Debian Codegraph @

ogr/ogrsf_frmts/xodr/ogr_xodr.h

raw
1 /******************************************************************************
2 * Project: OpenGIS Simple Features for OpenDRIVE
3 * Purpose: Definition of OGR driver components for OpenDRIVE.
4 * Author: Michael Scholz, German Aerospace Center (DLR)
5 * Gülsen Bardak, German Aerospace Center (DLR)
6 *
7 ******************************************************************************
8 * Copyright 2024 German Aerospace Center (DLR), Institute of Transportation Systems
9 *
10 * SPDX-License-Identifier: MIT
11 ****************************************************************************/
12
13 #pragma once
14 #include "ogrsf_frmts.h"
15 #include "ogr_api.h"
16 #include <iostream>
17 #include <OpenDriveMap.h>
18 #include <pugixml/pugixml.hpp>
19 #include <vector>
20
21 struct RoadElements
22 {
23 /* Map of road to its original OpenDRIVE ID for fast lookup. */
24 std::map<std::string, odr::Road> roads{};
25 std::vector<odr::Line3D> referenceLines{};
26
27 std::vector<odr::Lane> lanes{};
28 std::vector<odr::LaneSection> laneSections{};
29 std::vector<std::string> laneRoadIDs{};
30 std::vector<odr::Mesh3D> laneMeshes{};
31
32 std::vector<odr::Line3D> laneLinesInner{};
33 std::vector<odr::Line3D> laneLinesOuter{};
34
35 std::vector<odr::RoadMark> roadMarks{};
36 std::vector<odr::Mesh3D> roadMarkMeshes{};
37
38 std::vector<odr::RoadObject> roadObjects{};
39 std::vector<odr::Mesh3D> roadObjectMeshes{};
40
41 std::vector<odr::RoadSignal> roadSignals{};
42 std::vector<odr::Mesh3D> roadSignalMeshes{};
43 };
44
45 /*--------------------------------------------------------------------*/
46 /*--------------------- Layer declarations -------------------------*/
47 /*--------------------------------------------------------------------*/
48
49 class OGRXODRLayer : public OGRLayer
50 {
51 private:
52 const OGRFeatureDefn *GetLayerDefn() const override
53 {
54 return m_poFeatureDefn.get();
55 }
56
57 /**
58 * Initializes XODR road elements and iterators.
59 */
60 void resetRoadElementIterators();
61
62 protected:
63 RoadElements m_roadElements{};
64 bool m_bDissolveTIN{false};
65 OGRSpatialReference m_oSRS{};
66 /* Unique feature ID which is automatically incremented for any new road feature creation. */
67 int m_nNextFID{0};
68
69 std::map<std::string, odr::Road>::iterator m_roadIter{};
70 std::vector<odr::Line3D>::iterator m_referenceLineIter{};
71
72 std::vector<odr::Lane>::iterator m_laneIter{};
73 std::vector<odr::LaneSection>::iterator m_laneSectionIter{};
74 std::vector<std::string>::iterator m_laneRoadIDIter{};
75 std::vector<odr::Mesh3D>::iterator m_laneMeshIter{};
76
77 std::vector<odr::Line3D>::iterator m_laneLinesInnerIter{};
78 std::vector<odr::Line3D>::iterator m_laneLinesOuterIter{};
79
80 std::vector<odr::RoadMark>::iterator m_roadMarkIter{};
81 std::vector<odr::Mesh3D>::iterator m_roadMarkMeshIter{};
82
83 std::vector<odr::RoadObject>::iterator m_roadObjectIter{};
84 std::vector<odr::Mesh3D>::iterator m_roadObjectMeshesIter{};
85
86 std::vector<odr::RoadSignal>::iterator m_roadSignalIter{};
87 std::vector<odr::Mesh3D>::iterator m_roadSignalMeshesIter{};
88
89 std::unique_ptr<OGRFeatureDefn> m_poFeatureDefn{};
90
91 /**
92 * Builds an ordinary TIN from libOpenDRIVE's mesh.
93 */
94 std::unique_ptr<OGRTriangulatedSurface>
95 triangulateSurface(const odr::Mesh3D &mesh);
96
97 public:
98 OGRXODRLayer(const RoadElements &xodrRoadElements,
99 const std::string &proj4Defn);
100 /**
101 * \param dissolveTriangulatedSurface True if original triangulated surface meshes from
102 * libOpenDRIVE are to be dissolved into simpler geometries.
103 * Only applicable for layer types derived from meshes.
104 */
105 OGRXODRLayer(const RoadElements &xodrRoadElements,
106 const std::string &proj4Defn,
107 const bool dissolveTriangulatedSurface);
108 void ResetReading() override;
109 };
110
111 class OGRXODRLayerReferenceLine
112 : public OGRXODRLayer,
113 public OGRGetNextFeatureThroughRaw<OGRXODRLayerReferenceLine>
114 {
115 protected:
116 OGRFeature *GetNextRawFeature();
117
118 public:
119 const std::string FEATURE_CLASS_NAME = "ReferenceLine";
120
121 OGRXODRLayerReferenceLine(const RoadElements &xodrRoadElements,
122 const std::string &proj4Defn);
123 int TestCapability(const char *pszCap) const override;
124 DEFINE_GET_NEXT_FEATURE_THROUGH_RAW(OGRXODRLayerReferenceLine)
125 };
126
127 class OGRXODRLayerLaneBorder
128 : public OGRXODRLayer,
129 public OGRGetNextFeatureThroughRaw<OGRXODRLayerLaneBorder>
130 {
131 protected:
132 OGRFeature *GetNextRawFeature();
133
134 public:
135 const std::string FEATURE_CLASS_NAME = "LaneBorder";
136
137 OGRXODRLayerLaneBorder(const RoadElements &xodrRoadElements,
138 const std::string &proj4Defn);
139 int TestCapability(const char *pszCap) const override;
140 DEFINE_GET_NEXT_FEATURE_THROUGH_RAW(OGRXODRLayerLaneBorder)
141 };
142
143 class OGRXODRLayerRoadMark
144 : public OGRXODRLayer,
145 public OGRGetNextFeatureThroughRaw<OGRXODRLayerRoadMark>
146
147 {
148 protected:
149 OGRFeature *GetNextRawFeature();
150
151 public:
152 const std::string FEATURE_CLASS_NAME = "RoadMark";
153
154 OGRXODRLayerRoadMark(const RoadElements &xodrRoadElements,
155 const std::string &proj4Defn,
156 const bool dissolveTriangulatedSurface);
157 int TestCapability(const char *pszCap) const override;
158 DEFINE_GET_NEXT_FEATURE_THROUGH_RAW(OGRXODRLayerRoadMark)
159 };
160
161 class OGRXODRLayerRoadObject
162 : public OGRXODRLayer,
163 public OGRGetNextFeatureThroughRaw<OGRXODRLayerRoadObject>
164 {
165 protected:
166 OGRFeature *GetNextRawFeature();
167
168 public:
169 const std::string FEATURE_CLASS_NAME = "RoadObject";
170
171 OGRXODRLayerRoadObject(const RoadElements &xodrRoadElements,
172 const std::string &proj4Defn);
173 int TestCapability(const char *pszCap) const override;
174 DEFINE_GET_NEXT_FEATURE_THROUGH_RAW(OGRXODRLayerRoadObject)
175 };
176
177 class OGRXODRLayerRoadSignal
178 : public OGRXODRLayer,
179 public OGRGetNextFeatureThroughRaw<OGRXODRLayerRoadSignal>
180 {
181 protected:
182 OGRFeature *GetNextRawFeature();
183
184 public:
185 const std::string FEATURE_CLASS_NAME = "RoadSignal";
186
187 OGRXODRLayerRoadSignal(const RoadElements &xodrRoadElements,
188 const std::string &proj4Defn,
189 const bool dissolveTriangulatedSurface);
190 int TestCapability(const char *pszCap) const override;
191 DEFINE_GET_NEXT_FEATURE_THROUGH_RAW(OGRXODRLayerRoadSignal)
192 };
193
194 class OGRXODRLayerLane : public OGRXODRLayer,
195 public OGRGetNextFeatureThroughRaw<OGRXODRLayerLane>
196 {
197 protected:
198 OGRFeature *GetNextRawFeature();
199
200 public:
201 const std::string FEATURE_CLASS_NAME = "Lane";
202
203 OGRXODRLayerLane(const RoadElements &xodrRoadElements,
204 const std::string &proj4Defn,
205 const bool dissolveTriangulatedSurface);
206 int TestCapability(const char *pszCap) const override;
207 DEFINE_GET_NEXT_FEATURE_THROUGH_RAW(OGRXODRLayerLane)
208 };
209
210 /*--------------------------------------------------------------------*/
211 /*-------------------- Data source declarations ----------------------*/
212 /*--------------------------------------------------------------------*/
213
214 class OGRXODRDataSource : public GDALDataset
215 {
216 private:
217 std::vector<std::unique_ptr<OGRXODRLayer>> m_apoLayers{};
218
219 /**
220 * Approximation factor for sampling of continuous geometry functions into discrete
221 * OGC Simple Feature geometries.
222 */
223 double m_dfEpsilon{1.0};
224
225 /**
226 * Retrieves all necessary road elements from the underlying OpenDRIVE structure.
227 *
228 * \param roads Roads of the dataset.
229 */
230 RoadElements createRoadElements(const std::vector<odr::Road> &roads);
231
232 public:
233 bool Open(const char *pszFilename, CSLConstList openOptions);
234
235 int GetLayerCount() const override
236 {
237 return static_cast<int>(m_apoLayers.size());
238 }
239
240 const OGRLayer *GetLayer(int) const override;
241
242 int TestCapability(const char *pszCap) const override;
243 };