Collaboration diagram for Slic3r::ExPolygonWithOffset:

Public Member Functions
	ExPolygonWithOffset (const ExPolygon &expolygon, float angle, coord_t aoffset1, coord_t aoffset2=0)

	ExPolygonWithOffset (const ExPolygonWithOffset &rhs, float angle)

bool	is_contour_outer (size_t idx) const

bool	is_contour_inner (size_t idx) const

const Polygon &	contour (size_t idx) const

Polygon &	contour (size_t idx)

bool	is_contour_ccw (size_t idx) const

BoundingBox	bounding_box_src () const

BoundingBox	bounding_box_outer () const

BoundingBox	bounding_box_inner () const

Public Attributes
ExPolygon	polygons_src

Polygons	polygons_outer

Polygons	polygons_inner

size_t	n_contours_outer

size_t	n_contours_inner

size_t	n_contours

Protected Attributes
std::vector< unsigned char >	polygons_ccw

Detailed Description

Constructor & Destructor Documentation

◆ ExPolygonWithOffset() [1/2]

Slic3r::ExPolygonWithOffset::ExPolygonWithOffset	(	const ExPolygon &	expolygon,
		float	angle,
		coord_t	aoffset1,
		coord_t	aoffset2 = `0`
	)

inline

    {
        // Copy and rotate the source polygons.
        polygons_src = expolygon;
        if (angle != 0.f) {
            polygons_src.contour.rotate(angle);
            for (Polygon &hole : polygons_src.holes)
                hole.rotate(angle);
        }
 
        double miterLimit = DefaultMiterLimit;
        // for the infill pattern, don't cut the corners.
        // default miterLimt = 3
        //double miterLimit = 10.;
        // FIXME: Resolve properly the cases when it is constructed with aoffset1 = 0 and aoffset2 = 0,
        //        that is used in sample_grid_pattern() for Lightning infill.
        // assert(aoffset1 < 0);
        assert(aoffset2 <= 0);
        // assert(aoffset2 == 0 || aoffset2 < aoffset1);
//        bool sticks_removed = 
        remove_sticks(polygons_src);
//        if (sticks_removed) BOOST_LOG_TRIVIAL(error) << "Sticks removed!";
        polygons_outer = aoffset1 == 0 ? to_polygons(polygons_src) : offset(polygons_src, float(aoffset1), ClipperLib::jtMiter, miterLimit);
        if (aoffset2 < 0)
            polygons_inner = shrink(polygons_outer, float(aoffset1 - aoffset2), ClipperLib::jtMiter, miterLimit);
    // Filter out contours with zero area or small area, contours with 2 points only.
        const double min_area_threshold = 0.01 * aoffset2 * aoffset2;
        remove_small(polygons_outer, min_area_threshold);
        remove_small(polygons_inner, min_area_threshold);
        remove_sticks(polygons_outer);
        remove_sticks(polygons_inner);
    n_contours_outer = polygons_outer.size();
        n_contours_inner = polygons_inner.size();
        n_contours = n_contours_outer + n_contours_inner;
        polygons_ccw.assign(n_contours, false);
        for (size_t i = 0; i < n_contours; ++ i) {
            contour(i).remove_duplicate_points();
            assert(! contour(i).has_duplicate_points());
            polygons_ccw[i] = Slic3r::Geometry::is_ccw(contour(i));
        }
    }

References Slic3r::angle(), Slic3r::ExPolygon::contour, contour(), Slic3r::DefaultMiterLimit, Slic3r::has_duplicate_points(), Slic3r::ExPolygon::holes, Slic3r::Geometry::is_ccw(), ClipperLib::jtMiter, n_contours, n_contours_inner, n_contours_outer, Slic3r::offset(), polygons_ccw, polygons_inner, polygons_outer, polygons_src, Slic3r::MultiPoint::remove_duplicate_points(), Slic3r::remove_small(), Slic3r::remove_sticks(), Slic3r::MultiPoint::rotate(), Slic3r::shrink(), and Slic3r::to_polygons().

Here is the call graph for this function:

◆ ExPolygonWithOffset() [2/2]

Slic3r::ExPolygonWithOffset::ExPolygonWithOffset	(	const ExPolygonWithOffset &	rhs,
		float	angle
	)

inline

                                                                     : ExPolygonWithOffset(rhs) {
        if (angle != 0.f) {
            this->polygons_src.contour.rotate(angle);
            for (Polygon &hole : this->polygons_src.holes)
                hole.rotate(angle);
            for (Polygon &poly : this->polygons_outer)
                poly.rotate(angle);
            for (Polygon &poly : this->polygons_inner)
                poly.rotate(angle);
        }
    }