add GraphCells2d, which can extract the enclosed regions from a DGraph2

comp_geom/GraphCells2d.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace g3
+{
+    /// <summary>
+    /// This class extracts the set of loops bounding the "cells" of a DGraph2, ie 
+    /// each cell is a connected region with a polygonal boundary. 
+    /// Precondition: the graph has no self-intersections.
+    /// Precondition: at any vertex, the edges are sortable by angle (ie no outgoing edges overlap)
+    ///     ** numerically this may not be 100% reliable....
+    /// 
+    /// Both "sides" of each edge are included in some cell boundary, ie so for a simple
+    /// polygon, there are two cells, one infinitely large. The "inside" cells will be
+    /// oriented clockwise, if converted to a Polygon2d.
+    /// 
+    /// </summary>
+    public class GraphCells2d
+    {
+        public DGraph2 Graph;
+
+        /*
+         * Outputs
+         */
+
+        // set of boundary loops of cells
+        public List<int[]> CellLoops;
+
+
+        public GraphCells2d(DGraph2 graph)
+        {
+            Graph = graph;
+        }
+
+        public void FindCells()
+        {
+            // First we construct "wedges", which are pairs of sequential edges around each vtx.
+            // we then put all in a hash set, we will iterate until we use up all the available wedges.
+            // Edges are sorted by positive angle, so they are in clockwise order
+            // Hence, going from edge n to n+1 is a left-turn, and so "inside" cells are oriented clockwise
+            int NV = Graph.MaxVertexID;
+            Index2i[][] wedges = new Index2i[NV][];
+            HashSet<Index2i> remaining = new HashSet<Index2i>();
+            foreach (int vid in Graph.VertexIndices()) {
+                int[] sorted = Graph.SortedVtxEdges(vid);
+                wedges[vid] = new Index2i[sorted.Length];
+
+                for (int k = 0; k < sorted.Length; ++k) {
+                    wedges[vid][k] = new Index2i(sorted[k], sorted[(k + 1) % sorted.Length]);
+                    remaining.Add(new Index2i(vid, k));
+                }
+            }
+
+            CellLoops = new List<int[]>();
+
+            List<int> loopv = new List<int>();
+            while (remaining.Count > 0 ) {
+                Index2i idx = remaining.First();
+                remaining.Remove(idx);
+
+                int start_vid = idx.a;
+                int wid = idx.b;
+                int e0 = wedges[start_vid][wid].a;
+                int e1 = wedges[start_vid][wid].b;
+
+                loopv.Clear();
+                loopv.Add(start_vid);
+
+                int cur_v = start_vid;
+                int outgoing_e = e1;
+
+                // walk around loop taking immediate left-turns
+                bool done = false;
+                while (!done) {
+                    // find outgoing edge and vtx at far end
+                    Index2i ev = Graph.GetEdgeV(outgoing_e);
+                    int next_v = (ev.a == cur_v) ? ev.b : ev.a;
+
+                    if ( next_v == start_vid ) {
+                        done = true;
+                        continue;
+                    }
+
+                    // now find wedge at that vtx where this is incoming edge
+                    Index2i[] next_wedges = wedges[next_v];
+                    int use_wedge_idx = -1;
+                    for ( int k = 0; k < next_wedges.Length; ++k ) {
+                        if ( next_wedges[k].a == outgoing_e ) {
+                            use_wedge_idx = k;
+                            break;
+                        }
+                    }
+                    if (use_wedge_idx == -1)
+                        throw new Exception("could not find next wedge?");
+
+                    remaining.Remove(new Index2i(next_v, use_wedge_idx));
+                    loopv.Add(next_v);
+                    cur_v = next_v;
+                    outgoing_e = next_wedges[use_wedge_idx].b;
+                }
+
+                CellLoops.Add(loopv.ToArray());
+            }
+
+        }
+
+
+        /// <summary>
+        /// Convert cells to polygons, with optional filter. 
+        /// If filter returns false, polygon is not included in output
+        /// </summary>
+        public List<Polygon2d> CellsToPolygons(Func<Polygon2d, bool> FilterF = null)
+        {
+            List<Polygon2d> result = new List<Polygon2d>();
+
+            for ( int i = 0; i < CellLoops.Count; ++i) {
+                int[] loop = CellLoops[i];
+                Polygon2d poly = new Polygon2d();
+                for (int k = 0; k < loop.Length; ++k)
+                    poly.AppendVertex(Graph.GetVertex(loop[k]));
+
+                if (FilterF != null && FilterF(poly) == false)
+                    continue;
+
+                result.Add(poly);
+            }
+            return result;
+        }
+
+
+        /// <summary>
+        /// Find cells that are "inside" the container polygon.
+        /// Currently based on finding a point inside the cell and then
+        /// checking that it is also inside the container. 
+        /// This is perhaps not ideal!!
+        /// </summary>
+        public List<Polygon2d> ContainedCells(GeneralPolygon2d container)
+        {
+            Func<Polygon2d, bool> filterF = (poly) => {
+                bool bIsCW = poly.IsClockwise;
+                for (int k = 0; k < poly.VertexCount; k++) {
+                    Segment2d s = poly.Segment(k);
+                    Vector2d pt = s.Center + MathUtil.Epsilonf * s.Direction.Perp;
+                    if (poly.Contains(pt) == bIsCW)
+                        return container.Contains(pt);
+                }
+                // give up
+                return false;
+            };
+            return CellsToPolygons(filterF);
+        }
+
+
+    }
+}

geometry3Sharp.csproj

@@ -51,6 +51,7 @@
     <Compile Include="color\ColorHSV.cs" />
     <Compile Include="color\ColorMap.cs" />
     <Compile Include="color\ColorMixer.cs" />
+    <Compile Include="comp_geom\GraphCells2d.cs" />
     <Compile Include="comp_geom\GraphSplitter2d.cs" />
     <Compile Include="containment\ContMinBox2.cs" />
     <Compile Include="containment\ContMinCircle2.cs" />