DeepSDFStruct 1.7.2__py3-none-any.whl

tests/test_mesh_export.py

@@ -0,0 +1,137 @@
+from DeepSDFStruct.pretrained_models import get_model, PretrainedModels
+from DeepSDFStruct.SDF import SDFfromDeepSDF, SDFfromLineMesh, CappedBorderSDF
+from DeepSDFStruct.mesh import (
+    generate_2D_surf_mesh,
+    tetrahedralize_surface,
+    create_3D_mesh,
+    create_2D_mesh,
+    export_surface_mesh,
+    export_sdf_grid_vtk,
+)
+from DeepSDFStruct.lattice_structure import LatticeSDFStruct
+from DeepSDFStruct.parametrization import SplineParametrization
+from DeepSDFStruct.torch_spline import TorchSpline
+import splinepy
+import gustaf as _gus
+import torch
+
+
+def test_deepsdf_lattice_export_3D():
+    # Load a pretrained DeepSDF model
+    model = get_model(PretrainedModels.AnalyticRoundCross)
+    sdf = SDFfromDeepSDF(model)
+    torch.manual_seed(42)
+
+    # Define a spline-based deformation field
+    deformation_spline = TorchSpline(
+        splinepy.helpme.create.box(1.5, 1, 1).bspline, device=model.device
+    )
+    control_points = [
+        [0.3],
+        [0.3],
+        [0.3],
+        [0.3],
+        [0.3],
+        [0.3],
+        [0.3],
+        [0.3],
+        [0.3],
+        [0.3],
+        [0.3],
+        [0.3],
+    ]
+    param_spline = SplineParametrization(
+        splinepy.BSpline(
+            [0, 0, 0], [[0, 1 / 3, 2 / 3, 1], [0, 0.5, 1], [0, 0.5, 1]], control_points
+        ),
+        device=model.device,
+    )
+
+    # Create the lattice structure with deformation and microtile
+    lattice_struct = CappedBorderSDF(
+        LatticeSDFStruct(tiling=[3, 2, 2], microtile=sdf, parametrization=param_spline)
+    )
+    surf_mesh, derivative = create_3D_mesh(
+        lattice_struct,
+        10,
+        differentiate=True,
+        mesh_type="surface",
+        device=model.device,
+        deformation_function=deformation_spline,
+    )
+    export_surface_mesh(
+        "tests/tmp_outputs/mesh_with_derivative.vtk", surf_mesh.to_gus(), derivative
+    )
+    export_sdf_grid_vtk(lattice_struct, "tests/tmp_outputs/sdf.vtk")
+    mesh = surf_mesh.to_gus()
+    _gus.io.meshio.export("tests/tmp_outputs/faces.inp", mesh)
+    _gus.io.meshio.export("tests/tmp_outputs/faces.obj", mesh)
+
+    volumes, _ = tetrahedralize_surface(mesh)
+    _gus.io.mfem.export("tests/tmp_outputs/volumes.mfem", volumes)
+
+    # test other method to export 3D mesh:
+    volume_mesh, derivative_vols = create_3D_mesh(
+        lattice_struct, 10, differentiate=True, mesh_type="volume", device=model.device
+    )
+    _gus.io.meshio.export(
+        fname="tests/tmp_outputs/volumes.inp", mesh=volume_mesh.to_gus()
+    )
+
+
+def test_deepsdf_lattice_export_2D():
+    # Load a pretrained DeepSDF model
+    model = get_model(PretrainedModels.AnalyticRoundCross)
+    sdf = SDFfromDeepSDF(model)
+    torch.manual_seed(42)
+
+    # Define a spline-based deformation field
+    deformation_spline = TorchSpline(
+        splinepy.helpme.create.box(1.5, 1).bspline, device=model.device
+    )
+    control_points = [[0.3], [0.3], [0.3], [0.3], [0.3], [0.3]]
+    param_spline = SplineParametrization(
+        splinepy.BSpline([0, 0], [[0, 1 / 3, 2 / 3, 1], [0, 0.5, 1]], control_points),
+        device=model.device,
+    )
+
+    # Create the lattice structure with deformation and microtile
+    lattice_struct = CappedBorderSDF(
+        LatticeSDFStruct(
+            tiling=[3, 2],
+            microtile=sdf.to2D(axes=[0, 1], offset=0.5),
+            parametrization=param_spline,
+        )
+    )
+
+    surf_mesh, derivative = create_2D_mesh(
+        lattice_struct,
+        10,
+        differentiate=True,
+        mesh_type="surface",
+        device=model.device,
+        deformation_function=deformation_spline,
+    )
+    export_surface_mesh(
+        "tests/tmp_outputs/mesh2D_with_derivative.vtk", surf_mesh.to_gus(), derivative
+    )
+
+
+def test_2D_mesh_export():
+    linemesh = _gus.io.meshio.load("tests/data/example_line_mesh.vtk")
+    linemesh.vertices = linemesh.vertices[:, :2]
+
+    sdf_from_linemesh = SDFfromLineMesh(linemesh, thickness=0.5)
+    mesh = generate_2D_surf_mesh(sdf_from_linemesh, 100)
+    _gus.io.meshio.export("tests/tmp_outputs/triangles.inp", mesh)
+
+    sdf_from_linemesh = SDFfromLineMesh(linemesh, thickness=0.5, smoothness=0.1)
+    mesh = generate_2D_surf_mesh(sdf_from_linemesh, 100)
+    _gus.io.meshio.export("tests/tmp_outputs/triangles_smooth.inp", mesh)
+
+
+if __name__ == "__main__":
+    test_deepsdf_lattice_export_2D()
+    test_deepsdf_lattice_export_3D()
+
+    test_2D_mesh_export()

