icplot 0.0.7__tar.gz → 0.0.8__tar.gz

{icplot-0.0.7/src/icplot.egg-info → icplot-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.7
+Version: 0.0.8
 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

{icplot-0.0.7 → icplot-0.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "icplot"
-version = "0.0.7"
+version = "0.0.8"
 authors = [
   { name="James Grogan, Irish Centre for High End Computing", email="james.grogan@ichec.ie" },
 ]

icplot-0.0.8/src/icplot/color.py

@@ -0,0 +1,13 @@
+class Color:
+
+    def __init__(self, r=1, g=1, b=1, a=1):
+        self.r = r
+        self.g = g
+        self.b = b
+        self.a = a
+
+
+class ColorMap:
+
+    def __init__(self, label: str):
+        self.label = label

{icplot-0.0.7 → icplot-0.0.8}/src/icplot/geometry.py

@@ -1,10 +1,4 @@
-class Color:
-
-    def __init__(self, r=1, g=1, b=1, a=1):
-        self.r = r
-        self.g = g
-        self.b = b
-        self.a = a
+from .color import Color
 
 
 class Font:

icplot-0.0.8/src/icplot/graph/matplotlib_plot_backend.py

@@ -0,0 +1,69 @@
+from pathlib import Path
+import logging
+
+logging.getLogger("matplotlib").setLevel(logging.WARNING)
+import matplotlib  # NOQA
+
+default_backend = matplotlib.get_backend()
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # NOQA
+import matplotlib as mpl  # NOQA
+
+from icplot.color import ColorMap  # NOQA
+
+
+class MatplotlibColorMap(ColorMap):
+
+    def __init__(self, label: str):
+        super().__init__(label)
+        self.c_map = mpl.colormaps[label]
+        self.cmap_start_offset = 0.25
+        self.cmap_scale = 2
+
+    def get_color(self, cursor: int, values: list):
+        """
+        Returns a colour based on a cmap and how far across
+        the datasets you are
+        """
+        position = cursor / len(values)
+        return self.c_map(self.cmap_start_offset + (position / self.cmap_scale))
+
+
+class MatplotlibPlotBackend:
+
+    def __init__(self):
+        self.ax = plt.subplot(111)
+
+    def set_decorations(self, x_label, y_label, title, x_ticks, y_ticks):
+        self.ax.legend(loc="upper left")
+        if x_label:
+            self.ax.set_xlabel(x_label)
+        if y_label:
+            self.ax.set_ylabel(y_label)
+        if title:
+            self.ax.set_title(title)
+        if x_ticks:
+            self.ax.set_xticks(x_ticks)
+        if y_ticks:
+            self.ax.set_yticks(y_ticks)
+
+    def plot_line(self, x, y, label, color):
+        self.ax.plot(x, y, label=label, color=color)
+
+    def plot_scatter(self, data, label, color):
+        self.ax.plot(data, label=label, color=color)
+
+    def make_subplot(self, rows, cols, count):
+        plt.subplot(rows, cols, count)
+
+    def plot_image(self, data):
+        plt.imshow(data)
+        plt.axis("off")
+
+    def render(self, path: Path | None = None):
+        if path:
+            plt.savefig(path)
+        else:
+            plt.switch_backend(default_backend)
+            plt.show()
+            plt.switch_backend("Agg")

icplot-0.0.8/src/icplot/graph/plot.py

@@ -0,0 +1,163 @@
+"""
+This module has content for generating plots
+"""
+
+import random
+from pathlib import Path
+from typing import cast
+import json
+
+from .series import PlotSeries, LinePlotSeries, ScatterPlotSeries, ImageSeries
+from .matplotlib_plot_backend import MatplotlibPlotBackend, MatplotlibColorMap
+
+
+class Range:
+
+    def __init__(self, lower, upper, step):
+        self.lower = lower
+        self.upper = upper
+        self.step = step
+
+    def eval(self):
+        return range(self.lower, self.upper, self.step)
+
+    def serialize(self):
+        return {"lower": self.lower, "upper": self.upper, "step": self.step}
+
+    def __str__(self):
+        return json.dumps(self.serialize(), ident=4)
+
+
+class Plot:
+    """
+    A generic plot with optional axis ticks
+    """
+
+    def __init__(
+        self,
+        title: str = "",
+        x_label: str = "",
+        y_label: str = "",
+        legend_label: str = "",
+    ) -> None:
+        self.series: list[PlotSeries] = []
+        self.title = title
+        self.size: tuple | None = None
+        self.plot_type = ""
+        self.x_label = x_label
+        self.y_label = y_label
+        self.legend_label = legend_label
+        self.x_ticks: Range | None = None
+        self.y_ticks: Range | None = None
+        self.backend = MatplotlibPlotBackend()
+        self.cmap = MatplotlibColorMap("viridis")
+
+    def set_colour_map(self, cmap):
+        self.c_map = MatplotlibColorMap(cmap)
+
+    def set_x_ticks(self, lower, upper, step):
+        self.x_ticks = Range(lower, upper + 1, step)
+
+    def set_y_ticks(self, lower, upper, step):
+        self.y_ticks = Range(lower, upper + 1, step)
+
+    def set_decorations(self):
+
+        xtick_range = None
+        ytick_range = None
+        if self.x_ticks:
+            xtick_range = self.x_ticks.eval()
+        if self.y_ticks:
+            ytick_range = self.y_ticks.eval()
+
+        self.backend.set_decorations(
+            self.x_label,
+            self.y_label,
+            self.title,
+            xtick_range,
+            ytick_range,
+        )
+
+    def add_series(self, series):
+        self.series.append(series)
+
+    def plot_series(self, series, label):
+        if series.series_type == "line":
+            line_series = cast(LinePlotSeries, series)
+            self.backend.plot_line(
+                line_series.x, line_series.y, label=label, color=series.color
+            )
+        elif series.series_type == "scatter":
+            scatter_series = cast(ScatterPlotSeries, series)
+            self.backend.plot_scatter(
+                scatter_series.data, label=label, color=series.color
+            )
+        elif series.series_type == "image":
+            image_series = cast(ImageSeries, series)
+            self.backend.plot_image(image_series.data)
+
+    def plot(self, path: Path | None = None):
+        for idx, series in enumerate(self.series):
+            series.color = self.cmap.get_color(idx, self.series)
+
+        first = True
+        for series in self.series:
+            label = series.label
+            if first and self.legend_label:
+                label = f"{label} {self.legend_label}"
+                first = False
+            self.plot_series(series, label)
+
+        self.set_decorations()
+        self.backend.render(path)
+
+    def serialize(self):
+        return {
+            "series": [s.serialize() for s in self.series],
+            "title": self.title,
+            "type": self.plot_type,
+            "xlabel": self.x_label,
+            "ylabel": self.y_label,
+            "legend_label": self.legend_label,
+            "xticks": self.x_ticks.serialize(),
+            "yticks": self.y_ticks.serialize(),
+        }
+
+
+class GridPlot(Plot):
+    """
+    Make a grid of plots
+    """
+
+    def __init__(
+        self, title: str = "", stride: int = 4, size: tuple = (25, 20)
+    ) -> None:
+        super().__init__(title)
+        self.stride = stride
+        self.size = size
+
+    def _subplot(self, rows: int, cols: int, count: int, series):
+
+        self.backend.make_subplot(rows, cols, count)
+        self.plot_series(series, "")
+        return count + 1
+
+    def render(self, data, path: Path, num_samples: int = 0):
+        rows = num_samples // self.stride
+        cols = num_samples // rows
+        count = 1
+        if num_samples == 0:
+            indices = [random.randint(0, len(data) - 1) for _ in range(num_samples)]
+        else:
+            indices = list(range(0, len(data)))
+
+        for index in indices:
+            if num_samples > 0 and count == num_samples + 1:
+                break
+            if isinstance(data[index], list):
+                for series in data[index]:
+                    count = self._subplot(rows, cols, count, series)
+            else:
+                count = self._subplot(rows, cols, count, data[index])
+
+        self.backend.render(path)

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

@@ -0,0 +1,54 @@
+import json
+
+
+class PlotSeries:
+
+    def __init__(self, label: str = ""):
+        self.label = label
+        self.color: list[float] = [0.0, 0.0, 0.0]
+        self.series_type = ""
+
+    def serialize(self):
+        return {"label": self.label, "color": self.color, "type": self.series_type}
+
+    def __str__(self):
+        return json.dumps(self.serialize(), indent=4)
+
+
+class ImageSeries(PlotSeries):
+    def __init__(self, data, label: str = "", transform=None):
+        super().__init__(label)
+        self.data = data
+        self.series_type = "image"
+        self.transform = transform
+
+    def serialize(self):
+        ret = super().serialize()
+        ret["data"] = self.data
+        return ret
+
+
+class LinePlotSeries(PlotSeries):
+    def __init__(self, x: list[float], y: list[float], label: str = "") -> None:
+        super().__init__(label)
+        self.series_type = "line"
+        self.x = x
+        self.y = y
+
+    def serialize(self):
+        ret = super().serialize()
+        ret["x"] = self.x
+        ret["y"] = self.y
+        return ret
+
+
+class ScatterPlotSeries(PlotSeries):
+    def __init__(self, data, label: str = ""):
+        super().__init__(label)
+        self.data = data
+        self.series_type = "scatter"
+
+    def serialize(self):
+        ret = super().serialize()
+        ret["data"] = self.data
+        return ret

{icplot-0.0.7 → icplot-0.0.8/src/icplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icplot
-Version: 0.0.7
+Version: 0.0.8
 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

{icplot-0.0.7 → icplot-0.0.8}/src/icplot.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 setup.cfg
 src/icplot/__init__.py
 src/icplot/cairo_interface.py
+src/icplot/color.py
 src/icplot/gantt.py
 src/icplot/geometry.py
 src/icplot/image_utils.py
@@ -17,7 +18,9 @@ src/icplot.egg-info/entry_points.txt
 src/icplot.egg-info/requires.txt
 src/icplot.egg-info/top_level.txt
 src/icplot/graph/__init__.py
+src/icplot/graph/matplotlib_plot_backend.py
 src/icplot/graph/plot.py
+src/icplot/graph/series.py
 test/test_cairo_interface.py
 test/test_gantt_chart.py
 test/test_image_utils.py

{icplot-0.0.7 → icplot-0.0.8}/test/test_cairo_interface.py

@@ -1,5 +1,6 @@
 from icplot.cairo_interface import CairoInterface
 
+
 def test_cairo_interface():
 
     cairo_interface = CairoInterface()

{icplot-0.0.7 → icplot-0.0.8}/test/test_gantt_chart.py

@@ -20,10 +20,9 @@ def test_gantt_chart():
     milestone1.description = "Description of Milestone 1."
     milestone1.start_date = datetime.date(2024, 7, 1)
     milestone1.due_date = datetime.date(2024, 7, 15)
-    
+
     gantt = GanttChart()
-    gantt.milestones = [milestone0,
-                        milestone1]
+    gantt.milestones = [milestone0, milestone1]
 
     output_path = Path(os.getcwd()) / "gantt.svg"
 

{icplot-0.0.7 → icplot-0.0.8}/test/test_image_utils.py

@@ -3,9 +3,11 @@ from pathlib import Path
 
 from icplot.image_utils import svg_to_png, svg_to_pdf
 
+
 def get_test_data_dir():
     return Path(__file__).parent / "data"
-    
+
+
 def test_convert_svg():
 
     source = get_test_data_dir() / "test.svg"
@@ -17,5 +19,3 @@ def test_convert_svg():
     pdf_out = Path(os.getcwd()) / "out.pdf"
     svg_to_pdf(source, pdf_out)
     pdf_out.unlink()
-
-    

icplot-0.0.8/test/test_line_plots.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+from icplot.graph import Plot, LinePlotSeries
+
+
+def test_line_plot():
+
+    plot = Plot(
+        title="test", x_label="test_x", y_label="test_y", legend_label="test_legend"
+    )
+
+    data = [([0, 5, 10], [1, 2, 3]), ([0, 5, 10], [3, 6, 9]), ([0, 5, 10], [4, 8, 12])]
+
+    for idx, [x, y] in enumerate(data):
+        plot.add_series(LinePlotSeries(x, y, label=f"Series {idx}"))
+
+    plot.set_x_ticks(0, 10, 5)
+
+    output_path = Path() / "output.svg"
+    plot.plot(output_path)
+
+    assert output_path.exists()
+    output_path.unlink()

{icplot-0.0.7 → icplot-0.0.8}/test/test_tex_interface.py

@@ -3,6 +3,7 @@ import shutil
 from pathlib import Path
 from icplot.tex_interface import TexInterface
 
+
 def test_tex_interface():
 
     build_dir = Path(os.getcwd()) / "tmp_build"

icplot-0.0.7/src/icplot/graph/plot.py

@@ -1,200 +0,0 @@
-"""
-This module has content for generating plots
-"""
-
-import random
-from pathlib import Path
-from typing import cast
-
-import logging
-
-logging.getLogger("matplotlib").setLevel(logging.WARNING)
-import matplotlib  # NOQA
-
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt  # NOQA
-import matplotlib as mpl  # NOQA
-
-
-class PlotSeries:
-
-    def __init__(self, label: str = ""):
-        self.label = label
-
-
-class LinePlotSeries(PlotSeries):
-    def __init__(self, x: list[float], y: list[float], label: str = "") -> None:
-        super().__init__(label)
-        self.x = x
-        self.y = y
-
-
-class MatplotlibPlotter:
-
-    def __init__(self):
-        self.ax = plt.subplot(111)
-
-    def set_decorations(self, x_label, y_label, title, x_ticks, y_ticks):
-        self.ax.legend(loc="upper left")
-        if x_label:
-            self.ax.set_xlabel(x_label)
-        if y_label:
-            self.ax.set_ylabel(y_label)
-        if title:
-            self.ax.set_title(title)
-        if x_ticks:
-            self.ax.set_xticks(x_ticks)
-        if y_ticks:
-            self.ax.set_yticks(y_ticks)
-
-    def plot_line(self, x, y, label, color):
-        self.ax.plot(x, y, label=label, color=color)
-
-    def render(self, path: Path | None = None):
-        if path:
-            plt.savefig(path)
-        else:
-            plt.show()
-
-
-class Plot:
-    def __init__(
-        self,
-        title: str = "",
-        x_label: str = "",
-        y_label: str = "",
-        legend_label: str = "",
-    ) -> None:
-        self.series: list[PlotSeries] = []
-        self.title = title
-        self.plot_type = ""
-        self.x_label = x_label
-        self.y_label = y_label
-        self.legend_label = legend_label
-        self.c_map = mpl.colormaps["viridis"]
-        self.x_ticks = None
-        self.y_ticks = None
-        self.impl = MatplotlibPlotter()
-
-    def get_colour(self, curr, values, c_map):
-        """
-        Returns a colour based on a cmap and how far across
-        the datasets you are
-        """
-        length = len(values)
-        position = curr / length
-        return c_map(0.25 + (position / 2))
-
-    def set_colour_map(self, cmap="viridis"):
-        self.c_map = mpl.colormaps[cmap]
-
-    def set_x_ticks(self, lower, upper, step):
-        self.x_ticks = range(lower, upper + 1, step)
-
-    def set_y_ticks(self, lower, upper, step):
-        self.y_ticks = range(lower, upper + 1, step)
-
-    def set_decorations(self):
-        self.impl.set_decorations(
-            self.x_label, self.y_label, self.title, self.x_ticks, self.y_ticks
-        )
-
-    def plot(self, path: Path | None = None):
-        raise NotImplementedError()
-
-
-class LinePlot(Plot):
-
-    def plot(self, path: Path | None = None):
-
-        first = True
-        for i, series in enumerate(self.series):
-            colour = self.get_colour(i, self.series, self.c_map)
-            label = f"{series.label}"
-            if first and self.legend_label:
-                label = f"{label} {self.legend_label}"
-                first = False
-            line_series = cast(LinePlotSeries, series)
-            self.impl.plot_line(line_series.x, line_series.y, label=label, color=colour)
-
-        self.set_decorations()
-        self.impl.render(path)
-
-
-class MultiFigureLinePlotter:
-    """
-    Plot with multiple figures. Each is a line plot
-    """
-
-    def __init__(self, data: dict, figures: list, xlabel: str) -> None:
-        self.data = data
-        self.figures = figures
-        self.size: tuple = (10, 5)
-        self.xlabel = xlabel
-        self.output_fmt = "svg"
-
-    def _plot_line(self, key: str, label: str):
-        plt.plot(self.data[key], label=label)
-
-    def _decorate(self, ylabel: str, title: str):
-        plt.title(title)
-        plt.xlabel(self.xlabel)
-        plt.ylabel(ylabel)
-        plt.legend()
-        plt.show()
-
-    def plot(self, output_path: Path):
-        """
-        Do the plot
-        """
-
-        for idx, figure_info in enumerate(self.figures):
-            plt.figure(figsize=self.size)
-
-            for data_key, label in zip(figure_info["keys"], figure_info["labels"]):
-                self._plot_line(data_key, label)
-
-            title = figure_info["title"]
-            ylabel = figure_info["ylabel"]
-
-            self._decorate(ylabel, title)
-            plt.savefig(str(output_path) + f"_{idx}.{self.output_fmt}")
-
-
-class DatasetGridPlotter:
-    """
-    Plot a dataset on a grid. A dataset has pairs of images corresponding
-    to an image and an associated mask.
-    """
-
-    def __init__(
-        self, title: str = "", stride: int = 4, size: tuple = (25, 20)
-    ) -> None:
-        self.title = title
-        self.stride = stride
-        self.size = size
-
-    def _plot_grid_element(self, rows: int, cols: int, count: int, image, transform):
-        plt.subplot(rows, cols, count)
-        if transform:
-            plt.imshow(transform.reverse(image.squeeze(0).float()))
-        else:
-            plt.imshow(image.squeeze(0).float())
-        plt.axis("off")
-        plt.title(self.title)
-        return count + 1
-
-    def plot(self, data, num_samples: int, output_path: Path, transform=None):
-        plt.figure(figsize=self.size)
-        rows = num_samples // self.stride
-        cols = num_samples // rows
-        count = 1
-        indices = [random.randint(0, len(data) - 1) for _ in range(num_samples)]
-
-        for index in indices:
-            if count == num_samples + 1:
-                break
-            x, y = data[index]
-            count = self._plot_grid_element(rows, cols, count, x, transform)
-            count = self._plot_grid_element(rows, cols, count, y, transform)
-        plt.savefig(output_path)

icplot-0.0.7/test/test_line_plots.py

@@ -1,26 +0,0 @@
-from pathlib import Path
-
-from icplot.graph import LinePlot, LinePlotSeries
-
-
-def test_line_plot():
-    
-    plot = LinePlot(title="test",
-                    x_label="test_x",
-                    y_label="test_y",
-                    legend_label="test_legend")
-
-    data = [([0, 5, 10], [1, 2, 3]),
-            ([0, 5, 10], [3, 6, 9]),
-            ([0, 5, 10], [4, 8, 12])]
-
-    for idx, [x, y] in enumerate(data):
-        plot.series.append(LinePlotSeries(x, y,  label=f"Series {idx}"))
-        
-    plot.set_x_ticks(0, 10, 5)
-
-    output_path = Path() / "output.svg"
-    plot.plot(output_path)
-
-    assert output_path.exists()
-    output_path.unlink()