Area.h

Go to the documentation of this file.

#ifndef OSMSCOUT_AREA_H
#define OSMSCOUT_AREA_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2013  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 <memory>
#include <optional>
 
#include <osmscout/GeoCoord.h>
#include <osmscout/Point.h>
 
#include <osmscout/TypeConfig.h>
 
#include <osmscout/io/FileScanner.h>
#include <osmscout/io/FileWriter.h>
#include <osmscout/util/GeoBox.h>
#include <osmscout/util/Progress.h>
#include <osmscout/util/Geometry.h>
 
#include <osmscout/system/Compiler.h>
 
namespace osmscout {
  class OSMSCOUT_API Area CLASS_FINAL
  {
  public:
    static const uint8_t masterRingId;
    static const uint8_t outerRingId;
 
  public:
    class OSMSCOUT_API Ring
    {
    private:
      FeatureValueBuffer    featureValueBuffer; 
      uint8_t               ring=0;             
 
    public:
      std::vector<Point>          nodes;        
      std::vector<SegmentGeoBox>  segments;     
      GeoBox                      bbox;         
      std::optional<GeoCoord>     center;       
 
    public:
      Ring() = default;
 
      TypeInfoRef GetType() const
      {
        return featureValueBuffer.GetType();
      }
 
      size_t GetFeatureCount() const
      {
        return featureValueBuffer.GetType()->GetFeatureCount();
      }
 
      bool HasFeature(size_t idx) const
      {
        return featureValueBuffer.HasFeature(idx);
      }
 
      bool HasAnyFeaturesSet() const;
 
      const FeatureInstance& GetFeature(size_t idx) const
      {
        return featureValueBuffer.GetType()->GetFeature(idx);
      }
 
      void UnsetFeature(size_t idx)
      {
        featureValueBuffer.FreeValue(idx);
      }
 
      const FeatureValueBuffer& GetFeatureValueBuffer() const
      {
        return featureValueBuffer;
      }
 
      bool IsMaster() const
      {
        return ring==masterRingId;
      }
 
      // top level outer ring
      bool IsTopOuter() const
      {
        return ring==outerRingId;
      }
 
      // ring level is odd, it is some outer ring
      bool IsOuter() const
      {
        return (ring & outerRingId) == outerRingId;
      }
 
      uint8_t GetRing() const
      {
        return ring;
      }
 
      Id GetSerial(size_t index) const
      {
        return nodes[index].GetSerial();
      }
 
      Id GetId(size_t index) const
      {
        return nodes[index].GetId();
      }
 
      Id GetFrontId() const
      {
        return nodes.front().GetId();
      }
 
      Id GetBackId() const
      {
        return nodes.back().GetId();
      }
 
      bool GetNodeIndexByNodeId(Id id,
                                size_t& index) const;
 
      const GeoCoord& GetCoord(size_t index) const
      {
        return nodes[index].GetCoord();
      }
 
      bool GetCenter(GeoCoord& center) const;
 
      GeoBox GetBoundingBox() const;
 
      void SetType(const TypeInfoRef& type)
      {
        featureValueBuffer.SetType(type);
      }
 
      void SetFeatures(const FeatureValueBuffer& buffer)
      {
        featureValueBuffer.Set(buffer);
      }
 
      void CopyMissingValues(const FeatureValueBuffer& buffer)
      {
        featureValueBuffer.CopyMissingValues(buffer);
      }
 
      void MarkAsMasterRing()
      {
        ring=masterRingId;
      }
 
      void MarkAsOuterRing()
      {
        ring=outerRingId;
      }
 
      void SetRing(uint8_t ring)
      {
        this->ring=ring;
      }
 
      friend class Area;
    };
 
    using RingVisitor = std::function<bool(size_t i, const Ring&, const TypeInfoRef&)>;
 
  private:
    FileOffset        fileOffset=0;
    FileOffset        nextFileOffset=0;
 
  public:
    std::vector<Ring> rings;
 
  public:
    Area() = default;
 
    FileOffset GetFileOffset() const
    {
      return fileOffset;
    }
 
    FileOffset GetNextFileOffset() const
    {
      return nextFileOffset;
    }
 
    ObjectFileRef GetObjectFileRef() const
    {
      return {fileOffset,refArea};
    }
 
    TypeInfoRef GetType() const
    {
      return rings.front().GetType();
    }
 
    TypeInfoRef GetRingType(const Ring &ring) const
    {
      if (ring.IsTopOuter() ||
          (ring.IsOuter() && ring.GetType()->GetIgnore())) {
        return GetType();
      }
 
      return ring.GetType();
 
    }
 
    const FeatureValueBuffer& GetFeatureValueBuffer() const
    {
      return rings.front().GetFeatureValueBuffer();
    }
 
    bool IsSimple() const
    {
      return rings.size()==1;
    }
 
    bool GetCenter(GeoCoord& center) const;
 
    GeoBox GetBoundingBox() const;

    bool Intersects(const GeoBox& boundingBox) const
    {
      return GetBoundingBox().Intersects(boundingBox);
    }

    void Read(const TypeConfig& typeConfig,
              FileScanner& scanner);

    void ReadImport(const TypeConfig& typeConfig,
                    FileScanner& scanner);

    void ReadOptimized(const TypeConfig& typeConfig,
                       FileScanner& scanner);

    void Write(const TypeConfig& typeConfig,
               FileWriter& writer) const;

    void WriteImport(const TypeConfig& typeConfig,
                     FileWriter& writer) const;

    void WriteOptimized(const TypeConfig& typeConfig,
                        FileWriter& writer) const;

    void VisitRings(const RingVisitor& visitor) const;

    void VisitClippingRings(size_t index, const RingVisitor& visitor) const;
  };
 
  using AreaRef = std::shared_ptr<Area>;
}
 
#endif