utils3d

A collection of useful functions for 3D computer vision and graphics researchers in Python.

NumPy / PyTorch pairs: most functions have both implementations.
Flat & non-modular: standalone functions only, no classes, no hierarchies.
Native types: always use raw Python / NumPy / PyTorch / SciPy.sparse types.
Vectorized only: no Python loops beyond O(log N).

⚠️ This repo changes quickly. Functions may be added, removed, or modified at any time.

Copy code if you only need a single function.

Use commit id or fork if you need stability.

Install

Install via pip + git

pip install git+https://github.com/EasternJournalist/utils3d.git

or clone the repo and install

git clone https://github.com/EasternJournalist/utils3d.git
pip install ./utils3d

Documentation

Use utils3d.{function} to call the function automatically selecting the backend based on the input type (Numpy ndarray or Pytorch tensor).
Use utils3d.{np/pt}.{function} to specifically call the Numpy or Pytorch version.

The links below will take you to the source code of each function with detailed documentation and type hints.

Transforms

Function	Numpy	Pytorch
`utils3d.angle_between` Calculate the angle between two (batches of) vectors.	`utils3d.np.angle_between(v1, v2)`	`utils3d.pt.angle_between(v1, v2, eps)`
`utils3d.axis_angle_to_matrix` Convert axis-angle representation (rotation vector) to rotation matrix, whose direction is the axis of rotation and length is the angle of rotation	`utils3d.np.axis_angle_to_matrix(axis_angle)`	`utils3d.pt.axis_angle_to_matrix(axis_angle, eps)`
`utils3d.axis_angle_to_quaternion` Convert axis-angle representation (rotation vector) to quaternion (w, x, y, z)	`utils3d.np.axis_angle_to_quaternion(axis_angle)`	`utils3d.pt.axis_angle_to_quaternion(axis_angle, eps)`
`utils3d.crop_intrinsics` Evaluate the new intrinsics after cropping the image	`utils3d.np.crop_intrinsics(intrinsics, size, cropped_top, cropped_left, cropped_height, cropped_width)`	`utils3d.pt.crop_intrinsics(intrinsics, size, cropped_top, cropped_left, cropped_height, cropped_width)`
`utils3d.denormalize_intrinsics` Denormalize intrinsics from uv cooridnates to pixel coordinates	`utils3d.np.denormalize_intrinsics(intrinsics, size, pixel_convention)`	`utils3d.pt.denormalize_intrinsics(intrinsics, size, pixel_convention)`
`utils3d.depth_buffer_to_linear` OpenGL depth buffer to linear depth	`utils3d.np.depth_buffer_to_linear(depth_buffer, near, far)`	`utils3d.pt.depth_buffer_to_linear(depth, near, far)`
`utils3d.depth_linear_to_buffer` Project linear depth to depth value in screen space	`utils3d.np.depth_linear_to_buffer(depth, near, far)`	`utils3d.pt.depth_linear_to_buffer(depth, near, far)`
`utils3d.euler_angles_to_matrix` Convert rotations given as Euler angles in radians to rotation matrices.	`utils3d.np.euler_angles_to_matrix(euler_angles, convention)`	`utils3d.pt.euler_angles_to_matrix(euler_angles, convention)`
`utils3d.euler_axis_angle_rotation` Return the rotation matrices for one of the rotations about an axis	`utils3d.np.euler_axis_angle_rotation(axis, angle)`	`utils3d.pt.euler_axis_angle_rotation(axis, angle)`
`utils3d.extrinsics_look_at` Get OpenCV extrinsics matrix looking at something	`utils3d.np.extrinsics_look_at(eye, look_at, up)`	`utils3d.pt.extrinsics_look_at(eye, look_at, up)`
`utils3d.extrinsics_to_essential` extrinsics matrix `[[R, t] [0, 0, 0, 1]]` such that `x' = R (x - t)` to essential matrix such that `x' E x = 0`	`utils3d.np.extrinsics_to_essential(extrinsics)`	`utils3d.pt.extrinsics_to_essential(extrinsics)`
`utils3d.extrinsics_to_view` OpenCV camera extrinsics to OpenGL view matrix	`utils3d.np.extrinsics_to_view(extrinsics)`	`utils3d.pt.extrinsics_to_view(extrinsics)`
`utils3d.focal_to_fov`	`utils3d.np.focal_to_fov(focal)`	`utils3d.pt.focal_to_fov(focal)`
`utils3d.fov_to_focal`	`utils3d.np.fov_to_focal(fov)`	`utils3d.pt.fov_to_focal(fov)`
`utils3d.interpolate_se3_matrix` Linear interpolation between two SE(3) matrices.	`utils3d.np.interpolate_se3_matrix(T1, T2, t)`	`utils3d.pt.interpolate_se3_matrix(T1, T2, t)`
`utils3d.intrinsics_from_focal_center` Get OpenCV intrinsics matrix	`utils3d.np.intrinsics_from_focal_center(fx, fy, cx, cy)`	`utils3d.pt.intrinsics_from_focal_center(fx, fy, cx, cy)`
`utils3d.intrinsics_from_fov` Get normalized OpenCV intrinsics matrix from given field of view.	`utils3d.np.intrinsics_from_fov(fov_x, fov_y, fov_max, fov_min, aspect_ratio)`	`utils3d.pt.intrinsics_from_fov(fov_x, fov_y, fov_max, fov_min, aspect_ratio)`
`utils3d.intrinsics_to_fov` NOTE: approximate FOV by assuming centered principal point	`utils3d.np.intrinsics_to_fov(intrinsics)`	`utils3d.pt.intrinsics_to_fov(intrinsics)`
`utils3d.intrinsics_to_perspective` OpenCV intrinsics to OpenGL perspective matrix	`utils3d.np.intrinsics_to_perspective(intrinsics, near, far)`	`utils3d.pt.intrinsics_to_perspective(intrinsics, near, far)`
`utils3d.lerp` Linear interpolation between two vectors.	`utils3d.np.lerp(x1, x2, t)`	`utils3d.pt.lerp(v1, v2, t)`
`utils3d.make_affine_matrix` Make an affine transformation matrix from a linear matrix and a translation vector.	`utils3d.np.make_affine_matrix(M, t)`	`utils3d.pt.make_affine_matrix(M, t)`
`utils3d.matrix_to_axis_angle` Convert a batch of 3x3 rotation matrices to axis-angle representation (rotation vector)	`utils3d.np.matrix_to_axis_angle(rot_mat)`	`utils3d.pt.matrix_to_axis_angle(rot_mat, eps)`
`utils3d.matrix_to_euler_angles` Convert rotations given as rotation matrices to Euler angles in radians.	`utils3d.np.matrix_to_euler_angles(matrix, convention)`	`utils3d.pt.matrix_to_euler_angles(matrix, convention)`
`utils3d.matrix_to_quaternion` Convert 3x3 rotation matrix to quaternion (w, x, y, z)	`utils3d.np.matrix_to_quaternion(rot_mat)`	`utils3d.pt.matrix_to_quaternion(rot_mat, eps)`
`utils3d.normalize_intrinsics` Normalize intrinsics from pixel cooridnates to uv coordinates	`utils3d.np.normalize_intrinsics(intrinsics, size, pixel_convention)`	`utils3d.pt.normalize_intrinsics(intrinsics, size, pixel_convention)`
`utils3d.perspective_from_fov` Get OpenGL perspective matrix from field of view	`utils3d.np.perspective_from_fov(fov_x, fov_y, fov_min, fov_max, aspect_ratio, near, far)`	`utils3d.pt.perspective_from_fov(fov_x, fov_y, fov_min, fov_max, aspect_ratio, near, far)`
`utils3d.perspective_from_window` Get OpenGL perspective matrix from the window of z=-1 projection plane	`utils3d.np.perspective_from_window(left, right, bottom, top, near, far)`	`utils3d.pt.perspective_from_window(left, right, bottom, top, near, far)`
`utils3d.perspective_to_intrinsics` OpenGL perspective matrix to OpenCV intrinsics	`utils3d.np.perspective_to_intrinsics(perspective)`	`utils3d.pt.perspective_to_intrinsics(perspective)`
`utils3d.perspective_to_near_far` Get near and far planes from OpenGL perspective matrix	`utils3d.np.perspective_to_near_far(perspective)`	-
`utils3d.piecewise_interpolate_se3_matrix` Linear spline interpolation for SE(3) matrices.	`utils3d.np.piecewise_interpolate_se3_matrix(T, t, s, extrapolation_mode)`	-
`utils3d.piecewise_lerp` Linear spline interpolation.	`utils3d.np.piecewise_lerp(x, t, s, extrapolation_mode)`	-
`utils3d.pixel_to_ndc` Convert pixel coordinates to NDC (Normalized Device Coordinates).	`utils3d.np.pixel_to_ndc(pixel, size, pixel_convention)`	`utils3d.pt.pixel_to_ndc(pixel, size, pixel_convention)`
`utils3d.pixel_to_uv` Convert pixel space coordiantes to UV space coordinates.	`utils3d.np.pixel_to_uv(pixel, size, pixel_convention)`	`utils3d.pt.pixel_to_uv(pixel, size, pixel_convention)`
`utils3d.project` Calculate projection.	`utils3d.np.project(points, intrinsics, extrinsics, view, projection)`	`utils3d.pt.project(points, intrinsics, extrinsics, view, projection)`
`utils3d.project_cv` Project 3D points to 2D following the OpenCV convention	`utils3d.np.project_cv(points, intrinsics, extrinsics)`	`utils3d.pt.project_cv(points, intrinsics, extrinsics)`
`utils3d.project_gl` Project 3D points to 2D following the OpenGL convention (except for row major matrices)	`utils3d.np.project_gl(points, projection, view)`	`utils3d.pt.project_gl(points, projection, view)`
`utils3d.quaternion_to_axis_angle` Convert a batch of quaternions (w, x, y, z) to axis-angle representation (rotation vector)	`utils3d.np.quaternion_to_axis_angle(quaternion)`	`utils3d.pt.quaternion_to_axis_angle(quaternion, eps)`
`utils3d.quaternion_to_matrix` Converts a batch of quaternions (w, x, y, z) to rotation matrices	`utils3d.np.quaternion_to_matrix(quaternion)`	`utils3d.pt.quaternion_to_matrix(quaternion, eps)`
`utils3d.random_rotation_matrix` Generate random 3D rotation matrix.	`utils3d.np.random_rotation_matrix(size, dtype)`	`utils3d.pt.random_rotation_matrix(size, dtype, device)`
`utils3d.ray_intersection` Compute the intersection/closest point of two D-dimensional rays	`utils3d.np.ray_intersection(p1, d1, p2, d2)`	-
`utils3d.rotate_2d` 3x3 matrix for 2D rotation around a center	-	`utils3d.pt.rotate_2d(theta, center)`
`utils3d.rotation_matrix_2d` 2x2 matrix for 2D rotation	-	`utils3d.pt.rotation_matrix_2d(theta)`
`utils3d.rotation_matrix_from_vectors` Rotation matrix that rotates v1 to v2	`utils3d.np.rotation_matrix_from_vectors(v1, v2)`	`utils3d.pt.rotation_matrix_from_vectors(v1, v2)`
`utils3d.scale_2d` Scale matrix for 2D scaling	-	`utils3d.pt.scale_2d(scale, center)`
`utils3d.screen_coord_to_view_coord` Unproject screen space coordinates to 3D view space following the OpenGL convention (except for row major matrices)	`utils3d.np.screen_coord_to_view_coord(screen_coord, projection)`	-
`utils3d.skew_symmetric` Skew symmetric matrix from a 3D vector	`utils3d.np.skew_symmetric(v)`	`utils3d.pt.skew_symmetric(v)`
`utils3d.slerp` Spherical linear interpolation between two (unit) vectors.	`utils3d.np.slerp(v1, v2, t)`	`utils3d.pt.slerp(v1, v2, t, eps)`
`utils3d.slerp_rotation_matrix` Spherical linear interpolation between two rotation matrices.	`utils3d.np.slerp_rotation_matrix(R1, R2, t)`	`utils3d.pt.slerp_rotation_matrix(R1, R2, t)`
`utils3d.transform_points` Apply transformation(s) to a point or a set of points.	`utils3d.np.transform_points(x, Ts)`	`utils3d.pt.transform_points(x, Ts)`
`utils3d.translate_2d` Translation matrix for 2D translation	-	`utils3d.pt.translate_2d(translation)`
`utils3d.unproject` Calculate inverse projection.	`utils3d.np.unproject(uv, depth, intrinsics, extrinsics, projection, view)`	`utils3d.pt.unproject(uv, depth, intrinsics, extrinsics, projection, view)`
`utils3d.unproject_cv` Unproject uv coordinates to 3D view space following the OpenCV convention	`utils3d.np.unproject_cv(uv, depth, intrinsics, extrinsics)`	`utils3d.pt.unproject_cv(uv, depth, intrinsics, extrinsics)`
`utils3d.unproject_gl` Unproject screen space coordinates to 3D view space following the OpenGL convention (except for row major matrices)	`utils3d.np.unproject_gl(uv, depth, projection, view)`	`utils3d.pt.unproject_gl(uv, depth, projection, view)`
`utils3d.uv_to_pixel` Convert UV space coordinates to pixel space coordinates.	`utils3d.np.uv_to_pixel(uv, size, pixel_convention)`	`utils3d.pt.uv_to_pixel(uv, size, pixel_convention)`
`utils3d.view_look_at` Get OpenGL view matrix looking at something	`utils3d.np.view_look_at(eye, look_at, up)`	`utils3d.pt.view_look_at(eye, look_at, up)`
`utils3d.view_to_extrinsics` OpenGL view matrix to OpenCV camera extrinsics	`utils3d.np.view_to_extrinsics(view)`	`utils3d.pt.view_to_extrinsics(view)`

