DeepSDFStruct 1.7.2__py3-none-any.whl

tests/test_DOE.py

@@ -0,0 +1,49 @@
+from DeepSDFStruct.design_of_experiments import run_experiment, ExperimentSpecifications
+from huggingface_hub import snapshot_download
+from huggingface_hub.utils import HfHubHTTPError
+import time
+
+
+def snapshot_download_with_retry(*args, max_retries=3, **kwargs):
+    """Download with retry on 429 rate limit errors."""
+    for attempt in range(max_retries):
+        try:
+            return snapshot_download(*args, **kwargs)
+        except HfHubHTTPError as e:
+            if e.response and e.response.status_code == 429:
+                if attempt < max_retries - 1:
+                    wait_time = 60 * (attempt + 1)
+                    print(
+                        f"Rate limited (429). Waiting {wait_time}s before retry {attempt + 2}/{max_retries}"
+                    )
+                    time.sleep(wait_time)
+                else:
+                    raise
+            raise
+
+
+def test_DOE():
+    data_dir = snapshot_download_with_retry(
+        "mkofler/lattice_structure_unit_cells",
+        repo_type="dataset",
+        revision="b80339abc071df77ff81e8abc19ad4856d96ddbd",
+    )
+    specs = ExperimentSpecifications(
+        "DeepSDFStruct/trained_models/test_experiment/specs.json"
+    )
+    # Define hyperparameter grid / overrides
+    tuning_params = [
+        {"NetworkSpecs": {"latent_in": [2], "dropout_prob": 0.2}},
+        {"NetworkSpecs": {"latent_in": [3], "dropout_prob": 0.3}},
+        {"NetworkSpecs": {"latent_in": [4], "dropout_prob": 0.4}},
+    ]
+
+    # Run experiments
+    for i, overrides in enumerate(tuning_params):
+        specs.update(overrides)
+        exp_name = f"run_{i}"
+        run_experiment(exp_name, data_dir, specs=specs, device="cpu")
+
+
+if __name__ == "__main__":
+    test_DOE()

tests/test_elongate_sdf.py

