DeepSDFStruct 1.7.2__py3-none-any.whl

DeepSDFStruct/flexisquares/tables.py

@@ -0,0 +1,63 @@
+"""
+FlexiSquares Lookup Tables
+==========================
+
+This module contains precomputed lookup tables for the FlexiSquares algorithm.
+These tables encode the topology of all possible Marching Squares configurations.
+"""
+
+# (0,1) ─ 2 ─ (1,1)
+# |         |
+# 0         1
+# |         |
+# (0,0) ─ 3 ─ (1,0)
+
+# (2) ─ 2 ─ (3)
+#  |         |
+#  0         1
+#  |         |
+# (0) ─ 3 ─ (1)
+
+# Edges are:
+# e0: bottom → top along left side → (0,0)-(0,1) → corners (0,2)
+# e1: bottom → top along right side → (1,0)-(1,1) → corners (1,3)
+# e2: left → right along bottom → (0,0)-(1,0) → corners (0,1)
+# e3: left → right along top → (0,1)-(1,1) → corners (2,3)
+dmc_table = [
+    [[-1, -1], [-1, -1]],  # 0: 0000 no intersections
+    [[0, 3], [-1, -1]],  # 1: 0001
+    [[1, 3], [-1, -1]],  # 2: 0010
+    [[0, 1], [-1, -1]],  # 3: 0011
+    [[2, 0], [-1, -1]],  # 4: 0100
+    [[2, 3], [-1, -1]],  # 5: 0101
+    [[0, 3], [2, 1]],  # 6: 0110 # ambigous (two lines)
+    [[1, 2], [-1, -1]],  # 7: 0111
+    [[1, 2], [-1, -1]],  # 8: 1000
+    [[0, 2], [3, 1]],  # 9: 1001 # ambiguous (two lines)
+    [[2, 3], [-1, -1]],  # 10: 1010
+    [[0, 2], [-1, -1]],  # 11: 1011
+    [[0, 1], [-1, -1]],  # 12: 1100
+    [[3, 1], [-1, -1]],  # 13: 1101
+    [[0, 3], [-1, -1]],  # 14: 1110
+    [[-1, -1], [-1, -1]],  # 15: 1111 full fill (no contour)
+]
+# connect center to ->
+tet_table = [
+    [[-1, -1], [-1, -1]],  # 0: 0000 no intersections
+    [[-1, -1], [-1, -1]],  # 1: 0001
+    [[-1, -1], [-1, -1]],  # 2: 0010
+    [[0, 1], [-1, -1]],  # 3: 0011
+    [[-1, -1], [-1, -1]],  # 4: 0100
+    [[2, 0], [-1, -1]],  # 5: 0101
+    [[1, 2], [-1, -1]],  # 6: 0110 # ambigous (two lines)
+    [[2, 0], [0, 1]],  # 7: 0111
+    [[-1, -1], [-1, -1]],  # 8: 1000
+    [[0, 3], [-1, -1]],  # 9: 1001 # ambiguous (two lines)
+    [[1, 3], [-1, -1]],  # 10: 1010
+    [[1, 3], [0, 1]],  # 11: 1011
+    [[3, 2], [-1, -1]],  # 12: 1100
+    [[3, 2], [2, 0]],  # 13: 1101
+    [[1, 3], [3, 2]],  # 14: 1110
+    [[-1, -1], [-1, -1]],  # 15: 1111 full fill (no contour)
+]
+num_vd_table = [0, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 0]

DeepSDFStruct/lattice_structure.py