Maps

Function	Numpy	Pytorch
`utils3d.bounding_rect_from_mask` Get bounding rectangle of a mask	-	`utils3d.pt.bounding_rect_from_mask(mask)`
`utils3d.build_mesh_from_depth_map` Get a mesh by lifting depth map to 3D, while removing depths of large depth difference.	`utils3d.np.build_mesh_from_depth_map(depth, other_maps, intrinsics, extrinsics, atol, rtol, tri)`	`utils3d.pt.build_mesh_from_depth_map(depth, other_maps, intrinsics, extrinsics, atol, rtol, tri)`
`utils3d.build_mesh_from_map` Get a mesh regarding image pixel uv coordinates as vertices and image grid as faces.	`utils3d.np.build_mesh_from_map(maps, mask, tri)`	`utils3d.pt.build_mesh_from_map(maps, mask, tri)`
`utils3d.chessboard` Get a chessboard image	`utils3d.np.chessboard(size, grid_size, color_a, color_b)`	`utils3d.pt.chessboard(size, grid_size, color_a, color_b)`
`utils3d.colorize_depth_map` Colorize depth map for visualization.	`utils3d.np.colorize_depth_map(depth, mask, near, far, cmap)`	-
`utils3d.colorize_normal_map` Colorize normal map for visualization. Value range is [-1, 1].	`utils3d.np.colorize_normal_map(normal, mask, flip_yz)`	-
`utils3d.depth_map_aliasing` Compute the map that indicates the aliasing of x depth map, identifying pixels which neither close to the maximum nor the minimum of its neighbors.	`utils3d.np.depth_map_aliasing(depth, atol, rtol, kernel_size, mask)`	`utils3d.pt.depth_map_aliasing(depth, atol, rtol, kernel_size, mask)`
`utils3d.depth_map_edge` Compute the edge mask from depth map. The edge is defined as the pixels whose neighbors have large difference in depth.	`utils3d.np.depth_map_edge(depth, atol, rtol, ltol, kernel_size, mask)`	`utils3d.pt.depth_map_edge(depth, atol, rtol, kernel_size, mask)`
`utils3d.depth_map_to_normal_map` Calculate normal map from depth map. Value range is [-1, 1]. Normal direction in OpenCV identity camera's coordinate system.	`utils3d.np.depth_map_to_normal_map(depth, intrinsics, mask, edge_threshold)`	`utils3d.pt.depth_map_to_normal_map(depth, intrinsics, mask)`
`utils3d.depth_map_to_point_map` Unproject depth map to 3D points.	`utils3d.np.depth_map_to_point_map(depth, intrinsics, extrinsics)`	`utils3d.pt.depth_map_to_point_map(depth, intrinsics, extrinsics)`
`utils3d.masked_area_resize` Resize 2D map by area sampling with mask awareness.	`utils3d.np.masked_area_resize(image, mask, size)`	`utils3d.pt.masked_area_resize(image, mask, size)`
`utils3d.masked_nearest_resize` Resize image(s) by nearest sampling with mask awareness.	`utils3d.np.masked_nearest_resize(image, mask, size, return_index)`	`utils3d.pt.masked_nearest_resize(image, mask, size, return_index)`
`utils3d.normal_map_edge` Compute the edge mask from normal map.	`utils3d.np.normal_map_edge(normals, tol, kernel_size, mask)`	-
`utils3d.pixel_coord_map` Get image pixel coordinates map, where (0, 0) is the top-left corner of the top-left pixel, and (width, height) is the bottom-right corner of the bottom-right pixel.	`utils3d.np.pixel_coord_map(size, top, left, convention, dtype)`	`utils3d.pt.pixel_coord_map(size, top, left, convention, dtype, device)`
`utils3d.point_map_to_normal_map` Calculate normal map from point map. Value range is [-1, 1].	`utils3d.np.point_map_to_normal_map(point, mask, edge_threshold)`	`utils3d.pt.point_map_to_normal_map(point, mask)`
`utils3d.screen_coord_map` Get screen space coordinate map, where (0., 0.) is the bottom-left corner of the image, and (1., 1.) is the top-right corner of the image.	`utils3d.np.screen_coord_map(size, top, left, bottom, right, dtype)`	`utils3d.pt.screen_coord_map(size, top, left, bottom, right, dtype, device)`
`utils3d.uv_map` Get image UV space coordinate map, where (0., 0.) is the top-left corner of the image, and (1., 1.) is the bottom-right corner of the image.	`utils3d.np.uv_map(size, top, left, bottom, right, dtype)`	`utils3d.pt.uv_map(size, top, left, bottom, right, dtype, device)`

