gdbVectorNetworkFeatureSet.h

Go to the documentation of this file.

#pragma once

#include <features/featureSet.h>
#include <features/featureSetList.h>
#include <features/feature.h>
#include <features/query.h>
#include <gdb/specificationManager.h>
#include <iosfwd>
#include <set>

class DtVectorNetwork;
class DtNetworkEdge;
class DtNetworkNode;
class DtNetworkElement;
class OGRLayer;

namespace MAKVRinTerra
{
   class DT_DLL_features DtGdbVectorFeature
      : public DtFeature
      , public boost::enable_shared_from_this<DtGdbVectorFeature>
   {
   public:

      typedef boost::shared_ptr<DtGdbVectorFeature> Ptr;

      DtGdbVectorFeature(boost::shared_ptr<DtSpecificationManager> mgr, DtProj::CPtr);

      virtual ~DtGdbVectorFeature();

      virtual DtFeatureGeometry geometry() const;

      virtual void setAsPointGeometry(const DtPoint&);

      virtual void setAsLinearGeometry(const std::vector<DtPoint>&);

      virtual void setAsArealGeometry(const std::vector<DtPoint>&);

      virtual void setSpecificationID(DtSpecificationID);
      DtSpecificationID specificationID() const
      {
         return mySpecID;
      }

      static Ptr MakePoint(const DtNetworkNode*, boost::shared_ptr<DtSpecificationManager> mgr, DtProj::CPtr projection);

      static Ptr MakePath(const DtNetworkEdge*, boost::shared_ptr<DtSpecificationManager> mgr, DtProj::CPtr projection);

      static Ptr MakeArea(const DtNetworkEdge*, boost::shared_ptr<DtSpecificationManager> mgr, DtProj::CPtr projection);

      static Ptr Make(std::istream&, boost::shared_ptr<DtSpecificationManager> mgr, DtProj::CPtr projection);

      virtual boost::optional<Attribute> attribute(const Key & k) const;

      virtual void forEachAttribute(ForEachFunction f) const;

      virtual unsigned numberOfAttributes(const Key::String &) const;

      DetachCallback addDeleteCallback(const DeleteCallback&) const
      {
         return DetachCallback();
      }

      bool isDeleted() const
      {
         return false;
      }

      virtual void print(std::ostream&);

      virtual void convert(DtProj::CPtr transformTo);

   protected:
      virtual DtPoint geodeticTransform(const DtPoint&, DtProj::CPtr from, DtProj::CPtr to);

   protected:
      boost::shared_ptr<DtFeatureGeometry> myGeometry;
      boost::shared_ptr<DtSpecificationManager> mySpecificationManager;
      DtProj::CPtr myProjection;
      DtSpecificationID mySpecID;
   };

   class DT_DLL_features DtGdbFeatureSetCollection : public DtFeatureSet
   {
   public:
      DtGdbFeatureSetCollection(std::string file);

      DtGdbFeatureSetCollection(const DtGdbFeatureSetCollection&);

      virtual ~DtGdbFeatureSetCollection();

      virtual std::string label() const;
      DtFeatureSet* filter(
         const DtQuery&, const boost::optional<DtFeatureGeometry>&, DtLoadType) const;
      virtual void forEachFeatureParallel(const ForEachFunction&) const;
      virtual DetachCallback forEachFeatureAsync(const ForEachFunction& func) const;
      virtual DtFeatureSet* clone() const;
      virtual bool loaded(double = 0.0) const;
      virtual DetachCallback addLoadedCallback(const LoadedCallback&) const;
      virtual unsigned numberOfFeatures() const;
      virtual bool elided() const;
      virtual bool empty() const;

      virtual void setFeatureType(DtFeatureGeometry::Type);

      virtual void add(DtGdbVectorFeature::Ptr);

      virtual void print(std::ostream&);

   protected:
      std::vector<DtGdbVectorFeature::Ptr> myFeatures;
      std::string myFile;
   };

   class DT_DLL_features DtGdbVectorNetworkFeatureSet : public DtFeatureSet::List
   {
   public:
      DtGdbVectorNetworkFeatureSet(DtVectorNetwork*, std::string file, const DtProj* transformToProjection = 0);

      DtGdbVectorNetworkFeatureSet();

      virtual ~DtGdbVectorNetworkFeatureSet();

      virtual std::string label() const;

      virtual DtGdbFeatureSetCollection* getOrCreatePointFeatureSet();

      virtual DtGdbFeatureSetCollection* getOrCreateLinearFeatureSet();

      virtual DtGdbFeatureSetCollection* getOrCreateArealFeatureSet();

      virtual void processNodeFeatures(DtVectorNetwork*);

      virtual void processEdgeFeatures(DtVectorNetwork*);

      virtual void addLinearFeature(DtNetworkEdge*);

      virtual void addArealFeature(DtNetworkEdge*);

      virtual bool isPointFeature(const DtNetworkElement& networkElement);

      virtual bool isLinearFeature(const DtNetworkElement& networkElement);

      virtual bool isArealFeature(const DtNetworkElement& networkElement);

      static DtGdbVectorNetworkFeatureSet* Make(const std::string&);

      virtual void print(const std::string& file);
      virtual void print(std::ostream&);
      virtual void print(std::ostream&, const DtSpecification&);
      virtual void print(std::ostream&, DtGdbFeatureSetCollection*);

      virtual bool saveAsShapeFiles(const std::string& directory, std::string& error);

   protected:

      typedef std::map<std::string, int> AttributeMap;

      struct SpecificationLayer
      {
         std::set<DtSpecificationID> ids;
         AttributeMap attributes;
      };

      typedef std::map<int, SpecificationLayer> SpecificationLayers;

      virtual SpecificationLayers specificationLayers() const;

      virtual AttributeMap createAttributeMapFromSpecification(const DtSpecification&) const;

      virtual bool saveShapeFileForLayer(int featureType, const SpecificationLayer&, const std::string& directory, std::string& error) const;

      virtual std::string fixupNameToLength(const std::string& name, int length) const;

      virtual bool addAttributesToLayer(const AttributeMap&, OGRLayer*, std::string& error) const;

      virtual void addFeatureToOgrLayer(const DtFeature&, OGRLayer*, const SpecificationLayer&) const;

   protected:
      DtGdbFeatureSetCollection*  myPointFeatureSet;
      DtGdbFeatureSetCollection*  myLinearFeatureSet;
      DtGdbFeatureSetCollection*  myArealFeatureSet;

      boost::shared_ptr<DtSpecificationManager> mySpecificationManager;

      DtProj::CPtr myProjection;
      DtProj::CPtr myTransformToProjection;

      typedef std::map<std::string, std::string> OriginalLabelMap;
      OriginalLabelMap myOriginalLabelMap;
      std::string myFile;
   };
}