vecNetwTool.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2006 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: vecNetwTool.h,v $ $Revision: 1.26 $ $State: Exp $
*******************************************************************************/

// \file vecNetwTool.h
// \brief Contains the DtVectorNetworkTool class declaration.


#ifndef vecNetwTool_H_
#define vecNetwTool_H_

#include "gdb/gdbDefines.h"
#include <vlutil/vlList.h>
#include <list>

class DtNetworkNode;
class DtNetworkSegment;
class DtNetworkEdge;
class DtVectorNetwork;
class DtPoint;
class DtTerrainDatabase;
class DtSegmentMxCifTree;

class DT_DLL_gdb DtVectorNetworkTool
{
public:

   typedef std::list<const DtNetworkEdge*> DtNetworkEdgeContainer;
   typedef DtNetworkEdgeContainer::iterator DtNetworkEdgeIter;
   typedef DtNetworkEdgeContainer::const_iterator DtNetworkEdgeConstIter;

   // default constructor 
   DtVectorNetworkTool();

   // destructor
   virtual ~DtVectorNetworkTool();

   // Constructs a non-intersecting network from a given vector network, detecting and
   // eliminating places in which edges cross one another.  Returns true if
   // valid network. Only detects intersections between linear features of 
   // MAK GROUP MAK010 and MAK030, water features and roads.  
   // \note Because it only detects linear features (DtFeatureType == 1), only
   // rivers and road intersections should be detected and fixed.
   //
   // inputNetwork:  vector network that may contain crossing edges
   // outputNetwork: vector network in which edges have been eliminated by
   //                inserting new nodes and edges at the intersection points.  
   //                Caller must allocate outputNetwork outside of this call.
   //                *Assumes* that the output network is an *empty* network.
   //
   // tolerance:     the tolerance to use when deciding if edges intersect or 
   //                points are equal
   // excessiveEdgeCount:  if the network contains more than this number of edges at any time,
   //                      it stops planarizing for memory and performance reasons.
   //
   // @note: sets the myTolerance and myExcessiveEdgeCount member variables.
   //       
   virtual bool planarizeNetwork(DtVectorNetwork& inputNetwork, 
                                 DtVectorNetwork& outputNetwork,
                                 DtReal tolerance,
                                 unsigned int excessiveEdgeCount);

   // Clips all vector data to the extent specified by the two points.  
   // Assumes that the output vector network is an *empty* network.
   // The inputNetwork is converted to Geodetic *if* it comes in Geocentric. 
   // It is not restored back to Geocentric.
   virtual bool clipNetwork(DtVectorNetwork& inputNetwork, 
                            DtVectorNetwork& outputNetwork,
                            const DtPoint& southWestPoint,
                            const DtPoint& northEastPoint);

   virtual int sizeInBytes() const;

private:

   // copy constructor - not implemented
   DtVectorNetworkTool(const DtVectorNetworkTool& orig);

   // assignment operator  - not implemented
   DtVectorNetworkTool& operator=(const DtVectorNetworkTool& orig);

protected:

   // add connectivity to the existing vector data
   // could be faster, (called from planarizeNetwork()).
   // breaks all of the edges.  Very expensive.
   virtual void buildConnectivity(const DtVectorNetwork& inputNetwork, 
                                  DtVectorNetwork& outputNetwork,
                                  unsigned int numNodes);

   // connect all the edges with appropriate nodes
   // finds broken edges and connects them with new nodes.
   // Very expensive (n-squared for number of edges).
   virtual void buildEdges(const DtNetworkEdgeContainer& processedEdges,
                           DtVectorNetwork& network);

   // This method takes all the edges in inputNetwork and splits them at 
   // intersections.  It returns the remaining edges in processedEdgeList.  
   // Called from buildConnectivity.  
   //
   // \return True if successful and false if not.
   virtual bool deIntersectEdges(std::list<DtNetworkEdge*>& unprocessedEdges,
      DtVectorNetwork& outputNetwork, DtNetworkEdgeContainer& processedEdgeList);

   // split an edge into two.  splitEdge1 and splitEdge2 return the
   // two new edges.
   virtual void splitEdge(const DtNetworkEdge& edge1, const DtNetworkSegment& seg1,
      DtReal splitX, DtReal splitY, DtReal splitZ, DtNetworkEdge*& splitEdge1, 
      DtNetworkEdge*& splitEdge2);

   // --------------------------------------------------------
   // functions to create temporary nodes, segments, and edges
   // --------------------------------------------------------

   // allocate a new edge and put it on the list for later deletion
   virtual DtNetworkEdge* newEdgeToDelete();

   // allocate a new edge; user must handle deletion
   virtual DtNetworkEdge* newEdge();

