vectorNetwork.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1999 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: vecNetwrk.h,v $ $Revision: 1.35 $ $State: Exp $
*********************************************************************/
#ifndef vectorNetwork_H_
#define vectorNetwork_H_

#include "gdb/gdbDefines.h"
#include "gdb/terrainFeature.h"
#include "gdb/pointQuadtreeNode.h"
#include "gdb/segmentMxCifTree.h"
#include "gdb/networkSpecificationElement.h"
#include "geometry/surface.h"
#include "gdb/specificationAttribute.h"
#include "gdb/vectorNetworkIntersectionRecord.h"
#include <vlutil/vlConfig.h>
#include <list>
#include <vector>


//forward declarations
class DtNetworkSegment;
class DtNetworkEdge;
class DtNetworkNode;
class DtNetworkNodeMetric;
class DtNetworkAreaMetric;
class DtSpecificationManager;
class DtVectorNetworkRecord;
class DtVectorNetworkIntersectionRecordList;


//
// DtVectorNetwork is used to represent networks of vector data. 
class DT_DLL_gdb DtVectorNetwork
{
public:

   typedef std::vector<DtNetworkNode*> DtNodeContainer;
   typedef DtNodeContainer::iterator DtNodeIter;
   typedef DtNodeContainer::const_iterator DtNodeConstIter;

   typedef std::vector<DtNetworkEdge*> DtEdgeContainer;
   typedef DtEdgeContainer::iterator DtEdgeIter;
   typedef DtEdgeContainer::const_iterator DtEdgeConstIter;


   // constructor
   DtVectorNetwork();

   // destructor
   virtual ~DtVectorNetwork();

private:
   // copy constructor - not implemented
   DtVectorNetwork(const DtVectorNetwork& orig);

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

public:
   
   virtual DtSpecificationManager& specificationManager();
   virtual const DtSpecificationManager& specificationManager() const;
   virtual void setSpecificationManager(const DtSpecificationManager& specManager);

   // \return The number of nodes
   // \note This \b includes nodes set as removed!
   virtual unsigned int numNodes() const;

   // \return The number of nodes not set as removed.
   virtual unsigned int numUnremovedNodes() const;

   // \return The maximum number of nodes
   virtual unsigned int maxNumNodes() const;

   // Expands the vector network to contain at least the specified number of 
   // network nodes.
   virtual bool extendMaxNumNodesTo(unsigned int val);

   // add/remove a new node
   typedef std::vector<DtNetworkElement*> DtElementContainer;
   typedef DtElementContainer::iterator DtElementIter;
   typedef DtElementContainer::const_iterator DtElementConstIter;

   // Removes all the elements in the specified container.  
   // \return A boolean indicating whether or not all of the specified elements
   // could be removed or not.
   // \note The elements \b must be owned by this vector network.
   //
   // \implementation Currently, the elements are not removed, but are actually
   // set to be removed, and thus ignored by vector network queries and the
   // terrain writer.  
   virtual bool removeElements(DtElementContainer& elementsToRemove);
   
   // Removes the specified network elements from the vector network.  See the
   // removeElements function for more information about the behavior when
   // removing different types of elements.
   //
   // \return A boolean indicating whether or the specified element could be 
   // removed or not.
   //
   // \note The element \b must be owned by this vector network.
   // 
   // \see removeElements
   virtual bool removeElement(DtNetworkElement* elementToRemove);

   virtual DtNetworkNode* newNode();

   // expands the vector network's extent to include the specified
   // node and adds the node to the vector network's quadtree.
   // Only necessary to call this when adding a new node to an existing
   // vector network, as calculate extent will also accomplish the same
   // goals.
   virtual void addOn(DtNetworkNode& node);

   // Sets the removed flag of the node so that it will not affect calculations.
   virtual void setAsRemoved(DtNetworkElement& elementToSet, bool onOff = true) const;

   // get a pointer to an existing node
   virtual const DtNetworkNode* node(unsigned int val) const;
   virtual DtNetworkNode* node(unsigned int val);

   // get/add/remove a new segment
   virtual void addOn(DtNetworkSegment& segment);

   // \return The number of edges
   // \note This \b includes edges marked as removed!
   virtual unsigned int numEdges() const;

   // \return The number of edges, excluding edges set as removed.
   virtual unsigned int numUnremovedEdges() const;

   // get the maximum number of edges
   virtual unsigned int maxNumEdges() const;

   // extend the maximum number of edges
   virtual bool extendMaxNumEdgesTo(unsigned int val);

   // get a new edge
   virtual DtNetworkEdge* newEdge();

   // get a pointer to an edge
   virtual const DtNetworkEdge* edge(unsigned int val) const;
   virtual DtNetworkEdge* edge(unsigned int val);

   // determine the extent of the network
   virtual DtExtent extent() const;

   // modify extent to include all points in the vector network
   virtual void expandExtent(DtExtent& otherExt) const;

