Exemplo n.º 1
0
 /// <summary>
 /// For each edge in stack
 /// (which must originate at a node)
 /// extracts the line it initiates.
 /// </summary>
 private void BuildLines()
 {
     while (_nodeEdgeStack.Count > 0)
     {
         HalfEdge e = _nodeEdgeStack.Pop();
         if (MarkHalfEdge.IsMarked(e))
         {
             continue;
         }
         BuildLine(e);
     }
 }
Exemplo n.º 2
0
        /// <summary>
        /// Adds edges around this node to the stack.
        /// </summary>
        /// <param name="node"></param>
        private void StackEdges(HalfEdge node)
        {
            HalfEdge e = node;

            do
            {
                if (!MarkHalfEdge.IsMarked(e))
                {
                    _nodeEdgeStack.Push(e);
                }
                e = e.ONext;
            } while (e != node);
        }
Exemplo n.º 3
0
        private void ComputeResult()
        {
            IEnumerable <HalfEdge> edges = _graph.GetVertexEdges();

            foreach (HalfEdge e in edges)
            {
                if (MarkHalfEdge.IsMarked(e))
                {
                    continue;
                }
                Process(e);
            }
            _result = _factory.BuildGeometry(_lines);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Builds a line starting from the given edge.
        /// The start edge origin is a node (valence = 1 or >= 3),
        /// unless it is part of a pure ring.
        /// </summary>
        /// <remarks>
        /// A pure ring has no other incident lines.
        /// In this case the start edge may occur anywhere on the ring.
        /// </remarks>
        /// <remarks>
        /// The line is built up to the next node encountered,
        /// or until the start edge is re-encountered
        /// (which happens if the edges form a ring).
        /// </remarks>
        /// <param name="eStart"></param>
        private void BuildLine(HalfEdge eStart)
        {
            CoordinateList   line = new CoordinateList();
            DissolveHalfEdge e    = (DissolveHalfEdge)eStart;

            _ringStartEdge = null;

            MarkHalfEdge.MarkBoth(e);
            Coordinate orig = e.Orig;

            line.Add(orig.Clone(), false);
            // scan along the path until a node is found (if one exists)
            while (e.Sym.Degree() == 2)
            {
                UpdateRingStartEdge(e);
                DissolveHalfEdge eNext = (DissolveHalfEdge)e.Next;
                // check if edges form a ring - if so, we're done
                if (eNext == eStart)
                {
                    BuildRing(_ringStartEdge);
                    return;
                }
                // add point to line, and move to next edge
                orig = eNext.Orig;
                line.Add(orig.Clone(), false);
                e = eNext;
                MarkHalfEdge.MarkBoth(e);
            }
            // add final node
            Coordinate dest = e.Dest;

            line.Add(dest.Clone(), false);

            // queue up the final node edges
            StackEdges(e.Sym);
            // store the scanned line
            AddLine(line);
        }