@@ -0,0 +1,254 @@
+"""
+Lattice Structure Generation
+=============================
+
+This module provides tools for creating periodic lattice structures with
+deformable geometries. Lattices are built by tiling a unit cell (microtile)
+in a regular pattern and applying optional smooth deformations via B-splines.
+
+The main class, LatticeSDFStruct, enables creation of complex microstructured
+materials with spatially-varying properties, useful for applications in:
+- Topology optimization
+- Additive manufacturing
+- Metamaterial design
+- Lightweight structural components
+
+Key Features
+------------
+- Periodic tiling of arbitrary unit cell geometries
+- Smooth deformations via spline-based mapping
+- Spatially-varying parametrization (e.g., varying strut thickness)
+- Support for 2D and 3D lattices
+- Integration with boundary conditions and capping
+"""
+
+import logging
+
+
+import numpy as _np
+import torch as _torch
+
+from splinepy import BSpline as _BSpline
+from .SDF import SDFBase as _SDFBase
+import DeepSDFStruct
+import gustaf as gus
+
+logger = logging.getLogger(DeepSDFStruct.__name__)
+
+
+class LatticeSDFStruct(_SDFBase):
+    """Helper class to facilitate the construction of periodic lattice SDF structures.
+
+    This class creates periodic lattice structures by tiling a unit cell geometry
+    (microtile) in a regular pattern and optionally deforming the result through
+    a spline-based mapping. The microtile can be parametrized to have spatially-
+    varying properties (e.g., thickness that varies across the structure).
+
+    The lattice is defined in parametric space [0,1]^d and can be mapped to
+    physical space through a deformation spline. Boundary conditions can be
+    applied to cap the structure at domain boundaries.
+
+    Parameters
+    ----------
+    tiling : list of int or int, optional
+        Number of repetitions of the microtile in each parametric dimension.
+        If an int, uses the same tiling in all dimensions.
+    microtile : SDFBase, optional
+        The unit cell geometry to be tiled. Should be defined in the
+        unit cube [0,1]^d.
+    parametrization : torch.nn.Module, optional
+        Function that provides spatially-varying parameters for the microtile
+        (e.g., varying strut thickness). Takes parametric coordinates and
+        returns parameter values.
+    cap_border_dict : CapBorderDict, optional
+        Dictionary specifying whether material should be added or removed
+        at domain faces (for capping the structure at boundaries).
+    cap_outside_of_unitcube : bool, default True
+        If True, caps geometry outside the unit cube.
+
+    Attributes
+    ----------
+    tiling : list of int
+        Number of tiles in each dimension.
+    microtile : SDFBase
+        The unit cell geometry.
+    geometric_dim : int
+        Geometric dimensionality (2 or 3).
+    parametric_dimension : int
+        Parametric dimensionality (equal to geometric_dim).
+
+    Notes
+    -----
+    The microtile should ideally have periodic boundary conditions to ensure
+    smooth connections between adjacent tiles. For parametrized microtiles,
+    the microtile must provide:
+    - `evaluation_points`: Points where parameters are evaluated
+    - `para_dim`: Dimensionality of the parameter space
+    - `_set_param`: Method to update parameters
+
+    Examples
+    --------
+    >>> from DeepSDFStruct.lattice_structure import LatticeSDFStruct
+    >>> from DeepSDFStruct.sdf_primitives import SphereSDF
+    >>> from DeepSDFStruct.torch_spline import TorchSpline
+    >>> import torch
+    >>>
+    >>> # Create a simple unit cell
+    >>> unit_cell = SphereSDF(center=[0.5, 0.5, 0.5], radius=0.3)
+    >>>
+    >>> # Create lattice with 3x3x3 tiling
+    >>> lattice = LatticeSDFStruct(
+    ...     tiling=[3, 3, 3],
+    ...     microtile=unit_cell
+    ... )
+    >>>
+    >>> # Query lattice SDF
+    >>> points = torch.rand(100, 3)
+    >>> distances = lattice(points)
+    """
+
+    def __init__(
+        self,
+        tiling: list[int] | int | None = None,
+        microtile: _SDFBase | None = None,
+        parametrization: _torch.nn.Module | None = None,
+        bounds=None,
+    ):
+        """Helper class to facilitate the construction of microstructures.
+
+        Parameters
+        ----------
+        deformation_function : spline
+          Outer function that describes the contour of the microstructured
+          geometry
+        tiling : list of integers
+          microtiles per parametric dimension
+        microtile : SDFBase
+          Representation of the building block defined in the unit cube
+        parametrization_function : Callable (optional)
+          Function to describe spline parameters
+        """
+        if not isinstance(parametrization, _torch.nn.Module):
+            raise TypeError("Parametrization must be of type _Parametrization")
+        super().__init__(parametrization=parametrization)
+        self.geometric_dim = len(tiling)
+        assert (
+            microtile.geometric_dim == self.geometric_dim
+        ), f"dimension of microtile ({self.microtile.geometric_dim}) does not match the tiling ({tiling})"
+        self.tiling = tiling
+        self.microtile = microtile
+        if bounds is not None:
+            if isinstance(bounds, (list, tuple)):
+                bounds = _torch.tensor(
+                    bounds, device=microtile.get_device(), dtype=microtile.get_dtype()
+                )
+        else:
+            match self.geometric_dim:
+                case 2:
+                    bounds = _torch.tensor(
+                        [[0.0, 0.0], [1.0, 1.0]],
+                        device=microtile.get_device(),
+                        dtype=microtile.get_dtype(),
+                    )
+                case 3:
+                    bounds = _torch.tensor(
+                        [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],
+                        device=microtile.get_device(),
+                        dtype=microtile.get_dtype(),
+                    )
+                case _:
+                    raise ValueError(
+                        f"Geometric dimension must be either 2 or 3. Got {self.geometric_dim}"
+                    )
+        self.register_buffer("bounds", bounds)
+
+    @property
+    def parametric_dimension(self):
+        return len(self.tiling)
+
+    def _get_domain_bounds(self):
+        return self.get_buffer("bounds")
+
+    def _compute(self, samples: _torch.Tensor):
+        """Function, that - if required - parametrizes the microtiles.
+
+        In order to use said function, the Microtile needs to provide a couple
+        of attributes:
+
+         - evaluation_points - a list of points defined in the unit cube
+           that will be evaluated in the parametrization function to provide
+           the required set of data points
+         - para_dim - dimensionality of the parametrization
+           function and number of design variables for said microtile
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+         : Callable
+          Function that describes the local tile parameters
+        """
+        bounds = self._get_domain_bounds()
+        if self.parametrization is not None:
+            samples_parameter_space = (samples - bounds[0]) / (bounds[1] - bounds[0])
+            samples_parameter_space = _torch.clamp(samples_parameter_space, 0.0, 1.0)
+            parameters = self.parametrization(samples_parameter_space)
+            self.microtile._set_param(parameters)
+
+        queries_transformed = _torch.zeros_like(samples)
+        for i_dim, t in enumerate(self.tiling):
+            queries_transformed[:, i_dim] = transform(
+                samples[:, i_dim], t, bounds=bounds[:, i_dim]
+            )
+        sdf_values = self.microtile(queries_transformed)
+
+        return sdf_values
+
+    def _sanity_check(self):
+        """Check all members and consistency of user data.
+
+        Parameters
+        ----------
+        updated_properties : bool
+          Sets the updated_properties variable to value, which indicates,
+          wheither the microstructure needs to be rebuilt
+
+        Returns
+        -------
+        passes: bool
+        """
+        pass
+
+    def plot_samples(self, samples, sdf_values):
+        vp = gus.Vertices(vertices=samples)
+        vp.vertex_data["distance"] = sdf_values
+        vp.show_options["cmap"] = "coolwarm"
+        gus.show(vp, axes=1)
+
+    def plot_intermesh(self, verts: _torch.Tensor, faces: _torch.Tensor):
+        gus_faces = gus.Faces(vertices=verts.cpu().detach(), faces=faces.cpu().detach())
+        gus.show(gus_faces, axes=1)
+
+
+def constantLatvec(value):
+    return _BSpline([0, 0, 0], [[-1, 1], [-1, 1], [-1, 1]], [value])
+
+
+def transform(x, t, bounds=[0, 1]):
+    # transform x from [bounds[0], bounds[1]] to [-1,1]
+    x_norm = (x - bounds[0]) / (bounds[1] - bounds[0])
+    x_transformed = 2 * _torch.abs(t * x_norm / 2 - _torch.floor((t * x_norm + 1) / 2))
+    return 2 * x_transformed - 1
+
+
+def check_tiling_input(tiling):
+    if isinstance(tiling, list) or isinstance(tiling, tuple):
+        if len(tiling) != 3:
+            raise ValueError("Tiling must be a list of 3 integers")
+        tiling = _np.array(tiling)
+    elif isinstance(tiling, int):
+        tiling = _np.array([tiling, tiling, tiling])
+    else:
+        raise ValueError("Tiling must be a list or an integer")