tests/test_mesh_functions.py

@@ -0,0 +1,49 @@
+from DeepSDFStruct.mesh import torchVolumeMesh, mergeMeshs, torchLineMesh
+import gustaf as gus
+import torch
+
+
+def test_mesh_clean() -> None:
+    gus_mesh = gus.io.meshio.load("tests/data/example_disconnectd_mesh.inp")
+    verts_tensor = torch.tensor(gus_mesh.vertices, requires_grad=True)
+    volumes_tensor = torch.tensor(gus_mesh.volumes)
+    torch_vol_mesh = torchVolumeMesh(verts_tensor, volumes_tensor)
+    torch_vol_mesh.remove_disconnected_regions()
+    vols = torch_vol_mesh.to_gus()
+    assert (
+        vols.vertices.shape[0] == 194
+    ), f"number of clean vertices should be 194, but is {vols.vertices.shape[0]}"
+    gus.io.meshio.export("tests/tmp_outputs/cleaned_mesh.inp", vols)
+
+
+def test_mesh_merge():
+    # Simple line mesh 1: two vertices, one line
+    vertices1 = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]])
+    lines1 = torch.tensor([[0, 1]])
+    mesh1 = torchLineMesh(vertices1, lines1)
+
+    # Simple line mesh 2: one duplicate vertex and one new vertex
+    vertices2 = torch.tensor([[1.0, 0.0, 0.0], [2.0, 0.0, 0.0]])
+    lines2 = torch.tensor([[0, 1]])
+    mesh2 = torchLineMesh(vertices2, lines2)
+
+    merged_mesh = mergeMeshs(mesh1, mesh2, tol=1e-8)
+    expected_vertices = torch.tensor(
+        [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [2.0, 0.0, 0.0]]
+    )
+
+    assert torch.allclose(merged_mesh.vertices, expected_vertices), "Vertices mismatch"
+    # Check merged connectivity
+    expected_lines = torch.tensor([[0, 1], [1, 2]])
+    assert torch.equal(
+        merged_mesh.lines, expected_lines
+    ), f"Line connectivity mismatch. Expected\n {expected_lines}\n got \n{merged_mesh.lines}"
+    # Check no indices exceed number of vertices
+    assert (
+        merged_mesh.lines.max().item() < merged_mesh.vertices.shape[0]
+    ), "Index out of range"
+
+
+if __name__ == "__main__":
+    test_mesh_merge()
+    test_mesh_clean()

