obstacleFeature.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include <features/feature.h>
#include <features/featureSet.h>
#include <features/featureDuplicateRemover.h>

namespace MAKVRinTerra
{
   class DT_DLL_features DtObstacleFeature : public DtFeature
   {
   public:

      static const char* TypeName;

      typedef boost::shared_ptr<DtObstacleFeature>       Ptr;
      typedef boost::shared_ptr<const DtObstacleFeature> CPtr;

      static CPtr GetPtr(const DtObstacleFeature&);

      DtFeature::CPtr getPtr() const;
      virtual CPtr getObstaclePtr() const = 0;

      DtFeatureGeometry geometry() const;

      virtual DtFeatureGeometry::Area obstacle() const = 0;
   };

   typedef DtFeatureSetTemplate<DtObstacleFeature> DtObstacleFeatureSet;

   class DT_DLL_features DtObstacleFeatureSetAdapter : public DtObstacleFeatureSet
   {
   public:
      struct DT_DLL_features Config
      {
         std::string type;

         double buffer;

         bool unioned;

         explicit Config(
            const std::string& type, double buffer=0, bool unioned=false);

         bool operator<(const Config& other) const;
      };

      struct ObstacleCollector;

      explicit DtObstacleFeatureSetAdapter(
         DtFeatureSet* fs, const DtProj& proj, const Config& cfg);

      std::string label() const;
      void forEachFeature(ForEachFunction func, DtWaitType) const;
      DtObstacleFeatureSet* filter(const DtQuery& query, DtLoadType) const;
      DtObstacleFeatureSet* clone() const;
      bool loaded(double) const;
      unsigned numberOfFeatures() const;
      bool empty() const;

   protected:
      explicit DtObstacleFeatureSetAdapter(
         DtFeatureSet* fs, const DtObstacleFeatureSetAdapter& from);

      boost::scoped_ptr<DtFeatureSet> myFeatureSet;
      DtProj::CPtr myProjection;
      Config myConfig;
   };

   struct DtObstacleFeatureSetAdapter::ObstacleCollector
   {
      void operator()(const DtFeature& feature);

      void addFeature(const DtFeature& feature);

      void addGeometry(DtFeatureGeometry g,
         boost::optional<double> width = boost::none_t(),
         boost::optional<double> length = boost::none_t(),
         boost::optional<double> rotation = boost::none_t());

      typedef DtFeatureDuplicateRemover<DtFeature> DuplicateRemover;

      ObstacleCollector(const DtProj& proj, const Config& cfg);

      DtProj::CPtr projection;
      DuplicateRemover dedupe;
      Config config;
      DtFeatureGeometry collectedObstacles;
   };

   template <>
   class DtFeatureWrapper<DtObstacleFeature> : public DtObstacleFeature
   {
   public:
      DtFeature::CPtr getPtr() const { return DtFeature::Ptr(clone()); }
      DtObstacleFeature::CPtr getObstaclePtr() const { return DtObstacleFeature::Ptr(clone()); }

      DtFeatureGeometry geometry() const { return myWrappedFeature->geometry(); }
      DtFeatureGeometry::Area obstacle() const { return myWrappedFeature->obstacle(); }

      void forEachAttribute(ForEachFunction func) const 
      {    
         myWrappedFeature->forEachAttribute(func);
      }

      unsigned numberOfAttributes(const Key::String& str) const
      {
         return myWrappedFeature->numberOfAttributes(str);
      }

      boost::optional<Attribute> attribute(const Key& key) const
      {
         return myWrappedFeature->attribute(key);
      }

   protected:
      explicit DtFeatureWrapper(const DtObstacleFeature& f)
         : myWrappedFeature(f.getObstaclePtr()) { }

      explicit DtFeatureWrapper(DtObstacleFeature::CPtr f)
         : myWrappedFeature(f) { }

      virtual DtFeatureWrapper* clone() const = 0;

      DtObstacleFeature::CPtr myWrappedFeature;
   };
}