50 const Boundary& orig,
const Boundary& conv,
double scale,
double rot,
bool inverse,
bool flatten):
53 myProjection(nullptr),
54 myInverseProjection(nullptr),
55 myGeoProjection(nullptr),
61 myProjectionMethod(
NONE),
62 myUseInverseProjection(inverse),
65 myConvBoundary(conv) {
68 }
else if (proj ==
"-") {
70 }
else if (proj ==
"UTM") {
72 }
else if (proj ==
"DHDN") {
74 }
else if (proj ==
"DHDN_UTM") {
79 #ifdef PROJ_VERSION_MAJOR
80 myProjection = proj_create(PJ_DEFAULT_CTX, proj.c_str());
82 myProjection = pj_init_plus(proj.c_str());
84 if (myProjection ==
nullptr) {
95 if (myProjection !=
nullptr) {
96 #ifdef PROJ_VERSION_MAJOR
97 proj_destroy(myProjection);
99 pj_free(myProjection);
102 if (myInverseProjection !=
nullptr) {
103 #ifdef PROJ_VERSION_MAJOR
104 proj_destroy(myInverseProjection);
106 pj_free(myInverseProjection);
109 if (myGeoProjection !=
nullptr) {
110 #ifdef PROJ_VERSION_MAJOR
111 proj_destroy(myGeoProjection);
113 pj_free(myGeoProjection);
148 if (myProjection !=
nullptr) {
149 #ifdef PROJ_VERSION_MAJOR
150 proj_destroy(myProjection);
152 pj_free(myProjection);
154 myProjection =
nullptr;
156 if (myInverseProjection !=
nullptr) {
157 #ifdef PROJ_VERSION_MAJOR
158 proj_destroy(myInverseProjection);
160 pj_free(myInverseProjection);
162 myInverseProjection =
nullptr;
164 if (myGeoProjection !=
nullptr) {
165 #ifdef PROJ_VERSION_MAJOR
166 proj_destroy(myGeoProjection);
168 pj_free(myGeoProjection);
170 myGeoProjection =
nullptr;
172 if (orig.myProjection !=
nullptr) {
173 #ifdef PROJ_VERSION_MAJOR
174 myProjection = proj_create(PJ_DEFAULT_CTX, orig.
myProjString.c_str());
179 if (orig.myInverseProjection !=
nullptr) {
180 #ifdef PROJ_VERSION_MAJOR
181 myInverseProjection = orig.myInverseProjection;
183 myInverseProjection = pj_init_plus(pj_get_def(orig.myInverseProjection, 0));
186 if (orig.myGeoProjection !=
nullptr) {
187 #ifdef PROJ_VERSION_MAJOR
188 myGeoProjection = orig.myGeoProjection;
190 myGeoProjection = pj_init_plus(pj_get_def(orig.myGeoProjection, 0));
200 std::string proj =
"!";
201 double scale = oc.
getFloat(
"proj.scale");
202 double rot = oc.
getFloat(
"proj.rotate");
204 bool inverse = oc.
exists(
"proj.inverse") && oc.
getBool(
"proj.inverse");
205 bool flatten = oc.
exists(
"flatten") && oc.
getBool(
"flatten");
207 if (oc.
getBool(
"simple-projection")) {
213 WRITE_ERROR(
"Inverse projection works only with explicit proj parameters.");
217 if (numProjections > 1) {
218 WRITE_ERROR(
"The projection method needs to be uniquely defined.");
224 }
else if (oc.
getBool(
"proj.dhdn")) {
226 }
else if (oc.
getBool(
"proj.dhdnutm")) {
240 const Boundary& conv,
double scale) {
251 oc.
addSynonyme(
"simple-projection",
"proj.simple",
true);
252 oc.
addDescription(
"simple-projection",
"Projection",
"Uses a simple method for projection");
255 oc.
addDescription(
"proj.scale",
"Projection",
"Scaling factor for input coordinates");
258 oc.
addDescription(
"proj.rotate",
"Projection",
"Rotation (clockwise degrees) for input coordinates");
262 oc.
addDescription(
"proj.utm",
"Projection",
"Determine the UTM zone (for a universal transversal mercator projection based on the WGS84 ellipsoid)");
265 oc.
addDescription(
"proj.dhdn",
"Projection",
"Determine the DHDN zone (for a transversal mercator projection based on the bessel ellipsoid, \"Gauss-Krueger\")");
268 oc.
addDescription(
"proj",
"Projection",
"Uses STR as proj.4 definition for projection");
271 oc.
addDescription(
"proj.inverse",
"Projection",
"Inverses projection");
274 oc.
addDescription(
"proj.dhdnutm",
"Projection",
"Convert from Gauss-Krueger to UTM");
298 const double y = cartesian.
y() / 111136.;
299 const double x = cartesian.
x() / 111320. / cos(
DEG2RAD(y));
304 #ifdef PROJ_VERSION_MAJOR
306 c.xy.x = cartesian.
x();
307 c.xy.y = cartesian.
y();
308 c = proj_trans(myProjection, PJ_INV, c);
309 cartesian.
set(proj_todeg(c.lp.lam), proj_todeg(c.lp.phi));
314 p = pj_inv(p, myProjection);
318 cartesian.
set((
double) p.u, (
double) p.v);
326 if (includeInBoundary) {
331 if (myProjection ==
nullptr) {
335 int zone = (int)((x - 500000.) / 1000000.);
336 if (zone < 1 || zone > 5) {
341 " +k=1 +x_0=" +
toString(zone * 1000000 + 500000) +
342 " +y_0=0 +ellps=bessel +datum=potsdam +units=m +no_defs";
343 #ifdef PROJ_VERSION_MAJOR
344 myInverseProjection = proj_create(PJ_DEFAULT_CTX,
myProjString.c_str());
345 myGeoProjection = proj_create(PJ_DEFAULT_CTX,
"+proj=latlong +datum=WGS84");
347 myInverseProjection = pj_init_plus(
myProjString.c_str());
348 myGeoProjection = pj_init_plus(
"+proj=latlong +datum=WGS84");
351 x = ((x - 500000.) / 1000000.) * 3;
355 int zone = (int)(x + 180) / 6 + 1;
357 " +ellps=WGS84 +datum=WGS84 +units=m +no_defs";
358 #ifdef PROJ_VERSION_MAJOR
359 myProjection = proj_create(PJ_DEFAULT_CTX,
myProjString.c_str());
367 int zone = (int)(x / 3);
368 if (zone < 1 || zone > 5) {
373 " +k=1 +x_0=" +
toString(zone * 1000000 + 500000) +
374 " +y_0=0 +ellps=bessel +datum=potsdam +units=m +no_defs";
375 #ifdef PROJ_VERSION_MAJOR
376 myProjection = proj_create(PJ_DEFAULT_CTX,
myProjString.c_str());
387 if (myInverseProjection !=
nullptr) {
388 #ifdef PROJ_VERSION_MAJOR
392 c = proj_trans(myInverseProjection, PJ_INV, c);
393 from.
set(proj_todeg(c.lp.lam), proj_todeg(c.lp.phi));
397 if (pj_transform(myInverseProjection, myGeoProjection, 1, 1, &x, &y,
nullptr)) {
400 from.
set(
double(x * RAD_TO_DEG),
double(y * RAD_TO_DEG));
407 if (includeInBoundary) {
426 if (x > 180.1 || x < -180.1) {
430 if (y > 90.1 || y < -90.1) {
435 if (myProjection !=
nullptr) {
436 #ifdef PROJ_VERSION_MAJOR
438 c.lp.lam = proj_torad(x);
439 c.lp.phi = proj_torad(y);
440 c = proj_trans(myProjection, PJ_FWD, c);
446 p.u = x * DEG_TO_RAD;
447 p.v = y * DEG_TO_RAD;
448 p = pj_fwd(p, myProjection);
456 x *= 111320. * cos(
DEG2RAD(y));
461 if (x > std::numeric_limits<double>::max() ||
462 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 precison 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.