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/CoreImportExport.h>

#include <osmscout/util/Geometry.h>
#include <osmscout/util/Logger.h>
#include <osmscout/util/Projection.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].GetLon(),
                                      nodes[i].GetLat(),
                                      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);

  class OSMSCOUT_API CoordBufferRange CLASS_FINAL
  {
  private:
    size_t start=std::numeric_limits<size_t>::max();
    size_t end=std::numeric_limits<size_t>::max();

  public:
    CoordBufferRange() = default;
    CoordBufferRange(const CoordBufferRange& other) = default;

    CoordBufferRange(size_t start, size_t end)
      : start(start),
        end(end)
    {
    }

    size_t GetStart() const
    {
      return start;
    }

    size_t GetEnd() const
    {
      return end;
    }
  };

  class OSMSCOUT_API CoordBuffer CLASS_FINAL
  {
  private:
    size_t   bufferSize;
    size_t   usedPoints;

  public:
    Vertex2D *buffer;

  public:
    CoordBuffer();
    CoordBuffer(const CoordBuffer& other)   = delete;
    ~CoordBuffer();

    void Reset();

    size_t PushCoord(double x, double y);

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

  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