   // allocate a new edge and put it on the list for later deletion
   // copy over essential properties
   virtual DtNetworkEdge* newEdgeToDelete(const DtNetworkEdge& edge);

   // allocate a new edge; user must handle deletion
   // copy over essential properties
   virtual DtNetworkEdge* newEdge(const DtNetworkEdge& edge);

   // Deletes every element in myEdgeListToBeDeleted.  
   // Called from planarizeNetwork to 
   // clean up all the temporary edges created while
   // splitting the intersecting vectors.
   void deleteAllocatedEdges();

   bool buildNetworkFromEdges(const DtNetworkEdgeContainer& edges,
                              DtVectorNetwork& outputNetwork);

   bool calculateArealCentroids(DtVectorNetwork& vectorNetwork);

   bool clipEdges(const DtVectorNetwork& inputNetwork, 
                  DtNetworkEdgeContainer& croppedEdges, 
                  const DtPoint& southWestPoint, 
                  const DtPoint& northEastPoint, DtVectorNetwork& clippedVectorNetwork);

   bool clipNodes(const DtVectorNetwork& inputNetwork,
                  DtVectorNetwork& outputNetwork,
                  const DtPoint& southWestPoint, 
                  const DtPoint& northEastPoint);

   // Clips the specified node to the specified extent.
   // If the node lies within the extent, a copy of the node 
   // is added to the specified vector network. 
   // Otherwise, nothing is added.
   // NOTE:  Returns false only if an error occurred during clipping,
   //        not if the node was entirely clipped out.
   virtual bool clipNode(const DtNetworkNode& node, 
                         const DtPoint& southWestPoint,
                         const DtPoint& northEastPoint,
                         DtVectorNetwork& clippedVectorNetwork);

   // Used by clipArea and clipEdge to actually do the clipping of
   // the edge or area.
   // isClosedNetwork specifies whether the edge is actually an area (closed edge)
   // The specificationID is the ID of the specification associated with the edge
   // in its vector network's specification manager.
   //
   // Returns false if the network element was not added to the 
   // network for any reason, including an error.
   virtual bool clipNetworkElement(const DtNetworkEdge& edgeToClip, 
      const DtPoint& southWestPoint, const DtPoint& northEastPoint,
      DtNetworkEdgeContainer& clippedEdges, bool isClosedNetwork,
      DtVectorNetwork& clippedVectorNetwork);

   virtual bool clipLinearFeature(const DtNetworkEdge& edgeToClip, 
      const DtPoint& southWestPoint, const DtPoint& northEastPoint,
      DtNetworkEdgeContainer& clippedEdges, DtVectorNetwork& clippedVectorNetwork);

   virtual bool clipArealFeature(const DtNetworkEdge& edgeToClip, 
      const DtPoint& southWestPoint, const DtPoint& northEastPoint,
      DtNetworkEdgeContainer& clippedArealFeature, DtVectorNetwork& clippedVectorNetwork);

   // Function to manipulate points, determining if they are in the area of interest, moved to 
   // the closest location in the area (cropping) and to calculate the extent for area features,
   virtual bool isInArea(const DtPoint& point,
                         const DtPoint& southWestPoint,
                         const DtPoint& northEastPoint);
   
   // Determines if the specified point is in an area.  If not, it clips it to the area
   // in the direction of nextPoint.
   virtual DtPoint moveInArea(const DtPoint& point, 
                              const DtPoint& nextPoint,
                              const DtPoint& southWestPoint,
                              const DtPoint& northEastPoint);

   virtual void updateExtent(const DtPoint& point, DtPoint& minPoint, DtPoint& maxPoint);
   virtual void calculateExtent(const DtNetworkEdge& edge, DtPoint& minPoint, DtPoint& maxPoint);

   // Iterates over the segments in the given DtNetworkEdge and adds them to
   // the given DtSegmentMxCifTree
   void addEdgeToSegmentTree(const DtNetworkEdge& edgeToAdd, 
      DtSegmentMxCifTree& segmentTree) const;

   // Iterates over the segments in the given DtNetworkEdge and removes them 
   // from the given DtSegmentMxCifTree
   void removeEdgeFromSegmentTree(const DtNetworkEdge& edgeToRemove, 
      DtSegmentMxCifTree& segmentTree) const;


   virtual bool testInvariant() const;

protected:

   std::list<DtNetworkEdge*>      myEdges;
   
   // The following is the tolerance used to assess equality of points
   DtReal    myTolerance;
   // The following is the excessive edge count for the graph.  If the
   // number of edges exceeds this value, the conversion stops.
   DtU32     myExcessiveEdgeCount;
};

#endif