icplot 0.1.7__tar.gz → 0.2.1__tar.gz

{icplot-0.1.7/src/icplot.egg-info → icplot-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icplot
-Version: 0.1.7
+Version: 0.2.1
 Summary: Utilities for generating plots and graphics for technical reports.
 Author-email: "James Grogan, Irish Centre for High End Computing" <james.grogan@ichec.ie>
 Project-URL: Repository, https://git.ichec.ie/performance/toolshed/icplot
@@ -19,7 +19,7 @@ Requires-Dist: matplotlib
 Requires-Dist: vtk
 Requires-Dist: moviepy
 Requires-Dist: scipy
-Requires-Dist: iccore==0.1.13
+Requires-Dist: iccore==0.2.1
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

{icplot-0.1.7 → icplot-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "icplot"
-version = "0.1.7"
+version = "0.2.1"
 authors = [
   { name="James Grogan, Irish Centre for High End Computing", email="james.grogan@ichec.ie" },
 ]
@@ -21,7 +21,7 @@ dependencies = ["wand",
                "vtk",
                "moviepy",
                "scipy",
-	       "iccore==0.1.13"]
+	       "iccore==0.2.1"]
 
 [project.urls]
 Repository = "https://git.ichec.ie/performance/toolshed/icplot"
@@ -106,7 +106,7 @@ disable = ["raw-checker-failed", "missing-module-docstring", "missing-function-d
 testpaths = ["test",]
 log_cli = 1
 log_cli_level = "debug"
-addopts = "--cov=icplot --cov-report term --cov-fail-under=59 --cov-report xml:coverage.xml --cov-report html"
+addopts = "--cov=icplot --cov-report term --cov-fail-under=55 --cov-report xml:coverage.xml --cov-report html"
 
 [tool.tox]
 requires = ["tox"]

{icplot-0.1.7 → icplot-0.2.1}/src/icplot/graph/__init__.py

@@ -2,5 +2,6 @@ from .plot import *  # NOQA
 from .series import *  # NOQA
 from .axis import *  # NOQA
 from .generator import plot_file
+from .plot_group import PlotGroupCreate, PlotGroupPublic
 
-__all__ = ["plot_file"]
+__all__ = ["plot_file", "PlotGroupCreate", "PlotGroupPublic"]

icplot-0.2.1/src/icplot/graph/mpl.py

@@ -0,0 +1,203 @@
+"""
+Module to support plotting with matplotlib
+"""
+
+import os
+from pathlib import Path
+import shutil
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from iccore.data.measurement import MeasurementPublicWithUnits
+from iccore.data.units import to_date_str
+from iccore.data import Series, UnitPublic
+
+from .plot_group import PlotGroupPublic
+from .series import PlotSeriesPublic
+from .video import images_to_video
+
+
+def get_axis_label(
+    measurement: MeasurementPublicWithUnits, unit: UnitPublic | None = None
+) -> str:
+
+    if unit:
+        resolved_unit = unit
+    else:
+        resolved_unit = measurement.unit
+
+    if measurement.name == "time":
+        return f"{measurement.get_long_name()} (UTC)"
+
+    if measurement.unit.symbol:
+        return f"{measurement.get_long_name()} ({resolved_unit.symbol})"
+
+    return measurement.long_name
+
+
+def get_grid(series: Series):
+
+    if not series.x or not series.y:
+        raise RuntimeError("Series missing expected data")
+
+    return np.meshgrid(series.get_x_array().data, series.get_y_array().data)
+
+
+def save_plot(fig, path: Path, filename: str, file_prefix: str = ""):
+    plt.tight_layout()
+    prefix = f"{file_prefix}_" if file_prefix else ""
+    os.makedirs(path, exist_ok=True)
+    plt.savefig(path / f"{prefix}{filename}")
+    plt.clf()
+    plt.close(fig)
+
+
+def get_date_suffix(group: PlotGroupPublic) -> str:
+    if not group.has_date_range:
+        return ""
+    start, end = group.date_range
+    return f"_FROM_{to_date_str(start)}_TO_{to_date_str(end)}"
+
+
+def plot_2d(
+    path: Path, group: PlotGroupPublic, series: PlotSeriesPublic, data_series: Series
+):
+    """
+    Generate a contour plot for the provided quantity
+    """
+
+    if not data_series.x or not series.x:
+        raise RuntimeError("Expected series with an x quantity")
+
+    if not data_series.y or not series.y:
+        raise RuntimeError("Expected series with a y quantity.")
+
+    x, y = get_grid(data_series)
+
+    array = data_series.get_array(series.measurement.name)
+
+    fig, ax = plt.subplots()
+
+    ax.set_xlabel(get_axis_label(series.x))
+    ax.set_ylabel(get_axis_label(series.y))
+
+    if group.has_date_range:
+        ax.set_xlim(group.date_range)  # type: ignore
+    fig.autofmt_xdate()
+
+    if group.contour.show_grid:
+        ax.grid(c="k", ls="-", alpha=0.3)
+
+    if False and array.quantity.has_limits:
+        cs = ax.contourf(
+            x,
+            y,
+            np.clip(array.data.T, array.quantity.limits[0], array.quantity.limits[1]),
+            cmap=group.contour.colormap,
+        )
+    else:
+        cs = ax.contourf(x, y, np.array(array.data).T, cmap=group.contour.colormap)
+
+    cbar = fig.colorbar(cs)
+    cbar.ax.set_ylabel(get_axis_label(series.measurement, series.unit))
+
+    date_str = get_date_suffix(group)
+    save_plot(fig, path, f"{series.measurement.name}{date_str}.{group.contour.format}")
+
+
+def plot_1d(
+    path: Path, group: PlotGroupPublic, series: PlotSeriesPublic, data_series: Series
+):
+    """
+    Generate a line plot for the provided quantity
+    """
+
+    if not data_series.x or not series.x:
+        raise RuntimeError("Attempted to plot series without x data")
+
+    fig, ax = plt.subplots()
+    ax.set_xlabel(get_axis_label(series.x))
+    ax.set_ylabel(get_axis_label(series.measurement, series.unit))
+
+    if group.has_date_range:
+        ax.set_xlim(group.date_range)  # type: ignore
+    fig.autofmt_xdate()
+
+    if series.has_limits:
+        ax.set_ylim(series.limits)  # type: ignore
+
+    x = data_series.get_array(series.x.name).data
+    y = data_series.get_array(series.measurement.name).data
+    ax.plot(x, y)
+
+    date_str = get_date_suffix(group)
+    save_plot(
+        fig,
+        path,
+        f"{series.measurement.name}{date_str}.{group.line.format}",
+    )
+
+
+def plot_array(path: Path, series: PlotSeriesPublic, data_series: Series):
+    """
+    Plot an array for a single series x value. Useful for
+    time series video frames.
+    """
+
+    array = data_series.get_array(series.measurement.name)
+
+    if not data_series.x or not data_series.y or not series.y:
+        raise RuntimeError("Attempted to plot series with missing data")
+
+    for idx, (x, values) in enumerate(
+        zip(data_series.get_array(data_series.x).data, array.data)
+    ):
+        fig, ax = plt.subplots()
+
+        ax.set_title(x)
+        ax.set_xlabel(get_axis_label(series.measurement, series.unit))
+        ax.set_ylabel(get_axis_label(series.y))
+
+        if series.has_limits:
+            ax.set_xlim(series.limits)  # type: ignore
+
+        ax.plot(values, data_series.get_array(data_series.y).data)
+
+        save_plot(fig, path / f"{series.measurement.name}", f"{idx}.png")
+
+
+def make_video(
+    path: Path, group: PlotGroupPublic, series: PlotSeriesPublic, data_series: Series
+):
+
+    plot_array(path, series, data_series)
+
+    if not group.video:
+        return
+
+    images_to_video(
+        path / f"{series.measurement.name}",
+        path,
+        f"{series.measurement.name}{get_date_suffix(group)}",
+        fps=group.video.fps,
+        video_format=group.video.format,
+    )
+    shutil.rmtree(path / f"{series.measurement.name}")
+
+
+def plot(
+    path: Path, group: PlotGroupPublic, series: PlotSeriesPublic, data_series: Series
+):
+    """
+    Handle plotting 1-d and 2-d time series and videos for the given quantity
+    """
+
+    if data_series.y:
+        plot_2d(path, group, series, data_series)
+
+        if group.video and group.video.active:
+            make_video(path, group, series, data_series)
+        return
+
+    plot_1d(path, group, series, data_series)

{icplot-0.1.7 → icplot-0.2.1}/src/icplot/graph/plot.py

@@ -8,15 +8,15 @@ import os
 
 from pydantic import BaseModel
 
-from iccore.data.quantity import Quantity
 from iccore.data import Series
+from iccore.data.series import convert_units
 
 from icplot.color import ColorMap, Color
 from icplot.graph import mpl, vtk
 
 from .axis import PlotAxis
 from .series import LinePlotSeries, ScatterPlotSeries, ImageSeries
-from .plot_group import PlotGroup
+from .plot_group import PlotGroupPublic, PlotSeriesPublic
 
 
 class Plot(BaseModel, frozen=True):
@@ -95,23 +95,28 @@ def get_series_colors(cmap: ColorMap, plot: Plot) -> list[Color]:
     return colors
 
 
-def plot_quantity(path: Path, config: PlotGroup, series: Series, quantity: Quantity):
+def plot_series(
+    path: Path,
+    group: PlotGroupPublic,
+    series: PlotSeriesPublic,
+    data_series: Series,
+):
 
-    schema_name = "" if quantity.schema_name == "default" else quantity.schema_name
-    output_path = path / quantity.sensor / schema_name
+    output_path = path / series.measurement.product_name
 
     os.makedirs(output_path, exist_ok=True)
 
-    if "mpl" in config.formats:
-        mpl.plot(output_path, config, series, quantity)
+    # Convert units
+    if series.measurement.unit != series.unit:
+        converted_data_series = convert_units(
+            data_series,
+            ((series.measurement.name, series.measurement.unit, series.unit),),
+        )
+    else:
+        converted_data_series = data_series
 
+    if "mpl" in group.formats:
+        mpl.plot(output_path, group, series, converted_data_series)
 
-def plot_series(path: Path, config: PlotGroup, series: Series, sensor: str, name: str):
-
-    output_path = path / sensor / name
-
-    os.makedirs(output_path, exist_ok=True)
-
-    if "vtk" in config.formats:
-        if series.y:
-            vtk.save(output_path, config, series)
+    if "vtk" in group.formats and data_series.y:
+        vtk.save(output_path, group, series, converted_data_series)

icplot-0.2.1/src/icplot/graph/plot_group.py

@@ -0,0 +1,80 @@
+"""
+Module to handle generation of plots
+"""
+
+from datetime import datetime
+from dataclasses import dataclass
+
+from pydantic import BaseModel
+
+from .series import PlotSeriesCreate, PlotSeriesPublic
+
+
+@dataclass(frozen=True)
+class VideoConfig:
+    """
+    Representation of a video
+    """
+
+    fps: int = 5
+    format: str = "mp4"
+    active: bool = True
+
+
+@dataclass(frozen=True)
+class ContourConfig:
+    """
+    Representation of a contour plot
+    """
+
+    show_grid: bool = True
+    colormap: str = "rainbow"
+    format: str = "png"
+
+
+@dataclass(frozen=True)
+class LineConfig:
+    """
+    Representatino of a line plot
+    """
+
+    format: str = "png"
+
+
+class PlotGroupBase(BaseModel, frozen=True):
+
+    start_datetime: datetime | None = None
+    end_datetime: datetime | None = None
+    video: VideoConfig | None = None
+    contour: ContourConfig = ContourConfig()
+    line: LineConfig = LineConfig()
+    formats: tuple[str, ...] = ("mpl",)
+    active: bool = True
+
+    @property
+    def has_date_range(self) -> bool:
+        return self.start_datetime is not None and self.end_datetime is not None
+
+    @property
+    def date_range(self) -> tuple[datetime, datetime]:
+
+        if self.start_datetime is None or self.end_datetime is None:
+            raise ValueError("Requested data range but none set")
+
+        return self.start_datetime, self.end_datetime
+
+
+class PlotGroupCreate(PlotGroupBase, frozen=True):
+    """
+    A group of plots to be generated, one per quantity.
+    """
+
+    series: list[PlotSeriesCreate] = []
+
+
+class PlotGroupPublic(PlotGroupBase, frozen=True):
+    """
+    A group of plots to be generated, one per quantity.
+    """
+
+    series: list[PlotSeriesPublic] = []

icplot-0.2.1/src/icplot/graph/series.py

@@ -0,0 +1,129 @@
+"""
+A data series in a plot
+"""
+
+import typing
+
+from pydantic import BaseModel
+
+from iccore.data import (
+    ProductPublicWithMeasurements,
+    MeasurementPublicWithUnits,
+    Unit,
+    UnitPublic,
+)
+
+from icplot.color import Color
+
+
+class PlotSeriesBase(BaseModel, frozen=True):
+
+    min_value: float | None = None
+    max_value: float | None = None
+
+
+class PlotSeriesCreate(PlotSeriesBase, frozen=True):
+
+    measurement: str
+    unit_name: str = ""
+
+    @property
+    def product(self) -> str:
+        return self.measurement.split(".")[0]
+
+    @property
+    def base_measurement(self) -> str:
+        return self.measurement.split(".")[1]
+
+
+class PlotSeriesPublic(PlotSeriesBase, frozen=True):
+
+    measurement: MeasurementPublicWithUnits
+    unit: UnitPublic
+    x: MeasurementPublicWithUnits | None
+    y: MeasurementPublicWithUnits | None
+
+    @property
+    def has_limits(self) -> bool:
+        return self.min_value is not None and self.max_value is not None
+
+    @property
+    def limits(self) -> tuple[float, float]:
+        if self.max_value is None or self.min_value is None:
+            raise ValueError("Attempted to access limits but none set")
+        return self.min_value, self.max_value
+
+    @classmethod
+    def from_create(
+        cls, create: PlotSeriesCreate, product: ProductPublicWithMeasurements
+    ) -> "PlotSeriesPublic":
+
+        measurement = product.get_measurement(create.base_measurement)
+
+        if create.unit_name and create.unit_name != measurement.unit.name:
+            unit = Unit.object(create.unit_name, "name", return_t=UnitPublic)
+        else:
+            unit = measurement.unit
+
+        return PlotSeriesPublic(
+            measurement=measurement,
+            unit=unit,
+            min_value=create.min_value,
+            max_value=create.max_value,
+            x=product.x,
+            y=product.y,
+        )
+
+
+class PlotSeries(BaseModel, frozen=True):
+    """
+    A data series in a plot, such as a single line in a line-plot
+
+    :param position_right: allows the series to be plotted on the right y-axis.
+    :type position_right: bool, optional
+    """
+
+    label: str
+    color: Color = Color()
+    series_type: str = ""
+    highlight: bool = False
+    position_right: bool = False
+
+
+class ImageSeries(PlotSeries, frozen=True):
+    """
+    A plot data series where the elements are images
+    """
+
+    data: typing.Any
+    transform: typing.Any
+    series_type: str = "image"
+
+
+class LinePlotSeries(PlotSeries, frozen=True):
+    """
+    A plot series for line plots
+
+    :param drawstyle: Naming comes from matplotlib API, allows for various square plots,
+               default is a normal point to point line plot.
+    :type drawstyle: str, optional
+    """
+
+    x: list
+    y: list
+    x_err: float | list[float] | list[list[float]] | None = None
+    y_err: float | list[float] | list[list[float]] | None = None
+    err_capsize: float = 2.0
+    marker: str = "o"
+    series_type: str = "line"
+    drawstyle: str = "default"
+    linestyle: str = "-"
+
+
+class ScatterPlotSeries(PlotSeries, frozen=True):
+    """
+    Scatter type plot series
+    """
+
+    data: typing.Any
+    series_type: str = "scatter"

{icplot-0.1.7 → icplot-0.2.1}/src/icplot/graph/vtk.py

@@ -3,10 +3,9 @@ import logging
 
 import numpy as np
 
-from iccore.data.units import DateRange
 from iccore.data import Series
 
-from .plot_group import PlotGroup
+from .plot_group import PlotGroupPublic, PlotSeriesPublic
 
 _HAS_VTK = True
 try:
@@ -23,7 +22,7 @@ def has_vtk() -> bool:
     return _HAS_VTK
 
 
-def to_grid(series: Series, dates: DateRange | None):
+def to_grid(series: PlotSeriesPublic, data_series: Series):
 
     if not has_vtk():
         raise RuntimeError("VTK support failed to load")
@@ -34,37 +33,46 @@ def to_grid(series: Series, dates: DateRange | None):
     if not series.y:
         raise ValueError("Expected 2d series for grid plot.")
 
+    x = data_series.get_x_array().data
+    y = data_series.get_y_array().data
+
     grid = vtk.vtkStructuredGrid()
-    grid.SetDimensions([len(series.x.data), len(series.y.data), 1])
+    grid.SetDimensions([len(x), len(y), 1])
 
     points = vtk.vtkPoints()
     count = 0
 
-    x0 = series.x.data[0]
-    for y_pt in series.y.data:
-        for x_pt in series.x.data:
+    x0 = x[0]
+    for y_pt in y:
+        for x_pt in x:
             delta_x = x_pt.timestamp() - x0.timestamp()
             points.InsertPoint(count, [delta_x, y_pt, 0])
             count += 1
     grid.SetPoints(points)
 
-    for v in series.values:
+    for v in data_series.values:
         scalars = numpy_support.numpy_to_vtk(
             num_array=np.array(v.data[:]).flatten(order="F"),
             deep=True,
             array_type=vtk.VTK_FLOAT,
         )
-        scalars.SetName(v.quantity.name)
+        scalars.SetName(series.measurement.name)
         grid.GetPointData().AddArray(scalars)
     return grid
 
 
-def save(path: Path, config: PlotGroup, series: Series, filename: str = "series"):
+def save(
+    path: Path,
+    group: PlotGroupPublic,
+    series: PlotSeriesPublic,
+    data_series: Series,
+    filename: str = "series",
+):
 
     if not has_vtk():
         raise RuntimeError("VTK support failed to load")
 
-    grid = to_grid(series, config.date_range)
+    grid = to_grid(series, data_series)
 
     writer = vtk.vtkStructuredGridWriter()
     writer.SetFileName(path / f"{filename}.vtk")

{icplot-0.1.7 → icplot-0.2.1}/src/icplot/mesh/mesh.py

@@ -219,49 +219,53 @@ def from_cuboids(
 
 def from_cylinder(cylinder: Cylinder, boundary_frac: float = 0.66) -> Mesh:
 
-    depth = (cylinder.diameter - boundary_frac * cylinder.diameter) / 2.0
+    inner_cube_side = cylinder.diameter * boundary_frac / np.sqrt(2)
+    outer_cube_x = cylinder.diameter / np.sqrt(2)
+    outer_cube_z = cylinder.diameter * (1.0 - boundary_frac) / (2.0 * np.sqrt(2))
+
     cuboids = [
         Cuboid(
-            Point(0.0, 0.0, depth / 2.0),
-            width=cylinder.diameter,
+            Point(0.0, 0.0, -inner_cube_side / 2.0 - outer_cube_z / 2.0),
+            width=outer_cube_x,
             height=cylinder.length,
-            depth=depth,
+            depth=outer_cube_z,
             top_width_scale=boundary_frac,
         ),
         Cuboid(
-            Point(0.0, 0.0, cylinder.diameter + depth / 2.0),
-            width=cylinder.diameter,
+            Point(0.0, 0.0, inner_cube_side / 2.0 + outer_cube_z / 2.0),
+            width=outer_cube_x,
             height=cylinder.length,
-            depth=depth,
+            depth=outer_cube_z,
             normal=Vector(0.0, 0.0, -1.0),
             top_width_scale=boundary_frac,
         ),
         Cuboid(
-            Point(-cylinder.diameter / 2.0, 0.0, cylinder.diameter / 2.0 + depth / 2.0),
-            width=cylinder.diameter,
+            Point(-outer_cube_x / 2.0, 0.0, 0.0),
+            width=outer_cube_x,
             height=cylinder.length,
-            depth=depth,
+            depth=outer_cube_z,
             normal=Vector(1.0, 0.0, 0.0),
             top_width_scale=boundary_frac,
         ),
         Cuboid(
-            Point(cylinder.diameter / 2.0, 0.0, cylinder.diameter / 2.0 + depth / 2.0),
-            width=cylinder.diameter,
+            Point(outer_cube_x / 2.0, 0.0, 0.0),
+            width=outer_cube_x,
             height=cylinder.length,
-            depth=depth,
+            depth=outer_cube_z,
             normal=Vector(-1.0, 0.0, 0.0),
             top_width_scale=boundary_frac,
         ),
         Cuboid(
-            Point(0.0, 0.0, cylinder.diameter * boundary_frac / 2.0 + depth),
-            width=cylinder.diameter * boundary_frac,
+            Point(0.0, 0.0, 0.0),
+            width=inner_cube_side,
             height=cylinder.length,
-            depth=boundary_frac * cylinder.diameter,
+            depth=inner_cube_side,
         ),
     ]
 
     mesh = from_cuboids(cuboids)
 
+    """
     top_front_edge = mesh.get_closest_edge(
         Point(0.0, -cylinder.length / 2.0, cylinder.diameter + depth / 2.0)
     )
@@ -269,6 +273,8 @@ def from_cylinder(cylinder: Cylinder, boundary_frac: float = 0.66) -> Mesh:
         0.0, -cylinder.length / 2.0, cylinder.diameter + depth / 2.0 + 0.15
     )
 
-    edges = (Edge(top_front_edge[0], top_front_edge[1], "arc", (top_front_arc,)),)
+    # edges = (Edge(top_front_edge[0], top_front_edge[1], "arc", (top_front_arc,)),)
+    """
+    edges = ()
 
     return Mesh(mesh.vertices, mesh.blocks, edges=edges)

{icplot-0.1.7 → icplot-0.2.1/src/icplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icplot
-Version: 0.1.7
+Version: 0.2.1
 Summary: Utilities for generating plots and graphics for technical reports.
 Author-email: "James Grogan, Irish Centre for High End Computing" <james.grogan@ichec.ie>
 Project-URL: Repository, https://git.ichec.ie/performance/toolshed/icplot
@@ -19,7 +19,7 @@ Requires-Dist: matplotlib
 Requires-Dist: vtk
 Requires-Dist: moviepy
 Requires-Dist: scipy
-Requires-Dist: iccore==0.1.13
+Requires-Dist: iccore==0.2.1
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

{icplot-0.1.7 → icplot-0.2.1}/src/icplot.egg-info/SOURCES.txt

@@ -46,4 +46,5 @@ test/test_image_utils.py
 test/test_line_plots.py
 test/test_mermaid.py
 test/test_mesh.py
+test/test_plot_group.py
 test/test_tex.py

{icplot-0.1.7 → icplot-0.2.1}/src/icplot.egg-info/requires.txt

@@ -3,7 +3,7 @@ matplotlib
 vtk
 moviepy
 scipy
-iccore==0.1.13
+iccore==0.2.1
 
 [cairo]
 pycairo

icplot-0.2.1/test/test_plot_group.py

@@ -0,0 +1,35 @@
+from datetime import datetime, timedelta
+from icplot.graph.plot_group import (
+    PlotGroupPublic,
+    VideoConfig,
+    ContourConfig,
+    LineConfig,
+)
+
+
+def test_plot_group():
+    now = datetime.utcnow()
+    later = now + timedelta(hours=1)
+
+    video = VideoConfig(fps=10, format="avi", active=False)
+    contour = ContourConfig(show_grid=False, colormap="viridis", format="svg")
+    line = LineConfig(format="pdf")
+
+    group = PlotGroupPublic(
+        start_datetime=now,
+        end_datetime=later,
+        video=video,
+        contour=contour,
+        line=line,
+        formats=("mpl", "svg"),
+        active=True,
+        series=[],
+    )
+
+    assert group.has_date_range
+    assert group.date_range == (now, later)
+    assert group.video == video
+    assert group.contour == contour
+    assert group.line == line
+    assert group.formats == ("mpl", "svg")
+    assert group.active

icplot-0.1.7/src/icplot/graph/mpl.py

@@ -1,216 +0,0 @@
-"""
-Module to support plotting with matplotlib
-"""
-
-import os
-from pathlib import Path
-import shutil
-
-import numpy as np
-import matplotlib.pyplot as plt
-
-from iccore.data.quantity import Quantity
-from iccore.data.units import DateRange, to_date_str
-from iccore.data import Series, Array
-
-from .plot_group import PlotGroup
-from .video import images_to_video
-
-
-def get_axis_label_from_quantity(quantity: Quantity) -> str:
-
-    if quantity.name == "time":
-        return f"{quantity.long_name} (UTC)"
-
-    if quantity.unit.get_symbol():
-        return f"{quantity.long_name} ({quantity.unit.get_symbol()})"
-
-    return quantity.long_name
-
-
-def get_axis_label(array: Array) -> str:
-    return get_axis_label_from_quantity(array.quantity)
-
-
-def get_grid(series: Series):
-
-    if not series.x or not series.y:
-        raise RuntimeError("Series missing expected data")
-
-    return np.meshgrid(series.x.data, series.y.data)
-
-
-def save_plot(fig, path: Path, filename: str, file_prefix: str = ""):
-    plt.tight_layout()
-    prefix = f"{file_prefix}_" if file_prefix else ""
-    os.makedirs(path, exist_ok=True)
-    plt.savefig(path / f"{prefix}{filename}")
-    plt.clf()
-    plt.close(fig)
-
-
-def get_date_suffix(dates: DateRange | None) -> str:
-    if not dates:
-        return ""
-    if not dates.start or not dates.end:
-        return ""
-
-    return f"_FROM_{to_date_str(dates.start)}_TO_{to_date_str(dates.end)}"
-
-
-def plot_2d(
-    path: Path, config: PlotGroup, series: Series, quantity: str, file_prefix: str = ""
-):
-    """
-    Generate a contour plot for the provided quantity
-    """
-
-    if not series.x:
-        raise RuntimeError("Expected series with an x quantity")
-
-    if not series.y:
-        raise RuntimeError("Expected series with a y quantity.")
-
-    x, y = get_grid(series)
-
-    array = series.get_array(quantity)
-
-    fig, ax = plt.subplots()
-
-    ax.set_ylabel(get_axis_label(series.y))
-    ax.set_xlabel(get_axis_label(series.x))
-
-    if config.date_range:
-        start, end = config.date_range.as_tuple()
-        if start and end:
-            ax.set_xlim((start, end))  # type: ignore
-    fig.autofmt_xdate()
-
-    if config.contour.show_grid:
-        ax.grid(c="k", ls="-", alpha=0.3)
-
-    if False and array.quantity.has_limits:
-        cs = ax.contourf(
-            x,
-            y,
-            np.clip(array.data.T, array.quantity.limits[0], array.quantity.limits[1]),
-            cmap=config.contour.colormap,
-        )
-    else:
-        cs = ax.contourf(x, y, array.data.T, cmap=config.contour.colormap)
-
-    cbar = fig.colorbar(cs)
-    cbar.ax.set_ylabel(get_axis_label(array))
-
-    save_plot(
-        fig,
-        path,
-        f"{quantity}{get_date_suffix(config.date_range)}.{config.contour.format}",
-        file_prefix,
-    )
-
-
-def plot_1d(
-    path: Path, config: PlotGroup, series: Series, quantity: str, file_prefix: str = ""
-):
-    """
-    Generate a line plot for the provided quantity
-    """
-
-    if not series.x:
-        raise RuntimeError("Attempted to plot series without x data")
-
-    array = series.get_array(quantity)
-
-    fig, ax = plt.subplots()
-    ax.set_xlabel(get_axis_label(series.x))
-    ax.set_ylabel(get_axis_label(array))
-
-    if config.date_range:
-        ax.set_xlim(config.date_range.as_tuple())  # type: ignore
-    fig.autofmt_xdate()
-
-    if array.quantity.has_limits:
-        ax.set_ylim(array.quantity.limits)  # type: ignore
-
-    x = array.data.index.to_numpy(dtype="datetime64[ns]")
-    y = array.data.values
-    ax.plot(x, y)
-
-    save_plot(
-        fig,
-        path,
-        f"{quantity}{get_date_suffix(config.date_range)}.{config.line.format}",
-        file_prefix,
-    )
-
-
-def plot_array(path: Path, series: Series, array: Array, file_prefix):
-    """
-    Plot an array for a single series x value. Useful for
-    time series video frames.
-    """
-
-    if not series.x or not series.y:
-        raise RuntimeError("Attempted to plot series with missing data")
-
-    for idx, (x, values) in enumerate(zip(series.x.data, array.data)):
-        fig, ax = plt.subplots()
-
-        ax.set_title(x)
-        ax.set_xlabel(get_axis_label(array))
-        ax.set_ylabel(get_axis_label(series.y))
-
-        if array.quantity.has_limits:
-            ax.set_xlim(array.quantity.limits)  # type: ignore
-
-        ax.plot(values, series.y.data)
-
-        prefix = f"{file_prefix}_" if file_prefix else ""
-        save_plot(fig, path / f"{prefix}{array.quantity.name}", f"{idx}.png")
-
-
-def make_video(
-    path: Path, config: PlotGroup, series: Series, quantity: str, file_prefix: str = ""
-):
-    plot_array(path, series, series.get_array(quantity), file_prefix)
-
-    prefix = f"{file_prefix}_" if file_prefix else ""
-
-    if not config.video:
-        return
-
-    images_to_video(
-        path / f"{prefix}{quantity}",
-        path,
-        f"{prefix}{quantity}{get_date_suffix(config.date_range)}",
-        fps=config.video.fps,
-        video_format=config.video.format,
-    )
-    shutil.rmtree(path / f"{prefix}{quantity}")
-
-
-def plot(
-    path: Path,
-    config: PlotGroup,
-    series: Series,
-    quantity: Quantity,
-    file_prefix: str = "",
-):
-    """
-    Handle plotting 1-d and 2-d time series and videos for the given quantity
-    """
-
-    if series.is_compound:
-        for c in series.components:
-            plot(path, config, c, quantity, c.name)
-        return
-
-    if series.y:
-        plot_2d(path, config, series, quantity.name, file_prefix)
-
-        if config.video and config.video.active:
-            make_video(path, config, series, quantity.name, file_prefix)
-        return
-
-    plot_1d(path, config, series, quantity.name, file_prefix)

icplot-0.1.7/src/icplot/graph/plot_group.py

@@ -1,63 +0,0 @@
-"""
-Module to handle generation of plots
-"""
-
-from datetime import date
-from dataclasses import dataclass
-
-from pydantic import BaseModel
-
-from iccore.data.units import DateRange
-from iccore.data.quantity import Quantity
-
-
-@dataclass(frozen=True)
-class VideoConfig:
-    """
-    Representation of a video
-    """
-
-    fps: int = 5
-    format: str = "mp4"
-    active: bool = True
-
-
-@dataclass(frozen=True)
-class ContourConfig:
-    """
-    Representation of a contour plot
-    """
-
-    show_grid: bool = True
-    colormap: str = "rainbow"
-    format: str = "png"
-
-
-@dataclass(frozen=True)
-class LineConfig:
-    """
-    Representatino of a line plot
-    """
-
-    format: str = "png"
-
-
-class PlotGroup(BaseModel, frozen=True):
-    """
-    A group of plots to be generated, one per quantity.
-    """
-
-    quantities: list[Quantity] = []
-    start_date: date | None = None
-    end_date: date | None = None
-    video: VideoConfig | None = None
-    contour: ContourConfig = ContourConfig()
-    line: LineConfig = LineConfig()
-    formats: tuple[str, ...] = ("mpl", "vtk")
-    active: bool = True
-
-    @property
-    def date_range(self) -> DateRange | None:
-        if not self.start_date:
-            return None
-        return DateRange(start=self.start_date, end=self.end_date)

icplot-0.1.7/src/icplot/graph/series.py

@@ -1,63 +0,0 @@
-"""
-A data series in a plot
-"""
-
-import typing
-
-from pydantic import BaseModel
-
-from icplot.color import Color
-
-
-class PlotSeries(BaseModel, frozen=True):
-    """
-    A data series in a plot, such as a single line in a line-plot
-
-    :param position_right: allows the series to be plotted on the right y-axis.
-    :type position_right: bool, optional
-    """
-
-    label: str
-    color: Color = Color()
-    series_type: str = ""
-    highlight: bool = False
-    position_right: bool = False
-
-
-class ImageSeries(PlotSeries, frozen=True):
-    """
-    A plot data series where the elements are images
-    """
-
-    data: typing.Any
-    transform: typing.Any
-    series_type: str = "image"
-
-
-class LinePlotSeries(PlotSeries, frozen=True):
-    """
-    A plot series for line plots
-
-    :param drawstyle: Naming comes from matplotlib API, allows for various square plots,
-               default is a normal point to point line plot.
-    :type drawstyle: str, optional
-    """
-
-    x: list
-    y: list
-    x_err: float | list[float] | list[list[float]] | None = None
-    y_err: float | list[float] | list[list[float]] | None = None
-    err_capsize: float = 2.0
-    marker: str = "o"
-    series_type: str = "line"
-    drawstyle: str = "default"
-    linestyle: str = "-"
-
-
-class ScatterPlotSeries(PlotSeries, frozen=True):
-    """
-    Scatter type plot series
-    """
-
-    data: typing.Any
-    series_type: str = "scatter"