@@ -0,0 +1,195 @@
+"""
+Test ElongateSDF and wrapper SDFs with SmoothUnion operations.
+
+This test ensures that wrapper SDFs properly preserve tensor shapes
+when used in combination with SmoothUnionSDF and other composite operations.
+"""
+
+import pytest
+import torch
+from DeepSDFStruct.SDF import SmoothUnionSDF, UnionSDF
+from DeepSDFStruct.sdf_operations import (
+    ElongateSDF,
+    TwistSDF,
+    BendLinearSDF,
+    BendRadialSDF,
+    DilateSDF,
+    ErodeSDF,
+    ShellSDF,
+    MirrorSDF,
+)
+from DeepSDFStruct.sdf_primitives import SphereSDF, RoundedBoxSDF, CapsuleSDF
+
+
+class TestElongateSDF:
+    """Test ElongateSDF wrapper."""
+
+    def test_basic_elongate(self):
+        """Test basic ElongateSDF functionality."""
+        sphere = SphereSDF(center=[0, 0, 0], radius=0.5)
+        elongated = ElongateSDF(sphere, size=[0.5, 0.5, 0.5])
+
+        queries = torch.randn(100, 3)
+        result = elongated(queries)
+
+        assert result.shape == (100, 1), f"Expected shape (100, 1), got {result.shape}"
+        assert torch.isfinite(result).all(), "Result contains NaN or Inf"
+
+    def test_elongate_with_smooth_union(self):
+        """Test ElongateSDF in SmoothUnion - reproduces the original bug."""
+        sphere = SphereSDF(center=[0, 0, 0], radius=0.3)
+        elongated_sphere = ElongateSDF(sphere, size=[0.5, 0.2, 0.2])
+        capsule = CapsuleSDF(point_a=[1.0, 0, 0], point_b=[1.5, 0, 0], radius=0.2)
+        box = RoundedBoxSDF(center=[-1.0, 0, 0], extents=[0.5, 0.5, 0.5], radius=0.1)
+
+        smooth_union = SmoothUnionSDF(elongated_sphere, capsule, box, k=0.1)
+
+        queries = torch.randn(1000, 3)
+        result = smooth_union(queries)
+
+        assert result.shape == (
+            1000,
+            1,
+        ), f"Expected shape (1000, 1), got {result.shape}"
+        assert torch.isfinite(result).all(), "Result contains NaN or Inf"
+
+    def test_elongate_shape_preservation(self):
+        """Test that ElongateSDF preserves input tensor shape."""
+        sphere = SphereSDF(center=[0, 0, 0], radius=0.5)
+        elongated = ElongateSDF(sphere, size=[0.3, 0.3, 0.3])
+
+        for n_points in [1, 10, 100, 1000, 41616]:
+            queries = torch.randn(n_points, 3)
+            result = elongated(queries)
+            assert result.shape == (
+                n_points,
+                1,
+            ), f"Shape mismatch for {n_points} points: expected ({n_points}, 1), got {result.shape}"
+
+    def test_elongate_gradient_flow(self):
+        """Test that gradients flow through ElongateSDF."""
+        sphere = SphereSDF(center=[0, 0, 0], radius=0.5)
+        elongated = ElongateSDF(sphere, size=[0.3, 0.3, 0.3])
+
+        queries = torch.randn(100, 3, requires_grad=True)
+        result = elongated(queries)
+        loss = result.sum()
+        loss.backward()
+
+        assert queries.grad is not None, "Gradients not computed"
+        assert torch.isfinite(queries.grad).all(), "Gradients contain NaN or Inf"
+
+
+class TestWrapperSDFsWithSmoothUnion:
+    """Test various wrapper SDFs with SmoothUnion."""
+
+    def test_twist_sdf_smooth_union(self):
+        """Test TwistSDF in SmoothUnion."""
+        sphere = SphereSDF(center=[0, 0, 0], radius=0.5)
+        twisted = TwistSDF(sphere, k=0.5)
+        box = RoundedBoxSDF(center=[1.0, 0, 0], extents=[0.3, 0.3, 0.3], radius=0.05)
+
+        smooth_union = SmoothUnionSDF(twisted, box, k=0.1)
+
+        queries = torch.randn(500, 3)
+        result = smooth_union(queries)
+
+        assert result.shape == (500, 1), f"Expected shape (500, 1), got {result.shape}"
+        assert torch.isfinite(result).all(), "Result contains NaN or Inf"
+
+    def test_bend_linear_sdf_smooth_union(self):
+        """Test BendLinearSDF in SmoothUnion."""
+        sphere = SphereSDF(center=[0, 0, 0], radius=0.3)
+        bent = BendLinearSDF(sphere, p0=[0, 0, 0], p1=[0, 0, 1], v=[0.1, 0, 0])
+        capsule = CapsuleSDF(point_a=[0.5, 0, 0], point_b=[1.0, 0, 0], radius=0.2)
+
+        smooth_union = SmoothUnionSDF(bent, capsule, k=0.1)
+
+        queries = torch.randn(500, 3)
+        result = smooth_union(queries)
+
+        assert result.shape == (500, 1), f"Expected shape (500, 1), got {result.shape}"
+        assert torch.isfinite(result).all(), "Result contains NaN or Inf"
+
+    def test_dilate_sdf_smooth_union(self):
+        """Test DilateSDF in SmoothUnion."""
+        sphere = SphereSDF(center=[0, 0, 0], radius=0.3)
+        dilated = DilateSDF(sphere, r=0.1)
+        box = RoundedBoxSDF(center=[0.8, 0, 0], extents=[0.3, 0.3, 0.3], radius=0.05)
+
+        smooth_union = SmoothUnionSDF(dilated, box, k=0.1)
+
+        queries = torch.randn(500, 3)
+        result = smooth_union(queries)
+
+        assert result.shape == (500, 1), f"Expected shape (500, 1), got {result.shape}"
+        assert torch.isfinite(result).all(), "Result contains NaN or Inf"
+
+    def test_mirror_sdf_smooth_union(self):
+        """Test MirrorSDF in SmoothUnion."""
+        sphere = SphereSDF(center=[0.5, 0.5, 0], radius=0.3)
+        mirrored = MirrorSDF(sphere, plane_point=[0, 0, 0], plane_normal=[1, 0, 0])
+        capsule = CapsuleSDF(point_a=[0, 0, 0], point_b=[0, 1, 0], radius=0.2)
+
+        smooth_union = SmoothUnionSDF(mirrored, capsule, k=0.1)
+
+        queries = torch.randn(500, 3)
+        result = smooth_union(queries)
+
+        assert result.shape == (500, 1), f"Expected shape (500, 1), got {result.shape}"
+        assert torch.isfinite(result).all(), "Result contains NaN or Inf"
+
+
+class TestFormula1CarScenario:
+    """Test the specific scenario from the bug report - Formula 1 car chassis."""
+
+    def test_main_chassis_smooth_union(self):
+        """Test MainChassis configuration from bug report."""
+        rounded_box = RoundedBoxSDF(
+            center=[0, 0, 0.4], extents=[2.5, 0.8, 0.5], radius=0.15
+        )
+        elongated = ElongateSDF(rounded_box, size=[2.5, 0.4, 0.3])
+
+        capsule = CapsuleSDF(point_a=[1.5, 0, 0.3], point_b=[2.5, 0, 0.3], radius=0.25)
+
+        rounded_box2 = RoundedBoxSDF(
+            center=[-1.5, 0, 0.5], extents=[1.5, 0.7, 0.4], radius=0.1
+        )
+
+        smooth_union = SmoothUnionSDF(elongated, capsule, rounded_box2, k=0.1)
+
+        queries = torch.randn(41616, 3)
+        result = smooth_union(queries)
+
+        assert result.shape == (
+            41616,
+            1,
+        ), f"Expected shape (41616, 1), got {result.shape}"
+        assert torch.isfinite(result).all(), "Result contains NaN or Inf"
+
+    def test_side_pod_smooth_union(self):
+        """Test SidePod configuration from bug report."""
+        rounded_box = RoundedBoxSDF(
+            center=[-0.5, 0.55, 0.35], extents=[1.2, 0.35, 0.35], radius=0.12
+        )
+
+        from DeepSDFStruct.sdf_primitives import CappedConeSDF
+
+        capped_cone = CappedConeSDF(
+            point_a=[0.5, 0.55, 0.35], point_b=[-1.2, 0.55, 0.35], ra=0.25, rb=0.15
+        )
+
+        smooth_union = SmoothUnionSDF(rounded_box, capped_cone, k=0.15)
+
+        queries = torch.randn(1000, 3)
+        result = smooth_union(queries)
+
+        assert result.shape == (
+            1000,
+            1,
+        ), f"Expected shape (1000, 1), got {result.shape}"
+        assert torch.isfinite(result).all(), "Result contains NaN or Inf"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/test_flexisquares.py

