xyNetworkSegmentMetric.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2001 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: xyNetSegMet.h,v $ $Revision: 1.10 $ $State: Exp $
*********************************************************************/

#ifndef xyNetworkSegmentMetric_H_
#define xyNetworkSegmentMetric_H_

#include "gdb/gdbDefines.h"
#include <vlutil/vlNetTypes.h>
#include "gdb/networkSegmentMetric.h"

class DtNetworkSegment;
class DtSpecificationAttribute;

// class DtXyNetworkSegmentMetric:
//
// DtXyNetworkSegmentMetric is a metric for segments in an mx-cif
// quadtree.  The metric is based on proximity to a line segment in 
// projection onto an x-y plane. 

class DT_DLL_gdb DtXyNetworkSegmentMetric : public DtNetworkSegmentMetric
{
public:

   // default constructor 
   DtXyNetworkSegmentMetric();

   // destructor
   virtual ~DtXyNetworkSegmentMetric();

   // copy constructor 
   DtXyNetworkSegmentMetric(const DtXyNetworkSegmentMetric& orig);

   // assignment operator 
   DtXyNetworkSegmentMetric& operator=(const DtXyNetworkSegmentMetric& orig);

public:

   // measure the network segment
   virtual double measure(const DtNetworkSegment& seg) const;

   // measure the distance from the test segment
   virtual double measureDistanceSquaredFromSegment(
      const DtNetworkSegment& seg) const;

   // measure the distance along the test segment to the closest point
   virtual double measureDistanceSquaredAlongSegment(
      const DtNetworkSegment& seg) const;

   // validate the network segment
   virtual bool valid(const DtNetworkSegment& seg) const;

   // validate the southwest quadrant (closed on southwest side)
   virtual bool validSW(double xx, double yy) const;

   // validate the southeast quadrant (closed on southwest side)
   virtual bool validSE(double xx, double yy) const;

   // validate the northeast quadrant (closed on southwest side)
   virtual bool validNE(double xx, double yy) const;

   // validate the northwest quadrant (closed on southwest side)
   virtual bool validNW(double xx, double yy) const;

   // set conditional segment element by element
   virtual void setX0Y0X1Y1(double x0, double y0, double x1, double y1);

   // get/set range.  If this equals zero, validity checks intersection.  
   // Range should be nonnegative.  If maxRange < 0, the range is set to zero.
   virtual double maxRange() const;
   virtual void setMaxRange(double maxRange);

   // get/set flag indicating that the metric measures distance from
   // the segment.  The alternative is to measure distance along the
   // segment.
   virtual bool measuresDistanceFromSegment() const;
   virtual void setMeasuresDistanceFromSegment(bool flag);


   // Calculates the distance from the conditional segment to the specified 
   // network segment.  This method also caclculates the closest point along 
   // the conditional segment and the closest point on the network segment.
   virtual double distance(const DtNetworkSegment& seg, 
                           double& condX, 
                           double& condY, 
                           double& netX, 
                           double& netY);
   // Same as above, but only calculates the distance between the segments.
   virtual double distance(const DtNetworkSegment& seg);

protected:

   // quick check using the bounding rectangles for both the network
   // segment and the conditional segment.  Returns false if the two
   // segments definitely do not intersect.  true is inconclusive.
   virtual bool boundingRectangleTest(const DtNetworkSegment& seg) const;

   // Calculate if the projections onto the x-y plane of the network segment 
   // and the conditional segment intersect.  distanceSquared is the distance 
   // squared between the closest pair of points on the conditional and 
   // network segments.  
   // condX and condY hold the closest conditional-segment points, and netX 
   // and netY hold the closest point on the network segment.
   virtual bool xyIntersects(const DtNetworkSegment& seg,
                             double& distanceSquared,
                             double& condX, 
                             double& condY,
                             double& netX, 
                             double& netY) const;
   // Same as above, but only calculates if an intersection occurs
   virtual bool xyIntersects(const DtNetworkSegment& seg) const;


protected:

   double             myMaxRange;
   double             myX0;
   double             myY0;
   double             myX1;
   double             myY1;
   double             myMinX;
   double             myMinY;
   double             myMaxX;
   double             myMaxY;
   double             myDeltaX;
   double             myDeltaY;
   bool               myPositiveFiniteSlope;
   bool               myMeasuresDistanceFromSegment;
};

#endif