Struct SpzGaussians 

pub struct SpzGaussians {
    pub header: SpzGaussiansHeader,
    pub positions: SpzGaussiansPositions,
    pub scales: Vec<[u8; 3]>,
    pub rotations: SpzGaussiansRotations,
    pub alphas: Vec<u8>,
    pub colors: Vec<[u8; 3]>,
    pub shs: SpzGaussiansShs,
}

A collection of Gaussians in SPZ format.

Fields

header: SpzGaussiansHeader

positions: SpzGaussiansPositions

scales: Vec<[u8; 3]>

(x, y, z) each as 8-bit log-encoded integer.

rotations: SpzGaussiansRotations

alphas: Vec<u8>

8-bit unsigned integer.

colors: Vec<[u8; 3]>

(r, g, b) each as 8-bit unsigned integer.

shs: SpzGaussiansShs

Implementations

impl SpzGaussians

pub fn len(&self) -> usize

Get the number of Gaussians.

pub fn is_empty(&self) -> bool

Check if there are no Gaussians.

pub fn read_decompressed(reader: &mut impl Read) -> Result<Self, Error>

Read a SPZ from a decompressed buffer.

reader should be decompressed SPZ buffer.

pub fn read_header(reader: &mut impl Read) -> Result<SpzGaussiansHeader, Error>

Read a SPZ header.

reader should be decompressed SPZ buffer.

pub fn read_gaussians( reader: &mut impl Read, header: SpzGaussiansHeader, ) -> Result<Self, Error>

Read the SPZ Gaussians.

reader should be decompressed SPZ buffer positioned after the header.

header may be parsed by calling SpzGaussians::read_header.

pub fn write_decompressed(&self, writer: &mut impl Write) -> Result<(), Error>

Write the Gaussians to a SPZ buffer.

writer will receive the decompressed SPZ buffer.

pub fn from_gaussians( gaussians: impl IntoIterator<Item = impl AsRef<Gaussian>>, ) -> Self

Convert from a slice of Gaussians.

pub fn from_gaussians_with_options( gaussians: impl IntoIterator<Item = impl AsRef<Gaussian>>, options: &SpzGaussiansFromGaussianSliceOptions, ) -> Result<Self, Error>

Convert from a slice of Gaussians with options.

Examples found in repository

examples/write_spz.rs (lines 42-48)

fn main() {
    let model_path = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "target/output.spz".to_string());

    let gaussians = [
        gs::Gaussian {
            rot: Quat::from_axis_angle((Vec3::X + Vec3::Y / 2.0 + Vec3::Z).normalize(), 0.5),
            pos: Vec3::ZERO,
            scale: Vec3::new(0.5, 1.0, 0.75),
            color: U8Vec4::new(255, 0, 0, 255),
            sh: [Vec3::ZERO; 15],
        },
        gs::Gaussian {
            rot: Quat::from_axis_angle((Vec3::X + Vec3::Z / 3.0).normalize(), 0.3),
            pos: Vec3::new(0.0, 8.0, 4.0),
            scale: Vec3::new(1.0, 1.9, 0.75),
            color: U8Vec4::new(0, 255, 0, 255),
            sh: [Vec3::ZERO; 15],
        },
        gs::Gaussian {
            rot: Quat::from_axis_angle((Vec3::X - Vec3::Z).normalize(), 0.2),
            pos: Vec3::new(4.0, 0.0, 6.0),
            scale: Vec3::new(1.0, 1.1, 0.8),
            color: U8Vec4::new(0, 0, 255, 255),
            sh: [Vec3::ZERO; 15],
        },
    ];

    // Alternatively, use `SpzGaussians::from_gaussians` for default options.
    let gaussians = gs::SpzGaussians::from_gaussians_with_options(
        gaussians.as_slice(),
        &gs::SpzGaussiansFromGaussianSliceOptions {
            version: 2,
            ..Default::default()
        },
    )
    .expect("valid options");

    println!("Header: {:?}", gaussians.header);

    println!(
        "Writing {} gaussians to {}",
        gaussians.header.num_points(),
        model_path
    );

    gaussians
        .write_to_file(&model_path)
        .expect("write SPZ file");
}

pub fn from_iter( header: SpzGaussiansHeader, iter: impl IntoIterator<Item = SpzGaussian>, ) -> Result<Self, SpzGaussiansFromIterError>

Convert from an IntoIterator of SpzGaussians.

pub fn iter<'a>( &'a self, ) -> impl ExactSizeIterator<Item = SpzGaussianRef<'a>> + 'a

Get an iterator over Gaussian references.

Trait Implementations

impl Clone for SpzGaussians

fn clone(&self) -> SpzGaussians

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpzGaussians

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

Formats the value using the given formatter.

impl From<SpzGaussians> for Gaussians

fn from(value: SpzGaussians) -> Self

Converts to this type from the input type.

impl<G: AsRef<Gaussian>> FromIterator<G> for SpzGaussians

fn from_iter<T: IntoIterator<Item = G>>(iter: T) -> Self

Creates a value from an iterator.

impl IterGaussian for SpzGaussians

fn iter_gaussian(&self) -> impl ExactSizeIterator<Item = Gaussian> + '_

Iterate over Gaussian.

impl PartialEq for SpzGaussians

fn eq(&self, other: &SpzGaussians) -> 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 ReadIterGaussian for SpzGaussians

fn read_from(reader: &mut impl BufRead) -> Result<Self>

Read from a buffer.

fn read_from_file(path: impl AsRef<Path>) -> Result<Self>

Read from a file.

impl WriteIterGaussian for SpzGaussians

fn write_to(&self, writer: &mut impl Write) -> Result<()>

Write to a buffer.

fn write_to_file(&self, path: impl AsRef<Path>) -> Result<()>

Write to a file.

impl StructuralPartialEq for SpzGaussians