Struct GpuContext 

pub struct GpuContext {
    pub instance: Instance,
    pub device: Device,
    pub queue: Queue,
    pub adapter: Adapter,
    /* private fields */
}

GPU context for managing compute and rendering operations

Fields

instance: Instance

device: Device

queue: Queue

adapter: Adapter

Implementations

impl GpuContext

pub async fn new() -> Result<Self>

Create a new GPU context

pub fn from_parts( instance: Instance, adapter: Adapter, device: Device, queue: Queue, ) -> Self

Wrap a device the caller already created (for example to share it with a renderer). Pipelines are compiled on first use, as with Self::new.

pub fn create_buffer_init<T: Pod>( &self, label: &str, data: &[T], usage: BufferUsages, ) -> Buffer

Create a buffer from data

pub fn create_buffer( &self, label: &str, size: u64, usage: BufferUsages, ) -> Buffer

Create an empty buffer

pub fn create_compute_pipeline( &self, label: &str, shader: &ShaderModule, entry_point: &str, ) -> ComputePipeline

Create a compute pipeline

pub fn create_shader_module(&self, label: &str, source: &str) -> ShaderModule

Create a shader module from WGSL source

pub fn create_bind_group_layout( &self, label: &str, entries: &[BindGroupLayoutEntry], ) -> BindGroupLayout

Create a bind group layout

pub fn create_bind_group( &self, label: &str, layout: &BindGroupLayout, entries: &[BindGroupEntry<'_>], ) -> BindGroup

Create a bind group

impl GpuContext

pub async fn remove_statistical_outliers( &self, points: &[Point3f], k_neighbors: usize, std_dev_multiplier: f32, ) -> Result<Vec<Point3f>>

Remove statistical outliers from point cloud using GPU acceleration

pub async fn remove_radius_outliers( &self, points: &[Point3f], radius: f32, min_neighbors: usize, ) -> Result<Vec<Point3f>>

Remove radius outliers from point cloud using GPU acceleration.

A point is kept when at least min_neighbors other points lie within radius of it. Points with a NaN or infinite coordinate have no neighbors, so they are removed whenever min_neighbors > 0.

pub async fn voxel_grid_filter( &self, points: &[Point3f], voxel_size: f32, ) -> Result<Vec<Point3f>>

Voxel grid filtering using GPU acceleration

impl GpuContext

pub async fn batch_icp_align( &self, jobs: &[BatchICPJob], ) -> Result<Vec<BatchICPResult>>

Execute multiple ICP operations in parallel batches

pub async fn icp_align( &self, source: &PointCloud<Point3f>, target: &PointCloud<Point3f>, max_iterations: usize, convergence_threshold: f32, max_correspondence_distance: f32, ) -> Result<Isometry3<f32>>

GPU-accelerated ICP alignment (original single implementation)

impl GpuContext

pub async fn icp_point_to_plane_align( &self, source: &PointCloud<Point3f>, target: &PointCloud<Point3f>, target_normals: &[Vector3f], max_iterations: usize, convergence_threshold: f32, max_correspondence_distance: f32, ) -> Result<GpuPointToPlaneICPResult>

GPU-accelerated point-to-plane ICP.

The GPU matches points and sums the linearised 6×6 system (Chen & Medioni 1992); the CPU only solves it. Stops with the same rule as the CPU ICP (see icp_converged).

impl GpuContext

pub async fn find_k_nearest_neighbors( &self, points: &[Point3f], query_points: &[Point3f], k: usize, max_distance: f32, ) -> Result<Vec<Vec<(usize, f32)>>>

GPU-accelerated k-nearest neighbor search.

Builds a kd-tree over points once, uploads it, and answers every query on the GPU by walking the tree. Returns, for each query, up to k (point index, distance) pairs closer than max_distance, closest first. k is clamped to 1..=32.

impl GpuContext

pub async fn compute_normals_with_options( &self, points: &[Point3f], k_neighbors: usize, consistent_orientation: bool, viewpoint: Option<[f32; 3]>, ) -> Result<Vec<Vector3<f32>>>

Compute normals for a point cloud using GPU acceleration with options.

Uses the k nearest neighbors of each point (plus the point), like the CPU estimate_normals. k is clamped to 3..=31. With consistent_orientation, normals point towards viewpoint, or by default towards a point above the cloud’s bounding-box centre.

pub async fn compute_normals( &self, points: &[Point3f], k_neighbors: usize, ) -> Result<Vec<Vector3<f32>>>

Compute normals for a point cloud using GPU acceleration with default options

pub fn compute_neighbors_simple( &self, points: &[[f32; 3]], k: usize, ) -> Vec<[u32; 64]>

The k nearest neighbors of every point (not counting the point itself), padded to 64 slots by repeating the last neighbor. Used by the GPU statistical outlier filter. Runs on the CPU with a kd-tree.

pub fn compute_neighbors_simple_points3( &self, points: &[[f32; 3]], k: usize, ) -> Vec<[u32; 64]>

Helper to compute neighbors from Vec<[f32;3]> built from owned data

impl GpuContext

pub async fn segment_plane( &self, points: &[Point3f], config: GpuPlaneSegmentationConfig, ) -> Result<GpuPlaneSegmentationResult>

Segment the dominant plane using GPU-scored RANSAC candidates.

pub async fn segment_plane_ransac( &self, points: &[Point3f], threshold: f32, max_iters: usize, ) -> Result<GpuPlaneSegmentationResult>

Segment the dominant plane using GPU-scored RANSAC candidates.

pub async fn extract_clusters( &self, cloud: &PointCloud<Point3f>, config: GpuClusterConfig, ) -> Result<Vec<PointCloud<Point3f>>>

Extract Euclidean clusters as point-cloud values.

pub async fn extract_euclidean_clusters( &self, points: &[Point3f], config: &GpuEuclideanClusterConfig, ) -> Result<GpuClusterExtractionResult>

Extract Euclidean clusters using GPU-computed radius adjacency.

impl GpuContext

pub async fn tsdf_integrate( &self, volume: &mut TsdfVolume, depth_image: &[f32], color_image: Option<&[u8]>, camera_pose: &Matrix4<f32>, intrinsics: &CameraIntrinsics, ) -> Result<Vec<TsdfVoxel>>

Integrate depth image into TSDF volume

pub async fn tsdf_extract_surface( &self, volume: &TsdfVolume, voxels: &[TsdfVoxel], iso_value: f32, ) -> Result<PointCloud<ColoredPoint3f>>

Extract point cloud from TSDF volume using marching cubes