tests/test_networks.py

@@ -0,0 +1,71 @@
+import torch
+
+from DeepSDFStruct.deep_sdf.networks.hierarchical_positional_sdf_decoder import (
+    HierachicalPositionalDeepSDFDecoder,
+)
+from DeepSDFStruct.deep_sdf.networks.hierarchical_deep_sdf_decoder import (
+    HierachicalDeepSDFDecoder,
+)
+
+
+def test_hierarchical_positional_decoder_forward():
+    batch = 4
+    latent_size = 8
+    geom_dim = 3
+    dims = [32, 16, 8]
+    # inject latent at layer 0 (before first linear)
+    latent_in = [0]
+
+    net = HierachicalPositionalDeepSDFDecoder(
+        latent_size=latent_size,
+        dims=dims,
+        geom_dimension=geom_dim,
+        latent_in=latent_in,
+        positional_encoding=False,
+        activation_fun="gelu",
+    )
+    net.eval()
+
+    lat = torch.randn(batch, latent_size)
+    xyz = torch.randn(batch, geom_dim)
+    inp = torch.cat([lat, xyz], dim=1)
+
+    with torch.no_grad():
+        out = net(inp)
+
+    assert out.shape == (batch, 1)
+
+
+def test_hierarchical_deep_decoder_forward():
+    batch = 5
+    geom_dim = 3
+    # one latent chunk of size 4 injected into layer 1
+    latent_size = [4]
+    latent_in = [1]
+    dims = [32, 16]
+
+    net = HierachicalDeepSDFDecoder(
+        latent_size=latent_size,
+        dims=dims,
+        geom_dimension=geom_dim,
+        latent_in=latent_in,
+        activation_fun="silu",
+    )
+    net.eval()
+
+    lat = torch.randn(batch, sum(latent_size))
+    xyz = torch.randn(batch, geom_dim)
+    inp = torch.cat([lat, xyz], dim=1)
+
+    with torch.no_grad():
+        out = net(inp)
+
+    # hierarchical_deep_sdf_decoder returns a raw tensor (no explicit final layer),
+    # ensure it returns per-sample outputs (batch, *) and is finite
+    assert out.shape[0] == batch
+    assert torch.isfinite(out).all()
+
+
+if __name__ == "__main__":
+    test_hierarchical_deep_decoder_forward()
+    test_hierarchical_positional_decoder_forward()

tests/test_pretrained_models.py

@@ -0,0 +1,40 @@
+from DeepSDFStruct.pretrained_models import get_model, PretrainedModels
+from DeepSDFStruct.SDF import SDFfromDeepSDF
+import torch
+
+
+def test_pretrained_model_evaluation():
+    for pt_model in PretrainedModels:
+        print(f"Testing pretrained model: {pt_model.name}")
+        model = get_model(pt_model)
+        sdf = SDFfromDeepSDF(model)
+
+        # Set the latent vector and visualize a slice of the SDF
+        sdf.set_latent_vec(model._trained_latent_vectors[0])
+
+        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_analytic_round_cross():
+
+    model = get_model(PretrainedModels.AnalyticRoundCross)
+    sdf = SDFfromDeepSDF(model)
+
+    for radius in [0.2, 0.5, 0.7]:
+        radius_tensor = torch.tensor([radius], dtype=torch.float32, device=model.device)
+        sdf.set_latent_vec(radius_tensor)
+
+        out = sdf(torch.tensor([[0, 0, 0]], dtype=torch.float32, device=model.device))
+        torch.testing.assert_close(out[0], -radius_tensor)
+
+
+if __name__ == "__main__":
+    test_pretrained_model_evaluation()
+    test_analytic_round_cross()