@@ -0,0 +1,187 @@
+from DeepSDFStruct.sdf_primitives import CircleSDF, RectangleSDF
+from DeepSDFStruct.flexisquares.flexisquares import FlexiSquares
+from DeepSDFStruct.torch_spline import TorchSpline
+from DeepSDFStruct.pretrained_models import get_model, PretrainedModels
+from DeepSDFStruct.SDF import (
+    SDFfromDeepSDF,
+    CappedBorderSDF,
+    SDFfromLineMesh,
+    DifferenceSDF,
+)
+from DeepSDFStruct.lattice_structure import LatticeSDFStruct
+from DeepSDFStruct.parametrization import Constant
+from DeepSDFStruct.mesh import create_2D_mesh
+import numpy as np
+import gustaf as gus
+import splinepy
+import torch
+
+
+def test_flexisquares_linemesh_diag_and_straight():
+    linemesh = gus.Edges(
+        vertices=np.array([[-1, -1], [1, 1], [1, -1]]), edges=np.array([[0, 1], [1, 2]])
+    )
+    thickness = 0.4
+    rectangle = RectangleSDF(center=[0, 0], extents=[3.9, 3.9])
+    sdf_linemesh = SDFfromLineMesh(linemesh, thickness=thickness)
+    sdf = DifferenceSDF(rectangle, sdf_linemesh)
+    bounds = torch.tensor([[-2.0, -2.0], [2.0, 2.0]])
+    mesh, _ = create_2D_mesh(sdf, 10, mesh_type="surface", bounds=bounds)
+    mesh.export("linemesh.vtk")
+
+
+def test_flexisquares_linemesh_diag1():
+    linemesh = gus.Edges(
+        vertices=np.array([[-2, -2], [2, 2]]), edges=np.array([[0, 1]])
+    )
+    thickness = 0.4
+    rectangle = RectangleSDF(center=[0, 0], extents=[3.9, 3.9])
+    sdf_linemesh = SDFfromLineMesh(linemesh, thickness=thickness)
+    sdf = DifferenceSDF(rectangle, sdf_linemesh)
+    bounds = torch.tensor([[-2.0, -2.0], [2.0, 2.0]])
+    mesh, _ = create_2D_mesh(sdf, 2, mesh_type="surface", bounds=bounds)
+    torch.testing.assert_close(
+        mesh.vertices,
+        torch.tensor(
+            [
+                [-1.2913, 0.1414],
+                [-1.2913, 1.2913],
+                [0.1414, -1.2913],
+                [-0.5253, -0.5253],
+                [0.5253, 0.5253],
+                [-0.1414, 1.2913],
+                [1.2913, -1.2913],
+                [1.2913, -0.1414],
+                [-0.5486, 0.5486],
+                [0.5486, -0.5486],
+            ]
+        ),
+        rtol=1e-4,
+        atol=1e-4,
+    )
+
+
+def test_flexisquares_linemesh_diag2():
+    linemesh = gus.Edges(
+        vertices=np.array([[-2, 2], [2, -2]]), edges=np.array([[0, 1]])
+    )
+    thickness = 0.4
+    rectangle = RectangleSDF(center=[0, 0], extents=[3.9, 3.9])
+    sdf_linemesh = SDFfromLineMesh(linemesh, thickness=thickness)
+    sdf = DifferenceSDF(rectangle, sdf_linemesh)
+    bounds = torch.tensor([[-2.0, -2.0], [2.0, 2.0]])
+    mesh, _ = create_2D_mesh(sdf, 2, mesh_type="surface", bounds=bounds)
+    torch.testing.assert_close(
+        mesh.vertices,
+        torch.tensor(
+            [
+                [-1.2913, -1.2913],
+                [-1.2913, -0.1414],
+                [-0.1414, -1.2913],
+                [-0.5253, 0.5253],
+                [0.5253, -0.5253],
+                [0.1414, 1.2913],
+                [1.2913, 0.1414],
+                [1.2913, 1.2913],
+                [-0.5486, -0.5486],
+                [0.5486, 0.5486],
+            ]
+        ),
+        rtol=1e-4,
+        atol=1e-4,
+    )
+
+
+def test_flexisquares_simple():
+    circle_sdf = CircleSDF(center=(0.0, 0.0), radius=0.5)
+    bounds = torch.tensor([[-1, -1], [1, 1]])
+    fsq = FlexiSquares(device=bounds.device)
+    verts, square_idx = fsq.construct_voxel_grid([10, 10], bounds=bounds)
+    # this function is useful to plot the squares (voxels)
+    # for square in square_idx:
+    #     indices = square.index_select(0, torch.tensor([0, 1, 3, 2, 0]))
+    #     ax.plot(verts[indices][:, 0], verts[indices][:, 1], color="black", lw=0.3)
+    scalar_field = circle_sdf(verts)
+    vd_surf, edges, L_dev = fsq(verts, scalar_field, square_idx)
+    vd_surf_and_interior, faces, L_dev = fsq(
+        verts, scalar_field, square_idx, output_tetmesh=True
+    )
+    # check that the first vertices are the boundary vertices:
+    assert (
+        vd_surf.shape[0] == 20
+    ), f"Expected 20 surface vertices, got {vd_surf.shape[0]}"
+    torch.testing.assert_close(vd_surf, vd_surf_and_interior[:20])
+    assert (
+        circle_sdf(vd_surf).abs() < 0.05
+    ).all(), "Signed Distance Function not close to zero at border vertices"
+    assert (circle_sdf(vd_surf) < 0.05).all(), "Some interior nodes are positive"
+    mesh, _ = create_2D_mesh(circle_sdf, 40, mesh_type="surface", bounds=bounds)
+    try:
+        mesh, _ = create_2D_mesh(circle_sdf, 40, mesh_type="surface")
+        raise ValueError(
+            "This test should raise an error, because the bounds are not correct"
+        )
+    except RuntimeError as rError:
+        print(f"The test correctly raised the runtimeerror {rError} ✅️")
+    mesh.export("tests/tmp_outputs/circle_mesh.vtk")
+
+
+def test_flexisquares_lattice_struct():
+    model = get_model(PretrainedModels.AnalyticRoundCross)
+    sdf = SDFfromDeepSDF(model)
+
+    # Define a spline-based deformation field
+    deformation_spline = TorchSpline(
+        splinepy.helpme.create.box(2, 1).bspline, device=model.device
+    )
+
+    # Create the lattice structure with deformation and microtile
+    lattice_struct = CappedBorderSDF(
+        LatticeSDFStruct(
+            tiling=(6, 3),
+            microtile=sdf.to2D(axes=[0, 1], offset=0.5),
+            parametrization=Constant([0.5], device=model.device),
+        )
+    )
+    bounds = torch.tensor([[-0.05, -0.05], [1.05, 1.05]], device=model.device)
+    fsq = FlexiSquares(device=model.device)
+    verts, square_idx = fsq.construct_voxel_grid([60, 30], bounds=bounds)
+    scalar_field = lattice_struct(verts) + 0.01
+
+    vd_surf, edges, L_dev = fsq(verts, scalar_field, square_idx)
+
+    vd_surf_and_interior, faces, L_dev = fsq(
+        verts, scalar_field, square_idx, output_tetmesh=True
+    )
+
+    assert (lattice_struct(vd_surf) < 0.1).all(), "Some interior nodes are positive"
+
+    # check if deformation spline works on extracted mesh
+    vd = deformation_spline(vd_surf_and_interior)
+    vd_surf_and_interior_manual = vd_surf_and_interior
+    vd_surf_and_interior_manual[:, 0] = vd_surf_and_interior[:, 0] * 2
+    torch.testing.assert_close(vd, vd_surf_and_interior_manual)
+
+
+def test_near_zero_epsilon():
+    """
+    Test edge case where scalar values are exactly 0 or very close to it.
+    This often causes division by zero in interpolation if not handled.
+    """
+    fsq = FlexiSquares(device="cpu")
+    verts = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]])
+    square_idx = torch.tensor([[0, 1, 2, 3]])
+
+    # Exactly zero on two corners
+    scalar_field = torch.tensor([0.0, 0.0, 1.0, 1.0])
+
+    vd, edges, _ = fsq(verts, scalar_field, square_idx)
+
+
+if __name__ == "__main__":
+    test_flexisquares_linemesh_diag_and_straight()
+    test_flexisquares_linemesh_diag1()
+    test_flexisquares_linemesh_diag2()
+    test_flexisquares_simple()
+    test_near_zero_epsilon()
+    test_flexisquares_lattice_struct()

