lc-gpx-utils 0.1.4

utilities for to generate kml and gpx files
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

#[derive(Debug, Clone, PartialEq)]
pub struct Style {
    /// the id, used as the `style_id` field in Placemark  
    pub id: String,
    pub icon_style_scale: f64,
    /// look at <https://kml4earth.appspot.com/icons.html>for instance
    pub icon_url: String,
    pub line_style_width: f64,
}

/// a Point
/// to have the point on the earth ground, set altitude to 0.0 and altitude_mode to [AltitudeMode::ErelativeToGround]
#[derive(Debug, Clone, PartialEq)]
pub struct Point {
    pub longitude: f64,
    pub latitude: f64,
    pub altitude: f64,
    pub altitude_mode: AltitudeMode,
}

/// a kml line string.
#[derive(Debug, Clone, PartialEq)]
pub struct LineString {
    pub extrude: u32,
    pub tessellate: u32,
    /// the altitude_mode of the points is ignored, altitude_mode of self is used instead
    pub altitude_mode: AltitudeMode,
    pub points: Vec<Point>,
}

/// @todo kml has other modes, for diving under sea, not implemented yet
#[derive(Debug, Clone, PartialEq)]
pub enum AltitudeMode {
    ErelativeToGround,
    /// 0 is the sea level
    Eabsolute,
}

/// a kml place marker, This is what you see in google earth, in the left tab
#[derive(Debug, Clone, PartialEq)]
pub struct Placemark {
    pub name: String,
    /// description. @todo : support CDATA, so you can have html code in the description
    pub description: String,
    /// a reference to the style, without the leading # as in the generated kml file
    pub style_id: Option<String>,
    /// a place marker has only one geo_element
    pub geo_element: GeoElement,
    pub visible: bool,
}

/// a kml folder, only contains placemarks or sub-folders
#[derive(Debug, Clone, PartialEq)]
pub struct Folder {
    pub name: String,
    pub description: String,
    pub elements: Vec<Element>,
}

/// a geoelement is the sum type for what is in a placemark
#[derive(Debug, Clone, PartialEq)]
pub enum GeoElement {
    EPoint(Point),
    ELineString(LineString),
}

/// a kml element, in this simple model, is either a folder or a placemark,
/// as you see in google earth or map in the left tab
#[derive(Debug, Clone, PartialEq)]
pub enum Element {
    EFolder(Folder),
    EPlacemark(Placemark),
}

/// a kml document, this is the root of the xml tree.
#[derive(Debug, Clone, PartialEq)]
pub struct Document {
    pub name: String,
    pub description: String,
    pub styles: Vec<Style>,
    pub elements: Vec<Element>,
}

impl From<Placemark> for Element {
    fn from(e: Placemark) -> Self {
        Element::EPlacemark(e)
    }
}

impl From<Point> for GeoElement {
    fn from(p: Point) -> Self {
        GeoElement::EPoint(p)
    }
}

impl Placemark {
    pub fn new_point_on_ground(
        name: String,
        description: String,
        style_id: Option<String>,
        longitude: f64,
        latitude: f64,
    ) -> Self {
        let geo_element: GeoElement = Point {
            longitude,
            latitude,
            altitude: 0f64,
            altitude_mode: AltitudeMode::ErelativeToGround,
        }
        .into();
        Placemark {
            name,
            description,
            geo_element,
            style_id,
            visible: true,
        }
    }
}

impl From<Folder> for Element {
    fn from(e: Folder) -> Self {
        Element::EFolder(e)
    }
}

impl Placemark {
    pub fn new_line(
        name: String,
        description: String,
        style_id: Option<String>,
        points: Vec<(f64, f64)>,
    ) -> Self {
        let points = points
            .iter()
            .map(|(longitude, latitude)| Point {
                longitude: *longitude,
                latitude: *latitude,
                altitude: 0f64,
                altitude_mode: AltitudeMode::ErelativeToGround,
            })
            .collect::<Vec<_>>();
        let geo_element: GeoElement = LineString {
            extrude: 1,
            tessellate: 1,
            altitude_mode: AltitudeMode::ErelativeToGround,
            points,
        }
        .into();
        Placemark {
            name,
            description,
            style_id,
            geo_element,
            visible: true,
        }
    }
}

impl From<LineString> for GeoElement {
    fn from(ls: LineString) -> Self {
        GeoElement::ELineString(ls)
    }
}