draco-core 1.0.2

Pure Rust core encoder and decoder for Draco geometry compression
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

//! Attribute transform trait and transform-type enum.
//!
//! An attribute transform converts attribute values into a more compressible
//! "portable" integer representation before coding, and inverts it on decode
//! (e.g. quantization, octahedral normal mapping). [`AttributeTransform`] is the
//! shared interface; [`AttributeTransformType`] tags which transform was used.
//! Port of Draco's `attribute_transform.h`.

use crate::attribute_transform_data::AttributeTransformData;
#[cfg(feature = "decoder")]
use crate::decoder_buffer::DecoderBuffer;
use crate::draco_types::DataType;
#[cfg(feature = "encoder")]
use crate::encoder_buffer::EncoderBuffer;
use crate::geometry_attribute::PointAttribute;
use crate::geometry_indices::PointIndex;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AttributeTransformType {
    InvalidTransform = -1,
    NoTransform = 0,
    QuantizationTransform = 1,
    OctahedronTransform = 2,
}

impl TryFrom<u8> for AttributeTransformType {
    type Error = ();
    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(AttributeTransformType::NoTransform),
            1 => Ok(AttributeTransformType::QuantizationTransform),
            2 => Ok(AttributeTransformType::OctahedronTransform),
            _ => Err(()),
        }
    }
}

pub trait AttributeTransform {
    fn transform_type(&self) -> AttributeTransformType;

    fn init_from_attribute(&mut self, attribute: &PointAttribute) -> bool;

    fn copy_to_attribute_transform_data(&self, out_data: &mut AttributeTransformData);

    fn transform_attribute(
        &self,
        attribute: &PointAttribute,
        point_ids: &[PointIndex],
        target_attribute: &mut PointAttribute,
    ) -> bool;

    fn inverse_transform_attribute(
        &self,
        attribute: &PointAttribute,
        target_attribute: &mut PointAttribute,
    ) -> bool;

    #[cfg(feature = "encoder")]
    fn encode_parameters(&self, encoder_buffer: &mut EncoderBuffer) -> bool;

    #[cfg(feature = "decoder")]
    fn decode_parameters(
        &mut self,
        attribute: &PointAttribute,
        decoder_buffer: &mut DecoderBuffer,
    ) -> bool;

    fn get_transformed_data_type(&self, attribute: &PointAttribute) -> DataType;
    fn get_transformed_num_components(&self, attribute: &PointAttribute) -> i32;
}