dlr-utils3d 1.3

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

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)	-