icplot 0.2.4__py3-none-any.whl → 0.3.1__py3-none-any.whl

icplot/{gantt → charts}/gantt.py

@@ -4,11 +4,10 @@ This module represents a gantt chard
 
 from datetime import datetime
 
-from pydantic import BaseModel
-
 from iccore.project import Milestone
+from pydantic import BaseModel
 
-from icplot.color import Color
+from icplot.theme.color import Color
 
 
 class GanttChart(BaseModel, frozen=True):

icplot/{tree.py → charts/tree.py}

@@ -1,13 +1,12 @@
+import logging
 import os
 import shutil
-import logging
 from dataclasses import dataclass
-from typing import Callable
 from pathlib import Path
+from typing import Callable
 
 import graphviz
 
-
 logger = logging.getLogger(__name__)
 
 

icplot/converter/__init__.py

@@ -0,0 +1,3 @@
+from .image import pdf_to_png, svg_to_pdf, svg_to_png
+
+__all__ = ["pdf_to_png", "svg_to_pdf", "svg_to_png"]

icplot/converter/cli.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+from .convert import convert
+
+
+def convert_cli(args):
+
+    source = args.source.resolve()
+    target = Path(args.target).resolve() if args.target else None
+    convert(source, target)
+
+
+def register_parser(subparsers):
+
+    convert_parser = subparsers.add_parser("convert")
+    convert_parser.add_argument(
+        "source",
+        type=Path,
+        help="Path to file to be converted from",
+    )
+    convert_parser.add_argument(
+        "--target",
+        type=str,
+        default="",
+        help="Path to file to be converted to",
+    )
+    convert_parser.set_defaults(func=convert_cli)

icplot/converter/convert.py

@@ -0,0 +1,32 @@
+"""
+Module supporting conversion between image formats
+"""
+
+import logging
+from pathlib import Path
+
+from .image import pdf_to_png, svg_to_pdf, svg_to_png
+
+logger = logging.getLogger(__name__)
+
+
+def convert(source: Path, target: Path | None = None):
+    """
+    Convert between image formats using the source and target
+    file extensions as format hints.
+    """
+
+    logger.info("Converting %s", source)
+
+    if source.suffix == ".pdf":
+        pdf_to_png(source, target)
+    elif source.suffix == ".svg":
+        if target:
+            if target.suffix == ".png":
+                svg_to_png(source, target)
+            elif target.suffix == ".pdf":
+                svg_to_pdf(source, target)
+        else:
+            svg_to_png(source)
+
+    logger.info("Finished conversion")

icplot/{image_utils.py → converter/image.py}

@@ -5,34 +5,36 @@ formats
 
 import logging
 import os
+import shutil
+import subprocess
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
 _HAS_WAND = True
 try:
-    from wand.image import Image
     from wand.color import Color
+    from wand.image import Image
 except ImportError as e:
-    logging.getLogger(__name__).warning(
-        "Disabling Wand stupport. Failed to load with: %s", e
-    )
+    logger.debug("wand not available: %s", e)
     _HAS_WAND = False
 
 _HAS_CAIRO_SVG = True
 try:
     import cairosvg
 except ImportError as e:
-    logging.getLogger(__name__).warning(
-        "Disabling CairoSVG stupport. Failed to load with: %s", e
-    )
+    logger.debug("cairosvg not available: %s", e)
     _HAS_CAIRO_SVG = False
 
-logger = logging.getLogger(__name__)
-
 
 def has_wand() -> bool:
     return _HAS_WAND
 
 
+def has_magick() -> bool:
+    return bool(shutil.which("magick"))
+
+
 def has_cairo_svg() -> bool:
     return _HAS_CAIRO_SVG
 
@@ -43,13 +45,27 @@ def _get_out_filename(source: Path, target: Path | None, extension: str) -> Path
     return source.parent / f"{source.stem}.{extension}"
 
 