tests/test_reconstruction.py

@@ -0,0 +1,101 @@
+import trimesh
+from DeepSDFStruct.pretrained_models import get_model, PretrainedModels
+from DeepSDFStruct.SDF import SDFfromDeepSDF, SDFfromMesh, normalize_mesh_to_unit_cube
+from DeepSDFStruct.mesh import create_3D_mesh, export_sdf_grid_vtk, export_surface_mesh
+from DeepSDFStruct.deep_sdf.reconstruction import reconstruct_from_samples
+from DeepSDFStruct.lattice_structure import LatticeSDFStruct
+from DeepSDFStruct.parametrization import SplineParametrization
+from DeepSDFStruct.torch_spline import TorchScaling
+from DeepSDFStruct.sampling import sample_mesh_surface, random_sample_sdf
+import splinepy
+import torch
+import numpy as np
+from DeepSDFStruct.deep_sdf.metrics.mesh_to_analytical import mesh_to_analytical
+
+
+def test_shape_reconstruction():
+    model = get_model(PretrainedModels.Primitives)
+    sdf = SDFfromDeepSDF(model)
+    torch.manual_seed(42)
+
+    mesh_orig = trimesh.load_mesh("tests/data/cone.stl")
+    mesh, scale, shift = normalize_mesh_to_unit_cube(
+        mesh_orig.copy(), shrink_factor=0.9
+    )
+    bounds = torch.tensor(
+        [[-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], device=model.device, dtype=torch.float32
+    )
+    bounds = torch.tensor(mesh.bounds, device=model.device, dtype=torch.float32)
+    print("Mesh bounds:", bounds)
+    scaling = TorchScaling(
+        scale_factors=scale, translation=shift, bounds=bounds, device=model.device
+    )
+
+    tiling = [2, 2, 2]
+    param_spline_sp = splinepy.BSpline(
+        [1, 1, 1],
+        [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1]],
+        [[0.0] * model._trained_latent_vectors[0].shape[0]] * 8,
+    )
+    for i_box, n_box in enumerate(tiling):
+        knots = np.linspace(0, 1, n_box + 1)[1:-1]
+        print(f"Inserting {n_box - 1} knots at {knots} into spline dim {i_box}")
+        param_spline_sp.insert_knots(i_box, knots)
+
+    param_spline = SplineParametrization(param_spline_sp, device=model.device)
+    for p in param_spline.parameters():
+        torch.nn.init.normal_(p, mean=0.0, std=0.01)
+
+    struct = LatticeSDFStruct(
+        tiling=tiling, microtile=sdf, parametrization=param_spline, bounds=bounds
+    )
+
+    gt_sdf = SDFfromMesh(mesh, scale=False)
+
+    uniform_samples = random_sample_sdf(
+        gt_sdf,
+        bounds,
+        n_samples=5000,
+        sampling_strategy="uniform",
+        device=struct.get_device(),
+    )
+    surface_samples = sample_mesh_surface(
+        gt_sdf, mesh, n_samples=5000, stds=[0.25, 0.0001], device=struct.get_device()
+    )
+
+    SDF_samples = uniform_samples + surface_samples
+
+    recon_param = reconstruct_from_samples(
+        struct,
+        SDF_samples,
+        lr=5e-3,
+        loss_fn="ClampedL1",
+        num_iterations=50,
+        batch_size=512,
+        use_tanh_on_gt=False,
+        loss_plot_path="tests/tmp_outputs/reconstruction_loss.png",
+        optimizer_name="adam",
+        deformation_function=None,
+    )
+
+    surf_mesh, derivative = create_3D_mesh(
+        struct,
+        32,
+        differentiate=False,
+        device=model.device,
+        mesh_type="surface",
+        bounds=bounds,
+        deformation_function=scaling,
+    )
+
+    export_surface_mesh(
+        "tests/tmp_outputs/reconstructed_cone.stl", surf_mesh.to_gus(), derivative
+    )
+
+    error = mesh_to_analytical(SDFfromMesh(mesh_orig, scale=False), surf_mesh)
+    print(f"Norm of SDF error on mesh vertices: {error}")
+
+
+if __name__ == "__main__":
+
+    test_shape_reconstruction()

