示例#1
0
 public abstract void  SetEdgeRing(DirectedEdge de, EdgeRing er);
示例#2
0
 public abstract DirectedEdge GetNext(DirectedEdge de);
示例#3
0
        /// <summary>
        /// Traverse the star of DirectedEdges, linking the included edges together.
        /// </summary>
        /// <remarks>
        /// <para>
        /// To link two DirectedEdges, the "next" pointer for an incoming DirectedEdge
        /// is set to the next outgoing edge.
        /// </para>
        /// DirectedEdges are only linked if:
        /// <list type="number">
        /// <item>
        /// <description>
        /// they belong to an area (i.e. they have sides)
        /// </description>
        /// </item>
        /// <item>
        /// <description>
        /// they are marked as being in the result
        /// </description>
        /// </item>
        /// </list>
        /// <para>
        /// Edges are linked in CCW order (the order they are stored).
        /// This means that rings have their face on the Right
        /// (in other words, the topological location of the face is given by
        /// the right hand side label of the DirectedEdge)
        /// </para>
        /// PRECONDITION: No pair of DirectedEdges are both marked as being in the result.
        /// </remarks>
        public void LinkResultDirectedEdges()
        {
            // make sure edges are copied to resultAreaEdges list
            IList generatedAux = this.GetResultAreaEdges();

            if (generatedAux == null)
            {
                return;
            }

            // find first area edge (if any) to start linking at
            DirectedEdge firstOut = null;
            DirectedEdge incoming = null;
            int          state    = SCANNING_FOR_INCOMING;

            // link edges in CCW order
            for (int i = 0; i < resultAreaEdgeList.Count; i++)
            {
                DirectedEdge nextOut = (DirectedEdge)resultAreaEdgeList[i];
                DirectedEdge nextIn  = nextOut.Sym;

                // skip de's that we're not interested in
                if (!nextOut.Label.IsArea())
                {
                    continue;
                }

                // record first outgoing edge, in order to link the last incoming edge
                if (firstOut == null && nextOut.InResult)
                {
                    firstOut = nextOut;
                }

                switch (state)
                {
                case SCANNING_FOR_INCOMING:
                    if (!nextIn.InResult)
                    {
                        continue;
                    }
                    incoming = nextIn;
                    state    = LINKING_TO_OUTGOING;
                    break;

                case LINKING_TO_OUTGOING:
                    if (!nextOut.InResult)
                    {
                        continue;
                    }
                    incoming.Next = nextOut;
                    state         = SCANNING_FOR_INCOMING;
                    break;
                }
            }

            if (state == LINKING_TO_OUTGOING)
            {
                if (firstOut == null)
                {
                    throw new GeometryException("no outgoing dirEdge found", Coordinate);
                }

                Debug.Assert(firstOut.InResult, "unable to link last incoming dirEdge");
                incoming.Next = firstOut;
            }
        }
示例#4
0
        /// <summary>
        /// Traverse the star of edges, maintaing the current location in the result
        /// area at this node (if any).
        /// If any L edges are found in the interior of the result, mark them as covered.
        /// </summary>
        public void FindCoveredLineEdges()
        {
            // Since edges are stored in CCW order around the node,
            // as we move around the ring we move from the right to the left side of the edge

            // Find first DirectedEdge of result area (if any).
            // The interior of the result is on the RHS of the edge,
            // so the start location will be:
            // - INTERIOR if the edge is outgoing
            // - EXTERIOR if the edge is incoming
            int startLoc = LocationType.None;

            for (IEnumerator it = Iterator(); it.MoveNext();)
            {
                DirectedEdge nextOut = (DirectedEdge)it.Current;
                DirectedEdge nextIn  = nextOut.Sym;
                if (!nextOut.LineEdge)
                {
                    if (nextOut.InResult)
                    {
                        startLoc = LocationType.Interior;
                        break;
                    }
                    if (nextIn.InResult)
                    {
                        startLoc = LocationType.Exterior;
                        break;
                    }
                }
            }

            // no A edges found, so can't determine if L edges are covered or not
            if (startLoc == LocationType.None)
            {
                return;
            }

            // move around ring, keeping track of the current location
            // (Interior or Exterior) for the result area.
            // If L edges are found, mark them as covered if they are in the interior
            int currLoc = startLoc;

            for (IEnumerator it = Iterator(); it.MoveNext();)
            {
                DirectedEdge nextOut = (DirectedEdge)it.Current;
                DirectedEdge nextIn  = nextOut.Sym;
                if (nextOut.LineEdge)
                {
                    nextOut.Edge.Covered = currLoc == LocationType.Interior;
                }
                else
                {
                    // edge is an Area edge
                    if (nextOut.InResult)
                    {
                        currLoc = LocationType.Exterior;
                    }
                    if (nextIn.InResult)
                    {
                        currLoc = LocationType.Interior;
                    }
                }
            }
        }
示例#5
0
        /// <summary> Insert a directed edge in the list</summary>
        public override void Insert(EdgeEnd ee)
        {
            DirectedEdge de = (DirectedEdge)ee;

            InsertEdgeEnd(de, de);
        }