Struct coupe::ZCurve

pub struct ZCurve {
    pub part_count: usize,
    pub order: u32,
}

Z space-filling curve algorithm

The Z-curve uses space hashing to partition points. The points in the same part of a partition have the same Z-hash. This hash is computed by recursively constructing a N-dimensional region tree.

Example

use coupe::Partition as _;
use coupe::Point2D;

let points = [
    Point2D::new(0., 0.),
    Point2D::new(1., 1.),
    Point2D::new(0., 10.),
    Point2D::new(1., 9.),
    Point2D::new(9., 1.),
    Point2D::new(10., 0.),
    Point2D::new(10., 10.),
    Point2D::new(9., 9.),
];
let mut partition = [0; 8];

// generate a partition of 4 parts
coupe::ZCurve { part_count: 4, order: 5 }
    .partition(&mut partition, &points)?;

assert_eq!(partition[0], partition[1]);
assert_eq!(partition[2], partition[3]);
assert_eq!(partition[4], partition[5]);
assert_eq!(partition[6], partition[7]);

Fields

part_count: usize

order: u32

Trait Implementations

impl Clone for ZCurve

fn clone(&self) -> ZCurve

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ZCurve

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, const D: usize> Partition<&'a [Matrix<f64, Const<D>, Const<1>, ArrayStorage<f64, D, 1>>]> for ZCurvewhere Const<D>: DimSub<Const<1>> + ToTypenum, DefaultAllocator: Allocator<f64, Const<D>, Const<D>, Buffer = ArrayStorage<f64, D, D>> + Allocator<f64, DimDiff<Const<D>, Const<1>>>,

type Metadata = ()

Diagnostic data returned for a specific run of the algorithm.

type Error = Infallible

Error details, should the algorithm fail to run.

fn partition( &mut self, part_ids: &mut [usize], points: &'a [PointND<D>] ) -> Result<Self::Metadata, Self::Error>

Partition the given data and output the part ID of each element in part_ids.

impl Copy for ZCurve