Tiling.h

Go to the documentation of this file.

#ifndef OSMSCOUT_UTIL_TILING_H
#define OSMSCOUT_UTIL_TILING_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2014  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/lib/CoreImportExport.h>
 
#include <iterator>
 
#include <osmscout/GeoCoord.h>
#include <osmscout/Pixel.h>
 
#include <osmscout/util/GeoBox.h>
#include <osmscout/util/Magnification.h>
 
#include <osmscout/system/Compiler.h>
 
namespace osmscout {

 
  // forward declaration to avoid circular header includes
  class GeoCoord;
  class GeoBox;

  class OSMSCOUT_API OSMTileId CLASS_FINAL
  {
  private:
    uint32_t x;
    uint32_t y;
 
  public:
    OSMTileId(uint32_t x,
              uint32_t y);
 
    uint32_t GetX() const
    {
      return x;
    }
 
    uint32_t GetY() const
    {
      return y;
    }
 
    GeoCoord GetTopLeftCoord(const Magnification& magnification) const;
    GeoBox GetBoundingBox(const Magnification& magnification) const;
 
    bool operator==(const OSMTileId& other) const
    {
      return x==other.x && y==other.y;
    }
 
    bool operator!=(const OSMTileId& other) const
    {
      return x!=other.x || y!=other.y;
    }
 
    std::string GetDisplayText() const
    {
      return std::to_string(x)+","+std::to_string(y);
    }
 
    static OSMTileId GetOSMTile(const Magnification& magnification,
                                const GeoCoord& coord);
 
  };
 
  class OSMSCOUT_API OSMTileIdBoxConstIterator
  {
  public:
    using self_type         = OSMTileIdBoxConstIterator;
    using value_type        = OSMTileId;
    using reference         = OSMTileId&;
    using pointer           = OSMTileId*;
    using iterator_category = std::input_iterator_tag;
 
  private:
    OSMTileId currentTile;
    OSMTileId minTile;
    OSMTileId maxTile;
 
  public:
    OSMTileIdBoxConstIterator(const OSMTileId& currentTile,
                              const OSMTileId& minTile,
                              const OSMTileId& maxTile)
      : currentTile(currentTile),
        minTile(minTile),
        maxTile(maxTile)
    {
      // no code
    }
 
    OSMTileIdBoxConstIterator(const OSMTileIdBoxConstIterator& other) = default;
 
    OSMTileIdBoxConstIterator& operator++()
    {
      if (currentTile.GetX()>=maxTile.GetX()) {
        currentTile=OSMTileId(minTile.GetX(),currentTile.GetY()+1);
      }
      else {
        currentTile=OSMTileId(currentTile.GetX()+1,currentTile.GetY());
      }
 
      return *this;
    }
 
    OSMTileIdBoxConstIterator operator++(int)
    {
      OSMTileIdBoxConstIterator tmp(*this);
 
      operator++();
 
      return tmp;
    }
 
    bool operator==(const OSMTileIdBoxConstIterator& other) const
    {
      return currentTile==other.currentTile;
    }
 
    bool operator!=(const OSMTileIdBoxConstIterator& other) const
    {
      return currentTile!=other.currentTile;
    }
 
    const OSMTileId& operator*() const
    {
      return currentTile;
    }
 
    OSMTileId operator->() const
    {
      return currentTile;
    }
  };

  class OSMSCOUT_API OSMTileIdBox CLASS_FINAL
  {
  private:
    OSMTileId minTile;
    OSMTileId maxTile;
 
  public:
    OSMTileIdBox(const OSMTileId& a,
                 const OSMTileId& b);
 
    OSMTileId GetMin() const
    {
      return minTile;
    }
 
    OSMTileId GetMax() const
    {
      return maxTile;
    }
 
    uint32_t GetMinX() const
    {
      return minTile.GetX();
    }
 
    uint32_t GetMaxX() const
    {
      return maxTile.GetX();
    }
 
    uint32_t GetMinY() const
    {
      return minTile.GetY();
    }
 
    uint32_t GetMaxY() const
    {
      return maxTile.GetY();
    }
 
    uint32_t GetWidth() const
    {
      return maxTile.GetX()-minTile.GetX()+1;
    }
 
    uint32_t GetHeight() const
    {
      return maxTile.GetY()-minTile.GetY()+1;
    }
 
    uint32_t GetCount() const
    {
      return GetWidth()*GetHeight();
    }
 
    OSMTileIdBoxConstIterator begin() const
    {
      return OSMTileIdBoxConstIterator(minTile,
                                       minTile,
                                       maxTile);
    }
 
    OSMTileIdBoxConstIterator end() const
    {
      return OSMTileIdBoxConstIterator(OSMTileId(minTile.GetX(),
                                                 maxTile.GetY()+1),
                                       minTile,
                                       maxTile);
    }
 
    GeoBox GetBoundingBox(const Magnification& magnification) const;
 
    std::string GetDisplayText() const
    {
      return std::string("["+minTile.GetDisplayText()+" - "+maxTile.GetDisplayText()+"]");
    }
  };
}
 
#endif