#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Print.hpp>

Collaboration diagram for Slic3r::FakeWipeTower:

Public Member Functions
void	set_fake_extrusion_data (Vec2f p, float w, float h, float lh, float d, float bd, Vec2d o)
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 (Vec2f p)
void	set_pos_and_rotation (const Vec2f &p, float rotation)
std::vector< ExtrusionPaths >	getFakeExtrusionPathsFromWipeTower () const
ExtrusionLayers	getTrueExtrusionLayersFromWipeTower () const
std::vector< ExtrusionPaths >	getFakeExtrusionPathsFromWipeTower2 () 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
Vec2f	rib_offset {0.f,0.f}
std::map< float, Polylines >	outer_wall

Detailed Description

Member Function Documentation

◆ getFakeExtrusionPathsFromWipeTower()

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

inline

    {
        int   d         = scale_(depth);
        int   w         = scale_(width);
        int   bd        = scale_(brim_width);
        Point minCorner = {scale_(pos.x()), scale_(pos.y())};
        Point maxCorner = {minCorner.x() + w, minCorner.y() + d};
 
        std::vector<ExtrusionPaths> paths;
        for (float h = 0.f; h < height; h += layer_height) {
            ExtrusionPath path(ExtrusionRole::erWipeTower, 0.0, 0.0, layer_height);
            path.polyline = Polyline3(Polyline{{minCorner, {maxCorner.x(), minCorner.y()}, maxCorner, {minCorner.x(), maxCorner.y()}, minCorner}});
            paths.push_back({path});
 
            if (h == 0.f) { // add brim
                ExtrusionPath fakeBrim(ExtrusionRole::erBrim, 0.0, 0.0, layer_height);
                Point         wtbminCorner = {minCorner - Point{bd, bd}};
                Point         wtbmaxCorner = {maxCorner + Point{bd, bd}};
                fakeBrim.polyline          = Polyline3(Polyline{{wtbminCorner, {wtbmaxCorner.x(), wtbminCorner.y()}, wtbmaxCorner, {wtbminCorner.x(), wtbmaxCorner.y()}, wtbminCorner}});
                paths.back().push_back(fakeBrim);
            }
        }
        return paths;
    }

References bd, brim_width, depth, Slic3r::erBrim, Slic3r::erWipeTower, height, layer_height, Slic3r::ExtrusionPath::polyline, pos, scale_, and width.

◆ getFakeExtrusionPathsFromWipeTower2()

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

inline

    {
        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] = WipeTower2::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::erWipeTower, 0.0, 0.0, lh);
            path.polyline = Polyline3(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 = Polyline3(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 bd, brim_width, Slic3r::MultiPoint3::clear(), cone_angle, Slic3r::Geometry::deg2rad(), depth, Slic3r::erWipeTower, Slic3r::WipeTower2::get_wipe_tower_cone_base(), height, layer_height, M_PI, Slic3r::Point::new_scale(), Slic3r::MultiPoint3::points, Slic3r::ExtrusionPath::polyline, pos, rotation_angle, scale_, width, and z_and_depth_pairs.

Referenced by getTrueExtrusionLayersFromWipeTower().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getTrueExtrusionLayersFromWipeTower()

ExtrusionLayers Slic3r::FakeWipeTower::getTrueExtrusionLayersFromWipeTower ( ) const

{
    ExtrusionLayers wtels;
    wtels.type = ExtrusionLayersType::WIPE_TOWER;
 
    //ORCA: Fallback for WipeTower2 if outer_wall is empty
    if (outer_wall.empty()) {
        auto fake_paths = getFakeExtrusionPathsFromWipeTower2();
        float current_z = 0.f;
        for (auto& layer_paths : fake_paths) {
            if (layer_paths.empty()) continue;
            ExtrusionLayer el;
            float lh = layer_paths.front().height;
            el.height = lh;
            el.bottom_z = current_z;
            el.layer = nullptr;
            el.paths = std::move(layer_paths);
            wtels.push_back(std::move(el));
            current_z += lh;
        }
        return wtels;
    }
 
    std::vector<float> layer_heights;
    layer_heights.reserve(outer_wall.size());
    auto pre = outer_wall.begin();
    for (auto it = outer_wall.begin(); it != outer_wall.end(); ++it) {
        if (it == outer_wall.begin())
            layer_heights.push_back(it->first);
        else {
            layer_heights.push_back(it->first - pre->first);
            ++pre;
        }
    }
    Point trans = {scale_(pos.x()), scale_(pos.y())};
    for (auto it = outer_wall.begin(); it != outer_wall.end(); ++it) {
        int            index = std::distance(outer_wall.begin(), it);
        ExtrusionLayer el;
        ExtrusionPaths paths;
        paths.reserve(it->second.size());
        for (auto &polyline : it->second) {
            ExtrusionPath path(ExtrusionRole::erWipeTower, 0.0, 0.0, layer_heights[index]);
            path.polyline = Polyline3(polyline);
            Point3 trans3(trans, 0);
            for (auto &p : path.polyline.points) p += trans3;
            paths.push_back(path);
        }
        el.paths    = std::move(paths);
        el.bottom_z = it->first - layer_heights[index];
        el.layer    = nullptr;
        wtels.push_back(el);
    }
    return wtels;
}

References Slic3r::ExtrusionLayer::bottom_z, Slic3r::erWipeTower, getFakeExtrusionPathsFromWipeTower2(), getTrueExtrusionLayersFromWipeTower(), Slic3r::ExtrusionLayer::height, Slic3r::ExtrusionLayer::layer, outer_wall, Slic3r::ExtrusionLayer::paths, Slic3r::MultiPoint3::points, Slic3r::ExtrusionPath::polyline, pos, scale_, Slic3r::ExtrusionLayers::type, and Slic3r::WIPE_TOWER.

Referenced by getTrueExtrusionLayersFromWipeTower().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_fake_extrusion_data() [1/2]

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;
    }

References bd, brim_width, cone_angle, depth, height, layer_height, plate_origin, pos, rotation_angle, width, and z_and_depth_pairs.

◆ set_fake_extrusion_data() [2/2]

void Slic3r::FakeWipeTower::set_fake_extrusion_data	(	Vec2f	p,
		float	w,
		float	h,
		float	lh,
		float	d,
		float	bd,
		Vec2d	o )

inline

    {
        pos          = p;
        width        = w;
        height       = h;
        layer_height = lh;
        depth        = d;
        brim_width   = bd;
        plate_origin = o;
    }