Transformation.h

Go to the documentation of this file.

#ifndef OSMSCOUT_UTIL_TRANSFORMATION_H
#define OSMSCOUT_UTIL_TRANSFORMATION_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2011  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 <vector>
 
#include <osmscout/lib/CoreImportExport.h>
 
#include <osmscout/projection/Projection.h>
 
#include <osmscout/util/Geometry.h>
#include <osmscout/log/Logger.h>
 
#include <osmscout/system/Assert.h>
#include <osmscout/system/Math.h>
 
namespace osmscout {

  struct OSMSCOUT_API TransPoint
  {
    bool   draw;
    double x;
    double y;
  };

  class OSMSCOUT_API TransBuffer CLASS_FINAL
  {
  private:
    size_t pointsSize=0;
    size_t length=0;
    size_t start=0;
    size_t end=0;
 
  public:
    TransPoint* points=nullptr;
 
  private:
    void Reserve(size_t size);
 
  public:
    TransBuffer() = default;
    ~TransBuffer();

    bool IsEmpty() const
    {
      return length==0;
    }

    size_t GetLength() const
    {
      return length;
    }

    size_t GetStart() const
    {
      return start;
    }

    size_t GetEnd() const
    {
      return end;
    }

    void Reset();

    void CalcSize();

    template<typename C>
    void  TransformGeoToPixel(const Projection& projection,
                              const C& nodes)
    {
      Projection::BatchTransformer batchTransformer(projection);
 
      if (!nodes.empty()) {
        Reserve(nodes.size());
 
        start=0;
        length=nodes.size();
        end=length-1;
 
        for (size_t i=start; i<=end; i++) {
          batchTransformer.GeoToPixel(nodes[i],
                                      points[i].x,
                                      points[i].y);
          points[i].draw=true;
        }
      }
    }

    bool GetBoundingBox(double& xmin, double& ymin,
                        double& xmax, double& ymax) const;
  };

  class OSMSCOUT_API TransPolygon CLASS_FINAL
  {
  public:
    enum OptimizeMethod
    {
      none   =0,
      fast   =1,
      quality=2
    };
 
    enum OutputConstraint
    {
      noConstraint=0,
      simple      =1
    };
  };

  extern OSMSCOUT_API void OptimizeArea(TransBuffer& buffer,
                                        TransPolygon::OptimizeMethod optimize,
                                        double optimizeErrorTolerance,
                                        TransPolygon::OutputConstraint constraint);

  extern OSMSCOUT_API void OptimizeWay(TransBuffer& buffer,
                                       TransPolygon::OptimizeMethod optimize,
                                       double optimizeErrorTolerance,
                                       TransPolygon::OutputConstraint constraint);

  template<typename C>
  void TransformArea(const C& nodes,
                     TransBuffer& buffer,
                     const Projection& projection,
                     TransPolygon::OptimizeMethod optimize,
                     double optimizeErrorTolerance,
                     TransPolygon::OutputConstraint constraint=TransPolygon::noConstraint)
  {
    buffer.Reset();
 
    if (nodes.size()<2) {
      return;
    }
 
    buffer.TransformGeoToPixel(projection,
                               nodes);
 
    if (optimize!=TransPolygon::none) {
      OptimizeArea(buffer,
                   optimize,
                   optimizeErrorTolerance,
                   constraint);
    }
  }

  template<typename C>
  void TransformWay(const C& nodes,
                    TransBuffer& buffer,
                    const Projection& projection,
                    TransPolygon::OptimizeMethod optimize,
                    double optimizeErrorTolerance,
                    TransPolygon::OutputConstraint constraint=TransPolygon::noConstraint)
  {
    buffer.Reset();
 
    if (nodes.empty()) {
      return;
    }
 
    buffer.TransformGeoToPixel(projection,
                               nodes);
 
    if (optimize!=TransPolygon::none) {
      OptimizeWay(buffer,
                  optimize,
                  optimizeErrorTolerance,
                  constraint);
    }
  }
 

  extern OSMSCOUT_API void TransformBoundingBox(const GeoBox& boundingBox,
                                                TransBuffer& buffer,
                                                const Projection& projection,
                                                TransPolygon::OptimizeMethod optimize,
                                                double optimizeErrorTolerance,
                                                TransPolygon::OutputConstraint constraint=TransPolygon::noConstraint);
 
  // Forward declaration for CoordBuffer
  class CoordBufferRange;

