private DGraph2 FilterPathGraphSelfOverlaps(DGraph2 pathGraph)
{
PathOverlapRepair repair = new PathOverlapRepair(pathGraph);
repair.OverlapRadius = ToolWidth * SelfOverlapToolWidthX;
repair.PreserveEdgeFilterF = (eid) =>
{
return(repair.Graph.GetEdgeGroup(eid) > 0);
};
repair.Compute();
pathGraph = repair.GetResultGraph();
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();
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);
}
/// <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);
}
/// <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);
}