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

#![allow(dead_code)]
use crate::transformation::*;

#[derive(Debug, Clone)]
/// A scale transformation of a crystal, to get from standard orthogonal coordinates to fractional coordinates
pub struct Scale {
    /// The transformation from standard orthogonal coordinates to fractional coordinates
    transformation: TransformationMatrix,
    /// For validation, only if all rows are set this scale is valid
    rows_set: [bool; 3],
}

impl Scale {
    /// Create an empty transformation (identity)
    pub fn new() -> Self {
        Scale {
            transformation: TransformationMatrix::identity(),
            rows_set: [true, true, true],
        }
    }
    /// Get the transformation from standard orthogonal coordinates to fractional coordinates
    pub fn transformation(&self) -> &TransformationMatrix {
        &self.transformation
    }
    /// Set the transformation from standard orthogonal coordinates to fractional coordinates
    pub fn set_transformation(&mut self, transformation: TransformationMatrix) {
        self.transformation = transformation;
    }
    /// Set a row to the given data, this invalidates all other rows if the scale was valid before
    /// otherwise it validates the row given.
    /// To have a valid Scale all rows have to be set.
    ///
    /// ## Arguments
    /// * `row` - 0-based row to fill the data into
    /// * `data` - the row of data
    ///
    /// ## Example
    ///
    /// ```
    /// use pdbtbx::TransformationMatrix;
    /// use pdbtbx::Scale;
    /// let mut example = Scale::new();
    /// example.set_row(1, [0.0, 1.0, 0.0, 0.0]);
    /// example.set_row(2, [0.0, 0.0, 1.0, 0.0]);
    /// example.set_row(0, [1.0, 0.0, 0.0, 0.0]); // The order does not matter
    /// assert_eq!(example.transformation(), &TransformationMatrix::identity());
    /// assert!(example.valid());
    /// ```
    pub fn set_row(&mut self, row: usize, data: [f64; 4]) {
        if row > 2 {
            panic!(format!(
                "Row in Scale.set_row is too big (max 2, value: {})",
                row
            ));
        }
        let mut matrix = self.transformation.matrix();
        matrix[row] = data;
        self.transformation.set_matrix(matrix);
        if self.rows_set == [true, true, true] {
            self.rows_set = [false, false, false];
        }
        self.rows_set[row] = true;
    }
    /// Checks if this Scale is valid, for this all rows have to be set (also see `set_row`).
    /// Mainly used to validate a structure after parsing.
    pub fn valid(&self) -> bool {
        self.rows_set == [true, true, true]
    }
}

impl PartialEq for Scale {
    fn eq(&self, other: &Self) -> bool {
        self.transformation == other.transformation
    }
}

impl Default for Scale {
    fn default() -> Self {
        Self::new()
    }
}