tests/test_sdf_from_mesh.py

@@ -0,0 +1,52 @@
+import torch
+import trimesh
+from DeepSDFStruct.SDF import SDFfromMesh
+from DeepSDFStruct.sdf_primitives import SphereSDF
+import math
+
+
+def test_icosphere_sdf_igl():
+    mesh = trimesh.creation.icosphere(subdivisions=6, radius=1.0)
+
+    sdf_sphere_from_mesh = SDFfromMesh(mesh, backend="igl", scale=False, threshold=0)
+    sdf_sphere_from_analytical = SphereSDF(center=[0, 0, 0], radius=1.0)
+    points = torch.tensor(
+        [
+            [0.0, 0.0, 0.0],
+            [0.5, 0.0, 0.0],
+            [1.0, 0.0, 0.0],
+            [1.5, 0.0, 0.0],
+            [2.0, 2.0, 2.0],
+        ],
+        dtype=torch.float32,
+    )
+
+    distances_mesh = sdf_sphere_from_mesh(points)
+    distances_analyt = sdf_sphere_from_analytical(points)
+
+    print("\n--- SDF Test Results ---")
+    for i, p in enumerate(points):
+        print(
+            f"Point {p.tolist()}: Distance Mesh {distances_mesh[i,0]:.4f} | Distance Analytical {distances_analyt[i,0]:.4f}"
+        )
+    expected_distances = torch.tensor(
+        [[-1.0], [-0.5], [0.0], [0.5], [math.sqrt(2**2 + 2**2 + 2**2) - 1]]
+    )
+    torch.testing.assert_close(
+        distances_mesh,
+        expected_distances,
+        msg="Queried distances to mesh are wrong",
+        atol=1e-4,
+        rtol=1e-4,
+    )
+    torch.testing.assert_close(
+        distances_mesh,
+        expected_distances,
+        msg="Queried analytical distances are wrong",
+        atol=1e-4,
+        rtol=1e-4,
+    )
+
+
+if __name__ == "__main__":
+    test_icosphere_sdf_igl()

tests/test_sdf_functions.py

