warp-lang 1.9.1__py3-none-win_amd64.whl → 1.10.0rc2__py3-none-win_amd64.whl

warp/tests/sim/test_coloring.py

@@ -1,347 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024 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 numpy as np
-
-import warp as wp
-import warp.examples
-import warp.sim
-from warp.sim.graph_coloring import (
-    ColoringAlgorithm,
-    construct_trimesh_graph_edges,
-    convert_to_color_groups,
-    validate_graph_coloring,
-)
-from warp.tests.unittest_utils import *
-
-
-def color_lattice_grid(num_x, num_y):
-    colors = []
-    for _ in range(4):
-        colors.append([])
-
-    for xi in range(num_x + 1):
-        for yi in range(num_y + 1):
-            node_dx = yi * (num_x + 1) + xi
-
-            a = 1 if xi % 2 else 0
-            b = 1 if yi % 2 else 0
-
-            c = b * 2 + a
-
-            colors[c].append(node_dx)
-
-    color_groups = [np.array(group) for group in colors]
-
-    return color_groups
-
-
-def create_lattice_grid(N):
-    size = 10
-    position = (0, 0)
-
-    X = np.linspace(-0.5 * size + position[0], 0.5 * size + position[0], N)
-    Y = np.linspace(-0.5 * size + position[1], 0.5 * size + position[1], N)
-
-    X, Y = np.meshgrid(X, Y)
-
-    Z = []
-    for _i in range(N):
-        Z.append(np.linspace(0, size, N))
-
-    Z = np.array(Z)
-
-    vs = []
-    for i, j in itertools.product(range(N), range(N)):
-        vs.append(wp.vec3((X[i, j], Y[i, j], Z[i, j])))
-
-    fs = []
-    for i, j in itertools.product(range(0, N - 1), range(0, N - 1)):
-        vId = j + i * N
-
-        if (j + i) % 2:
-            fs.extend(
-                [
-                    vId,
-                    vId + N + 1,
-                    vId + 1,
-                ]
-            )
-            fs.extend(
-                [
-                    vId,
-                    vId + N,
-                    vId + N + 1,
-                ]
-            )
-        else:
-            fs.extend(
-                [
-                    vId,
-                    vId + N,
-                    vId + 1,
-                ]
-            )
-            fs.extend(
-                [
-                    vId + N,
-                    vId + N + 1,
-                    vId + 1,
-                ]
-            )
-
-    return vs, fs
-
-
-def test_coloring_corner_case(test, device):
-    builder_1 = wp.sim.ModelBuilder()
-    builder_1.color()
-    test.assertTrue(len(builder_1.particle_color_groups) == 0)
-
-    builder_2 = wp.sim.ModelBuilder()
-    builder_2.add_particle(pos=wp.vec3(0, 0, 0), vel=wp.vec3(0, 0, 0), mass=1.0)
-    builder_2.add_particle(pos=wp.vec3(1, 0, 0), vel=wp.vec3(0, 0, 0), mass=1.0)
-    builder_2.color()
-    test.assertTrue(len(builder_2.particle_color_groups) == 1)
-    test.assertTrue(builder_2.particle_color_groups[0].shape[0] == 2)
-
-
-@unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
-def test_coloring_trimesh(test, device):
-    from pxr import Usd, UsdGeom
-
-    with wp.ScopedDevice(device):
-        usd_stage = Usd.Stage.Open(os.path.join(wp.examples.get_asset_directory(), "bunny.usd"))
-        usd_geom = UsdGeom.Mesh(usd_stage.GetPrimAtPath("/root/bunny"))
-
-        vertices = np.array(usd_geom.GetPointsAttr().Get())
-        faces = np.array(usd_geom.GetFaceVertexIndicesAttr().Get())
-
-        builder = wp.sim.ModelBuilder()
-
-        builder.add_cloth_mesh(
-            pos=wp.vec3(0.0, 0.0, 0.0),
-            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
-            scale=1.0,
-            vertices=[wp.vec3(p) for p in vertices],
-            indices=faces.flatten(),
-            vel=wp.vec3(0.0, 0.0, 0.0),
-            density=0.02,
-        )
-
-        model = builder.finalize()
-
-        particle_colors = wp.empty(shape=(model.particle_count), dtype=int, device="cpu")
-
-        edge_indices_cpu = wp.array(model.edge_indices.numpy()[:, 2:], dtype=int, device="cpu")
-
-        # coloring without bending
-        num_colors_greedy = wp.context.runtime.core.wp_graph_coloring(
-            model.particle_count,
-            edge_indices_cpu.__ctype__(),
-            ColoringAlgorithm.GREEDY.value,
-            particle_colors.__ctype__(),
-        )
-        wp.launch(
-            kernel=validate_graph_coloring,
-            inputs=[edge_indices_cpu, particle_colors],
-            dim=edge_indices_cpu.shape[0],
-            device="cpu",
-        )
-
-        num_colors_mcs = wp.context.runtime.core.wp_graph_coloring(
-            model.particle_count,
-            edge_indices_cpu.__ctype__(),
-            ColoringAlgorithm.MCS.value,
-            particle_colors.__ctype__(),
-        )
-        wp.launch(
-            kernel=validate_graph_coloring,
-            inputs=[edge_indices_cpu, particle_colors],
-            dim=edge_indices_cpu.shape[0],
-            device="cpu",
-        )
-
-        # coloring with bending
-        edge_indices_cpu_with_bending = construct_trimesh_graph_edges(model.edge_indices, True)
-        num_colors_greedy = wp.context.runtime.core.wp_graph_coloring(
-            model.particle_count,
-            edge_indices_cpu_with_bending.__ctype__(),
-            ColoringAlgorithm.GREEDY.value,
-            particle_colors.__ctype__(),
-        )
-        wp.context.runtime.core.wp_balance_coloring(
-            model.particle_count,
-            edge_indices_cpu_with_bending.__ctype__(),
-            num_colors_greedy,
-            1.1,
-            particle_colors.__ctype__(),
-        )
-        wp.launch(
-            kernel=validate_graph_coloring,
-            inputs=[edge_indices_cpu_with_bending, particle_colors],
-            dim=edge_indices_cpu_with_bending.shape[0],
-            device="cpu",
-        )
-
-        num_colors_mcs = wp.context.runtime.core.wp_graph_coloring(
-            model.particle_count,
-            edge_indices_cpu_with_bending.__ctype__(),
-            ColoringAlgorithm.MCS.value,
-            particle_colors.__ctype__(),
-        )
-        max_min_ratio = wp.context.runtime.core.wp_balance_coloring(
-            model.particle_count,
-            edge_indices_cpu_with_bending.__ctype__(),
-            num_colors_mcs,
-            1.1,
-            particle_colors.__ctype__(),
-        )
-        wp.launch(
-            kernel=validate_graph_coloring,
-            inputs=[edge_indices_cpu_with_bending, particle_colors],
-            dim=edge_indices_cpu_with_bending.shape[0],
-            device="cpu",
-        )
-
-        color_categories_balanced = convert_to_color_groups(num_colors_mcs, particle_colors)
-
-        color_sizes = np.array([c.shape[0] for c in color_categories_balanced], dtype=np.float32)
-        test.assertTrue(np.max(color_sizes) / np.min(color_sizes) <= max_min_ratio)
-
-        # test if the color balance can quit from equilibrium
-        builder = wp.sim.ModelBuilder()
-
-        vs, fs = create_lattice_grid(100)
-        builder.add_cloth_mesh(
-            pos=wp.vec3(0.0, 0.0, 0.0),
-            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
-            scale=1.0,
-            vertices=vs,
-            indices=fs,
-            vel=wp.vec3(0.0, 0.0, 0.0),
-            density=0.02,
-        )
-
-        builder.color(include_bending=True)
-
-
-@unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
-def test_combine_coloring(test, device):
-    from pxr import Usd, UsdGeom
-
-    with wp.ScopedDevice(device):
-        builder1 = wp.sim.ModelBuilder()
-        usd_stage = Usd.Stage.Open(os.path.join(wp.examples.get_asset_directory(), "bunny.usd"))
-        usd_geom = UsdGeom.Mesh(usd_stage.GetPrimAtPath("/root/bunny"))
-
-        vertices = np.array(usd_geom.GetPointsAttr().Get())
-        faces = np.array(usd_geom.GetFaceVertexIndicesAttr().Get())
-
-        builder1.add_cloth_mesh(
-            pos=wp.vec3(0.0, 0.0, 0.0),
-            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
-            scale=1.0,
-            vertices=[wp.vec3(p) for p in vertices],
-            indices=faces.flatten(),
-            vel=wp.vec3(0.0, 0.0, 0.0),
-            density=0.02,
-        )
-
-        builder1.add_cloth_grid(
-            pos=wp.vec3(0.0, 4.0, 0.0),
-            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
-            vel=wp.vec3(0.0, 0.0, 0.0),
-            dim_x=50,
-            dim_y=100,
-            cell_x=0.1,
-            cell_y=0.1,
-            mass=0.1,
-            fix_left=True,
-        )
-        builder1.color()
-
-        builder2 = wp.sim.ModelBuilder()
-        builder2.add_cloth_grid(
-            pos=wp.vec3(0.0, 4.0, 0.0),
-            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
-            vel=wp.vec3(0.0, 0.0, 0.0),
-            dim_x=50,
-            dim_y=100,
-            cell_x=0.1,
-            cell_y=0.1,
-            mass=0.1,
-            # to include bending in coloring
-            edge_ke=100000,
-            fix_left=True,
-        )
-        builder2.color()
-
-        builder3 = wp.sim.ModelBuilder()
-        builder3.add_cloth_grid(
-            pos=wp.vec3(0.0, 4.0, 0.0),
-            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 0.0),
-            vel=wp.vec3(0.0, 0.0, 0.0),
-            dim_x=50,
-            dim_y=100,
-            cell_x=0.1,
-            cell_y=0.1,
-            mass=0.1,
-            fix_left=True,
-        )
-
-        builder3.set_coloring(
-            color_lattice_grid(50, 100),
-        )
-
-        builder1.add_builder(builder2)
-        builder1.add_builder(builder3)
-
-        model = builder2.finalize()
-
-        particle_number_colored = np.full((model.particle_count), -1, dtype=int)
-        particle_colors = np.full((model.particle_count), -1, dtype=int)
-        for color, color_group in enumerate(model.particle_color_groups):
-            particle_number_colored[color_group.numpy()] += 1
-            particle_colors[color_group.numpy()] = color
-
-        # all particles has been colored exactly once
-        assert_np_equal(particle_number_colored, 0)
-
-        edge_indices_cpu = wp.array(model.edge_indices.numpy()[:, 2:], dtype=int, device="cpu")
-        wp.launch(
-            kernel=validate_graph_coloring,
-            inputs=[edge_indices_cpu, wp.array(particle_colors, dtype=int, device="cpu")],
-            dim=edge_indices_cpu.shape[0],
-            device="cpu",
-        )
-
-
-devices = get_test_devices()
-
-
-class TestColoring(unittest.TestCase):
-    pass
-
-
-add_function_test(TestColoring, "test_coloring_trimesh", test_coloring_trimesh, devices=devices, check_output=False)
-add_function_test(TestColoring, "test_combine_coloring", test_combine_coloring, devices=devices)
-add_function_test(TestColoring, "test_coloring_corner_case", test_coloring_corner_case, devices=devices)
-
-if __name__ == "__main__":
-    wp.clear_kernel_cache()
-    unittest.main(verbosity=2)

