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 <osmscout/GeoCoord.h>
#include <osmscout/Point.h>

#include <osmscout/TypeConfig.h>

#include <osmscout/util/FileScanner.h>
#include <osmscout/util/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;         

    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;

      void GetBoundingBox(GeoBox& boundingBox) 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