+def _pdf_to_png(source: Path, target: Path | None = None, resolution: int = 300):
+
+    outfile = _get_out_filename(source, target, "png")
+    os.makedirs(outfile.parent, exist_ok=True)
+    cmd = (
+        f"magick -density {resolution} -background white -alpha off {source} {outfile}"
+    )
+    subprocess.run(cmd, shell=True, check=True)
+
+
 def pdf_to_png(source: Path, target: Path | None = None, resolution: int = 300):
     """
     Convert a pdf to png with white background
     """
 
     if not has_wand():
-        raise RuntimeError("Loading Wand failed - no pdf to png support")
+        if has_magick():
+            _pdf_to_png(source, target, resolution)
+            return
+        else:
+            raise RuntimeError("Loading Wand failed - no pdf to png support")
 
     outfile = _get_out_filename(source, target, "png")
     os.makedirs(outfile.parent, exist_ok=True)

icplot/geometry/base.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 
 import numpy as np
 
+from .operations import get_point_distance
+
 
 @dataclass(frozen=True)
 class Vector:
@@ -47,6 +50,9 @@ class Point:
     def subtract(self, v: Vector) -> Vector:
         return Vector(self.x - v.x, self.y - v.y, self.z - v.z)
 
+    def get_distance(self, p: Point) -> float:
+        return get_point_distance(p.as_array(), self.as_array())
+
 
 @dataclass(frozen=True)
 class Bounds:

icplot/{mesh → geometry/mesh}/edge.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 
-from icplot.geometry import Point, segment_contains_point, get_segment_distance
+from icplot.geometry import Point, get_segment_distance, segment_contains_point
 
 from .vertex import Vertex
 

icplot/{mesh → geometry/mesh}/mesh.py

@@ -4,13 +4,14 @@ over performance. Consider something else for high performance meshing.
 """
 
 from __future__ import annotations
+
 from dataclasses import dataclass
 
-from icplot.geometry import Point, Vector, Transform, Bounds
+from icplot.geometry import Bounds, Point, Shape, Transform, Vector
 
-from .vertex import Vertex, find_closest_vertex
 from .cell import Cell, flip_normals
 from .edge import Edge, contains_point, get_distance
+from .vertex import Vertex, find_closest_vertex
 
 
 @dataclass(frozen=True)
@@ -49,7 +50,7 @@ class Mesh:
             ymin = min(ymin, v.y)
             ymax = max(ymax, v.y)
             zmin = min(zmin, v.z)
-            zmax = min(zmax, v.z)
+            zmax = max(zmax, v.z)
         return Bounds(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax)
 
     def flip_normals(self) -> Mesh:
@@ -67,8 +68,28 @@ class Mesh:
             vertices=tuple(v.translate(delta) for v in self.vertices), cells=self.cells
         )
 
-    def move_by(self, x: float, y: float, z: float) -> Mesh:
+    def scale_by(self, factor: float) -> Mesh:
+        return Mesh(
+            vertices=tuple(v.scale(factor) for v in self.vertices), cells=self.cells
+        )
+
+    def rotate_to(self, vec: Vector) -> Mesh:
+        return Mesh(
+            vertices=tuple(v.rotate_to(vec) for v in self.vertices), cells=self.cells
+        )
+
+    def move_by(
+        self, x: float, y: float, z: float, selection: list[int] | None = None
+    ) -> Mesh:
         delta = Vector(x, y, z)
+        if selection:
+            return Mesh(
+                vertices=tuple(
+                    v.translate(delta) if v.id in selection else v.copy()
+                    for v in self.vertices
+                ),
+                cells=self.cells,
+            )
         return Mesh(
             vertices=tuple(v.translate(delta) for v in self.vertices), cells=self.cells
         )
@@ -105,3 +126,8 @@ class Mesh:
             vertices=tuple(Vertex(v.x, v.y, v.z, v.id) for v in self.vertices),
             cells=tuple(Cell(c.vertices, c.type) for c in self.cells),
         )
+
+    def select_region(self, region: Shape) -> list[int]:
+        return [
+            v.id for v in self.vertices if region.contains_point(Point(v.x, v.y, v.z))
+        ]

icplot/{mesh → geometry/mesh}/openfoam/blockmesh.py

@@ -2,14 +2,13 @@
 Meshing utilities for use in openfoam
 """
 
