include/bhavePathDataGen/vectorNetworkConverter.h

Go to the documentation of this file.

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

#pragma once

#include "gdb/rangeNetSegMet.h"
#include "gdb/vecNetwrk.h"
#include "gdb/netwrkSeg.h"
#include "gdb/specification.h"
#include <deque>

namespace BHAVE 
{
   typedef void (*DtProcessBoundingPolygonCallbackFcn)(std::deque<DtPoint> points, void* usr);

   struct DtSegmentStruct
   {
      DtPoint leftOffset;
      DtPoint rightOffset;
      double halfWidth;
      unsigned int segmentId;
      unsigned int firstNodeId;
      unsigned int secondNodeId;
      const DtNetworkSegment* vectorSegment;

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

      DtPoint leftEnd;
      DtPoint rightEnd;

      DtSegmentStruct(const DtNetworkSegment* seg)
      {
         vectorSegment = seg;
         leftEnd = vectorSegment->endpoint0();
         rightEnd = vectorSegment->endpoint1();
      }

      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 DtVectorNetworkConverter
   {
   public: 
      DtVectorNetworkConverter(const DtVectorNetwork* network, bool isGeocentric = false);
      virtual ~DtVectorNetworkConverter();

      virtual void init(const DtPoint& center, double distance = 0.0);
      
      virtual bool processAllBoundingPolygons(DtProcessBoundingPolygonCallbackFcn func, void* usr) const;

      
   protected:

      virtual bool isValidBoundingPolygon(const std::deque<DtPoint>& points) const;

      //
      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 generateNodesAndSegments(DtRangeNetworkSegmentMetric* metric);

      virtual void calcNodeBoundingPoints();

      //
      //
      virtual bool calcOrthoOffset(const DtPoint& startPoint, const DtPoint& endPoint, double distance,
         DtPoint& leftOffset, DtPoint& rightOffset) const;

      //
      //
      virtual bool findPointOnLine(const DtPoint& startPoint, 
         const DtPoint& endPoint, DtPoint& result, double distance) const; 

      virtual bool addSegment(const DtNetworkSegment* seg);

      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;

      const DtVectorNetwork* myNetwork;
      DtRangeNetworkSegmentMetric* myMetric;
      
      std::map<DtSegmentNodeStruct, unsigned int> myNodeHistory;
      std::deque<DtSegmentNodeStruct> myNodes;
      std::deque<DtSegmentStruct> mySegments;

      double myMinZ;
      double myMaxZ;

      bool myIsGeocentric;
   };


}