liblaf-melon 0.2.2__tar.gz → 0.2.3__tar.gz

{liblaf_melon-0.2.2 → liblaf_melon-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liblaf-melon
-Version: 0.2.2
+Version: 0.2.3
 Summary: Add your description here
 Project-URL: Changelog, https://github.com/liblaf/melon/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://liblaf.github.io/melon/
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Typing :: Typed
-Requires-Python: >=3.12
+Requires-Python: <3.13,>=3.12
 Requires-Dist: attrs<26,>=25.3.0
 Requires-Dist: einops<0.9,>=0.8.1
 Requires-Dist: fast-simplification<0.2,>=0.1.11

{liblaf_melon-0.2.2 → liblaf_melon-0.2.3}/pyproject.toml

@@ -84,7 +84,7 @@ keywords = []
 license = "MIT"
 name = "liblaf-melon"
 readme = "docs/README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.12,<3.13"
 
 [project.scripts]
 melon = "liblaf.melon.cli:main"
@@ -116,9 +116,6 @@ packages = ["src/liblaf/"]
 [tool.hatch.version]
 source = "vcs"
 
-[tool.pixi.dependencies]
-python = ">=3.13,<3.14"
-
 [tool.pixi.environments]
 default = { features = ["build", "dev", "docs", "test"] }
 

{liblaf_melon-0.2.2 → liblaf_melon-0.2.3}/src/liblaf/melon/__init__.pyi

@@ -1,6 +1,9 @@
-from . import io, mesh, plugin, proximity, triangle, typed, utils
+from . import barycentric, io, mesh, plugin, proximity, triangle, typed, utils
 from ._version import __version__, __version_tuple__, version, version_tuple
+from .barycentric import barycentric_to_points, sample_barycentric_coords
 from .io import (
+    PVDWriter,
+    SeriesWriter,
     as_poly_data,
     as_trimesh,
     as_unstructured_grid,
@@ -29,12 +32,16 @@ __all__ = [
     "NearestPointPrepared",
     "NearestPrepared",
     "NearestResult",
+    "PVDWriter",
+    "SeriesWriter",
     "__version__",
     "__version_tuple__",
     "annotate_landmarks",
     "as_poly_data",
     "as_trimesh",
     "as_unstructured_grid",
+    "barycentric",
+    "barycentric_to_points",
     "fast_wrapping",
     "io",
     "load_landmarks",
@@ -47,6 +54,7 @@ __all__ = [
     "nearest",
     "plugin",
     "proximity",
+    "sample_barycentric_coords",
     "save",
     "save_landmarks",
     "save_polygons",

{liblaf_melon-0.2.2 → liblaf_melon-0.2.3}/src/liblaf/melon/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.2'
-__version_tuple__ = version_tuple = (0, 2, 2)
+__version__ = version = '0.2.3'
+__version_tuple__ = version_tuple = (0, 2, 3)

liblaf_melon-0.2.3/src/liblaf/melon/barycentric/__init__.pyi

@@ -0,0 +1,4 @@
+from ._points import barycentric_to_points
+from ._sample import sample_barycentric_coords
+
+__all__ = ["barycentric_to_points", "sample_barycentric_coords"]

liblaf_melon-0.2.3/src/liblaf/melon/barycentric/_points.py

@@ -0,0 +1,15 @@
+import einops
+import numpy as np
+from jaxtyping import Float
+from numpy.typing import ArrayLike
+
+
+def barycentric_to_points(
+    cells: Float[ArrayLike, "N B D"], barycentric: Float[ArrayLike, "N B"]
+) -> Float[np.ndarray, "N D"]:
+    cells: Float[np.ndarray, "N B D"] = np.asarray(cells)
+    barycentric: Float[np.ndarray, "N B"] = np.asarray(barycentric)
+    points: Float[np.ndarray, "N D"] = einops.einsum(
+        barycentric, cells, "N B, N B D -> N D"
+    )
+    return points

liblaf_melon-0.2.3/src/liblaf/melon/barycentric/_sample.py

@@ -0,0 +1,15 @@
+import numpy as np
+from jaxtyping import Float
+
+
+def sample_barycentric_coords(
+    shape: tuple[int, int], generator: np.random.Generator | None = None
+) -> Float[np.ndarray, "N D"]:
+    if generator is None:
+        generator = np.random.default_rng()
+    n_samples: int = shape[0]
+    dim: int = shape[1]
+    coords: Float[np.ndarray, "N D-1"] = generator.uniform(0, 1, (n_samples, dim - 1))
+    coords: Float[np.ndarray, "N D-1"] = np.sort(coords, axis=1)
+    coords: Float[np.ndarray, "N D"] = np.diff(coords, axis=1, prepend=0, append=1)
+    return coords

{liblaf_melon-0.2.2 → liblaf_melon-0.2.3}/src/liblaf/melon/io/__init__.pyi

@@ -1,5 +1,6 @@
-from . import abc, pyvista, trimesh
+from . import abc, paraview, pyvista, trimesh
 from ._save import save
+from .paraview import PVDWriter, SeriesWriter
 from .pyvista import (
     as_mesh,
     as_point_set,
@@ -19,6 +20,8 @@ from .wrap import (
 )
 
 __all__ = [
+    "PVDWriter",
+    "SeriesWriter",
     "abc",
     "as_mesh",
     "as_point_set",
@@ -32,6 +35,7 @@ __all__ = [
     "load_polygons",
     "load_trimesh",
     "load_unstructured_grid",
+    "paraview",
     "pyvista",
     "save",
     "save_landmarks",

{liblaf_melon-0.2.2 → liblaf_melon-0.2.3}/src/liblaf/melon/io/abc/_writer.py

@@ -52,6 +52,7 @@ class WriterDispatcher:
     def save(self, path: PathLike, data: Any, /, **kwargs) -> None:
         for writer in self.writers:
             if writer.match_data(data) and writer.match_path(path):
+                Path(path).parent.mkdir(parents=True, exist_ok=True)
                 writer.save(path, data, **kwargs)
                 logger.debug('Saved {} to "{}".', type(data), path)
                 return

liblaf_melon-0.2.3/src/liblaf/melon/io/paraview/__init__.pyi

@@ -0,0 +1,4 @@
+from ._pvd_writer import PVDWriter
+from ._series_writer import SeriesWriter
+
+__all__ = ["PVDWriter", "SeriesWriter"]

liblaf_melon-0.2.3/src/liblaf/melon/io/paraview/_pvd_writer.py

@@ -0,0 +1,72 @@
+import shutil
+from pathlib import Path
+from typing import Any
+from xml.etree import ElementTree
+
+import attrs
+
+from liblaf.melon.io._save import save
+
+
+@attrs.frozen(kw_only=True)
+class PVDDataSet:
+    timestep: float
+    part: int
+    file: Path
+
+
+@attrs.frozen
+class PVDWriter:
+    """.
+
+    References:
+        [1]: [ParaView/Data formats - KitwarePublic](https://www.paraview.org/Wiki/ParaView/Data_formats#PVD_File_Format)
+    """
+
+    @property
+    def folder(self) -> Path:
+        return self.file.with_suffix("")
+
+    @property
+    def name(self) -> str:
+        return self.file.stem
+
+    clear: bool = attrs.field(default=False, kw_only=True)
+    datasets: list[PVDDataSet] = attrs.field(init=False, factory=list)
+    file: Path = attrs.field(default=Path("animation.pvd"), converter=Path)
+    fps: float = attrs.field(default=30.0, kw_only=True)
+
+    def __attrs_post_init__(self) -> None:
+        if self.clear:
+            shutil.rmtree(self.folder, ignore_errors=True)
+
+    def end(self) -> None:
+        root = ElementTree.Element(
+            "VTKFile", type="Collection", version="0.1", byte_order="LittleEndian"
+        )
+        collection: ElementTree.Element = ElementTree.SubElement(root, "Collection")
+        root_dir: Path = self.file.absolute().parent
+        for dataset in self.datasets:
+            elem: ElementTree.Element = ElementTree.SubElement(collection, "DataSet")
+            elem.set("timestep", str(dataset.timestep))
+            elem.set("part", str(dataset.part))
+            elem.set("file", dataset.file.absolute().relative_to(root_dir).as_posix())
+        tree = ElementTree.ElementTree(root)
+        ElementTree.indent(tree, space="  ")
+        self.file.parent.mkdir(parents=True, exist_ok=True)
+        tree.write(self.file, xml_declaration=True)
+
+    def append(
+        self, dataset: Any, timestep: float | None = None, *, ext: str, part: int = 0
+    ) -> None:
+        if timestep is None:
+            timestep = (
+                self.datasets[-1].timestep + (1 / self.fps) if self.datasets else 0
+            )
+        frame_id: int = len(self.datasets)
+        filename: str = f"{self.name}_{frame_id:06d}"
+        filename += ext
+        filepath: Path = self.folder / filename
+        save(filepath, dataset)
+        self.datasets.append(PVDDataSet(timestep=timestep, part=part, file=filepath))
+        self.end()

liblaf_melon-0.2.3/src/liblaf/melon/io/paraview/_series_writer.py

@@ -0,0 +1,118 @@
+import contextlib
+import os
+import shutil
+import types
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any, Literal, Self, overload
+
+import pydantic
+
+from liblaf import grapes
+from liblaf.melon.io._save import save
+
+
+def snake_to_kebab(snake: str) -> str:
+    return snake.replace("_", "-")
+
+
+class File(pydantic.BaseModel):
+    name: str
+    time: float
+
+
+class Series(pydantic.BaseModel):
+    model_config = pydantic.ConfigDict(alias_generator=snake_to_kebab)
+    file_series_version: Literal["1.0"] = "1.0"
+    files: list[File] = []
+
+
+class SeriesWriter(Sequence[File], contextlib.AbstractContextManager):
+    file: Path
+    series: Series
+    timestep: float
+
+    def __init__(
+        self,
+        path: str | os.PathLike[str],
+        /,
+        *,
+        clear: bool = False,
+        fps: float = 30.0,
+        timestep: float | None = None,
+    ) -> None:
+        self.file = grapes.as_path(path)
+        self.series = Series()
+        if timestep is not None:
+            self.timestep = timestep
+        else:
+            self.timestep = 1.0 / fps
+
+        if clear:
+            shutil.rmtree(self.folder, ignore_errors=True)
+
+    @overload
+    def __getitem__(self, index: int) -> File: ...
+    @overload
+    def __getitem__(self, index: slice) -> list[File]: ...
+    def __getitem__(self, index: int | slice) -> File | list[File]:
+        return self.series.files[index]
+
+    def __len__(self) -> int:
+        return len(self.series.files)
+
+    def __enter__(self) -> Self:
+        self.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> None:
+        self.end()
+
+    @property
+    def ext(self) -> str:
+        return self.file.suffixes[-2]
+
+    @property
+    def folder(self) -> Path:
+        return self.file.parent
+
+    @property
+    def fps(self) -> float:
+        return 1.0 / self.timestep
+
+    @property
+    def name(self) -> str:
+        return self.file.with_suffix("").stem
+
+    @property
+    def time(self) -> float:
+        if len(self) == 0:
+            return 0.0
+        return self.series.files[-1].time
+
+    def append(
+        self, data: Any, *, time: float | None = None, timestep: float | None = None
+    ) -> None:
+        filename: str = f"{self.name}_{len(self):06d}{self.ext}"
+        ic(filename, self.ext, self.file)
+        save(self.folder / filename, data)
+        if time is None:
+            if timestep is None:
+                timestep = self.timestep
+            time = self.time + timestep
+        self.series.files.append(File(name=filename, time=time))
+        self.save()
+
+    def end(self) -> None:
+        self.save()
+
+    def save(self) -> None:
+        grapes.save_json(self.file, self.series.model_dump(by_alias=True))
+
+    def start(self) -> None:
+        pass

{liblaf_melon-0.2.2 → liblaf_melon-0.2.3}/src/liblaf/melon/triangle/__init__.pyi

@@ -1,11 +1,15 @@
+from ._boolean import intersection
 from ._compute_edge_length import compute_edge_lengths
 from ._extract import extract_cells, extract_groups, extract_points
+from ._ray import contains
 from ._selection import select_groups
 
 __all__ = [
     "compute_edge_lengths",
+    "contains",
     "extract_cells",
     "extract_groups",
     "extract_points",
+    "intersection",
     "select_groups",
 ]

liblaf_melon-0.2.3/src/liblaf/melon/triangle/_boolean.py

@@ -0,0 +1,16 @@
+from collections.abc import Sequence
+from typing import Any, Literal
+
+import trimesh as tm
+
+
+def intersection(
+    meshes: Sequence[Any],
+    *,
+    engine: Literal["blender", "manifold"] | None = None,
+    check_volume: bool = True,
+    **kwargs,
+) -> tm.Trimesh:
+    return tm.boolean.intersection(
+        meshes, engine=engine, check_volume=check_volume, **kwargs
+    )

liblaf_melon-0.2.3/src/liblaf/melon/triangle/_ray.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+import numpy as np
+import pyvista as pv
+import trimesh as tm
+from jaxtyping import Bool
+
+from liblaf.melon import io
+
+
+def contains(mesh: Any, pcl: Any) -> Bool[np.ndarray, " N"]:
+    mesh: tm.Trimesh = io.as_trimesh(mesh)
+    pcl: pv.PointSet = io.as_point_set(pcl)
+    return mesh.contains(pcl.points)

liblaf_melon-0.2.3/src/liblaf/melon/typed/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

liblaf_melon-0.2.3/src/liblaf/melon/utils/__init__.py

@@ -0,0 +1,3 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)