GenLocationIndex.h

Go to the documentation of this file.

#ifndef OSMSCOUT_IMPORT_GENLOCATIONINDEX_H
#define OSMSCOUT_IMPORT_GENLOCATIONINDEX_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2009  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 <map>
#include <memory>
#include <unordered_map>
#include <unordered_set>
 
#include <osmscout/Node.h>
#include <osmscout/Area.h>
#include <osmscout/Way.h>
 
#include <osmscout/ObjectRef.h>
 
#include <osmscout/TypeInfoSet.h>
 
#include <osmscoutimport/Import.h>
 
#include <osmscout/system/Compiler.h>
 
namespace osmscout {
 
  namespace locidx {

    struct RegionMetrics CLASS_FINAL
    {
      uint32_t minRegionChars=std::numeric_limits<uint32_t>::max();
      uint32_t maxRegionChars=0;
      uint32_t minRegionWords=std::numeric_limits<uint32_t>::max();
      uint32_t maxRegionWords=0;
      uint32_t maxPOIWords=0;
      uint32_t minLocationChars=std::numeric_limits<uint32_t>::max();
      uint32_t maxLocationChars=0;
      uint32_t minLocationWords=std::numeric_limits<uint32_t>::max();
      uint32_t maxLocationWords=0;
      uint32_t maxAddressWords=0;
 
      RegionMetrics() = default;
    };

    struct RegionAlias CLASS_FINAL
    {
      FileOffset  reference; 
      std::string name;      
      std::string altName;
    };

    struct RegionPOI CLASS_FINAL
    {
      std::string   name;   
      ObjectFileRef object; 
 
      RegionPOI(const std::string& name,
                const ObjectFileRef& object)
        : name(name),
          object(object)
      {
        // no code
      }
 
      bool operator<(const RegionPOI& other) const
      {
        return object.GetFileOffset()<other.object.GetFileOffset();
      }
    };

    struct RegionAddress CLASS_FINAL
    {
      std::string   name;       
      ObjectFileRef object;     
 
      RegionAddress(const std::string& name,
                    const ObjectFileRef& object)
        : name(name),
          object(object)
      {
        // no code
      }
 
      bool operator<(const RegionAddress& other) const
      {
        return object.GetFileOffset()<other.object.GetFileOffset();
      }
    };

    struct RegionLocation CLASS_FINAL
    {
      std::unordered_map<std::string,
                         size_t>      names;            
      FileOffset                      dataOffsetOffset; 
      std::list<ObjectFileRef>        objects;          
      std::list<RegionAddress>        addresses;        
 
      std::string GetName() const;
    };

    struct PostalArea CLASS_FINAL
    {
      std::string                          name;             
      FileOffset                           dataOffsetOffset; 
      std::map<std::string,RegionLocation> locations;        
 
      explicit PostalArea(const std::string& name)
        : name(name)
      {
        // no code
      }
 
      void AddLocationObject(const std::string& name,
                             const ObjectFileRef& objectRef);
    };
 
    class Region;
 
    using RegionRef = std::shared_ptr<Region>;

    class Region CLASS_FINAL
    {
    public:
      using PostalAreaMap = std::unordered_map<std::string, PostalArea>;
 
    private:
      std::vector<GeoBox>                boundingBoxes;      
      GeoBox                             boundingBox;        
      std::vector<GeoCoord>              probePoints;        
 
    public:
      FileOffset                         indexOffset;        
      FileOffset                         dataOffset;         
 
      ObjectFileRef                      reference;          
      std::string                        name;               
      std::string                        altName;
      std::string                        isIn;               
      std::list<RegionAlias>             aliases;            
      int8_t                             level{-1};          
 
      std::vector<std::vector<GeoCoord>> areas;              
      std::list<RegionPOI>               pois;               
      PostalAreaMap                      postalAreas;        
      PostalAreaMap::iterator            defaultPostalArea;  
 
      std::list<RegionRef>               regions;            
 
    public:
      Region();
 
      void CalculateMinMax();
      bool CouldContain(const GeoBox& boundingBox) const;
      bool CouldContain(const Region& region, bool strict) const;
 
      bool Contains(Region& child) const;                 
 
      GeoBox GetBoundingBox() const
      {
        return boundingBox;
      }
 
      std::vector<GeoBox> GetAreaBoundingBoxes() const
      {
        return boundingBoxes;
      }
 
      void AddAlias(const RegionAlias& location,
                    const GeoCoord& node);
 
