pathFeatureConverter.h

Go to the documentation of this file.

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

#pragma once

#include <deque>
#include <bhavePathDataGen/baseFeatureConverter.h>
#include <terrainInterface/terrainProcessPolygonsBox.h>

#include <features/pathFeature.h>
#include <features/featureGeometry.h>

class DtTerrainInterface;

namespace BHAVE 
{
   struct DtSegmentStruct
   {
      DtPoint leftOffset;
      DtPoint rightOffset;
      double halfWidth;
      unsigned int segmentId;
      unsigned int firstNodeId;
      unsigned int secondNodeId;
      MAKVRinTerra::DtPathFeature::CPtr feature;

      DtPoint leftFirstBP;
      DtPoint rightFirstBP;
      DtPoint leftSecondBP;
      DtPoint rightSecondBP;

      DtPoint leftEnd;
      DtPoint rightEnd;

      DtSegmentStruct(MAKVRinTerra::DtPathFeature::CPtr f, const DtPoint& leftPoint, const DtPoint& rightPoint)
      {
         feature = f;
         leftEnd = leftPoint;
         rightEnd = rightPoint;
      }

      DtPoint endPoint(int zeroOrOne) const
      {
         if (zeroOrOne)
         {
            return rightEnd;
         }
         else
         {
            return leftEnd;
         }
      }
   };

   struct DtSegmentNodeStruct
   {
   public:
      DtPoint location;
      std::map<unsigned int,int> segmentEnds;
      unsigned int nodeId;
      std::deque<DtPoint> boundingPoints;

      DtSegmentNodeStruct(const DtPoint& point)
      {
         location = point;
      }

      bool operator< (const DtSegmentNodeStruct& right) const
      {
         if (location.x() != right.location.x())
         {
            return (location.x() < right.location.x());
         }
         if (location.y() != right.location.y())
         {
            return (location.y() < right.location.y());
         }
         if (location.z() != right.location.z())
         {
            return (location.z() < right.location.z());
         }
         return false;
      }

      bool operator==(const DtSegmentNodeStruct& other) const
      {
         return (location == other.location);
      }

      bool operator!=(const DtSegmentNodeStruct& other) const
      {
         return (location == other.location);
      }   
   };

   class DtPathFeatureConverter : public DtBaseFeatureConverter
   {
   public: 
      
      DtPathFeatureConverter(DtTerrainInterface* terrainInterface, 
                             const std::string& featureType, 
                             unsigned int terrainType, 
                             bool isGeocentric = false);

      virtual ~DtPathFeatureConverter();

      virtual void init(DtTerrainProcessPolygonsBox& box);

      virtual bool processAllBoundingPolygons(DtProcessBoundingPolygonCallbackFcn func, void* usr);

      virtual void operator()(const MAKVRinTerra::DtPathFeature& feature);

   protected:

      //
      virtual bool calcSegmentPoints(DtSegmentStruct& segment);

      virtual bool calcSlopeOfLine(const DtPoint& startPoint, const DtPoint& endPoint, double& slope) const;

      //
      //
      //
      virtual bool calcIntersectionOfTwoArbSegs(const DtPoint& segOneA, const DtPoint& segOneB, 
         const DtPoint& segTwoA, const DtPoint& segTwoB, DtPoint& result) const;

      //
      //
      //
      virtual void calcEndNodePoints(DtSegmentNodeStruct& node, unsigned int segmentId, int segmentEnd);

      //
      //
      virtual void calcTopNodePoints(DtSegmentNodeStruct& node, unsigned int segmentOneId,
         int segmentOneEnd, unsigned int segmentTwoId, int segmentTwoEnd);

      virtual void calcNodeBoundingPoints();

      virtual unsigned int addNode(const DtPoint& point, unsigned int segmentId, int endpoint);

      //
      //
      //
      virtual double determineAngle(const DtPoint& centerPoint, const DtPoint& point, bool degrees = false) const;

      std::map<DtSegmentNodeStruct, unsigned int> myNodeHistory;
      std::deque<DtSegmentNodeStruct> myNodes;
      std::deque<DtSegmentStruct> mySegments;
   };
}