   // In order to hide the implementation details, wrap the underlying structures'
   // containers in new typedefs.
   typedef DtPointQuadtreeNode::DtPtrConstNodeContainer DtPtrConstNodeContainer;
   typedef DtPointQuadtreeNode::DtPtrConstNodeConstIter DtPtrConstNodeConstIter;
   typedef DtPointQuadtreeNode::DtPtrConstNodeIter DtPtrConstNodeIter;

   typedef DtPointQuadtreeNode::DtPtrNodeContainer DtPtrNodeContainer;
   typedef DtPointQuadtreeNode::DtPtrNodeConstIter DtPtrNodeConstIter;
   typedef DtPointQuadtreeNode::DtPtrNodeIter DtPtrNodeIter;

   // collect all nodes that are validated by the metric
   virtual void collectAllNodes(DtNetworkNodeMetric& metric, 
      DtPtrConstNodeContainer& nodeContainer) const;
   virtual void collectAllNodes(DtNetworkNodeMetric& metric, 
      DtPtrNodeContainer& nodeContainer);

   // find the best valid node in the tree as measured by the metric
   virtual const DtNetworkNode* findBestNode(DtNetworkNodeMetric& metric) const;

   // In order to hide the implementation details, wrap the underlying structures'
   // containers in new typedefs.
   typedef DtSegmentMxCifTree::DtPtrConstSegmentContainer DtPtrConstSegmentContainer;
   typedef DtSegmentMxCifTree::DtPtrConstSegmentConstIter DtPtrConstSegmentConstIter;
   typedef DtSegmentMxCifTree::DtPtrConstSegmentIter DtPtrConstSegmentIter;

   typedef DtSegmentMxCifTree::DtPtrSegmentContainer DtPtrSegmentContainer;
   typedef DtSegmentMxCifTree::DtPtrSegmentConstIter DtPtrSegmentConstIter;
   typedef DtSegmentMxCifTree::DtPtrSegmentIter DtPtrSegmentIter;

   // collect all segments that are validated by the metric
   virtual void collectAllSegments(DtNetworkSegmentMetric& metric, 
      DtPtrConstSegmentContainer& segmentContainer) const;
   virtual void collectAllSegments(DtNetworkSegmentMetric& metric, 
      DtPtrSegmentContainer& segmentContainer);

   // find the best valid segment in the tree as measured by the metric
   virtual const DtNetworkSegment* findBestSegment(DtNetworkSegmentMetric& metric) const;
   
   // collect all areas in the network as measured by the metrics
   typedef std::list<const DtNetworkElement*> DtPtrConstAreaContainer;
   typedef std::list<DtNetworkElement*> DtPtrAreaContainer;

   virtual void collectAllAreas(DtNetworkAreaMetric& areaMetric, 
      DtPtrConstAreaContainer& networkElementList) const;
   virtual void collectAllAreas(DtNetworkAreaMetric& areaMetric, 
      DtPtrAreaContainer& networkElementList);

   // find the best area in the network as measured by the metrics
   virtual const DtNetworkNode* findBestArea(DtNetworkAreaMetric& areaMetric) const;
   
   // collect all features in the range and returns a list ordered by relevance / distance,
   // where relevance is defined by its location against other features in the same location 
   // and return true if it found something.
   // example: a bridge is more relevant than a river under it.
   // User is responsible for deleting each entry in the list
   virtual bool intersectVectors(const DtPoint& p, 
                                 DtList& list, 
                                 const DtVectorNetworkRecord& record);
   
   // find the best feature in the range and return true if it found something.
   // example: a bridge is more relevant than a river under it.
   virtual bool intersectVectors(const DtPoint& p, 
                                 DtVectorNetworkIntersectionRecord& intersectionRecord, 
                                 const DtVectorNetworkRecord& record);

   // collect all features in the range of the segment defined by p1 and p2
   // and returns a list ordered by distance,
   // and return true if it found something.
   // User is responsible for deleting each entry in the list
   virtual bool intersectVectors(const DtPoint& p1, 
                                 const DtPoint& p2, 
                                 DtList& list, 
                                 const DtVectorNetworkRecord& record,
                                 const DtTerrainDatabase& terrainDatabase);

   // collect all features in the range of the segment defined by p1 and p2
   // and returns a vectorNetworkIntersectionRecordList ordered by distance,
   // and return true if it found something.
   // User is responsible for allocating and deallocating the 
   // vectorNetworkIntersectionRecordList
   virtual bool intersectVectors(const DtPoint& p1, 
                                 const DtPoint& p2, 
                                 DtVectorNetworkIntersectionRecordList& vectorNetworkIntersectionRecordList, 
                                 const DtVectorNetworkRecord& record,
                                 const DtTerrainDatabase& terrainDatabase);

   // find if there is any feature in the range and return true if it found something.
   virtual bool intersectVectors(const DtPoint& p1, 
                                 const DtPoint& p2,
                                 DtVectorNetworkIntersectionRecord& intersectionRecord,
                                 const DtVectorNetworkRecord& record,
                                 const DtTerrainDatabase& terrainDatabase);

   // debugging aid
   virtual void dump(int indent_level) const;

