Projection.h

Go to the documentation of this file.

#ifndef OSMSCOUT_UTIL_PROJECTION_H
#define OSMSCOUT_UTIL_PROJECTION_H

/*
  This source is part of the libosmscout library
  Copyright (C) 2010  Tim Teulings

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/

#include <osmscout/CoreImportExport.h>

#include <osmscout/GeoCoord.h>

#include <osmscout/util/GeoBox.h>
#include <osmscout/util/Magnification.h>
#include <osmscout/util/Tiling.h>

#include <osmscout/system/SSEMathPublic.h>

namespace osmscout {

  class OSMSCOUT_API Projection
  {
  protected:
    double        lon;            
    double        lat;            
    double        angle;          
    Magnification magnification;  
    double        dpi;            
    size_t        width;          
    size_t        height;         

    double        lonMin;         
    double        latMin;         
    double        lonMax;         
    double        latMax;         

    double        pixelSize;      
    double        meterInPixel;   
    double        meterInMM;      

  public:

    class BatchTransformer
    {
    public:
      // this should be private, but that would exclude future projection
      // implementors. I don't know a nice way to handle this
      const Projection&  projection;
#ifdef OSMSCOUT_HAVE_SSE2
      int                count;
      ALIGN16_BEG double lon[2] ALIGN16_END;
      ALIGN16_BEG double lat[2] ALIGN16_END;
      double*            xPointer[2];
      double*            yPointer[2];
#endif

    public:
      explicit BatchTransformer(const Projection& projection)
        : projection(projection)
#ifdef OSMSCOUT_HAVE_SSE2
          ,count(0)
#endif
      {
      }

      ~BatchTransformer()
      {
        Flush();
      }

      void GeoToPixel(double lon,
                             double lat,
                             double& x,
                             double& y)
      {
#ifdef OSMSCOUT_HAVE_SSE2
        if (projection.CanBatch()) {
          this->lon[count]=lon;
          this->lat[count]=lat;
          xPointer[count]=&x;
          yPointer[count]=&y;
          count++;

          if (count==2) {
            count=0;
            projection.GeoToPixel(*this);
          }
        }
        else {
          projection.GeoToPixel(GeoCoord(lat,lon),
                                x,y);
        }
#else
        projection.GeoToPixel(GeoCoord(lat,lon),
                              x,y);
#endif
      }

      void Flush()
      {
#ifdef OSMSCOUT_HAVE_SSE2
        if (count!=0) {
          count=0;
          projection.GeoToPixel(GeoCoord(lat[0],
                                         lon[0]),
                                *xPointer[0],
                                *yPointer[0]);
        }
#endif
      }
    };

    Projection();
    virtual ~Projection() = default;

    virtual bool CanBatch() const = 0;
    virtual bool IsValid() const = 0;

    virtual bool IsValidFor(const GeoCoord& coord) const = 0;

    GeoCoord GetCenter() const
    {
      return GeoCoord(lat,lon);
    }

    double GetLon() const
    {
      return lon;
    }

    double GetLat() const
    {
      return lat;
    }

    double GetAngle() const
    {
      return angle;
    }

    size_t GetWidth() const
    {
      return width;
    }

    size_t GetHeight() const
    {
      return height;
    }

    Magnification GetMagnification() const
    {
      return magnification;
    }

    double GetDPI() const
    {
      return dpi;
    }

    bool GeoIsIn(double lon, double lat) const
    {
      return lon>=lonMin && lon<=lonMax && lat>=latMin && lat<=latMax;
    }

    bool GeoIsIn(double lonMin, double latMin,
                        double lonMax, double latMax) const
    {
      return !(lonMin>this->lonMax ||
               lonMax<this->lonMin ||
               latMin>this->latMax ||
               latMax<this->latMin);
    }

    GeoBox GetDimensions() const
    {
      return GeoBox(GeoCoord(latMin,lonMin),
                    GeoCoord(latMax,lonMax));
    }

    void GetDimensions(GeoBox& boundingBox) const
    {
      boundingBox.Set(GeoCoord(latMin,lonMin),
                      GeoCoord(latMax,lonMax));
    }

    double GetPixelSize() const
    {
      return pixelSize;
    }

    double GetMeterInPixel() const
    {
      return meterInPixel;
    }

    double GetMeterInMM() const
    {
      return meterInMM;
    }

    double ConvertWidthToPixel(double width) const
    {
      return width*dpi/25.4;
    }

    double ConvertPixelToWidth(double pixel) const
    {
      return pixel*25.4/dpi;
    }

    virtual bool PixelToGeo(double x, double y,
                            double& lon, double& lat) const = 0;

    virtual bool GeoToPixel(const GeoCoord& coord,
                            double& x, double& y) const = 0;

  protected:
    virtual void GeoToPixel(const BatchTransformer& transformData) const = 0;

    friend class BatchTransformer;
  };

  class OSMSCOUT_API MercatorProjection : public Projection
  {
  protected:
    bool   valid;          

    double latOffset;      
    double angleSin;
    double angleCos;
    double angleNegSin;
    double angleNegCos;

    double scale;
    double scaleGradtorad; 

    double scaledLatDeriv; 
    bool   useLinearInterpolation; 

  public:
    static const double MaxLat;
    static const double MinLat;
    static const double MaxLon;
    static const double MinLon;

    MercatorProjection();

    bool CanBatch() const override
    {
      return false;
    }

    bool IsValid() const override
    {
      return valid;
    }

    bool IsValidFor(const GeoCoord& coord) const override
    {
      return coord.GetLat() >= MinLat && coord.GetLat() <= MaxLat &&
             coord.GetLon() >= MinLon && coord.GetLon() <= MaxLon;
    }

    bool Set(const GeoCoord& coord,
                    const Magnification& magnification,
                    size_t width,size_t height)
    {
      return Set(coord,0.0,magnification,GetDPI(),width,height);
    }

    bool Set(const GeoCoord& coord,
                    double angle,
                    const Magnification& magnification,
                    size_t width, size_t height)
    {
      return Set(coord,angle,magnification,GetDPI(),width,height);
    }

    bool Set(const GeoCoord& coord,
                    const Magnification& magnification,
                    double dpi,
                    size_t width, size_t height)
    {
      return Set(coord,0.0,magnification,dpi,width,height);
    }

    bool Set(const GeoCoord& coord,
             double angle,
             const Magnification& magnification,
             double dpi,
             size_t width, size_t height);

    bool PixelToGeo(double x, double y,
                    double& lon, double& lat) const override;

    bool PixelToGeo(double x, double y,
                           GeoCoord &coord) const
    {
      double lat;
      double lon;
      if (PixelToGeo(x,y,lon,lat)){
        coord.Set(lat,lon);
        return true;
      }
      return false;
    }

    bool GeoToPixel(const GeoCoord& coord,
                    double& x, double& y) const override;

    bool Move(double horizPixel,
              double vertPixel);

    bool MoveUp(double pixel)
    {
      return Move(0,pixel);
    }

    bool MoveDown(double pixel)
    {
      return Move(0,-pixel);
    }

    bool MoveLeft(double pixel)
    {
      return Move(-pixel,0);
    }

    bool MoveRight(double pixel)
    {
      return Move(pixel,0);
    }

    bool IsLinearInterpolationEnabled() const
    {
      return useLinearInterpolation;
    }

    void SetLinearInterpolationUsage(bool useLinearInterpolation)
    {
      this->useLinearInterpolation=useLinearInterpolation;
    }

  protected:
    void GeoToPixel(const BatchTransformer& transformData) const override;
  };


  class OSMSCOUT_API TileProjection : public Projection
  {
  protected:
    bool   valid;          

    double lonOffset;
    double latOffset;
    double scale;
    double scaleGradtorad; 

    double scaledLatDeriv; 
    bool   useLinearInterpolation; 

#ifdef OSMSCOUT_HAVE_SSE2
    //some extra vars for special sse needs
      v2df              sse2LonOffset;
      v2df              sse2LatOffset;
      v2df              sse2Scale;
      v2df              sse2ScaleGradtorad;
      v2df              sse2Height;
#endif

  protected:
    virtual bool SetInternal(double lonMin,double latMin,
                             double lonMax,double latMax,
                             const Magnification& magnification,
                             double dpi,
                             size_t width,size_t height);

  public:
    TileProjection();

    bool CanBatch() const override
    {
      return true;
    }

    bool IsValid() const override
    {
      return valid;
    }

    bool IsValidFor(const GeoCoord& coord) const override
    {
      return coord.GetLat() >= -85.0511 && coord.GetLat() <= +85.0511 &&
             coord.GetLon() >= -180.0   && coord.GetLon() <= +180.0;
    }

    bool Set(const OSMTileId& tile,
                    const Magnification& magnification,
                    size_t width, size_t height)
    {
      return Set(tile,magnification,GetDPI(),width,height);
    }

    bool Set(const OSMTileId& tile,
             const Magnification& magnification,
             double dpi,
             size_t width, size_t height);

    bool Set(const OSMTileIdBox& tileBox,
             const Magnification& magnification,
             double dpi,
             size_t width, size_t height);

    bool PixelToGeo(double x, double y,
                    double& lon, double& lat) const override;

    bool GeoToPixel(const GeoCoord& coord,
                    double& x, double& y) const override;

    bool IsLinearInterpolationEnabled() const
    {
      return useLinearInterpolation;
    }

    void SetLinearInterpolationUsage(bool b)
    {
      useLinearInterpolation = b;
    }

  protected:

    void GeoToPixel(const BatchTransformer& transformData) const override;
  };

}

#endif