tests/test_generate_dataset.py

@@ -0,0 +1,76 @@
+import numpy as np
+from DeepSDFStruct.sampling import SDFSampler, augment_by_FFD
+from DeepSDFStruct.splinepy_unitcells.chi_3D import Chi3D
+from DeepSDFStruct.splinepy_unitcells.cross_lattice import CrossLattice
+import splinepy
+import multiprocessing as mp
+import pytest
+import pathlib
+
+
+@pytest.fixture(scope="session", autouse=True)
+def set_mp_start_method():
+    mp.set_start_method("spawn", force=True)
+
+
+def test_generate_dataset_from_obj_files():
+    outdir = "./training_data"
+    splitdir = "./training_data/splits"
+    dataset_name = "furniture"
+
+    sdf_sampler = SDFSampler(outdir, splitdir, dataset_name, overwrite_existing=True)
+    meshs = sdf_sampler.get_meshs_from_folder(
+        foldername="./tests/data/chairs", mesh_type="obj"
+    )
+    meshs_augment = augment_by_FFD(meshs)
+    sdf_sampler.add_class(meshs_augment, class_name="chairs")
+
+    sdf_sampler.process_geometries(
+        sampling_strategy="uniform",
+        add_surface_samples=True,
+        also_save_vtk=True,
+        n_samples=10,
+    )
+
+    sdf_sampler.write_json("chairs_train.json")
+
+
+@pytest.mark.parametrize("n_workers", [0, 1])
+def test_generate_dataset(n_workers, tmp_path):
+    outdir = tmp_path / "training_data"
+    splitdir = tmp_path / "training_data/splits"
+    dataset_name = "microstructure"
+
+    sdf_sampler = SDFSampler(outdir, splitdir, dataset_name, overwrite_existing=True)
+
+    t_start = 0.1 * np.sqrt(2) / 2
+    t_end = 0.15 * np.sqrt(2) / 2
+    crosslattice_tiles = []
+    for t in np.linspace(t_start, t_end, 3):
+        tile, _ = CrossLattice().create_tile(np.array([[t]]), make3D=True)
+        crosslattice_tiles.append(splinepy.Multipatch(tile))
+
+    chi = Chi3D()
+    chi_tiles = []
+
+    for phi in np.linspace(0, -np.pi / 6, 2):
+        for x2 in np.linspace(-0.1, 0.2, 2):
+            t = 0.1
+            x1 = 0.2
+            r = 0.5 * t
+            tile, _ = chi.create_tile(np.array([[phi, t, x1, x2, r]] * 5))
+            chi_tiles.append(splinepy.Multipatch(tile))
+
+    sdf_sampler.add_class(chi_tiles, class_name="Chi3D_center", n_faces=3)
+    sdf_sampler.add_class(crosslattice_tiles, class_name="CrossLattice", n_faces=3)
+
+    sdf_sampler.process_geometries(
+        sampling_strategy="uniform", n_workers=n_workers, n_samples=10
+    )
+
+    sdf_sampler.write_json("chi_and_cross.json")
+
+
+if __name__ == "__main__":
+    test_generate_dataset_from_obj_files()
+    test_generate_dataset(n_workers=1, tmp_path=pathlib.Path("."))

