Slic3r::orientation Namespace Reference

Classes
struct	CostItems
class	AutoOrienter
struct	OrientMesh
	Input/Output structure for the orient() function. The mesh field will not be modified during orientment. Instead, the translation and rotation fields will mark the needed transformation for the polygon to be in the orientd position. These can also be set to an initial offset and rotation. More...
struct	OrientParams

Typedefs
using	OrientMeshs = std::vector<OrientMesh>

Functions
void	_orient (OrientMeshs &meshs_, const OrientParams &params, std::function< void(unsigned, std::string)> progressfn, std::function< bool()> stopfn)
void	orient (OrientMeshs &items, const OrientMeshs &excludes, const OrientParams &params={})
	Orients the input polygons.
void	orient (ModelObject *obj)
void	orient (ModelInstance *instance)
void	orient_for_cooling (TriangleMesh &mesh, const FanDirection &fan_dir)

Variables
static const constexpr int	UNORIENTD = -1
	A logical bed representing an object not being orientd. Either the orient has not yet successfully run on this OrientPolygon or it could not fit the object due to overly large size or invalid geometry.

Typedef Documentation

OrientMeshs

using Slic3r::orientation::OrientMeshs = std::vector<OrientMesh>

Function Documentation

_orient()

void Slic3r::orientation::_orient	(	OrientMeshs &	meshs_,
		const OrientParams &	params,
		std::function< void(unsigned, std::string)>	progressfn,
		std::function< bool()>	stopfn )

{
    if (!params.parallel)
    {
        for (size_t i = 0; i != meshs_.size(); ++i) {
            auto& mesh_ = meshs_[i];
            progressfn(i, mesh_.name);
            //auto progressfn_i = [&](unsigned cnt) {progressfn(cnt, "Orienting " + mesh_.name); };
            AutoOrienter orienter(&mesh_, params, /*progressfn_i*/{}, stopfn);
            mesh_.orientation = orienter.process();
            Geometry::rotation_from_two_vectors(mesh_.orientation, { 0,0,1 }, mesh_.axis, mesh_.angle, &mesh_.rotation_matrix);
            BOOST_LOG_TRIVIAL(info) << std::fixed << std::setprecision(3) << "v,phi: " << mesh_.axis.transpose() << ", " << mesh_.angle;
            //flush_logs();
        }
    }
    else {
        tbb::parallel_for(tbb::blocked_range<size_t>(0, meshs_.size()), [&meshs_, &params, progressfn, stopfn](const tbb::blocked_range<size_t>& range) {
            for (size_t i = range.begin(); i != range.end(); ++i) {
                auto& mesh_ = meshs_[i];
                progressfn(i, mesh_.name);
                AutoOrienter orienter(&mesh_, params, {}, stopfn);
                mesh_.orientation = orienter.process();
                Geometry::rotation_from_two_vectors(mesh_.orientation, { 0,0,1 }, mesh_.axis, mesh_.angle, &mesh_.rotation_matrix);
                mesh_.euler_angles = Geometry::extract_euler_angles(mesh_.rotation_matrix);
                // find cool direction
                if (mesh_.has_cooling_fan)
                {
                    mesh_.orientation_vertical = orienter.find_cooling_direction2(mesh_.euler_angles, orienter.areas_cooling, mesh_.mesh);
                    BOOST_LOG_TRIVIAL(info) << "cooling direction: " << mesh_.orientation_vertical.transpose() << "\n";
                    Geometry::rotation_from_two_vectors(mesh_.orientation_vertical, mesh_.cooling_direction, mesh_.axis_vertical, mesh_.angle_vertical, &mesh_.rotation_matrix_vertical);
                }
                BOOST_LOG_TRIVIAL(debug) << "rotation_from_two_vectors: " << mesh_.orientation << "; " << mesh_.axis << "; " << mesh_.angle << "; euler: " << mesh_.euler_angles.transpose();
            }});
    }
}

References Slic3r::orientation::OrientParams::parallel, Slic3r::orientation::AutoOrienter::process(), Slic3r::range(), and Slic3r::Geometry::rotation_from_two_vectors().

Referenced by orient().

Here is the call graph for this function:

Here is the caller graph for this function:

orient() [1/3]

void Slic3r::orientation::orient

(

ModelInstance *

instance

)

{
    auto m = instance->get_object()->mesh();
    AutoOrienter orienter(&m);
    Vec3d orientation = orienter.process();
    Vec3d axis;
    double angle;
    Matrix3d rotation_matrix;
    Geometry::rotation_from_two_vectors(orientation, { 0,0,1 }, axis, angle, &rotation_matrix);
    instance->rotate(rotation_matrix);
}

References Slic3r::angle(), Slic3r::ModelInstance::get_object(), Slic3r::ModelObject::mesh(), Slic3r::orientation::AutoOrienter::process(), Slic3r::ModelInstance::rotate(), and Slic3r::Geometry::rotation_from_two_vectors().

Here is the call graph for this function:

orient() [2/3]

void Slic3r::orientation::orient

(

ModelObject *

obj

)

{
    auto m = obj->mesh();
    AutoOrienter orienter(&m);
    Vec3d orientation = orienter.process();
    Vec3d axis;
    double angle;
    Geometry::rotation_from_two_vectors(orientation, { 0,0,1 }, axis, angle);
 
    obj->rotate(angle, axis);
    obj->ensure_on_bed();
}

