warp-lang 1.7.2__py3-none-win_amd64.whl → 1.8.0__py3-none-win_amd64.whl

warp/tests/sim/test_collision.py

@@ -78,7 +78,7 @@ def vertex_triangle_collision_detection_brute_force(
 
 
 @wp.kernel
-def validate_vertex_collisions(
+def vertex_triangle_collision_detection_brute_force_no_triangle_buffers(
     query_radius: float,
     bvh_id: wp.uint64,
     pos: wp.array(dtype=wp.vec3),
@@ -88,33 +88,82 @@ def validate_vertex_collisions(
     vertex_colliding_triangles_offsets: wp.array(dtype=wp.int32),
     vertex_colliding_triangles_buffer_size: wp.array(dtype=wp.int32),
     vertex_colliding_triangles_min_dist: wp.array(dtype=float),
+    triangle_colliding_vertices_min_dist: wp.array(dtype=float),
     resize_flags: wp.array(dtype=wp.int32),
 ):
     v_index = wp.tid()
     v = pos[v_index]
 
-    num_cols = vertex_colliding_triangles_count[v_index]
-    offset = vertex_colliding_triangles_offsets[v_index]
-    min_dis = vertex_colliding_triangles_min_dist[v_index]
-    for col in range(wp.min(num_cols, vertex_colliding_triangles_buffer_size[v_index])):
-        tri_index = vertex_colliding_triangles[offset + col]
-
+    vertex_num_collisions = wp.int32(0)
+    min_dis_to_tris = query_radius
+    for tri_index in range(tri_indices.shape[0]):
         t1 = tri_indices[tri_index, 0]
         t2 = tri_indices[tri_index, 1]
         t3 = tri_indices[tri_index, 2]
-        # wp.expect_eq(vertex_on_triangle(v_index, t1, t2, t3), False)
+        if vertex_adjacent_to_triangle(v_index, t1, t2, t3):
+            continue
 
         u1 = pos[t1]
         u2 = pos[t2]
         u3 = pos[t3]
 
         closest_p, bary, feature_type = triangle_closest_point(u1, u2, u3, v)
+
         dis = wp.length(closest_p - v)
-        wp.expect_eq(dis < query_radius, True)
-        wp.expect_eq(dis >= min_dis, True)
 
-        # wp.printf("vertex %d, offset %d, num cols %d, colliding with triangle: %d, dis: %f\n",
-        #           v_index, offset, num_cols, tri_index, dis)
+        if dis < query_radius:
+            vertex_num_collisions = vertex_num_collisions + 1
+            min_dis_to_tris = wp.min(dis, min_dis_to_tris)
+
+            wp.atomic_min(triangle_colliding_vertices_min_dist, tri_index, dis)
+
+    vertex_colliding_triangles_count[v_index] = vertex_num_collisions
+    vertex_colliding_triangles_min_dist[v_index] = min_dis_to_tris
+
+
+@wp.kernel
+def validate_vertex_collisions(
+    query_radius: float,
+    bvh_id: wp.uint64,
+    pos: wp.array(dtype=wp.vec3),
+    tri_indices: wp.array(dtype=wp.int32, ndim=2),
+    vertex_colliding_triangles: wp.array(dtype=wp.int32),
+    vertex_colliding_triangles_count: wp.array(dtype=wp.int32),
+    vertex_colliding_triangles_offsets: wp.array(dtype=wp.int32),
+    vertex_colliding_triangles_buffer_size: wp.array(dtype=wp.int32),
+    vertex_colliding_triangles_min_dist: wp.array(dtype=float),
+    resize_flags: wp.array(dtype=wp.int32),
+):
+    v_index = wp.tid()
+    v = pos[v_index]
+
+    num_cols = vertex_colliding_triangles_count[v_index]
+    offset = vertex_colliding_triangles_offsets[v_index]
+    min_dis = vertex_colliding_triangles_min_dist[v_index]
+    for col in range(vertex_colliding_triangles_buffer_size[v_index]):
+        vertex_index = vertex_colliding_triangles[2 * (offset + col)]
+        tri_index = vertex_colliding_triangles[2 * (offset + col) + 1]
+        if col < num_cols:
+            t1 = tri_indices[tri_index, 0]
+            t2 = tri_indices[tri_index, 1]
+            t3 = tri_indices[tri_index, 2]
+            # wp.expect_eq(vertex_on_triangle(v_index, t1, t2, t3), False)
+
+            u1 = pos[t1]
+            u2 = pos[t2]
+            u3 = pos[t3]
+
+            closest_p, bary, feature_type = triangle_closest_point(u1, u2, u3, v)
+            dis = wp.length(closest_p - v)
+            wp.expect_eq(dis < query_radius, True)
+            wp.expect_eq(dis >= min_dis, True)
+            wp.expect_eq(v_index == vertex_colliding_triangles[2 * (offset + col)], True)
+
+            # wp.printf("vertex %d, offset %d, num cols %d, colliding with triangle: %d, dis: %f\n",
+            #           v_index, offset, num_cols, tri_index, dis)
+        else:
+            wp.expect_eq(vertex_index == -1, True)
+            wp.expect_eq(tri_index == -1, True)
 
 
 @wp.kernel
@@ -242,30 +291,35 @@ def validate_edge_collisions(
     num_cols = edge_colliding_edges_count[e0_index]
     offset = edge_colliding_edges_offsets[e0_index]
     min_dist = edge_colliding_edges_min_dist[e0_index]
-    for col in range(wp.min(num_cols, edge_colliding_edges_buffer_sizes[e0_index])):
-        e1_index = edge_colliding_edges[offset + col]
+    for col in range(edge_colliding_edges_buffer_sizes[e0_index]):
+        e1_index = edge_colliding_edges[2 * (offset + col) + 1]
 
-        e1_v0 = edge_indices[e1_index, 2]
-        e1_v1 = edge_indices[e1_index, 3]
+        if col < num_cols:
+            e1_v0 = edge_indices[e1_index, 2]
+            e1_v1 = edge_indices[e1_index, 3]
 
-        if e0_v0 == e1_v0 or e0_v0 == e1_v1 or e0_v1 == e1_v0 or e0_v1 == e1_v1:
-            wp.expect_eq(False, True)
+            if e0_v0 == e1_v0 or e0_v0 == e1_v1 or e0_v1 == e1_v0 or e0_v1 == e1_v1:
+                wp.expect_eq(False, True)
 
-        e1_v0_pos = pos[e1_v0]
-        e1_v1_pos = pos[e1_v1]
+            e1_v0_pos = pos[e1_v0]
+            e1_v1_pos = pos[e1_v1]
 
-        st = wp.closest_point_edge_edge(e0_v0_pos, e0_v1_pos, e1_v0_pos, e1_v1_pos, edge_edge_parallel_epsilon)
-        s = st[0]
-        t = st[1]
-        c1 = e0_v0_pos + (e0_v1_pos - e0_v0_pos) * s
-        c2 = e1_v0_pos + (e1_v1_pos - e1_v0_pos) * t
+            st = wp.closest_point_edge_edge(e0_v0_pos, e0_v1_pos, e1_v0_pos, e1_v1_pos, edge_edge_parallel_epsilon)
+            s = st[0]
+            t = st[1]
+            c1 = e0_v0_pos + (e0_v1_pos - e0_v0_pos) * s
+            c2 = e1_v0_pos + (e1_v1_pos - e1_v0_pos) * t
 
-        dist = wp.length(c2 - c1)
+            dist = wp.length(c2 - c1)
 
-        wp.expect_eq(dist >= min_dist, True)
+            wp.expect_eq(dist >= min_dist, True)
+            wp.expect_eq(e0_index == edge_colliding_edges[2 * (offset + col)], True)
+        else:
+            wp.expect_eq(e1_index == -1, True)
+            wp.expect_eq(edge_colliding_edges[2 * (offset + col)] == -1, True)
 
 
-def init_model(vs, fs, device):
+def init_model(vs, fs, device, record_triangle_contacting_vertices=True):
     vertices = [wp.vec3(v) for v in vs]
 
     builder = wp.sim.ModelBuilder()
@@ -283,7 +337,7 @@ def init_model(vs, fs, device):
     )
     model = builder.finalize(device=device)
 
-    collision_detector = TriMeshCollisionDetector(model=model)
+    collision_detector = TriMeshCollisionDetector(model=model, record_triangle_contacting_vertices=True)
 
     return model, collision_detector
 
@@ -304,7 +358,8 @@ def get_data():
 def test_vertex_triangle_collision(test, device):
     vertices, faces = get_data()
 
-    model, collision_detector = init_model(vertices, faces, device)
+    # record triangle contacting vertices
+    model, collision_detector = init_model(vertices, faces, device, True)
 
     rs = [1e-2, 2e-2, 5e-2, 1e-1]
 
@@ -316,6 +371,42 @@ def test_vertex_triangle_collision(test, device):
         triangle_colliding_vertices_count_1 = collision_detector.triangle_colliding_vertices_count.numpy()
         triangle_min_dis_1 = collision_detector.triangle_colliding_vertices_min_dist.numpy()
 
+        wp.launch(
+            kernel=validate_vertex_collisions,
+            inputs=[
+                query_radius,
+                collision_detector.bvh_tris.id,
+                collision_detector.model.particle_q,
+                collision_detector.model.tri_indices,
+                collision_detector.vertex_colliding_triangles,
+                collision_detector.vertex_colliding_triangles_count,
+                collision_detector.vertex_colliding_triangles_offsets,
+                collision_detector.vertex_colliding_triangles_buffer_sizes,
+                collision_detector.vertex_colliding_triangles_min_dist,
+                collision_detector.resize_flags,
+            ],
+            dim=model.particle_count,
+            device=device,
+        )
+
+        wp.launch(
+            kernel=validate_triangle_collisions,
+            inputs=[
+                query_radius,
+                collision_detector.bvh_tris.id,
+                collision_detector.model.particle_q,
+                collision_detector.model.tri_indices,
+                collision_detector.triangle_colliding_vertices,
+                collision_detector.triangle_colliding_vertices_count,
+                collision_detector.triangle_colliding_vertices_offsets,
+                collision_detector.triangle_colliding_vertices_buffer_sizes,
+                collision_detector.triangle_colliding_vertices_min_dist,
+                collision_detector.resize_flags,
+            ],
+            dim=model.tri_count,
+            device=model.device,
+        )
+
         wp.launch(
             kernel=init_triangle_collision_data_kernel,
             inputs=[
@@ -325,7 +416,7 @@ def test_vertex_triangle_collision(test, device):
                 collision_detector.resize_flags,
             ],
             dim=model.tri_count,
-            device=device,
+            device=model.device,
         )
 
         wp.launch(
@@ -348,7 +439,7 @@ def test_vertex_triangle_collision(test, device):
                 collision_detector.resize_flags,
             ],
             dim=model.particle_count,
-            device=device,
+            device=model.device,
         )
 
         vertex_colliding_triangles_count_2 = collision_detector.vertex_colliding_triangles_count.numpy()
@@ -362,6 +453,18 @@ def test_vertex_triangle_collision(test, device):
         assert_np_equal(triangle_colliding_vertices_count_2, triangle_colliding_vertices_count_1)
         assert_np_equal(vertex_min_dis_2, vertex_min_dis_1)
 
+        # do not record triangle contacting vertices
+        model, collision_detector = init_model(vertices, faces, device, False)
+
+        rs = [1e-2, 2e-2, 5e-2, 1e-1]
+
+    for query_radius in rs:
+        collision_detector.vertex_triangle_collision_detection(query_radius)
+        vertex_colliding_triangles_count_1 = collision_detector.vertex_colliding_triangles_count.numpy()
+        vertex_min_dis_1 = collision_detector.vertex_colliding_triangles_min_dist.numpy()
+
+        triangle_min_dis_1 = collision_detector.triangle_colliding_vertices_min_dist.numpy()
+
         wp.launch(
             kernel=validate_vertex_collisions,
             inputs=[
@@ -381,24 +484,31 @@ def test_vertex_triangle_collision(test, device):
         )
 
         wp.launch(
-            kernel=validate_triangle_collisions,
+            kernel=vertex_triangle_collision_detection_brute_force_no_triangle_buffers,
             inputs=[
                 query_radius,
                 collision_detector.bvh_tris.id,
                 collision_detector.model.particle_q,
                 collision_detector.model.tri_indices,
-                collision_detector.triangle_colliding_vertices,
-                collision_detector.triangle_colliding_vertices_count,
-                collision_detector.triangle_colliding_vertices_offsets,
-                collision_detector.triangle_colliding_vertices_buffer_sizes,
+                collision_detector.vertex_colliding_triangles,
+                collision_detector.vertex_colliding_triangles_count,
+                collision_detector.vertex_colliding_triangles_offsets,
+                collision_detector.vertex_colliding_triangles_buffer_sizes,
+                collision_detector.vertex_colliding_triangles_min_dist,
                 collision_detector.triangle_colliding_vertices_min_dist,
                 collision_detector.resize_flags,
             ],
-            dim=model.tri_count,
-            device=device,
+            dim=model.particle_count,
+            device=model.device,
         )
 
-    wp.synchronize_device(device)
+        vertex_colliding_triangles_count_2 = collision_detector.vertex_colliding_triangles_count.numpy()
+        vertex_min_dis_2 = collision_detector.vertex_colliding_triangles_min_dist.numpy()
+        triangle_min_dis_2 = collision_detector.triangle_colliding_vertices_min_dist.numpy()
+
+        assert_np_equal(vertex_colliding_triangles_count_2, vertex_colliding_triangles_count_1)
+        assert_np_equal(triangle_min_dis_2, triangle_min_dis_1)
+        assert_np_equal(vertex_min_dis_2, vertex_min_dis_1)
 
 
 @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
@@ -416,7 +526,7 @@ def test_edge_edge_collision(test, device):
         edge_min_dist_1 = collision_detector.edge_colliding_edges_min_dist.numpy()
 
         wp.launch(
-            kernel=edge_edge_collision_detection_brute_force,
+            kernel=validate_edge_collisions,
             inputs=[
                 query_radius,
                 collision_detector.bvh_edges.id,
@@ -432,18 +542,12 @@ def test_edge_edge_collision(test, device):
                 collision_detector.edge_colliding_edges_min_dist,
                 collision_detector.resize_flags,
             ],
-            dim=model.edge_count,
+            dim=model.particle_count,
             device=device,
         )
 
-        edge_colliding_edges_count_2 = collision_detector.edge_colliding_edges_count.numpy()
-        edge_min_dist_2 = collision_detector.edge_colliding_edges_min_dist.numpy()
-
-        assert_np_equal(edge_colliding_edges_count_2, edge_colliding_edges_count_1)
-        assert_np_equal(edge_min_dist_2, edge_min_dist_1)
-
         wp.launch(
-            kernel=validate_edge_collisions,
+            kernel=edge_edge_collision_detection_brute_force,
             inputs=[
                 query_radius,
                 collision_detector.bvh_edges.id,
@@ -459,11 +563,15 @@ def test_edge_edge_collision(test, device):
                 collision_detector.edge_colliding_edges_min_dist,
                 collision_detector.resize_flags,
             ],
-            dim=model.particle_count,
+            dim=model.edge_count,
             device=device,
         )
 
-    wp.synchronize_device(device)
+        edge_colliding_edges_count_2 = collision_detector.edge_colliding_edges_count.numpy()
+        edge_min_dist_2 = collision_detector.edge_colliding_edges_min_dist.numpy()
+
+        assert_np_equal(edge_colliding_edges_count_2, edge_colliding_edges_count_1)
+        assert_np_equal(edge_min_dist_1, edge_min_dist_2)
 
 
 def test_particle_collision(test, device):

warp/tests/sim/test_coloring.py

@@ -48,6 +48,19 @@ def color_lattice_grid(num_x, num_y):
     return color_groups
 
 
+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
@@ -227,7 +240,7 @@ def test_combine_coloring(test, device):
 
         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_coloring):
+        for color, color_group in enumerate(model.particle_color_groups):
             particle_number_colored[color_group.numpy()] += 1
             particle_colors[color_group.numpy()] = color
 
@@ -252,6 +265,7 @@ class TestColoring(unittest.TestCase):
 
 add_function_test(TestColoring, "test_coloring_trimesh", test_coloring_trimesh, devices=devices)
 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()

warp/tests/test_array.py

@@ -412,7 +412,7 @@ def test_slicing(test, device):
     assert_array_equal(wp_arr[:5], wp.array(np_arr[:5], dtype=int, device=device))
     assert_array_equal(wp_arr[1:5], wp.array(np_arr[1:5], dtype=int, device=device))
     assert_array_equal(wp_arr[-9:-5:1], wp.array(np_arr[-9:-5:1], dtype=int, device=device))
-    assert_array_equal(wp_arr[:5,], wp.array(np_arr[:5], dtype=int, device=device))  # noqa: E231
+    assert_array_equal(wp_arr[:5,], wp.array(np_arr[:5], dtype=int, device=device))
 
 
 def test_view(test, device):
@@ -2370,6 +2370,257 @@ def test_array_from_cai(test, device):
     assert_np_equal(arr_warp.numpy(), np.array([[2, 1, 1], [1, 0, 0], [1, 0, 0]]))
 
 
+def test_array_from_data(test, device):
+    with wp.ScopedDevice(device):
+        # =========================================
+        # scalars, reshaping
+
+        data = np.arange(12, dtype=np.float32).reshape((3, 4))
+        src = wp.array(data)
+
+        assert src.device == device
+
+        dtypes = [Any, wp.float32]
+        shapes = [None, (3, 4), (12,), (3, 2, 2)]
+
+        for dtype in dtypes:
+            for shape in shapes:
+                with test.subTest(msg=f"scalar, dtype={dtype}, shape={shape}"):
+                    dst = wp.array(src, dtype=dtype, shape=shape)
+                    assert dst.device == src.device
+                    if dtype is Any:
+                        assert dst.dtype == src.dtype
+                    else:
+                        assert dst.dtype == dtype
+                    if shape is None:
+                        assert dst.shape == src.shape
+                        assert_np_equal(dst.numpy(), data)
+                    else:
+                        assert dst.shape == shape
+                        assert_np_equal(dst.numpy(), data.reshape(shape))
+
+        # =========================================
+        # vectors, reshaping
+
+        with test.subTest(msg="vector, single"):
+            data = np.arange(3, dtype=np.float32)
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.vec3)
+            assert dst.dtype == wp.vec3
+            assert dst.shape == (1,)
+            assert_np_equal(dst.numpy(), data.reshape((1, 3)))
+
+        with test.subTest(msg="vector, multiple in 1d"):
+            data = np.arange(12, dtype=np.float32)
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.vec3)
+            assert dst.dtype == wp.vec3
+            assert dst.shape == (4,)
+            assert_np_equal(dst.numpy(), data.reshape((4, 3)))
+
+        with test.subTest(msg="vector, singles in 2d"):
+            data = np.arange(12, dtype=np.float32).reshape((4, 3))
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.vec3)
+            assert dst.dtype == wp.vec3
+            assert dst.shape == (4,)
+            assert_np_equal(dst.numpy(), data.reshape((4, 3)))
+
+        with test.subTest(msg="vector, multiples in 2d"):
+            data = np.arange(24, dtype=np.float32).reshape((4, 6))
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.vec3)
+            assert dst.dtype == wp.vec3
+            assert dst.shape == (4, 2)
+            assert_np_equal(dst.numpy(), data.reshape((4, 2, 3)))
+
+        with test.subTest(msg="vector, singles in 2d, reshape"):
+            data = np.arange(12, dtype=np.float32).reshape((4, 3))
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.vec3, shape=(2, 2))
+            assert dst.dtype == wp.vec3
+            assert dst.shape == (2, 2)
+            assert_np_equal(dst.numpy(), data.reshape((2, 2, 3)))
+
+        with test.subTest(msg="vector, multiples in 2d, reshape"):
+            data = np.arange(24, dtype=np.float32).reshape((4, 6))
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.vec3, shape=(2, 2, 2))
+            assert dst.dtype == wp.vec3
+            assert dst.shape == (2, 2, 2)
+            assert_np_equal(dst.numpy(), data.reshape((2, 2, 2, 3)))
+
+        # =========================================
+        # matrices, reshaping
+
+        with test.subTest(msg="matrix, single in 2d"):
+            # one 2x2 matrix in a 2d array
+            data = np.arange(4, dtype=np.float32).reshape((2, 2))
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.mat22)
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (1,)
+            assert_np_equal(dst.numpy(), data.reshape((1, 2, 2)))
+
+        with test.subTest(msg="matrix, single in 1d"):
+            # 2x2 matrix in a 1d array
+            data = np.arange(4, dtype=np.float32)
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.mat22)
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (1,)
+            assert_np_equal(dst.numpy(), data.reshape((1, 2, 2)))
+
+        with test.subTest(msg="matrix, multiples in 1d"):
+            # 3 2x2 matrices in a 1d array
+            data = np.arange(12, dtype=np.float32)
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.mat22)
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (3,)
+            assert_np_equal(dst.numpy(), data.reshape((3, 2, 2)))
+
+        with test.subTest(msg="matrix, multiples in 1d, reshape"):
+            # 4 2x2 matrices in a 1d array
+            data = np.arange(16, dtype=np.float32)
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.mat22, shape=(4,))
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (4,)
+            assert_np_equal(dst.numpy(), data.reshape((4, 2, 2)))
+
+        with test.subTest(msg="matrix, multiples in 2d"):
+            # 3 2x2 matrices in a 2d array
+            data = np.arange(12, dtype=np.float32).reshape((3, 4))
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.mat22)
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (3,)
+            assert_np_equal(dst.numpy(), data.reshape((3, 2, 2)))
+
+        with test.subTest(msg="matrix, multiples in 2d, reshape"):
+            # 4 2x2 matrices in a 2d array
+            data = np.arange(16, dtype=np.float32).reshape((4, 4))
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.mat22, shape=(2, 2))
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (2, 2)
+            assert_np_equal(dst.numpy(), data.reshape((2, 2, 2, 2)))
+
+        with test.subTest(msg="matrix, multiples in 3d"):
+            # 3 2x2 matrices in a 3d array
+            data = np.arange(12, dtype=np.float32).reshape((3, 2, 2))
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.mat22)
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (3,)
+            assert_np_equal(dst.numpy(), data.reshape((3, 2, 2)))
+
+        with test.subTest(msg="matrix, multiples in 3d, reshape"):
+            # 4 2x2 matrices in a 3d array
+            data = np.arange(16, dtype=np.float32).reshape((4, 2, 2))
+            src = wp.array(data)
+            dst = wp.array(src, dtype=wp.mat22, shape=(2, 2))
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (2, 2)
+            assert_np_equal(dst.numpy(), data.reshape((2, 2, 2, 2)))
+
+        # =========================================
+        # vectors and matrices in strided arrays
+
+        with test.subTest(msg="vector, singles in 2d, strided"):
+            # 4 vec3 in strided 2d array
+            data = np.arange(20, dtype=np.float32).reshape((4, 5))
+            src = wp.array(data)[:, 2:]  # source with strides
+            dst = wp.array(src, dtype=wp.vec3)
+            assert dst.dtype == wp.vec3
+            assert dst.shape == (4,)
+            expected = np.array(
+                [
+                    [2, 3, 4],
+                    [7, 8, 9],
+                    [12, 13, 14],
+                    [17, 18, 19],
+                ],
+                dtype=np.float32,
+            )
+            assert_np_equal(dst.numpy(), expected)
+
+        with test.subTest(msg="vector, multiples in 2d, strided"):
+            # 4 vec3 in strided 2d array
+            data = np.arange(14, dtype=np.float32).reshape((2, 7))
+            src = wp.array(data)[:, 1:]  # source with strides
+            dst = wp.array(src, dtype=wp.vec3)
+            assert dst.dtype == wp.vec3
+            assert dst.shape == (2, 2)
+            expected = np.array(
+                [
+                    [
+                        [1, 2, 3],
+                        [4, 5, 6],
+                    ],
+                    [
+                        [8, 9, 10],
+                        [11, 12, 13],
+                    ],
+                ],
+                dtype=np.float32,
+            )
+            assert_np_equal(dst.numpy(), expected)
+
+        with test.subTest(msg="matrix, multiples in 2d, strided"):
+            # 3 2x2 matrices in a 2d array
+            data = np.arange(15, dtype=np.float32).reshape((3, 5))
+            src = wp.array(data)[:, 1:]  # source with strides
+            dst = wp.array(src, dtype=wp.mat22)
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (3,)
+            expected = np.array(
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ],
+                    [
+                        [6, 7],
+                        [8, 9],
+                    ],
+                    [
+                        [11, 12],
+                        [13, 14],
+                    ],
+                ],
+                dtype=np.float32,
+            )
+            assert_np_equal(dst.numpy(), expected)
+
+        with test.subTest(msg="matrix, multiples in 3d, strided"):
+            # 3 2x2 matrices in a 3d array
+            data = np.arange(18, dtype=np.float32).reshape((3, 3, 2))
+            src = wp.array(data)[:, 1:]  # source with strides
+            dst = wp.array(src, dtype=wp.mat22)
+            assert dst.dtype == wp.mat22
+            assert dst.shape == (3,)
+            expected = np.array(
+                [
+                    [
+                        [2, 3],
+                        [4, 5],
+                    ],
+                    [
+                        [8, 9],
+                        [10, 11],
+                    ],
+                    [
+                        [14, 15],
+                        [16, 17],
+                    ],
+                ],
+                dtype=np.float32,
+            )
+            assert_np_equal(dst.numpy(), expected)
+
+
 @wp.kernel
 def inplace_add_1d(x: wp.array(dtype=float), y: wp.array(dtype=float)):
     i = wp.tid()