  class OSMSCOUT_API CoordBuffer CLASS_FINAL
  {
  private:
    size_t   bufferSize=131072;
    size_t   usedPoints=0;
 
  public:
    static CoordBuffer emptyCoordBuffer;
 
  public:
    Vertex2D *buffer{new Vertex2D[bufferSize]()};
 
  public:
    CoordBuffer() = default;
    ~CoordBuffer();
 
    CoordBuffer(const CoordBuffer& other) = delete;
    CoordBuffer& operator=(const CoordBuffer& other) = delete;
 
    void Reset();

    size_t PushCoord(const Vertex2D& coord);

    CoordBufferRange GenerateParallelWay(const CoordBufferRange& org,
                                         double offset);
  };

  class OSMSCOUT_API CoordBufferRange CLASS_FINAL
  {
  private:
    CoordBuffer* coordBuffer=&CoordBuffer::emptyCoordBuffer;
    size_t start=std::numeric_limits<size_t>::max();
    size_t end=std::numeric_limits<size_t>::max();
    mutable double length=-1;
 
  public:
    CoordBufferRange() = default;
    CoordBufferRange(const CoordBufferRange& other) = default;
 
    CoordBufferRange(CoordBuffer& coordBuffer, size_t start, size_t end)
      : coordBuffer(&coordBuffer),
        start(start),
        end(end)
    {
    }
 
    CoordBufferRange& operator=(const CoordBufferRange& other)
    {
      if (this!=&other) {
        this->coordBuffer=other.coordBuffer;
        this->start=other.start;
        this->end=other.end;
      }
 
      return *this;
    }

    Vertex2D GetFirst() const
    {
      return coordBuffer->buffer[start];
    }

    Vertex2D GetLast() const
    {
      return coordBuffer->buffer[end];
    }

    size_t GetStart() const
    {
      return start;
    }

    Vertex2D Get(size_t index) const
    {
      return coordBuffer->buffer[index];
    }

    size_t GetEnd() const
    {
      return end;
    }

    size_t GetSize() const
    {
      return end-start+1;
    }

    double GetLength() const
    {
      if (length<0.0) {
        Vertex2D lastCoord=GetFirst();
 
        length=0.0;
        for (size_t j = start+1; j <= end; j++) {
          Vertex2D currentCoord=Get(j);
          length += sqrt(pow(currentCoord.GetX() - lastCoord.GetX(), 2) +
                         pow(currentCoord.GetY() - lastCoord.GetY(), 2));
 
          lastCoord=currentCoord;
        }
      }
 
      return length;
    }
 
    bool IsValid() const {
      return start!=std::numeric_limits<size_t>::max();
    }
  };
 
  extern OSMSCOUT_API CoordBufferRange CopyPolygonToCoordBuffer(const TransBuffer& transBuffer,
                                                                CoordBuffer& coordBuffer);

  template<typename C>
  CoordBufferRange TransformArea(const C& nodes,
                                 TransBuffer& transBuffer,
                                 CoordBuffer& coordBuffer,
                                 const Projection& projection,
                                 TransPolygon::OptimizeMethod optimize,
                                 double optimizeErrorTolerance)
  {
    TransformArea(nodes,
                  transBuffer,
                  projection,
                  optimize,
                  optimizeErrorTolerance);
 
    assert(!transBuffer.IsEmpty());
 
    return CopyPolygonToCoordBuffer(transBuffer,
                                    coordBuffer);
  }

  template<typename C>
  CoordBufferRange TransformWay(const C& nodes,
                                TransBuffer& transBuffer,
                                CoordBuffer& coordBuffer,
                                const Projection& projection,
                                TransPolygon::OptimizeMethod optimize,
                                double optimizeErrorTolerance)
  {
    TransformWay(nodes,
                 transBuffer,
                 projection,
                 optimize,
                 optimizeErrorTolerance);
 
    assert(!transBuffer.IsEmpty());
 
    return CopyPolygonToCoordBuffer(transBuffer,
                                    coordBuffer);
  }

  extern OSMSCOUT_API CoordBufferRange TransformBoundingBox(const GeoBox& boundingBox,
                                                            TransBuffer& buffer,
                                                            CoordBuffer& coordBuffer,
                                                            const Projection& projection,
                                                            TransPolygon::OptimizeMethod optimize,
                                                            double optimizeErrorTolerance);
}
 
#endif