pathFeature.h

Go to the documentation of this file.

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


#pragma once

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

namespace MAKVRinTerra
{
   class DT_DLL_features DtPathFeature : public DtFeature
   {
   public:
      typedef boost::shared_ptr<DtPathFeature>        Ptr;
      typedef boost::shared_ptr<const DtPathFeature>  CPtr;

      enum Direction
      {
         BOTH_WAYS,
         ONE_WAY_FORWARD,
         ONE_WAY_BACKWARD
      };

      static const char* TypeName;

      virtual DtPathFeature* clone() const = 0;

      virtual DtFeatureGeometry::Path pathGeometry() const = 0;

      virtual Direction direction() const;
      virtual boost::optional<unsigned> numLanes() const;
      virtual boost::optional<double> width() const;
      virtual boost::optional<double> medianWidth() const;
      virtual boost::optional<std::string> roadName() const;
   };

   typedef DtFeatureSetTemplate<DtPathFeature> DtPathFeatureSet;

   class DT_DLL_features DtSimplePathFeature : public DtPathFeature
   {
   public:
      static DtPathFeatureSet* MakeSet(DtFeatureSet*);

      explicit DtSimplePathFeature(const DtFeature& feature);
      explicit DtSimplePathFeature(DtFeature*);
      explicit DtSimplePathFeature(DtFeature*, const DtFeatureGeometry::Path&);

      DtFeatureGeometry geometry() const           { return myPathGeometry; }
      DtFeatureGeometry::Path pathGeometry() const { return myPathGeometry; }


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

      void forEachAttribute(ForEachFunction f) const
      {
         myFeature.forEachAttribute(f);
      }

      unsigned numberOfAttributes(const Key::String & name) const
      {
         return myFeature.numberOfAttributes(name);
      }

      DtSimplePathFeature* clone() const
      {
         return new DtSimplePathFeature(*this);
      }

      DetachCallback addDeleteCallback(const DeleteCallback& callback) const
      {
         return myFeature.addDeleteCallback(callback);
      }

      bool isDeleted() const
      {
         return myFeature.isDeleted();
      }

   private:
      DtSimplePathFeature(const DtSimplePathFeature& from)
         : myFeature(from.myFeature)
         , myPathGeometry(from.myPathGeometry)
      {
      }

      DtFeatureWrapper<DtFeature> myFeature;
      DtFeatureGeometry::Path myPathGeometry;
   };

   //Use on a feature set with findeachFeature to get the closest
   //path feature to the given point.  Once the closest feature 
   //has been found, call findClosestPointOnFeature() to get 
   //the closest edge and closest point on that edge.
   class DT_DLL_features DtClosestPathFeatureFinder
   {
   public:   
      typedef DtFeatureGeometry::PointVector PointVector;

      explicit DtClosestPathFeatureFinder(
         const DtPoint& point,
         const DtProj& localProj);

      void operator()(const DtPathFeature & feature);

      void findClosestPointOnFeature();

      bool foundClosestFeature() const;

      DtFeatureGeometry::Point myEntityPoint;
      DtPathFeature::CPtr myClosestFeature;
      double myClosestDistance;
      DtPoint myClosestPoint;
      DtPoint myClosestEdgeA;
      DtPoint myClosestEdgeB;
      DtProj::CPtr myLocalProj;
      DtProj::CPtr myTopoProj;
   };
}