Struct BlueNoiseApprox 

pub struct BlueNoiseApprox { /* private fields */ }

Blue noise approximation using multiple octaves.

Hybrid approach that combines InterleavedGradientNoise with SpatialHash to approximate true blue noise characteristics. Better quality than either method alone, without the memory cost of real blue noise tables.

Implementations

impl BlueNoiseApprox

pub fn new(seed: u32) -> Self

Trait Implementations

impl Clone for BlueNoiseApprox

fn clone(&self) -> BlueNoiseApprox

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlueNoiseApprox

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

Formats the value using the given formatter.

impl Hash for BlueNoiseApprox

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BlueNoiseApprox

fn eq(&self, other: &BlueNoiseApprox) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SpatialRng for BlueNoiseApprox

fn new(seed: u32) -> Self

Create a new spatial RNG with the given seed.

fn compute(&self, x: u32, y: u32) -> f32

Compute a deterministic value for given 2D coordinates. Returns a value in range [-1, 1].

fn dither_2d<T>( &self, value: T, min: T, one: T, dither_amplitude: T, x: u32, y: u32, ) -> T

where T: DitherFloat, Self: Sized,

Dither a single value using 2D coordinates.

fn simple_dither_2d<T>(&self, value: T, one: T, x: u32, y: u32) -> T

where T: DitherFloat + Number + CastableFrom<f32>, Self: Sized,

Simple dither for a single value using 2D coordinates.

fn dither_slice_2d<T>( &self, values: &mut [T], width: usize, min: T, one: T, dither_amplitude: T, )

where T: DitherFloat + Send + Sync, Self: Sized,

Dither a 2D image stored as a flat slice (parallel version).

fn simple_dither_slice_2d<T>(&self, values: &mut [T], width: usize, one: T)

where T: DitherFloat + Number + CastableFrom<f32> + Send + Sync, Self: Sized,

Simple dither for a 2D image stored as a flat slice (parallel version).

fn dither_float_2d<Src, Dest>(&self, value: Src, x: u32, y: u32) -> Dest

where Src: DitherFloatConversion<Dest> + DitherFloat + CastableFrom<f64>, Self: Sized,

Dither a float value when converting to lower precision using 2D coordinates.

fn dither_float_slice_2d<Src, Dest>( &self, values: &[Src], width: usize, ) -> Vec<Dest>

where Src: DitherFloatConversion<Dest> + DitherFloat + CastableFrom<f64> + Copy + Send + Sync, Dest: Send, Self: Sized,

Dither float values in a 2D image slice when converting to lower precision (parallel version).

impl Copy for BlueNoiseApprox

impl Eq for BlueNoiseApprox

impl StructuralPartialEq for BlueNoiseApprox