      void AddPOINode(const FileOffset& fileOffset,
                      const std::string& name,
                      bool& added);
 
      void AddPOIArea(const FileOffset& fileOffset,
                      const std::string& name,
                      const std::vector<Point>& nodes,
                      const GeoBox& boundingBox,
                      bool& added);
 
      bool AddPOIWay(const FileOffset& fileOffset,
                     const std::string& name,
                     const std::vector<Point>& nodes,
                     const GeoBox& boundingBox,
                     bool& added);
 
      void AddLocationObject(const std::string& name,
                             const std::string& postalCode,
                             const ObjectFileRef& objectRef);
 
      bool AddLocationArea(const Area& area,
                           const std::vector<Point>& nodes,
                           const std::string& name,
                           const std::string& postalCode,
                           const GeoBox& boundingBox);
 
      bool AddLocationWay(const Way& way,
                          const std::string& name,
                          const std::string& postalCode,
                          const GeoBox& boundingBox);
 
      bool AddRegion(const RegionRef& region,
                     bool assume_contains=true);
 
    private:
      void CalculateProbePoints();                           
      void CalculateProbePointsForArea(size_t areaIndex,     
                                       size_t refinement=0);
    };
 
    class RegionIndex CLASS_FINAL
    {
    private:
      double                                cellWidth;
      double                                cellHeight;
      std::map<Pixel,std::list<RegionRef> > index;
 
    public:
      RegionIndex(double cellWidth,
                  double cellheight);
 
      void IndexRegions(const std::vector<std::list<locidx::RegionRef> >& regionTree);
 
      RegionRef GetRegionForNode(const RegionRef& rootRegion,
                                 const GeoCoord& coord) const;
    };
 
  }
 
  class LocationIndexGenerator CLASS_FINAL : public ImportModule
  {
  public:
    static const char* const FILENAME_LOCATION_REGION_TXT;
    static const char* const FILENAME_LOCATION_FULL_TXT;
    static const char* const FILENAME_LOCATION_METRICS_TXT;
 
  private:
    uint8_t                bytesForNodeFileOffset;
    uint8_t                bytesForAreaFileOffset;
    uint8_t                bytesForWayFileOffset;
 
    ImportErrorReporterRef errorReporter;
 
  private:
    void Write(FileWriter& writer,
               const ObjectFileRef& object) const;
 
    void CalculateRegionMetrics(const locidx::Region& region,
                                locidx::RegionMetrics& metrics) const;
 
    void DumpRegion(const locidx::Region& parent,
                    size_t indent,
                    std::ostream& out) const;
 
    void DumpRegionAndData(const locidx::Region& parent,
                           size_t indent,
                           std::ostream& out) const;
 
    bool DumpRegionTree(Progress& progress,
                        const locidx::Region& rootRegion,
                        const std::string& filename) const;
 
    bool DumpLocationTree(Progress& progress,
                          const locidx::Region& rootRegion,
                          const std::string& filename) const;
 
    bool DumpLocationMetrics(Progress& progress,
                             const std::string& filename,
                             const locidx::RegionMetrics& metrics,
                             const std::list<std::string>& regionIgnoreTokens,
                             const std::list<std::string>& poiIgnoreTokens,
                             const std::list<std::string>& locationIgnoreTokens) const;
 
    bool GetBoundaryAreas(const ImportParameter& parameter,
                          Progress& progress,
                          const TypeConfigRef& typeConfig,
                          const TypeInfoSet& boundaryTypes,
                          std::vector<std::list<locidx::RegionRef>>& boundaryAreas) const;
 
    void SortInBoundaries(Progress& progress,
                          locidx::Region& rootRegion,
                          const std::list<locidx::RegionRef>& boundaryAreas);
 
    bool GetRegionAreas(const TypeConfig& typeConfig,
                        const ImportParameter& parameter,
                        Progress& progress,
                        std::list<locidx::RegionRef>& regionAreas) const;
 
    bool SortInRegionAreas(Progress& progress,
                           locidx::Region& rootRegion,
                           std::list<locidx::RegionRef>& regionAreas);
 
    void SortInRegion(const locidx::RegionRef& area,
                      std::vector<std::list<locidx::RegionRef> >& regionTree,
                      unsigned long level);
 
    unsigned long GetRegionTreeDepth(const locidx::Region& rootRegion) const;
 
    bool IndexRegionNodes(const TypeConfigRef& typeConfig,
                          const ImportParameter& parameter,
                          Progress& progress,
                          const locidx::RegionIndex& regionIndex,
                          locidx::RegionRef& rootRegion);
 