warp/tests/sim/test_inertia.py

@@ -1,161 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025 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.render.render_opengl import OpenGLRenderer
-from warp.sim import ModelBuilder
-from warp.sim.inertia import (
-    compute_box_inertia,
-    compute_mesh_inertia,
-    compute_sphere_inertia,
-)
-from warp.tests.unittest_utils import assert_np_equal
-
-
-class TestInertia(unittest.TestCase):
-    def test_cube_mesh_inertia(self):
-        # Unit cube
-        vertices = [
-            [1.0, 0.0, 0.0],
-            [1.0, 0.0, 1.0],
-            [0.0, 0.0, 1.0],
-            [0.0, 0.0, 0.0],
-            [1.0, 1.0, 0.0],
-            [1.0, 1.0, 1.0],
-            [0.0, 1.0, 1.0],
-            [0.0, 1.0, 0.0],
-        ]
-        indices = [
-            [1, 2, 3],
-            [7, 6, 5],
-            [4, 5, 1],
-            [5, 6, 2],
-            [2, 6, 7],
-            [0, 3, 7],
-            [0, 1, 3],
-            [4, 7, 5],
-            [0, 4, 1],
-            [1, 5, 2],
-            [3, 2, 7],
-            [4, 0, 7],
-        ]
-
-        mass_0, com_0, I_0, volume_0 = compute_mesh_inertia(
-            density=1000, vertices=vertices, indices=indices, is_solid=True
-        )
-
-        self.assertAlmostEqual(mass_0, 1000.0, delta=1e-6)
-        self.assertAlmostEqual(volume_0, 1.0, delta=1e-6)
-        assert_np_equal(np.array(com_0), np.array([0.5, 0.5, 0.5]), tol=1e-6)
-
-        # Check against analytical inertia
-        mass_box, com_box, I_box = compute_box_inertia(1000.0, 1.0, 1.0, 1.0)
-        self.assertAlmostEqual(mass_box, mass_0, delta=1e-6)
-        assert_np_equal(np.array(com_box), np.zeros(3), tol=1e-6)
-        assert_np_equal(np.array(I_0), np.array(I_box), tol=1e-4)
-
-        # Compute hollow box inertia
-        mass_0_hollow, com_0_hollow, I_0_hollow, volume_0_hollow = compute_mesh_inertia(
-            density=1000,
-            vertices=vertices,
-            indices=indices,
-            is_solid=False,
-            thickness=0.1,
-        )
-        assert_np_equal(np.array(com_0_hollow), np.array([0.5, 0.5, 0.5]), tol=1e-6)
-
-        # Add vertex between [0.0, 0.0, 0.0] and [1.0, 0.0, 0.0]
-        vertices.append([0.5, 0.0, 0.0])
-        indices[5] = [0, 8, 7]
-        indices.append([8, 3, 7])
-        indices[6] = [0, 1, 8]
-        indices.append([8, 1, 3])
-
-        mass_1, com_1, I_1, volume_1 = compute_mesh_inertia(
-            density=1000, vertices=vertices, indices=indices, is_solid=True
-        )
-
-        # Inertia values should be the same as before
-        self.assertAlmostEqual(mass_1, mass_0, delta=1e-6)
-        self.assertAlmostEqual(volume_1, volume_0, delta=1e-6)
-        assert_np_equal(np.array(com_1), np.array([0.5, 0.5, 0.5]), tol=1e-6)
-        assert_np_equal(np.array(I_1), np.array(I_0), tol=1e-4)
-
-        # Compute hollow box inertia
-        mass_1_hollow, com_1_hollow, I_1_hollow, volume_1_hollow = compute_mesh_inertia(
-            density=1000,
-            vertices=vertices,
-            indices=indices,
-            is_solid=False,
-            thickness=0.1,
-        )
-
-        # Inertia values should be the same as before
-        self.assertAlmostEqual(mass_1_hollow, mass_0_hollow, delta=2e-3)
-        self.assertAlmostEqual(volume_1_hollow, volume_0_hollow, delta=1e-6)
-        assert_np_equal(np.array(com_1_hollow), np.array([0.5, 0.5, 0.5]), tol=1e-6)
-        assert_np_equal(np.array(I_1_hollow), np.array(I_0_hollow), tol=1e-4)
-
-    def test_sphere_mesh_inertia(self):
-        vertices, indices = OpenGLRenderer._create_sphere_mesh(radius=2.5, num_latitudes=500, num_longitudes=500)
-
-        offset = np.array([1.0, 2.0, 3.0], dtype=np.float32)
-        vertices = vertices[:, :3] + offset
-
-        mass_mesh, com_mesh, I_mesh, vol_mesh = compute_mesh_inertia(
-            density=1000,
-            vertices=vertices,
-            indices=indices,
-            is_solid=True,
-        )
-
-        # Check against analytical inertia
-        mass_sphere, _, I_sphere = compute_sphere_inertia(1000.0, 2.5)
-        self.assertAlmostEqual(mass_mesh, mass_sphere, delta=1e2)
-        assert_np_equal(np.array(com_mesh), np.array(offset), tol=2e-3)
-        assert_np_equal(np.array(I_mesh), np.array(I_sphere), tol=4e2)
-        # Check volume
-        self.assertAlmostEqual(vol_mesh, 4.0 / 3.0 * np.pi * 2.5**3, delta=3e-2)
-
-    def test_body_inertia(self):
-        vertices, indices = OpenGLRenderer._create_sphere_mesh(radius=2.5, num_latitudes=500, num_longitudes=500)
-
-        offset = np.array([1.0, 2.0, 3.0], dtype=np.float32)
-        vertices = vertices[:, :3] + offset
-
-        builder = ModelBuilder()
-        b = builder.add_body()
-        tf = wp.transform(wp.vec3(4.0, 5.0, 6.0), wp.quat_rpy(0.5, -0.8, 1.3))
-        builder.add_shape_mesh(
-            b,
-            pos=tf.p,
-            rot=tf.q,
-            mesh=wp.sim.Mesh(vertices=vertices, indices=indices),
-            density=1000.0,
-        )
-        transformed_com = wp.transform_point(tf, wp.vec3(*offset))
-        assert_np_equal(np.array(builder.body_com[0]), np.array(transformed_com), tol=2e-3)
-        mass_sphere, _, I_sphere = compute_sphere_inertia(1000.0, 2.5)
-        assert_np_equal(np.array(builder.body_inertia[0]), np.array(I_sphere), tol=4e2)
-        self.assertAlmostEqual(builder.body_mass[0], mass_sphere, delta=1e2)
-
-
-if __name__ == "__main__":
-    wp.clear_kernel_cache()
-    unittest.main(verbosity=2)