Mesh

Function	Numpy	Pytorch
`utils3d.compute_boundaries` Compute boundary edges of a mesh.	-	`utils3d.pt.compute_boundaries(faces, edges, face2edge, edge_degrees)`
`utils3d.compute_face_corner_angles` Compute face corner angles of a mesh	`utils3d.np.compute_face_corner_angles(vertices, faces)`	`utils3d.pt.compute_face_corner_angles(vertices, faces)`
`utils3d.compute_face_corner_normals` Compute the face corner normals of a mesh	`utils3d.np.compute_face_corner_normals(vertices, faces, normalize)`	`utils3d.pt.compute_face_corner_normals(vertices, faces, normalize)`
`utils3d.compute_face_corner_tangents` Compute the face corner tangent (and bitangent) vectors of a mesh	`utils3d.np.compute_face_corner_tangents(vertices, uv, faces_vertices, faces_uv, normalize)`	`utils3d.pt.compute_face_corner_tangents(vertices, uv, faces_vertices, faces_uv, normalize)`
`utils3d.compute_face_normals` Compute face normals of a mesh	`utils3d.np.compute_face_normals(vertices, faces)`	`utils3d.pt.compute_face_normals(vertices, faces)`
`utils3d.compute_face_tangents` Compute the face corner tangent (and bitangent) vectors of a mesh	`utils3d.np.compute_face_tangents(vertices, uv, faces_vertices, faces_uv, normalize)`	`utils3d.pt.compute_face_tangents(vertices, uv, faces_vertices, faces_uv, normalize)`
`utils3d.compute_mesh_laplacian` Laplacian smooth with cotangent weights	-	`utils3d.pt.compute_mesh_laplacian(vertices, faces, weight)`
`utils3d.compute_vertex_normals` Compute vertex normals of a triangular mesh by averaging neighboring face normals	`utils3d.np.compute_vertex_normals(vertices, faces, weighted)`	-
`utils3d.create_camera_frustum_mesh` Create a triangle mesh of camera frustum.	`utils3d.np.create_camera_frustum_mesh(extrinsics, intrinsics, depth)`	-
`utils3d.create_cube_mesh` Create a cube mesh of size 1 centered at origin.	`utils3d.np.create_cube_mesh(tri)`	-
`utils3d.create_icosahedron_mesh` Create an icosahedron mesh of centered at origin.	`utils3d.np.create_icosahedron_mesh()`	-
`utils3d.create_square_mesh` Create a square mesh of area 1 centered at origin in the xy-plane.	`utils3d.np.create_square_mesh(tri)`	-
`utils3d.flatten_mesh_indices`	`utils3d.np.flatten_mesh_indices(args)`	-
`utils3d.graph_connected_components` Compute connected components of an undirected graph.	`utils3d.np.graph_connected_components(edges, num_vertices)`	`utils3d.pt.graph_connected_components(edges, num_vertices)`
`utils3d.laplacian_hc_smooth_mesh` HC algorithm from Improved Laplacian Smoothing of Noisy Surface Meshes by J.Vollmer et al.	-	`utils3d.pt.laplacian_hc_smooth_mesh(vertices, faces, times, alpha, beta, weight)`
`utils3d.laplacian_smooth_mesh` Laplacian smooth with cotangent weights	-	`utils3d.pt.laplacian_smooth_mesh(vertices, faces, weight, times)`
`utils3d.merge_duplicate_vertices` Merge duplicate vertices of a triangular mesh.	`utils3d.np.merge_duplicate_vertices(vertices, faces, tol)`	`utils3d.pt.merge_duplicate_vertices(vertices, faces, tol)`
`utils3d.merge_meshes` Merge multiple meshes into one mesh. Vertices will be no longer shared.	`utils3d.np.merge_meshes(meshes)`	-
`utils3d.mesh_adjacency_graph` Get adjacency graph of a mesh.	`utils3d.np.mesh_adjacency_graph(adjacency, faces, edges, num_vertices, self_loop)`	-
`utils3d.mesh_connected_components` Compute connected faces of a mesh.	`utils3d.np.mesh_connected_components(faces, num_vertices)`	`utils3d.pt.mesh_connected_components(faces, num_vertices)`
`utils3d.mesh_dual_graph` Get dual graph of a mesh. (Mesh face as dual graph's vertex, adjacency by edge sharing)	-	`utils3d.pt.mesh_dual_graph(faces)`
`utils3d.mesh_edges` Get undirected edges of a mesh. Optionally return additional mappings.	`utils3d.np.mesh_edges(faces, return_face2edge, return_edge2face, return_counts)`	`utils3d.pt.mesh_edges(faces, return_face2edge, return_edge2face, return_counts)`
`utils3d.mesh_half_edges` Get half edges of a mesh. Optionally return additional mappings.	`utils3d.np.mesh_half_edges(faces, return_face2edge, return_edge2face, return_twin, return_next, return_prev, return_counts)`	`utils3d.pt.mesh_half_edges(faces, return_face2edge, return_edge2face, return_twin, return_next, return_prev, return_counts)`
`utils3d.remove_corrupted_faces` Remove corrupted faces (faces with duplicated vertices)	`utils3d.np.remove_corrupted_faces(faces)`	`utils3d.pt.remove_corrupted_faces(faces)`
`utils3d.remove_isolated_pieces` Remove isolated pieces of a mesh.	-	`utils3d.pt.remove_isolated_pieces(vertices, faces, connected_components, thresh_num_faces, thresh_radius, thresh_boundary_ratio, remove_unreferenced)`
`utils3d.remove_unused_vertices` Remove unreferenced vertices of a mesh.	`utils3d.np.remove_unused_vertices(faces, vertice_attrs, return_indices)`	`utils3d.pt.remove_unused_vertices(faces, vertice_attrs, return_indices)`
`utils3d.subdivide_mesh` Subdivide a triangular mesh by splitting each triangle into 4 smaller triangles.	`utils3d.np.subdivide_mesh(vertices, faces, level)`	`utils3d.pt.subdivide_mesh(vertices, faces, n)`
`utils3d.taubin_smooth_mesh` Taubin smooth mesh	-	`utils3d.pt.taubin_smooth_mesh(vertices, faces, lambda_, mu_)`
`utils3d.triangulate_mesh` Triangulate a polygonal mesh.	`utils3d.np.triangulate_mesh(faces, vertices, method)`	`utils3d.pt.triangulate_mesh(faces, vertices, method)`

Rasterization

Function	Numpy	Pytorch
`utils3d.RastContext` Context for numpy-side rasterization. Based on moderngl.	`utils3d.np.RastContext(args, kwargs)`	`utils3d.pt.RastContext(nvd_ctx, backend, device)`
`utils3d.rasterize_lines` Rasterize lines.	`utils3d.np.rasterize_lines(ctx, size, vertices, lines, attributes, attributes_domain, view, projection, line_width, return_depth, return_interpolation, background_image, background_depth, background_interpolation_id, background_interpolation_uv)`	-
`utils3d.rasterize_point_cloud` Rasterize point cloud.	`utils3d.np.rasterize_point_cloud(ctx, size, points, point_sizes, point_size_in, point_shape, attributes, view, projection, return_depth, return_point_id, background_image, background_depth, background_point_id)`	-
`utils3d.rasterize_triangles` Rasterize triangles.	`utils3d.np.rasterize_triangles(ctx, size, vertices, attributes, attributes_domain, faces, view, projection, cull_backface, return_depth, return_interpolation, background_image, background_depth, background_interpolation_id, background_interpolation_uv)`	`utils3d.pt.rasterize_triangles(ctx, width, height, vertices, faces, attr, uv, texture, model, view, projection, antialiasing, diff_attrs)`
`utils3d.rasterize_triangles_peeling` Rasterize triangles with depth peeling.	`utils3d.np.rasterize_triangles_peeling(ctx, size, vertices, attributes, attributes_domain, faces, view, projection, cull_backface, return_depth, return_interpolation)`	`utils3d.pt.rasterize_triangles_peeling(ctx, vertices, faces, width, height, max_layers, attr, uv, texture, model, view, projection, antialiasing, diff_attrs)`
`utils3d.sample_texture` Sample from a texture map with a UV map.	`utils3d.np.sample_texture(ctx, uv_map, texture_map, interpolation, mipmap_level, repeat, anisotropic)`	`utils3d.pt.sample_texture(texture, uv, uv_da)`
`utils3d.test_rasterization` Test if rasterization works. It will render a cube with random colors and save it as a CHECKME.png file.	`utils3d.np.test_rasterization(ctx)`	-
`utils3d.texture_composite` Composite textures with depth peeling output.	-	`utils3d.pt.texture_composite(texture, uv, uv_da, background)`
`utils3d.warp_image_by_depth` Warp image by depth.	-	`utils3d.pt.warp_image_by_depth(ctx, depth, image, mask, width, height, extrinsics_src, extrinsics_tgt, intrinsics_src, intrinsics_tgt, near, far, antialiasing, backslash, padding, return_uv, return_dr)`
`utils3d.warp_image_by_forward_flow` Warp image by forward flow.	-	`utils3d.pt.warp_image_by_forward_flow(ctx, image, flow, depth, antialiasing, backslash)`

Utils

Function	Numpy	Pytorch
`utils3d.csr_eliminate_zeros` Remove zero elements from a sparse CSR tensor.	-	`utils3d.pt.csr_eliminate_zeros(input)`
`utils3d.csr_matrix_from_dense_indices` Convert a regular indices array to a sparse CSR adjacency matrix format	`utils3d.np.csr_matrix_from_dense_indices(indices, n_cols)`	`utils3d.pt.csr_matrix_from_dense_indices(indices, n_cols)`
`utils3d.group` Split the data into groups based on the provided labels.	`utils3d.np.group(labels, data)`	`utils3d.pt.group(labels, data)`
`utils3d.group_as_segments` Group as segments by labels	`utils3d.np.group_as_segments(labels, data)`	`utils3d.pt.group_as_segments(labels, data)`
`utils3d.lookup` Look up `query` in `key` like a dictionary. Useful for COO indexing.	`utils3d.np.lookup(key, query)`	`utils3d.pt.lookup(key, query)`
`utils3d.lookup_get` Dictionary-like get for arrays	`utils3d.np.lookup_get(key, value, get_key, default_value)`	`utils3d.pt.lookup_get(key, value, get_key, default_value)`
`utils3d.lookup_set` Dictionary-like set for arrays.	`utils3d.np.lookup_set(key, value, set_key, set_value, append, inplace)`	`utils3d.pt.lookup_set(key, value, set_key, set_value, append, inplace)`
`utils3d.masked_max` Similar to torch.max, but with mask	-	`utils3d.pt.masked_max(input, mask, dim, keepdim)`
`utils3d.masked_min` Similar to torch.min, but with mask	-	`utils3d.pt.masked_min(input, mask, dim, keepdim)`
`utils3d.max_pool_2d`	`utils3d.np.max_pool_2d(x, kernel_size, stride, padding, axis)`	-
`utils3d.pooling` Compute the pooling of the input array.	`utils3d.np.pooling(x, kernel_size, stride, padding, axis, mode)`	-
`utils3d.segment_roll` Roll the data within each segment.	`utils3d.np.segment_roll(data, offsets, shift)`	`utils3d.pt.segment_roll(data, offsets, shift)`
`utils3d.segment_take` Take some segments from a segmented array	`utils3d.np.segment_take(data, offsets, taking)`	`utils3d.pt.segment_take(data, offsets, taking)`
`utils3d.sliding_window` Get a sliding window of the input array. Window axis(axes) will be appended as the last dimension(s).	`utils3d.np.sliding_window(x, window_size, stride, pad_size, pad_mode, pad_value, axis)`	`utils3d.pt.sliding_window(x, window_size, stride, pad_size, pad_mode, pad_value, dim)`

Io

Function	Numpy	Pytorch
`utils3d.read_extrinsics_from_colmap` Read extrinsics from colmap `images.txt` file.	`utils3d.np.read_extrinsics_from_colmap(file)`	-
`utils3d.read_intrinsics_from_colmap` Read intrinsics from colmap `cameras.txt` file.	`utils3d.np.read_intrinsics_from_colmap(file, normalize)`	-
`utils3d.read_obj` Read wavefront .obj file, without preprocessing.	`utils3d.np.read_obj(file, encoding, ignore_unknown)`	-
`utils3d.write_extrinsics_as_colmap` Write extrinsics to colmap `images.txt` file.	`utils3d.np.write_extrinsics_as_colmap(file, extrinsics, image_names, camera_ids)`	-
`utils3d.write_intrinsics_as_colmap` Write intrinsics to colmap `cameras.txt` file. Currently only support PINHOLE model (no distortion)	`utils3d.np.write_intrinsics_as_colmap(file, intrinsics, width, height, normalized)`	-
`utils3d.write_obj`	`utils3d.np.write_obj(file, obj, encoding)`	-
`utils3d.write_simple_obj` Write wavefront .obj file, without preprocessing.	`utils3d.np.write_simple_obj(file, vertices, faces, encoding)`	-

License
- OSI Approved :: MIT License
Operating System
- OS Independent
Programming Language
- Python :: 3

Metadata

License
- OSI Approved :: MIT License
Operating System
- OS Independent
Programming Language
- Python :: 3

Release files for dlr-utils3d 1.3

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for dlr-utils3d 1.3
File	Size	Uploaded
dlr_utils3d-1.3.tar.gz	135.0 kB	Jun 17, 2026	Details

Built distribution (wheel)

Table of built distributions (wheels) for dlr-utils3d 1.3
File	Interpreter	ABI	Platform	Reset
dlr_utils3d-1.3-py3-none-any.whl 130.4 kB Jun 17, 2026	Python 3	none	any	Details

Total release size: 265.4 kB

Release files / dlr_utils3d-1.3.tar.gz

Download URL	dlr_utils3d-1.3.tar.gz
Size	135.0 kB
Tags	Source
SHA-256 checksum How to use checksums	`b8608ec5ba3ab3ca08f42da38ad2bc759d1c6da5a76db23f3a3cf063ee0a2823`
BLAKE2b-256 checksum How to use checksums	`9a67f3f784d3f9e4af9d549d0ebda6434015f64666d8db58e4cb777f8d1c7a53`
Upload date	Jun 17, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`twine/6.2.0 CPython/3.13.13`

Release files / dlr_utils3d-1.3-py3-none-any.whl

Download URL	dlr_utils3d-1.3-py3-none-any.whl
Size	130.4 kB
Tags	Python 3
SHA-256 checksum How to use checksums	`d8ec2e1266182469b386b49af38aed118ec4b21c3a0ab55d22272f1ce2d32d4c`
BLAKE2b-256 checksum How to use checksums	`62aa333ebbd95a85bd775b1858c946e4c60fbe882ff0402fcb44142a82b83640`
Upload date	Jun 17, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	No
Uploaded via	`twine/6.2.0 CPython/3.13.13`

Release history Release notifications | RSS feed

This release

1.3 This release

Jun 17, 2026 2 release files

dlr-utils3d 1.3