sog-decoder 0.1.0-rc.1

.sog 3D Gaussian Splatting data decoder
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use crate::error::ParseError;

#[derive(Debug, Clone, Default)]
pub struct Vector3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

impl Vector3 {
    pub fn new(x: f32, y: f32, z: f32) -> Self {
        Self { x, y, z }
    }
}

impl TryFrom<Vec<f32>> for Vector3 {
    type Error = ParseError;
    fn try_from(value: Vec<f32>) -> Result<Self, Self::Error> {
        if value.len() >= 3 {
            Ok(Self::new(value[0], value[1], value[2]))
        } else {
            Err(ParseError::ParseVector(
                "Vector must have at least 3 elements".to_string(),
            ))
        }
    }
}

#[derive(Debug, Clone)]
pub struct SogDataV2 {
    pub count: u32,
    pub antialias: bool,
    pub means: Means,
    pub scales: Scales,
    pub quats: Quats,
    pub sh_0: Sh0,
    pub sh_n: Option<ShN>,
}

#[derive(Debug, Clone)]
pub struct Codebook(pub [f32; 256]);

impl TryFrom<&[f32]> for Codebook {
    type Error = ParseError;
    fn try_from(value: &[f32]) -> Result<Self, Self::Error> {
        if value.len() >= 256 {
            let mut arr = [0.0f32; 256];
            arr.copy_from_slice(&value[..256]);
            Ok(Self(arr))
        } else {
            Err(ParseError::ParseCodebook(
                "Codebook must have at least 256 elements".to_string(),
            ))
        }
    }
}

pub type ImageData = Vec<u8>;

#[derive(Debug, Clone)]
pub struct Means {
    pub mins: Vector3,
    pub maxs: Vector3,
    pub means_u: ImageData,
    pub means_l: ImageData,
}

#[derive(Debug, Clone)]
pub struct Quats(pub ImageData);

#[derive(Debug, Clone)]
pub struct Scales {
    pub codebook: Codebook,
    pub scales: ImageData,
}

#[derive(Debug, Clone)]
pub struct Sh0 {
    pub codebook: Codebook,
    pub sh_0: ImageData,
}

#[derive(Debug, Clone)]
pub struct ShN {
    pub count: i32,
    pub bands: i32,
    pub codebook: Codebook,
    pub labels: ImageData,
    pub centroids: ImageData,
}

#[derive(Debug, Clone)]
pub struct Splat {
    pub count: usize,
    pub antialias: bool,
    pub sh_degree: usize,
    pub position: Vec<f32>,
    pub rotation: Vec<f32>,
    pub scale: Vec<f32>,
    pub sh_0: Vec<f32>,
    pub sh_n: Option<Vec<f32>>,
}