ecitygml-core 0.0.2-alpha.3

Core primitives and operations for processing CityGML data.
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

use egml::model::base::Id;
use egml::model::feature::BoundingShape;
use egml::model::geometry::Envelope;
use nalgebra::Isometry3;

#[derive(Debug, Clone, PartialEq)]
pub struct AbstractFeature {
    pub(crate) abstract_feature: egml::model::feature::AbstractFeature,
}

impl AbstractFeature {
    pub fn new(id: Id) -> Self {
        let abstract_gml = egml::model::base::AbstractGml::with_id(id);
        let abstract_feature = egml::model::feature::AbstractFeature::new(abstract_gml);

        Self { abstract_feature }
    }

    pub fn with_gml_abstract_feature(
        abstract_feature: egml::model::feature::AbstractFeature,
    ) -> Self {
        Self { abstract_feature }
    }

    pub fn gml_abstract_feature(&self) -> &egml::model::feature::AbstractFeature {
        &self.abstract_feature
    }

    pub fn id(&self) -> &Id {
        self.abstract_feature
            .abstract_gml
            .id
            .as_ref()
            .expect("id must be set for AbstractFeature")
    }

    pub fn name(&self) -> &Vec<String> {
        &self.abstract_feature.abstract_gml.name
    }

    pub fn set_name(&mut self, name: Vec<String>) {
        self.abstract_feature.abstract_gml.name = name;
    }

    pub fn bounded_by(&self) -> Option<&Envelope> {
        self.abstract_feature.bounded_by.as_ref()?.envelope.as_ref()
    }

    pub fn set_bounding_shape(&mut self, bounding_shape: Option<BoundingShape>) {
        self.abstract_feature.bounded_by = bounding_shape;
    }

    pub fn apply_transform(&mut self, m: &Isometry3<f64>) {
        if let Some(bounding_shape) = self.abstract_feature.bounded_by.as_mut()
            && let Some(envelope) = &mut bounding_shape.envelope
        {
            envelope.apply_transform(m);
        }
    }
}

pub trait AsAbstractFeature {
    fn abstract_feature(&self) -> &AbstractFeature;

    fn id(&self) -> &Id {
        self.abstract_feature().id()
    }

    fn name(&self) -> &Vec<String> {
        self.abstract_feature().name()
    }

    fn bounded_by(&self) -> Option<&Envelope> {
        self.abstract_feature().bounded_by()
    }
}

pub trait AsAbstractFeatureMut: AsAbstractFeature {
    fn abstract_feature_mut(&mut self) -> &mut AbstractFeature;

    fn set_name(&mut self, name: Vec<String>) {
        self.abstract_feature_mut().set_name(name);
    }

    fn set_bounding_shape_from_envelope(&mut self, envelope: Option<Envelope>) {
        let bounding_shape = envelope.map(BoundingShape::new);
        self.abstract_feature_mut()
            .set_bounding_shape(bounding_shape);
    }

    fn set_bounding_shape(&mut self, bounding_shape: Option<BoundingShape>) {
        self.abstract_feature_mut()
            .set_bounding_shape(bounding_shape);
    }
}

impl AsAbstractFeature for AbstractFeature {
    fn abstract_feature(&self) -> &AbstractFeature {
        self
    }
}

impl AsAbstractFeatureMut for AbstractFeature {
    fn abstract_feature_mut(&mut self) -> &mut AbstractFeature {
        self
    }
}