Ejemplo n.º 1
0
        public bool Compute()
        {
            if (InsetFromInputPolygon)
            {
                double inset   = ToolWidth * InsetFromInputPolygonX;
                var    current = ClipperUtil.ComputeOffsetPolygon(Polygon, -inset, true);
                foreach (var poly in current)
                {
                    FillCurveSet2d fillPaths = ComputeFillPaths(poly);
                    if (fillPaths != null)
                    {
                        FillCurves.Add(fillPaths);
                    }
                }
            }
            else
            {
                FillCurveSet2d fillPaths = ComputeFillPaths(Polygon);
                if (fillPaths != null)
                {
                    FillCurves.Add(fillPaths);
                }
            }

            return(true);
        }
Ejemplo n.º 2
0
        public bool Compute()
        {
            if (InsetFromInputPolygon)
            {
                //BoundaryPolygonCache = new SegmentSet2d(Polygon);
                List <GeneralPolygon2d> current = ClipperUtil.ComputeOffsetPolygon(Polygon, -ToolWidth / 2, true);
                foreach (GeneralPolygon2d poly in current)
                {
                    FillCurveSet2d fillPaths = ComputeFillPaths(poly);
                    if (fillPaths != null)
                    {
                        FillCurves.Add(fillPaths);
                    }
                }
            }
            else
            {
                List <GeneralPolygon2d> boundary = ClipperUtil.ComputeOffsetPolygon(Polygon, ToolWidth / 2, true);
                //BoundaryPolygonCache = new SegmentSet2d(boundary);
                FillCurveSet2d fillPaths = ComputeFillPaths(Polygon);
                if (fillPaths != null)
                {
                    FillCurves.Add(fillPaths);
                }
            }


            return(true);
        }
Ejemplo n.º 3
0
        public List <FillPolyline2d> thin_offset(GeneralPolygon2d p)
        {
            List <FillPolyline2d> result = new List <FillPolyline2d>();

            // to support non-hole thin offsets we need to return polylines
            if (p.Holes.Count == 0)
            {
                return(result);
            }

            // compute desired offset from outer polygon
            GeneralPolygon2d        outer   = new GeneralPolygon2d(p.Outer);
            List <GeneralPolygon2d> offsets =
                ClipperUtil.ComputeOffsetPolygon(outer, -ToolWidth, true);

            if (offsets == null || offsets.Count == 0)
            {
                return(result);
            }

            double clip_dist = ToolWidth * ToolWidthClipMultiplier;

            foreach (GeneralPolygon2d offset_poly in offsets)
            {
                List <FillPolyline2d> clipped = clip_to_band(offset_poly.Outer, p, clip_dist);
                result.AddRange(clipped);
            }

            return(result);
        }
Ejemplo n.º 4
0
        public bool Compute()
        {
            if (InsetFromInputPolygon)
            {
                BoundaryPolygonCache = new SegmentSet2d(Polygon);
                List <GeneralPolygon2d> current = ClipperUtil.ComputeOffsetPolygon(Polygon, -ToolWidth / 2, true);
                foreach (GeneralPolygon2d poly in current)
                {
                    SegmentSet2d polyCache = new SegmentSet2d(poly);
                    Paths.Add(ComputeFillPaths(poly, polyCache));
                }
            }
            else
            {
                List <GeneralPolygon2d> boundary = ClipperUtil.ComputeOffsetPolygon(Polygon, ToolWidth / 2, true);
                BoundaryPolygonCache = new SegmentSet2d(boundary);

                SegmentSet2d polyCache = new SegmentSet2d(Polygon);
                Paths.Add(ComputeFillPaths(Polygon, polyCache));
            }

            return(true);
        }
Ejemplo n.º 5
0
        public bool Compute()
        {
            bool   enable_thin_check     = false;
            double thin_check_offset     = ToolWidth * 0.45;
            double thin_check_thresh_sqr = ToolWidth * 0.3;

            thin_check_thresh_sqr *= thin_check_thresh_sqr;

            // first shell is either polygon, or inset from that polygon
            List <GeneralPolygon2d> current = null;

            if (InsetFromInputPolygonX != 0)
            {
                current = ComputeInitialInsetPolygon(PreserveInputInsetTopology);
            }
            else
            {
                current = new List <GeneralPolygon2d>()
                {
                    Polygon
                };
            }
            List <GeneralPolygon2d> current_prev = null;

            if (current.Count == 0)
            {
                HandleTinyPolygon();
                return(true);
            }

            // convert previous layer to shell, and then compute next layer
            List <GeneralPolygon2d> failedShells     = new List <GeneralPolygon2d>();
            List <GeneralPolygon2d> nextShellTooThin = new List <GeneralPolygon2d>();

            for (int i = 0; i < Layers; ++i)
            {
                FillCurveSet2d paths = ShellPolysToPaths(current, i);
                Shells.Add(paths);

                List <GeneralPolygon2d> all_next = new List <GeneralPolygon2d>();
                foreach (GeneralPolygon2d gpoly in current)
                {
                    List <GeneralPolygon2d> offsets =
                        ClipperUtil.ComputeOffsetPolygon(gpoly, -PathSpacing, true);

                    List <GeneralPolygon2d> filtered = new List <GeneralPolygon2d>();
                    foreach (var v in offsets)
                    {
                        bool bTooSmall = (v.Perimeter < DiscardTinyPerimterLengthMM ||
                                          v.Area < DiscardTinyPolygonAreaMM2);
                        if (bTooSmall)
                        {
                            continue;
                        }

                        if (enable_thin_check && is_too_thin(v, thin_check_offset, thin_check_thresh_sqr))
                        {
                            nextShellTooThin.Add(v);
                        }
                        else
                        {
                            filtered.Add(v);
                        }
                    }

                    if (filtered.Count == 0)
                    {
                        failedShells.Add(gpoly);
                    }
                    else
                    {
                        all_next.AddRange(filtered);
                    }
                }

                current_prev = current;
                current      = all_next;
            }


            // failedShells have no space for internal contours. But
            // we might be able to fit a single line...
            //foreach (GeneralPolygon2d gpoly in failedShells) {
            //	if (gpoly.Perimeter < DiscardTinyPerimterLengthMM ||
            //		 gpoly.Area < DiscardTinyPolygonAreaMM2)
            //		continue;

            //	List<FillPolyline2d> thin_shells = thin_offset(gpoly);
            //	Shells[Shells.Count - 1].Append(thin_shells);
            //}


            // remaining inner polygons
            if (InsetInnerPolygons)
            {
                InnerPolygons = current;
                InnerPolygons.AddRange(nextShellTooThin);
            }
            else
            {
                InnerPolygons = current_prev;
                InnerPolygons.AddRange(nextShellTooThin);
            }
            return(true);
        }