DeepSDFStruct/local_shapes.py

@@ -0,0 +1,226 @@
+"""
+Local Shapes for Microstructure Design
+======================================
+
+This module provides tools for creating microstructured geometries with
+localized shape variations. Unlike uniform lattices, local shapes allow
+different regions of a structure to have distinct geometric properties,
+enabling graded and functionally-graded materials.
+
+Key Features
+------------
+
+LocalShapesSDF
+    A specialized SDF class for microstructures with spatially-varying
+    unit cell shapes. Enables:
+    - Region-specific unit cell geometries
+    - Smooth transitions between different shapes
+    - Integration with parametrization functions
+    - Support for 2D and 3D microstructures
+
+The module extends the lattice structure capabilities to support more
+complex, heterogeneous microstructural designs where different regions
+may require different geometric features (e.g., varying strut patterns,
+different connectivity, or distinct topologies).
+
+This is particularly useful for:
+- Multi-material structures
+- Functionally graded materials
+- Transition zones between different lattice types
+- Adaptive microstructures
+
+Examples
+--------
+Create a microstructure with local shape variations::
+
+    from DeepSDFStruct.local_shapes import LocalShapesSDF
+    from DeepSDFStruct.sdf_primitives import SphereSDF
+
+    # Define unit cell
+    unit_cell = SphereSDF([0.5, 0.5, 0.5], radius=0.3)
+
+    # Create local shapes structure
+    local_struct = LocalShapesSDF(
+        tiling=[3, 3, 3],
+        unit_cell=unit_cell,
+        parametrization=param_func,
+        bounds=torch.tensor([[-1, -1, -1], [1, 1, 1]])
+    )
+"""
+
+import logging
+
+
+import numpy as _np
+import torch as _torch
+
+from .SDF import SDFBase as _SDFBase
+from .SDF import CapBorderDict
+import DeepSDFStruct
+from DeepSDFStruct.lattice_structure import check_tiling_input, transform
+
+logger = logging.getLogger(DeepSDFStruct.__name__)
+
+
+class LocalShapesSDF(_SDFBase):
+    """Helper class to facilitatae the construction of Lattice SDF Structures."""
+
+    def __init__(
+        self,
+        tiling: list[int] | int | None = None,
+        unit_cell: _SDFBase | None = None,
+        parametrization: _torch.nn.Module | None = None,
+        bounds=_torch.tensor([[-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]]),
+    ):
+        """Helper class to facilitatae the construction of microstructures.
+
+        Parameters
+        ----------
+        deformation_function : spline
+          Outer function that describes the contour of the microstructured
+          geometry
+        tiling : list of integers
+          microtiles per parametric dimension
+        microtile : SDFBase
+          Representation of the building block defined in the unit cube
+        parametrization_function : Callable (optional)
+          Function to describe spline parameters
+        """
+        if not isinstance(parametrization, _torch.nn.Module):
+            raise TypeError("Parametrization must be of type _Parametrization")
+        check_tiling_input(tiling)
+        super().__init__(parametrization=parametrization)
+        self.tiling = (
+            [tiling] * unit_cell.geometric_dim if isinstance(tiling, int) else tiling
+        )
+        self.unit_cell = unit_cell
+        self.bounds = bounds
+
+    @property
+    def tiling(self):
+        """Number of microtiles per parametric dimension.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        tiling : list<int>
+        """
+        if hasattr(self, "_tiling"):
+            return self._tiling
+        else:
+            return None
+
+    @tiling.setter
+    def tiling(self, tiling):
+        """Setter for the tiling attribute, defining the number of microtiles
+        per parametric dimension.
+
+        Parameters
+        ----------
+        tiling : int / list<int>
+          Number of tiles for each dimension respectively
+        Returns
+        -------
+        None
+        """
+        if (
+            not isinstance(tiling, list)
+            and not isinstance(tiling, int)
+            and not isinstance(tiling, tuple)
+        ):
+            raise ValueError(
+                "Tiling mus be either list of integers of integer " "value"
+            )
+        self._tiling = tiling
+
+    @property
+    def unit_cell(self):
+        """Microtile that is either a spline, a list of splines, or a class
+        that provides a `create_tile` function."""
+        if hasattr(self, "_microtile"):
+            return self._microtile
+        else:
+            self._logi(
+                "microtile is empty. "
+                "Please checkout splinepy.microstructure.tiles.show() for "
+                "predefined tile collections."
+            )
+            return None
+
+    @unit_cell.setter
+    def unit_cell(self, microtile):
+        """Setter for microtile.
+
+        Microtile must be either a spline, a list of splines, or a class that
+        provides (at least) a `create_tile` function and a `dim` member.
+
+        Parameters
+        ----------
+        microtile : spline / list<splines> / user-object
+          arbitrary long list of splines that define the microtile
+
+        Returns
+        -------
+        None
+        """
+        # place single tiles into a list to provide common interface
+        if not isinstance(microtile, _SDFBase):
+            raise TypeError(f"Microtile must be SDF, not {type(microtile)}")
+        # Assign Microtile object to member variable
+        self._microtile = microtile
+
+    def _get_domain_bounds(self):
+        return self.bounds
+
+    def _compute(self, samples: _torch.Tensor):
+        """Function, that - if required - parametrizes the microtiles.
+
+        In order to use said function, the Microtile needs to provide a couple
+        of attributes:
+
+         - evaluation_points - a list of points defined in the unit cube
+           that will be evaluated in the parametrization function to provide
+           the required set of data points
+         - para_dim - dimensionality of the parametrization
+           function and number of design variables for said microtile
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+         : Callable
+          Function that describes the local tile parameters
+        """
+        if self.parametrization is not None:
+            parameters = self.parametrization(samples)
+            self.unit_cell._set_param(parameters)
+
+        queries_transformed = _torch.zeros_like(samples)
+        if self.unit_cell.geometric_dim == 2:
+            tx, ty = self._tiling
+            queries_transformed[:, 0] = transform(
+                samples[:, 0], tx, bounds=self.bounds[:, 0]
+            )
+            queries_transformed[:, 1] = transform(
+                samples[:, 1], ty, bounds=self.bounds[:, 1]
+            )
+        elif self.unit_cell.geometric_dim == 3:
+            tx, ty, tz = self._tiling
+            queries_transformed[:, 0] = transform(
+                samples[:, 0], tx, bounds=self.bounds[:, 0]
+            )
+            queries_transformed[:, 1] = transform(
+                samples[:, 1], ty, bounds=self.bounds[:, 1]
+            )
+            queries_transformed[:, 2] = transform(
+                samples[:, 2], tz, bounds=self.bounds[:, 2]
+            )
+
+        sdf_values = self.unit_cell(queries_transformed)
+
+        return sdf_values