anonymous_namespace{EmbossJob.cpp} Namespace Reference

private namespace implementation More...

Classes
struct	DataCreateVolume
	Hold neccessary data to create ModelVolume in job Volume is created on the surface of existing volume in object. NOTE: EmbossDataBase::font_file doesn't have to be valid !!! More...
class	CreateVolumeJob
	Create new TextVolume on the surface of ModelObject Should not be stopped NOTE: EmbossDataBase::font_file doesn't have to be valid !!! More...
struct	DataCreateObject
	Hold neccessary data to create ModelObject in job Object is placed on bed under screen coor OR to center of scene when it is out of bed shape. More...
class	CreateObjectJob
	Create new TextObject on the platter Should not be stopped. More...
struct	CreateSurfaceVolumeData
	Hold neccessary data to create(cut) volume from surface object in job. More...
class	CreateSurfaceVolumeJob
	Cut surface from object and create cutted volume Should not be stopped. More...
class	JobException

Functions
bool	check (const DataBase &input, bool check_fontfile=true, bool use_surface=false)
	Assert check of inputs data.
bool	check (GLGizmosManager::EType gizmo)
bool	check (const CreateVolumeParams &input)
bool	check (const DataCreateVolume &input, bool is_main_thread=false)
bool	check (const DataCreateObject &input)
bool	check (const DataUpdate &input, bool is_main_thread=false, bool use_surface=false)
bool	check (const CreateSurfaceVolumeData &input, bool is_main_thread=false)
bool	check (const UpdateSurfaceVolumeData &input, bool is_main_thread=false)
template<typename Fnc>
static ExPolygons	create_shape (DataBase &input, Fnc was_canceled)
template<typename Fnc>
TriangleMesh	try_create_mesh (DataBase &input, const Fnc &was_canceled)
	Try to create mesh from text.
template<typename Fnc>
TriangleMesh	create_mesh (DataBase &input, const Fnc &was_canceled, Job::Ctl &ctl)
TriangleMesh	create_default_mesh ()
	Create default mesh for embossed text.
void	update_volume (TriangleMesh &&mesh, const DataUpdate &data, const Transform3d *tr=nullptr)
	Must be called on main thread.
void	update_name_in_list (const ObjectList &object_list, const ModelVolume &volume)
	Update name in right panel.
void	create_volume (TriangleMesh &&mesh, const ObjectID &object_id, const ModelVolumeType type, const std::optional< Transform3d > &trmat, const DataBase &data, GLGizmosManager::EType gizmo)
	Add new volume to object.
OrthoProject	create_projection_for_cut (Transform3d tr, double shape_scale, const std::pair< float, float > &z_range)
	Create projection for cut surface from mesh.
OrthoProject3d	create_emboss_projection (bool is_outside, float emboss, Transform3d tr, SurfaceCut &cut)
	Create tranformation for emboss Cutted surface.
template<typename Fnc>
TriangleMesh	cut_surface (DataBase &input1, const SurfaceVolumeData &input2, const Fnc &was_canceled)
	Cut surface into triangle mesh.
SurfaceVolumeData::ModelSources	create_sources (const ModelVolumePtrs &volumes, std::optional< size_t > text_volume_id={})
	Copied triangles from object to be able create mesh for cut surface from.
void	create_message (const std::string &message)
bool	process (std::exception_ptr &eptr)
bool	finalize (bool canceled, std::exception_ptr &eptr, const DataBase &input)
auto	was_canceled (const Job::Ctl &ctl, const DataBase &base)
bool	is_valid (ModelVolumeType volume_type)
	Check if volume type is possible use for new text volume.
bool	start_create_volume_job (Worker &worker, const ModelObject &object, const std::optional< Transform3d > &volume_tr, DataBasePtr data, ModelVolumeType volume_type, GLGizmosManager::EType gizmo)
	Start job for add new volume to object with given transformation.
const GLVolume *	find_closest (const Selection &selection, const Vec2d &screen_center, const Camera &camera, const ModelObjectPtrs &objects, Vec2d *closest_center)
	Find volume in selected objects with closest convex hull to screen center.
bool	start_create_object_job (const CreateVolumeParams &input, DataBasePtr emboss_data, const Vec2d &coor)
	Start job for add object with text into scene.
bool	start_create_volume_on_surface_job (CreateVolumeParams &input, DataBasePtr data, const Vec2d &screen_coor, bool try_no_coor)
	Start job to create volume on the surface of object.
template<typename Fnc>
ExPolygons	create_shape (DataBase &input, Fnc was_canceled)
std::vector< BoundingBoxes >	create_line_bounds (const ExPolygonsWithIds &shapes, size_t count_lines=0)
template<typename Fnc>
TriangleMesh	create_mesh_per_glyph (DataBase &input, Fnc was_canceled)
indexed_triangle_set	cut_surface_to_its (const ExPolygons &shapes, const Transform3d &tr, const SurfaceVolumeData::ModelSources &sources, DataBase &input, std::function< bool()> was_canceled)
TriangleMesh	cut_per_glyph_surface (DataBase &input1, const SurfaceVolumeData &input2, std::function< bool()> was_canceled)

Variables
constexpr float	SAFE_SURFACE_OFFSET = 0.015f
constexpr float	safe_extension = 1.0f

Detailed Description

private namespace implementation

---

Class Documentation

anonymous_namespace{EmbossJob.cpp}::DataCreateVolume

struct anonymous_namespace{EmbossJob.cpp}::DataCreateVolume

Hold neccessary data to create ModelVolume in job Volume is created on the surface of existing volume in object. NOTE: EmbossDataBase::font_file doesn't have to be valid !!!

Collaboration diagram for anonymous_namespace{EmbossJob.cpp}::DataCreateVolume:

Class Members
DataBasePtr	base
EType	gizmo
ObjectID	object_id
optional< Transform3d >	trmat
ModelVolumeType	volume_type

anonymous_namespace{EmbossJob.cpp}::DataCreateObject

struct anonymous_namespace{EmbossJob.cpp}::DataCreateObject

Hold neccessary data to create ModelObject in job Object is placed on bed under screen coor OR to center of scene when it is out of bed shape.

Collaboration diagram for anonymous_namespace{EmbossJob.cpp}::DataCreateObject:

Class Members
optional< float >	angle = {}
DataBasePtr	base
vector< Vec2d >	bed_shape
Camera	camera
EType	gizmo
Vec2d	screen_coor

Function Documentation

check() [1/8]

bool anonymous_namespace{EmbossJob.cpp}::check	(	const CreateSurfaceVolumeData &	input,
		bool	is_main_thread = false )

{
    bool use_surface = true;
    assert(input.base != nullptr);
    bool res = input.base != nullptr;
    res &= check(*input.base, is_main_thread, use_surface);
    assert(!input.sources.empty());
    res &= !input.sources.empty();
    res &= check(input.gizmo);
    assert(input.base->shape.projection.use_surface);
    res &= input.base->shape.projection.use_surface;
    return res;
}

References anonymous_namespace{EmbossJob.cpp}::CreateSurfaceVolumeData::base, check(), anonymous_namespace{EmbossJob.cpp}::CreateSurfaceVolumeData::gizmo, Slic3r::EmbossShape::projection, Slic3r::GUI::Emboss::DataBase::shape, Slic3r::GUI::Emboss::SurfaceVolumeData::sources, and Slic3r::EmbossProjection::use_surface.

Here is the call graph for this function:

check() [2/8]

bool anonymous_namespace{EmbossJob.cpp}::check

(

const CreateVolumeParams &

input

)

{
    bool res        = is_valid(input.volume_type);
    auto gizmo_type = static_cast<GLGizmosManager::EType>(input.gizmo);
    res &= ::check(gizmo_type);
    return res;
}

References check(), Slic3r::GUI::Emboss::CreateVolumeParams::gizmo, is_valid(), and Slic3r::GUI::Emboss::CreateVolumeParams::volume_type.

Here is the call graph for this function:

check() [3/8]

bool anonymous_namespace{EmbossJob.cpp}::check	(	const DataBase &	input,
		bool	check_fontfile = true,
		bool	use_surface = false )

Assert check of inputs data.