@@ -0,0 +1,117 @@
+import gustaf as gus
+import torch
+import numpy as np
+import itertools
+import splinepy
+from DeepSDFStruct.SDF import SDFfromLineMesh, CappedBorderSDF, SDFfromMesh
+from DeepSDFStruct.mesh import export_sdf_grid_vtk, export_surface_mesh, create_3D_mesh
+from DeepSDFStruct.sdf_primitives import CrossMsSDF
+
+
+def test_sdf_from_multipatch_cubes_equivalence():
+
+    # --- define cubes ---
+    cube1 = splinepy.helpme.create.box(1.0, 1.0, 1.0)
+
+    cube2 = splinepy.helpme.create.box(1.0, 1.0, 1.0)
+    cube2.control_points[:, 0] = cube2.control_points[:, 0] + 1
+    big_cube = splinepy.helpme.create.box(2.0, 1.0, 1.0)
+
+    multipatch = splinepy.Multipatch([cube1, cube2])
+
+    n = 10
+    xs = torch.linspace(-0.5, 2.5, n)
+    ys = torch.linspace(-0.5, 1.5, n)
+    zs = torch.linspace(-0.5, 1.5, n)
+
+    queries = torch.stack(torch.meshgrid(xs, ys, zs, indexing="ij"), dim=-1).reshape(
+        -1, 3
+    )
+
+    multipatch_sdf = SDFfromMesh(multipatch.extract.faces(10))
+    big_cube_sdf = SDFfromMesh(big_cube.extract.faces(10))
+
+    vals_multipatch = multipatch_sdf(queries)
+    vals_big_cube = big_cube_sdf(queries)
+
+    torch.testing.assert_close(
+        vals_multipatch,
+        vals_big_cube,
+        atol=1e-2,
+        rtol=1e-2,
+        msg="Unified multipatch does not match single large cube",
+    )
+
+
+def test_cap_border_dict():
+    n = 11
+    xs = torch.linspace(-1.0, 1.0, n)
+    ys = torch.linspace(-1.0, 1.0, n)
+    zs = torch.linspace(-1.0, 1.0, n)
+
+    queries = torch.stack(torch.meshgrid(xs, ys, zs, indexing="ij"), dim=-1).reshape(
+        -1, 3
+    )
+
+    base_sdf = CrossMsSDF(radius=0.2)
+    export_sdf_grid_vtk(base_sdf, "sdf_nocap.vtk")
+    base_sdf_vals = base_sdf(queries)
+
+    axes = ["x", "y", "z"]
+    sides = ["0", "1"]
+    caps = [1, -1]
+
+    dim_dict = {"x": 0, "y": 1, "z": 2}
+    minstr_dict = {1: "plus", -1: "minus"}
+    measure = 0.25
+
+    for axis, side, cap in itertools.product(axes, sides, caps):
+        minstr = minstr_dict[cap]
+        name = f"{axis}{side}{caps}{minstr}"
+        key = f"{axis}{side}"
+        cap_border_dict = {key: {"cap": cap, "measure": measure}}
+
+        capped_sdf = CappedBorderSDF(base_sdf, cap_border_dict)
+        print("Evaluating capdict for cap dict")
+        print(cap_border_dict)
+        capped_sdf_vals = capped_sdf(queries)
+        export_sdf_grid_vtk(capped_sdf, f"tests/tmp_outputs/sdf_{name}.vtk")
+        surf_mesh, _ = create_3D_mesh(capped_sdf, 11, mesh_type="surface")
+        export_surface_mesh(f"tests/tmp_outputs/sdf_{name}.obj", surf_mesh.to_gus())
+        export_surface_mesh(f"tests/tmp_outputs/sdf_{name}.stl", surf_mesh.to_gus())
+        interior_low = caps[0] + measure
+        interior_high = caps[1] - measure
+
+        inside_mask = (queries[:, dim_dict[axis]] > interior_low) & (
+            queries[:, dim_dict[axis]] < interior_high
+        )
+        torch.testing.assert_close(
+            capped_sdf_vals[inside_mask],
+            base_sdf_vals[inside_mask],
+            msg=f"Inside modified for {name}, cap={cap}, measure={measure}",
+        )
+        # raise NotImplementedError("stahp")
+
+
+def test_sdf_from_linemesh():
+    linemesh = gus.io.meshio.load("tests/data/example_line_mesh.vtk")
+    linemesh.vertices = linemesh.vertices[:, :2]
+    bounds = np.array([[-9.5, 0.0], [9.5, 20.0]])
+    n_points = 100
+    x = np.linspace(bounds[0, 0], bounds[1, 0], n_points)
+    y = np.linspace(bounds[0, 1], bounds[1, 1], n_points)
+    xx, yy = np.meshgrid(x, y)
+    queries = np.hstack([xx.reshape(-1, 1), yy.reshape(-1, 1)])
+    sdf_from_linemesh = SDFfromLineMesh(linemesh, thickness=0.5)
+    sdf = sdf_from_linemesh(queries)
+    np.testing.assert_almost_equal(sdf.min(), -0.25)
+    np.testing.assert_array_compare(np.greater_equal, sdf.max(), 0)
+
+
+if __name__ == "__main__":
+    import warnings
+
+    warnings.filterwarnings("error")
+    test_sdf_from_multipatch_cubes_equivalence()
+    test_cap_border_dict()
+    test_sdf_from_linemesh()