52 const Boundary& orig,
const Boundary& conv,
double scale,
double rot,
bool inverse,
bool flatten):
55 myProjection(nullptr),
56 myInverseProjection(nullptr),
57 myGeoProjection(nullptr),
63 myProjectionMethod(
NONE),
64 myUseInverseProjection(inverse),
67 myConvBoundary(conv) {
70 }
else if (proj ==
"-") {
72 }
else if (proj ==
"UTM") {
74 }
else if (proj ==
"DHDN") {
76 }
else if (proj ==
"DHDN_UTM") {
82 if (myProjection ==
nullptr) {
84 myProjString = std::regex_replace(proj, std::regex(
"\\+geoidgrids[^ ]*"), std::string(
""));
85 myProjString = std::regex_replace(
myProjString, std::regex(
"\\+step \\+proj=vgridshift \\+grids[^ ]*"), std::string(
""));
91 if (myProjection ==
nullptr) {
102 GeoConvHelper::initProj(
const std::string& proj) {
103 #ifdef PROJ_VERSION_MAJOR
104 myProjection = proj_create(PJ_DEFAULT_CTX, proj.c_str());
106 myProjection = pj_init_plus(proj.c_str());
114 if (myProjection !=
nullptr) {
115 #ifdef PROJ_VERSION_MAJOR
116 proj_destroy(myProjection);
118 pj_free(myProjection);
121 if (myInverseProjection !=
nullptr) {
122 #ifdef PROJ_VERSION_MAJOR
123 proj_destroy(myInverseProjection);
125 pj_free(myInverseProjection);
128 if (myGeoProjection !=
nullptr) {
129 #ifdef PROJ_VERSION_MAJOR
130 proj_destroy(myGeoProjection);
132 pj_free(myGeoProjection);
167 if (myProjection !=
nullptr) {
168 #ifdef PROJ_VERSION_MAJOR
169 proj_destroy(myProjection);
171 pj_free(myProjection);
173 myProjection =
nullptr;
175 if (myInverseProjection !=
nullptr) {
176 #ifdef PROJ_VERSION_MAJOR
177 proj_destroy(myInverseProjection);
179 pj_free(myInverseProjection);
181 myInverseProjection =
nullptr;
183 if (myGeoProjection !=
nullptr) {
184 #ifdef PROJ_VERSION_MAJOR
185 proj_destroy(myGeoProjection);
187 pj_free(myGeoProjection);
189 myGeoProjection =
nullptr;
191 if (orig.myProjection !=
nullptr) {
192 #ifdef PROJ_VERSION_MAJOR
193 myProjection = proj_create(PJ_DEFAULT_CTX, orig.
myProjString.c_str());
198 if (orig.myInverseProjection !=
nullptr) {
199 #ifdef PROJ_VERSION_MAJOR
200 myInverseProjection = orig.myInverseProjection;
202 myInverseProjection = pj_init_plus(pj_get_def(orig.myInverseProjection, 0));
205 if (orig.myGeoProjection !=
nullptr) {
206 #ifdef PROJ_VERSION_MAJOR
207 myGeoProjection = orig.myGeoProjection;
209 myGeoProjection = pj_init_plus(pj_get_def(orig.myGeoProjection, 0));
219 std::string proj =
"!";
220 double scale = oc.
getFloat(
"proj.scale");
221 double rot = oc.
getFloat(
"proj.rotate");
223 bool inverse = oc.
exists(
"proj.inverse") && oc.
getBool(
"proj.inverse");
224 bool flatten = oc.
exists(
"flatten") && oc.
getBool(
"flatten");
226 if (oc.
getBool(
"simple-projection")) {
232 WRITE_ERROR(
TL(
"Inverse projection works only with explicit proj parameters."));
236 if (numProjections > 1) {
237 WRITE_ERROR(
TL(
"The projection method needs to be uniquely defined."));
243 }
else if (oc.
getBool(
"proj.dhdn")) {
245 }
else if (oc.
getBool(
"proj.dhdnutm")) {
259 const Boundary& conv,
double scale) {
268 if (myProjection ==
nullptr &&
274 if (myProjection ==
nullptr) {
287 oc.
addSynonyme(
"simple-projection",
"proj.simple",
true);
288 oc.
addDescription(
"simple-projection",
"Projection",
TL(
"Uses a simple method for projection"));
291 oc.
addDescription(
"proj.scale",
"Projection",
TL(
"Scaling factor for input coordinates"));
294 oc.
addDescription(
"proj.rotate",
"Projection",
TL(
"Rotation (clockwise degrees) for input coordinates"));
298 oc.
addDescription(
"proj.utm",
"Projection",
TL(
"Determine the UTM zone (for a universal transversal mercator projection based on the WGS84 ellipsoid)"));
301 oc.
addDescription(
"proj.dhdn",
"Projection",
"Determine the DHDN zone (for a transversal mercator projection based on the bessel ellipsoid, \"Gauss-Krueger\")");
304 oc.
addDescription(
"proj",
"Projection",
TL(
"Uses STR as proj.4 definition for projection"));
310 oc.
addDescription(
"proj.dhdnutm",
"Projection",
TL(
"Convert from Gauss-Krueger to UTM"));
334 const double y = cartesian.
y() / 111136.;
335 const double x = cartesian.
x() / 111320. / cos(
DEG2RAD(y));
340 #ifdef PROJ_VERSION_MAJOR
342 c.xy.x = cartesian.
x();
343 c.xy.y = cartesian.
y();
344 c = proj_trans(myProjection, PJ_INV, c);
345 cartesian.
set(proj_todeg(c.lp.lam), proj_todeg(c.lp.phi));
350 p = pj_inv(p, myProjection);
354 cartesian.
set((
double) p.u, (
double) p.v);
362 if (includeInBoundary) {
367 if (myProjection ==
nullptr) {
371 int zone = (int)((x - 500000.) / 1000000.);
372 if (zone < 1 || zone > 5) {
377 " +k=1 +x_0=" +
toString(zone * 1000000 + 500000) +
378 " +y_0=0 +ellps=bessel +datum=potsdam +units=m +no_defs";
379 #ifdef PROJ_VERSION_MAJOR
380 myInverseProjection = proj_create(PJ_DEFAULT_CTX,
myProjString.c_str());
381 myGeoProjection = proj_create(PJ_DEFAULT_CTX,
"+proj=latlong +datum=WGS84");
383 myInverseProjection = pj_init_plus(
myProjString.c_str());
384 myGeoProjection = pj_init_plus(
"+proj=latlong +datum=WGS84");
387 x = ((x - 500000.) / 1000000.) * 3;
391 int zone = (int)(x + 180) / 6 + 1;
393 " +ellps=WGS84 +datum=WGS84 +units=m +no_defs";
394 #ifdef PROJ_VERSION_MAJOR
395 myProjection = proj_create(PJ_DEFAULT_CTX,
myProjString.c_str());
403 int zone = (int)(x / 3);
404 if (zone < 1 || zone > 5) {
409 " +k=1 +x_0=" +
toString(zone * 1000000 + 500000) +
410 " +y_0=0 +ellps=bessel +datum=potsdam +units=m +no_defs";
411 #ifdef PROJ_VERSION_MAJOR
412 myProjection = proj_create(PJ_DEFAULT_CTX,
myProjString.c_str());
423 if (myInverseProjection !=
nullptr) {
424 #ifdef PROJ_VERSION_MAJOR
428 c = proj_trans(myInverseProjection, PJ_INV, c);
429 from.
set(proj_todeg(c.lp.lam), proj_todeg(c.lp.phi));
433 if (pj_transform(myInverseProjection, myGeoProjection, 1, 1, &x, &y,
nullptr)) {
436 from.
set(
double(x * RAD_TO_DEG),
double(y * RAD_TO_DEG));
443 if (includeInBoundary) {
462 if (x > 180.1 || x < -180.1) {
466 if (y > 90.1 || y < -90.1) {
471 if (myProjection !=
nullptr) {
472 #ifdef PROJ_VERSION_MAJOR
474 c.lp.lam = proj_torad(x);
475 c.lp.phi = proj_torad(y);
476 c = proj_trans(myProjection, PJ_FWD, c);
482 p.u = x * DEG_TO_RAD;
483 p.v = y * DEG_TO_RAD;
484 p = pj_fwd(p, myProjection);
493 x *= 111320. * cos(
DEG2RAD(y));
498 if (x > std::numeric_limits<double>::max() ||
499 y > std::numeric_limits<double>::max()) {
#define WRITE_WARNINGF(...)
#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.
Position getCenter() const
Returns the center of the 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
static void setLoadedPlain(const std::string &nodFile, const GeoConvHelper &loaded)
registers the coordinate transformation as having been loaded from the given file
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
static GeoConvHelper * getLoadedPlain(const std::string &plainFile, const std::string &suffix=".edg.xml")
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
void resolveAbstractProjection()
init projString such as 'UTM' in loaded projection
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 std::map< std::string, std::pair< std::string, Position > > myLoadedPlain
the projections loaded from .nod.xml (to be re-used when loading edg.xml)
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.
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.
void doRegister(const std::string &name, Option *o)
Adds an option under the given name.
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)
Subtracts 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 position with the given value.
double y() const
Returns the y-position.
static std::string replace(std::string str, const std::string &what, const std::string &by)
Replaces all occurrences of the second string by the third string within the first string.