tests/test_lattice_evaluation.py

@@ -0,0 +1,137 @@
+from DeepSDFStruct.local_shapes import LocalShapesSDF
+from DeepSDFStruct.pretrained_models import get_model, PretrainedModels
+from DeepSDFStruct.SDF import SDFfromDeepSDF, _cap_outside_of_unitcube
+from DeepSDFStruct.lattice_structure import LatticeSDFStruct
+from DeepSDFStruct.parametrization import Constant
+from DeepSDFStruct.torch_spline import TorchSpline
+import splinepy
+import torch
+import matplotlib.pyplot as plt
+
+
+def test_deepsdf_evaluation():
+    # Load a pretrained DeepSDF model
+    model = get_model(PretrainedModels.ChiAndCross)
+    sdf = SDFfromDeepSDF(model)
+
+    # Set the latent vector and visualize a slice of the SDF
+    sdf.set_latent_vec(
+        torch.tensor([0.3, 0.3], dtype=torch.float32, device=model.device)
+    )
+
+    out = sdf(
+        torch.tensor(
+            [[0, 0, 0], [0, 1, 0], [0.5, 0.5, 0.5]],
+            dtype=torch.float32,
+            device=model.device,
+        )
+    )
+    print(out)
+
+
+def test_deepsdf_lattice_evaluation():
+    # Load a pretrained DeepSDF model
+    model = get_model(PretrainedModels.AnalyticRoundCross)
+    sdf = SDFfromDeepSDF(model)
+
+    # Define a spline-based deformation field
+    deformation_spline = TorchSpline(
+        splinepy.helpme.create.box(1, 1, 1).bspline, device=model.device
+    )
+
+    # Create the lattice structure with deformation and microtile
+    lattice_struct = LatticeSDFStruct(
+        tiling=(1, 1, 1),
+        microtile=sdf,
+        parametrization=Constant([0.5], device=model.device),
+    )
+
+    out = lattice_struct(
+        torch.tensor(
+            [[0, 0, 0], [0, 1, 0], [0.5, 0.5, 0.5]],
+            dtype=torch.float32,
+            device=model.device,
+        )
+    )
+    fig, axs = plt.subplots(1, 3)
+    lattice_struct.plot_slice(
+        origin=(0, 0.5, 0),
+        normal=(0, 1, 0),
+        ax=axs[0],
+        show_zero_level=True,
+        res=(300, 300),
+        deformation_function=deformation_spline,
+    )
+    print(out)
+
+
+def test_lattice_local_shapes_comparison():
+    # Load a pretrained DeepSDF model
+    model = get_model(PretrainedModels.AnalyticRoundCross)
+    sdf = SDFfromDeepSDF(model)
+
+    # Create the lattice structure with deformation and microtile
+    lattice_struct = LatticeSDFStruct(
+        tiling=(2, 1, 1),
+        microtile=sdf,
+        parametrization=Constant([0.5], device=model.device),
+    )
+
+    test_input_param_domain = torch.tensor(
+        [[0, 0, 0], [0, 1, 0], [0.5, 0.5, 0.5]],
+        dtype=torch.float32,
+        device=model.device,
+    )
+
+    out_latt = lattice_struct(test_input_param_domain)
+
+    local_shape_sdf = LocalShapesSDF(
+        tiling=(2, 1, 1),
+        unit_cell=sdf,
+        parametrization=Constant([0.5], device=model.device),
+        bounds=torch.tensor([[0, 0, 0], [2, 1, 1]]),
+    )
+
+    out_ls = local_shape_sdf(test_input_param_domain)
+
+    torch.testing.assert_close(out_latt, out_ls)
+
+
+def test_cap_outside_unitcube():
+
+    samples = torch.tensor(
+        [
+            [1.1, 0.0, 0.0],
+            [-0.1, 0.0, 0.0],
+            [0.0, 1.1, 0.0],
+            [0.0, -0.1, 0.0],
+            [0.0, 0.0, 1.1],
+            [0.0, 0.0, -0.1],
+            [0.1, 0.1, 0.1],
+            [0.9, 0.9, 0.9],
+            [0.0, 0.0, 0.0],
+        ],
+        dtype=torch.float32,
+    )
+    # true = inside, false = outside
+    labels = [False, False, False, False, False, False, True, True]
+
+    # Initial SDF values: all negative (e.g., "inside")
+    sdf_values = torch.tensor([[-0.5]] * samples.shape[0], dtype=torch.float32)
+
+    capped_sdf = _cap_outside_of_unitcube(samples, sdf_values.clone())
+
+    # Check that the SDF is capped (increased) for points outside the cube
+    for sample, sdf_value, label in zip(samples, capped_sdf, labels):
+        if sdf_value < 1e-10:
+            continue
+        assertion = (sdf_value < 0) == label
+        assert assertion, f"Incorrect capping on valid sample {sample}"
+    assert capped_sdf[-1] < 1e10, "Point on the boundary is wrong"
+
+
+if __name__ == "__main__":
+    test_deepsdf_evaluation()
+    test_lattice_local_shapes_comparison()
+    test_cap_outside_unitcube()
+    test_deepsdf_lattice_evaluation()