51 const Boundary& orig,
const Boundary& conv,
double scale,
double rot,
bool inverse,
bool flatten):
54 myProjection(nullptr),
55 myInverseProjection(nullptr),
56 myGeoProjection(nullptr),
62 myProjectionMethod(
NONE),
63 myUseInverseProjection(inverse),
66 myConvBoundary(conv) {
69 }
else if (proj ==
"-") {
71 }
else if (proj ==
"UTM") {
73 }
else if (proj ==
"DHDN") {
75 }
else if (proj ==
"DHDN_UTM") {
81 if (myProjection ==
nullptr) {
83 initProj(std::regex_replace(proj, std::regex(
"\\+geoidgrids[^ ]*"), std::string(
"")));
85 if (myProjection ==
nullptr) {
96 GeoConvHelper::initProj(
const std::string& proj) {
97 #ifdef PROJ_VERSION_MAJOR
98 myProjection = proj_create(PJ_DEFAULT_CTX, proj.c_str());
100 myProjection = pj_init_plus(proj.c_str());
108 if (myProjection !=
nullptr) {
109 #ifdef PROJ_VERSION_MAJOR
110 proj_destroy(myProjection);
112 pj_free(myProjection);
115 if (myInverseProjection !=
nullptr) {
116 #ifdef PROJ_VERSION_MAJOR
117 proj_destroy(myInverseProjection);
119 pj_free(myInverseProjection);
122 if (myGeoProjection !=
nullptr) {
123 #ifdef PROJ_VERSION_MAJOR
124 proj_destroy(myGeoProjection);
126 pj_free(myGeoProjection);
161 if (myProjection !=
nullptr) {
162 #ifdef PROJ_VERSION_MAJOR
163 proj_destroy(myProjection);
165 pj_free(myProjection);
167 myProjection =
nullptr;
169 if (myInverseProjection !=
nullptr) {
170 #ifdef PROJ_VERSION_MAJOR
171 proj_destroy(myInverseProjection);
173 pj_free(myInverseProjection);
175 myInverseProjection =
nullptr;
177 if (myGeoProjection !=
nullptr) {
178 #ifdef PROJ_VERSION_MAJOR
179 proj_destroy(myGeoProjection);
181 pj_free(myGeoProjection);
183 myGeoProjection =
nullptr;
185 if (orig.myProjection !=
nullptr) {
186 #ifdef PROJ_VERSION_MAJOR
187 myProjection = proj_create(PJ_DEFAULT_CTX, orig.
myProjString.c_str());
192 if (orig.myInverseProjection !=
nullptr) {
193 #ifdef PROJ_VERSION_MAJOR
194 myInverseProjection = orig.myInverseProjection;
196 myInverseProjection = pj_init_plus(pj_get_def(orig.myInverseProjection, 0));
199 if (orig.myGeoProjection !=
nullptr) {
200 #ifdef PROJ_VERSION_MAJOR
201 myGeoProjection = orig.myGeoProjection;
203 myGeoProjection = pj_init_plus(pj_get_def(orig.myGeoProjection, 0));
213 std::string proj =
"!";
214 double scale = oc.
getFloat(
"proj.scale");
215 double rot = oc.
getFloat(
"proj.rotate");
217 bool inverse = oc.
exists(
"proj.inverse") && oc.
getBool(
"proj.inverse");
218 bool flatten = oc.
exists(
"flatten") && oc.
getBool(
"flatten");
220 if (oc.
getBool(
"simple-projection")) {
226 WRITE_ERROR(
"Inverse projection works only with explicit proj parameters.");
230 if (numProjections > 1) {
231 WRITE_ERROR(
"The projection method needs to be uniquely defined.");
237 }
else if (oc.
getBool(
"proj.dhdn")) {
239 }
else if (oc.
getBool(
"proj.dhdnutm")) {
253 const Boundary& conv,
double scale) {
264 oc.
addSynonyme(
"simple-projection",
"proj.simple",
true);
265 oc.
addDescription(
"simple-projection",
"Projection",
"Uses a simple method for projection");
268 oc.
addDescription(
"proj.scale",
"Projection",
"Scaling factor for input coordinates");
271 oc.
addDescription(
"proj.rotate",
"Projection",
"Rotation (clockwise degrees) for input coordinates");
275 oc.
addDescription(
"proj.utm",
"Projection",
"Determine the UTM zone (for a universal transversal mercator projection based on the WGS84 ellipsoid)");
278 oc.
addDescription(
"proj.dhdn",
"Projection",
"Determine the DHDN zone (for a transversal mercator projection based on the bessel ellipsoid, \"Gauss-Krueger\")");
281 oc.
addDescription(
"proj",
"Projection",
"Uses STR as proj.4 definition for projection");
284 oc.
addDescription(
"proj.inverse",
"Projection",
"Inverses projection");
287 oc.
addDescription(
"proj.dhdnutm",
"Projection",
"Convert from Gauss-Krueger to UTM");
311 const double y = cartesian.
y() / 111136.;
312 const double x = cartesian.
x() / 111320. / cos(
DEG2RAD(y));
317 #ifdef PROJ_VERSION_MAJOR
319 c.xy.x = cartesian.
x();
320 c.xy.y = cartesian.
y();
321 c = proj_trans(myProjection, PJ_INV, c);
322 cartesian.
set(proj_todeg(c.lp.lam), proj_todeg(c.lp.phi));
327 p = pj_inv(p, myProjection);
331 cartesian.
set((
double) p.u, (
double) p.v);
339 if (includeInBoundary) {
344 if (myProjection ==
nullptr) {
348 int zone = (int)((x - 500000.) / 1000000.);
349 if (zone < 1 || zone > 5) {
354 " +k=1 +x_0=" +
toString(zone * 1000000 + 500000) +
355 " +y_0=0 +ellps=bessel +datum=potsdam +units=m +no_defs";
356 #ifdef PROJ_VERSION_MAJOR
357 myInverseProjection = proj_create(PJ_DEFAULT_CTX,
myProjString.c_str());
358 myGeoProjection = proj_create(PJ_DEFAULT_CTX,
"+proj=latlong +datum=WGS84");
360 myInverseProjection = pj_init_plus(
myProjString.c_str());
361 myGeoProjection = pj_init_plus(
"+proj=latlong +datum=WGS84");
364 x = ((x - 500000.) / 1000000.) * 3;
368 int zone = (int)(x + 180) / 6 + 1;
370 " +ellps=WGS84 +datum=WGS84 +units=m +no_defs";
371 #ifdef PROJ_VERSION_MAJOR
372 myProjection = proj_create(PJ_DEFAULT_CTX,
myProjString.c_str());
380 int zone = (int)(x / 3);
381 if (zone < 1 || zone > 5) {
386 " +k=1 +x_0=" +
toString(zone * 1000000 + 500000) +
387 " +y_0=0 +ellps=bessel +datum=potsdam +units=m +no_defs";
388 #ifdef PROJ_VERSION_MAJOR
389 myProjection = proj_create(PJ_DEFAULT_CTX,
myProjString.c_str());
400 if (myInverseProjection !=
nullptr) {
401 #ifdef PROJ_VERSION_MAJOR
405 c = proj_trans(myInverseProjection, PJ_INV, c);
406 from.
set(proj_todeg(c.lp.lam), proj_todeg(c.lp.phi));
410 if (pj_transform(myInverseProjection, myGeoProjection, 1, 1, &x, &y,
nullptr)) {
413 from.
set(
double(x * RAD_TO_DEG),
double(y * RAD_TO_DEG));
420 if (includeInBoundary) {
439 if (x > 180.1 || x < -180.1) {
443 if (y > 90.1 || y < -90.1) {
448 if (myProjection !=
nullptr) {
449 #ifdef PROJ_VERSION_MAJOR
451 c.lp.lam = proj_torad(x);
452 c.lp.phi = proj_torad(y);
453 c = proj_trans(myProjection, PJ_FWD, c);
459 p.u = x * DEG_TO_RAD;
460 p.v = y * DEG_TO_RAD;
461 p = pj_fwd(p, myProjection);
470 x *= 111320. * cos(
DEG2RAD(y));
475 if (x > std::numeric_limits<double>::max() ||
476 y > std::numeric_limits<double>::max()) {
#define WRITE_WARNING(msg)
@ SUMO_ATTR_CONV_BOUNDARY
@ SUMO_ATTR_ORIG_BOUNDARY
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
A class that stores a 2D geometrical boundary.
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
void moveby(double x, double y, double z=0)
Moves the boundary by the given amount.
void flipY()
flips ymin and ymax
static methods for processing the coordinates conversion for the current net
static void resetLoaded()
resets loaded location elements
const Position getOffset() const
Returns the network offset.
static void writeLocation(OutputDevice &into)
writes the location element
Boundary myOrigBoundary
The boundary before conversion (x2cartesian)
static void addProjectionOptions(OptionsCont &oc)
Adds projection options to the given container.
bool x2cartesian(Position &from, bool includeInBoundary=true)
Converts the given coordinate into a cartesian and optionally update myConvBoundary.
GeoConvHelper & operator=(const GeoConvHelper &)
make assignment operator private
ProjectionMethod myProjectionMethod
Information whether no projection shall be done.
void cartesian2geo(Position &cartesian) const
Converts the given cartesian (shifted) position to its geo (lat/long) representation.
GeoConvHelper(OptionsCont &oc)
Constructor based on the stored options.
Position myOffset
The offset to apply.
void moveConvertedBy(double x, double y)
Shifts the converted boundary by the given amounts.
bool usingInverseGeoProjection() const
Returns the information whether an inverse transformation will happen.
bool operator==(const GeoConvHelper &o) const
const std::string & getProjString() const
Returns the original projection definition.
const Boundary & getOrigBoundary() const
Returns the original boundary.
double mySin
The rotation to apply to geo-coordinates.
static GeoConvHelper myLoaded
coordinate transformation loaded from a location element
static GeoConvHelper myFinal
coordinate transformation to use for writing the location element and for tracking the original coord...
static void setLoaded(const GeoConvHelper &loaded)
sets the coordinate transformation loaded from a location element
double myGeoScale
The scaling to apply to geo-coordinates.
const Position getOffsetBase() const
Returns the network base.
static bool init(OptionsCont &oc)
Initialises the processing and the final instance using the given options.
bool myFlatten
whether to discard z-data
bool myUseInverseProjection
Information whether inverse projection shall be used.
Boundary myConvBoundary
The boundary after conversion (x2cartesian)
static void computeFinal(bool lefthand=false)
compute the location attributes which will be used for output based on the loaded location data,...
bool usingGeoProjection() const
Returns whether a transformation from geo to metric coordinates will be performed.
const Boundary & getConvBoundary() const
Returns the converted boundary.
bool x2cartesian_const(Position &from) const
Converts the given coordinate into a cartesian using the previous initialisation.
~GeoConvHelper()
Destructor.
std::string myProjString
A proj options string describing the proj.4-projection to use.
static int myNumLoaded
the numer of coordinate transformations loaded from location elements
static GeoConvHelper myProcessing
coordinate transformation to use for input conversion and processing
A storage for options typed value containers)
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
void doRegister(const std::string &name, Option *v)
Adds an option under the given name.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
void addSynonyme(const std::string &name1, const std::string &name2, bool isDeprecated=false)
Adds a synonyme for an options name (any order)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
bool exists(const std::string &name) const
Returns the information whether the named option is known.
void addOptionSubTopic(const std::string &topic)
Adds an option subtopic.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
Static storage of an output device and its base (abstract) implementation.
void lf()
writes a line feed if applicable
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
void setPrecision(int precision=gPrecision)
Sets the precision or resets it to default.
A point in 2D or 3D with translation and scaling methods.
void set(double x, double y)
set positions x and y
void sub(double dx, double dy)
Substracts the given position from this one.
double x() const
Returns the x-position.
void add(const Position &pos)
Adds the given position to this one.
void setz(double z)
set position z
void mul(double val)
Multiplies both positions with the given value.
double y() const
Returns the y-position.