    bool IndexLocationAreas(const TypeConfig& typeConfig,
                            const ImportParameter& parameter,
                            Progress& progress,
                            const locidx::RegionIndex& regionIndex,
                            locidx::RegionRef& rootRegion);
 
    bool IndexLocationWays(const TypeConfig& typeConfig,
                           const ImportParameter& parameter,
                           Progress& progress,
                           const locidx::RegionIndex& regionIndex,
                           locidx::RegionRef& rootRegion);
 
    void AddLocationAreaToRegion(locidx::RegionRef& rootRegion,
                                 const Area& area,
                                 const Area::Ring& ring,
                                 const std::string& name,
                                 const std::string& postalCode,
                                 const locidx::RegionIndex& regionIndex);
 
    void AddAddressToRegion(Progress& progress,
                            locidx::Region& region,
                            const ObjectFileRef& object,
                            const std::string& location,
                            const std::string& address,
                            const std::string &postalCode,
                            bool allowDuplicates,
                            bool& added);
 
    void AddAddressAreaToRegion(Progress& progress,
                                locidx::Region& region,
                                const FileOffset& fileOffset,
                                const std::string& location,
                                const std::string& address,
                                const std::string &postalCode,
                                const std::vector<Point>& nodes,
                                const GeoBox& boundingBox,
                                bool& added);
 
    bool IndexAddressAreas(const TypeConfig& typeConfig,
                           const ImportParameter& parameter,
                           Progress& progress,
                           locidx::RegionRef& rootRegion,
                           const locidx::RegionIndex& regionIndex);
 
    bool AddAddressWayToRegion(Progress& progress,
                               locidx::Region& region,
                               const FileOffset& fileOffset,
                               const std::string& location,
                               const std::string& address,
                               const std::vector<Point>& nodes,
                               const GeoBox& boundingBox,
                               bool& added);
 
    bool IndexAddressWays(const TypeConfig& typeConfig,
                          const ImportParameter& parameter,
                          Progress& progress,
                          const locidx::RegionRef& rootRegion,
                          const locidx::RegionIndex& regionIndex);

    std::map<std::string,locidx::RegionLocation>::iterator FindLocation(Progress& progress,
                                                                const locidx::Region& region,
                                                                locidx::PostalArea& postalArea,
                                                                const std::string &locationName) const;
 
    void AddAddressNodeToRegion(Progress& progress,
                                locidx::Region& region,
                                const FileOffset& fileOffset,
                                const std::string& location,
                                const std::string& address,
                                const std::string& postalCode,
                                bool& added);
 
    bool IndexAddressNodes(const TypeConfig& typeConfig,
                           const ImportParameter& parameter,
                           Progress& progress,
                           const locidx::RegionRef& rootRegion,
                           const locidx::RegionIndex& regionIndex);
 
    void CleanupPostalAreasAdresses(locidx::Region& region);
    void CleanupPostalAreasLocations(locidx::Region& region);
    void CleanupPostalAreas(locidx::Region& region);
 
    void SortLocationTree(locidx::Region& region);
 
    void ValidateIsIn(locidx::Region& region);
 
    void WriteIgnoreTokens(FileWriter& writer,
                           const std::list<std::string>& regionIgnoreTokens,
                           const std::list<std::string>& poiIgnoreTokens,
                           const std::list<std::string>& locationIgnoreTokens) const;
 
    void WriteRegionMetrics(FileWriter& writer,
                            const locidx::RegionMetrics& metrics) const;
 
    void WriteRegionIndexEntry(FileWriter& writer,
                               const locidx::Region& parentRegion,
                               locidx::Region& region);
 
    void WriteRegionIndex(FileWriter& writer,
                          locidx::Region& region);
 
    void WriteRegionDataEntry(FileWriter& writer,
                              locidx::Region& region);
 
    void WriteRegionData(FileWriter& writer,
                         locidx::Region& region);
 
    void WritePostalArea(FileWriter& writer,
                         locidx::PostalArea& postalArea) const;
 
    void WriteAddressDataEntry(FileWriter& writer,
                               const locidx::Region& region);
 
    void WriteAddressData(FileWriter& writer,
                          const locidx::Region& region);
 
  public:
    void GetDescription(const ImportParameter& parameter,
                        ImportModuleDescription& description) const override;
 
    bool Import(const TypeConfigRef& typeConfig,
                const ImportParameter& parameter,
                Progress& progress) override;
  };
}
 
#endif