/// <summary>
/// Insert nodes for all intersections on the edges of a Geometry.
/// Label the created nodes the same as the edge label if they do not already
/// have a label.
/// This allows nodes created by either self-intersections or
/// mutual intersections to be labelled.
/// Endpoint nodes will already be labelled from when they were inserted.
/// <para>
/// Precondition: edge intersections have been computed.
/// </para>
/// </summary>
public void ComputeIntersectionNodes(GeometryGraph geomGraph, int argIndex)
{
for (IEdgeEnumerator edgeIt = geomGraph.EdgeIterator; edgeIt.MoveNext();)
{
Edge e = edgeIt.Current;
int eLoc = e.Label.GetLocation(argIndex);
for (IEnumerator eiIt = e.EdgeIntersectionList.Iterator(); eiIt.MoveNext();)
{
EdgeIntersection ei = (EdgeIntersection)eiIt.Current;
RelateNode n = (RelateNode)nodes.AddNode(ei.coord);
if (eLoc == LocationType.Boundary)
{
n.SetLabelBoundary(argIndex);
}
else
{
if (n.Label.IsNull(argIndex))
{
n.SetLabel(argIndex, LocationType.Interior);
}
}
}
}
}
/// <summary>
/// Construct an enumerator over the out-edges
/// </summary>
/// <param name="vertexOutEdges">Out edge dictionary to iterate</param>
/// <exception cref="ArgumentNullException">vertexOutEdges is null</exception>
public VertexEdgesEnumerator(VertexEdgesDictionary vertexOutEdges)
{
if (vertexOutEdges == null)
throw new ArgumentNullException("vertexOutEdges");
VertexOutEdgeEnumerator = vertexOutEdges.GetEnumerator();
OutEdgeEnumerator = null;
}
/// <summary>
/// Test that no edge intersection is the endpoint of a closed line.
/// To check this we compute the degree of each endpoint.
/// The degree of endpoints of closed lines must be exactly 2.
/// </summary>
private bool HasClosedEndpointIntersection(GeometryGraph graph)
{
IDictionary endPoints = new SortedList();
for (IEdgeEnumerator i = graph.EdgeIterator; i.MoveNext();)
{
Edge e = i.Current;
// int maxSegmentIndex = e.MaximumSegmentIndex;
bool isClosed = e.IsClosed;
Coordinate p0 = e.GetCoordinate(0);
AddEndpoint(endPoints, p0, isClosed);
Coordinate p1 = e.GetCoordinate(e.NumPoints - 1);
AddEndpoint(endPoints, p1, isClosed);
}
for (IEnumerator i = endPoints.Values.GetEnumerator(); i.MoveNext();)
{
EndpointInfo eiInfo = (EndpointInfo)i.Current;
if (eiInfo.isClosed && eiInfo.degree != 2)
{
return(true);
}
}
return(false);
}
public void AddAll(EdgeCollection edgeColl)
{
for (IEdgeEnumerator i = edgeColl.GetEnumerator(); i.MoveNext();)
{
Add(i.Current);
}
}
public void ComputeSplitEdges(EdgeCollection edgelist)
{
for (IEdgeEnumerator i = edges.GetEnumerator(); i.MoveNext();)
{
Edge e = i.Current;
e.eiList.AddSplitEdges(edgelist);
}
}
public ReversedEdgeEnumerator(IEdgeEnumerator enumerator)
{
if (enumerator == null)
{
throw new ArgumentNullException("enumerator");
}
this.wrapped = enumerator;
}
private void InsertUniqueEdges(EdgeCollection edges)
{
for (IEdgeEnumerator i = edges.GetEnumerator(); i.MoveNext(); )
{
Edge e = i.Current;
InsertUniqueEdge(e);
}
}
public TargetVertexEnumerator(IEdgeEnumerable edges)
{
if (edges == null)
{
throw new ArgumentNullException("edges");
}
this.enumerator = edges.GetEnumerator();
}
private void Add(EdgeCollection edges, object edgeSet)
{
for (IEdgeEnumerator i = edges.GetEnumerator(); i.MoveNext();)
{
Edge edge = i.Current;
Add(edge, edgeSet);
}
}
private void Add(EdgeCollection edges)
{
for (IEdgeEnumerator i = edges.GetEnumerator(); i.MoveNext();)
{
Edge edge = i.Current;
// edge is its own group
Add(edge, edge);
}
}
/// <summary>
/// Construct an enumerator over the out-edges
/// </summary>
/// <param name="vertexOutEdges">Out edge dictionary to iterate</param>
/// <exception cref="ArgumentNullException">vertexOutEdges is null</exception>
public VertexEdgesEnumerator(VertexEdgesDictionary vertexOutEdges)
{
if (vertexOutEdges == null)
{
throw new ArgumentNullException("vertexOutEdges");
}
VertexOutEdgeEnumerator = vertexOutEdges.GetEnumerator();
OutEdgeEnumerator = null;
}
/// <summary>
/// Returns the number of in-edges (for directed graphs) or the number
/// of incident edges (for undirected graphs) of vertex v in graph g.
/// </summary>
/// <param name="v">vertex to test</param>
/// <returns>out-degree</returns>
public int InDegree(IVertex v)
{
IEdgeEnumerator en = InEdges(v).GetEnumerator();
int n = 0;
while (en.MoveNext())
{
++n;
}
return(n);
}
public ArrayList ComputeEdgeEnds(IEdgeEnumerator edges)
{
ArrayList l = new ArrayList();
for (IEdgeEnumerator i = edges; i.MoveNext();)
{
Edge e = i.Current;
ComputeEdgeEnds(e, l);
}
return(l);
}
/// <summary>
/// Check that there is no ring which self-intersects (except of course at its endpoints).
/// This is required by OGC topology rules (but not by other models
/// such as ESRI SDE, which allow inverted shells and exverted holes).
///
/// </summary>
/// <param name="graph">the topology graph of the geometry
/// </param>
private void CheckNoSelfIntersectingRings(GeometryGraph graph)
{
for (IEdgeEnumerator i = graph.EdgeIterator; i.MoveNext();)
{
Edge e = i.Current;
CheckNoSelfIntersectingRing(e.EdgeIntersectionList);
if (validErr != null)
{
return;
}
}
}
/// <summary>
/// Processes isolated edges by computing their labelling and adding them
/// to the isolated edges list.
/// Isolated edges are guaranteed not to touch the boundary of the target
/// (since if they did, they would have caused an intersection to be
/// computed and hence would not be isolated)
/// </summary>
private void LabelIsolatedEdges(int thisIndex, int targetIndex)
{
for (IEdgeEnumerator ei = arg[thisIndex].EdgeIterator; ei.MoveNext();)
{
Edge e = ei.Current;
if (e.Isolated)
{
LabelIsolatedEdge(e, targetIndex, arg[targetIndex].Geometry);
isolatedEdges.Add(e);
}
}
}
/// <summary>
/// Move the vertex iterator to the next vertex.
/// </summary>
/// <returns></returns>
public bool MoveNextVertex()
{
// check if empty vertex set
if (!VertexOutEdgeEnumerator.MoveNext())
{
OutEdgeEnumerator = null;
return(false);
}
// getting enumerator
OutEdgeEnumerator = ((EdgeCollection)((DictionaryEntry)VertexOutEdgeEnumerator.Current).Value).GetEnumerator();
return(true);
}
public override void ComputeIntersections(EdgeCollection edges0,
EdgeCollection edges1, SegmentIntersector si)
{
for (IEdgeEnumerator i0 = edges0.GetEnumerator(); i0.MoveNext();)
{
Edge edge0 = i0.Current;
for (IEdgeEnumerator i1 = edges1.GetEnumerator(); i1.MoveNext();)
{
Edge edge1 = i1.Current;
ComputeIntersects(edge0, edge1, si);
}
}
}
private void AddSelfIntersectionNodes(int argIndex)
{
for (IEdgeEnumerator i = edges.GetEnumerator(); i.MoveNext();)
{
Edge e = i.Current;
int eLoc = e.Label.GetLocation(argIndex);
for (IEnumerator eiIt = e.eiList.Iterator(); eiIt.MoveNext();)
{
EdgeIntersection ei = (EdgeIntersection)eiIt.Current;
AddSelfIntersectionNode(argIndex, ei.coord, eLoc);
}
}
}
private IEdge SelectSingleOutEdgeNotInCircuit(IVertex v)
{
IEdgeEnumerable en = this.SelectOutEdgesNotInCircuit(v);
IEdgeEnumerator eor = en.GetEnumerator();
if (!eor.MoveNext())
{
return(null);
}
else
{
return(eor.Current);
}
}
public override void ComputeIntersections(EdgeCollection edges, SegmentIntersector si, bool testAllSegments)
{
for (IEdgeEnumerator i0 = edges.GetEnumerator(); i0.MoveNext();)
{
Edge edge0 = i0.Current;
for (IEdgeEnumerator i1 = edges.GetEnumerator(); i1.MoveNext();)
{
Edge edge1 = i1.Current;
if (testAllSegments || edge0 != edge1)
{
ComputeIntersects(edge0, edge1, si);
}
}
}
}
/// <summary>
/// Update the IM with the sum of the IMs for each component.
/// </summary>
private void UpdateIM(IntersectionMatrix im)
{
for (IEdgeEnumerator ei = isolatedEdges.GetEnumerator(); ei.MoveNext();)
{
Edge e = ei.Current;
e.UpdateIM(im);
}
for (IEnumerator ni = nodes.Iterator(); ni.MoveNext();)
{
RelateNode node = (RelateNode)ni.Current;
node.UpdateIM(im);
node.updateIMFromEdges(im);
}
}
/// <summary>
/// Returns the last edge of the edge collection
/// </summary>
/// <param name="edges">edge collection</param>
/// <returns>last edge if any, otherwise a null reference</returns>
public static IEdge LastEdge(IEdgeEnumerable edges)
{
if (edges == null)
{
throw new ArgumentNullException("edges");
}
IEdgeEnumerator en = edges.GetEnumerator();
IEdge current = null;
while (en.MoveNext())
{
current = en.Current;
}
return(current);
}
/// <summary>
/// Returns the first edge of the graph
/// </summary>
/// <param name="edges">graph</param>
/// <returns>first edge if any, otherwise a null reference</returns>
public static IEdge FirstEdge(IEdgeEnumerable edges)
{
if (edges == null)
{
throw new ArgumentNullException("edges");
}
IEdgeEnumerator en = edges.GetEnumerator();
if (!en.MoveNext())
{
return(null);
}
else
{
return(en.Current);
}
}
/// <summary>
/// For all edges, check if there are any intersections which are NOT at an endpoint.
/// The Geometry is not simple if there are intersections not at endpoints.
/// </summary>
private bool HasNonEndpointIntersection(GeometryGraph graph)
{
for (IEdgeEnumerator i = graph.EdgeIterator; i.MoveNext();)
{
Edge e = i.Current;
int maxSegmentIndex = e.MaximumSegmentIndex;
for (IEnumerator eiIt = e.EdgeIntersectionList.Iterator(); eiIt.MoveNext();)
{
EdgeIntersection ei = (EdgeIntersection)eiIt.Current;
if (!ei.IsEndPoint(maxSegmentIndex))
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Add a set of edges to the graph. For each edge two DirectedEdges
/// will be created. DirectedEdges are NOT linked by this method.
/// </summary>
public void AddEdges(EdgeCollection edgesToAdd)
{
// create all the nodes for the edges
for (IEdgeEnumerator it = edgesToAdd.GetEnumerator();
it.MoveNext();)
{
Edge e = it.Current;
edges.Add(e);
DirectedEdge de1 = new DirectedEdge(e, true);
DirectedEdge de2 = new DirectedEdge(e, false);
de1.Sym = de2;
de2.Sym = de1;
Add(de1);
Add(de2);
}
}
/// <summary>
/// If edges which have undergone dimensional collapse are found,
/// replace them with a new edge which is a L edge
/// </summary>
private void ReplaceCollapsedEdges()
{
EdgeCollection replacableEdges = new EdgeCollection();
for (IEdgeEnumerator it = edgeList.Iterator(); it.MoveNext();)
{
Edge e = it.Current;
if (e.IsCollapsed)
{
replacableEdges.Add(e);
}
}
int nCount = replacableEdges.Count;
for (int i = 0; i < nCount; i++)
{
Edge e = replacableEdges[i];
edgeList.Replace(e, e.CollapsedEdge);
}
}
/// <summary>
/// Update the labels for edges according to their depths.
/// For each edge, the depths are first normalized.
/// Then, if the depths for the edge are equal,
/// this edge must have collapsed into a line edge.
/// If the depths are not equal, update the label
/// with the locations corresponding to the depths
/// (i.e. a depth of 0 corresponds to a Location of EXTERIOR,
/// a depth of 1 corresponds to INTERIOR)
/// </summary>
private void ComputeLabelsFromDepths()
{
for (IEdgeEnumerator it = edgeList.Iterator(); it.MoveNext(); )
{
Edge e = it.Current;
Label lbl = e.Label;
Depth depth = e.Depth;
// Only check edges for which there were duplicates,
// since these are the only ones which might
// be the result of dimensional collapses.
if (!depth.IsNull())
{
depth.Normalize();
for (int i = 0; i < 2; i++)
{
if (!lbl.IsNull(i) && lbl.IsArea() && !depth.IsNull(i))
{
// if the depths are equal, this edge is the result of
// the dimensional collapse of two or more edges.
// It has the same location on both sides of the edge,
// so it has collapsed to a line.
if (depth.GetDelta(i) == 0)
{
lbl.ToLine(i);
}
else
{
// This edge may be the result of a dimensional collapse,
// but it still has different locations on both sides. The
// label of the edge must be updated to reflect the resultant
// side locations indicated by the depth values.
Debug.Assert(!depth.IsNull(i, Position.Left), "depth of LEFT side has not been initialized");
lbl.SetLocation(i, Position.Left, depth.GetLocation(i, Position.Left));
Debug.Assert(!depth.IsNull(i, Position.Right), "depth of RIGHT side has not been initialized");
lbl.SetLocation(i, Position.Right, depth.GetLocation(i, Position.Right));
}
}
}
}
}
}
private ArrayList TopoSortAdjVertices(IVertex v, IIncidenceGraph g, VertexIntDictionary topo_ordering)
// return adjacent vertices to "v" sorted in topological order
{
IEdgeEnumerator it = g.OutEdges(v).GetEnumerator();
bool valid = false;
ArrayList adj = new ArrayList();
while (it.MoveNext())
{
valid = true;
adj.Add(it.Current.Target);
}
if (!valid) // no outgoing edges
{
return(adj);
}
CompareTopo ctopo = new CompareTopo(topo_ordering);
SwapTopo stopo = new SwapTopo();
QuickSorter qs = new QuickSorter(ctopo, stopo);
qs.Sort(adj);
return(adj);
}
/// <summary>
/// Sets the enumerator to its initial position,
/// which is before the first element in the collection.
/// </summary>
public void Reset()
{
VertexOutEdgeEnumerator.Reset();
OutEdgeEnumerator = null;
}
/// <summary>
/// Sets the enumerator to its initial position,
/// which is before the first element in the collection.
/// </summary>
public void Reset()
{
VertexOutEdgeEnumerator.Reset();
OutEdgeEnumerator=null;
}
/// <summary>
/// Move the vertex iterator to the next vertex.
/// </summary>
/// <returns></returns>
public bool MoveNextVertex()
{
// check if empty vertex set
if (!VertexOutEdgeEnumerator.MoveNext())
{
OutEdgeEnumerator=null;
return false;
}
// getting enumerator
OutEdgeEnumerator = ((EdgeCollection)((DictionaryEntry)VertexOutEdgeEnumerator.Current).Value).GetEnumerator();
return true;
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
/// <param name="p"></param>
public Enumerator(IEdgeEnumerator e, IEdgePredicate p)
{
m_Enumerator = e;
m_Predicate = p;
}
public ReversedEdgeEnumerator(IEdgeEnumerator enumerator)
{
if (enumerator == null)
throw new ArgumentNullException("enumerator");
this.wrapped = enumerator;
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
/// <param name="p"></param>
public Enumerator(IEdgeEnumerator e, IEdgePredicate p)
{
m_Enumerator = e;
m_Predicate = p;
}
public DataTableVertexDataRelationEdgeCollectionEdgeEnumerator(IEnumerable en)
{
Debug.Assert(en!=null);
this.edges = en.GetEnumerator();
this.edge = null;
}
public void Reset()
{
this.edges.Reset();
this.edge=null;
}
private bool moveNextVertex()
{
// check if empty vertex set
if (!this.edges.MoveNext())
{
this.edges=null;
return false;
}
// getting enumerator
this.edge = ((DataRelationEdgeCollection)this.edges.Current).GetEnumerator();
return true;
}
public TargetVertexEnumerator(IEdgeEnumerable edges)
{
if (edges==null)
throw new ArgumentNullException("edges");
this.enumerator = edges.GetEnumerator();
}
public Face()
{
m_Points = new List <Vector3>(10);
m_PointIndicies = new List <int>(10);
m_LoopEnumerator = new EdgeLoopEnumerator();
}