+import os
 import shutil
 import subprocess
-import os
 from pathlib import Path
 from typing import cast
 
-
-from icplot.mesh import Edge, HexCell, Mesh, Patch
+from icplot.geometry.mesh import Edge, HexCell, Mesh, Patch
 
 from .foamfile import FoamFile, write_header
 

icplot/{mesh → geometry/mesh}/openfoam/polymesh.py

@@ -1,11 +1,11 @@
 from dataclasses import dataclass
-from pathlib import Path
 from functools import cmp_to_key
+from pathlib import Path
 
 from icplot.geometry import Point
-from icplot.mesh import Vertex, Mesh, get_hex_faces
+from icplot.geometry.mesh import Mesh, Vertex, get_hex_faces
 
-from .foamfile import read_foamfile, FoamFile, write_header
+from .foamfile import FoamFile, read_foamfile, write_header
 
 
 @dataclass(frozen=True)
@@ -65,10 +65,8 @@ class PolymeshPatch:
 
 def read_polymesh(path: Path) -> Polymesh:
 
-    points_file = read_foamfile(path / "points")
+    _ = read_foamfile(path / "points")
     # faces_file = read_foamfile(path / "faces")
-    print(points_file)
-    # print(faces_file)
     return Polymesh((), (), ())
 
 

icplot/{mesh → geometry/mesh}/shapes.py

@@ -1,21 +1,21 @@
 import numpy as np
 
 from icplot.geometry import (
-    Point,
-    Quad,
     Annulus,
-    Transform,
     Circle,
     Cuboid,
-    Vector,
     Cylinder,
+    Point,
+    Quad,
+    Shape,
+    Transform,
+    Vector,
 )
 
+from .cell import Cell, HexCell
 from .mesh import Mesh
+from .operations import close_mesh, map_radial, merge_meshes, mesh_extrude
 from .vertex import Vertex, find_closest
-from .cell import Cell, HexCell
-
-from .operations import map_radial, close_mesh, merge_meshes, mesh_extrude
 
 
 def mesh_rectangle(rect: Quad, num_width: int = 10, num_height: int = 10) -> Mesh:
@@ -187,6 +187,73 @@ def mesh_cylinder_basic(
     )
 
 
