public static DGraph2 perturb_fill(DGraph2 graphIn, GeneralPolygon2d bounds, double waveWidth, double stepSize) { DGraph2Util.Curves curves = DGraph2Util.ExtractCurves(graphIn); Polygon2d poly = curves.Loops[0]; GeneralPolygon2dBoxTree gpTree = new GeneralPolygon2dBoxTree(bounds); Polygon2dBoxTree outerTree = new Polygon2dBoxTree(bounds.Outer); Polygon2dBoxTree innerTree = new Polygon2dBoxTree(bounds.Holes[0]); DGraph2 graph = new DGraph2(); graph.EnableVertexColors(Vector3f.Zero); double len = poly.Perimeter; int waves = (int)(len / waveWidth); double lenScale = len / (MathUtil.TwoPI * waves); double accum_len = 0; int prev_vid = -1, start_vid = -1; int N = poly.VertexCount; for (int k = 0; k < N; ++k) { double t = accum_len / lenScale; t = Math.Cos(t); //Vector2d normal = poly.GetNormal(k); Vector2d normal = poly[k].Normalized; int vid = graph.AppendVertex(poly[k], new Vector3f(t, normal.x, normal.y)); if (prev_vid != -1) { graph.AppendEdge(prev_vid, vid); accum_len += graph.GetVertex(prev_vid).Distance(graph.GetVertex(vid)); } else { start_vid = vid; } prev_vid = vid; } graph.AppendEdge(prev_vid, start_vid); Vector2d[] newPos = new Vector2d[graph.MaxVertexID]; for (int k = 0; k < 10; ++k) { smooth_pass(graph, 0.5f, newPos); } for (int k = 0; k < 20; ++k) { foreach (int vid in graph.VertexIndices()) { Vector2d v = graph.GetVertex(vid); Vector3f c = graph.GetVertexColor(vid); float t = c.x; Vector2d n = new Vector2d(c.y, c.z); if (k == 0 || Math.Abs(t) > 0.9) { v += t * stepSize * n; if (!bounds.Contains(v)) { v = gpTree.NearestPoint(v); } } newPos[vid] = v; } foreach (int vid in graph.VertexIndices()) { graph.SetVertex(vid, newPos[vid]); } for (int j = 0; j < 5; ++j) { smooth_pass(graph, 0.1f, newPos); } } return(graph); }
/// <summary> /// fill poly w/ adjacent straight line segments, connected by connectors /// </summary> protected FillCurveSet2d ComputeFillPaths(GeneralPolygon2d poly) { FillCurveSet2d paths = new FillCurveSet2d(); // smooth the input poly a little bit, this simplifies the filling // (simplify after?) //GeneralPolygon2d smoothed = poly.Duplicate(); //CurveUtils2.LaplacianSmoothConstrained(smoothed, 0.5, 5, ToolWidth / 2, true, false); //poly = smoothed; // compute 2D non-manifold graph consisting of original polygon and // inserted line segments DGraph2 spanGraph = ComputeSpanGraph(poly); if (spanGraph == null || spanGraph.VertexCount == poly.VertexCount) { return(paths); } DGraph2 pathGraph = BuildPathGraph(spanGraph); // filter out self-overlaps from graph if (FilterSelfOverlaps) { PathOverlapRepair repair = new PathOverlapRepair(pathGraph); repair.OverlapRadius = ToolWidth * SelfOverlapToolWidthX; repair.PreserveEdgeFilterF = (eid) => { return(repair.Graph.GetEdgeGroup(eid) > 0); }; repair.Compute(); pathGraph = repair.GetResultGraph(); } HashSet <int> boundaries = new HashSet <int>(); foreach (int vid in pathGraph.VertexIndices()) { if (pathGraph.IsBoundaryVertex(vid)) { boundaries.Add(vid); } if (pathGraph.IsJunctionVertex(vid)) { throw new Exception("DenseLinesFillPolygon: PathGraph has a junction???"); } } // walk paths from boundary vertices while (boundaries.Count > 0) { int start_vid = boundaries.First(); boundaries.Remove(start_vid); int vid = start_vid; int eid = pathGraph.GetVtxEdges(vid)[0]; FillPolyline2d path = new FillPolyline2d() { TypeFlags = this.TypeFlags }; path.AppendVertex(pathGraph.GetVertex(vid)); while (true) { Index2i next = DGraph2Util.NextEdgeAndVtx(eid, vid, pathGraph); eid = next.a; vid = next.b; int gid = pathGraph.GetEdgeGroup(eid); if (gid < 0) { path.AppendVertex(pathGraph.GetVertex(vid), TPVertexFlags.IsConnector); } else { path.AppendVertex(pathGraph.GetVertex(vid)); } if (boundaries.Contains(vid)) { boundaries.Remove(vid); break; } } // discard paths that are too short if (path.ArcLength < MinPathLengthMM) { continue; } // run polyline simplification to get rid of unneccesary detail in connectors // [TODO] we could do this at graph level...) // [TODO] maybe should be checkign for collisions? we could end up creating // non-trivial overlaps here... if (SimplifyAmount != SimplificationLevel.None && path.VertexCount > 2) { PolySimplification2 simp = new PolySimplification2(path); switch (SimplifyAmount) { default: case SimplificationLevel.Minor: simp.SimplifyDeviationThreshold = ToolWidth / 4; break; case SimplificationLevel.Aggressive: simp.SimplifyDeviationThreshold = ToolWidth; break; case SimplificationLevel.Moderate: simp.SimplifyDeviationThreshold = ToolWidth / 2; break; } simp.Simplify(); path = new FillPolyline2d(simp.Result.ToArray()) { TypeFlags = this.TypeFlags }; } paths.Append(path); } // Check to make sure that we are not putting way too much material in the // available volume. Computes extrusion volume from path length and if the // ratio is too high, scales down the path thickness // TODO: do we need to compute volume? If we just divide everything by // height we get the same scaling, no? Then we don't need layer height. if (MaxOverfillRatio > 0) { throw new NotImplementedException("this is not finished yet"); #if false double LayerHeight = 0.2; // AAAHHH hardcoded nonono double len = paths.TotalLength(); double extrude_vol = ExtrusionMath.PathLengthToVolume(LayerHeight, ToolWidth, len); double polygon_vol = LayerHeight * Math.Abs(poly.Area); double ratio = extrude_vol / polygon_vol; if (ratio > MaxOverfillRatio && PathSpacing == ToolWidth) { double use_width = ExtrusionMath.WidthFromTargetVolume(LayerHeight, len, polygon_vol); //System.Console.WriteLine("Extrusion volume: {0} PolyVolume: {1} % {2} ScaledWidth: {3}", //extrude_vol, polygon_vol, extrude_vol / polygon_vol, use_width); foreach (var path in paths.Curves) { path.CustomThickness = use_width; } } #endif } return(paths); }
public static void TestDGraph2() { Window window = new Window("TestDGraph2"); window.SetDefaultSize(600, 600); window.SetPosition(WindowPosition.Center); DebugViewCanvas view = new DebugViewCanvas(); GeneralPolygon2d poly = new GeneralPolygon2d( Polygon2d.MakeCircle(10, 32)); //Polygon2d hole = Polygon2d.MakeCircle(9, 32); //hole.Reverse(); //poly.AddHole(hole); Polygon2d hole = Polygon2d.MakeCircle(5, 32); hole.Translate(new Vector2d(2, 0)); hole.Reverse(); poly.AddHole(hole); Polygon2d hole2 = Polygon2d.MakeCircle(1, 32); hole2.Translate(-6 * Vector2d.AxisX); hole2.Reverse(); poly.AddHole(hole2); Polygon2d hole3 = Polygon2d.MakeCircle(1, 32); hole3.Translate(-6 * Vector2d.One); hole3.Reverse(); poly.AddHole(hole3); Polygon2d hole4 = Polygon2d.MakeCircle(1, 32); hole4.Translate(7 * Vector2d.AxisY); hole4.Reverse(); poly.AddHole(hole4); view.AddPolygon(poly, Colorf.Black); double spacing = 0.2; //double[] offsets = new double[] { 0.5, 1, 1.5, 2, 2.5 }; double[] offsets = new double[] { 0.2, 0.6 }; TopoOffset2d o = new TopoOffset2d(poly) { PointSpacing = spacing }; foreach (double offset in offsets) { o.Offset = offset; DGraph2 graph = o.Compute(); DGraph2Util.Curves c = DGraph2Util.ExtractCurves(graph); view.AddGraph(graph, Colorf.Red); } window.Add(view); window.ShowAll(); }
/// <summary> /// Convert the input polygons to a set of paths. /// If FilterSelfOverlaps=true, then the paths will be clipped against /// themselves, in an attempt to avoid over-printing. /// </summary> public virtual FillCurveSet2d ShellPolysToPaths(List <GeneralPolygon2d> shell_polys, int nShell) { FillCurveSet2d paths = new FillCurveSet2d(); FillTypeFlags flags = FillTypeFlags.PerimeterShell; if (nShell == 0 && ShellType == ShellTypes.ExternalPerimeters) { flags = FillTypeFlags.OutermostShell; } else if (ShellType == ShellTypes.InternalShell) { flags = FillTypeFlags.InteriorShell; } else if (ShellType == ShellTypes.BridgeShell) { flags = FillTypeFlags.BridgeSupport; } if (FilterSelfOverlaps == false) { foreach (GeneralPolygon2d shell in shell_polys) { paths.Append(shell, flags); } return(paths); } int outer_shell_edgegroup = 100; foreach (GeneralPolygon2d shell in shell_polys) { PathOverlapRepair repair = new PathOverlapRepair(); repair.OverlapRadius = SelfOverlapTolerance; repair.Add(shell, outer_shell_edgegroup); // Ideally want to presreve outermost shell of external perimeters. // However in many cases internal holes are 'too close' to outer border. // So we will still apply to those, but use edge filter to preserve outermost loop. // [TODO] could we be smarter about this somehow? if (PreserveOuterShells && nShell == 0 && ShellType == ShellTypes.ExternalPerimeters) { repair.PreserveEdgeFilterF = (eid) => { return(repair.Graph.GetEdgeGroup(eid) == outer_shell_edgegroup); } } ; repair.Compute(); DGraph2Util.Curves c = DGraph2Util.ExtractCurves(repair.GetResultGraph()); foreach (var polygon in c.Loops) { paths.Append(polygon, flags); } foreach (var polyline in c.Paths) { if (polyline.ArcLength < DiscardTinyPerimterLengthMM) { continue; } if (polyline.Bounds.MaxDim < DiscardTinyPerimterLengthMM) { continue; } paths.Append(new FillPolyline2d(polyline) { TypeFlags = flags }); } } return(paths); }
protected DGraph2 compute_result(GeneralPolygon2d poly, double fOffset, double fTargetSpacing) { double dt = fTargetSpacing / 2; int nSteps = (int)(Math.Abs(fOffset) / dt); if (nSteps < 10) { nSteps = 10; } // [TODO] we could cache this over multiple runs... DGraph2 graph = new DGraph2(); graph.AppendPolygon(poly.Outer); foreach (var h in poly.Holes) { graph.AppendPolygon(h); } // resample to nbrhood of target spacing SplitToMaxEdgeLength(graph, fTargetSpacing * 1.33); // build bvtree for polygon if (poly_tree == null || poly_tree.Polygon != poly) { poly_tree = new GeneralPolygon2dBoxTree(poly); } // allocate and resize caches as necessary if (offset_cache == null) { offset_cache = new DVector <Vector2d>(); } if (offset_cache.size < graph.VertexCount) { offset_cache.resize(graph.VertexCount * 2); } if (position_cache == null) { position_cache = new DVector <Vector2d>(); } if (position_cache.size < graph.VertexCount) { position_cache.resize(graph.VertexCount * 2); } if (collapse_cache == null) { collapse_cache = new DVector <Vector2d>(); } if (collapse_cache.size < graph.VertexCount) { collapse_cache.resize(graph.VertexCount * 2); } if (last_step_size == null) { last_step_size = new DVector <double>(); } if (last_step_size.size < graph.VertexCount) { last_step_size.resize(graph.VertexCount * 2); } // insert all points into a hashgrid. We will dynamically update this grid as we proceed // [TODO] is this a good bounds-size? graph_cache = new PointHashGrid2d <int>(poly.Bounds.MaxDim / 64, -1); foreach (int vid in graph.VertexIndices()) { graph_cache.InsertPoint(vid, graph.GetVertex(vid)); } LocalProfiler p = (_enable_profiling) ? new LocalProfiler() : null; if (_enable_profiling) { p.Start("All"); } // run a bunch of steps. The last few are tuning steps where we use half-steps, // which seems to help? int TUNE_STEPS = nSteps / 2; nSteps *= 2; for (int i = 0; i < nSteps; ++i) { if (_enable_profiling) { p.Start("offset"); } double step_dt = dt; if (i > nSteps - TUNE_STEPS) { step_dt = dt / 2; } if (last_step_size.size < graph.VertexCount) { last_step_size.resize(graph.VertexCount + 256); } // Each vertex steps forward. In fact we compute two steps and average them, // this helps w/ convergence. To produce more accurate convergence, we track // the size of the actual step we took at the last round, and use that the next // time. (The assumption is that the steps will get smaller at the target distance). gParallel.ForEach(graph.VertexIndices(), (vid) => { // use tracked step size if we have it double use_dt = step_dt; if (last_step_size[vid] > 0) { use_dt = Math.Min(last_step_size[vid], dt); } Vector2d cur_pos = graph.GetVertex(vid); double err, err_2; // take two sequential steps and average them. this vastly improves convergence. Vector2d new_pos = compute_offset_step(cur_pos, poly, fOffset, use_dt, out err); Vector2d new_pos_2 = compute_offset_step(new_pos, poly, fOffset, use_dt, out err_2); // weighted blend of points - prefer one w/ smaller error //double w = 1.0 / Math.Max(err, MathUtil.ZeroTolerancef); //double w_2 = 1.0 / Math.Max(err_2, MathUtil.ZeroTolerancef); //new_pos = w * new_pos + w_2 * new_pos_2; //new_pos /= (w + w_2); // [RMS] weighted blend doesn't seem to matter if we are tracking per-vertex step size. new_pos = Vector2d.Lerp(new_pos, new_pos_2, 0.5); // keep track of actual step we are taking and use that next iteration double actual_step_dist = cur_pos.Distance(new_pos); if (last_step_size[vid] == 0) { last_step_size[vid] = actual_step_dist; } else { last_step_size[vid] = (0.75) * last_step_size[vid] + (0.25) * actual_step_dist; } // update point in hashtable and graph graph_cache.UpdatePoint(vid, cur_pos, new_pos); graph.SetVertex(vid, new_pos); }); if (_enable_profiling) { p.StopAndAccumulate("offset"); p.Start("smooth"); } // Do a smoothing pass, but for the last few steps, reduce smoothing // (otherwise it pulls away from target solution) int smooth_steps = 5; double smooth_alpha = 0.75; if (i > nSteps - TUNE_STEPS) { smooth_steps = 2; smooth_alpha = 0.25; } smooth_pass(graph, smooth_steps, smooth_alpha, fTargetSpacing / 2); if (_enable_profiling) { p.StopAndAccumulate("smooth"); p.Start("join"); } // if a vertex is within targetSpacing from another vertex, and they are // not geodesically connected in the graph, them we merge/weld them together. int joined = 0; do { //joined = JoinInTolerance(graph, fMergeThresh); //joined = JoinInTolerance_Parallel(graph, fMergeThresh); joined = JoinInTolerance_Parallel_Cache(graph, fTargetSpacing); } while (joined > 0); if (_enable_profiling) { p.StopAndAccumulate("join"); p.Start("refine"); } // now do a pass of graph refinement, to collapse short edges and split long ones CollapseToMinEdgeLength(graph, fTargetSpacing * 0.66f); SplitToMaxEdgeLength(graph, fTargetSpacing * 1.33); if (_enable_profiling) { p.StopAndAccumulate("refine"); } } if (_enable_profiling) { p.Stop("All"); System.Console.WriteLine("All: " + p.Elapsed("All")); System.Console.WriteLine(p.AllAccumulatedTimes()); } // get rid of junction vertices, if requested if (DisconnectGraphJunctions) { DGraph2Util.DisconnectJunctions(graph); } return(graph); }
/// <summary> /// Assumption is that input graph is a polygon with inserted ray-spans. We want to /// find a set of paths (ie no junctions) that cover all the spans, and travel between /// adjacent spans along edges of the input polygon. /// </summary> protected DGraph2 BuildPathGraph(DGraph2 input) { int NV = input.MaxVertexID; /* * OK, as input we have a graph of our original polygon and a bunch of inserted * segments ("spans"). Orig polygon segments have gid < 0, and span segments >= 0. * However between polygon/span junctions, we have an arbitrary # of polygon edges. * So first step is to simplify these to single-edge "connectors", in new graph MinGraph. * the [connector-edge, path] mappings (if pathlen > 1) are stored in MinEdgePaths * We also store a weight for each connector edge in EdgeWeights (just distance for now) */ DGraph2 MinGraph = new DGraph2(); Dictionary <int, List <int> > MinEdgePaths = new Dictionary <int, List <int> >(); DVector <double> EdgeWeights = new DVector <double>(); EdgeWeights.resize(NV); BitArray done_edge = new BitArray(input.MaxEdgeID); // we should see each edge twice, this avoids repetition // vertex map from input graph to MinGraph int[] MapV = new int[NV]; for (int i = 0; i < NV; ++i) { MapV[i] = -1; } for (int a = 0; a < NV; ++a) { if (input.IsVertex(a) == false || input.IsJunctionVertex(a) == false) { continue; } if (MapV[a] == -1) { MapV[a] = MinGraph.AppendVertex(input.GetVertex(a)); } foreach (int eid in input.VtxEdgesItr(a)) { if (done_edge[eid]) { continue; } Index2i ev = input.GetEdgeV(eid); int b = (ev.a == a) ? ev.b : ev.a; if (input.IsJunctionVertex(b)) { // if we have junction/juntion connection, we can just copy this edge to MinGraph if (MapV[b] == -1) { MapV[b] = MinGraph.AppendVertex(input.GetVertex(b)); } int gid = input.GetEdgeGroup(eid); int existing = MinGraph.FindEdge(MapV[a], MapV[b]); if (existing == DMesh3.InvalidID) { int new_eid = MinGraph.AppendEdge(MapV[a], MapV[b], gid); double path_len = input.GetEdgeSegment(eid).Length; EdgeWeights.insertAt(path_len, new_eid); } else { // we may have inserted this edge already in the simplify branch, this happens eg at the // edge of a circle where the minimal path is between the same vertices as the segment. // But if this is also a fill edge, we want to treat it that way (determind via positive gid) if (gid >= 0) { MinGraph.SetEdgeGroup(existing, gid); } } } else { // not a junction - walk until we find other vtx, and add single edge to MinGraph List <int> path = DGraph2Util.WalkToNextNonRegularVtx(input, a, eid); if (path == null || path.Count < 2) { throw new Exception("build_min_graph: invalid walk!"); } int c = path[path.Count - 1]; // it is somehow possible to get loops... if (c == a) { goto skip_this_edge; } if (MapV[c] == -1) { MapV[c] = MinGraph.AppendVertex(input.GetVertex(c)); } if (MinGraph.FindEdge(MapV[a], MapV[c]) == DMesh3.InvalidID) { int new_eid = MinGraph.AppendEdge(MapV[a], MapV[c], -2); path.Add(MapV[a]); path.Add(MapV[c]); MinEdgePaths[new_eid] = path; double path_len = DGraph2Util.PathLength(input, path); EdgeWeights.insertAt(path_len, new_eid); } } skip_this_edge: done_edge[eid] = true; } } // [TODO] filter MinGraph to remove invalid connectors // - can a connector between two connectors happen? that would be bad. /// - connector that is too close to paths should be ignored (ie avoid collisions) /* * Now that we have MinGraph, we can easily walk between the spans because * they are connected by at most one edge. To find a sequence of spans, we * pick one to start, then walk along connectors, discarding as we go, * so that we don't pass through these vertices again. Repeat until * there are no remaining spans. */ // [TODO] // do we actually have to delete from MinGraph? this prevents us from doing // certain things, like trying different options. Maybe could use a hash for // remaining vertices and edges instead? DGraph2 PathGraph = new DGraph2(); Vector2d sortAxis = Vector2d.FromAngleDeg(AngleDeg).Perp; while (true) { // find most extreme edge to start at // [TODO] could use segment gid here as we set them based on insertion span! // [TODO] could use a smarter metric? like, closest to previous last endpoint? Using // extrema like this tends to produce longest spans, though... double min_dot = double.MaxValue; int start_eid = -1; foreach (int eid in MinGraph.EdgeIndices()) { Index3i evg = MinGraph.GetEdge(eid); if (evg.c >= 0) { double dot = MinGraph.GetVertex(evg.a).Dot(sortAxis); if (dot < min_dot) { min_dot = dot; start_eid = eid; } } } if (start_eid == -1) { break; // if we could not find a start edge, we must be done! } // ok now walk forward through connectors and spans. We do this in // connector/span pairs - we are always at an end-of-span point, and // we pick a next-connector and then a next-span. // We need to keep track of vertices in both the pathgraph and mingraph, // these are the "new" and "old" vertices Index3i start_evg = MinGraph.GetEdge(start_eid); int new_start = PathGraph.AppendVertex(MinGraph.GetVertex(start_evg.a)); int new_prev = PathGraph.AppendVertex(MinGraph.GetVertex(start_evg.b)); int old_prev = start_evg.b; PathGraph.AppendEdge(new_start, new_prev, start_evg.c); MinGraph.RemoveVertex(start_evg.a, true); while (true) { // choose next connector edge, outgoing from current vtx int connector_e = -1; foreach (int eid in MinGraph.VtxEdgesItr(old_prev)) { Index3i evg = MinGraph.GetEdge(eid); if (evg.c >= 0) { continue; // what?? } if (connector_e == -1 || EdgeWeights[connector_e] > EdgeWeights[eid]) { connector_e = eid; } } if (connector_e == -1) { break; } // find the vertex at end of connector Index3i conn_evg = MinGraph.GetEdge(connector_e); int old_conn_v = (conn_evg.a == old_prev) ? conn_evg.b : conn_evg.a; // can never look at prev vertex again, or any edges connected to it // [TODO] are we sure none of these edges are unused spans?!? MinGraph.RemoveVertex(old_prev, true); // now find outgoing span edge int span_e = -1; foreach (int eid in MinGraph.VtxEdgesItr(old_conn_v)) { Index3i evg = MinGraph.GetEdge(eid); if (evg.c >= 0) { span_e = eid; break; } } if (span_e == -1) { break; // disaster! } // find vertex at far end of span Index3i span_evg = MinGraph.GetEdge(span_e); int old_span_v = (span_evg.a == old_conn_v) ? span_evg.b : span_evg.a; // ok we want to insert the connectr to the path graph, however the // connector might actually have come from a more complex path in the input graph. int new_conn_next = -1; if (MinEdgePaths.ContainsKey(connector_e)) { // complex path case. Note that the order [old_prev, old_conn_v] may be the opposite // of the order in the pathv. But above, we appended the [a,b] edge order to the pathv. // So we can check if we need to flip, but this means we need to be a bit clever w/ indices... List <int> pathv = MinEdgePaths[connector_e]; int N = pathv.Count; int path_prev = new_prev; int k = 1; if (pathv[N - 2] != old_prev) // case where order flipped { pathv.Reverse(); k = 3; } else { N = N - 2; } while (k < N) { int path_next = PathGraph.AppendVertex(input.GetVertex(pathv[k])); PathGraph.AppendEdge(path_prev, path_next); path_prev = path_next; k++; } new_conn_next = path_prev; } else { new_conn_next = PathGraph.AppendVertex(MinGraph.GetVertex(old_conn_v)); PathGraph.AppendEdge(new_prev, new_conn_next, conn_evg.c); } // add span to path int new_fill_next = PathGraph.AppendVertex(MinGraph.GetVertex(old_span_v)); PathGraph.AppendEdge(new_conn_next, new_fill_next, span_evg.c); // remove the connector vertex MinGraph.RemoveVertex(old_conn_v, true); // next iter starts at far end of span new_prev = new_fill_next; old_prev = old_span_v; } sortAxis = -sortAxis; } // for testing/debugging //SVGWriter writer = new SVGWriter(); ////writer.AddGraph(input, SVGWriter.Style.Outline("blue", 0.1f)); //writer.AddGraph(MinGraph, SVGWriter.Style.Outline("red", 0.1f)); ////foreach ( int eid in MinGraph.EdgeIndices() ) { //// if ( MinGraph.GetEdgeGroup(eid) >= 0 ) writer.AddLine(MinGraph.GetEdgeSegment(eid), SVGWriter.Style.Outline("green", 0.07f)); ////} ////writer.AddGraph(MinGraph, SVGWriter.Style.Outline("black", 0.03f)); //writer.AddGraph(PathGraph, SVGWriter.Style.Outline("black", 0.03f)); //foreach (int vid in PathGraph.VertexIndices()) { // if (PathGraph.IsBoundaryVertex(vid)) // writer.AddCircle(new Circle2d(PathGraph.GetVertex(vid), 0.5f), SVGWriter.Style.Outline("blue", 0.03f)); //} ////writer.AddGraph(IntervalGraph, SVGWriter.Style.Outline("black", 0.03f)); //writer.Write("c:\\scratch\\MIN_GRAPH.svg"); return(PathGraph); }
/// <summary> /// Convert the input polygons to a set of paths. /// If FilterSelfOverlaps=true, then the paths will be clipped against /// themselves, in an attempt to avoid over-printing. /// </summary> public virtual FillCurveSet2d ShellPolysToPaths(List <GeneralPolygon2d> shell_polys, int nShell) { FillCurveSet2d paths = new FillCurveSet2d(); IFillType currentFillType = nShell == 0 ? firstShellFillType ?? fillType : fillType; if (FilterSelfOverlaps == false) { foreach (var shell in shell_polys) { paths.Append(new FillLoop <FillSegment>(shell.Outer.Vertices) { FillType = currentFillType, PerimeterOrder = nShell }); foreach (var hole in shell.Holes) { paths.Append(new FillLoop <FillSegment>(hole.Vertices) { FillType = currentFillType, PerimeterOrder = nShell, IsHoleShell = true });; } } return(paths); } int outer_shell_edgegroup = 100; foreach (GeneralPolygon2d shell in shell_polys) { PathOverlapRepair repair = new PathOverlapRepair(); repair.OverlapRadius = SelfOverlapTolerance; repair.Add(shell, outer_shell_edgegroup); // Ideally want to presreve outermost shell of external perimeters. // However in many cases internal holes are 'too close' to outer border. // So we will still apply to those, but use edge filter to preserve outermost loop. // [TODO] could we be smarter about this somehow? if (PreserveOuterShells && nShell == 0) { repair.PreserveEdgeFilterF = (eid) => { return(repair.Graph.GetEdgeGroup(eid) == outer_shell_edgegroup); } } ; repair.Compute(); DGraph2Util.Curves c = DGraph2Util.ExtractCurves(repair.GetResultGraph()); #region Borrow nesting calculations from PlanarSlice to enforce winding direction PlanarComplex complex = new PlanarComplex(); foreach (Polygon2d poly in c.Loops) { complex.Add(poly); } PlanarComplex.FindSolidsOptions options = PlanarComplex.FindSolidsOptions.Default; options.WantCurveSolids = false; options.SimplifyDeviationTolerance = 0.001; options.TrustOrientations = false; options.AllowOverlappingHoles = false; PlanarComplex.SolidRegionInfo solids = complex.FindSolidRegions(options); foreach (var polygon in solids.Polygons) { polygon.EnforceCounterClockwise(); paths.Append(new FillLoop <FillSegment>(polygon.Outer.Vertices) { FillType = currentFillType, PerimeterOrder = nShell }); foreach (var hole in polygon.Holes) { paths.Append(new FillLoop <FillSegment>(hole.Vertices) { FillType = currentFillType, PerimeterOrder = nShell, IsHoleShell = true, }); } } #endregion Borrow nesting calculations from PlanarSlice to enforce winding direction foreach (var polyline in c.Paths) { if (polyline.ArcLength < DiscardTinyPerimeterLengthMM) { continue; } if (polyline.Bounds.MaxDim < DiscardTinyPerimeterLengthMM) { continue; } paths.Append(new FillCurve <FillSegment>(polyline) { FillType = currentFillType, PerimeterOrder = nShell }); } } return(paths); }