@@ -2604,7 +2855,7 @@ def test_array_inplace_non_diff_ops(test, device):
     wp.launch(inplace_div_1d, N, inputs=[x1, y1], device=device)
     assert_np_equal(x1.numpy(), np.full(N, fill_value=2.0, dtype=float))
 
-    for dtype in wp.types.non_atomic_types + (wp.vec2b, wp.vec2ub, wp.vec2s, wp.vec2us, uint16vec3):
+    for dtype in (*wp.types.non_atomic_types, wp.vec2b, wp.vec2ub, wp.vec2s, wp.vec2us, uint16vec3):
         x = wp.full(N, value=0, dtype=dtype, device=device)
         y = wp.full(N, value=1, dtype=dtype, device=device)
 
@@ -2943,6 +3194,7 @@ add_function_test(TestArray, "test_alloc_strides", test_alloc_strides, devices=d
 add_function_test(TestArray, "test_casting", test_casting, devices=devices)
 add_function_test(TestArray, "test_array_len", test_array_len, devices=devices)
 add_function_test(TestArray, "test_cuda_interface_conversion", test_cuda_interface_conversion, devices=devices)
+add_function_test(TestArray, "test_array_from_data", test_array_from_data, devices=devices)
 
 try:
     import torch

warp/tests/test_array_reduce.py

@@ -28,7 +28,7 @@ def make_test_array_sum(dtype):
     def test_array_sum(test, device):
         rng = np.random.default_rng(123)
 
-        cols = wp.types.type_length(dtype)
+        cols = wp.types.type_size(dtype)
 
         values_np = rng.random(size=(N, cols))
         values = wp.array(values_np, device=device, dtype=dtype)
@@ -77,7 +77,7 @@ def make_test_array_inner(dtype):
     def test_array_inner(test, device):
         rng = np.random.default_rng(123)
 
-        cols = wp.types.type_length(dtype)
+        cols = wp.types.type_size(dtype)
 
         a_np = rng.random(size=(N, cols))
         b_np = rng.random(size=(N, cols))