References Slic3r::angle(), Slic3r::ModelObject::ensure_on_bed(), Slic3r::ModelObject::mesh(), Slic3r::orientation::AutoOrienter::process(), Slic3r::ModelObject::rotate(), and Slic3r::Geometry::rotation_from_two_vectors().

Here is the call graph for this function:

orient() [3/3]

void Slic3r::orientation::orient	(	OrientMeshs &	items,
		const OrientMeshs &	excludes,
		const OrientParams &	params = {} )

Orients the input polygons.

Parameters

items

Input vector of OrientMeshs. The transformation, rotation and bin_idx fields will be changed after the call finished and can be used to apply the result on the input polygon.

{
 
    auto &cfn = params.stopcondition;
    auto &pri = params.progressind;
 
    _orient(arrangables, params, pri, cfn);
 
}

References _orient(), Slic3r::orientation::OrientParams::progressind, and Slic3r::orientation::OrientParams::stopcondition.

Referenced by Slic3r::GUI::OrientJob::process(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

orient_for_cooling()

void Slic3r::orientation::orient_for_cooling	(	TriangleMesh &	mesh,
		const FanDirection &	fan_dir )

{
    Vec3f best_direction{ 0, 0, 0 };
    Vec3f machine_cool_dir{ 0, 0, 0 };
 
    if (fan_dir == FanDirection::fdUndefine)
    {
        // no cooling fan, do not rotate along z axis
        return;
    }
    else if (fan_dir == FanDirection::fdRight)
    {
        machine_cool_dir = { 1, 0, 0 };   // the cooling fan is on the right side.
    }
    else
    {
        // the cooling fan is on the left side or both side has cooling fans
        machine_cool_dir = { -1, 0, 0 };
    }
 
    // 1. filter the overhang_areas
    int nfaces = mesh.facets_count();
    auto face_normals = its_face_normals(mesh.its);
 
    Eigen::VectorXf normal_projection(nfaces, 1);
    for (auto i = 0; i < nfaces; i++)
    {
        normal_projection(i) = face_normals[i].dot(Vec3f(0, 0, 1));
    }
    float angle_thres_high = -0.6427f;
    float angle_thres_low = -0.97f;
    // 2. compute the weighted overhang faces area
    Eigen::VectorXf weighted_areas = Eigen::VectorXf::Zero(nfaces);
    for (int i = 0; i < nfaces; i++)
    {
        if (normal_projection(i) < angle_thres_high && normal_projection(i) > angle_thres_low)
        {
            weighted_areas(i) = mesh.its.facet_area(i) * (1.0f - normal_projection(i));
        }
    }
 
    const size_t sample_nums = 180;
    std::vector<Vec3f> cool_dirs;
    for (size_t i = 0; i < sample_nums; i++)
    {
        float angle_deg = i * (360.0 / sample_nums);
        float angle_rad = angle_deg * (PI / 180.0);
        cool_dirs.push_back(Vec3f{ std::cos(angle_rad), std::sin(angle_rad), 0 });
    }
 
    // 3. accumulate the weighted projected overhang area, find the max weighted project area direction
    float overhang_projected_max = 0.f;
    float overhang_projected_origin = 0.f;
    for (auto cool_dir : cool_dirs)
    {
        float overhang_projected_tmp = 0.f;
        for (size_t i = 0; i < nfaces; i++)
        {
            float cool_dir_projection = face_normals[i].dot(cool_dir);
            if (weighted_areas[i] > 0 && cool_dir_projection > 0)
            {
                overhang_projected_tmp += weighted_areas[i] * cool_dir_projection;
            }
        }
        if (overhang_projected_tmp > overhang_projected_max)
        {
            overhang_projected_max = overhang_projected_tmp;
            best_direction = cool_dir;
        }
        if (cool_dir.dot(machine_cool_dir) > 0.999)
        {
            overhang_projected_origin = overhang_projected_tmp;
        }
    }
 
    // The symmetric model has similar overhang projection at all angles, so Z-axis rotation is unnecessary.
    if (std::abs(overhang_projected_origin - overhang_projected_max) < 1.0f)
    {
        return;
    }
 
    // rotate the mesh
    Vec3d axis;
    double angle;
    Matrix3d rotation_matrix;
    Geometry::rotation_from_two_vectors(best_direction.cast<double>(), machine_cool_dir.cast<double>(), axis, angle, &rotation_matrix);
    mesh.rotate(angle, axis);
}

References Slic3r::angle(), Slic3r::TriangleMesh::facets_count(), Slic3r::fdRight, Slic3r::fdUndefine, Slic3r::TriangleMesh::its, Slic3r::its_face_normals(), orient_for_cooling(), PI, Slic3r::TriangleMesh::rotate(), and Slic3r::Geometry::rotation_from_two_vectors().

Referenced by Slic3r::GUI::ObjectList::load_shape_object(), and orient_for_cooling().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

UNORIENTD

const constexpr int Slic3r::orientation::UNORIENTD = -1

staticconstexpr

A logical bed representing an object not being orientd. Either the orient has not yet successfully run on this OrientPolygon or it could not fit the object due to overly large size or invalid geometry.