/// <summary>
/// Compute the change in depth as an edge is crossed from R to L
/// </summary>
/// <param name="label"></param>
/// <returns></returns>
private static int DepthDelta(Label label)
{
int lLoc = label.GetLocation(0, Position.Left);
int rLoc = label.GetLocation(0, Position.Right);
if (lLoc == Location.Interior && rLoc == Location.Exterior)
return 1;
else if (lLoc == Location.Exterior && rLoc == Location.Interior)
return -1;
return 0;
}
/// <summary>
/// Updates an IM from the label for an edge. Handles edges from both L and A geometrys.
/// </summary>
/// <param name="label"></param>
/// <param name="im"></param>
public static void UpdateIM(Label label, IntersectionMatrix im)
{
im.SetAtLeastIfValid( label.GetLocation( 0, Position.On ), label.GetLocation( 1, Position.On ), 1);
if ( label.IsArea() )
{
im.SetAtLeastIfValid( label.GetLocation( 0, Position.Left ), label.GetLocation( 1, Position.Left ), 2);
im.SetAtLeastIfValid( label.GetLocation( 0, Position.Right ), label.GetLocation( 1, Position.Right ), 2);
}
}
/// <summary>
///
/// </summary>
/// <param name="lbl"></param>
public void Add(Label lbl)
{
for (int i = 0; i < 2; i++)
{
for (int j = 1; j < 3; j++)
{
int loc = lbl.GetLocation( i, j );
if ( loc == Location.Exterior || loc == Location.Interior )
{
// initialize depth if it is null, otherwise add this location value
if (IsNull(i, j))
{
_depth[i,j] = DepthAtLocation(loc);
}
else
_depth[i,j] += DepthAtLocation(loc);
}
}
} // for (int i = 0; i < 2; i++)
}
/// <summary>
/// To merge labels for two nodes, the merged location for each LabelElement is computed.
/// The location for the corresponding node LabelElement is set to the result, as long as the location is non-null.
/// </summary>
/// <param name="label2"></param>
public void MergeLabel( Label label2 )
{
for (int i = 0; i < 2; i++)
{
int loc = ComputeMergedLocation(label2, i);
int thisLoc = _label.GetLocation(i);
if ( thisLoc == Location.Null )
{
_label.SetLocation( i, loc );
}
} // for (int i = 0; i < 2; i++)
}
protected void MergeLabel( Label deLabel )
{
MergeLabel( deLabel, 0 );
MergeLabel( deLabel, 1 );
}
/**
* Inserted edges are checked identical edge already exists.
* If so, the edge is not inserted, but its label is merged
* with the existing edge.
*/
protected void InsertEdge(Edge e)
{
//Debug.println(e);
int foundIndex = _edgeList.FindEdgeIndex(e);
// If an identical edge already exists, simply update its label
if (foundIndex >= 0)
{
Edge existingEdge = (Edge) _edgeList[foundIndex];
Label existingLabel = existingEdge.Label;
Label labelToMerge = e.Label;
// check if new edge is in reverse direction to existing edge
// if so, must flip the label before merging it
if (! existingEdge.IsPointwiseEqual(e))
{
labelToMerge = new Label(e.Label);
labelToMerge.Flip();
}
existingLabel.Merge(labelToMerge);
// compute new depth delta of sum of edges
int mergeDelta = DepthDelta(labelToMerge);
int existingDelta = existingEdge.DepthDelta;
int newDelta = existingDelta + mergeDelta;
existingEdge.DepthDelta=newDelta;
CheckDimensionalCollapse(labelToMerge, existingLabel);
//Debug.print("new edge "); Debug.println(e);
//Debug.print("existing "); Debug.println(existingEdge);
}
else
{ // no matching existing edge was found
// add this new edge to the list of edges in this graph
//e.setName(name + edges.size());
_edgeList.Add(e);
e.DepthDelta=DepthDelta(e.Label);
}
}
/// <summary>
/// Converts a Label to a Line label (that is, one with no side Locations)
/// </summary>
/// <param name="label"></param>
/// <returns></returns>
public static Label ToLineLabel(Label label)
{
Label lineLabel = new Label( Location.Null );
for (int i = 0; i < 2; i++)
{
lineLabel.SetLocation( i, label.GetLocation(i) );
}
return lineLabel;
}
} // private void InsertUniqueEdges( ArrayList edges )
/// <summary>
/// Insert an edge from one of the noded input graphs.
/// Checks edges that are inserted to see if an
/// identical edge already exists.
/// If so, the edge is not inserted, but its label is merged
/// with the existing edge.
/// </summary>
/// <param name="e"></param>
protected void InsertUniqueEdge( Edge e )
{
// Trace.WriteLine( e.ToString() );
int foundIndex = _edgeList.FindEdgeIndex( e );
// If an identical edge already exists, simply update its label
if ( foundIndex >= 0 )
{
Edge existingEdge = (Edge) _edgeList[foundIndex];
Label existingLabel = existingEdge.Label;
Label labelToMerge = e.Label;
// check if new edge is in reverse direction to existing edge
// if so, must flip the label before merging it
if ( !existingEdge.IsPointwiseEqual( e ) )
{
labelToMerge = new Label( e.Label );
labelToMerge.Flip();
}
Depth depth = existingEdge.Depth;
// if this is the first duplicate found for this edge, initialize the depths
//
if ( depth.IsNull() )
{
depth.Add( existingLabel );
}
//
depth.Add( labelToMerge );
existingLabel.Merge( labelToMerge );
//Trace.WriteLine("inserted edge: ");
//Trace.WriteLine( e.ToString() );
//Trace.WriteLine("existing edge: ");
//Trace.WriteLine( existingEdge.ToString() );
} // if ( foundIndex >= 0 )
else
{
// no matching existing edge was found
// add this new edge to the list of edges in this graph
//e.setName(name + edges.size());
//e.getDepth().add(e.getLabel());
_edgeList.Add( e );
} // else
} // protected void InsertUniqueEdge( Edge e )
public EdgeEnd(Edge edge, Coordinate p0, Coordinate p1, Label label)
: this(edge)
{
Initialize(p0, p1);
_label = label;
}
/// <summary>
/// Construct a Label with the same values as the argument Label.
/// </summary>
/// <param name="lbl"></param>
public Label( Label lbl )
{
_elt[0] = new TopologyLocation(lbl.LabelElements[0]);
_elt[1] = new TopologyLocation(lbl.LabelElements[1]);
}
/// <summary>
/// Initializes a new instance of the Node class.
/// </summary>
public Node(Coordinate coord, EdgeEndStar edges)
{
_coord = coord;
_edges = edges;
_label = new Label( 0, Location.Null );
}
/// <summary>
/// The location for a given eltIndex for a node will be one
/// of { null, INTERIOR, BOUNDARY }.
/// A node may be on both the boundary and the interior of a geometry;
/// in this case, the rule is that the node is considered to be in the boundary.
/// The merged location is the maximum of the two input values.
/// </summary>
/// <param name="label2"></param>
/// <param name="eltIndex"></param>
/// <returns></returns>
int ComputeMergedLocation(Label label2, int eltIndex)
{
int loc = Location.Null;
loc = _label.GetLocation( eltIndex );
if ( !label2.IsNull( eltIndex ) )
{
int nLoc = label2.GetLocation( eltIndex );
if (loc != Location.Boundary)
{
loc = nLoc;
}
}
return loc;
}
/// <summary>
///
/// </summary>
/// <param name="argIndex"></param>
/// <param name="onLocation"></param>
public void SetLabel( int argIndex, int onLocation )
{
if ( _label == null )
{
_label = new Label( argIndex, onLocation );
}
else
{
_label.SetLocation( argIndex, onLocation );
}
}
/// <summary>
/// Constructs a new edge using the coordinates collection and supplied label object.
/// </summary>
/// <param name="pts"></param>
/// <param name="label"></param>
public Edge(Coordinates pts, Label label)
{
_eiList = new EdgeIntersectionList( this );
_pts = pts;
_label = label; // inherited member variable.
}
/// <summary>
///
/// </summary>
/// <param name="lbl"></param>
/// <param name="side"></param>
/// <returns></returns>
public bool IsEqualOnSide(Label lbl, int side)
{
return _elt[0].IsEqualOnSide( lbl.LabelElements[0], side )
&& _elt[1].IsEqualOnSide( lbl.LabelElements[1], side );
}
} // public void Insert( EdgeEnd e )
/// <summary>
/// This computes the overall edge label for the set of edges in this EdgeStubBundle.
/// It essentially merges the ON and side labels for each edge. These labels must be compatible.
/// </summary>
public override void ComputeLabel()
{
// create the label. If any of the edges belong to areas,
// the label must be an area label
bool isArea = false;
foreach ( object obj in _edgeEnds )
{
EdgeEnd e = (EdgeEnd)obj;
if ( e.Label.IsArea() )
{
isArea = true;
}
}
if ( isArea )
{
_label = new Label( Location.Null, Location.Null, Location.Null );
}
else
{
_label = new Label( Location.Null );
}
// compute the On label, and the side labels if present
for ( int i = 0; i < 2; i++ )
{
ComputeLabelOn( i );
if ( isArea )
{
ComputeLabelSides(i);
}
} // for ( int i = 0; i < 2; i++ )
} // public override void ComputeLabel()
/// <summary>
/// Merge this label with another one. Merging updates any null attributes of this label
/// with the attributes from label.
/// </summary>
/// <param name="lbl"></param>
public void Merge( Label lbl )
{
for (int i = 0; i < 2; i++)
{
if (_elt[i] == null && lbl.LabelElements[i] != null)
{
_elt[i] = new TopologyLocation( lbl.LabelElements[i] );
}
else
{
_elt[i].Merge( lbl.LabelElements[i] );
}
}
}
} // public static Geometry Overlay( Geometry geom0, Geometry geom1, int opCode )
/// <summary>
///
/// </summary>
/// <param name="label"></param>
/// <param name="opCode"></param>
/// <returns></returns>
public static bool IsResultOfOp( Label label, int opCode )
{
int loc0 = label.GetLocation( 0 );
int loc1 = label.GetLocation( 1 );
return IsResultOfOp( loc0, loc1, opCode );
} // public static bool IsResultOfOp( Label label, int opCode )
/// <summary>
/// Update incomplete dirEdge labels from the labelling for the node.
/// </summary>
/// <param name="nodeLabel"></param>
public void UpdateLabelling(Label nodeLabel)
{
foreach ( DirectedEdge de in Edges() )
{
Label label = de.Label;
label.SetAllLocationsIfNull( 0, nodeLabel.GetLocation( 0 ) );
label.SetAllLocationsIfNull( 1, nodeLabel.GetLocation( 1 ) );
}
}
/// <summary>
/// Merge the RHS label from a DirectedEdge into the label for this EdgeRing.
/// from a node which is NOT an intersection node between the Geometries
/// (e.g. the end node of a LinearRing). In this case the DirectedEdge label
/// does not contribute any information to the overall labelling, and is simply skipped.
/// </summary>
/// <param name="deLabel"></param>
/// <param name="geomIndex"></param>
protected void MergeLabel( Label deLabel, int geomIndex )
{
int loc = deLabel.GetLocation( geomIndex, Position.Right ); // get the location for this label.
// no information to be had from this label
if ( loc == Location.Null ) return;
// if there is no current RHS value, set it
if ( _label.GetLocation( geomIndex ) == Location.Null )
{
_label.SetLocation( geomIndex, loc );
return;
}
}
/// <summary>
/// Compute the labelling for all dirEdges in this star, as well
/// as the overall labelling
/// </summary>
/// <param name="geom"></param>
public override void ComputeLabelling(GeometryGraph[] geom)
{
//Trace.WriteLine( ToString() );
base.ComputeLabelling( geom );
// determine the overall labelling for this DirectedEdgeStar
// (i.e. for the node it is based at)
_label = new Label( Location.Null );
foreach ( object obj in Edges() )
{
EdgeEnd ee = (EdgeEnd)obj;
Edge e = ee.Edge;
Label eLabel = e.Label;
for (int i = 0; i < 2; i++)
{
int eLoc = eLabel.GetLocation(i);
if ( eLoc == Location.Interior || eLoc == Location.Boundary )
{
_label.SetLocation( i, Location.Interior );
}
}
} // foreach ( object obj in edges )
//Trace.WriteLine( ToString() );
}
/**
* If either of the GeometryLocations for the existing label is
* exactly opposite to the one in the labelToMerge,
* this indicates a dimensional collapse has happened.
* In this case, convert the label for that Geometry to a Line label
*/
private void CheckDimensionalCollapse(Label labelToMerge, Label existingLabel)
{
if (existingLabel.IsArea() && labelToMerge.IsArea())
{
for (int i = 0; i < 2; i++)
{
if (! labelToMerge.IsNull(i)
&& labelToMerge.GetLocation(i, Position.Left) == existingLabel.GetLocation(i, Position.Right)
&& labelToMerge.GetLocation(i, Position.Right) == existingLabel.GetLocation(i, Position.Left) )
{
existingLabel.ToLine(i);
}
}
}
}
/// <summary>
/// Compute the label in the appropriate orientation for this DirEdge.
/// </summary>
private void ComputeDirectedLabel()
{
_label = new Label( _edge.Label );
if (!IsForward )
{
_label.Flip();
}
}
public GraphComponent(Label label)
{
_label = label;
}
} // public void ComputeEdgeEnds( Edge edge, ArrayList l )
/// <summary>
/// Create a EdgeStub for the edge before the intersection eiCurr.
/// The previous intersection is provided
/// in case it is the endpoint for the stub edge.
/// Otherwise, the previous point from the parent edge will be the endpoint.
/// eiCurr will always be an EdgeIntersection, but eiPrev may be null.
/// </summary>
/// <param name="edge"></param>
/// <param name="list"></param>
/// <param name="eiCurr"></param>
/// <param name="eiPrev"></param>
void CreateEdgeEndForPrev(
Edge edge,
ArrayList list,
EdgeIntersection eiCurr,
EdgeIntersection eiPrev)
{
int iPrev = eiCurr.SegmentIndex;
if ( eiCurr.Distance == 0.0 )
{
// if at the start of the edge there is no previous edge
if ( iPrev == 0 ) return;
iPrev--;
}
Coordinate pPrev = edge.GetCoordinate( iPrev );
// if prev intersection is past the previous vertex, use it instead
if ( eiPrev != null && eiPrev.SegmentIndex >= iPrev )
{
pPrev = eiPrev.Coordinate;
}
Label label = new Label( edge.Label );
// since edgeStub is oriented opposite to it's parent edge, have to flip sides for edge label
label.Flip();
EdgeEnd e = new EdgeEnd( edge, eiCurr.Coordinate, pPrev, label );
//Trace.WriteLine( e.ToString() );
list.Add( e );
} //void CreateEdgeEndForPrev(...
