icplot 0.2.3__py3-none-any.whl → 0.3.0__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}

@@ -7,27 +7,23 @@ import logging
 import os
 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

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}/cell.py

@@ -14,6 +14,27 @@ class Cell:
         raise NotImplementedError()
 
 
+def flip_normals(cell: Cell) -> Cell:
+    if cell.type == "quad":
+        return Cell(type=cell.type, vertices=tuple(reversed(cell.vertices)))
+    else:
+        raise RuntimeError("Not implemented for this cell type")
+
+
+def get_hex_faces(cell: Cell) -> tuple[tuple[int, ...], ...]:
+    if cell.type != "hex":
+        raise RuntimeError("Can only get hex faces for hex cells")
+
+    return (
+        (cell.vertices[0], cell.vertices[1], cell.vertices[5], cell.vertices[4]),
+        (cell.vertices[1], cell.vertices[2], cell.vertices[6], cell.vertices[5]),
+        (cell.vertices[2], cell.vertices[3], cell.vertices[7], cell.vertices[6]),
+        (cell.vertices[3], cell.vertices[0], cell.vertices[4], cell.vertices[7]),
+        (cell.vertices[0], cell.vertices[3], cell.vertices[2], cell.vertices[1]),
+        (cell.vertices[4], cell.vertices[5], cell.vertices[6], cell.vertices[7]),
+    )
+
+
 @dataclass(frozen=True)
 class HexCell(Cell):
     """

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
-from .cell import Cell
+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,9 +50,14 @@ 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:
+        return Mesh(
+            vertices=self.vertices, cells=tuple(flip_normals(c) for c in self.cells)
+        )
+
     def get_location(self) -> Vector:
         bounds = self.get_bounds()
         return Vector(bounds.xmin, bounds.ymin, bounds.zmin)
@@ -62,6 +68,32 @@ class Mesh:
             vertices=tuple(v.translate(delta) for v in self.vertices), cells=self.cells
         )
 
+    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
+        )
+
     def select_edge(self, p: Point) -> tuple[int, int]:
 
         for c in self.cells:
@@ -70,6 +102,9 @@ class Mesh:
                     return (e[0], e[1])
         raise RuntimeError("No edge found at selection point")
 
+    def get_closest_vertex(self, v: Vertex) -> Vertex:
+        return find_closest_vertex(self.vertices, v)
+
     def get_closest_edge(self, p: Point) -> tuple[int, int]:
 
         min_dist = -1.0
@@ -85,3 +120,14 @@ class Mesh:
                     min_dist = dist
                     closest_edges = (e[0], e[1])
         return closest_edges
+
+    def copy(self) -> Mesh:
+        return 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/foamfile.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 
@@ -14,8 +14,9 @@ class FoamFile:
     body: tuple[str, ...] = ()
     version: float = 2.0
     format: str = "ascii"
-    arch: str = '"LSB;label=32;scalar=64"'
+    arch: str = "LSB;label=32;scalar=64"
     foam_class: str = "vectorField"
+    meta: dict[str, tuple] = field(default_factory=dict)
 
 
 def write_header(spec: FoamFile) -> str:
@@ -27,6 +28,13 @@ def write_header(spec: FoamFile) -> str:
     output += f"\tclass\t{spec.foam_class};\n"
     output += f'\tlocation\t"{spec.location}";\n'
     output += f"\tobject\t{spec.foam_object};\n"
+    if spec.meta:
+        output += "\tmeta\n{\n"
+        for key, value in spec.meta.items():
+            values = list(value)
+            value_items = " ".join(str(item) for item in values)
+            output += f"\t{key} {len(values)}({value_items});\n"
+        output += "}\n"
     output += "}\n\n"
     return output
 

icplot/geometry/mesh/openfoam/polymesh.py

@@ -0,0 +1,313 @@
+from dataclasses import dataclass
+from functools import cmp_to_key
+from pathlib import Path
+
+from icplot.geometry import Point
+from icplot.geometry.mesh import Mesh, Vertex, get_hex_faces
+
+from .foamfile import FoamFile, read_foamfile, write_header
+
+
+@dataclass(frozen=True)
+class Face:
+    """
+    A mesh face, which is a sequence of vertices
+    """
+
+    vertices: tuple[int, ...]
+    id: int = -1
+    owner: int = -1
+    neighbour: int = -1
+
+    def get_centre(self, mesh: Mesh) -> Point:
+        x = sum(mesh.vertices[idx].x for idx in self.vertices)
+        y = sum(mesh.vertices[idx].y for idx in self.vertices)
+        z = sum(mesh.vertices[idx].z for idx in self.vertices)
+        return Point(
+            x / len(self.vertices), y / len(self.vertices), z / len(self.vertices)
+        )
+
+
+@dataclass(frozen=True)
+class Cell:
+    """
+    A mesh cell, which is a squence of faces
+    """
+
+    faces: tuple[int, ...]
+    id: int = -1
+
+
+@dataclass(frozen=True)
+class Polymesh:
+    """
+    The polymesh
+    """
+
+    vertices: tuple[Vertex, ...]
+    faces: tuple[Face, ...]
+    cells: tuple[Cell, ...]
+
+
+@dataclass(frozen=True)
+class PolymeshPatch:
+    name: str
+    faces: tuple[Face, ...]
+    startFace: int
+    type: str = "patch"
+
+    def has_face(self, face: Face) -> bool:
+        for f in self.faces:
+            if f.id == face.id:
+                return True
+        return False
+
+
+def read_polymesh(path: Path) -> Polymesh:
+
+    _ = read_foamfile(path / "points")
+    # faces_file = read_foamfile(path / "faces")
+    return Polymesh((), (), ())
+
+
+def _write_points(vertices: tuple[Vertex, ...]) -> str:
+
+    # Write file header
+    header = FoamFile(
+        location="constant/polyMesh", foam_object="points", foam_class="vectorField"
+    )
+    ret = write_header(header)
+
+    ret += f"{len(vertices)}\n(\n"
+    for v in vertices:
+        ret += f"({v.x} {v.y} {v.z})\n"
+    ret += ")\n"
+    return ret
+
+
+def _write_faces(internal_faces: tuple[Face, ...], patches: list[PolymeshPatch]) -> str:
+    header = FoamFile(
+        location="constant/polyMesh", foam_object="faces", foam_class="faceList"
+    )
+    ret = write_header(header)
+
+    num_patch_faces = sum(len(p.faces) for p in patches)
+    num_faces = len(internal_faces) + num_patch_faces
+
+    ret += f"{num_faces}\n(\n"
+    for f in internal_faces:
+        verts = f.vertices
+        ret += f"{len(verts)}({verts[0]} {verts[1]} {verts[2]} {verts[3]})\n"
+
+    for p in patches:
+        for f in p.faces:
+            verts = f.vertices
+            ret += f"{len(verts)}({verts[0]} {verts[1]} {verts[2]} {verts[3]})\n"
+    ret += ")\n"
+    return ret
+
+
+def _write_owners(
+    internal_faces: tuple[Face, ...], patches: list[PolymeshPatch]
+) -> str:
+    header = FoamFile(
+        location="constant/polyMesh", foam_object="owner", foam_class="labelList"
+    )
+    ret = write_header(header)
+
+    num_patch_faces = sum(len(p.faces) for p in patches)
+    num_faces = len(internal_faces) + num_patch_faces
+
+    ret += f"{num_faces}\n(\n"
+    for f in internal_faces:
+        ret += f"{f.owner}\n"
+    for p in patches:
+        for f in p.faces:
+            ret += f"{f.owner}\n"
+    ret += ")\n"
+    return ret
+
+
+def _write_neighbours(
+    internal_faces: tuple[Face, ...], patches: list[PolymeshPatch]
+) -> str:
+    header = FoamFile(
+        location="constant/polyMesh", foam_object="neighbour", foam_class="labelList"
+    )
+    ret = write_header(header)
+
+    num_patch_faces = sum(len(p.faces) for p in patches)
+    num_faces = len(internal_faces) + num_patch_faces
+
+    ret += f"{num_faces}\n(\n"
+    for f in internal_faces:
+        ret += f"{f.neighbour}\n"
+    for p in patches:
+        for f in p.faces:
+            ret += f"{f.neighbour}\n"
+    ret += ")\n"
+    return ret
+
+
+"""
+def _write_face_zones(zones: list[FaceZone]) -> str:
+
+    header = FoamFile(
+        location="constant/polyMesh",
+        foam_object="faceZones",
+        foam_class="regIOobject",
+        meta={"names": tuple(zone.name for zone in zones)},
+    )
+    ret = write_header(header)
+
+    ret += f"{len(zones)}\n( "
+    for zone in zones:
+        ret += f"{zone.name}\n{{"
+        ret += "\ttype\tfaceZone;\n\tfaceLabels\tList<label>\n"
+        ret += f"{len(zone.faces)}\n("
+        for face in zone.faces:
+            ret += f"{face}\n"
+        ret += ");\n"
+        ret += "\tflipMap\tList<bool>\n"
+        ret += f"{len(zone.faces)}\n("
+        for face in zone.faces:
+            ret += "0\n"
+        ret += ");\n"
+        ret += "}\n\n"
+    ret += ")"
+    return ret
+"""
+
+
+def _write_boundaries(patches: list[PolymeshPatch]):
+
+    header = FoamFile(
+        location="constant/polyMesh",
+        foam_object="boundary",
+        foam_class="polyBoundaryMesh",
+    )
+    ret = write_header(header)
+
+    ret += f"{len(patches)}(\n"
+    for p in patches:
+        ret += f"{p.name}\n{{"
+        ret += f"\ttype\t{p.type};\n"
+        ret += f"\tnFaces\t{len(p.faces)};\n"
+        ret += f"\tstartFace\t{p.startFace};\n"
+        ret += "}\n\n"
+    ret += ")"
+    return ret
+
+
+def _faces_equal(f0, f1):
+    return set(f0) == set(f1)
+
+
+def _compare_faces(f0: Face, f1: Face):
+    if f0.owner == f1.owner:
+        if f0.neighbour == f1.neighbour:
+            return 0
+        elif f0.neighbour > f1.neighbour:
+            return 1
+        else:
+            return -1
+    else:
+        if f0.owner > f1.owner:
+            return 1
+        else:
+            return -1
+
+
+def _build_faces(mesh: Mesh) -> list[Face]:
+    faces: list[Face] = []
+
+    count = 0
+    for idx, cell in enumerate(mesh.cells):
+        hex_faces = get_hex_faces(cell)
+        for hex_face in hex_faces:
+            found = False
+            for face in faces:
+                if _faces_equal(hex_face, face.vertices):
+                    if idx < face.owner:
+                        faces[face.id] = Face(
+                            vertices=tuple(list(reversed(face.vertices))),
+                            owner=idx,
+                            id=face.id,
+                            neighbour=face.owner,
+                        )
+                    else:
+                        faces[face.id] = Face(
+                            vertices=face.vertices,
+                            owner=face.owner,
+                            id=face.id,
+                            neighbour=idx,
+                        )
+                    found = True
+                    break
+            if not found:
+                faces.append(Face(id=count, vertices=hex_face, owner=idx, neighbour=-1))
+                count += 1
+
+    faces.sort(key=cmp_to_key(_compare_faces))
+    return faces
+
+
+def _get_external_faces(faces: tuple[Face, ...]) -> tuple[Face, ...]:
+    return tuple(f for f in faces if f.neighbour == -1)
+
+
+def _get_internal_faces(faces: tuple[Face, ...]) -> tuple[Face, ...]:
+    return tuple(f for f in faces if f.neighbour != -1)
+
+
+def write_polymesh(path: Path, mesh: Mesh, patch_funcs: dict):
+
+    # Write points
+    with open(path / "points", "w", encoding="utf-8") as f:
+        f.write(_write_points(mesh.vertices))
+
+    # Prepare faces, owners and neighbours
+    faces = _build_faces(mesh)
+
+    internal_faces = _get_internal_faces(tuple(faces))
+    external_faces = _get_external_faces(tuple(faces))
+
+    # Get patches
+    count = len(internal_faces)
+    patches = []
+    for name, func in patch_funcs.items():
+        patch_faces = tuple(f for f in external_faces if func(f.get_centre(mesh)))
+        patches.append(PolymeshPatch(name=name, faces=patch_faces, startFace=count))
+        count += len(patch_faces)
+
+    # Add a default wall patch
+    wall_faces = []
+    for face in external_faces:
+        found = False
+        for patch in patches:
+            if patch.has_face(face):
+                found = True
+                break
+        if not found:
+            wall_faces.append(face)
+    patches.append(
+        PolymeshPatch(
+            name="wall",
+            type="wall",
+            faces=tuple(f for f in wall_faces),
+            startFace=count,
+        )
+    )
+
+    with open(path / "faces", "w", encoding="utf-8") as f:
+        f.write(_write_faces(internal_faces, patches))
+
+    with open(path / "owner", "w", encoding="utf-8") as f:
+        f.write(_write_owners(internal_faces, patches))
+
+    with open(path / "neighbour", "w", encoding="utf-8") as f:
+        f.write(_write_neighbours(internal_faces, patches))
+
+    # Write boundaries
+    with open(path / "boundary", "w", encoding="utf-8") as f:
+        f.write(_write_boundaries(patches))