GeoConvHelper.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// static methods for processing the coordinates conversion for the current net
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <map>
#include <string>
#include <utils/geom/Position.h>
#include <utils/geom/Boundary.h>
 
#ifdef PROJ_API_FILE
#include PROJ_API_FILE
#ifdef PROJ_VERSION_MAJOR
typedef PJ* projPJ;
#endif
#endif
 
 
// ===========================================================================
// class declarations
// ===========================================================================
 
class OptionsCont;
class PositionVector;
class OutputDevice;
 
// ===========================================================================
// class definitions
// ===========================================================================
class GeoConvHelper {
public:
 
    GeoConvHelper(OptionsCont& oc);
 
    GeoConvHelper(const std::string& proj, const Position& offset,
                  const Boundary& orig, const Boundary& conv, double scale = 1.0, double rot = 0.0, bool inverse = false, bool flatten = false);
 
    ~GeoConvHelper();
 
    static void addProjectionOptions(OptionsCont& oc);
 
    static bool init(OptionsCont& oc);
 
    static void init(const std::string& proj, const Position& offset, const Boundary& orig,
                     const Boundary& conv, double scale = 1.0);
 
    static GeoConvHelper& getProcessing() {
        return myProcessing;
    }
 
    static GeoConvHelper& getLoaded() {
        return myLoaded;
    }
 
    static int getNumLoaded() {
        return myNumLoaded;
    }
 
    static void computeFinal(bool lefthand = false);
 
    static const GeoConvHelper& getFinal() {
        return myFinal;
    }
 
    static void setLoaded(const GeoConvHelper& loaded);
 
    static void setLoadedPlain(const std::string& nodFile, const GeoConvHelper& loaded);
 
    static GeoConvHelper* getLoadedPlain(const std::string& plainFile, const std::string& suffix = ".edg.xml");
 
    static void resetLoaded();
 
    void cartesian2geo(Position& cartesian) const;
 
    bool x2cartesian(Position& from, bool includeInBoundary = true);
 
    bool x2cartesian_const(Position& from) const;
 
    bool usingGeoProjection() const;
 
    bool usingInverseGeoProjection() const;
 
    void moveConvertedBy(double x, double y);
 
    const Boundary& getOrigBoundary() const;
 
    const Boundary& getConvBoundary() const;
 
    void setConvBoundary(const Boundary& boundary) {
        myConvBoundary = boundary;
    }
 
    const Position getOffset() const;
 
    const Position getOffsetBase() const;
 
    const std::string& getProjString() const;
 
    void resolveAbstractProjection();
 
    static void writeLocation(OutputDevice& into);
 
    bool operator==(const GeoConvHelper& o) const;
 
    bool operator!=(const GeoConvHelper& o) const {
        return !(*this == o);
    }
 
private:
    enum ProjectionMethod {
        NONE,
        SIMPLE,
        UTM,
        DHDN,
        DHDN_UTM,
        PROJ
    };
 
    std::string myProjString;
 
#ifdef PROJ_API_FILE
    void initProj(const std::string& proj);
 
#ifdef PROJ_VERSION_MAJOR
    bool checkError(projPJ projection) const;
#endif
 
    projPJ myProjection;
 
    projPJ myInverseProjection;
 
    projPJ myGeoProjection;
#endif
 
    Position myOffset;
 
    double myGeoScale;
 
    double mySin;
    double myCos;
 
    ProjectionMethod myProjectionMethod;
 
    bool myUseInverseProjection;
 
    bool myFlatten;
 
    Boundary myOrigBoundary;
 
    Boundary myConvBoundary;
 
    static GeoConvHelper myProcessing;
 
    static GeoConvHelper myLoaded;
 
    static GeoConvHelper myFinal;
 
    static int myNumLoaded;
 
    static std::map<std::string, std::pair<std::string, Position> > myLoadedPlain;
 
    GeoConvHelper& operator=(const GeoConvHelper&);
 
    GeoConvHelper(const GeoConvHelper&) = delete;
};