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
134
135
136
137
138

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},
};

use super::{traits::SignedDistance, Vec3};

/// Infinite plane, defined by origin point and normal direction.
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, Copy)]
pub struct Plane<T> {
    origin: Vec3<T>,
    normal: Vec3<T>,
}

static PLANE_PARAMS: &[Parameter; 2] = &[
    Parameter {
        name: "Origin",
        data_type: DataType::Vec3,
    },
    Parameter {
        name: "Normal",
        data_type: DataType::Vec3,
    },
];

impl<T: Float> Plane<T> {
    /// Create a new Plane from an origin point and a normal.
    ///
    /// # Arguments
    ///
    /// * `origin` - The location of the origin.
    /// * `normal` - The direction of the normal (z) direction.
    pub fn new(origin: Vec3<T>, normal: Vec3<T>) -> Self {
        Plane {
            origin,
            normal: normal.normalize(),
        }
    }

    /// Create a new global XY plane at the origin point `{0,0,0}`
    ///
    /// # Arguments
    ///
    /// * `origin` - The location of the origin.
    /// * `normal` - The direction of the normal (z) direction.
    pub fn xy() -> Self {
        Plane {
            origin: Vec3::origin(),
            normal: Vec3::z_axis().normalize(),
        }
    }

    /// Create a new global YZ plane at the origin point `{0,0,0}`
    pub fn yz() -> Self {
        Plane {
            origin: Vec3::origin(),
            normal: Vec3::x_axis().normalize(),
        }
    }

    /// Create a new global XZ plane at the origin point `{0,0,0}`
    pub fn xz() -> Self {
        Plane {
            origin: Vec3::origin(),
            normal: Vec3::y_axis().normalize(),
        }
    }

    /// Returns the origin of the plane.
    pub fn origin(&self) -> Vec3<T> {
        self.origin
    }

    /// Returns the normal of the plane.
    pub fn normal(&self) -> Vec3<T> {
        self.normal
    }

    /// Computes the signed distance to the plane from a point, based on x, y and z coordinates.
    ///
    /// Locations above the plane in the direction of the normal will return a positive distance. Locations below will be negative.
    ///
    /// # Arguments
    ///
    /// * `x` - X coordinate of the point.
    /// * `y` - Y coordinate of the point.
    /// * `z` - Z coordinate of the point.
    pub fn signed_distance_coord(&self, x: T, y: T, z: T) -> T {
        self.normal
            .dot_coord(x - self.origin.x, y - self.origin.y, z - self.origin.z)
    }
}

impl<T: ModelFloat> SignedDistance<T> for Plane<T> {
    fn signed_distance(&self, x: T, y: T, z: T) -> T {
        self.signed_distance_coord(x, y, z)
    }
}

impl<T: ModelFloat> ImplicitFunction<T> for Plane<T> {
    fn eval(&self, x: T, y: T, z: T) -> T {
        self.signed_distance_coord(x, y, z)
    }
}

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

    fn set_parameter(&mut self, parameter_name: &str, data: Data<T>) {
        if !(Parameter::set_vec3_from_param(parameter_name, &data, "Origin", &mut self.origin)
            || Parameter::set_vec3_from_param(parameter_name, &data, "Normal", &mut self.normal))
        {
            error!("Unknown parameter name: {}", parameter_name);
        }
    }

    fn read_parameter(&self, parameter_name: &str) -> Option<Data<T>> {
        match parameter_name {
            "Origin" => Some(Data::Vec3(self.origin)),
            "Normal" => Some(Data::Vec3(self.normal)),
            _ => None,
        }
    }

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