{
    bool res = true;
    // if (check_fontfile) {
    //     assert(input.font_file.has_value());
    //     res &= input.font_file.has_value();
    // }
    // assert(!input.text_configuration.fix_3mf_tr.has_value());
    // res &= !input.text_configuration.fix_3mf_tr.has_value();
    // assert(!input.text_configuration.text.empty());
    // res &= !input.text_configuration.text.empty();
    assert(!input.volume_name.empty());
    res &= !input.volume_name.empty();
    //const FontProp& prop = input.text_configuration.style.prop;
    //assert(prop.per_glyph == !input.text_lines.empty());
    //res &= prop.per_glyph == !input.text_lines.empty();
    //if (prop.per_glyph) {
    //    assert(get_count_lines(input.text_configuration.text) == input.text_lines.size());
    //    res &= get_count_lines(input.text_configuration.text) == input.text_lines.size();
    //}
    return res; 
}

References check(), and Slic3r::GUI::Emboss::DataBase::volume_name.

Referenced by anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::CreateObjectJob(), anonymous_namespace{EmbossJob.cpp}::CreateSurfaceVolumeJob::CreateSurfaceVolumeJob(), anonymous_namespace{EmbossJob.cpp}::CreateVolumeJob::CreateVolumeJob(), check(), check(), check(), check(), check(), check(), check(), check(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::process(), anonymous_namespace{EmbossJob.cpp}::CreateSurfaceVolumeJob::process(), and anonymous_namespace{EmbossJob.cpp}::CreateVolumeJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

check() [4/8]

bool anonymous_namespace{EmbossJob.cpp}::check

(

const DataCreateObject &

input

)

{
    bool check_fontfile = false;
    assert(input.base != nullptr);
    bool res = input.base != nullptr;
    res &= check(*input.base, check_fontfile);
    assert(input.screen_coor.x() >= 0.);
    res &= input.screen_coor.x() >= 0.;
    assert(input.screen_coor.y() >= 0.);
    res &= input.screen_coor.y() >= 0.;
    assert(input.bed_shape.size() >= 3); // at least triangle
    res &= input.bed_shape.size() >= 3;
    res &= check(input.gizmo);
    assert(!input.base->shape.projection.use_surface);
    res &= !input.base->shape.projection.use_surface;
    return res;
}

References anonymous_namespace{EmbossJob.cpp}::DataCreateObject::base, anonymous_namespace{EmbossJob.cpp}::DataCreateObject::bed_shape, check(), anonymous_namespace{EmbossJob.cpp}::DataCreateObject::gizmo, Slic3r::EmbossShape::projection, anonymous_namespace{EmbossJob.cpp}::DataCreateObject::screen_coor, Slic3r::GUI::Emboss::DataBase::shape, and Slic3r::EmbossProjection::use_surface.

Here is the call graph for this function:

check() [5/8]

bool anonymous_namespace{EmbossJob.cpp}::check	(	const DataCreateVolume &	input,
		bool	is_main_thread = false )

{
    bool check_fontfile = false;
    assert(input.base != nullptr);
    bool res = input.base != nullptr;
    res &= check(*input.base, check_fontfile);
    res &= is_valid(input.volume_type);
    res &= check(input.gizmo);
    assert(!input.base->shape.projection.use_surface);
    res &= !input.base->shape.projection.use_surface;
    return res;
}

References anonymous_namespace{EmbossJob.cpp}::DataCreateVolume::base, check(), anonymous_namespace{EmbossJob.cpp}::DataCreateVolume::gizmo, is_valid(), Slic3r::EmbossShape::projection, Slic3r::GUI::Emboss::DataBase::shape, Slic3r::EmbossProjection::use_surface, and anonymous_namespace{EmbossJob.cpp}::DataCreateVolume::volume_type.

Here is the call graph for this function:

check() [6/8]

bool anonymous_namespace{EmbossJob.cpp}::check	(	const DataUpdate &	input,
		bool	is_main_thread = false,
		bool	use_surface = false )

{
    bool check_fontfile = true;
    assert(input.base != nullptr);
    bool res = input.base != nullptr;
    res &= check(*input.base, check_fontfile, use_surface);
    if (is_main_thread)
        assert(get_model_volume(input.volume_id, wxGetApp().model().objects) != nullptr);
    assert(input.base->cancel != nullptr);
    res &= input.base->cancel != nullptr;
    if (is_main_thread)
        assert(!input.base->cancel->load());
    assert(!input.base->shape.projection.use_surface);
    res &= !input.base->shape.projection.use_surface;
    return res;
}

References Slic3r::GUI::Emboss::DataUpdate::base, Slic3r::GUI::Emboss::DataBase::cancel, check(), Slic3r::GUI::get_model_volume(), Slic3r::EmbossShape::projection, Slic3r::GUI::Emboss::DataBase::shape, Slic3r::EmbossProjection::use_surface, and Slic3r::GUI::Emboss::DataUpdate::volume_id.

Here is the call graph for this function:

check() [7/8]

bool anonymous_namespace{EmbossJob.cpp}::check	(	const UpdateSurfaceVolumeData &	input,
		bool	is_main_thread = false )

{
    bool use_surface = true;
    assert(input.base != nullptr);
    bool res = input.base != nullptr;
    res &= check(*input.base, is_main_thread, use_surface);
    assert(!input.sources.empty());
    res &= !input.sources.empty();
    assert(input.base->shape.projection.use_surface);
    res &= input.base->shape.projection.use_surface;
    return res;
}

References Slic3r::GUI::Emboss::DataUpdate::base, check(), Slic3r::EmbossShape::projection, Slic3r::GUI::Emboss::DataBase::shape, Slic3r::GUI::Emboss::SurfaceVolumeData::sources, and Slic3r::EmbossProjection::use_surface.

Here is the call graph for this function:

check() [8/8]

bool anonymous_namespace{EmbossJob.cpp}::check

(

GLGizmosManager::EType

gizmo

)

{
    assert(gizmo == GLGizmosManager::Emboss || gizmo == GLGizmosManager::Svg);
    return gizmo == GLGizmosManager::Emboss || gizmo == GLGizmosManager::Svg;
}

References check(), Slic3r::GUI::GLGizmosManager::Emboss, and Slic3r::GUI::GLGizmosManager::Svg.

Here is the call graph for this function:

create_default_mesh()

TriangleMesh anonymous_namespace{EmbossJob.cpp}::create_default_mesh

(

)

Create default mesh for embossed text.

Returns

Not empty model(index trinagle set - its)

{
    // When cant load any font use default object loaded from file
    std::string  path = Slic3r::resources_dir() + "/data/embossed_text.obj";
    TriangleMesh triangle_mesh;
    std::string  message;
    ObjInfo                 obj_info;
    if (!load_obj(path.c_str(), &triangle_mesh, obj_info, message)) {
        // when can't load mesh use cube
        return TriangleMesh(its_make_cube(36., 4., 2.5));
    }
    return triangle_mesh;
}

References create_default_mesh(), Slic3r::its_make_cube(), Slic3r::load_obj(), and Slic3r::resources_dir().

Referenced by create_default_mesh(), and create_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

create_emboss_projection()

OrthoProject3d anonymous_namespace{EmbossJob.cpp}::create_emboss_projection	(	bool	is_outside,
		float	emboss,
		Transform3d	tr,
		SurfaceCut &	cut )

Create tranformation for emboss Cutted surface.

Parameters

is_outside	True .. raise, False .. engrave
emboss	Depth of embossing
tr	Text voliume transformation inside object
cut	Cutted surface from model

Returns

Projection

{
    float 
        front_move = (is_outside) ? emboss : SAFE_SURFACE_OFFSET,
        back_move  = -((is_outside) ? SAFE_SURFACE_OFFSET : emboss);    
    its_transform(cut, tr.pretranslate(Vec3d(0., 0., front_move)));    
    Vec3d from_front_to_back(0., 0., back_move - front_move);
    return OrthoProject3d(from_front_to_back);
}

References create_emboss_projection(), and SAFE_SURFACE_OFFSET.

Referenced by create_emboss_projection(), and cut_surface_to_its().

Here is the call graph for this function:

Here is the caller graph for this function:

create_line_bounds()

std::vector< BoundingBoxes > anonymous_namespace{EmbossJob.cpp}::create_line_bounds	(	const ExPolygonsWithIds &	shapes,
		size_t	count_lines = 0 )

{
    if (count_lines == 0)
        count_lines = get_count_lines(shapes);
    assert(count_lines == get_count_lines(shapes));
 
    std::vector<BoundingBoxes> result(count_lines);
    size_t text_line_index = 0;
    // s_i .. shape index
    for (const ExPolygonsWithId &shape_id: shapes) {
        const ExPolygons &shape = shape_id.expoly;
        BoundingBox       bb;
        if (!shape.empty()) {
            bb = get_extents(shape);
        }
        BoundingBoxes &line_bbs = result[text_line_index];
        line_bbs.push_back(bb);
        if (shape_id.id == ENTER_UNICODE) {
            // skip enters on beginig and tail
            ++text_line_index;
        }
    }
    return result;
}

References create_line_bounds(), Slic3r::Emboss::ENTER_UNICODE, Slic3r::Emboss::get_count_lines(), and Slic3r::get_extents().

Referenced by create_line_bounds(), create_mesh_per_glyph(), and cut_per_glyph_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

create_mesh()

template<typename Fnc>

TriangleMesh anonymous_namespace{EmbossJob.cpp}::create_mesh	(	DataBase &	input,
		const Fnc &	was_canceled,
		Job::Ctl &	ctl )

{
    // It is neccessary to create some shape
    // Emboss text window is opened by creation new emboss text object
    TriangleMesh result = try_create_mesh(input, was_canceled);
    if (was_canceled())
        return {};
 
    if (result.its.empty()) {
        result = create_default_mesh();
        if (was_canceled())
            return {};
        // only info
        ctl.call_on_main_thread([]() {
            create_message(_u8L("It is used default volume for embossed text, try to change text or font to fix it."));
        });
    }
 
    assert(!result.its.empty());
    return result;
}

References _u8L, Slic3r::GUI::Job::Ctl::call_on_main_thread(), create_default_mesh(), create_message(), Slic3r::TriangleMesh::its, try_create_mesh(), and was_canceled().

Referenced by anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::process(), and anonymous_namespace{EmbossJob.cpp}::CreateVolumeJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

create_mesh_per_glyph()

template<typename Fnc>

TriangleMesh anonymous_namespace{EmbossJob.cpp}::create_mesh_per_glyph	(	DataBase &	input,
		Fnc	was_canceled )

{
    // method use square of coord stored into int64_t
    // static_assert(std::is_same<Point::coord_type, int32_t>());
    const EmbossShape &shape = input.create_shape();
    if (shape.shapes_with_ids.empty())
        return {};
    
    // Precalculate bounding boxes of glyphs
    // Separate lines of text to vector of Bounds
    assert(get_count_lines(shape.shapes_with_ids) == input.text_lines.size());
    size_t count_lines = input.text_lines.size();
    std::vector<BoundingBoxes> bbs = create_line_bounds(shape.shapes_with_ids, count_lines);
        
    double depth = shape.projection.depth / shape.scale;
    auto scale_tr = Eigen::Scaling(shape.scale); 
    
    // half of font em size for direction of letter emboss
    // double  em_2_mm      = prop.size_in_mm / 2.; // TODO: fix it
    double em_2_mm = 5.;
    coord_t em_2_polygon = static_cast<coord_t>(std::round(scale_(em_2_mm)));
 
    size_t s_i_offset = 0; // shape index offset(for next lines)
    indexed_triangle_set result;
    for (size_t text_line_index = 0; text_line_index < input.text_lines.size(); ++text_line_index) {
        const BoundingBoxes &line_bbs = bbs[text_line_index];
        const TextLine      &line     = input.text_lines[text_line_index];
        PolygonPoints        samples  = sample_slice(line, line_bbs, shape.scale);
        std::vector<double>  angles   = calculate_angles(em_2_polygon, samples, line.polygon);
 
        for (size_t i = 0; i < line_bbs.size(); ++i) {
            const BoundingBox &letter_bb = line_bbs[i];
            if (!letter_bb.defined)
                continue;
 
            Vec2d to_zero_vec = letter_bb.center().cast<double>() * shape.scale; // [in mm]
            float surface_offset = input.is_outside ? -SAFE_SURFACE_OFFSET : (-shape.projection.depth + SAFE_SURFACE_OFFSET);
            
            if (input.from_surface.has_value())
                surface_offset += *input.from_surface;
 
            Eigen::Translation<double, 3> to_zero(-to_zero_vec.x(), 0., static_cast<double>(surface_offset));
 
            const double &angle = angles[i];
            Eigen::AngleAxisd rotate(angle + M_PI_2, Vec3d::UnitY());
 
            const PolygonPoint &sample = samples[i];
            Vec2d offset_vec = unscale(sample.point); // [in mm]
            Eigen::Translation<double, 3> offset_tr(offset_vec.x(), 0., -offset_vec.y());
            Transform3d tr = offset_tr * rotate * to_zero * scale_tr;
 
            const ExPolygons &letter_shape = shape.shapes_with_ids[s_i_offset + i].expoly;
            assert(get_extents(letter_shape) == letter_bb);
            auto projectZ = std::make_unique<ProjectZ>(depth);
            ProjectTransform project(std::move(projectZ), tr);
            indexed_triangle_set glyph_its = polygons2model(letter_shape, project);
            its_merge(result, std::move(glyph_its));
 
            if (((s_i_offset + i) % 15) && was_canceled())
                return {};
        }
        s_i_offset += line_bbs.size();
 
#ifdef STORE_SAMPLING
        { // Debug store polygon
            //std::string stl_filepath = "C:/data/temp/line" + std::to_string(text_line_index) + "_model.stl";
            //bool suc = its_write_stl_ascii(stl_filepath.c_str(), "label", result);
 
            BoundingBox bbox      = get_extents(line.polygon);
            std::string file_path = "C:/data/temp/line" + std::to_string(text_line_index) + "_letter_position.svg";
            SVG         svg(file_path, bbox);
            svg.draw(line.polygon);
            int32_t radius = bbox.size().x() / 300; 
            for (size_t i = 0; i < samples.size(); i++) {
                const PolygonPoint &pp = samples[i];
                const Point& p = pp.point;
                svg.draw(p, "green", radius);
                std::string label = std::string(" ")+tc.text[i];
                svg.draw_text(p, label.c_str(), "black");
 
                double a = angles[i];
                double length = 3.0 * radius;
                Point  n(length * std::cos(a), length * std::sin(a));
                svg.draw(Slic3r::Line(p - n, p + n), "Lime");
            }
        }
#endif // STORE_SAMPLING
    }
    return TriangleMesh(std::move(result));
}

References Slic3r::angle(), Slic3r::Emboss::calculate_angles(), Slic3r::BoundingBoxBase< PointType, APointsType >::center(), create_line_bounds(), create_mesh_per_glyph(), Slic3r::GUI::Emboss::DataBase::create_shape(), Slic3r::BoundingBoxBase< PointType, APointsType >::defined, Slic3r::EmbossProjection::depth, Slic3r::SVG::draw(), Slic3r::SVG::draw_text(), Slic3r::GUI::Emboss::DataBase::from_surface, Slic3r::Emboss::get_count_lines(), Slic3r::get_extents(), Slic3r::GUI::Emboss::DataBase::is_outside, Slic3r::its_merge(), Slic3r::length(), Slic3r::PolygonPoint::point, Slic3r::Emboss::TextLine::polygon, Slic3r::Emboss::polygons2model(), Slic3r::EmbossShape::projection, SAFE_SURFACE_OFFSET, Slic3r::Emboss::sample_slice(), Slic3r::EmbossShape::scale, scale_, Slic3r::EmbossShape::shapes_with_ids, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::GUI::Emboss::DataBase::text_lines, Slic3r::unscale(), and was_canceled().

Referenced by create_mesh_per_glyph(), and try_create_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message()

void anonymous_namespace{EmbossJob.cpp}::create_message

(

const std::string &

message

)

                                              {
    show_error(nullptr, message.c_str());
}

References create_message(), and Slic3r::GUI::show_error().

Referenced by create_mesh(), create_message(), create_volume(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), anonymous_namespace{EmbossJob.cpp}::CreateVolumeJob::finalize(), process(), and update_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

create_projection_for_cut()

OrthoProject anonymous_namespace{EmbossJob.cpp}::create_projection_for_cut	(	Transform3d	tr,
		double	shape_scale,
		const std::pair< float, float > &	z_range )

Create projection for cut surface from mesh.

Parameters

tr	Volume transformation in object
shape_scale	Convert shape to millimeters
z_range	Bounding box 3d of model volume for projection ranges

Returns

Orthogonal cut_projection

{
    double min_z = z_range.first - safe_extension;
    double max_z = z_range.second + safe_extension;
    assert(min_z < max_z);
    // range between min and max value
    double   projection_size           = max_z - min_z;
    Matrix3d transformation_for_vector = tr.linear();
    // Projection must be negative value.
    // System of text coordinate
    // X .. from left to right
    // Y .. from bottom to top
    // Z .. from text to eye
    Vec3d untransformed_direction(0., 0., projection_size);
    Vec3d project_direction = transformation_for_vector * untransformed_direction;
 
    // Projection is in direction from far plane
    tr.translate(Vec3d(0., 0., min_z));
    tr.scale(shape_scale);
    return OrthoProject(tr, project_direction);
}

References create_projection_for_cut(), and safe_extension.

Referenced by create_projection_for_cut(), and cut_surface_to_its().

Here is the call graph for this function:

Here is the caller graph for this function:

create_shape() [1/2]

template<typename Fnc>

ExPolygons anonymous_namespace{EmbossJob.cpp}::create_shape	(	DataBase &	input,
		Fnc	was_canceled )

                                                           {
    EmbossShape &es = input.create_shape();
    // TODO: improve to use real size of volume
    // ... need world matrix for volume
    // ... printer resolution will be fine too
    return union_with_delta(es, UNION_DELTA, UNION_MAX_ITERATIN);
}

References create_shape(), Slic3r::GUI::Emboss::DataBase::create_shape(), Slic3r::Emboss::UNION_DELTA, Slic3r::Emboss::UNION_MAX_ITERATIN, Slic3r::union_with_delta(), and was_canceled().

Referenced by create_shape(), cut_surface(), and try_create_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

create_shape() [2/2]

template<typename Fnc>

ExPolygons anonymous_namespace{EmbossJob.cpp}::create_shape ( DataBase & input, Fnc was_canceled )

static

                                                           {
    EmbossShape &es = input.create_shape();
    // TODO: improve to use real size of volume
    // ... need world matrix for volume
    // ... printer resolution will be fine too
    return union_with_delta(es, UNION_DELTA, UNION_MAX_ITERATIN);
}

References create_shape(), Slic3r::GUI::Emboss::DataBase::create_shape(), Slic3r::Emboss::UNION_DELTA, Slic3r::Emboss::UNION_MAX_ITERATIN, Slic3r::union_with_delta(), and was_canceled().

Referenced by create_shape(), cut_surface(), and try_create_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

create_sources()

SurfaceVolumeData::ModelSources anonymous_namespace{EmbossJob.cpp}::create_sources	(	const ModelVolumePtrs &	volumes,
		std::optional< size_t >	text_volume_id = {} )

Copied triangles from object to be able create mesh for cut surface from.

Parameters

volumes	Source object volumes for cut surface from
text_volume_id	Source volume id

Returns

Source data for cut surface from

{
    SurfaceVolumeData::ModelSources result;
    result.reserve(volumes.size() - 1);
    for (const ModelVolume *v : volumes) {
        if (text_volume_id.has_value() && v->id().id == *text_volume_id)
            continue;
        // skip modifiers and negative volumes, ...
        if (!v->is_model_part())
            continue;
        const TriangleMesh &tm = v->mesh();
        if (tm.empty())
            continue;
        if (tm.its.empty())
            continue;
        result.push_back({v->get_mesh_shared_ptr(), v->get_matrix()});
    }
    return result;
}

References create_sources(), Slic3r::TriangleMesh::empty(), and Slic3r::TriangleMesh::its.

Referenced by create_sources(), and start_create_volume_job().

Here is the call graph for this function:

Here is the caller graph for this function:

create_volume()

void anonymous_namespace{EmbossJob.cpp}::create_volume	(	TriangleMesh &&	mesh,
		const ObjectID &	object_id,
		const ModelVolumeType	type,
		const std::optional< Transform3d > &	trmat,
		const DataBase &	data,
		GLGizmosManager::EType	gizmo )

Add new volume to object.

Parameters

mesh	triangles of new volume
object_id	Object where to add volume
type	Type of new volume
trmat	Transformation of volume inside of object
data	Text configuration and New VolumeName
gizmo	Gizmo to open

{
    GUI_App         &app      = wxGetApp();
    Plater          *plater   = app.plater();
    ObjectList      *obj_list = app.obj_list();
    GLCanvas3D      *canvas   = plater->get_view3D_canvas3D();
    ModelObjectPtrs &objects  = plater->model().objects;
 
    ModelObject *obj        = nullptr;
    size_t       object_idx = 0;
    for (; object_idx < objects.size(); ++object_idx) {
        ModelObject *o = objects[object_idx];
        if (o->id() == object_id) {
            obj = o;
            break;
        }
    }
 
    // Parent object for text volume was propably removed.
    // Assumption: User know what he does, so text volume is no more needed.
    if (obj == nullptr) 
        return create_message(_u8L("Bad object to create volume."));
 
    if (mesh.its.empty()) 
        return create_message(_u8L("Can't create empty volume."));
 
    plater->take_snapshot(_u8L("Add Emboss text Volume"));
 
    BoundingBoxf3 instance_bb;
    if (!trmat.has_value()) {
        // used for align to instance
        size_t instance_index = 0; // must exist
        instance_bb           = obj->instance_bounding_box(instance_index);
    }
 
    // NOTE: be carefull add volume also center mesh !!!
    // So first add simple shape(convex hull is also calculated)
    ModelVolume *volume = obj->add_volume(make_cube(1., 1., 1.), type);
 
    // TODO: Refactor to create better way to not set cube at begining
    // Revert mesh centering by set mesh after add cube
    volume->set_mesh(std::move(mesh));
    volume->calculate_convex_hull();
 
    // set a default extruder value, since user can't add it manually
    volume->config.set_key_value("extruder", new ConfigOptionInt(0));
 
    // do not allow model reload from disk
    volume->source.is_from_builtin_objects = true;
 
    volume->name = data.volume_name; // copy
 
    if (trmat.has_value()) {
        volume->set_transformation(*trmat);
    } else {
        assert(!data.shape.projection.use_surface);
        // Create transformation for volume near from object(defined by glVolume)
        // Transformation is inspired add generic volumes in ObjectList::load_generic_subobject
        Vec3d volume_size = volume->mesh().bounding_box().size();
        // Translate the new modifier to be pickable: move to the left front corner of the instance's bounding box, lift to print bed.
        Vec3d offset_tr(0, // center of instance - Can't suggest width of text before it will be created
                        -instance_bb.size().y() / 2 - volume_size.y() / 2, // under
                        volume_size.z() / 2 - instance_bb.size().z() / 2); // lay on bed
        // use same instance as for calculation of instance_bounding_box
        Transform3d tr           = obj->instances.front()->get_transformation().get_matrix_no_offset().inverse();
        Transform3d volume_trmat = tr * Eigen::Translation3d(offset_tr);
        volume->set_transformation(volume_trmat);
    }
 
    data.write(*volume);
 
    // update printable state on canvas
    if (type == ModelVolumeType::MODEL_PART) {
        volume->get_object()->ensure_on_bed();
        canvas->update_instance_printable_state_for_object(object_idx);
    }
 
    // update volume name in object list
    // updata selection after new volume added
    // change name of volume in right panel
    // select only actual volume
    // when new volume is created change selection to this volume
    auto                add_to_selection = [volume](const ModelVolume *vol) { return vol == volume; };
    wxDataViewItemArray sel              = obj_list->reorder_volumes_and_get_selection(object_idx, add_to_selection);
    if (!sel.IsEmpty())
        obj_list->select_item(sel.front());
 
    obj_list->selection_changed();
 
    // Now is valid text volume selected open emboss gizmo
    GLGizmosManager &manager = canvas->get_gizmos_manager();
    if (manager.get_current_type() != gizmo)
        manager.open_gizmo(gizmo);
 
    // update model and redraw scene
    //canvas->reload_scene(true);
    plater->update();
}

References _u8L, Slic3r::ModelObject::add_volume(), Slic3r::TriangleMesh::bounding_box(), Slic3r::ModelVolume::calculate_convex_hull(), Slic3r::ModelVolume::config, create_message(), create_volume(), Slic3r::ModelObject::ensure_on_bed(), Slic3r::GUI::GLGizmosManager::get_current_type(), Slic3r::GUI::GLCanvas3D::get_gizmos_manager(), Slic3r::ModelVolume::get_object(), Slic3r::ObjectBase::id(), Slic3r::ModelObject::instance_bounding_box(), Slic3r::ModelObject::instances, Slic3r::ModelVolume::Source::is_from_builtin_objects, Slic3r::make_cube(), Slic3r::ModelVolume::mesh(), Slic3r::MODEL_PART, Slic3r::ModelVolume::name, Slic3r::GUI::GUI_App::obj_list(), Slic3r::GUI::obj_list(), Slic3r::GUI::GLGizmosManager::open_gizmo(), Slic3r::GUI::GUI_App::plater(), Slic3r::GUI::plater(), Slic3r::EmbossShape::projection, Slic3r::ModelConfig::set_key_value(), Slic3r::ModelVolume::set_mesh(), Slic3r::ModelVolume::set_transformation(), Slic3r::GUI::Emboss::DataBase::shape, Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::ModelVolume::source, Slic3r::GUI::GLCanvas3D::update_instance_printable_state_for_object(), Slic3r::EmbossProjection::use_surface, Slic3r::GUI::Emboss::DataBase::volume_name, and Slic3r::GUI::Emboss::DataBase::write().

Referenced by create_volume(), anonymous_namespace{EmbossJob.cpp}::CreateSurfaceVolumeJob::finalize(), and anonymous_namespace{EmbossJob.cpp}::CreateVolumeJob::finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

cut_per_glyph_surface()

TriangleMesh anonymous_namespace{EmbossJob.cpp}::cut_per_glyph_surface	(	DataBase &	input1,
		const SurfaceVolumeData &	input2,
		std::function< bool()>	was_canceled )

{
    // Precalculate bounding boxes of glyphs
    // Separate lines of text to vector of Bounds
    const EmbossShape &es = input1.create_shape();
    if (was_canceled()) return {};
    if (es.shapes_with_ids.empty())
        throw JobException(_u8L("Font doesn't have any shape for given text.").c_str());
 
    assert(get_count_lines(es.shapes_with_ids) == input1.text_lines.size());
    size_t count_lines = input1.text_lines.size();
    std::vector<BoundingBoxes> bbs = create_line_bounds(es.shapes_with_ids, count_lines);
        
    // half of font em size for direction of letter emboss
    double  em_2_mm      = 5.; // TODO: fix it
    int32_t em_2_polygon = static_cast<int32_t>(std::round(scale_(em_2_mm)));
 
    size_t s_i_offset = 0; // shape index offset(for next lines)
    indexed_triangle_set result;
    for (size_t text_line_index = 0; text_line_index < input1.text_lines.size(); ++text_line_index) {
        const BoundingBoxes &line_bbs = bbs[text_line_index];
        const TextLine      &line     = input1.text_lines[text_line_index];
        PolygonPoints        samples  = sample_slice(line, line_bbs, es.scale);
        std::vector<double>  angles   = calculate_angles(em_2_polygon, samples, line.polygon);
 
        for (size_t i = 0; i < line_bbs.size(); ++i) {
            const BoundingBox &glyph_bb = line_bbs[i];
            if (!glyph_bb.defined)
                continue;
 
            const double &angle = angles[i];
            auto rotate = Eigen::AngleAxisd(angle + M_PI_2, Vec3d::UnitY());
 
            const PolygonPoint &sample = samples[i];
            Vec2d offset_vec = unscale(sample.point); // [in mm]
            auto offset_tr = Eigen::Translation<double, 3>(offset_vec.x(), 0., -offset_vec.y());
 
            ExPolygons glyph_shape = es.shapes_with_ids[s_i_offset + i].expoly;
            assert(get_extents(glyph_shape) == glyph_bb);
 
            Point offset(-glyph_bb.center().x(), 0);
            for (ExPolygon& s: glyph_shape)
                s.translate(offset);
 
            Transform3d modify = offset_tr * rotate;
            Transform3d tr = input2.transform * modify;
            indexed_triangle_set glyph_its = cut_surface_to_its(glyph_shape, tr, input2.sources, input1, was_canceled);
            // move letter in volume on the right position
            its_transform(glyph_its, modify);
 
            // Improve: union instead of merge
            its_merge(result, std::move(glyph_its));
 
            if (((s_i_offset + i) % 15) && was_canceled())
                return {};
        }
        s_i_offset += line_bbs.size();
    }
 
    if (was_canceled()) return {};    
    if (result.empty()) 
        throw JobException(_u8L("There is no valid surface for text projection.").c_str());
    return TriangleMesh(std::move(result));
}

References _u8L, Slic3r::angle(), Slic3r::Emboss::calculate_angles(), Slic3r::BoundingBoxBase< PointType, APointsType >::center(), create_line_bounds(), Slic3r::GUI::Emboss::DataBase::create_shape(), cut_per_glyph_surface(), cut_surface_to_its(), Slic3r::BoundingBoxBase< PointType, APointsType >::defined, Slic3r::Emboss::get_count_lines(), Slic3r::get_extents(), Slic3r::its_merge(), Slic3r::offset(), Slic3r::PolygonPoint::point, Slic3r::Emboss::TextLine::polygon, Slic3r::Emboss::sample_slice(), Slic3r::EmbossShape::scale, scale_, Slic3r::EmbossShape::shapes_with_ids, Slic3r::GUI::Emboss::SurfaceVolumeData::sources, Slic3r::GUI::Emboss::DataBase::text_lines, Slic3r::GUI::Emboss::SurfaceVolumeData::transform, Slic3r::unscale(), and was_canceled().

Referenced by cut_per_glyph_surface(), and cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

cut_surface()

template<typename Fnc>

TriangleMesh anonymous_namespace{EmbossJob.cpp}::cut_surface	(	DataBase &	input1,
		const SurfaceVolumeData &	input2,
		const Fnc &	was_canceled )

Cut surface into triangle mesh.

Parameters

base	(can't be const - cache of font)
input2	SurfaceVolume data
was_canceled	Check to interupt execution

Returns

Extruded object from cuted surace

{
    if (!input1.text_lines.empty())
        return cut_per_glyph_surface(input1, input2, was_canceled);
    
    ExPolygons shapes = create_shape(input1, was_canceled);
    if (was_canceled()) return {};
    if (shapes.empty())
        throw JobException(_u8L("Font doesn't have any shape for given text.").c_str());
 
    indexed_triangle_set its = cut_surface_to_its(shapes, input2.transform, input2.sources, input1, was_canceled);
    if (was_canceled()) return {};    
    if (its.empty()) 
        throw JobException(_u8L("There is no valid surface for text projection.").c_str());    
 
    return TriangleMesh(std::move(its));
}

References _u8L, create_shape(), cut_per_glyph_surface(), cut_surface_to_its(), Slic3r::GUI::Emboss::SurfaceVolumeData::sources, Slic3r::GUI::Emboss::DataBase::text_lines, Slic3r::GUI::Emboss::SurfaceVolumeData::transform, and was_canceled().

Referenced by anonymous_namespace{EmbossJob.cpp}::CreateSurfaceVolumeJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

cut_surface_to_its()

indexed_triangle_set anonymous_namespace{EmbossJob.cpp}::cut_surface_to_its	(	const ExPolygons &	shapes,
		const Transform3d &	tr,
		const SurfaceVolumeData::ModelSources &	sources,
		DataBase &	input,
		std::function< bool()>	was_canceled )

                                                                                                                                                                                         {
    assert(!sources.empty());
    BoundingBox bb = get_extents(shapes);
    double shape_scale = input.shape.scale;
 
    const SurfaceVolumeData::ModelSource *biggest = &sources.front();
 
    size_t biggest_count = 0;
    // convert index from (s)ources to (i)ndexed (t)riangle (s)ets
    std::vector<size_t> s_to_itss(sources.size(), std::numeric_limits<size_t>::max());
    std::vector<indexed_triangle_set>  itss;
    itss.reserve(sources.size());
    for (const SurfaceVolumeData::ModelSource &s : sources) {
        Transform3d mesh_tr_inv       = s.tr.inverse();
        Transform3d cut_projection_tr = mesh_tr_inv * tr;
        std::pair<float, float> z_range{0., 1.};
        OrthoProject    cut_projection = create_projection_for_cut(cut_projection_tr, shape_scale, z_range);
        // copy only part of source model
        indexed_triangle_set its = its_cut_AoI(s.mesh->its, bb, cut_projection);
        if (its.indices.empty())
            continue;
        if (biggest_count < its.vertices.size()) {
            biggest_count = its.vertices.size();
            biggest       = &s;
        }
        size_t source_index     = &s - &sources.front();
        size_t its_index        = itss.size();
        s_to_itss[source_index] = its_index;
        itss.emplace_back(std::move(its));
    }
    if (itss.empty())
        return {};
 
    Transform3d tr_inv = biggest->tr.inverse();
    Transform3d cut_projection_tr = tr_inv * tr;
 
    size_t itss_index = s_to_itss[biggest - &sources.front()];
    BoundingBoxf3 mesh_bb    = bounding_box(itss[itss_index]);
    for (const SurfaceVolumeData::ModelSource &s : sources) {
        itss_index = s_to_itss[&s - &sources.front()];
        if (itss_index == std::numeric_limits<size_t>::max())
            continue;
        if (&s == biggest)
            continue;
 
        Transform3d           tr  = s.tr * tr_inv;
        bool        fix_reflected = true;
        indexed_triangle_set &its = itss[itss_index];
        its_transform(its, tr, fix_reflected);
        BoundingBoxf3 its_bb = bounding_box(its);
        mesh_bb.merge(its_bb);
    }
 
    // tr_inv = transformation of mesh inverted
    Transform3d             emboss_tr  = cut_projection_tr.inverse();
    BoundingBoxf3           mesh_bb_tr = mesh_bb.transformed(emboss_tr);
    std::pair<float, float> z_range{mesh_bb_tr.min.z(), mesh_bb_tr.max.z()};
    OrthoProject cut_projection = create_projection_for_cut(cut_projection_tr, shape_scale, z_range);
    float projection_ratio = (-z_range.first + safe_extension) / 
                              (z_range.second - z_range.first + 2 * safe_extension);
 
    ExPolygons shapes_data; // is used only when text is reflected to reverse polygon points order
    const ExPolygons *shapes_ptr = &shapes;
    bool is_text_reflected = Slic3r::has_reflection(tr);
    if (is_text_reflected) {
        // revert order of points in expolygons
        // CW --> CCW
        shapes_data = shapes; // copy
        for (ExPolygon &shape : shapes_data) {
            shape.contour.reverse();
            for (Slic3r::Polygon &hole : shape.holes)
                hole.reverse();
        }
        shapes_ptr = &shapes_data;
    }
 
    // Use CGAL to cut surface from triangle mesh
    SurfaceCut cut = cut_surface(*shapes_ptr, itss, cut_projection, projection_ratio);
 
    if (is_text_reflected) {
        for (SurfaceCut::Contour &c : cut.contours)
            std::reverse(c.begin(), c.end());
        for (Vec3i32 &t : cut.indices)
            std::swap(t[0], t[1]);
    }
 
    if (cut.empty()) return {}; // There is no valid surface for text projection.
    if (was_canceled()) return {};
 
    // !! Projection needs to transform cut
    OrthoProject3d projection = create_emboss_projection(input.is_outside, input.shape.projection.depth, emboss_tr, cut);
    return cut2model(cut, projection);
}

References Slic3r::bounding_box(), Slic3r::SurfaceCut::contours, create_emboss_projection(), create_projection_for_cut(), Slic3r::cut2model(), Slic3r::cut_surface(), cut_surface_to_its(), Slic3r::EmbossProjection::depth, Slic3r::get_extents(), Slic3r::has_reflection(), Slic3r::GUI::Emboss::DataBase::is_outside, Slic3r::its_cut_AoI(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::EmbossShape::projection, Slic3r::MultiPoint::reverse(), safe_extension, Slic3r::EmbossShape::scale, Slic3r::GUI::Emboss::DataBase::shape, Slic3r::GUI::Emboss::SurfaceVolumeData::ModelSource::tr, Slic3r::BoundingBoxf3::transformed(), and was_canceled().

Referenced by cut_per_glyph_surface(), cut_surface(), and cut_surface_to_its().

Here is the call graph for this function:

Here is the caller graph for this function:

finalize()

bool anonymous_namespace{EmbossJob.cpp}::finalize	(	bool	canceled,
		std::exception_ptr &	eptr,
		const DataBase &	input )

{
    // doesn't care about exception when process was canceled by user
    if (canceled || input.cancel->load()) {
        eptr = nullptr;
        return false;
    }
    return !process(eptr);
}

References Slic3r::GUI::Emboss::DataBase::cancel, finalize(), and process().

Referenced by finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

find_closest()

const GLVolume * anonymous_namespace{EmbossJob.cpp}::find_closest	(	const Selection &	selection,
		const Vec2d &	screen_center,
		const Camera &	camera,
		const ModelObjectPtrs &	objects,
		Vec2d *	closest_center )

Find volume in selected objects with closest convex hull to screen center.

Parameters

selection	Define where to search for closest
screen_center	Canvas center(dependent on camera settings)
objects	Actual objects
closest_center	OUT: coordinate of controid of closest volume

Returns

closest volume when exists otherwise nullptr

{
    assert(closest_center != nullptr);
    const GLVolume               *closest = nullptr;
    const Selection::IndicesList &indices = selection.get_volume_idxs();
    assert(!indices.empty()); // no selected volume
    if (indices.empty())
        return closest;
 
    double center_sq_distance = std::numeric_limits<double>::max();
    for (unsigned int id : indices) {
        const GLVolume    *gl_volume = selection.get_volume(id);        
        if (const ModelVolume *volume = get_model_volume(*gl_volume, objects);
            volume == nullptr || !volume->is_model_part())
            continue;
        Slic3r::Polygon hull        = CameraUtils::create_hull2d(camera, *gl_volume);
        Vec2d           c           = hull.centroid().cast<double>();
        Vec2d           d           = c - screen_center;
        bool            is_bigger_x = std::fabs(d.x()) > std::fabs(d.y());
        if ((is_bigger_x && d.x() * d.x() > center_sq_distance) || 
           (!is_bigger_x && d.y() * d.y() > center_sq_distance))
            continue;
 
        double distance = d.squaredNorm();
        if (center_sq_distance < distance)
            continue;
        center_sq_distance = distance;
 
        *closest_center = c;
        closest         = gl_volume;
    }
    return closest;
}

References Slic3r::Polygon::centroid(), Slic3r::GUI::CameraUtils::create_hull2d(), find_closest(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), and Slic3r::ModelVolume::is_model_part().

Referenced by find_closest().

Here is the call graph for this function:

Here is the caller graph for this function:

is_valid()

bool anonymous_namespace{EmbossJob.cpp}::is_valid

(

ModelVolumeType

volume_type

)

Check if volume type is possible use for new text volume.

Parameters

volume_type

Type

Returns

True when allowed otherwise false

{
    assert(volume_type != ModelVolumeType::INVALID);
    assert(volume_type == ModelVolumeType::MODEL_PART || 
           volume_type == ModelVolumeType::NEGATIVE_VOLUME ||
           volume_type == ModelVolumeType::PARAMETER_MODIFIER);
    if (volume_type == ModelVolumeType::MODEL_PART || 
        volume_type == ModelVolumeType::NEGATIVE_VOLUME ||
        volume_type == ModelVolumeType::PARAMETER_MODIFIER)
        return true;
 
    BOOST_LOG_TRIVIAL(error) << "Can't create embossed volume with this type: " << (int) volume_type;
    return false;
}

References Slic3r::INVALID, is_valid(), Slic3r::MODEL_PART, Slic3r::NEGATIVE_VOLUME, and Slic3r::PARAMETER_MODIFIER.

Referenced by check(), check(), and is_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

process()

bool anonymous_namespace{EmbossJob.cpp}::process

(

std::exception_ptr &

eptr

)

{
    if (!eptr)
        return false;
    try {
        std::rethrow_exception(eptr);
    } catch (JobException &e) {
        create_message(e.what());
        eptr = nullptr;
    }
    return true;
}

References create_message(), and process().

Referenced by finalize(), and process().

Here is the call graph for this function:

Here is the caller graph for this function:

start_create_object_job()

bool anonymous_namespace{EmbossJob.cpp}::start_create_object_job	(	const CreateVolumeParams &	input,
		DataBasePtr	emboss_data,
		const Vec2d &	coor )

Start job for add object with text into scene.

Parameters

input	Contain worker, build shape, gizmo
emboss_data	Define params for create volume
coor	Screen coordinat, where to create new object laying on bed

Returns

True when can add job to worker otherwise FALSE

{
    const Pointfs   &bed_shape  = input.build_volume.printable_area();
    auto             gizmo_type = static_cast<GLGizmosManager::EType>(input.gizmo);
    DataCreateObject data{std::move(emboss_data), coor, input.camera, bed_shape, gizmo_type, input.angle};
 
    // Fix: adding text on print bed with style containing use_surface
    if (data.base->shape.projection.use_surface) 
        // Til the print bed is flat using surface for Object is useless
        data.base->shape.projection.use_surface = false;
 
    auto job = std::make_unique<CreateObjectJob>(std::move(data));
    return queue_job(input.worker, std::move(job));
}

References Slic3r::GUI::Emboss::CreateVolumeParams::angle, anonymous_namespace{EmbossJob.cpp}::DataCreateObject::base, Slic3r::GUI::Emboss::CreateVolumeParams::build_volume, Slic3r::GUI::Emboss::CreateVolumeParams::camera, Slic3r::GUI::Emboss::CreateVolumeParams::gizmo, Slic3r::BuildVolume::printable_area(), Slic3r::EmbossShape::projection, Slic3r::GUI::queue_job(), Slic3r::GUI::Emboss::DataBase::shape, start_create_object_job(), Slic3r::EmbossProjection::use_surface, and Slic3r::GUI::Emboss::CreateVolumeParams::worker.

Referenced by start_create_object_job().

Here is the call graph for this function:

Here is the caller graph for this function:

start_create_volume_job()

bool anonymous_namespace{EmbossJob.cpp}::start_create_volume_job	(	Worker &	worker,
		const ModelObject &	object,
		const std::optional< Transform3d > &	volume_tr,
		DataBasePtr	data,
		ModelVolumeType	volume_type,
		GLGizmosManager::EType	gizmo )

Start job for add new volume to object with given transformation.

Parameters

worker	Define where to queue the job. e.g. wxGetApp().plater()->get_ui_job_worker()
object	Define where to add
volume_tr	Wanted volume transformation, when not set will be calculated after creation to be near the object
data	Define what to emboss - shape
volume_type	Type of volume: Part, negative, modifier
gizmo	Define which gizmo open on the success

Returns

Nullptr when job is sucessfully add to worker otherwise return data to be processed different way

{
    bool &use_surface = data->shape.projection.use_surface;
    std::unique_ptr<GUI::Job> job;
    if (use_surface) {
        // Model to cut surface from.
        SurfaceVolumeData::ModelSources sources = create_sources(object.volumes);
        if (sources.empty() || !volume_tr.has_value()) {
            use_surface = false;
        } else {
            SurfaceVolumeData sfvd{*volume_tr, std::move(sources)};
            CreateSurfaceVolumeData surface_data{std::move(sfvd), std::move(data), volume_type, object.id(), gizmo};
            job = std::make_unique<CreateSurfaceVolumeJob>(std::move(surface_data));
        }
    }
    if (!use_surface) {
        // create volume
        DataCreateVolume create_volume_data{std::move(data), volume_type, object.id(), volume_tr, gizmo};
        job = std::make_unique<CreateVolumeJob>(std::move(create_volume_data));
    }
    return queue_job(worker, std::move(job));
}

References create_sources(), Slic3r::EmbossShape::projection, Slic3r::GUI::queue_job(), Slic3r::GUI::Emboss::DataBase::shape, start_create_volume_job(), and Slic3r::EmbossProjection::use_surface.

Referenced by start_create_volume_job(), and start_create_volume_on_surface_job().

Here is the call graph for this function:

Here is the caller graph for this function:

start_create_volume_on_surface_job()

bool anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job	(	CreateVolumeParams &	input,
		DataBasePtr	data,
		const Vec2d &	screen_coor,
		bool	try_no_coor )

Start job to create volume on the surface of object.

Parameters

input	Variabless needed to create volume
data	Describe what to emboss - shape
screen_coor	Where to add
try_no_coor	True .. try to create volume without screen_coor, False ..

Returns

Nullptr when job is sucessfully add to worker otherwise return data to be processed different way

{
    auto on_bad_state = [&input, try_no_coor](DataBasePtr data_, const ModelObject *object = nullptr) {
        if (try_no_coor) {
            // Can't create on coordinate try to create somewhere
            return start_create_volume_without_position(input, std::move(data_));
        } else {
            // In centroid of convex hull is not hit with object. e.g. torid
            // soo create transfomation on border of object
 
            // there is no point on surface so no use of surface will be applied
            if (data_->shape.projection.use_surface)
                data_->shape.projection.use_surface = false;
 
            if (object == nullptr)
                return false;
 
            auto gizmo_type = static_cast<GLGizmosManager::EType>(input.gizmo);
            return start_create_volume_job(input.worker, *object, {}, std::move(data_), input.volume_type, gizmo_type);
        }
    };
 
    assert(input.gl_volume != nullptr);
    if (input.gl_volume == nullptr)
        return on_bad_state(std::move(data));
 
    const Model *model = input.canvas.get_model();
 
    assert(model != nullptr);
    if (model == nullptr)
        return on_bad_state(std::move(data));
 
    const ModelObjectPtrs &objects = model->objects;
    const ModelVolume     *volume  = get_model_volume(*input.gl_volume, objects);
    assert(volume != nullptr);
    if (volume == nullptr)
        return on_bad_state(std::move(data));
 
    const ModelInstance *instance = get_model_instance(*input.gl_volume, objects);
    assert(instance != nullptr);
    if (instance == nullptr)
        return on_bad_state(std::move(data));
 
    const ModelObject *object = volume->get_object();
    assert(object != nullptr);
    if (object == nullptr)
        return on_bad_state(std::move(data));
 
    auto                   cond   = RaycastManager::AllowVolumes({volume->id().id});
    RaycastManager::Meshes meshes = create_meshes(input.canvas, cond);
    input.raycaster.actualize(*instance, &cond, &meshes);
    std::optional<RaycastManager::Hit> hit = ray_from_camera(input.raycaster, screen_coor, input.camera, &cond);
 
    // context menu for add text could be open only by right click on an
    // object. After right click, object is selected and object_idx is set
    // also hit must exist. But there is options to add text by object list
    if (!hit.has_value())
        // When model is broken. It could appear that hit miss the object.
        // So add part near by in simmilar manner as right panel do
        return on_bad_state(std::move(data), object);
 
    // Create result volume transformation
    Transform3d surface_trmat = create_transformation_onto_surface(hit->position, hit->normal, UP_LIMIT);
    apply_transformation(input.angle, input.distance, surface_trmat);
    Transform3d transform  = instance->get_matrix().inverse() * surface_trmat;
    auto        gizmo_type = static_cast<GLGizmosManager::EType>(input.gizmo);
    // Try to cast ray into scene and find object for add volume
    return start_create_volume_job(input.worker, *object, transform, std::move(data), input.volume_type, gizmo_type);
}

References Slic3r::GUI::RaycastManager::actualize(), Slic3r::GUI::Emboss::CreateVolumeParams::angle, Slic3r::Emboss::apply_transformation(), Slic3r::GUI::Emboss::CreateVolumeParams::camera, Slic3r::GUI::Emboss::CreateVolumeParams::canvas, Slic3r::GUI::create_meshes(), Slic3r::Emboss::create_transformation_onto_surface(), Slic3r::GUI::Emboss::CreateVolumeParams::distance, Slic3r::ModelInstance::get_matrix(), Slic3r::GUI::GLCanvas3D::get_model(), Slic3r::GUI::get_model_instance(), Slic3r::GUI::get_model_volume(), Slic3r::ModelVolume::get_object(), Slic3r::GUI::Emboss::CreateVolumeParams::gizmo, Slic3r::GUI::Emboss::CreateVolumeParams::gl_volume, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::Model::objects, Slic3r::GUI::ray_from_camera(), Slic3r::GUI::Emboss::CreateVolumeParams::raycaster, start_create_volume_job(), start_create_volume_on_surface_job(), Slic3r::GUI::Emboss::start_create_volume_without_position(), Slic3r::transform(), Slic3r::GUI::UP_LIMIT, Slic3r::GUI::Emboss::CreateVolumeParams::volume_type, and Slic3r::GUI::Emboss::CreateVolumeParams::worker.

Referenced by start_create_volume_on_surface_job().

Here is the call graph for this function:

Here is the caller graph for this function:

try_create_mesh()

template<typename Fnc>

TriangleMesh anonymous_namespace{EmbossJob.cpp}::try_create_mesh	(	DataBase &	input,
		const Fnc &	was_canceled )

Try to create mesh from text.

Parameters

input	Text to convert on mesh Shape of characters + Property of font
font	Font file with cache NOTE: Cache glyphs is changed
was_canceled	To check if process was canceled

Returns

Triangle mesh model

{
    if (!input.text_lines.empty()) {
        TriangleMesh tm = create_mesh_per_glyph(input, was_canceled);
        if (was_canceled()) return {};
        if (!tm.empty()) return tm;
    }
 
    ExPolygons shapes = create_shape(input, was_canceled);
    if (shapes.empty()) return {};
    if (was_canceled()) return {};
 
    // NOTE: SHAPE_SCALE is applied in ProjectZ
    double scale = input.shape.scale;
    double depth = input.shape.projection.depth / scale;    
    auto projectZ = std::make_unique<ProjectZ>(depth);    
    float offset = input.is_outside ? -SAFE_SURFACE_OFFSET : (SAFE_SURFACE_OFFSET - input.shape.projection.depth);
    if (input.from_surface.has_value())
        offset += *input.from_surface;
    Transform3d tr = Eigen::Translation<double, 3>(0., 0.,static_cast<double>(offset)) * Eigen::Scaling(scale);
    ProjectTransform project(std::move(projectZ), tr);
    if (was_canceled()) return {};
    return TriangleMesh(polygons2model(shapes, project));
}

References create_mesh_per_glyph(), create_shape(), Slic3r::EmbossProjection::depth, Slic3r::TriangleMesh::empty(), Slic3r::GUI::Emboss::DataBase::from_surface, Slic3r::GUI::Emboss::DataBase::is_outside, Slic3r::offset(), Slic3r::Emboss::polygons2model(), Slic3r::EmbossShape::projection, SAFE_SURFACE_OFFSET, scale(), Slic3r::EmbossShape::scale, Slic3r::GUI::Emboss::DataBase::shape, Slic3r::GUI::Emboss::DataBase::text_lines, try_create_mesh(), and was_canceled().

Referenced by create_mesh(), and try_create_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

update_name_in_list()

void anonymous_namespace{EmbossJob.cpp}::update_name_in_list	(	const ObjectList &	object_list,
		const ModelVolume &	volume )

Update name in right panel.

Parameters

obj_list	Right panel data
volume	Volume with just changed name

{
    const ModelObjectPtrs *objects_ptr = object_list.objects();
    if (objects_ptr == nullptr)
        return;
 
    const ModelObjectPtrs &objects   = *objects_ptr;
    const ModelObject     *object    = volume.get_object();
    const ObjectID        &object_id = object->id();
 
    // search for index of object
    int object_index = -1;
    for (size_t i = 0; i < objects.size(); ++i)
        if (objects[i]->id() == object_id) {
            object_index = static_cast<int>(i);
            break;
        }
 
    const ModelVolumePtrs volumes   = object->volumes;
    const ObjectID       &volume_id = volume.id();
 
    // search for index of volume
    int volume_index = -1;
    for (size_t i = 0; i < volumes.size(); ++i)
        if (volumes[i]->id() == volume_id) {
            volume_index = static_cast<int>(i);
            break;
        }
 
    if (object_index < 0 || volume_index < 0)
        return;
 
    object_list.update_name_in_list(object_index, volume_index);
}

References Slic3r::ModelVolume::get_object(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::GUI::ObjectList::objects(), update_name_in_list(), and Slic3r::GUI::ObjectList::update_name_in_list().

Referenced by update_name_in_list().

Here is the call graph for this function:

Here is the caller graph for this function:

update_volume()

void anonymous_namespace{EmbossJob.cpp}::update_volume	(	TriangleMesh &&	mesh,
		const DataUpdate &	data,
		const Transform3d *	tr = nullptr )

Must be called on main thread.

Parameters

mesh	New mesh data
data	Text configuration, ...
mesh	Transformation of volume

{
    // for sure that some object will be created
    if (mesh.its.empty())
        return create_message(_u8L("Empty mesh can't be created."));
 
    Plater *plater = wxGetApp().plater();
    // Check gizmo is still open otherwise job should be canceled
    assert(plater->canvas3D()->get_gizmos_manager().get_current_type() == GLGizmosManager::Emboss ||
           plater->canvas3D()->get_gizmos_manager().get_current_type() == GLGizmosManager::Svg);
 
    if (data.make_snapshot) {
        // TRN: This is the title of the action appearing in undo/redo stack.
        // It is same for Text and SVG.
        std::string snap_name = _u8L("Emboss attribute change");
        Plater::TakeSnapshot snapshot(plater, snap_name, UndoRedo::SnapshotType::GizmoAction);
    }
 
    ModelVolume *volume = get_model_volume(data.volume_id, plater->model().objects);   
 
    // could appear when user delete edited volume
    if (volume == nullptr)
        return;
 
    if (tr) {
        volume->set_transformation(*tr);
    } else {
        // apply fix matrix made by store to .3mf
        const std::optional<EmbossShape> &emboss_shape = volume->emboss_shape;
        assert(emboss_shape.has_value());
        if (emboss_shape.has_value() && emboss_shape->fix_3mf_tr.has_value())
            volume->set_transformation(volume->get_matrix() * emboss_shape->fix_3mf_tr->inverse());
    }
 
    UpdateJob::update_volume(volume, std::move(mesh), *data.base);
}

References _u8L, Slic3r::GUI::Emboss::DataUpdate::base, create_message(), Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::ModelVolume::emboss_shape, Slic3r::ModelVolume::get_matrix(), Slic3r::GUI::get_model_volume(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::Emboss::DataUpdate::make_snapshot, Slic3r::GUI::plater(), Slic3r::ModelVolume::set_transformation(), Slic3r::GUI::GLGizmosManager::Svg, update_volume(), Slic3r::GUI::Emboss::UpdateJob::update_volume(), and Slic3r::GUI::Emboss::DataUpdate::volume_id.

Referenced by update_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

was_canceled()

auto anonymous_namespace{EmbossJob.cpp}::was_canceled	(	const Job::Ctl &	ctl,
		const DataBase &	base )

                                                          {
    return [&ctl, &cancel = base.cancel]() {
        if (cancel->load())
            return true;
        return ctl.was_canceled();
    };
}

References Slic3r::GUI::Emboss::DataBase::cancel, was_canceled(), and Slic3r::GUI::Job::Ctl::was_canceled().

Referenced by create_mesh(), create_mesh_per_glyph(), create_shape(), cut_per_glyph_surface(), cut_surface(), cut_surface_to_its(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::process(), anonymous_namespace{EmbossJob.cpp}::CreateSurfaceVolumeJob::process(), anonymous_namespace{EmbossJob.cpp}::CreateVolumeJob::process(), try_create_mesh(), and was_canceled().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

safe_extension

float anonymous_namespace{EmbossJob.cpp}::safe_extension = 1.0f

constexpr

Referenced by create_projection_for_cut(), and cut_surface_to_its().

SAFE_SURFACE_OFFSET

float anonymous_namespace{EmbossJob.cpp}::SAFE_SURFACE_OFFSET = 0.015f

constexpr

Referenced by create_emboss_projection(), create_mesh_per_glyph(), and try_create_mesh().