+"""
+def _mesh_cylinder_block(radius,
+                         top_loc,
+                         bottom_loc,
+                         boundary_fraction,
+                         num_radial,
+                         num_circumferential,
+                         cell_height,
+                         top_hole: Hole | None = None,
+                         bottom_hole: Hole | None = None) -> Mesh:
+    length = height - hole_loc.z
+    num_cells_in_block = int(num_height*length/height) + 1
+    block = mesh_cylinder_basic(Cylinder(diameter=radius*2, length=length),
+                                boundary_fraction,
+                                num_radial,
+                                num_circumferential,
+                                num_cells_in_block)
+    block = block.move_by(0.0, 0.0, hole_loc.z)
+    selection = block.select_region(holes[0])
+    block = block.move_by(0.0, 0.0, (length/num_cells_in_block)/8.0, selection)
+"""
+
+
+def _mesh_compound_cylinder_with_holes(
+    inlet_radius,
+    inlet_height,
+    radius,
+    height,
+    boundary_fraction,
+    num_circumferential,
+    num_radial,
+    num_height,
+    holes: list[Shape],
+) -> Mesh:
+
+    # Mesh the core cylinder in blocks at the hole locations
+    hole_loc = holes[0].transform.location
+
+    length = height - hole_loc.z
+    num_cells_in_block = int(num_height * length / height) + 1
+    block = mesh_cylinder_basic(
+        Cylinder(diameter=radius * 2, length=length),
+        boundary_fraction,
+        num_radial,
+        num_circumferential,
+        num_cells_in_block,
+    )
+    block = block.move_by(0.0, 0.0, hole_loc.z)
+    selection = block.select_region(holes[0])
+    block = block.move_by(0.0, 0.0, (length / num_cells_in_block) / 8.0, selection)
+
+    length = hole_loc.z
+    num_cells_in_block = int(num_height * length / height) + 1
+    block = mesh_cylinder_basic(
+        Cylinder(diameter=radius * 2, length=length),
+        boundary_fraction,
+        num_radial,
+        num_circumferential,
+        num_cells_in_block,
+    )
+    block = block.move_by(0.0, 0.0, 0.0)
+    selection = block.select_region(holes[0])
+    block = block.move_by(0.0, 0.0, -(length / num_cells_in_block) / 8.0, selection)
+
+    return merge_meshes(block, block)
+
+
 def mesh_compound_cylinder(
     inlet_radius,
     inlet_height,
@@ -196,8 +263,21 @@ def mesh_compound_cylinder(
     num_circumferential,
     num_radial,
     num_height,
+    holes: list[Shape] | None = None,
 ) -> Mesh:
 
+    if holes:
+        return _mesh_compound_cylinder_with_holes(
+            inlet_radius,
+            inlet_height,
+            radius,
+            height,
+            boundary_fraction,
+            num_circumferential,
+            num_radial,
+            num_height,
+            holes,
+        )
     inner = mesh_cylinder_basic(
         Cylinder(diameter=inlet_radius * 2, length=2 * inlet_height + height),
         boundary_fraction,

icplot/{mesh → geometry/mesh}/vertex.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 
 import numpy as np
 
-from icplot.geometry import Point, Vector, get_point_distance
+from icplot.geometry import Point, Vector, get_point_distance, get_rotation_matrix
+
+_GLOBAL_Z = np.array([0.0, 0.0, 1.0])
 
 
 @dataclass(frozen=True)
@@ -21,6 +24,9 @@ class Vertex:
     def from_point(p: Point, id: int = -1) -> Vertex:
         return Vertex(p.x, p.y, p.z, id)
 
+    def copy(self) -> Vertex:
+        return Vertex(self.x, self.y, self.z, self.id)
+
     def as_array(self) -> np.ndarray:
         return np.array([self.x, self.y, self.z])
 
@@ -33,6 +39,15 @@ class Vertex:
     def translate(self, v: Vector) -> Vertex:
         return Vertex(self.x + v.x, self.y + v.y, self.z + v.z, self.id)
 
+    def scale(self, factor: float) -> Vertex:
+        return Vertex(self.x * factor, self.y * factor, self.z * factor, self.id)
+
+    def rotate_to(self, v: Vector) -> Vertex:
+        loc = np.array([self.x, self.y, self.z])
+        rot = get_rotation_matrix(_GLOBAL_Z, v.as_array())
+        loc_rot = rot.dot(loc)
+        return Vertex(loc_rot[0], loc_rot[1], loc_rot[2], self.id)
+
 
 def find_closest(verts: list[Vertex], point: Point) -> int:
 

icplot/geometry/shapes.py

@@ -5,6 +5,7 @@ dependent work.
 """
 
 from __future__ import annotations
+
 from dataclasses import dataclass
 
 from .base import Point, Vector
@@ -19,6 +20,9 @@ class Shape:
 
     transform: Transform = Transform()
 
+    def contains_point(self, p: Point) -> bool:
+        raise NotImplementedError()
+
 
 @dataclass(frozen=True)
 class Circle(Shape):
@@ -75,6 +79,21 @@ class Cuboid(Shape):
     def translate(self, v: Vector) -> Cuboid:
         return Cuboid(self.transform.translate(v), self.width, self.height, self.depth)
 
+    def contains_point(self, p: Point) -> bool:
+        in_x = (
+            p.x >= self.transform.location.x
+            and p.x <= self.transform.location.x + self.width
+        )
+        in_y = (
+            p.y >= self.transform.location.y
+            and p.y <= self.transform.location.y + self.height
+        )
+        in_z = (
+            p.z >= self.transform.location.z
+            and p.z <= self.transform.location.z + self.depth
+        )
+        return in_x and in_y and in_z
+
     @property
     def points(self) -> list[Point]:
 
@@ -110,6 +129,16 @@ class Cylinder(Shape):
     def end(self) -> Point:
         return self.transform.get_point_at_normal_offset(self.length)
 
+    def contains_point(self, p: Point) -> bool:
+        in_radius = p.get_distance(self.transform.location) <= self.diameter / 2.0
+        if not in_radius:
+            return False
+        in_height = (
+            p.z >= self.transform.location.z
+            and p.z <= self.transform.location.z + self.length
+        )
+        return in_height
+
 
 @dataclass(frozen=True)
 class Revolution(Shape):

icplot/geometry/transform.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 
 import numpy as np
 
 from .base import Point, Vector
-from .operations import get_three_point_normal, get_rotation_matrix
-
+from .operations import get_rotation_matrix, get_three_point_normal
 
 _GLOBAL_Z = np.array([0.0, 0.0, 1.0])
 

icplot/graph/__init__.py

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

icplot/graph/plot.py

@@ -3,20 +3,11 @@ This module has content for generating plots
 """
 
 import random
-from pathlib import Path
-import os
 
 from pydantic import BaseModel
 
-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 PlotGroupPublic, PlotSeriesPublic
+from .series import ImageSeries, LinePlotSeries, ScatterPlotSeries
 
 
 class Plot(BaseModel, frozen=True):
@@ -52,7 +43,7 @@ class GridPlot(Plot, frozen=True):
     data: list = []
 
     def get_series_indices(self, num_samples: int = 0):
-        rows = num_samples // self.stride
+        rows = max(1, num_samples // self.stride)
         cols = num_samples // rows
         len_data = len(self.data)
 
@@ -78,45 +69,3 @@ class GridPlot(Plot, frozen=True):
                 subplots.append(self.data[index])
                 count += 1
         return rows, cols, subplots
-
-
-def get_series_colors(cmap: ColorMap, plot: Plot) -> list[Color]:
-
-    count = 0
-    num_colorable = len([s for s in plot.series if not s.highlight])
-    colors = []
-    for s in plot.series:
-        if not s.highlight:
-            color = cmap.get_color(count, num_colorable)
-            count = count + 1
-        else:
-            color = s.color
-        colors.append(color)
-    return colors
-
-
-def plot_series(
-    path: Path,
-    group: PlotGroupPublic,
-    series: PlotSeriesPublic,
-    data_series: Series,
-):
-
-    output_path = path / series.measurement.product_name
-
-    os.makedirs(output_path, exist_ok=True)
-
-    # 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)
-
-    if "vtk" in group.formats and data_series.y:
-        vtk.save(output_path, group, series, converted_data_series)

icplot/graph/plot_group.py

@@ -2,8 +2,8 @@
 Module to handle generation of plots
 """
 
-from datetime import datetime
 from dataclasses import dataclass
+from datetime import datetime
 
 from pydantic import BaseModel
 

icplot/graph/series.py

@@ -4,16 +4,15 @@ A data series in a plot
 
 import typing
 
-from pydantic import BaseModel
-
 from iccore.data import (
-    ProductPublicWithMeasurements,
     MeasurementPublicWithUnits,
+    ProductPublicWithMeasurements,
     Unit,
     UnitPublic,
 )
+from pydantic import BaseModel
 
-from icplot.color import Color
+from icplot.theme.color import Color
 
 
 class PlotSeriesBase(BaseModel, frozen=True):