src.utils package

Submodules

src.utils.vector module

src.utils.vector.get_mps_device() → torch.device

src.utils.vector.cross_product_2d(p0: torch.Tensor, p1: torch.Tensor) → torch.Tensor

src.utils.vector.triangle_raycast(ray_origin: torch.Tensor, ray_dir: torch.Tensor, v1: torch.Tensor, v2: torch.Tensor, v3: torch.Tensor, epsilon=1e-08) → torch.Tensor | None

src.utils.vector.intersect_ray_line_2d(O, D, P1, P2, eps=1e-08)

Find intersection of a ray (O + tD, t>=0) with a line segment between P1 and P2.

All inputs are torch tensors of shape (…, 2) and can be batched.

src.utils.vector.triangle_raycast_batch(ray_origin: torch.Tensor, ray_dir: torch.Tensor, v1: torch.Tensor, v2: torch.Tensor, v3: torch.Tensor, epsilon=1e-08) → torch.Tensor

Batched ray-triangle intersection using Moller–Trumbore.

Parameters:

• ray_origin – (N, 3) origins

• ray_dir – (N, 3) directions (normalized)

• v1 – (M, 3) triangle vertices

• v2 – (M, 3) triangle vertices

• v3 – (M, 3) triangle vertices

Returns:

(N, M, 3) intersection points (NaN if no hit)

Return type:

intersections

src.utils.vector.pairwise_distances(pts)

src.utils.vector.pairwise_distances_cross(A, B)

src.utils.vector.compute_orthonormal_basis(forward_vector_3d, reference_vector_3d=None, device=None)

src.utils.vector.compute_model_view(camera_pos, camera_target_pos, device=None)

src.utils.vector.project_to_screen(world_points, model_view, fov, aspect, far, near, z_scale, device=None)

src.utils.vector.sample_cone(x, theta, k)

src.utils.vector.sample_semicircular_sweep(forward: torch.Tensor, left: torch.Tensor, up: torch.Tensor, interval: tuple[float, float] = (-0.5, 0.5), n_steps: int = 32) → torch.Tensor

Generate a semicircular sweep of direction vectors across the front hemisphere.

Parameters:

• forward (torch.Tensor) – (3,) normalized forward vector.

• left (torch.Tensor) – (3,) normalized left vector.

• up (torch.Tensor) – (3,) normalized up vector (unused except for completeness).

• n_steps (int) – Number of vectors in the sweep.

Returns:

(n_steps, 3) array of direction vectors.

Return type:

torch.Tensor

src.utils.vector.clipped_mean(points: torch.Tensor, std_thresh: float = 2.0)

Compute mean of 3D points, keeping only those within std_thresh stds of the mean.

points: (N,3) tensor std_thresh: threshold in standard deviations

src.utils.vector.interpolate(x0, x1, alpha)

src.utils.vector.smooth_mean(x0: torch.Tensor, sx1: torch.Tensor, alpha: float, std_threshold: float)

src.utils.vector.project(a: torch.Tensor, b: torch.Tensor)

src.utils.vector.extrapolate(P: torch.Tensor, source: torch.Tensor, dim=0)

src.utils.vector.triangle_altitude(a, b)

Module contents