   // debugging aid... dumps the vector network structure into a GraphViz
   // format file
   virtual void dump(const char* filename, DtString indent="") const;

   // Return the minimum terrain file version number that this Node can be
   // saved in.
   virtual DtTerrainFileVersionNumber minSaveVersion() const;

   // calculate and set the extent of the network
   virtual void calcExtent(); 

   // Merges this vector network with the specified vector network.
   // Adjusts such things as specification IDs as appropriate.
   // Returns true if the merge was successful.
   virtual bool merge(const DtVectorNetwork& networkToMerge, bool connectEdges = true);


   virtual void connectEdges(unsigned int startingNodeIndex,
                             unsigned int startingEdgeIndex);

   // Calls above connectEdges function with 0 for starting indices in order 
   // to process all nodes and edges
   virtual void connectEdges();

   // Copies the nodes in the input network into the network.
   // The specification ID Map specifies the offsets for each 
   // original specification ID to its copy in this network's
   // specification manager.  
   // 
   // Returns true if the copying was successful.
   // Returns false otherwise.
   virtual bool copyNodes(const DtVectorNetwork& inputNetwork, 
                          DtSpecificationID* specificationIDMap);
   
   // Same as the above function ,but assumes that the specification 
   // IDs of the copied nodes are the same as the input nodes.
   // NOTE:  only useful for copying nodes into an empty network
   virtual bool copyNodes(const DtVectorNetwork& inputNetwork);

   virtual bool copyEdges(const DtVectorNetwork& inputNetwork, 
                          DtSpecificationID* specificationIDMap);

   // this method joints all edges beyond iiStart to the node if 
   // appropriate (called from connectWithNodes).  Looks for edges that could
   // be connected and connects them.  Very expensive (n-cubed for number
   // of edges in db).
   virtual void joinEdges(unsigned int nodeIndex,
                          unsigned int startingEdgeIndex);
   virtual void joinEdges(DtNetworkNode& node,
                          unsigned int startingEdgeIndex);

   // Returns true if the network contains no data
   // (i.e. no nodes or edges, the specification manager is empty
   // etc. )
   virtual bool isEmpty() const;

   // check validity of the network
   virtual bool validity(bool removeInvalidSegments = false, bool* segmentsRemoved = 0);

   virtual int sizeInBytes() const;

   // These check if the specification id exists, if not add to specMgr
   virtual DtSpecificationID riverSpecificationId();
   virtual DtSpecificationID interchangeSpecificationId();
   virtual DtSpecificationID bridgeSpecificationId();

   virtual Coordinate_System* coordinateSystem();
   virtual Coordinate_System* coordinateSystem() const;
   virtual void setCoordinateSystem(Coordinate_System* cs);

   virtual void transformTo(Coordinate_System* newCoordSys, const DtVector* offset=0);

protected:

   // Removes the specified point feature from the vector network.
   // \return A boolean indicating success or failure 
   virtual bool removePointFeature(DtNetworkElement* pointFeatureToRemove);
   virtual bool removeLinearFeature(DtNetworkElement* linearFeatureToRemove);
   virtual bool removeArealFeature(DtNetworkElement* arealFeatureToRemove);

   virtual bool removeNode(DtNetworkNode* nodeToRemove);
   virtual bool removeEdge(DtNetworkEdge* edgeToRemove);

   virtual bool testInvariant() const;


   virtual bool intersectInfoList(const DtPoint& p, 
                                  std::list<DtNetworkElement*>& list, 
                                  const DtVectorNetworkRecord& record);

   virtual bool intersectInfo(const DtPoint& p, 
                              const DtNetworkSpecificationElement*& element, 
                              const DtVectorNetworkRecord& record);

   virtual const DtNetworkNode* betterFeature(const DtNetworkNode* node1, 
                                              const DtNetworkNode* node2) const;

   // Dumps the specification manager's structure into a GraphViz format file
   virtual void dumpSpecs(FILE* fp, DtString indent="") const;

   // Dumps the node structure into a GraphViz format file
   virtual void dumpNodes(FILE* fp, DtString indent="") const;

   // Dumps the edge structure into a GraphViz format file
   virtual void dumpEdges(FILE* fp, DtString indent="") const;

protected:

   // These specifications are used in planarization. 
   DtSpecificationID myRiverIntersectionSpecId;
   DtSpecificationID myInterchangeSpecId;
   DtSpecificationID myBridgeSpecId;

   bool myHaveRiverSpecId;
   bool myHaveInterchangeSpecId;
   bool myHaveBridgeSpecId;

   unsigned int            myMaxNumNodes;
   unsigned int            myMaxNumEdges;

   DtNodeContainer         myNodes;
   DtEdgeContainer         myEdges;

   DtPointQuadtreeNode     myPointQuadtree;
   DtSegmentMxCifTree      mySegmentMxCifTree;
   
   DtExtent                myExtent;
   
   DtSpecificationManager  mySpecificationManager;
   Coordinate_System*      myCoordinateSystem;
};

#endif