icplot 0.1.6__tar.gz → 0.2.0__tar.gz

{icplot-0.1.6/src/icplot.egg-info → icplot-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icplot
-Version: 0.1.6
+Version: 0.2.0
 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
@@ -18,7 +18,8 @@ Requires-Dist: wand
 Requires-Dist: matplotlib
 Requires-Dist: vtk
 Requires-Dist: moviepy
-Requires-Dist: iccore==0.1.13
+Requires-Dist: scipy
+Requires-Dist: iccore==0.2.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

{icplot-0.1.6 → icplot-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "icplot"
-version = "0.1.6"
+version = "0.2.0"
 authors = [
   { name="James Grogan, Irish Centre for High End Computing", email="james.grogan@ichec.ie" },
 ]
@@ -20,7 +20,8 @@ dependencies = ["wand",
 	       "matplotlib",
                "vtk",
                "moviepy",
-	       "iccore==0.1.13"]
+               "scipy",
+	       "iccore==0.2.0"]
 
 [project.urls]
 Repository = "https://git.ichec.ie/performance/toolshed/icplot"
@@ -50,7 +51,7 @@ build-backend = "setuptools.build_meta"
 icplot = "icplot.main_cli:main_cli"
 
 [tool.setuptools.package-data]
-"icplot" = ["py.typed"]
+"icplot" = ["py.typed", "controlDict"]
 
 [tool.setuptools.packages.find]
 where = ["src"]
@@ -61,7 +62,7 @@ ignore_missing_imports = true
 [tool.pylint.main]
 
 source-roots = ["src"]
-fail-under = 9.33
+fail-under = 9.2
 
 [tool.pylint.basic]
 
@@ -105,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.6 → icplot-0.2.0}/src/icplot/geometry.py

@@ -5,9 +5,11 @@ dependent work.
 """
 
 from __future__ import annotations
-import copy
 from dataclasses import dataclass
 
+import numpy as np
+from scipy.spatial.transform import Rotation
+
 
 @dataclass(frozen=True)
 class Vector:
@@ -22,6 +24,9 @@ class Vector:
     def scale(self, factor: float) -> Vector:
         return Vector(self.x * factor, self.y * factor, self.z * factor)
 
+    def as_array(self) -> np.ndarray:
+        return np.array([self.x, self.y, self.z])
+
 
 @dataclass(frozen=True)
 class Point:
@@ -33,9 +38,16 @@ class Point:
     y: float = 0.0
     z: float = 0.0
 
+    def as_array(self) -> np.ndarray:
+        return np.array([self.x, self.y, self.z])
+
     def translate(self, v: Vector) -> Point:
         return Point(self.x + v.x, self.y + v.y, self.z + v.z)
 
+    @staticmethod
+    def from_array(arr: np.ndarray) -> Point:
+        return Point(arr[0], arr[1], arr[2])
+
 
 @dataclass(frozen=True)
 class Shape:
@@ -43,10 +55,26 @@ class Shape:
     A shape in 3d space, defaults to having a normal to Z
     """
 
-    loc: Point
+    loc: Point = Point(0.0, 0.0, 0.0)
     normal: Vector = Vector(0.0, 0.0, 1.0)
 
 
+def get_rotation_matrix(vec0, vec1):
+    """get rotation matrix between two vectors using scipy"""
+    vec0 = np.reshape(vec0, (1, -1))
+    vec1 = np.reshape(vec1, (1, -1))
+    r = Rotation.align_vectors(vec0, vec1)
+    return r[0].as_matrix()
+
+
+def get_normal(p0, p1, p2):
+    direction = np.cross(p1 - p0, p2 - p0)
+    return direction / np.linalg.norm(direction)
+
+
+_GLOBAL_Z = np.array([0.0, 0.0, 1.0])
+
+
 @dataclass(frozen=True)
 class Quad(Shape):
     """
@@ -58,14 +86,32 @@ class Quad(Shape):
 
     @property
     def points(self) -> list[Point]:
-        p = copy.deepcopy(self.loc)
-        return [
-            p,
-            p.translate(Vector(self.width)),
-            p.translate(Vector(self.width, self.height)),
-            p.translate(Vector(0.0, self.height)),
+
+        points = [
+            self.loc.translate(Vector(-self.width / 2.0, -self.height / 2.0)),
+            self.loc.translate(Vector(self.width / 2.0, -self.height / 2.0)),
+            self.loc.translate(Vector(self.width / 2.0, self.height / 2.0)),
+            self.loc.translate(Vector(-self.width / 2.0, self.height / 2.0)),
+        ]
+
+        rot = get_rotation_matrix(_GLOBAL_Z, self.normal.as_array())
+        rotated_points = [
+            Point.from_array(
+                rot.dot(p.as_array() - self.loc.as_array()) + self.loc.as_array()
+            )
+            for p in points
         ]
 
+        plane_normal = get_normal(
+            rotated_points[0].as_array(),
+            rotated_points[1].as_array(),
+            rotated_points[3].as_array(),
+        )
+
+        if np.dot(plane_normal, self.normal.as_array()) < 0:
+            rotated_points.reverse()
+        return rotated_points
+
     def translate(self, v: Vector) -> Quad:
         return Quad(self.loc.translate(v), self.normal, self.width, self.height)
 
@@ -76,10 +122,10 @@ class Cuboid(Shape):
     A regular cuboid
     """
 
-    loc: Point
     width: float = 1.0
     height: float = 1.0
     depth: float = 1.0
+    top_width_scale: float = 1.0
 
     def translate(self, v: Vector) -> Cuboid:
         return Cuboid(
@@ -89,8 +135,20 @@ class Cuboid(Shape):
     @property
     def points(self) -> list[Point]:
 
-        base = Quad(self.loc, self.normal, self.width, self.height)
-        top = base.translate(self.normal.scale(self.depth))
+        base = Quad(
+            self.loc.translate(Vector(0.0, 0.0, -self.depth / 2.0)),
+            self.normal,
+            self.width,
+            self.height,
+        )
+
+        top = Quad(
+            self.loc.translate(Vector(0.0, 0.0, -self.depth / 2.0)),
+            self.normal,
+            self.width * self.top_width_scale,
+            self.height,
+        )
+        top = top.translate(self.normal.scale(self.depth))
         return base.points + top.points
 
 

{icplot-0.1.6 → icplot-0.2.0}/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.0/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.6 → icplot-0.2.0}/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.0/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.0/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"