warp-lang 1.10.0__py3-none-macosx_11_0_arm64.whl

warp/tests/geometry/test_marching_cubes.py

@@ -0,0 +1,294 @@
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import numpy as np
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+
+@wp.kernel
+def make_field_sphere_sdf(field: wp.array3d(dtype=float), center: wp.vec3, radius: float):
+    """Make a sphere SDF for nodes on the integer domain with node coordinates 0,1,2,3,..."""
+
+    i, j, k = wp.tid()
+
+    p = wp.vec3(float(i), float(j), float(k))
+
+    d = wp.length(p - center) - radius
+
+    field[i, j, k] = d
+
+
+@wp.kernel
+def make_field_sphere_sdf_unit_domain(
+    field: wp.array3d(dtype=float), center: wp.vec3, radius: wp.array(dtype=wp.float32)
+):
+    """Makes a sphere SDF for nodes on the unit domain [-1, 1]^3."""
+    i, j, k = wp.tid()
+
+    nx, ny, nz = field.shape[0], field.shape[1], field.shape[2]
+
+    p = wp.vec3(
+        2.0 * wp.float32(i) / (wp.float32(nx) - 1.0) - 1.0,
+        2.0 * wp.float32(j) / (wp.float32(ny) - 1.0) - 1.0,
+        2.0 * wp.float32(k) / (wp.float32(nz) - 1.0) - 1.0,
+    )
+
+    d = wp.length(p - center) - radius[0]
+
+    field[i, j, k] = d
+
+
+@wp.kernel
+def compute_surface_area(
+    verts: wp.array(dtype=wp.vec3), faces: wp.array(dtype=wp.int32), out_area: wp.array(dtype=wp.float32)
+):
+    tid = wp.tid()
+    vi = faces[3 * tid + 0]
+    vj = faces[3 * tid + 1]
+    vk = faces[3 * tid + 2]
+
+    p0 = verts[vi]
+    p1 = verts[vj]
+    p2 = verts[vk]
+
+    # Heron's formula for triangle area
+    a = wp.length(p1 - p0)
+    b = wp.length(p2 - p0)
+    c = wp.length(p2 - p1)
+    s = (a + b + c) / 2.0
+    area = wp.sqrt(s * (s - a) * (s - b) * (s - c))
+
+    wp.atomic_add(out_area, 0, area)
+
+
+def validate_marching_cubes_output(test, verts_np, faces_np, check_nonempty=True):
+    # check that the face array seems valid
+    if check_nonempty:
+        test.assertGreater(faces_np.shape[0], 0)  # at least one face
+    test.assertEqual(faces_np.shape[1], 3)  # all faces triangular
+    test.assertTrue((faces_np >= 0).all())  # all face inds nonnegative
+    test.assertTrue((faces_np < verts_np.shape[0]).all())  # all face inds are in-bounds on the vertex array
+    test.assertTrue((faces_np[:, 0] != faces_np[:, 1]).all())  # all faces have unique vertices
+    test.assertTrue((faces_np[:, 0] != faces_np[:, 2]).all())  # all faces have unique vertices
+    test.assertTrue((faces_np[:, 1] != faces_np[:, 2]).all())  # all faces have unique vertices
+    test.assertTrue(
+        (np.unique(faces_np.flatten()) == np.arange(verts_np.shape[0])).all()
+    )  # all vertices are used in at least one face
+
+    # check that the vertex array seems valid
+    if check_nonempty:
+        test.assertGreater(verts_np.shape[0], 0)  # at least one vertex
+    test.assertEqual(verts_np.shape[1], 3)  # all vertices are 3D
+    test.assertTrue(np.isfinite(verts_np).all())  # all vertices are finite
+
+
+def test_marching_cubes(test, device):
+    """Basic test of typical usage."""
+    node_dim = 64
+    cell_dim = node_dim - 1
+    field = wp.zeros(shape=(node_dim, node_dim, node_dim), dtype=float, device=device)
+    bounds_low = (0.0, 0.0, 0.0)
+    bounds_high = (float(cell_dim), float(cell_dim), float(cell_dim))
+
+    iso = wp.MarchingCubes(
+        nx=node_dim,
+        ny=node_dim,
+        nz=node_dim,
+        device=device,
+        domain_bounds_lower_corner=bounds_low,
+        domain_bounds_upper_corner=bounds_high,
+    )
+
+    radius = node_dim / 4.0
+
+    wp.launch(
+        make_field_sphere_sdf,
+        dim=field.shape,
+        inputs=[field, wp.vec3(node_dim / 2, node_dim / 2, node_dim / 2), radius],
+        device=device,
+    )
+
+    iso.surface(field=field, threshold=0.0)
+    verts_np = iso.verts.numpy()
+    faces_np = iso.indices.numpy().reshape(-1, 3)
+    test.assertEqual(
+        iso.indices.dtype, wp.int32
+    )  # make sure we are following Warp convention of using a flat array of indices
+    validate_marching_cubes_output(test, verts_np, faces_np)
+
+    # check that all returned vertices lie on the surface of the sphere
+    length = np.linalg.norm(verts_np - np.array([node_dim / 2, node_dim / 2, node_dim / 2]), axis=1)
+    error = np.abs(length - radius)
+    test.assertTrue(np.max(error) < 1.0)
+
+    iso.resize(nx=node_dim * 2, ny=node_dim * 2, nz=node_dim * 2)  # smoke test for deprecated function
+
+
+def test_marching_cubes_functional(test, device):
+    """Ensure the single-function interface works as expected."""
+    node_dim = 64
+    cell_dim = node_dim - 1
+    field = wp.zeros(shape=(node_dim, node_dim, node_dim), dtype=float, device=device)
+    bounds_low = (0.0, 0.0, 0.0)
+    bounds_high = (float(cell_dim), float(cell_dim), float(cell_dim))
+
+    radius = node_dim / 4.0
+    wp.launch(
+        make_field_sphere_sdf,
+        dim=field.shape,
+        inputs=[field, wp.vec3(node_dim / 2, node_dim / 2, node_dim / 2), radius],
+        device=device,
+    )
+
+    # call via the functional interface
+    verts, faces = wp.MarchingCubes.extract_surface_marching_cubes(
+        field, threshold=0.0, domain_bounds_lower_corner=bounds_low, domain_bounds_upper_corner=bounds_high
+    )
+
+    verts_np = verts.numpy()
+    faces_np = faces.numpy().reshape(-1, 3)
+    validate_marching_cubes_output(test, verts_np, faces_np)
+
+    # check that all returned vertices lie on the surface of the sphere
+    length = np.linalg.norm(verts_np - np.array([node_dim / 2, node_dim / 2, node_dim / 2]), axis=1)
+    error = np.abs(length - radius)
+    test.assertTrue(np.max(error) < 1.0)
+
+
+def test_marching_cubes_nonuniform(test, device):
+    """Test the logic for when the dimensions of the grid are not uniform."""
+
+    dimX = 64
+    dimY = 48
+    dimZ = 72
+    field = wp.zeros(shape=(dimX, dimY, dimZ), dtype=float, device=device)
+
+    bounds_low = wp.vec3(0.0, 0.0, 0.0)
+    bounds_high = wp.vec3(float(dimX), float(dimY), float(dimZ))
+
+    iso = wp.MarchingCubes(
+        nx=dimX,
+        ny=dimY,
+        nz=dimZ,
+        device=device,
+        domain_bounds_lower_corner=bounds_low,
+        domain_bounds_upper_corner=bounds_high,
+    )
+
+    radius = dimX / 4.0
+    wp.launch(
+        make_field_sphere_sdf,
+        dim=field.shape,
+        inputs=[field, wp.vec3(dimX / 2, dimY / 2, dimZ / 2), radius],
+        device=device,
+    )
+
+    iso.surface(field=field, threshold=0.0)
+    verts_np = iso.verts.numpy()
+    faces_np = iso.indices.numpy().reshape(-1, 3)
+    validate_marching_cubes_output(test, verts_np, faces_np)
+
+
+def test_marching_cubes_empty_output(test, device):
+    """Make sure we handle the empty-output case correctly."""
+
+    dim = 64
+    field = wp.zeros(shape=(dim, dim, dim), dtype=float, device=device)
+
+    iso = wp.MarchingCubes(nx=dim, ny=dim, nz=dim, device=device)
+
+    wp.launch(make_field_sphere_sdf, dim=field.shape, inputs=[field, wp.vec3(0.5, 0.5, 0.5), 0.25], device=device)
+
+    iso.surface(field=field, threshold=1000.0)  # set threshold to a large value so that no vertices are generated
+    verts_np = iso.verts.numpy()
+    faces_np = iso.indices.numpy().reshape(-1, 3)
+    validate_marching_cubes_output(test, verts_np, faces_np, check_nonempty=False)
+
+    test.assertEqual(faces_np.shape[0], 0)  # no faces
+    test.assertEqual(verts_np.shape[0], 0)  # no vertices
+
+
+def test_marching_cubes_differentiable(test, device):
+    """Check that marching cubes has reasonable gradients.
+
+    This test constructs an SDF of sphere, extracts a surface, computes its
+    surface area, and then differentiates the surface area with respect to
+    the sphere's radius.
+    """
+    node_dim = 64
+    bounds_low = wp.vec3(-1.0, -1.0, -1.0)
+    bounds_high = wp.vec3(1.0, 1.0, 1.0)
+
+    radius = 0.5
+    radius_wp = wp.full((1,), value=0.5, dtype=wp.float32, device=device, requires_grad=True)
+
+    with wp.Tape() as tape:
+        field = wp.zeros(shape=(node_dim, node_dim, node_dim), dtype=float, device=device, requires_grad=True)
+        wp.launch(
+            make_field_sphere_sdf_unit_domain,
+            dim=field.shape,
+            inputs=[field, wp.vec3(0.0, 0.0, 0.0), radius_wp],
+            device=device,
+        )
+
+        # call via the functional interface
+        verts, faces = wp.MarchingCubes.extract_surface_marching_cubes(
+            field, threshold=0.0, domain_bounds_lower_corner=bounds_low, domain_bounds_upper_corner=bounds_high
+        )
+
+        # compute surface area
+        area = wp.zeros(shape=(1,), dtype=float, device=device, requires_grad=True)
+        wp.launch(compute_surface_area, dim=faces.shape[0] // 3, inputs=[verts, faces, area], device=device)
+
+        # confirm surface area is correct vs. the analytical ground truth
+        area_np = area.numpy()[0]
+        test.assertTrue(np.abs(area_np - 4.0 * np.pi * radius * radius) < 1e-2)
+
+    # compute the gradient of the surface area with respect to the radius
+    tape.backward(area)
+
+    # confirm the gradient is correct vs. the analytical ground truth
+    grad_np = radius_wp.grad.numpy()[0]
+    test.assertTrue(np.abs(grad_np - 8.0 * np.pi * radius) < 1e-2)
+
+
+devices = get_test_devices()
+
+
+class TestMarchingCubes(unittest.TestCase):
+    def test_marching_cubes_new_del(self):
+        # test the scenario in which a MarchingCubes instance is created but not initialized before gc
+        instance = wp.MarchingCubes.__new__(wp.MarchingCubes)
+        instance.__del__()
+
+
+add_function_test(TestMarchingCubes, "test_marching_cubes", test_marching_cubes, devices=devices)
+add_function_test(TestMarchingCubes, "test_marching_cubes_functional", test_marching_cubes_functional, devices=devices)
+add_function_test(TestMarchingCubes, "test_marching_cubes_nonuniform", test_marching_cubes_nonuniform, devices=devices)
+add_function_test(
+    TestMarchingCubes, "test_marching_cubes_empty_output", test_marching_cubes_empty_output, devices=devices
+)
+add_function_test(
+    TestMarchingCubes, "test_marching_cubes_differentiable", test_marching_cubes_differentiable, devices=devices
+)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/geometry/test_mesh.py

@@ -0,0 +1,318 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import itertools
+import unittest
+
+import numpy as np
+
+import warp as wp
+from warp.tests.unittest_utils import *
+
+# fmt: off
+
+POINT_POSITIONS = (
+    ( 0.5, -0.5,  0.5),
+    (-0.5, -0.5,  0.5),
+    ( 0.5,  0.5,  0.5),
+    (-0.5,  0.5,  0.5),
+    (-0.5, -0.5, -0.5),
+    ( 0.5, -0.5, -0.5),
+    (-0.5,  0.5, -0.5),
+    ( 0.5,  0.5, -0.5),
+)
+
+# Right-hand winding order. This corresponds to USD's (and others).
+RIGHT_HANDED_FACE_VERTEX_INDICES = (
+    0, 3, 1,
+    0, 2, 3,
+    4, 7, 5,
+    4, 6, 7,
+    6, 2, 7,
+    6, 3, 2,
+    5, 1, 4,
+    5, 0, 1,
+    5, 2, 0,
+    5, 7, 2,
+    1, 6, 4,
+    1, 3, 6,
+)
+
+
+# Left-hand winding order. This corresponds to Houdini's (and others).
+LEFT_HANDED_FACE_VERTEX_INDICES = (
+    0, 1, 3,
+    0, 3, 2,
+    4, 5, 7,
+    4, 7, 6,
+    6, 7, 2,
+    6, 2, 3,
+    5, 4, 1,
+    5, 1, 0,
+    5, 0, 2,
+    5, 2, 7,
+    1, 4, 6,
+    1, 6, 3,
+)
+
+# fmt: on
+
+POINT_COUNT = 8
+VERTEX_COUNT = 36
+FACE_COUNT = 12
+
+
+@wp.kernel(enable_backward=False)
+def read_points_kernel(
+    mesh_id: wp.uint64,
+    out_points: wp.array(dtype=wp.vec3),
+):
+    tid = wp.tid()
+    mesh = wp.mesh_get(mesh_id)
+    out_points[tid] = mesh.points[tid]
+
+
+@wp.kernel(enable_backward=False)
+def read_indices_kernel(
+    mesh_id: wp.uint64,
+    out_indices: wp.array(dtype=int),
+):
+    tid = wp.tid()
+    mesh = wp.mesh_get(mesh_id)
+    out_indices[tid * 3 + 0] = mesh.indices[tid * 3 + 0]
+    out_indices[tid * 3 + 1] = mesh.indices[tid * 3 + 1]
+    out_indices[tid * 3 + 2] = mesh.indices[tid * 3 + 2]
+
+
+def test_mesh_read_properties(test, device):
+    if device.is_cpu:
+        constructors = ["sah", "median"]
+    else:
+        constructors = ["sah", "median", "lbvh"]
+
+    for constructor in constructors:
+        points = wp.array(POINT_POSITIONS, dtype=wp.vec3, device=device)
+        indices = wp.array(RIGHT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        mesh = wp.Mesh(points=points, indices=indices, bvh_constructor=constructor)
+
+        assert mesh.points.size == POINT_COUNT
+        assert mesh.indices.size == VERTEX_COUNT
+        assert int(mesh.indices.size / 3) == FACE_COUNT
+
+        out_points = wp.empty(POINT_COUNT, dtype=wp.vec3, device=device)
+        wp.launch(read_points_kernel, dim=POINT_COUNT, inputs=[mesh.id], outputs=[out_points], device=device)
+        assert_np_equal(out_points.numpy(), np.array(POINT_POSITIONS))
+
+        out_indices = wp.empty(VERTEX_COUNT, dtype=int, device=device)
+        wp.launch(read_indices_kernel, dim=FACE_COUNT, inputs=[mesh.id], outputs=[out_indices], device=device)
+        assert_np_equal(out_indices.numpy(), np.array(RIGHT_HANDED_FACE_VERTEX_INDICES))
+
+
+@wp.kernel(enable_backward=False)
+def query_point_kernel(
+    mesh_id: wp.uint64,
+    expected_sign: float,
+):
+    point = wp.vec3(0.1, 0.2, 0.3)
+    expected_pos = wp.vec3(0.1, 0.2, 0.5)
+
+    sign = float(0.0)
+    face = int(0)
+    bary_u = float(0.0)
+    bary_v = float(0.0)
+
+    wp.mesh_query_point(mesh_id, point, 1e6, sign, face, bary_u, bary_v)
+    pos = wp.mesh_eval_position(mesh_id, face, bary_u, bary_v)
+
+    wp.expect_eq(wp.sign(sign), expected_sign)
+    wp.expect_eq(face, 1)
+    wp.expect_near(wp.length(pos - expected_pos), 0.0)
+
+
+def test_mesh_query_point(test, device):
+    if device.is_cpu:
+        constructors = ["sah", "median"]
+    else:
+        constructors = ["sah", "median", "lbvh"]
+
+    for constructor in constructors:
+        points = wp.array(POINT_POSITIONS, dtype=wp.vec3, device=device)
+
+        indices = wp.array(RIGHT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        mesh = wp.Mesh(points=points, indices=indices, bvh_constructor=constructor)
+        expected_sign = -1.0
+        wp.launch(query_point_kernel, dim=1, inputs=[mesh.id, expected_sign], device=device)
+
+        indices = wp.array(LEFT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        mesh = wp.Mesh(points=points, indices=indices)
+        expected_sign = 1.0
+        wp.launch(query_point_kernel, dim=1, inputs=[mesh.id, expected_sign], device=device)
+
+
+@wp.kernel(enable_backward=False)
+def query_ray_kernel(
+    mesh_id: wp.uint64,
+    expected_sign: float,
+):
+    start = wp.vec3(0.1, 0.2, 0.3)
+    dir = wp.normalize(wp.vec3(-1.2, 2.3, -3.4))
+    expected_t = 0.557828
+    expected_pos = wp.vec3(-0.0565217, 0.5, -0.143478)
+
+    t = float(0.0)
+    bary_u = float(0.0)
+    bary_v = float(0.0)
+    sign = float(0.0)
+    normal = wp.vec3(0.0, 0.0, 0.0)
+    face = int(0)
+
+    wp.mesh_query_ray(
+        mesh_id,
+        start,
+        dir,
+        1e6,
+        t,
+        bary_u,
+        bary_v,
+        sign,
+        normal,
+        face,
+    )
+    pos = wp.mesh_eval_position(mesh_id, face, bary_u, bary_v)
+
+    wp.expect_near(t, expected_t)
+    wp.expect_near(t, wp.length(pos - start), 1e-6)
+    wp.expect_eq(wp.sign(sign), expected_sign)
+    wp.expect_eq(face, 4)
+    wp.expect_near(wp.length(pos - expected_pos), 0.0, 1e-6)
+
+
+def test_mesh_query_ray(test, device):
+    if device.is_cpu:
+        constructors = ["sah", "median"]
+    else:
+        constructors = ["sah", "median", "lbvh"]
+
+    leaf_sizes = [1, 2, 4]
+
+    for leaf_size, constructor in itertools.product(leaf_sizes, constructors):
+        points = wp.array(POINT_POSITIONS, dtype=wp.vec3, device=device)
+
+        indices = wp.array(RIGHT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        mesh = wp.Mesh(points=points, indices=indices, bvh_constructor=constructor, bvh_leaf_size=leaf_size)
+        expected_sign = -1.0
+        wp.launch(
+            query_ray_kernel,
+            dim=1,
+            inputs=[
+                mesh.id,
+                expected_sign,
+            ],
+            device=device,
+        )
+
+        indices = wp.array(LEFT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        mesh = wp.Mesh(points=points, indices=indices)
+        expected_sign = 1.0
+        wp.launch(
+            query_ray_kernel,
+            dim=1,
+            inputs=[
+                mesh.id,
+                expected_sign,
+            ],
+            device=device,
+        )
+
+
+def test_mesh_refit_graph(test, device):
+    if device.is_cpu:
+        constructors = ["sah", "median"]
+    else:
+        constructors = ["sah", "median", "lbvh"]
+
+    for constructor in constructors:
+        points = wp.array(POINT_POSITIONS, dtype=wp.vec3, device=device)
+
+        indices = wp.array(RIGHT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        mesh = wp.Mesh(points=points, indices=indices, bvh_constructor=constructor)
+
+        wp.capture_begin(device, force_module_load=False)
+        try:
+            mesh.refit()
+        finally:
+            graph = wp.capture_end(device)
+
+        # replay
+        num_iters = 10
+        for _ in range(num_iters):
+            wp.capture_launch(graph)
+
+        wp.synchronize_device(device)
+
+
+def test_mesh_exceptions(test, device):
+    # points and indices must be on same device
+    with test.assertRaises(RuntimeError):
+        points = wp.array(POINT_POSITIONS, dtype=wp.vec3, device="cpu")
+        indices = wp.array(RIGHT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        wp.Mesh(points=points, indices=indices)
+
+    # points must be vec3
+    with test.assertRaises(RuntimeError):
+        points = wp.array(POINT_POSITIONS, dtype=wp.vec3d, device=device)
+        indices = wp.array(RIGHT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        wp.Mesh(points=points, indices=indices)
+
+    # velocities must be vec3
+    with test.assertRaises(RuntimeError):
+        points = wp.array(POINT_POSITIONS, dtype=wp.vec3, device=device)
+        velocities = wp.zeros(points.shape, dtype=wp.vec3d, device=device)
+        indices = wp.array(RIGHT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        wp.Mesh(points=points, indices=indices, velocities=velocities)
+
+    # indices must be int32
+    with test.assertRaises(RuntimeError):
+        points = wp.array(POINT_POSITIONS, dtype=wp.vec3, device=device)
+        indices = wp.array(RIGHT_HANDED_FACE_VERTEX_INDICES, dtype=wp.int64, device=device)
+        wp.Mesh(points=points, indices=indices)
+
+    # indices must be 1d
+    with test.assertRaises(RuntimeError):
+        points = wp.array(POINT_POSITIONS, dtype=wp.vec3, device=device)
+        indices = wp.array(RIGHT_HANDED_FACE_VERTEX_INDICES, dtype=int, device=device)
+        indices = indices.reshape((3, -1))
+        wp.Mesh(points=points, indices=indices)
+
+
+devices = get_test_devices()
+
+
+class TestMesh(unittest.TestCase):
+    def test_mesh_new_del(self):
+        # test the scenario in which a mesh is created but not initialized before gc
+        instance = wp.Mesh.__new__(wp.Mesh)
+        instance.__del__()
+
+
+add_function_test(TestMesh, "test_mesh_read_properties", test_mesh_read_properties, devices=devices)
+add_function_test(TestMesh, "test_mesh_query_point", test_mesh_query_point, devices=devices)
+add_function_test(TestMesh, "test_mesh_query_ray", test_mesh_query_ray, devices=devices)
+add_function_test(TestMesh, "test_mesh_refit_graph", test_mesh_refit_graph, devices=get_selected_cuda_test_devices())
+add_function_test(TestMesh, "test_mesh_exceptions", test_mesh_exceptions, devices=get_selected_cuda_test_devices())
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)