imlet 0.2.0

A lightweight engine for implicit modeling.
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::fmt::Debug;

use log::error;
use num_traits::Float;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

use crate::types::{
    computation::{
        model::{Data, DataType, Parameter},
        traits::{ImplicitComponent, ImplicitFunction, ModelFloat},
    },
    geometry::{BoundingBox, Vec3},
};

use super::traits::SignedDistance;

static SPHERE_PARAMS: &[Parameter; 2] = &[
    Parameter {
        name: "Centre",
        data_type: DataType::Vec3,
    },
    Parameter {
        name: "Radius",
        data_type: DataType::Value,
    },
];

/// A sphere defined by its centre point and radius.
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, Copy)]
pub struct Sphere<T> {
    pub centre: Vec3<T>,
    pub radius: T,
}

impl<T> Sphere<T> {
    /// Create a new sphere.
    /// # Arguments
    ///
    /// * `centre` -The centre point of the sphere.
    /// * `radius` -The radius of the sphere
    pub fn new(centre: Vec3<T>, radius: T) -> Self {
        Self { centre, radius }
    }

    /// Create a new sphere at a point defined by x, y and z coordinates.
    /// # Arguments
    ///
    /// * `x` -The x coord of the centre of the sphere.
    /// * `y` -The y coord of the centre of the sphere.
    /// * `z` -The z coord of the centre of the sphere.
    /// * `radius` -The radius of the sphere
    pub fn at_coord(x: T, y: T, z: T, radius: T) -> Self {
        Self {
            centre: Vec3::new(x, y, z),
            radius,
        }
    }
}

impl<T: Float> Sphere<T> {
    /// Compute the bounding box for the sphere
    pub fn bounds(&self) -> BoundingBox<T> {
        let min = self.centre - Vec3::new(self.radius, self.radius, self.radius);
        let max = self.centre + Vec3::new(self.radius, self.radius, self.radius);
        BoundingBox::new(min, max)
    }
}

impl<T: ModelFloat> SignedDistance<T> for Sphere<T> {
    fn signed_distance(&self, x: T, y: T, z: T) -> T {
        self.centre.distance_to_coord(x, y, z) - self.radius
    }
}

impl<T: ModelFloat> ImplicitFunction<T> for Sphere<T> {
    fn eval(&self, x: T, y: T, z: T) -> T {
        self.centre.distance_to_coord(x, y, z) - self.radius
    }
}

impl<T: ModelFloat> ImplicitComponent<T> for Sphere<T> {
    fn parameters(&self) -> &[Parameter] {
        SPHERE_PARAMS
    }

    fn set_parameter(&mut self, parameter_name: &str, data: Data<T>) {
        if !(Parameter::set_vec3_from_param(parameter_name, &data, "Centre", &mut self.centre)
            || Parameter::set_value_from_param(parameter_name, &data, "Radius", &mut self.radius))
        {
            error!("Unknown parameter name: {}", parameter_name);
        }
    }

    fn read_parameter(&self, parameter_name: &str) -> Option<Data<T>> {
        match parameter_name {
            "Centre" => Some(Data::Vec3(self.centre)),
            "Radius" => Some(Data::Value(self.radius)),
            _ => None,
        }
    }

    fn name(&self) -> &'static str {
        "Sphere"
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_get_assigns_params() {
        let mut sphere = Sphere::new(Vec3::new(1., 1., 1.), 10.);

        let params = sphere.parameters().to_vec();

        for param in params {
            match param.data_type {
                DataType::Value => sphere.set_parameter(param.name, Data::Value(1.)),
                DataType::Vec3 => {
                    sphere.set_parameter(param.name, Data::Vec3(Vec3::new(1., 1., 1.)))
                }
                _ => panic!("Error in the param"),
            }
        }

        assert!((sphere.radius - 1.).abs() < f64::epsilon());
        assert!(sphere.centre.distance_to_coord(1., 1., 1.).abs() < f64::epsilon());
    }
}