#include <src/libslic3r/Print.hpp>

Collaboration diagram for Slic3r::FakeWipeTower:

Public Member Functions
void	set_fake_extrusion_data (const Vec2f &p, float w, float h, float lh, float d, const std::vector< std::pair< float, float > > &zad, float bd, float ra, float ca, const Vec2d &o)

void	set_pos_and_rotation (const Vec2f &p, float rotation)

std::vector< ExtrusionPaths >	getFakeExtrusionPathsFromWipeTower () const

Public Attributes
Vec2f	pos

float	width

float	height

float	layer_height

float	depth

std::vector< std::pair< float, float > >	z_and_depth_pairs

float	brim_width

float	rotation_angle

float	cone_angle

Vec2d	plate_origin

Detailed Description

Member Function Documentation

◆ getFakeExtrusionPathsFromWipeTower()

std::vector< ExtrusionPaths > Slic3r::FakeWipeTower::getFakeExtrusionPathsFromWipeTower ( ) const

    {
        float h = height;
        float lh = layer_height;
        int   d = scale_(depth);
        int   w = scale_(width);
        int   bd = scale_(brim_width);
        Point minCorner = { -bd, -bd };
        Point maxCorner = { minCorner.x() + w + bd, minCorner.y() + d + bd };
 
        const auto [cone_base_R, cone_scale_x] = WipeTower::get_wipe_tower_cone_base(width, height, depth, cone_angle);
 
        std::vector<ExtrusionPaths> paths;
        for (float hh = 0.f; hh < h; hh += lh) {
            
            if (hh != 0.f) {
                // The wipe tower may be getting smaller. Find the depth for this layer.
                size_t i = 0;
                for (i=0; i<z_and_depth_pairs.size()-1; ++i)
                    if (hh >= z_and_depth_pairs[i].first && hh < z_and_depth_pairs[i+1].first)
                        break;
                d = scale_(z_and_depth_pairs[i].second);
                minCorner = {0.f, -d/2 + scale_(z_and_depth_pairs.front().second/2.f)};
                maxCorner = { minCorner.x() + w, minCorner.y() + d };
            }
 
 
            ExtrusionPath path(ExtrusionRole::WipeTower, 0.0, 0.0, lh);
            path.polyline = { minCorner, {maxCorner.x(), minCorner.y()}, maxCorner, {minCorner.x(), maxCorner.y()}, minCorner };
            paths.push_back({ path });
 
            // We added the border, now add several parallel lines so we can detect an object that is fully inside the tower.
            // For now, simply use fixed spacing of 3mm.
            for (coord_t y=minCorner.y()+scale_(3.); y<maxCorner.y(); y+=scale_(3.)) {
                path.polyline = { {minCorner.x(), y}, {maxCorner.x(), y} };
                paths.back().emplace_back(path);
            }
 
            // And of course the stabilization cone and its base...
            if (cone_base_R > 0.) {
                path.polyline.clear();
                double r = cone_base_R * (1 - hh/height);
                for (double alpha=0; alpha<2.01*M_PI; alpha+=2*M_PI/20.)
                    path.polyline.points.emplace_back(Point::new_scale(width/2. + r * std::cos(alpha)/cone_scale_x, depth/2. + r * std::sin(alpha)));
                paths.back().emplace_back(path);
                if (hh == 0.f) { // Cone brim.
                    for (float bw=brim_width; bw>0.f; bw-=3.f) {
                        path.polyline.clear();
                        for (double alpha=0; alpha<2.01*M_PI; alpha+=2*M_PI/20.) // see load_wipe_tower_preview, where the same is a bit clearer
                            path.polyline.points.emplace_back(Point::new_scale(
                                width/2. + cone_base_R * std::cos(alpha)/cone_scale_x * (1. + cone_scale_x*bw/cone_base_R),
                                depth/2. + cone_base_R * std::sin(alpha) * (1. + bw/cone_base_R))
                            );
                        paths.back().emplace_back(path);
                    }
                }
            }
 
            // Only the first layer has brim.
            if (hh == 0.f) {
                minCorner = minCorner + Point(bd, bd);
                maxCorner = maxCorner - Point(bd, bd);
            }
        }
 
        // Rotate and translate the tower into the final position.
        for (ExtrusionPaths& ps : paths) {
            for (ExtrusionPath& p : ps) {
                p.polyline.rotate(Geometry::deg2rad(rotation_angle));
                p.polyline.translate(scale_(pos.x()), scale_(pos.y()));
            }
        }
 
        return paths;
    }

References brim_width, Slic3r::MultiPoint::clear(), cone_angle, Slic3r::Geometry::deg2rad(), depth, Slic3r::WipeTower::get_wipe_tower_cone_base(), height, layer_height, M_PI, Slic3r::MultiPoint::points, Slic3r::ExtrusionPath::polyline, pos, rotation_angle, scale_, width, Slic3r::ExtrusionRole::WipeTower, and z_and_depth_pairs.

Here is the call graph for this function:

◆ set_fake_extrusion_data()

void Slic3r::FakeWipeTower::set_fake_extrusion_data	(	const Vec2f &	p,
		float	w,
		float	h,
		float	lh,
		float	d,
		const std::vector< std::pair< float, float > > &	zad,
		float	bd,
		float	ra,
		float	ca,
		const Vec2d &	o
	)

inline

    {
        pos = p;
        width = w;
        height = h;
        layer_height = lh;
        depth = d;
        z_and_depth_pairs = zad;
        brim_width = bd;
        rotation_angle = ra;
        cone_angle = ca;
        plate_origin = o;
    }