Struct SpzGaussiansHeader 

pub struct SpzGaussiansHeader(/* private fields */);

Header of SPZ Gaussians file.

This is the validated version of SpzGaussiansHeaderPod. This is simply a wrapper around SpzGaussiansHeaderPod that ensures the values are valid, we could also implement specialized structs for each field but it would be overkill for now.

Implementations

impl SpzGaussiansHeader

pub const MAGIC: u32 = 1_347_635_022u32

The magic number for SPZ Gaussians files.

pub const SUPPORTED_VERSIONS: RangeInclusive<u32>

The supported SPZ versions.

pub const SUPPORTED_SH_DEGREES: RangeInclusive<u8>

The supported SH degrees.

pub fn new( version: u32, num_points: u32, sh_degree: SpzGaussianShDegree, fractional_bits: u8, antialiased: bool, ) -> Result<Self, Error>

Create a SpzGaussiansHeader.

Returns an error if the header is invalid.

pub fn try_from_pod(pod: SpzGaussiansHeaderPod) -> Result<Self, Error>

Validate and create a validated SPZ Gaussians header.

pub fn default(num_points: u32) -> Result<Self, Error>

Create a default SpzGaussiansHeader from number of points and SH degree.

pub fn as_pod(&self) -> &SpzGaussiansHeaderPod

Get the SpzGaussiansHeaderPod.

pub fn version(&self) -> u32

Get the version of the SPZ file.

pub fn set_num_points(&mut self, num_points: u32)

Set the number of points.

Setting the number of points does not invalidate the header.

pub fn num_points(&self) -> usize

Get the number of points in the SPZ file.

Examples found in repository

examples/write_spz.rs (line 55)

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 sh_degree(&self) -> SpzGaussianShDegree

Get the SH degree of the SPZ file.

pub fn sh_num_coefficients(&self) -> usize

Get the number of SH coefficients.

pub fn fractional_bits(&self) -> u8

Get the number of fractional bits.

pub fn is_antialiased(&self) -> bool

Check if the antialiased flag is set.

pub fn uses_float16(&self) -> bool

Check if float16 encoding is used.

pub fn uses_quat_smallest_three(&self) -> bool

Check if quaternion smallest three encoding is used.

Trait Implementations

impl Clone for SpzGaussiansHeader

fn clone(&self) -> SpzGaussiansHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpzGaussiansHeader

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

Formats the value using the given formatter.

impl PartialEq for SpzGaussiansHeader

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

impl Eq for SpzGaussiansHeader

impl StructuralPartialEq for SpzGaussiansHeader