Classes
struct	ClosePoint

struct	IntersectingElement
	IntersectingElement. More...

struct	IntersectionSources
	Corefine visitor Store intersection source for vertices of constrained edge of tm1 Must be used with corefine flag no modification of tm2. More...

class	JobException

struct	Limit

struct	Limits

struct	MinMax

class	ModelCut2index
	Keep conversion from VCutAOIs to Index and vice versa Model_index .. contour(or hole) poin from ExPolygons Index .. continous number. More...

struct	ModelCutId

struct	ProjectionDistance
	To select surface near projection distance. More...

struct	SearchData

struct	Source

struct	SpikeDesc

struct	SurfacePatch

struct	SurfacePatchEx

struct	Visitor
	Track source of intersection Help for anotate inner and outer faces. More...

Typedefs
using	Project = Emboss::IProjection

using	Project3d = Emboss::IProject3d

using	EpicKernel = CGAL::Exact_predicates_inexact_constructions_kernel

using	CutMesh = CGAL::Surface_mesh< EpicKernel::Point_3 >

using	CutMeshes = std::vector< CutMesh >

using	VI = CGAL::SM_Vertex_index

using	HI = CGAL::SM_Halfedge_index

using	EI = CGAL::SM_Edge_index

using	FI = CGAL::SM_Face_index

using	P3 = CGAL::Epick::Point_3

using	EdgeShapeMap = CutMesh::Property_map< EI, IntersectingElement >

using	FaceShapeMap = CutMesh::Property_map< FI, IntersectingElement >

using	VertexShapeMap = CutMesh::Property_map< VI, const IntersectingElement * >

using	FaceTypeMap = CutMesh::Property_map< FI, FaceType >

using	CvtVI2VI = CutMesh::Property_map< VI, VI >

using	ReductionMap = CvtVI2VI

using	EdgeBoolMap = CutMesh::Property_map< EI, bool >

using	CutAOI = std::pair< std::vector< FI >, std::vector< HI > >

using	CutAOIs = std::vector< CutAOI >

using	VCutAOIs = std::vector< CutAOIs >

using	Loop = std::vector< VI >

using	Loops = std::vector< Loop >

using	SurfacePatches = std::vector< SurfacePatch >

using	ProjectionDistances = std::vector< ProjectionDistance >

using	VDistances = std::vector< ProjectionDistances >

using	PointNormal = std::pair< Vec3d, Vec3d >

using	PointNormals = std::array< PointNormal, 4 >

using	IsOnSides = std::vector< std::array< bool, 4 > >

using	Sources = std::vector< Source >

using	VertexSourceMap = CutMesh::Property_map< VI, Source >

using	SurfacePatchesEx = std::vector< SurfacePatchEx >

using	BBS = std::vector< BoundingBoxf3 >

using	Primitive = CGAL::AABB_face_graph_triangle_primitive< CutMesh >

using	Traits = CGAL::AABB_traits< EpicKernel, Primitive >

using	Ray = EpicKernel::Ray_3

using	Tree = CGAL::AABB_tree< Traits >

using	Trees = std::vector< Tree >

using	PatchNumber = CutMesh::Property_map< FI, size_t >

using	Polygon = Slic3r::Polygon

Enumerations
enum class	FaceType { inside , outside , not_constrained , inside_processed }
	Flag for faces in CGAL mesh. More...

enum class	IconType : unsigned { rename = 0 , erase , add , save , undo , italic , unitalic , bold , unbold , system_selector , open_file , exclamation , lock , lock_bold , unlock , unlock_bold , _count }

enum class	IconState : unsigned { activable = 0 , hovered , disabled }

Functions
void	set_skip_for_out_of_aoi (std::vector< bool > &skip_indicies, const indexed_triangle_set &its, const Project &projection, const BoundingBox &shapes_bb)
	Set true for indices out of area of interest.

void	set_skip_by_angle (std::vector< bool > &skip_indicies, const indexed_triangle_set &its, const Project3d &projection, double max_angle=89.)
	Set true for indicies outward and almost parallel together. Note: internally calculate normals.

Vec3d	to_vec3d (const P3 &p)

CutMesh	to_cgal (const indexed_triangle_set &its, const std::vector< bool > &skip_indicies, bool flip=false)
	Convert triangle mesh model to CGAL Surface_mesh Filtrate out opposite triangles Add property map for source face index.

CutMesh	to_cgal (const ExPolygons &shapes, const Project &projection)
	Covert 2d shape (e.g. Glyph) to CGAL model NOTE: internaly create edge_shape_map .. Property map to store conversion from edge to contour face_shape_map .. Property map to store conversion from face to contour.

bool	exist_duplicit_vertex (const CutMesh &mesh)

void	create_reduce_map (ReductionMap &reduction_map, const CutMesh &meshes)
	Create map to reduce unnecesary triangles, Triangles are made by divided quad to two triangles on side of cutting shape mesh Note: also use from mesh (have to be created) face_type_map .. Type of shape inside / outside vert_shape_map .. Source of outline vertex.

CutAOIs	cut_from_model (CutMesh &cgal_model, const ExPolygons &shapes, CutMesh &cgal_shape, float projection_ratio, const ExPolygonsIndices &s2i)
	Create AOIs(area of interest) on model surface.

Loops	create_loops (const std::vector< HI > &outlines, const CutMesh &mesh)
	Create closed loops of contour vertices created from open half edges.

SurfacePatches	diff_models (VCutAOIs &cuts, CutMeshes &cut_models, CutMeshes &models, const Project3d &projection)
	Differenciate other models.

bool	is_over_whole_expoly (const CutAOI &cutAOI, const ExPolygon &shape, const CutMesh &mesh)
	Checking whether patch is uninterrupted cover of whole expolygon it belongs.

bool	is_over_whole_expoly (const SurfacePatch &patch, const ExPolygons &shapes, const VCutAOIs &cutAOIs, const CutMeshes &meshes)
	Checking whether patch is uninterrupted cover of whole expolygon it belongs.

Polygons	unproject_loops (const SurfacePatch &patch, const Project &projection, Vec2d &depth_range)
	Unptoject points from outline loops of patch.

ExPolygon	to_expoly (const SurfacePatch &patch, const Project &projection, Vec2d &depth_range)
	Unproject points from loops and create expolygons.

VDistances	calc_distances (const SurfacePatches &patches, const CutMeshes &models, const CutMesh &shapes_mesh, size_t count_shapes_points, float projection_ratio)
	Calculate distances for SurfacePatches outline points NOTE: each model has to have "vert_shape_map" .. Know source of new vertices.

ProjectionDistances	choose_best_distance (const VDistances &distances, const ExPolygons &shapes, const Point &start, const ExPolygonsIndices &s2i, const SurfacePatches &patches)
	Select distances in similar depth between expolygons.

std::vector< bool >	select_patches (const ProjectionDistances &best_distances, const SurfacePatches &patches, const ExPolygons &shapes, const ExPolygonsIndices &s2i, const VCutAOIs &cutAOIs, const CutMeshes &meshes, const Project &projection)
	Create mask for patches.

void	append (SurfaceCut &sc, SurfaceCut &&sc_add)
	Merge two surface cuts together Added surface cut will be consumed.

SurfaceCut	patch2cut (SurfacePatch &patch)
	Convert patch to indexed_triangle_set.

SurfaceCut	merge_patches (SurfacePatches &patches, const std::vector< bool > &mask)
	Merge masked patches to one surface cut.

bool	is_out_of (const Vec3d &v, const PointNormal &point_normal)
	Check.

bool	is_all_on_one_side (const Vec3i &t, const IsOnSides &is_on_sides)
	Check if triangle t has all vertices out of any plane.

bool	is_face_inside (HI hi, const CutMesh &mesh, const CutMesh &shape_mesh, const VertexShapeMap &vertex_shape_map, const ExPolygonsIndices &shape2index)
	Distiquish face type for half edge.

void	set_face_type (FaceTypeMap &face_type_map, const CutMesh &mesh, const VertexShapeMap &vertex_shape_map, const EdgeBoolMap &ecm, const CutMesh &shape_mesh, const ExPolygonsIndices &shape2index)
	Face with constrained edge are inside/outside by type of intersection Other set to not_constrained(still it could be inside/outside)

void	flood_fill_inner (const CutMesh &mesh, FaceTypeMap &face_type_map)
	Change FaceType from not_constrained to inside For neighbor(or neighbor of neighbor of ...) of inside triangles. Process only not_constrained triangles.

void	collect_surface_data (std::queue< FI > &process, std::vector< FI > &faces, std::vector< HI > &outlines, FaceTypeMap &face_type_map, const CutMesh &mesh)
	Collect connected inside faces Collect outline half edges.

CutAOIs	create_cut_area_of_interests (const CutMesh &mesh, const ExPolygons &shapes, FaceTypeMap &face_type_map)
	Create areas from mesh surface.

float	calc_distance (const P3 &p, uint32_t pi, const CutMesh &shapes_mesh, float projection_ratio)
	Calculate projection distance of point [in mm].

float	calc_size_sq (const Point &p)

SearchData	create_search_data (const ExPolygons &shapes, const std::vector< bool > &mask)

uint32_t	get_closest_point_index (const SearchData &sd, size_t line_idx, const Vec2d &hit_point, const ExPolygons &shapes, const ExPolygonsIndices &s2i)

uint32_t	find_closest_point_index (const Point &p, const ExPolygons &shapes, const ExPolygonsIndices &s2i, const std::vector< bool > &mask)

std::pair< uint32_t, uint32_t >	find_closest_point_pair (const ExPolygons &shapes, const std::vector< bool > &done_shapes, const ExPolygonsIndices &s2i, const std::vector< bool > &mask)

const ProjectionDistance *	get_closest_projection (const ProjectionDistances &distance, float wanted_distance)

void	fill_polygon_distances (const ProjectionDistance &pd, uint32_t index, const ExPolygonsIndex &id, ProjectionDistances &result, const ExPolygon &shape, const VDistances &distances)

void	fill_shape_distances (uint32_t start_index, const ProjectionDistance *start_pd, ProjectionDistances &result, const ExPolygonsIndices &s2i, const ExPolygon &shape, const VDistances &distances)

ClosePoint	find_close_point (const Point &p, ProjectionDistances &result, std::vector< bool > &finished_shapes, const ExPolygonsIndices &s2i, const ExPolygons &shapes)

const VI	default_vi (std::numeric_limits< uint32_t >::max())

void	create_face_types (FaceTypeMap &map, const CutMesh &tm1, const CutMesh &tm2, const EdgeBoolMap &ecm, const VertexSourceMap &sources)
	Create map1 and map2.

bool	clip_cut (SurfacePatch &cut, CutMesh clipper)
	Implement 'cut' Minus 'clipper', where clipper is reverse input Volume NOTE: clipper will be modified (corefined by cut) !!!

BoundingBoxf3	bounding_box (const CutAOI &cut, const CutMesh &mesh)

BoundingBoxf3	bounding_box (const CutMesh &mesh)

BoundingBoxf3	bounding_box (const SurfacePatch &ecut)

SurfacePatch	create_surface_patch (const std::vector< FI > &fis, CutMesh &mesh, const ReductionMap *rmap=nullptr)
	Create patch.

BBS	create_bbs (const VCutAOIs &cuts, const CutMeshes &cut_models)
	Create bounding boxes for AOI.

Trees	create_trees (const CutMeshes &models)
	Create AABB trees for check when patch is whole inside of model.

bool	has_bb_intersection (const BoundingBoxf3 &bb, size_t model_index, const BBS &bbs, const ModelCut2index &m2i)
	Check whether bounding box has intersection with model.

bool	is_patch_inside_of_model (const SurfacePatch &patch, const Tree &tree, const Project3d &projection)
	Only for model without intersection Use ray (in projection direction) from a point from patch and count intersections: pair .. outside \| odd .. inside.

uint32_t	get_shape_point_index (const CutAOI &cut, const CutMesh &model)
	Return some shape point index which identify shape NOTE: Used to find expolygon index.

SurfacePatch	separate_patch (const std::vector< FI > &fis, SurfacePatch &patch, const CvtVI2VI &cvt_from)
	Separate triangles singned with number n.

void	divide_patch (size_t i, SurfacePatchesEx &patches)
	Separate connected triangles into it's own patches new patches are added to back of input patches.

void	collect_open_edges (SurfacePatches &patches)
	Fill outline in patches by open edges.

bool	is_valid (const FontFile &font, unsigned int index)

fontinfo_opt	load_font_info (const unsigned char *data, unsigned int index=0)

std::optional< Glyph >	get_glyph (const stbtt_fontinfo &font_info, int unicode_letter, float flatness)

const Glyph *	get_glyph (int unicode, const FontFile &font, const FontProp &font_prop, Glyphs &cache, fontinfo_opt &font_info_opt)

EmbossStyle	create_style (std::wstring name, std::wstring path)

Point	to_point (const stbtt__point &point)

void	remove_bad (Polygons &polygons)

void	remove_bad (ExPolygons &expolygons)

bool	remove_same_neighbor (Polygon &points)

bool	remove_same_neighbor (Polygons &polygons)

bool	remove_same_neighbor (ExPolygons &expolygons)

bool	remove_self_intersections (ExPolygons &shape, unsigned max_iteration=10)

ExPolygon	create_bounding_rect (const ExPolygons &shape)

void	remove_small_islands (ExPolygons &shape, double minimal_area)

Points	collect_close_points (const ExPolygons &expolygons, double distance=.6)

bool	heal_dupl_inter (ExPolygons &shape, unsigned max_iteration)

void	visualize_heal (const std::string &svg_filepath, const ExPolygons &expolygons)

const Points	pts_2x2 ({Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1)})

const Points	pts_3x3 ({Point(-1, -1), Point(1, -1), Point(1, 1), Point(-1, 1)})

bool	remove_when_spike (Polygon &polygon, size_t index, const SpikeDesc &spike_desc)

void	remove_spikes_in_duplicates (ExPolygons &expolygons, const Points &duplicates)

void	add_quad (uint32_t i1, uint32_t i2, indexed_triangle_set &result, uint32_t count_point)

indexed_triangle_set	polygons2model_unique (const ExPolygons &shape2d, const IProjection &projection, const Points &points)

indexed_triangle_set	polygons2model_duplicit (const ExPolygons &shape2d, const IProjection &projection, const Points &points, const Points &duplicits)

Slic3r::Pointfs	compute_intersections (const Slic3r::Lines &lines)

void	insert_edges (Triangulation::HalfEdges &edges, uint32_t &offset, const Polygon &polygon, const Triangulation::Changes &changes)

void	insert_edges (Triangulation::HalfEdges &edges, uint32_t &offset, const Polygon &polygon)

bool	has_bidirectional_constrained (const Triangulation::HalfEdges &constrained)

bool	is_unique (const Points &points)

bool	has_self_intersection (const Points &points, const Triangulation::HalfEdges &constrained_half_edges)

template<typename T >
void	to_range_pi_pi (T &angle)

static DataBase	create_emboss_data_base (const std::string &text, StyleManager &style_manager, std::shared_ptr< std::atomic< bool > > &cancel)
	Prepare data for emboss.

static void	start_create_volume_job (const ModelObject *object, const Transform3d volume_trmat, DataBase &emboss_data, ModelVolumeType volume_type)
	Start job for add new volume to object with given transformation.

static bool	start_create_volume_on_surface_job (DataBase &emboss_data, ModelVolumeType volume_type, const Vec2d &screen_coor, const GLVolume *gl_volume, RaycastManager &raycaster, GLCanvas3D &canvas)
	Start job for add new volume on surface of object defined by screen coor.

static void	find_closest_volume (const Selection &selection, const Vec2d &screen_center, const Camera &camera, const ModelObjectPtrs &objects, Vec2d closest_center, const GLVolume *closest_volume)
	Find volume in selected object with closest convex hull to screen center. Return.

static void	start_create_object_job (DataBase &emboss_data, const Vec2d &coor)
	Start job for add object with text into scene.

const IconManager::Icon &	get_icon (const IconManager::VIcons &icons, IconType type, IconState state)

static bool	draw_button (const IconManager::VIcons &icons, IconType type, bool disable=false)

static bool	apply_camera_dir (const Camera &camera, GLCanvas3D &canvas)
	Apply camera direction for emboss direction.

static ImVec2	calc_fine_position (const Selection &selection, const ImVec2 &windows_size, const Size &canvas_size)
	Move window for edit emboss text near to embossed object NOTE: embossed object must be selected.

static void	change_window_position (std::optional< ImVec2 > &output_window_offset, bool try_to_fix)
	Change position of emboss window.

static bool	is_text_empty (const std::string &text)

static void	clear (IconManager::Icons &icons)

static const std::vector< std::pair< int, bool > > &	get_states (IconManager::RasterType type)

static void	draw_transparent_icon (const IconManager::Icon &icon)

bool	check (const DataBase &input, bool check_fontfile=true, bool use_surface=false)
	Assert check of inputs data.

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 >
static TriangleMesh	try_create_mesh (DataBase &input, Fnc was_canceled)
	Try to create mesh from text.

template<typename Fnc >
static TriangleMesh	create_mesh (DataBase &input, Fnc was_canceled, Job::Ctl &ctl)

static TriangleMesh	create_default_mesh ()
	Create default mesh for embossed text.

static void	update_volume (TriangleMesh &&mesh, const DataUpdate &data, Transform3d *tr=nullptr)
	Must be called on main thread.

static void	create_volume (TriangleMesh &&mesh, const ObjectID &object_id, const ModelVolumeType type, const Transform3d trmat, const DataBase &data)
	Add new volume to object.

static ModelVolume *	get_volume (ModelObjectPtrs &objects, const ObjectID &volume_id)
	Select Volume from objects.

static OrthoProject	create_projection_for_cut (Transform3d tr, double shape_scale, const std::pair< float, float > &z_range)
	Create projection for cut surface from mesh.

static OrthoProject3d	create_emboss_projection (bool is_outside, float emboss, Transform3d tr, SurfaceCut &cut)
	Create tranformation for emboss Cutted surface.

static TriangleMesh	cut_surface (DataBase &input1, const SurfaceVolumeData &input2, std::function< bool()> was_canceled)
	Cut surface into triangle mesh.

static void	create_message (const std::string &message)

static bool	process (std::exception_ptr &eptr)

static bool	finalize (bool canceled, std::exception_ptr &eptr, const DataBase &input)

Variables
const std::string	edge_shape_map_name = "e:IntersectingElement"

const std::string	face_shape_map_name = "f:IntersectingElement"

const std::string	vert_shape_map_name = "v:IntersectingElement"

const std::string	face_type_map_name = "f:side"

const std::string	patch_source_name = "v:patch_source"

const std::string	vertex_reduction_map_name = "v:reduction"

const std::string	is_constrained_edge_name = "e:is_constrained"

const std::string	vertex_source_map_name = "v:SourceIntersecting"

static const struct priv::Limits	limits

constexpr double	up_limit = 0.9

constexpr float	safe_extension = 1.0f

Class Documentation

◆ priv::ClosePoint

struct priv::ClosePoint

Class Members
float	dist_sq = std::numeric_limits<float>::max()
uint32_t	index = std::numeric_limits<uint32_t>::max()

◆ priv::Limit

struct priv::Limit

template<typename T>
struct priv::Limit< T >

Inheritance diagram for priv::Limit< T >:

Class Members
MinMax< T >	gui
MinMax< T >	values

◆ priv::MinMax

struct priv::MinMax

template<typename T>
struct priv::MinMax< T >

Inheritance diagram for priv::MinMax< T >:

Collaboration diagram for priv::MinMax< T >:

Class Members
T	max
T	min

◆ priv::ModelCutId

struct priv::ModelCutId

Class Members
uint32_t	cut_index
uint32_t	model_index

◆ priv::ProjectionDistance

struct priv::ProjectionDistance

To select surface near projection distance.

Class Members
uint32_t	aoi_index = std::numeric_limits<uint32_t>::max()
float	distance = std::numeric_limits<float>::max()
uint32_t	model_index = std::numeric_limits<uint32_t>::max()
uint32_t	patch_index = std::numeric_limits<uint32_t>::max()

◆ priv::SearchData

struct priv::SearchData

Collaboration diagram for priv::SearchData:

Class Members
vector< size_t >	cvt
vector< Linef >	lines
Tree< 2, double >	tree

◆ priv::Source

struct priv::Source

Class Members
HI	hi
int	sdim =0

◆ priv::SurfacePatch

struct priv::SurfacePatch

Collaboration diagram for priv::SurfacePatch:

Class Members
size_t	aoi_id
BoundingBoxf3	bb
bool	is_whole_aoi = true
Loops	loops
CutMesh	mesh
size_t	model_id
size_t	shape_id = 0

◆ priv::SurfacePatchEx

struct priv::SurfacePatchEx

Collaboration diagram for priv::SurfacePatchEx:

Class Members
bool	full_inside = false
bool	just_cliped = false
SurfacePatch	patch

Typedef Documentation

◆ BBS

using priv::BBS = typedef std::vector<BoundingBoxf3>

◆ CutAOI

using priv::CutAOI = typedef std::pair<std::vector<FI>, std::vector<HI> >

◆ CutAOIs

using priv::CutAOIs = typedef std::vector<CutAOI>

◆ CutMesh

using priv::CutMesh = typedef CGAL::Surface_mesh<EpicKernel::Point_3>

◆ CutMeshes

using priv::CutMeshes = typedef std::vector<CutMesh>

◆ CvtVI2VI

using priv::CvtVI2VI = typedef CutMesh::Property_map<VI, VI>

◆ EdgeBoolMap

using priv::EdgeBoolMap = typedef CutMesh::Property_map<EI, bool>

◆ EdgeShapeMap

using priv::EdgeShapeMap = typedef CutMesh::Property_map<EI, IntersectingElement>

◆ EI

using priv::EI = typedef CGAL::SM_Edge_index

◆ EpicKernel

using priv::EpicKernel = typedef CGAL::Exact_predicates_inexact_constructions_kernel

◆ FaceShapeMap

using priv::FaceShapeMap = typedef CutMesh::Property_map<FI, IntersectingElement>

◆ FaceTypeMap

using priv::FaceTypeMap = typedef CutMesh::Property_map<FI, FaceType>

◆ FI

using priv::FI = typedef CGAL::SM_Face_index

◆ HI

using priv::HI = typedef CGAL::SM_Halfedge_index

◆ IsOnSides

using priv::IsOnSides = typedef std::vector<std::array<bool, 4> >

◆ Loop

using priv::Loop = typedef std::vector<VI>

◆ Loops

using priv::Loops = typedef std::vector<Loop>

◆ P3

using priv::P3 = typedef CGAL::Epick::Point_3

◆ PatchNumber

using priv::PatchNumber = typedef CutMesh::Property_map<FI, size_t>

◆ PointNormal

using priv::PointNormal = typedef std::pair<Vec3d, Vec3d>

◆ PointNormals

using priv::PointNormals = typedef std::array<PointNormal, 4>

◆ Polygon

using priv::Polygon = typedef Slic3r::Polygon

◆ Primitive

using priv::Primitive = typedef CGAL::AABB_face_graph_triangle_primitive<CutMesh>

◆ Project

using priv::Project = typedef Emboss::IProjection

◆ Project3d

using priv::Project3d = typedef Emboss::IProject3d

◆ ProjectionDistances

using priv::ProjectionDistances = typedef std::vector<ProjectionDistance>

◆ Ray

using priv::Ray = typedef EpicKernel::Ray_3

◆ ReductionMap

using priv::ReductionMap = typedef CvtVI2VI

◆ Sources

using priv::Sources = typedef std::vector<Source>

◆ SurfacePatches

using priv::SurfacePatches = typedef std::vector<SurfacePatch>

◆ SurfacePatchesEx

using priv::SurfacePatchesEx = typedef std::vector<SurfacePatchEx>

◆ Traits

using priv::Traits = typedef CGAL::AABB_traits<EpicKernel, Primitive>

◆ Tree

using priv::Tree = typedef CGAL::AABB_tree<Traits>

◆ Trees

using priv::Trees = typedef std::vector<Tree>

◆ VCutAOIs

using priv::VCutAOIs = typedef std::vector<CutAOIs>

◆ VDistances

using priv::VDistances = typedef std::vector<ProjectionDistances>

◆ VertexShapeMap

using priv::VertexShapeMap = typedef CutMesh::Property_map<VI, const IntersectingElement *>

◆ VertexSourceMap

using priv::VertexSourceMap = typedef CutMesh::Property_map<VI, Source>

◆ VI

using priv::VI = typedef CGAL::SM_Vertex_index

Enumeration Type Documentation

◆ FaceType

enum class priv::FaceType

strong

Flag for faces in CGAL mesh.

Enumerator
inside
outside
not_constrained
inside_processed

                    {
    // face inside of the cutted shape
    inside,
    // face outside of the cutted shape
    outside,
    // face without constrained edge (In or Out)
    not_constrained,
 
    // Helper flag that inside was processed
    inside_processed
};

◆ IconState

enum class priv::IconState : unsigned

strong

Enumerator
activable
hovered
disabled

228: unsigned { activable = 0, hovered /*1*/, disabled /*2*/ };

priv::IconState::disabled

@ disabled

priv::IconState::activable

@ activable

priv::IconState::hovered

@ hovered

◆ IconType

enum class priv::IconType : unsigned

strong

Enumerator
rename
erase
add
save
undo
italic
unitalic
bold
unbold
system_selector
open_file
exclamation
lock
lock_bold
unlock
unlock_bold
_count

                    : unsigned {
    rename = 0,
    erase,
    add,
    save,
    undo,
    italic,
    unitalic,
    bold,
    unbold,
    system_selector,
    open_file,
    exclamation,
    lock,
    lock_bold,
    unlock,
    unlock_bold,
    // automatic calc of icon's count
    _count
};

Function Documentation

◆ add_quad()

void priv::add_quad	(	uint32_t	i1,
		uint32_t	i2,
		indexed_triangle_set &	result,
		uint32_t	count_point
	)

{
    // bottom indices
    uint32_t i1_ = i1 + count_point;
    uint32_t i2_ = i2 + count_point;
    result.indices.emplace_back(i2, i2_, i1);
    result.indices.emplace_back(i1_, i1, i2_);
};

References indexed_triangle_set::indices.

Referenced by polygons2model_duplicit(), and polygons2model_unique().

Here is the caller graph for this function:

◆ append()

void priv::append	(	SurfaceCut &	sc,
		SurfaceCut &&	sc_add
	)

Merge two surface cuts together Added surface cut will be consumed.

Parameters

sc	Surface cut to extend
sc_add	Surface cut to consume

{
    if (sc.empty()) {
        sc = std::move(sc_add);
        return;
    }
 
    if (!sc_add.contours.empty()) {
        SurfaceCut::Index offset = static_cast<SurfaceCut::Index>(
            sc.vertices.size());
        size_t require = sc.contours.size() + sc_add.contours.size();
        if (sc.contours.capacity() < require) sc.contours.reserve(require);
        for (std::vector<SurfaceCut::Index> &cut : sc_add.contours)
            for (SurfaceCut::Index &i : cut) i += offset;
        Slic3r::append(sc.contours, std::move(sc_add.contours));
    }
    its_merge(sc, std::move(sc_add));
}

References Slic3r::append(), Slic3r::SurfaceCut::contours, indexed_triangle_set::empty(), Slic3r::its_merge(), Slic3r::offset(), and indexed_triangle_set::vertices.

Referenced by merge_patches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_camera_dir()

bool priv::apply_camera_dir	(	const Camera &	camera,
		GLCanvas3D &	canvas
	)

static

Apply camera direction for emboss direction.

Parameters

camera	Define view vector
canvas	Containe Selected Model to modify

Returns: True when apply change otherwise false

                                                                    {
    const Vec3d &cam_dir = camera.get_dir_forward();
 
    Selection &sel = canvas.get_selection();
    if (sel.is_empty()) return false;
    
    // camera direction transformed into volume coordinate system    
    Transform3d to_world = world_matrix_fixed(sel);
    Vec3d cam_dir_tr = to_world.inverse().linear() * cam_dir;
    cam_dir_tr.normalize();
 
    Vec3d emboss_dir(0., 0., -1.);
 
    // check wether cam_dir is already used
    if (is_approx(cam_dir_tr, emboss_dir)) return false;
 
    assert(sel.get_volume_idxs().size() == 1);
    GLVolume *gl_volume = sel.get_volume(*sel.get_volume_idxs().begin());
 
    Transform3d vol_rot;
    Transform3d vol_tr = gl_volume->get_volume_transformation().get_matrix();
    // check whether cam_dir is opposit to emboss dir
    if (is_approx(cam_dir_tr, -emboss_dir)) {
        // rotate 180 DEG by y
        vol_rot = Eigen::AngleAxis(M_PI_2, Vec3d(0., 1., 0.));
    } else {
        // calc params for rotation
        Vec3d axe = emboss_dir.cross(cam_dir_tr);
        axe.normalize();
        double angle = std::acos(emboss_dir.dot(cam_dir_tr));
        vol_rot = Eigen::AngleAxis(angle, axe);
    }
 
    Vec3d offset = vol_tr * Vec3d::Zero();
    Vec3d offset_inv = vol_rot.inverse() * offset;
    Transform3d res = vol_tr * 
        Eigen::Translation<double, 3>(-offset) * 
        vol_rot * 
        Eigen::Translation<double, 3>(offset_inv);
    //Transform3d res = vol_tr * vol_rot;
    gl_volume->set_volume_transformation(Geometry::Transformation(res));
    get_model_volume(*gl_volume, sel.get_model()->objects)->set_transformation(res);
    return true;
}

References Slic3r::angle(), Slic3r::GUI::Camera::get_dir_forward(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::GLCanvas3D::get_selection(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GLVolume::get_volume_transformation(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Slic3r::is_approx(), Slic3r::GUI::Selection::is_empty(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::linear(), Slic3r::Model::objects, Slic3r::offset(), Slic3r::ModelVolume::set_transformation(), Slic3r::GLVolume::set_volume_transformation(), and Slic3r::GUI::world_matrix_fixed().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bounding_box() [1/3]

BoundingBoxf3 priv::bounding_box	(	const CutAOI &	cut,
		const CutMesh &	mesh
	)

                                                                       {
    const P3& p_from_cut = mesh.point(mesh.target(mesh.halfedge(cut.first.front())));
    Vec3d min = to_vec3d(p_from_cut);
    Vec3d max = min;
    for (FI fi : cut.first) { 
        for(VI vi: mesh.vertices_around_face(mesh.halfedge(fi))){
            const P3& p = mesh.point(vi);
            for (size_t i = 0; i < 3; ++i) { 
                if (min[i] > p[i]) min[i] = p[i];
                if (max[i] < p[i]) max[i] = p[i];
            }
        } 
    }
    return BoundingBoxf3(min, max);
}

References to_vec3d().

Referenced by bounding_box(), create_bbs(), divide_patch(), and separate_patch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bounding_box() [2/3]

BoundingBoxf3 priv::bounding_box ( const CutMesh & mesh )

{
    Vec3d min = to_vec3d(*mesh.points().begin());
    Vec3d max = min;
    for (VI vi : mesh.vertices()) {
        const P3 &p = mesh.point(vi);
        for (size_t i = 0; i < 3; ++i) {
            if (min[i] > p[i]) min[i] = p[i];
            if (max[i] < p[i]) max[i] = p[i];
        }
    }
    return BoundingBoxf3(min, max);
}

References to_vec3d().

Here is the call graph for this function:

◆ bounding_box() [3/3]

BoundingBoxf3 priv::bounding_box ( const SurfacePatch & ecut )

                                                         {
    return bounding_box(ecut.mesh);
}

References bounding_box(), and priv::SurfacePatch::mesh.

Here is the call graph for this function:

◆ calc_distance()

float priv::calc_distance	(	const P3 &	p,
		uint32_t	pi,
		const CutMesh &	shapes_mesh,
		float	projection_ratio
	)

Calculate projection distance of point [in mm].

Parameters

p	Point to calc distance
pi	Index of point on contour
shapes_mesh	Model of cutting shape
projection_ratio	Ratio for best projection distance

Returns: Distance of point from best projection

{
    // It is known because shapes_mesh is created inside of private space
    VI vi_start(2 * pi);
    VI vi_end(2 * pi + 1);
 
    // Get range for intersection
    const P3 &start = shapes_mesh.point(vi_start);
    const P3 &end   = shapes_mesh.point(vi_end);
 
    // find index in vector with biggest difference
    size_t max_i   = 0;
    float  max_val = 0.f;
    for (size_t i = 0; i < 3; i++) {
        float val = start[i] - end[i];
        // abs value
        if (val < 0.f) val *= -1.f;
        if (max_val < val) {
            max_val = val;
            max_i   = i;
        }
    }
 
    float from_start    = p[max_i] - start[max_i];
    float best_distance = projection_ratio * (end[max_i] - start[max_i]);
    return from_start - best_distance;
}

Referenced by calc_distances().

Here is the caller graph for this function:

◆ calc_distances()

priv::VDistances priv::calc_distances	(	const SurfacePatches &	patches,
		const CutMeshes &	models,
		const CutMesh &	shapes_mesh,
		size_t	count_shapes_points,
		float	projection_ratio
	)

Calculate distances for SurfacePatches outline points NOTE: each model has to have "vert_shape_map" .. Know source of new vertices.

Parameters

patches	Part of surface
models	Vertices position
shapes_mesh	Mesh created by shapes
count_shapes_points	Count of contour points in shapes
projection_ratio	Define best distnace

Returns: Projection distances of cutted shape points

{
    priv::VDistances result(count_shapes_points);
    for (const SurfacePatch &patch : patches) {
        // map is created during intersection by corefine visitor
        const VertexShapeMap &vert_shape_map = 
            models[patch.model_id].property_map<VI, const IntersectingElement *>(vert_shape_map_name).first;
        uint32_t patch_index = &patch - &patches.front();
        // map is created during patch creation / dividing
        const CvtVI2VI& cvt = patch.mesh.property_map<VI, VI>(patch_source_name).first;
        // for each point on outline
        for (const Loop &loop : patch.loops) 
        for (const VI &vi_patch : loop) {
            VI vi_model = cvt[vi_patch];
            if (!vi_model.is_valid()) continue;            
            const IntersectingElement *ie = vert_shape_map[vi_model];
            if (ie == nullptr) continue;
            assert(ie->shape_point_index != std::numeric_limits<uint32_t>::max());
            assert(ie->attr != (unsigned char) IntersectingElement::Type::undefined);
            uint32_t pi = ie->shape_point_index;
            assert(pi <= count_shapes_points);
            std::vector<ProjectionDistance> &pds = result[pi];
            uint32_t model_index = patch.model_id;
            uint32_t  aoi_index = patch.aoi_id;
            //uint32_t  hi_index  = &hi - &patch.outline.front();
            const P3 &p = patch.mesh.point(vi_patch);
            float distance = calc_distance(p, pi, shapes_mesh, projection_ratio);
            pds.push_back({model_index, aoi_index, patch_index, distance});
        }
    }
    return result;
}

References priv::IntersectingElement::attr, calc_distance(), patch_source_name, priv::IntersectingElement::shape_point_index, priv::IntersectingElement::undefined, and vert_shape_map_name.

Referenced by Slic3r::cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calc_fine_position()

ImVec2 priv::calc_fine_position	(	const Selection &	selection,
		const ImVec2 &	windows_size,
		const Size &	canvas_size
	)

static

Move window for edit emboss text near to embossed object NOTE: embossed object must be selected.

{
    const Selection::IndicesList indices = selection.get_volume_idxs();
    // no selected volume
    if (indices.empty())
        return {};
    const GLVolume *volume = selection.get_volume(*indices.begin());
    // bad volume selected (e.g. deleted one)
    if (volume == nullptr)
        return {};
 
    const Camera   &camera = wxGetApp().plater()->get_camera();
    Slic3r::Polygon hull   = CameraUtils::create_hull2d(camera, *volume);
 
    ImVec2 c_size(canvas_size.get_width(), canvas_size.get_height());
    ImVec2 offset = ImGuiWrapper::suggest_location(windows_size, hull, c_size);
    return offset;
}

References Slic3r::GUI::CameraUtils::create_hull2d(), Slic3r::GUI::Size::get_height(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::GUI::Size::get_width(), Slic3r::offset(), and Slic3r::GUI::ImGuiWrapper::suggest_location().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_window(), and Slic3r::GUI::GLGizmoEmboss::on_set_state().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calc_size_sq()

float priv::calc_size_sq ( const Point & p )

                                      {    
    // NOTE: p.squaredNorm() can't be use due to overflow max int value
    return (float) p.x() * p.x() + (float) p.y() * p.y();
}

Referenced by fill_shape_distances(), and find_close_point().

Here is the caller graph for this function:

◆ change_window_position()

void priv::change_window_position	(	std::optional< ImVec2 > &	output_window_offset,
		bool	try_to_fix
	)

static

Change position of emboss window.

Parameters

output_window_offset
try_to_fix	When True Only move to be full visible otherwise reset position

                                                                                            {
    const char* name = "Emboss";
    ImGuiWindow *window = ImGui::FindWindowByName(name);
    // is window just created 
    if (window == NULL)
        return;
 
    // position of window on screen
    ImVec2 position = window->Pos;
    ImVec2 size     = window->SizeFull;
 
    // screen size
    ImVec2 screen = ImGui::GetMainViewport()->Size;
 
    if (position.x < 0) {
        if (position.y < 0)
            output_window_offset = ImVec2(0, 0);
        else
            output_window_offset = ImVec2(0, position.y);
    } else if (position.y < 0) {
        output_window_offset = ImVec2(position.x, 0);
    } else if (screen.x < (position.x + size.x)) {
        if (screen.y < (position.y + size.y))
            output_window_offset = ImVec2(screen.x - size.x, screen.y - size.y);
        else
            output_window_offset = ImVec2(screen.x - size.x, position.y);
    } else if (screen.y < (position.y + size.y)) {
        output_window_offset = ImVec2(position.x, screen.y - size.y);
    }
 
    if (!try_to_fix && output_window_offset.has_value())
        output_window_offset = ImVec2(-1, -1); // Cannot 
}

References ImGui::FindWindowByName(), ImGui::GetMainViewport(), ImGuiWindow::Pos, ImGuiViewport::Size, ImGuiWindow::SizeFull, ImVec2::x, and ImVec2::y.

Referenced by Slic3r::GUI::GLGizmoEmboss::on_set_state(), and Slic3r::GUI::GLGizmoEmboss::set_minimal_window_size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check() [1/6]

bool priv::check	(	const CreateSurfaceVolumeData &	input,
		bool	is_main_thread = `false`
	)

{
    bool use_surface = true;
    bool res = check((DataBase)input, is_main_thread, use_surface);
    assert(!input.sources.empty());
    res &= !input.sources.empty();
    return res;
}

References check(), and input().

Here is the call graph for this function:

◆ check() [2/6]

bool priv::check	(	const DataBase &	input,
		bool	check_fontfile = `true`,
		bool	use_surface = `false`
	)

Assert check of inputs data.

private namespace implementation

Parameters

input

Returns

{
    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();
    assert(input.text_configuration.style.prop.use_surface == use_surface);
    res &= input.text_configuration.style.prop.use_surface == use_surface;
    return res; 
}

References input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check() [3/6]

bool priv::check ( const DataCreateObject & input )

                                              {
    bool check_fontfile = false;
    bool res = check((DataBase) input, 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;
    return res;
}

References check(), and input().

Here is the call graph for this function:

◆ check() [4/6]

bool priv::check	(	const DataCreateVolume &	input,
		bool	is_main_thread = `false`
	)

                                                                   {
    bool check_fontfile = false;
    bool res = check((DataBase) input, check_fontfile);
    assert(input.volume_type != ModelVolumeType::INVALID);
    res &= input.volume_type != ModelVolumeType::INVALID;
    assert(input.object_id.id >= 0);
    res &= input.object_id.id >= 0;
    return res; 
}

References check(), input(), and Slic3r::INVALID.

Here is the call graph for this function:

◆ check() [5/6]

bool priv::check	(	const DataUpdate &	input,
		bool	is_main_thread = `false`,
		bool	use_surface = `false`
	)

                                                                              {
    bool check_fontfile = true;
    bool res = check((DataBase) input, check_fontfile, use_surface);
    assert(input.volume_id.id >= 0);
    res &= input.volume_id.id >= 0;
    if (is_main_thread)
        assert(get_volume(wxGetApp().model().objects, input.volume_id) != nullptr);
    assert(input.cancel != nullptr);
    res &= input.cancel != nullptr;
    if (is_main_thread)
        assert(!input.cancel->load());
    return res;
}

References check(), Slic3r::GUI::get_volume(), and input().

Here is the call graph for this function:

◆ check() [6/6]

bool priv::check	(	const UpdateSurfaceVolumeData &	input,
		bool	is_main_thread = `false`
	)

                                                                         {
    bool use_surface = true;
    bool res = check((DataUpdate)input, is_main_thread, use_surface);
    assert(!input.sources.empty());
    res &= !input.sources.empty();
    return res;
}

References check(), and input().

Here is the call graph for this function:

◆ choose_best_distance()

priv::ProjectionDistances priv::choose_best_distance	(	const VDistances &	distances,
		const ExPolygons &	shapes,
		const Point &	start,
		const ExPolygonsIndices &	s2i,
		const SurfacePatches &	patches
	)

Select distances in similar depth between expolygons.

Parameters

distances	All distances - Vector distances for each shape point
shapes	Vector of letters
start	Pivot for start projection in 2d
s2i	Convert index to addresss inside of shape
patches	Cutted parts from surface

Returns: Closest distance projection indexed by points in shapes(see s2i)

{
    assert(distances.size() == count_points(shapes));
 
    // vector of patches for shape
    std::vector<std::vector<uint32_t>> shapes_patches(shapes.size());
    for (const SurfacePatch &patch : patches)
        shapes_patches[patch.shape_id].push_back(&patch-&patches.front());
 
    // collect one closest projection for each outline point
    ProjectionDistances result(distances.size());
 
    // store info about finished shapes
    std::vector<bool> finished_shapes(shapes.size(), {false});
    
    // wanted distance from ideal projection
    // Distances are relative to projection distance
    // so first wanted distance is the closest one (ZERO)
    float wanted_distance = 0.f;
    
    std::vector<bool> mask_distances(s2i.get_count(), {true});
    for (const auto &d : distances)
        if (d.empty()) mask_distances[&d - &distances.front()] = false;
 
    // Select point from shapes(text contour) which is closest to center (all in 2d)
    uint32_t unfinished_index = find_closest_point_index(start, shapes, s2i, mask_distances);
    
#ifdef DEBUG_OUTPUT_DIR
    Connections connections;
    connections.reserve(shapes.size());
    connections.emplace_back(unfinished_index, unfinished_index);
#endif // DEBUG_OUTPUT_DIR
 
    do {
        const ProjectionDistance* pd = get_closest_projection(distances[unfinished_index], wanted_distance);
        // selection of closest_id should proove that pd has value 
        // (functions: get_closest_point_index and find_close_point_in_points)
        assert(pd != nullptr);
        uint32_t expolygons_index = s2i.cvt(unfinished_index).expolygons_index;        
        const ExPolygon &shape = shapes[expolygons_index];
        std::vector<uint32_t> &shape_patches = shapes_patches[expolygons_index];
        if (shape_patches.size() == 1){
            // Speed up, only one patch so copy distance from patch
            uint32_t first_shape_index = s2i.cvt({expolygons_index, 0, 0});
            uint32_t laset_shape_index = first_shape_index + count_points(shape);
            for (uint32_t i = first_shape_index; i < laset_shape_index; ++i) { 
                const ProjectionDistances &pds = distances[i];
                if (pds.empty()) continue;
                // check that index belongs to patch
                assert(pds.front().patch_index == shape_patches.front());
                result[i] = pds.front();
                if (pds.size() == 1) continue;
 
                float relative_distance = fabs(result[i].distance - pd->distance);
                // patch could contain multiple value for one outline point
                // so choose closest to start point
                for (uint32_t pds_index = 1; pds_index < pds.size(); ++pds_index) {
                    // check that index still belongs to same patch
                    assert(pds[pds_index].patch_index == shape_patches.front());
                    float relative_distance2 = fabs(pds[pds_index].distance - pd->distance);
                    if (relative_distance > relative_distance2) { 
                        relative_distance = relative_distance2;
                        result[i]         = pds[pds_index];
                    }
                }
            }
        } else {
            // multiple patches for expolygon
            // check that exist patch to fill shape
            assert(!shape_patches.empty());
            fill_shape_distances(unfinished_index, pd, result, s2i, shape, distances);
        }
 
        finished_shapes[expolygons_index] = true;
        // The most close points between finished and unfinished shapes
        auto [finished, unfinished] = find_closest_point_pair(
            shapes, finished_shapes, s2i, mask_distances);
 
        // detection of end (best doesn't have value)
        if (finished == std::numeric_limits<uint32_t>::max()) break;
 
        assert(unfinished != std::numeric_limits<uint32_t>::max());
        const ProjectionDistance &closest_pd = result[finished];
        // check that best_cp is finished and has result
        assert(closest_pd.aoi_index != std::numeric_limits<uint32_t>::max());
        wanted_distance = closest_pd.distance;
        unfinished_index = unfinished;
 
#ifdef DEBUG_OUTPUT_DIR
        connections.emplace_back(finished, unfinished);
#endif // DEBUG_OUTPUT_DIR
    } while (true); //(unfinished_index != std::numeric_limits<uint32_t>::max());    
#ifdef DEBUG_OUTPUT_DIR
    store(shapes, mask_distances, connections, DEBUG_OUTPUT_DIR + "closest_points.svg");
#endif // DEBUG_OUTPUT_DIR
    return result;
}

References priv::ProjectionDistance::aoi_index, Slic3r::count_points(), Slic3r::ExPolygonsIndices::cvt(), priv::ProjectionDistance::distance, fill_shape_distances(), find_closest_point_index(), find_closest_point_pair(), get_closest_projection(), and Slic3r::ExPolygonsIndices::get_count().

Referenced by Slic3r::cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

void priv::clear ( IconManager::Icons & icons )

static

                                        {
    std::string message;
  for (auto &icon : icons) {
    // Exist more than this instance of shared ptr?
        long count = icon.use_count();
        if (count != 1) {
      // in existing icon change texture to non existing one
            icon->tex_id = 0;
 
            std::string descr = 
        ((count > 2) ? (std::to_string(count - 1) + "x") : "") + // count
        std::to_string(icon->size.x) + "x" + std::to_string(icon->size.y); // resolution
            if (message.empty())
                message = descr;
            else
                message += ", " + descr;
    }
  }
 
    if (!message.empty())
    BOOST_LOG_TRIVIAL(warning) << "There is still used icons(" << message << ").";
}

Referenced by Slic3r::GUI::IconManager::~IconManager(), and Slic3r::GUI::IconManager::init().

Here is the caller graph for this function:

◆ clip_cut()

bool priv::clip_cut	(	SurfacePatch &	cut,
		CutMesh	clipper
	)

Implement 'cut' Minus 'clipper', where clipper is reverse input Volume NOTE: clipper will be modified (corefined by cut) !!!

Parameters

cut	differ from
clipper	differ what

Returns: True on succes, otherwise FALSE

{
    CutMesh& tm = cut.mesh; 
    // create backup for case that there is no intersection
    CutMesh backup_copy = tm; 
 
    class ExistIntersectionClipVisitor: public CGAL::Polygon_mesh_processing::Corefinement::Default_visitor<CutMesh>
    {
        bool* exist_intersection;
    public:
        ExistIntersectionClipVisitor(bool *exist_intersection): exist_intersection(exist_intersection){}
        void intersection_point_detected(std::size_t, int , HI, HI, const CutMesh&, const CutMesh&, bool, bool)
        { *exist_intersection = true;}
    };
    bool exist_intersection = false;
    ExistIntersectionClipVisitor visitor{&exist_intersection};    
    
    // namep parameters for model tm and function clip
    const auto &np_tm = CGAL::parameters::visitor(visitor)
                            .throw_on_self_intersection(false);
    
    // name parameters for model clipper and function clip
    const auto &np_c = CGAL::parameters::throw_on_self_intersection(false);
    // Can't use 'do_not_modify', when Ture than clipper has to be closed !!
    // .do_not_modify(true);
    // .throw_on_self_intersection(false); is set automaticaly by param 'do_not_modify'
    // .clip_volume(false); is set automaticaly by param 'do_not_modify'
        
    bool suc = CGAL::Polygon_mesh_processing::clip(tm, clipper, np_tm, np_c);
 
    // true if the output surface mesh is manifold. 
    // If false is returned tm and clipper are only corefined.
    assert(suc); 
    // decide what TODO when can't clip source object !?!
    if (!exist_intersection  || !suc) {
        // TODO: test if cut is fully in or fully out!!
        cut.mesh = backup_copy;
        return false;
    }
    return true;
}

References priv::SurfacePatch::mesh.

Referenced by diff_models().

Here is the caller graph for this function:

◆ collect_close_points()

Points priv::collect_close_points	(	const ExPolygons &	expolygons,
		double	distance = `.6`
	)

                                                                               { 
    if (expolygons.empty()) return {};
    if (distance < 0.) return {};
    
    // IMPROVE: use int(insted of double) lines and tree
    const ExPolygonsIndices ids(expolygons);
    const std::vector<Linef> lines = Slic3r::to_linesf(expolygons, ids.get_count());
    AABBTreeIndirect::Tree<2, double> tree = AABBTreeLines::build_aabb_tree_over_indexed_lines(lines);
    // Result close points
    Points res; 
    size_t point_index = 0;
    auto collect_close = [&res, &point_index, &lines, &tree, &distance, &ids, &expolygons](const Points &pts) {
        for (const Point &p : pts) {
            Vec2d p_d = p.cast<double>();
            std::vector<size_t> close_lines = AABBTreeLines::all_lines_in_radius(lines, tree, p_d, distance);
            for (size_t index : close_lines) {
                // skip point neighbour lines indices
                if (index == point_index) continue;
                if (&p != &pts.front()) { 
                    if (index == point_index - 1) continue;
                } else if (index == (pts.size()-1)) continue;
 
                // do not doubled side point of segment
                const ExPolygonsIndex id = ids.cvt(index);
                const ExPolygon &expoly = expolygons[id.expolygons_index];
                const Polygon &poly = id.is_contour() ? expoly.contour : expoly.holes[id.hole_index()];
                const Points &poly_pts = poly.points;
                const Point &line_a = poly_pts[id.point_index];
                const Point &line_b = (!ids.is_last_point(id)) ? poly_pts[id.point_index + 1] : poly_pts.front();
                assert(line_a == lines[index].a.cast<int>());
                assert(line_b == lines[index].b.cast<int>());
                if (p == line_a || p == line_b) continue;
                res.push_back(p);
            }
            ++point_index;
        }
    };
    for (const ExPolygon &expoly : expolygons) { 
        collect_close(expoly.contour.points);
        for (const Polygon &hole : expoly.holes) 
            collect_close(hole.points);
    }
    if (res.empty()) return {};
    std::sort(res.begin(), res.end());
    // only unique points
    res.erase(std::unique(res.begin(), res.end()), res.end());
    return res;
}

References Slic3r::AABBTreeLines::all_lines_in_radius(), Slic3r::AABBTreeLines::build_aabb_tree_over_indexed_lines(), Slic3r::ExPolygon::contour, Slic3r::ExPolygonsIndices::cvt(), Slic3r::ExPolygonsIndices::get_count(), Slic3r::ExPolygon::holes, Slic3r::ExPolygonsIndices::is_last_point(), Slic3r::MultiPoint::points, and Slic3r::to_linesf().

Here is the call graph for this function:

◆ collect_open_edges()

void priv::collect_open_edges ( SurfacePatches & patches )

Fill outline in patches by open edges.

Parameters

patches Input/Output meshes with open edges

                                                     {
    std::vector<HI> open_half_edges;
    for (SurfacePatch &patch : patches) {
        open_half_edges.clear();
        const CutMesh &mesh = patch.mesh;
        for (FI fi : mesh.faces()) {
            HI hi1 = mesh.halfedge(fi);
            assert(hi1.is_valid());
            HI hi2 = mesh.next(hi1);
            assert(hi2.is_valid());
            HI hi3 = mesh.next(hi2);
            assert(hi3.is_valid());
            // Is fi triangle?
            assert(mesh.next(hi3) == hi1);
            for (HI hi : {hi1, hi2, hi3}) {
                HI hi_op = mesh.opposite(hi);
                FI fi_op = mesh.face(hi_op);
                if (!fi_op.is_valid())
                    open_half_edges.push_back(hi);
            }
        }
        patch.loops = create_loops(open_half_edges, mesh);
    }
}

References create_loops().

Referenced by diff_models().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_surface_data()

void priv::collect_surface_data	(	std::queue< FI > &	process,
		std::vector< FI > &	faces,
		std::vector< HI > &	outlines,
		FaceTypeMap &	face_type_map,
		const CutMesh &	mesh
	)

Collect connected inside faces Collect outline half edges.

Parameters

process	Queue of face to process - find connected
faces	[Output] collected Face indices from mesh
outlines	[Output] collected Halfedge indices from mesh
face_type_map	Use flag inside / outside NOTE: Modify in function: inside -> inside_processed
mesh	mesh to process

{
    assert(!process.empty());
    assert(faces.empty());
    assert(outlines.empty());
    while (!process.empty()) {
        FI fi = process.front();
        process.pop();
 
        FaceType &fi_type = face_type_map[fi];
        // Do not process twice
        if (fi_type == FaceType::inside_processed) continue;
        assert(fi_type == FaceType::inside);
        // flag face as processed
        fi_type = FaceType::inside_processed;
        faces.push_back(fi);
 
        // check neighbor triangle
        HI hi     = mesh.halfedge(fi);
        HI hi_end = hi;
        do {
            HI hi_opposite = mesh.opposite(hi);
            // open edge doesn't have opposit half edge
            if (!hi_opposite.is_valid()) { 
                outlines.push_back(hi);
                hi = mesh.next(hi);
                continue; 
            }            
            FI fi_opposite = mesh.face(hi_opposite);
            if (!fi_opposite.is_valid()) {
                outlines.push_back(hi);
                hi = mesh.next(hi);
                continue;
            }
            FaceType side = face_type_map[fi_opposite];
            if (side == FaceType::inside) {
                process.emplace(fi_opposite);
            } else if (side == FaceType::outside) {
                // store outlines
                outlines.push_back(hi);
            }
            hi = mesh.next(hi);
        } while (hi != hi_end);
    }
}

References inside, inside_processed, outside, and process().

Referenced by create_cut_area_of_interests().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_intersections()

Slic3r::Pointfs priv::compute_intersections ( const Slic3r::Lines & lines )

{
    using namespace Slic3r;
    // IMPROVE0: BoundingBoxes of Polygons
    // IMPROVE1: Polygon's neighbor lines can't intersect
    // e.g. use indices to Point to find same points
    // IMPROVE2: Use BentleyOttmann algorithm
    // https://doc.cgal.org/latest/Surface_sweep_2/index.html -- CGAL implementation is significantly slower
    // https://stackoverflow.com/questions/4407493/is-there-a-robust-c-implementation-of-the-bentley-ottmann-algorithm
    Pointfs pts;
    Point   i;
    for (size_t li = 0; li < lines.size(); ++li) {
        const Line  &l = lines[li];
        const Point &a = l.a;
        const Point &b = l.b;
        Point min(std::min(a.x(), b.x()), std::min(a.y(), b.y()));
        Point max(std::max(a.x(), b.x()), std::max(a.y(), b.y()));
        BoundingBox  bb(min, max);
        for (size_t li_ = li + 1; li_ < lines.size(); ++li_) {
            const Line  &l_ = lines[li_];
            const Point &a_ = l_.a;
            const Point &b_ = l_.b;
            if (a == b_ || b == a_ || a == a_ || b == b_) continue;
            Point min_(std::min(a_.x(), b_.x()), std::min(a_.y(), b_.y()));
            Point max_(std::max(a_.x(), b_.x()), std::max(a_.y(), b_.y()));
            BoundingBox bb_(min_, max_);
            // intersect of BB compare min max
            if (bb.overlap(bb_) &&
                l.intersection(l_, &i))
                pts.push_back(i.cast<double>());
        }
    }
    return pts;
}

References Slic3r::Line::a, Slic3r::Line::b, Slic3r::Line::intersection(), and Slic3r::BoundingBoxBase< PointType, APointsType >::overlap().

Referenced by Slic3r::intersection_points(), Slic3r::intersection_points(), Slic3r::intersection_points(), Slic3r::intersection_points(), and Slic3r::intersection_points().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_bbs()

std::vector< BoundingBoxf3 > priv::create_bbs	(	const VCutAOIs &	cuts,
		const CutMeshes &	cut_models
	)

Create bounding boxes for AOI.

Parameters

cuts	Cutted AOI from models
cut_models	Source points of cuts

Returns: Bounding boxes

{
    size_t count = 0;
    for (const CutAOIs &cut : cuts) count += cut.size();
 
    std::vector<BoundingBoxf3> bbs;
    bbs.reserve(count);
    for (size_t model_index = 0; model_index < cut_models.size(); ++model_index) {
        const CutMesh &cut_model = cut_models[model_index];
        const CutAOIs &cutAOIs   = cuts[model_index];
        for (size_t cut_index = 0; cut_index < cutAOIs.size(); ++cut_index) {
            const CutAOI &cut = cutAOIs[cut_index];
            bbs.push_back(bounding_box(cut, cut_model));
        }
    }
    return bbs;
}

References bounding_box().

Referenced by diff_models().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_bounding_rect()

ExPolygon priv::create_bounding_rect ( const ExPolygons & shape )

                                                            {
    BoundingBox bb   = get_extents(shape);
    Point       size = bb.size();
    if (size.x() < 10)
        bb.max.x() += 10;
    if (size.y() < 10)
        bb.max.y() += 10;
 
    Polygon rect({// CCW
        bb.min,
        {bb.max.x(), bb.min.y()},
        bb.max,
        {bb.min.x(), bb.max.y()}});
 
    Point   offset = bb.size() * 0.1;
    Polygon hole({// CW
        bb.min + offset,
        {bb.min.x() + offset.x(), bb.max.y() - offset.y()},
        bb.max - offset,
        {bb.max.x() - offset.x(), bb.min.y() + offset.y()}});
 
    return ExPolygon(rect, hole);
}

References Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::offset(), and Slic3r::BoundingBoxBase< PointType, APointsType >::size().

Referenced by heal_dupl_inter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_cut_area_of_interests()

priv::CutAOIs priv::create_cut_area_of_interests	(	const CutMesh &	mesh,
		const ExPolygons &	shapes,
		FaceTypeMap &	face_type_map
	)

Create areas from mesh surface.

Parameters

mesh	Model
shapes	Cutted shapes
face_type_map	Define Triangles of interest. Edge between inside / outside. NOTE: Not const because it need to flag proccessed faces

Returns: Areas of interest from mesh

{
    // IMPROVE: Create better heuristic for count.
    size_t faces_per_cut    = mesh.faces().size() / shapes.size();
    size_t outlines_per_cut = faces_per_cut / 2;
    size_t cuts_per_model   = shapes.size() * 2;
 
    CutAOIs result;
    result.reserve(cuts_per_model);
 
    // It is faster to use one queue for all cuts
    std::queue<FI> process;
    for (FI fi : mesh.faces()) {
        if (face_type_map[fi] != FaceType::inside) continue;
 
        CutAOI cut;
        std::vector<FI> &faces    = cut.first;
        std::vector<HI> &outlines = cut.second;
 
        // faces for one surface cut
        faces.reserve(faces_per_cut);
        // outline for one surface cut
        outlines.reserve(outlines_per_cut);
 
        assert(process.empty());
        // Process queue of faces to separate to surface_cut
        process.push(fi);
        collect_surface_data(process, faces, outlines, face_type_map, mesh);
        assert(!faces.empty());
        assert(!outlines.empty());
        result.emplace_back(std::move(cut));
    }
    return result;
}

References collect_surface_data(), inside, and process().

Referenced by cut_from_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_default_mesh()

TriangleMesh priv::create_default_mesh ( )

static

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;
    if (!load_obj(path.c_str(), &triangle_mesh)) {
        // when can't load mesh use cube
        return TriangleMesh(its_make_cube(36., 4., 2.5));
    }
    return triangle_mesh;
}

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

Here is the call graph for this function:

◆ create_emboss_data_base()

DataBase priv::create_emboss_data_base	(	const std::string &	text,
		StyleManager &	style_manager,
		std::shared_ptr< std::atomic< bool > > &	cancel
	)

static

Prepare data for emboss.

Parameters

text	Text to emboss
style_manager	Keep actual selected style
cancel	Cancel for previous job

Returns: Base data for emboss text

{
    // create volume_name
    std::string volume_name = text; // copy
    // contain_enter?
    if (volume_name.find('\n') != std::string::npos)
        // change enters to space
        std::replace(volume_name.begin(), volume_name.end(), '\n', ' ');
 
    if (!style_manager.is_active_font()) {
        style_manager.load_valid_style();
        assert(style_manager.is_active_font());
        if (!style_manager.is_active_font())
            return {}; // no active font in style, should never happend !!!
    }
 
    const EmbossStyle &es = style_manager.get_style();
    // actualize font path - during changes in gui it could be corrupted
    // volume must store valid path
    assert(style_manager.get_wx_font().IsOk());
    assert(es.path.compare(WxFontUtils::store_wxFont(style_manager.get_wx_font())) == 0);
    TextConfiguration tc{es, text};
 
    // Cancel previous Job, when it is in process
    // worker.cancel(); --> Use less in this case I want cancel only previous EmbossJob no other jobs
    // Cancel only EmbossUpdateJob no others
    if (cancel != nullptr)
        cancel->store(true);
    // create new shared ptr to cancel new job
    cancel = std::make_shared<std::atomic<bool>>(false);
    return Slic3r::GUI::Emboss::DataBase{style_manager.get_font_file_with_cache(), tc, volume_name, cancel};
}

References Slic3r::GUI::Emboss::StyleManager::get_font_file_with_cache(), Slic3r::GUI::Emboss::StyleManager::get_style(), Slic3r::GUI::Emboss::StyleManager::get_wx_font(), Slic3r::GUI::Emboss::StyleManager::is_active_font(), Slic3r::GUI::Emboss::StyleManager::load_valid_style(), Slic3r::EmbossStyle::path, and Slic3r::GUI::WxFontUtils::store_wxFont().

Referenced by Slic3r::GUI::GLGizmoEmboss::create_volume(), Slic3r::GUI::GLGizmoEmboss::create_volume(), and Slic3r::GUI::GLGizmoEmboss::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_emboss_projection()

OrthoProject3d priv::create_emboss_projection	(	bool	is_outside,
		float	emboss,
		Transform3d	tr,
		SurfaceCut &	cut
	)

static

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

{
    // Offset of clossed side to model
    const float surface_offset = 0.015f; // [in mm]
    float 
        front_move = (is_outside) ? emboss : surface_offset,
        back_move  = -((is_outside) ? 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 its_transform(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::pretranslate().

Referenced by cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_face_types()

void priv::create_face_types	(	FaceTypeMap &	map,
		const CutMesh &	tm1,
		const CutMesh &	tm2,
		const EdgeBoolMap &	ecm,
		const VertexSourceMap &	sources
	)

Create map1 and map2.

Parameters

map	Convert tm1.face to type
tm1	Corefined mesh
tm2	Source of intersection
ecm1	Identify constrainde edge
sources	Convert tm1.face to type

{
    auto get_intersection_source = [&tm2](const Source& s1, const Source& s2)->FI{        
        // when one of sources is face than return it
        FI fi1 = tm2.face(s1.hi);
        if (s1.sdim == 2) return fi1;
        FI fi2 = tm2.face(s2.hi);
        if (s2.sdim == 2) return fi2;
        // both vertices are made by same source triangle
        if (fi1 == fi2) return fi1;
 
        // when one from sources is edge second one decide side of triangle triangle
        HI hi1_opposit = tm2.opposite(s1.hi);
        FI fi1_opposit;
        if (hi1_opposit.is_valid())
            fi1_opposit = tm2.face(hi1_opposit);
        if (fi2 == fi1_opposit) return fi2;
 
        HI hi2_opposit = tm2.opposite(s2.hi);
        FI fi2_opposit;
        if (hi2_opposit.is_valid())
            fi2_opposit = tm2.face(hi2_opposit);
        if (fi1 == fi2_opposit) return fi1;
        if (fi1_opposit.is_valid() && fi1_opposit == fi2_opposit)
            return fi1_opposit;
 
        // when intersection is vertex need loop over neighbor
        for (FI fi_around_hi1 : tm2.faces_around_target(s1.hi)) {
            for (FI fi_around_hi2 : tm2.faces_around_target(s2.hi)) { 
                if (fi_around_hi1 == fi_around_hi2) 
                    return fi_around_hi1;
            }
        }
 
        // should never rich it
        // Exist case when do not know source triangle for decide side of intersection
        assert(false);
        return FI();
    };
 
    for (FI fi : tm1.faces()) map[fi] = FaceType::not_constrained;
    for (EI ei1 : tm1.edges()) {
        if (!get(ecm, ei1)) continue;
 
        // get faces from tm1 (f1a + f1b)
        HI hi1 = tm1.halfedge(ei1);
        assert(hi1.is_valid());
        FI f1a = tm1.face(hi1);
        assert(f1a.is_valid());
        HI hi_op = tm1.opposite(hi1);
        assert(hi_op.is_valid());
        FI f1b = tm1.face(hi_op);
        assert(f1b.is_valid());
 
        // get faces from tm2 (f2a + f2b)
        VI vi1_source = tm1.source(hi1);
        assert(vi1_source.is_valid());
        VI vi1_target = tm1.target(hi1);
        assert(vi1_target.is_valid());
 
        const Source &s_s = sources[vi1_source];
        const Source &s_t = sources[vi1_target];
        FI fi2 = get_intersection_source(s_s, s_t);
 
        // in release solve situation that face was NOT deduced
        if (!fi2.is_valid()) continue;
 
        HI hi2 = tm2.halfedge(fi2);
        std::array<const P3 *, 3> t;
        size_t ti =0;
        for (VI vi2 : tm2.vertices_around_face(hi2))
            t[ti++] = &tm2.point(vi2);
 
        // triangle tip from face f1a
        VI vi1a_tip = tm1.target(tm1.next(hi1));
        assert(vi1a_tip.is_valid());
        const P3 &p = tm1.point(vi1a_tip);
 
        // check if f1a is behinde f2a
        // inside mean it will be used
        // outside will be discarded
        if (CGAL::orientation(*t[0], *t[1], *t[2], p) == CGAL::POSITIVE) {
            map[f1a] = FaceType::inside;
            map[f1b] = FaceType::outside;
        } else {
            map[f1a] = FaceType::outside;
            map[f1b] = FaceType::inside;
        }
    }
}

References priv::Source::hi, inside, not_constrained, outside, and priv::Source::sdim.

◆ create_loops()

priv::Loops priv::create_loops	(	const std::vector< HI > &	outlines,
		const CutMesh &	mesh
	)

Create closed loops of contour vertices created from open half edges.

Parameters

outlines	Unsorted half edges
mesh	Source mesh for half edges

Returns: Closed loops

{
    Loops loops;
    Loops unclosed;
    for (HI hi : outlines) {
        VI vi_s = mesh.source(hi);
        VI vi_t = mesh.target(hi);
        Loop *loop_move    = nullptr;
        Loop *loop_connect = nullptr;
        for (std::vector<VI> &cut : unclosed) {
            if (cut.back() != vi_s) continue;
            if (cut.front() == vi_t) {
                // cut closing
                loop_move = &cut;
            } else {
                loop_connect = &cut;
            }
            break;
        }
        if (loop_move != nullptr) {
            // index of closed cut
            size_t index = loop_move - &unclosed.front();
            // move cut to result
            loops.emplace_back(std::move(*loop_move));
            // remove it from unclosed cut
            unclosed.erase(unclosed.begin() + index);
        } else if (loop_connect != nullptr) {
            // try find tail to connect cut
            Loop *loop_tail = nullptr;
            for (Loop &cut : unclosed) {
                if (cut.front() != vi_t) continue;
                loop_tail = &cut;
                break;
            }
            if (loop_tail != nullptr) {
                // index of tail
                size_t index = loop_tail - &unclosed.front();
                // move to connect vector
                loop_connect->insert(loop_connect->end(),
                                    make_move_iterator(loop_tail->begin()),
                                    make_move_iterator(loop_tail->end()));
                // remove tail from unclosed cut
                unclosed.erase(unclosed.begin() + index);
            } else {
                loop_connect->push_back(vi_t);
            }
        } else { // not found
            bool create_cut = true;
            // try to insert to front of cut
            for (Loop &cut : unclosed) {
                if (cut.front() != vi_t) continue;
                cut.insert(cut.begin(), vi_s);
                create_cut = false;
                break;
            }
            if (create_cut)
                unclosed.emplace_back(std::vector{vi_s, vi_t});
        }
    }
    assert(unclosed.empty());
    return loops;
}

Referenced by collect_open_edges().

Here is the caller graph for this function:

◆ create_mesh()

template<typename Fnc >

static TriangleMesh priv::create_mesh	(	DataBase &	input,
		Fnc	was_canceled,
		Job::Ctl &	ctl
	)

static

Referenced by Slic3r::GUI::Emboss::CreateVolumeJob::process(), and Slic3r::GUI::Emboss::CreateObjectJob::process().

Here is the caller graph for this function:

◆ create_message()

void priv::create_message ( const std::string & message )

static

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

References Slic3r::GUI::show_error().

Referenced by create_volume(), Slic3r::GUI::Emboss::CreateVolumeJob::finalize(), Slic3r::GUI::Emboss::CreateObjectJob::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 priv::create_projection_for_cut	(	Transform3d	tr,
		double	shape_scale,
		const std::pair< float, float > &	z_range
	)

static

Create projection for cut surface from mesh.

Parameters

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

Returns: Orthogonal cut_projection

{
    double min_z = z_range.first - priv::safe_extension;
    double max_z = z_range.second + priv::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 Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::linear(), safe_extension, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::scale(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::translate().

Referenced by cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_reduce_map()

void priv::create_reduce_map	(	ReductionMap &	reduction_map,
		const CutMesh &	meshes
	)

Create map to reduce unnecesary triangles, Triangles are made by divided quad to two triangles on side of cutting shape mesh Note: also use from mesh (have to be created) face_type_map .. Type of shape inside / outside vert_shape_map .. Source of outline vertex.

Parameters

reduction_map	Reduction map from vertex to vertex, when key == value than no reduction
faces	Faces of one
mesh	Input object

Append reduction or change existing one.

Parameters

hi	HalEdge between outside and inside face. Target vertex will be reduced, source vertex left

[[maybe_unused]] &face_type_map, &is_reducible_vertex are need only in debug

{
    const VertexShapeMap &vert_shape_map = mesh.property_map<VI, const IntersectingElement*>(vert_shape_map_name).first;
    const EdgeBoolMap &ecm = mesh.property_map<EI, bool>(is_constrained_edge_name).first;
 
    // check if vertex was made by edge_2 which is diagonal of quad
    auto is_reducible_vertex = [&vert_shape_map](VI reduction_from) -> bool {
        const IntersectingElement *ie = vert_shape_map[reduction_from];
        if (ie == nullptr) return false;
        IntersectingElement::Type type = ie->get_type();
        return type == IntersectingElement::Type::edge_2;
    };
 
    auto add_reduction = [&] //&reduction_map, &mesh, &face_type_map, &is_reducible_vertex
    (HI hi) {
        VI erase = mesh.target(hi);
        VI left = mesh.source(hi);
        assert(is_reducible_vertex(erase));
        assert(!is_reducible_vertex(left));
        VI &vi = reduction_map[erase];
        // check if it is first add
        if (vi.is_valid())
            return;
 
        // check that all triangles after reduction has 'erase' and 'left' vertex
        // on same side of opposite line of vertex in triangle
        Vec3d v_erase = to_vec3d(mesh.point(erase));
        Vec3d v_left = to_vec3d(mesh.point(left));
        for (FI fi : mesh.faces_around_target(hi)) {
            if (!fi.is_valid())
                continue;
            // get vertices of rest 
            VI vi_a, vi_b;
            for (VI vi : mesh.vertices_around_face(mesh.halfedge(fi))) {
                if (!vi.is_valid())
                    continue;
                if (vi == erase)
                    continue;
                if (!vi_a.is_valid())
                    vi_a = vi;
                else {
                    assert(!vi_b.is_valid());
                    vi_b = vi;
                }
            } 
            assert(vi_b.is_valid());
            // do not check triangle, which will be removed
            if (vi_a == left || vi_b == left)
                continue;
            
            Vec3d v_a = to_vec3d(mesh.point(vi_a));
            Vec3d v_b = to_vec3d(mesh.point(vi_b));
            // Vectors of triangle edges
            Vec3d v_ab = v_b - v_a;
            Vec3d v_ae = v_erase - v_a;
            Vec3d v_al = v_left - v_a;
 
            Vec3d n1 = v_ab.cross(v_ae);
            Vec3d n2 = v_ab.cross(v_al);
            // check that normal has same direction
            if (((n1.x() > 0) != (n2.x() > 0)) ||
                ((n1.y() > 0) != (n2.y() > 0)) ||
                ((n1.z() > 0) != (n2.z() > 0)))
                return; // this reduction will create CCW triangle
        }
 
        reduction_map[erase] = left;
        // I have no better rule than take the first
        // for decide which reduction will be better
        // But it could be use only one of them
    };
 
    for (EI ei : mesh.edges()) { 
        if (!ecm[ei]) continue;
        HI hi = mesh.halfedge(ei);
        VI vi = mesh.target(hi);
        if (is_reducible_vertex(vi)) add_reduction(hi);
        
        HI hi_op = mesh.opposite(hi);
        VI vi_op = mesh.target(hi_op);
        if (is_reducible_vertex(vi_op)) add_reduction(hi_op);
    }
#ifdef DEBUG_OUTPUT_DIR
    store(mesh, reduction_map, DEBUG_OUTPUT_DIR + "reduces/");
#endif // DEBUG_OUTPUT_DIR
}

References priv::IntersectingElement::edge_2, erase, priv::IntersectingElement::get_type(), is_constrained_edge_name, to_vec3d(), and vert_shape_map_name.

Referenced by diff_models().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_search_data()

priv::SearchData priv::create_search_data	(	const ExPolygons &	shapes,
		const std::vector< bool > &	mask
	)

{
    // IMPROVE: Use float precission (it is enough)
    SearchData sd;
    sd.lines.reserve(mask.size());
    sd.cvt.reserve(mask.size());
    size_t index     = 0;
    auto   add_lines = [&sd, &index, &mask]
    (const Polygon &poly) {
        Vec2d prev = poly.back().cast<double>();
        bool use_point = mask[index + poly.points.size() - 1];
        for (const Point &p : poly.points) {
            if (!use_point) {
                use_point = mask[index];
                if (use_point) prev = p.cast<double>();
            } else if (!mask[index]) {
                use_point = false;
            } else {
                Vec2d p_d = p.cast<double>();
                sd.lines.emplace_back(prev, p_d);
                sd.cvt.push_back(index);
                prev = p_d;
            }
            ++index;
        }
    };
 
    for (const ExPolygon &shape : shapes) {
        add_lines(shape.contour);
        for (const Polygon &hole : shape.holes) add_lines(hole);
    }
    sd.tree = AABBTreeLines::build_aabb_tree_over_indexed_lines(sd.lines);
    return sd;
}

References Slic3r::AABBTreeLines::build_aabb_tree_over_indexed_lines(), priv::SearchData::cvt, priv::SearchData::lines, and priv::SearchData::tree.

Referenced by find_closest_point_index(), and find_closest_point_pair().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_shape()

template<typename Fnc >

static ExPolygons priv::create_shape	(	DataBase &	input,
		Fnc	was_canceled
	)

static

Referenced by cut_surface().

Here is the caller graph for this function:

◆ create_style()

EmbossStyle priv::create_style	(	std::wstring	name,
		std::wstring	path
	)

                                                               {
    return { boost::nowide::narrow(name.c_str()),
             boost::nowide::narrow(path.c_str()),
             EmbossStyle::Type::file_path, FontProp() };
}

References boost::nowide::narrow().

Here is the call graph for this function:

◆ create_surface_patch()

priv::SurfacePatch priv::create_surface_patch	(	const std::vector< FI > &	fis,
		CutMesh &	mesh,
		const ReductionMap *	rmap = `nullptr`
	)

Create patch.

Parameters

fis	Define patch faces
mesh	Source of fis NOTE: Need temporary add property map for convert vertices
rmap	Options to reduce vertices from fis. NOTE: Used for skip vertices made by diagonal edge in rectangle of shape side

Returns: Patch

{
    auto is_counted = mesh.add_property_map<VI, bool>("v:is_counted").first;
    uint32_t count_vertices = 0;
    if (rmap == nullptr) {
        for (FI fi : fis) 
            for (VI vi : mesh.vertices_around_face(mesh.halfedge(fi))) 
                if (!is_counted[vi]) { 
                    is_counted[vi] = true;
                    ++count_vertices;
                }
    } else {
        for (FI fi : fis)
            for (VI vi : mesh.vertices_around_face(mesh.halfedge(fi))) {
                // Will vertex be reduced?
                if ((*rmap)[vi].is_valid()) continue;
                if (!is_counted[vi]) {
                    is_counted[vi] = true;
                    ++count_vertices;
                }
            }        
    }
    mesh.remove_property_map(is_counted);
 
    uint32_t count_faces = fis.size();    
    // IMPROVE: Value is greater than neccessary, count edges used twice
    uint32_t count_edges = count_faces*3; 
 
    CutMesh cm;
    cm.reserve(count_vertices, count_edges, count_faces);
 
    // vertex conversion function from mesh VI to result VI
    CvtVI2VI mesh2result = mesh.add_property_map<VI,VI>("v:mesh2result").first;
 
    if (rmap == nullptr) {
        for (FI fi : fis) {
            std::array<VI, 3> t;
            int index = 0;
            for (VI vi : mesh.vertices_around_face(mesh.halfedge(fi))) {
                VI &vi_cvt = mesh2result[vi];
                if (!vi_cvt.is_valid()) {
                    vi_cvt = VI(cm.vertices().size());
                    cm.add_vertex(mesh.point(vi));
                }
                t[index++] = vi_cvt;
            }
            cm.add_face(t[0], t[1], t[2]);
        }
    } else {
        for (FI fi :fis) {
            std::array<VI, 3> t;
            int  index = 0;
            bool exist_reduction = false;
            for (VI vi : mesh.vertices_around_face(mesh.halfedge(fi))) {
                VI vi_r = (*rmap)[vi];
                if (vi_r.is_valid()) { 
                    exist_reduction = true;
                    vi = vi_r;
                }
                VI &vi_cvt = mesh2result[vi];
                if (!vi_cvt.is_valid()) {
                    vi_cvt = VI(cm.vertices().size());
                    cm.add_vertex(mesh.point(vi));
                }
                t[index++] = vi_cvt;
            }
 
            // prevent add reduced triangle
            if (exist_reduction &&
                (t[0] == t[1] || 
                 t[1] == t[2] ||
                 t[2] == t[0]))
                continue;
 
            cm.add_face(t[0], t[1], t[2]);
        }
    }
    
    assert(count_vertices == cm.vertices().size());
    assert((rmap == nullptr && count_faces == cm.faces().size()) ||
           (rmap != nullptr && count_faces >= cm.faces().size()));
    assert(count_edges >= cm.edges().size());
    
    // convert VI from this patch to source VI, when exist
    CvtVI2VI cvt = cm.add_property_map<VI, VI>(patch_source_name).first;
    // vi_s .. VertexIndex into mesh (source)
    // vi_d .. new VertexIndex in cm (destination)
    for (VI vi_s : mesh.vertices()) { 
        VI vi_d = mesh2result[vi_s];
        if (!vi_d.is_valid()) continue;
        cvt[vi_d] = vi_s;
    }
    mesh.remove_property_map(mesh2result);
    return {std::move(cm)};
}

References patch_source_name.

Referenced by diff_models(), and separate_patch().

Here is the caller graph for this function:

◆ create_trees()

priv::Trees priv::create_trees ( const CutMeshes & models )

Create AABB trees for check when patch is whole inside of model.

Parameters

models Source for trees

Returns: trees

                                                    {
    Trees result;
    result.reserve(models.size());
    for (const CutMesh &model : models) {
        Tree tree;
        tree.insert(faces(model).first, faces(model).second, model);
        tree.build();
        result.emplace_back(std::move(tree));
    }
    return result;
}

◆ create_volume()

void priv::create_volume	(	TriangleMesh &&	mesh,
		const ObjectID &	object_id,
		const ModelVolumeType	type,
		const Transform3d	trmat,
		const DataBase &	data
	)

static

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

{
    GUI_App         &app      = wxGetApp();
    Plater          *plater   = app.plater();
    ObjectList      *obj_list = app.obj_list();
    GLCanvas3D      *canvas   = plater->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 priv::create_message("Bad object to create volume.");
 
    if (mesh.its.empty()) 
        return priv::create_message("Can't create empty volume.");
 
    plater->take_snapshot(_L("Add Emboss text Volume"));
 
    // 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
    volume->text_configuration = data.text_configuration; // copy
 
    // discard information about rotation, should not be stored in volume
    volume->text_configuration->style.prop.angle.reset();
 
    volume->set_transformation(trmat);
 
    // 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() != GLGizmosManager::Emboss) 
        manager.open_gizmo(GLGizmosManager::Emboss);
 
    // update model and redraw scene
    //canvas->reload_scene(true);
    plater->update();
}

References _L, Slic3r::ModelObject::add_volume(), Slic3r::GUI::Plater::canvas3D(), create_message(), Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::GUI::GLGizmosManager::get_current_type(), Slic3r::GUI::GLCanvas3D::get_gizmos_manager(), Slic3r::ObjectBase::id(), Slic3r::make_cube(), Slic3r::GUI::Plater::model(), Slic3r::MODEL_PART, Slic3r::GUI::GUI_App::obj_list(), Slic3r::GUI::obj_list(), Slic3r::Model::objects, Slic3r::GUI::GLGizmosManager::open_gizmo(), Slic3r::GUI::GUI_App::plater(), Slic3r::GUI::plater(), Slic3r::GUI::ObjectList::reorder_volumes_and_get_selection(), Slic3r::GUI::ObjectList::select_item(), Slic3r::GUI::ObjectList::selection_changed(), Slic3r::GUI::Plater::take_snapshot(), Slic3r::GUI::Plater::update(), and Slic3r::GUI::GLCanvas3D::update_instance_printable_state_for_object().

Referenced by Slic3r::GUI::Emboss::CreateVolumeJob::finalize(), and Slic3r::GUI::Emboss::CreateSurfaceVolumeJob::finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cut_from_model()

priv::CutAOIs priv::cut_from_model	(	CutMesh &	cgal_model,
		const ExPolygons &	shapes,
		CutMesh &	cgal_shape,
		float	projection_ratio,
		const ExPolygonsIndices &	s2i
	)

Create AOIs(area of interest) on model surface.

Parameters

cgal_model	Input model converted to CGAL NOTE: will be extended by corefine edge
shapes	2d contours
cgal_shape	[const]Model made by shapes NOTE: Can't be definde as const because of corefine function input definition, but it is.
projection_ratio	Wanted projection distance
s2i	Convert index to shape point from ExPolygons

Returns: Patches from model surface

{
    // pointer to edge or face shape_map
    VertexShapeMap vert_shape_map = cgal_model.add_property_map<VI, const IntersectingElement*>(vert_shape_map_name, nullptr).first;
    
    // detect anomalities in visitor.
    bool is_valid = true;
    // NOTE: map are created when convert shapes to cgal model
    const EdgeShapeMap& edge_shape_map = cgal_shape.property_map<EI, IntersectingElement>(edge_shape_map_name).first;
    const FaceShapeMap& face_shape_map = cgal_shape.property_map<FI, IntersectingElement>(face_shape_map_name).first;
    Visitor visitor{cgal_model, cgal_shape, edge_shape_map, face_shape_map, vert_shape_map, &is_valid};
 
    // a property map containing the constrained-or-not status of each edge
    EdgeBoolMap ecm = cgal_model.add_property_map<EI, bool>(is_constrained_edge_name, false).first;
    const auto &p = CGAL::parameters::visitor(visitor)
                        .edge_is_constrained_map(ecm)
                        .throw_on_self_intersection(false);
    const auto& q = CGAL::parameters::do_not_modify(true);
    CGAL::Polygon_mesh_processing::corefine(cgal_model, cgal_shape, p, q);
 
    if (!is_valid) return {};
 
    FaceTypeMap face_type_map = cgal_model.add_property_map<FI, FaceType>(face_type_map_name, FaceType::not_constrained).first;
 
    // Select inside and outside face in model
    set_face_type(face_type_map, cgal_model, vert_shape_map, ecm, cgal_shape, s2i);
#ifdef DEBUG_OUTPUT_DIR
    store(cgal_model, face_type_map, DEBUG_OUTPUT_DIR + "constrained/"); // only debug
#endif // DEBUG_OUTPUT_DIR
    
    // flood fill the other faces inside the region.
    flood_fill_inner(cgal_model, face_type_map);
 
#ifdef DEBUG_OUTPUT_DIR
    store(cgal_model, face_type_map, DEBUG_OUTPUT_DIR + "filled/", true); // only debug
#endif // DEBUG_OUTPUT_DIR
        
    // IMPROVE: AOIs area could be created during flood fill
    return create_cut_area_of_interests(cgal_model, shapes, face_type_map);
}

References create_cut_area_of_interests(), edge_shape_map_name, face_shape_map_name, face_type_map_name, flood_fill_inner(), is_constrained_edge_name, is_valid(), not_constrained, set_face_type(), and vert_shape_map_name.

Referenced by Slic3r::cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cut_surface()

TriangleMesh priv::cut_surface	(	DataBase &	input1,
		const SurfaceVolumeData &	input2,
		std::function< bool()>	was_canceled
	)

static

Cut surface into triangle mesh.

Parameters

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

Returns: Extruded object from cuted surace

{
    ExPolygons shapes = create_shape(input1, was_canceled);
    if (shapes.empty())
        throw JobException(_u8L("Font doesn't have any shape for given text.").c_str());
 
    if (was_canceled()) return {};
 
    // Define alignment of text - left, right, center, top bottom, ....
    BoundingBox bb                = get_extents(shapes);
    Point       projection_center = bb.center();
    for (ExPolygon &shape : shapes) shape.translate(-projection_center);
    bb.translate(-projection_center);
 
    const FontFile &ff = *input1.font_file.font_file;
    const FontProp &fp = input1.text_configuration.style.prop;
    double shape_scale = get_shape_scale(fp, ff);
 
    const SurfaceVolumeData::ModelSources &sources = input2.sources;
    const SurfaceVolumeData::ModelSource  *biggest = nullptr;
 
    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 * input2.text_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())
        throw JobException(_u8L("There is no volume in projection direction.").c_str());
 
    Transform3d tr_inv = biggest->tr.inverse();
    Transform3d cut_projection_tr = tr_inv * input2.text_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) {
        size_t 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 bb = bounding_box(its);
        mesh_bb.merge(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);
 
    bool is_text_reflected = Slic3r::has_reflection(input2.text_tr);
    if (is_text_reflected) {
        // revert order of points in expolygons
        // CW --> CCW
        for (ExPolygon &shape : shapes) {
            shape.contour.reverse();
            for (Slic3r::Polygon &hole : shape.holes)
                hole.reverse();
        }
    }
 
    // Use CGAL to cut surface from triangle mesh
    SurfaceCut cut = cut_surface(shapes, itss, cut_projection, projection_ratio);
 
    if (is_text_reflected) {
        for (SurfaceCut::Contour &c : cut.contours)
            std::reverse(c.begin(), c.end());
        for (Vec3i &t : cut.indices)
            std::swap(t[0], t[1]);
    }
 
    if (cut.empty()) throw JobException(_u8L("There is no valid surface for text projection.").c_str());
    if (was_canceled()) return {};
 
    // !! Projection needs to transform cut
    OrthoProject3d projection = create_emboss_projection(input2.is_outside, fp.emboss, emboss_tr, cut);
    indexed_triangle_set new_its = cut2model(cut, projection);
    assert(!new_its.empty());
    if (was_canceled()) return {};
    return TriangleMesh(std::move(new_its));
}

References _u8L, Slic3r::bounding_box(), Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::SurfaceCut::contours, create_emboss_projection(), create_projection_for_cut(), create_shape(), Slic3r::cut2model(), Slic3r::cut_surface(), Slic3r::FontProp::emboss, indexed_triangle_set::empty(), Slic3r::Emboss::FontFileWithCache::font_file, Slic3r::GUI::Emboss::DataBase::font_file, Slic3r::get_extents(), Slic3r::Emboss::get_shape_scale(), Slic3r::has_reflection(), indexed_triangle_set::indices, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Slic3r::GUI::Emboss::SurfaceVolumeData::is_outside, Slic3r::its_cut_AoI(), its_transform(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::EmbossStyle::prop, Slic3r::MultiPoint::reverse(), safe_extension, Slic3r::GUI::Emboss::SurfaceVolumeData::sources, Slic3r::TextConfiguration::style, Slic3r::GUI::Emboss::DataBase::text_configuration, Slic3r::GUI::Emboss::SurfaceVolumeData::text_tr, Slic3r::GUI::Emboss::SurfaceVolumeData::ModelSource::tr, Slic3r::BoundingBoxf3::transformed(), Slic3r::BoundingBoxBase< PointType, APointsType >::translate(), and indexed_triangle_set::vertices.

Referenced by Slic3r::GUI::Emboss::CreateSurfaceVolumeJob::process(), and Slic3r::GUI::Emboss::UpdateSurfaceVolumeJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ default_vi()

const VI priv::default_vi ( std::numeric_limits< uint32_t > ::max() )

◆ diff_models()

priv::SurfacePatches priv::diff_models	(	VCutAOIs &	cuts,
		CutMeshes &	cut_models,
		CutMeshes &	models,
		const Project3d &	projection
	)

Differenciate other models.

Parameters

cuts	Patches from meshes
cut_models	Source points for Cutted AOIs NOTE: Create Reduction map as mesh property - clean on end
models	Original models without cut modifications used for differenciation NOTE: Clip function modify Mesh
projection	Define projection direction

Returns: Cuts differenciate by models - Patch

{
    // IMPROVE: when models contain ONE mesh. It is only about convert cuts to patches
    // and reduce unneccessary triangles on contour
 
    //Convert model_index and cut_index into one index
    priv::ModelCut2index m2i(cuts);
 
    // create bounding boxes for cuts
    std::vector<BoundingBoxf3> bbs = create_bbs(cuts, cut_models);
    Trees trees(models.size());
 
    SurfacePatches patches;
 
    // queue of patches for one AOI (permanent with respect to for loop)
    SurfacePatchesEx aoi_patches;
 
    //SurfacePatches aoi_patches;
    patches.reserve(m2i.get_count()); // only approximation of count
    size_t index = 0;
    for (size_t model_index = 0; model_index < models.size(); ++model_index) {
        CutAOIs &model_cuts = cuts[model_index];
        CutMesh &cut_model_ = cut_models[model_index];
        const CutMesh &cut_model = cut_model_;
        ReductionMap vertex_reduction_map = cut_model_.add_property_map<VI, VI>(vertex_reduction_map_name).first;
        create_reduce_map(vertex_reduction_map, cut_model);
 
        for (size_t cut_index = 0; cut_index < model_cuts.size(); ++cut_index, ++index) {
            const CutAOI &cut = model_cuts[cut_index];
            SurfacePatchEx patch_ex;
            SurfacePatch  &patch = patch_ex.patch;
            patch = create_surface_patch(cut.first, cut_model_, &vertex_reduction_map);
            patch.bb = bbs[index];
            patch.aoi_id   = cut_index;
            patch.model_id = model_index;
            patch.shape_id = get_shape_point_index(cut, cut_model);
            patch.is_whole_aoi = true;
 
            aoi_patches.clear();
            aoi_patches.push_back(patch_ex);
            for (size_t model_index2 = 0; model_index2 < models.size(); ++model_index2) {
                // do not clip source model itself
                if (model_index == model_index2) continue;
                for (SurfacePatchEx &patch_ex : aoi_patches) {
                    SurfacePatch &patch = patch_ex.patch;
                    if (has_bb_intersection(patch.bb, model_index2, bbs, m2i) &&
                        clip_cut(patch, models[model_index2])){
                        patch_ex.just_cliped = true;
                    } else { 
                        // build tree on demand
                        // NOTE: it is possible not neccessary: e.g. one model
                        Tree &tree = trees[model_index2];
                        if (tree.empty()) {
                            const CutMesh &model   = models[model_index2];
                            auto           f_range = faces(model);
                            tree.insert(f_range.first, f_range.second, model);
                            tree.build();
                        }
                        if (is_patch_inside_of_model(patch, tree, projection))
                            patch_ex.full_inside = true;
                    }
                }
                // erase full inside
                for (size_t i = aoi_patches.size(); i != 0; --i) {
                    auto it = aoi_patches.begin() + (i - 1);
                    if (it->full_inside) aoi_patches.erase(it);
                }
 
                // detection of full AOI inside of model
                if (aoi_patches.empty()) break;
 
                // divide cliped into parts
                size_t end = aoi_patches.size();
                for (size_t i = 0; i < end; ++i)
                    if (aoi_patches[i].just_cliped)
                        divide_patch(i, aoi_patches);
            }
 
            if (!aoi_patches.empty()) {
                patches.reserve(patches.size() + aoi_patches.size());
                for (SurfacePatchEx &patch : aoi_patches)
                    patches.push_back(std::move(patch.patch));
                
            }
        }
        cut_model_.remove_property_map(vertex_reduction_map);
    }
 
    // Also use outline inside of patches(made by non manifold models)
    // IMPROVE: trace outline from AOIs
    collect_open_edges(patches);
    return patches;
}

References priv::SurfacePatch::aoi_id, priv::SurfacePatch::bb, clip_cut(), collect_open_edges(), create_bbs(), create_reduce_map(), create_surface_patch(), divide_patch(), priv::SurfacePatchEx::full_inside, priv::ModelCut2index::get_count(), get_shape_point_index(), has_bb_intersection(), is_patch_inside_of_model(), priv::SurfacePatch::is_whole_aoi, priv::SurfacePatchEx::just_cliped, priv::SurfacePatch::model_id, priv::SurfacePatchEx::patch, priv::SurfacePatch::shape_id, and vertex_reduction_map_name.

Referenced by Slic3r::cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ divide_patch()

void priv::divide_patch	(	size_t	i,
		SurfacePatchesEx &	patches
	)

Separate connected triangles into it's own patches new patches are added to back of input patches.

Parameters

i	index into patches
patches	In/Out Patches

{
    SurfacePatchEx &patch_ex = patches[i];
    assert(patch_ex.just_cliped); 
    patch_ex.just_cliped = false;
 
    SurfacePatch& patch = patch_ex.patch;
    CutMesh& cm = patch.mesh;
    assert(!cm.faces().empty());
    std::string patch_number_name = "f:patch_number";
    CutMesh::Property_map<FI,bool> is_processed = cm.add_property_map<FI, bool>(patch_number_name, false).first;
    
    const CvtVI2VI& cvt_from = patch.mesh.property_map<VI, VI>(patch_source_name).first;
 
    std::vector<FI> fis;
    fis.reserve(cm.faces().size());
 
    SurfacePatchesEx new_patches;
    std::vector<FI> queue;
    // IMPROVE: create groups around triangles and than connect groups
    for (FI fi_cm : cm.faces()) {
        if (is_processed[fi_cm]) continue;
        assert(queue.empty());
        queue.push_back(fi_cm);
        if (!fis.empty()) {
            // Be carefull after push to patches,
            // all ref on patch contain non valid values
            SurfacePatchEx patch_ex_n;
            patch_ex_n.patch = separate_patch(fis, patch, cvt_from);
            patch_ex_n.patch.is_whole_aoi = false;
            new_patches.push_back(std::move(patch_ex_n));
            fis.clear();
        }
        // flood fill from triangle fi_cm to surrounding
        do {
            FI fi_q = queue.back();
            queue.pop_back();
            if (is_processed[fi_q]) continue;             
            is_processed[fi_q] = true;
            fis.push_back(fi_q);
            HI hi = cm.halfedge(fi_q);
            for (FI fi : cm.faces_around_face(hi)) {
                // by documentation The face descriptor may be the null face, and it may be several times the same face descriptor.
                if (!fi.is_valid()) continue;
                if (!is_processed[fi]) queue.push_back(fi);
            }
        } while (!queue.empty());
    }
    cm.remove_property_map(is_processed);
    assert(!fis.empty());
 
    // speed up for only one patch - no dividing (the most common)
    if (new_patches.empty()) {
        patch.bb = bounding_box(cm);
        patch.is_whole_aoi = false;
    } else {
        patch = separate_patch(fis, patch, cvt_from);
        patches.insert(patches.end(), new_patches.begin(), new_patches.end());
    }
}

References priv::SurfacePatch::bb, bounding_box(), priv::SurfacePatch::is_whole_aoi, priv::SurfacePatchEx::just_cliped, priv::SurfacePatch::mesh, priv::SurfacePatchEx::patch, patch_source_name, and separate_patch().

Referenced by diff_models().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_button()

bool priv::draw_button	(	const IconManager::VIcons &	icons,
		IconType	type,
		bool	disable = `false`
	)

static

{
    return Slic3r::GUI::button(
        get_icon(icons, type, IconState::activable),
        get_icon(icons, type, IconState::hovered),
        get_icon(icons, type, IconState::disabled),
        disable
    );
}

References Slic3r::GUI::button(), and get_icon().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_bold_button(), Slic3r::GUI::GLGizmoEmboss::draw_delete_style_button(), Slic3r::GUI::GLGizmoEmboss::draw_font_list(), Slic3r::GUI::GLGizmoEmboss::draw_font_list_line(), Slic3r::GUI::GLGizmoEmboss::draw_italic_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_add_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_rename_button(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_button(), and Slic3r::GUI::GLGizmoEmboss::revertible().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw_transparent_icon()

void priv::draw_transparent_icon ( const IconManager::Icon & icon )

static

{
    // Check input
    if (!icon.is_valid()) {
        assert(false);
        BOOST_LOG_TRIVIAL(warning) << "Drawing invalid Icon.";
        ImGui::Text("?");
        return;
    }
 
    // size UV texture coors [in texture ratio]
    ImVec2 size_uv(icon.br.x - icon.tl.x, icon.br.y - icon.tl.y);
    ImVec2 one_px(size_uv.x / icon.size.x, size_uv.y / icon.size.y);
 
    // use top left corner of first icon
    IconManager::Icon icon_px = icon; // copy
    // reduce uv coors to one pixel
    icon_px.tl = ImVec2(0, 0);
    icon_px.br = one_px;
    draw(icon_px);
}

References Slic3r::GUI::IconManager::Icon::br, Slic3r::GUI::draw(), Slic3r::GUI::IconManager::Icon::is_valid(), Slic3r::GUI::IconManager::Icon::size, ImGui::Text(), Slic3r::GUI::IconManager::Icon::tl, ImVec2::x, and ImVec2::y.

Referenced by Slic3r::GUI::clickable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ exist_duplicit_vertex()

bool priv::exist_duplicit_vertex ( const CutMesh & mesh )

                                                    {
    std::vector<Vec3d> points;
    points.reserve(mesh.vertices().size());
    // copy points
    for (VI vi : mesh.vertices()) { 
        const P3 &p = mesh.point(vi);
        points.emplace_back(p.x(), p.y(), p.z());
    }
    std::sort(points.begin(), points.end(), [](const Vec3d &v1, const Vec3d &v2) {
        return v1.x() < v2.x() || 
              (v1.x() == v2.x() && 
                  (v1.y() < v2.y() || 
                  (v1.y() == v2.y()  && 
                      v1.z() < v2.z())));
    });
    // find first duplicit
    auto it = std::adjacent_find(points.begin(), points.end());
    return it != points.end();
}

Referenced by to_cgal().

Here is the caller graph for this function:

◆ fill_polygon_distances()

void priv::fill_polygon_distances	(	const ProjectionDistance &	pd,
		uint32_t	index,
		const ExPolygonsIndex &	id,
		ProjectionDistances &	result,
		const ExPolygon &	shape,
		const VDistances &	distances
	)

{
    const Points& points = (id.polygon_index == 0) ?
                                            shape.contour.points :
                                            shape.holes[id.polygon_index - 1].points;
    // border of indexes for Polygon
    uint32_t first_index = index - id.point_index;
    uint32_t last_index  = first_index + points.size();        
 
    uint32_t act_index = index;
    const ProjectionDistance* act_pd = &pd;
 
    // Copy starting pd to result
    result[act_index] = pd;
 
    auto exist_next = [&distances, &act_index, &act_pd, &result]
    (uint32_t nxt_index) {
        const ProjectionDistance *nxt_pd = get_closest_projection(distances[nxt_index] ,act_pd->distance);
        // exist next projection distance ?
        if (nxt_pd == nullptr) return false;
 
        // check no rewrite result
        assert(result[nxt_index].aoi_index == std::numeric_limits<uint32_t>::max());
        // copy founded projection to result
        result[nxt_index] = *nxt_pd; // copy
 
        // next
        act_index = nxt_index;
        act_pd    = &result[nxt_index];
        return true;
    };
 
    // last index in circle
    uint32_t finish_index = (index == first_index) ? (last_index - 1) :
                                                        (index - 1);
    // Positive iteration inside polygon
    do {
        uint32_t nxt_index = act_index + 1;
        // close loop of indexes inside of contour
        if (nxt_index == last_index) nxt_index = first_index;
        // check that exist next 
        if (!exist_next(nxt_index)) break;            
    } while (act_index != finish_index);
 
    // when all results for polygon are set no neccessary to iterate negative
    if (act_index == finish_index) return;
 
    act_index = index;
    act_pd    = &pd;
    // Negative iteration inside polygon
    do {
        uint32_t nxt_index = (act_index == first_index) ? 
            (last_index-1) : (act_index - 1);
        // When iterate negative it must be split to parts
        // and can't iterate in circle
        assert(nxt_index != index);
        // check that exist next 
        if (!exist_next(nxt_index)) break;
    } while (true);
}

References Slic3r::ExPolygon::contour, priv::ProjectionDistance::distance, get_closest_projection(), Slic3r::ExPolygon::holes, and Slic3r::MultiPoint::points.

Referenced by fill_shape_distances().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fill_shape_distances()

void priv::fill_shape_distances	(	uint32_t	start_index,
		const ProjectionDistance *	start_pd,
		ProjectionDistances &	result,
		const ExPolygonsIndices &	s2i,
		const ExPolygon &	shape,
		const VDistances &	distances
	)

{
    uint32_t expolygons_index = s2i.cvt(start_index).expolygons_index;
    uint32_t first_shape_index = s2i.cvt({expolygons_index, 0, 0});
    do {
        fill_polygon_distances(*start_pd, start_index, s2i.cvt(start_index),result, shape, distances);
        // seaching only inside shape, return index of closed finished point
        auto find_close_finished_point = [&first_shape_index, &shape, &result]
        (const Point &p) -> ClosePoint {
            uint32_t index = first_shape_index;                
            ClosePoint cp;
            auto check_finished_points = [&cp, &result, &index, &p]
            (const Points& pts) { 
                for (const Point &p_ : pts) {
                    // finished point with some distances
                    if (result[index].aoi_index == std::numeric_limits<uint32_t>::max()) {
                        ++index;
                        continue;
                    }
                    float distance = calc_size_sq(p_ - p);
                    if (cp.dist_sq > distance) { 
                        cp.dist_sq = distance;
                        cp.index   = index;
                    }
                    ++index;
                }
            };
            check_finished_points(shape.contour.points);
            for (const Polygon &h : shape.holes)
                check_finished_points(h.points);
            return cp;
        };
                        
        // find next closest pair of points
        // (finished + unfinished) in ExPolygon
        start_index = std::numeric_limits<uint32_t>::max(); // unfinished_index
        uint32_t finished_index = std::numeric_limits<uint32_t>::max();
        float dist_sq = std::numeric_limits<float>::max();
 
        // first index in shape
        uint32_t index = first_shape_index;
        auto check_unfinished_points = [&index, &result, &distances, &find_close_finished_point, &dist_sq, &start_index, &finished_index]
        (const Points& pts) { 
            for (const Point &p : pts) {
                // try find unfinished
                if (result[index].aoi_index !=
                    std::numeric_limits<uint32_t>::max() ||
                    distances[index].empty()) {
                    ++index;
                    continue;
                }
                ClosePoint cp = find_close_finished_point(p);
                if (dist_sq > cp.dist_sq) { 
                    dist_sq = cp.dist_sq;
                    start_index = index;
                    finished_index = cp.index;
                }
                ++index;
            }
        };
        // for each unfinished points
        check_unfinished_points(shape.contour.points);
        for (const Polygon &h : shape.holes)
            check_unfinished_points(h.points);
    } while (start_index != std::numeric_limits<uint32_t>::max());
}

References calc_size_sq(), Slic3r::ExPolygonsIndices::cvt(), priv::ClosePoint::dist_sq, fill_polygon_distances(), and priv::ClosePoint::index.

Referenced by choose_best_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalize()

bool priv::finalize	(	bool	canceled,
		std::exception_ptr &	eptr,
		const DataBase &	input
	)

static

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

References input(), and process().

Referenced by Slic3r::GUI::Emboss::CreateVolumeJob::finalize(), Slic3r::GUI::Emboss::CreateObjectJob::finalize(), Slic3r::GUI::Emboss::UpdateJob::finalize(), Slic3r::GUI::Emboss::CreateSurfaceVolumeJob::finalize(), and Slic3r::GUI::Emboss::UpdateSurfaceVolumeJob::finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_close_point()

priv::ClosePoint priv::find_close_point	(	const Point &	p,
		ProjectionDistances &	result,
		std::vector< bool > &	finished_shapes,
		const ExPolygonsIndices &	s2i,
		const ExPolygons &	shapes
	)

{
    // result
    ClosePoint cp;
    // for all finished points
    for (uint32_t shape_index = 0; shape_index < shapes.size(); ++shape_index) {
        if (!finished_shapes[shape_index]) continue;
        const ExPolygon &shape = shapes[shape_index];
        uint32_t index = s2i.cvt({shape_index, 0, 0});
        auto find_close_point_in_points = [&p, &cp, &index, &result]
        (const Points &pts){
            for (const Point &p_ : pts) {
                // Exist result (is finished) ?
                if (result[index].aoi_index ==
                    std::numeric_limits<uint32_t>::max()) {
                    ++index;
                    continue;
                }
                float distance_sq = calc_size_sq(p - p_);
                if (cp.dist_sq > distance_sq) { 
                    cp.dist_sq = distance_sq;
                    cp.index = index;
                }
                ++index;
            }
        };
        find_close_point_in_points(shape.contour.points);
        // shape could be inside of another shape's hole
        for (const Polygon& h:shape.holes)
            find_close_point_in_points(h.points);
    }
    return cp;
}

References calc_size_sq(), Slic3r::ExPolygon::contour, Slic3r::ExPolygonsIndices::cvt(), Slic3r::ExPolygon::holes, and Slic3r::MultiPoint::points.

Here is the call graph for this function:

◆ find_closest_point_index()

uint32_t priv::find_closest_point_index	(	const Point &	p,
		const ExPolygons &	shapes,
		const ExPolygonsIndices &	s2i,
		const std::vector< bool > &	mask
	)

{    
    SearchData sd = create_search_data(shapes, mask);
    size_t line_idx = std::numeric_limits<size_t>::max();
    Vec2d  hit_point;
    Vec2d  p_d = p.cast<double>();
    [[maybe_unused]] double distance_sq =
        AABBTreeLines::squared_distance_to_indexed_lines(
        sd.lines, sd.tree, p_d, line_idx, hit_point);
    assert(distance_sq > 0);
    
    // IMPROVE: one could use line ratio to find closest point
    return get_closest_point_index(sd, line_idx, hit_point, shapes, s2i);
}

References create_search_data(), get_closest_point_index(), priv::SearchData::lines, Slic3r::AABBTreeLines::squared_distance_to_indexed_lines(), and priv::SearchData::tree.

Referenced by choose_best_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_closest_point_pair()

std::pair< uint32_t, uint32_t > priv::find_closest_point_pair	(	const ExPolygons &	shapes,
		const std::vector< bool > &	done_shapes,
		const ExPolygonsIndices &	s2i,
		const std::vector< bool > &	mask
	)

{
    assert(mask.size() == s2i.get_count());
    assert(done_shapes.size() == shapes.size());
    std::vector<bool> unfinished_mask = mask; // copy
 
    size_t index = 0;
    for (size_t shape_index = 0; shape_index < shapes.size(); shape_index++) {
        size_t count = count_points(shapes[shape_index]);
        if (done_shapes[shape_index]) { 
            for (size_t i = 0; i < count; ++i, ++index)
                unfinished_mask[index] = false;
        } else {
            index += count;
        }
    }
    assert(index == s2i.get_count());
    SearchData sd = create_search_data(shapes, unfinished_mask);
 
    struct ClosestPair
    {
        size_t finish_idx          = std::numeric_limits<size_t>::max();
        size_t unfinished_line_idx = std::numeric_limits<size_t>::max();
        Vec2d  hit_point           = Vec2d();
        double distance_sq         = std::numeric_limits<double>::max();
    } cp;
 
    index = 0;
    for (size_t shape_index = 0; shape_index < shapes.size(); shape_index++) {
        const ExPolygon shape = shapes[shape_index];
        if (!done_shapes[shape_index]) {            
            index += count_points(shape);
            continue;
        }        
 
        auto search_in_polygon = [&index, &cp, &sd, &mask](const Polygon& polygon) {
            for (size_t i = 0; i < polygon.size(); ++i, ++index) { 
                if (mask[index] == false) continue;
                Vec2d p_d = polygon[i].cast<double>();
                size_t line_idx = std::numeric_limits<size_t>::max();
                Vec2d  hit_point;
                double distance_sq = AABBTreeLines::squared_distance_to_indexed_lines(
                    sd.lines, sd.tree, p_d, line_idx, hit_point, cp.distance_sq);
                if (distance_sq < 0 || 
                    distance_sq >= cp.distance_sq) continue;
                assert(line_idx < sd.lines.size());
                cp.distance_sq         = distance_sq;
                cp.unfinished_line_idx = line_idx;
                cp.hit_point           = hit_point;
                cp.finish_idx          = index;
            }
        };
        search_in_polygon(shape.contour);
        for (const Polygon& hole: shape.holes)
            search_in_polygon(hole);
    }
    assert(index == s2i.get_count());
    // check that exists result
    if (cp.finish_idx == std::numeric_limits<size_t>::max()) {
        return std::make_pair(std::numeric_limits<size_t>::max(),
                              std::numeric_limits<size_t>::max());
    }
 
    size_t unfinished_idx = get_closest_point_index(sd, cp.unfinished_line_idx, cp.hit_point, shapes, s2i);
    return std::make_pair(cp.finish_idx, unfinished_idx);
}

References Slic3r::ExPolygon::contour, Slic3r::count_points(), create_search_data(), get_closest_point_index(), Slic3r::ExPolygonsIndices::get_count(), Slic3r::ExPolygon::holes, and Slic3r::AABBTreeLines::squared_distance_to_indexed_lines().

Referenced by choose_best_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_closest_volume()

void priv::find_closest_volume	(	const Selection &	selection,
		const Vec2d &	screen_center,
		const Camera &	camera,
		const ModelObjectPtrs &	objects,
		Vec2d *	closest_center,
		const GLVolume **	closest_volume
	)

static

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

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
closest_volume	OUT: closest volume

{
    assert(closest_center != nullptr);
    assert(closest_volume != nullptr);
    assert(*closest_volume == nullptr);
    const Selection::IndicesList &indices = selection.get_volume_idxs();
    assert(!indices.empty()); // no selected volume
    if (indices.empty()) return;
 
    double center_sq_distance = std::numeric_limits<double>::max();
    for (unsigned int id : indices) {
        const GLVolume *gl_volume = selection.get_volume(id);
        const ModelVolume *volume = get_model_volume(*gl_volume, objects);
        if (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_volume = gl_volume;
    }
}

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

Referenced by Slic3r::GUI::GLGizmoEmboss::create_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flood_fill_inner()

void priv::flood_fill_inner	(	const CutMesh &	mesh,
		FaceTypeMap &	face_type_map
	)

Change FaceType from not_constrained to inside For neighbor(or neighbor of neighbor of ...) of inside triangles. Process only not_constrained triangles.

Parameters

mesh	Corefined mesh
face_type_map	In/Out map with faces type

{
    std::vector<FI> process;
    // guess count of connected not constrained triangles
    size_t guess_size = 128;
    process.reserve(guess_size);
 
    // check if neighbor(one of three in triangle) has type inside
    auto has_inside_neighbor = [&mesh, &face_type_map](FI fi) {
        HI hi     = mesh.halfedge(fi);
        HI hi_end = hi;
        auto exist_next = [&hi, &hi_end, &mesh]() -> bool {
            hi = mesh.next(hi);
            return hi != hi_end;
        };
        // loop over 3 half edges of face
        do {
            HI hi_opposite = mesh.opposite(hi);
            // open edge doesn't have opposit half edge
            if (!hi_opposite.is_valid()) continue;
            FI fi_opposite = mesh.face(hi_opposite);
            if (!fi_opposite.is_valid()) continue;
            if (face_type_map[fi_opposite] == FaceType::inside) return true;
        } while (exist_next());
        return false;
    };
 
    for (FI fi : mesh.faces()) {
        FaceType type = face_type_map[fi];
        if (type != FaceType::not_constrained) continue;
        if (!has_inside_neighbor(fi)) continue;
        assert(process.empty());
        process.push_back(fi); 
        //store(mesh, face_type_map, DEBUG_OUTPUT_DIR + "progress.off");
 
        while (!process.empty()) {
            FI process_fi = process.back();
            process.pop_back();
            // Do not fill twice
            FaceType& process_type = face_type_map[process_fi];
            if (process_type == FaceType::inside) continue;
            process_type = FaceType::inside;
 
            // check neighbor triangle
            HI hi = mesh.halfedge(process_fi);
            HI hi_end = hi;
            auto exist_next = [&hi, &hi_end, &mesh]() -> bool {
                hi = mesh.next(hi);
                return hi != hi_end;
            };
            do {
                HI hi_opposite = mesh.opposite(hi);
                // open edge doesn't have opposit half edge
                if (!hi_opposite.is_valid()) continue;                
                FI fi_opposite = mesh.face(hi_opposite);
                if (!fi_opposite.is_valid()) continue;                
                FaceType type_opposite = face_type_map[fi_opposite];
                if (type_opposite == FaceType::not_constrained)
                    process.push_back(fi_opposite);
            } while (exist_next());
        }
    }
}

References inside, not_constrained, and process().

Referenced by cut_from_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_closest_point_index()

uint32_t priv::get_closest_point_index	(	const SearchData &	sd,
		size_t	line_idx,
		const Vec2d &	hit_point,
		const ExPolygons &	shapes,
		const ExPolygonsIndices &	s2i
	)

{
    const Linef &line = sd.lines[line_idx];
    Vec2d dir = line.a - line.b;
    Vec2d dir_abs = dir.cwiseAbs();
    // use x coordinate
    int i = (dir_abs.x() > dir_abs.y())? 0 :1;
 
    bool use_index = abs(line.a[i] - hit_point[i]) >
                     abs(line.b[i] - hit_point[i]);
    size_t point_index = sd.cvt[line_idx];
 
    // Lambda used only for check result
    [[maybe_unused]] auto is_same = [&s2i, &shapes]
    (const Vec2d &p, size_t i) -> bool {
        auto id = s2i.cvt(i);
        const ExPolygon &shape = shapes[id.expolygons_index];
        const Polygon   &poly  = (id.polygon_index == 0) ?
                                           shape.contour :
                                           shape.holes[id.polygon_index - 1];
        Vec2i p_ = p.cast<int>();
        return p_ == poly[id.point_index];
    };
 
    if (use_index) { 
        assert(is_same(line.b, point_index));
        return point_index; 
    }
    auto id = s2i.cvt(point_index);
    if (id.point_index != 0) {
        assert(is_same(line.a, point_index - 1));
        return point_index - 1;
    }
    const ExPolygon &shape = shapes[id.expolygons_index];
    size_t count_polygon_points = (id.polygon_index == 0) ?
        shape.contour.size() :
        shape.holes[id.polygon_index - 1].size();
    size_t prev_point_index = point_index  + (count_polygon_points - 1);
    assert(is_same(line.a, prev_point_index));
    // return previous point index
    return prev_point_index;
}

References Slic3r::Linef::a, Slic3r::Linef::b, Slic3r::ExPolygon::contour, priv::SearchData::cvt, Slic3r::ExPolygonsIndices::cvt(), Slic3r::ExPolygon::holes, priv::SearchData::lines, and Slic3r::MultiPoint::size().

Referenced by find_closest_point_index(), and find_closest_point_pair().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_closest_projection()

const priv::ProjectionDistance * priv::get_closest_projection	(	const ProjectionDistances &	distance,
		float	wanted_distance
	)

{
    // minimal distance
    float min_d = std::numeric_limits<float>::max();
    const ProjectionDistance *min_pd = nullptr;
    for (const ProjectionDistance &pd : distance) { 
        float d = std::fabs(pd.distance - wanted_distance);
        // There should be limit for maximal distance
        if (min_d > d) { 
            min_d = d;
            min_pd = &pd;
        }
    }
    return min_pd;
}

Referenced by choose_best_distance(), and fill_polygon_distances().

Here is the caller graph for this function:

◆ get_glyph() [1/2]

std::optional< Glyph > priv::get_glyph	(	const stbtt_fontinfo &	font_info,
		int	unicode_letter,
		float	flatness
	)

{
    int glyph_index = stbtt_FindGlyphIndex(&font_info, unicode_letter);
    if (glyph_index == 0) {
        //wchar_t wchar = static_cast<wchar_t>(unicode_letter); 
        //<< "Character unicode letter ("
        //<< "decimal value = " << std::dec << unicode_letter << ", "
        //<< "hexadecimal value = U+" << std::hex << unicode_letter << std::dec << ", "
        //<< "wchar value = " << wchar
        //<< ") is NOT defined inside of the font. \n";
        return {};
    }
 
    Glyph glyph;
    stbtt_GetGlyphHMetrics(&font_info, glyph_index, &glyph.advance_width, &glyph.left_side_bearing);
 
    stbtt_vertex *vertices;
    int num_verts = stbtt_GetGlyphShape(&font_info, glyph_index, &vertices);
    if (num_verts <= 0) return glyph; // no shape
    ScopeGuard sg1([&vertices]() { free(vertices); });
 
    int *contour_lengths = NULL;
    int  num_countour_int = 0;
    stbtt__point *points = stbtt_FlattenCurves(vertices, num_verts,
        flatness, &contour_lengths, &num_countour_int, font_info.userdata);
    if (!points) return glyph; // no valid flattening
    ScopeGuard sg2([&contour_lengths, &points]() {
        free(contour_lengths); 
        free(points); 
    });
 
    size_t   num_contour = static_cast<size_t>(num_countour_int);
    Polygons glyph_polygons;
    glyph_polygons.reserve(num_contour);
    size_t pi = 0; // point index
    for (size_t ci = 0; ci < num_contour; ++ci) {
        int length = contour_lengths[ci];
        // check minimal length for triangle
        if (length < 4) {
            // weird font
            pi+=length;
            continue;
        }
        // last point is first point
        --length;
        Points pts;
        pts.reserve(length);
        for (int i = 0; i < length; ++i) 
            pts.emplace_back(to_point(points[pi++]));
        
        // last point is first point --> closed contour
        assert(pts.front() == to_point(points[pi]));
        ++pi;
 
        // change outer cw to ccw and inner ccw to cw order
        std::reverse(pts.begin(), pts.end());
        glyph_polygons.emplace_back(pts);
    }
    if (!glyph_polygons.empty())
        glyph.shape = Emboss::heal_shape(glyph_polygons);
    return glyph;
}

References Slic3r::Emboss::Glyph::advance_width, free(), Slic3r::Emboss::heal_shape(), Slic3r::Emboss::Glyph::left_side_bearing, Slic3r::length(), Slic3r::Emboss::Glyph::shape, stbtt_FindGlyphIndex(), stbtt_GetGlyphHMetrics(), stbtt_GetGlyphShape(), to_point(), and stbtt_fontinfo::userdata.

Referenced by get_glyph(), Slic3r::Emboss::letter2glyph(), and Slic3r::Emboss::text2shapes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_glyph() [2/2]

const Glyph * priv::get_glyph	(	int	unicode,
		const FontFile &	font,
		const FontProp &	font_prop,
		Glyphs &	cache,
		fontinfo_opt &	font_info_opt
	)

{
    // TODO: Use resolution by printer configuration, or add it into FontProp
    const float RESOLUTION = 0.0125f; // [in mm]
    auto glyph_item = cache.find(unicode);
    if (glyph_item != cache.end()) return &glyph_item->second;
 
    unsigned int font_index = font_prop.collection_number.value_or(0);
    if (!is_valid(font, font_index)) return nullptr;
 
    if (!font_info_opt.has_value()) {
        
        font_info_opt  = priv::load_font_info(font.data->data(), font_index);
        // can load font info?
        if (!font_info_opt.has_value()) return nullptr;
    }
 
    float flatness = font.infos[font_index].ascent * RESOLUTION / font_prop.size_in_mm;
 
    // Fix for very small flatness because it create huge amount of points from curve
    if (flatness < RESOLUTION) flatness = RESOLUTION;
 
    std::optional<Glyph> glyph_opt =
        priv::get_glyph(*font_info_opt, unicode, flatness);
 
    // IMPROVE: multiple loadig glyph without data
    // has definition inside of font?
    if (!glyph_opt.has_value()) return nullptr;
 
    if (font_prop.char_gap.has_value()) 
        glyph_opt->advance_width += *font_prop.char_gap;
 
    // scale glyph size
    glyph_opt->advance_width = 
        static_cast<int>(glyph_opt->advance_width / SHAPE_SCALE);
    glyph_opt->left_side_bearing = 
        static_cast<int>(glyph_opt->left_side_bearing / SHAPE_SCALE);
 
    if (!glyph_opt->shape.empty()) {
        if (font_prop.boldness.has_value()) {
            float delta = *font_prop.boldness / SHAPE_SCALE /
                          font_prop.size_in_mm;
            glyph_opt->shape = Slic3r::union_ex(offset_ex(glyph_opt->shape, delta));
        }
        if (font_prop.skew.has_value()) {
            double ratio = *font_prop.skew;
            auto skew = [&ratio](Polygon &polygon) {
                for (Slic3r::Point &p : polygon.points)
                    p.x() += static_cast<Point::coord_type>(std::round(p.y() * ratio));
            };
            for (ExPolygon &expolygon : glyph_opt->shape) {
                skew(expolygon.contour);
                for (Polygon &hole : expolygon.holes) skew(hole);
            }
        }
    }
    auto it = cache.insert({unicode, std::move(*glyph_opt)});
    assert(it.second);
    return &it.first->second;
}

References Slic3r::FontProp::boldness, Slic3r::FontProp::char_gap, Slic3r::FontProp::collection_number, Slic3r::Emboss::FontFile::data, get_glyph(), Slic3r::Emboss::FontFile::infos, is_valid(), load_font_info(), Slic3r::offset_ex(), Slic3r::Emboss::SHAPE_SCALE, Slic3r::FontProp::size_in_mm, Slic3r::FontProp::skew, and Slic3r::union_ex().

Here is the call graph for this function:

◆ get_icon()

const IconManager::Icon & priv::get_icon	(	const IconManager::VIcons &	icons,
		IconType	type,
		IconState	state
	)

3409{ return *icons[(unsigned) type][(unsigned) state]; }

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_bold_button(), draw_button(), Slic3r::GUI::GLGizmoEmboss::draw_italic_button(), and Slic3r::GUI::GLGizmoEmboss::draw_text_input().

Here is the caller graph for this function:

◆ get_shape_point_index()

uint32_t priv::get_shape_point_index	(	const CutAOI &	cut,
		const CutMesh &	model
	)

Return some shape point index which identify shape NOTE: Used to find expolygon index.

Parameters

cut	Used to search source shapes poin
model

Returns: shape point index

{
    // map is created during intersection by corefine visitor
    const VertexShapeMap &vert_shape_map = model.property_map<VI, const IntersectingElement *>(vert_shape_map_name).first;
    // for each half edge of outline
    for (HI hi : cut.second) {
        VI vi = model.source(hi);
        const IntersectingElement *ie = vert_shape_map[vi];
        if (ie == nullptr) continue;
        assert(ie->shape_point_index != std::numeric_limits<uint32_t>::max());
        return ie->shape_point_index;
    }
    // can't found any intersecting element in cut
    assert(false);
    return 0;
}

References priv::IntersectingElement::shape_point_index, and vert_shape_map_name.

Referenced by diff_models().

Here is the caller graph for this function:

◆ get_states()

const std::vector< std::pair< int, bool > > & priv::get_states ( IconManager::RasterType type )

static

                                                                                {
    static std::vector<std::pair<int, bool>> color = {std::make_pair(0, false)};
    static std::vector<std::pair<int, bool>> white = {std::make_pair(1, false)};
    static std::vector<std::pair<int, bool>> gray = {std::make_pair(2, false)};
    static std::vector<std::pair<int, bool>> color_wite_gray = {
        std::make_pair(1, false), // Activable
        std::make_pair(0, false), // Hovered
        std::make_pair(2, false)  // Disabled
    };
 
    switch (type) {
    case IconManager::RasterType::color: return color;
    case IconManager::RasterType::white_only_data: return white;
    case IconManager::RasterType::gray_only_data: return gray;
    case IconManager::RasterType::color_wite_gray: return color_wite_gray;
    default: return color;
    }
}

References Slic3r::GUI::IconManager::color, Slic3r::GUI::IconManager::color_wite_gray, Slic3r::GUI::IconManager::gray_only_data, and Slic3r::GUI::IconManager::white_only_data.

Referenced by Slic3r::GUI::IconManager::init().

Here is the caller graph for this function:

◆ get_volume()

ModelVolume * priv::get_volume	(	ModelObjectPtrs &	objects,
		const ObjectID &	volume_id
	)

static

Select Volume from objects.

Parameters

objects	All objects in scene
volume_id	Identifier of volume in object

Returns: Pointer to volume when exist otherwise nullptr

{
    for (ModelObject *obj : objects)
        for (ModelVolume *vol : obj->volumes)
            if (vol->id() == volume_id) return vol;
    return nullptr;
};

◆ has_bb_intersection()

bool priv::has_bb_intersection	(	const BoundingBoxf3 &	bb,
		size_t	model_index,
		const BBS &	bbs,
		const ModelCut2index &	m2i
	)

Check whether bounding box has intersection with model.

Parameters

bb	Bounding box to check
model_index	Model to check with
bbs	All bounding boxes from VCutAOIs
m2i	Help index into VCutAOIs

Returns: True when exist bounding boxes intersection

{
    const auto&offsets = m2i.get_offsets();
    // for cut index with model_index2
    size_t start = offsets[model_index];
    size_t next  = model_index + 1;
    size_t end   = (next < offsets.size()) ? offsets[next] : m2i.get_count();
    for (size_t bb_index = start; bb_index < end; bb_index++)
        if (bb.intersects(bbs[bb_index])) return true;
    return false;
}

References priv::ModelCut2index::get_count(), priv::ModelCut2index::get_offsets(), and Slic3r::BoundingBox3Base< PointType >::intersects().

Referenced by diff_models().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_bidirectional_constrained()

bool priv::has_bidirectional_constrained ( const Triangulation::HalfEdges & constrained )

inline

{
    for (const auto &c : constrained) {
        auto key = std::make_pair(c.second, c.first);
        auto it  = std::lower_bound(constrained.begin(), constrained.end(),
                                    key);
        if (it != constrained.end() && *it == key) return true;
    }
    return false;
}

Referenced by Slic3r::Triangulation::triangulate().

Here is the caller graph for this function:

◆ has_self_intersection()

bool priv::has_self_intersection	(	const Points &	points,
		const Triangulation::HalfEdges &	constrained_half_edges
	)

inline

{
    Lines lines;
    lines.reserve(constrained_half_edges.size());
    for (const auto &he : constrained_half_edges)
        lines.emplace_back(points[he.first], points[he.second]);
    return !intersection_points(lines).empty();
}

References Slic3r::intersection_points().

Referenced by Slic3r::Triangulation::triangulate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ heal_dupl_inter()

bool priv::heal_dupl_inter	(	ExPolygons &	shape,
		unsigned	max_iteration
	)

{    
    if (shape.empty()) return true;
 
    // create loop permanent memory
    Polygons holes;
    Points intersections;
    while (--max_iteration) {
        priv::remove_same_neighbor(shape);
        Pointfs intersections_f = intersection_points(shape);
 
        // convert intersections into Points
        assert(intersections.empty());
        intersections.reserve(intersections_f.size());
        std::transform(intersections_f.begin(), intersections_f.end(), std::back_inserter(intersections),
                       [](const Vec2d &p) { return Point(std::floor(p.x()), std::floor(p.y())); });
 
        // intersections should be unique poits
        std::sort(intersections.begin(), intersections.end());
        auto it = std::unique(intersections.begin(), intersections.end());
        intersections.erase(it, intersections.end());
 
        Points duplicates = collect_duplicates(to_points(shape));
        // duplicates are already uniqua and sorted
 
        // Check whether shape is already healed
        if (intersections.empty() && duplicates.empty())
            return true;
 
        assert(holes.empty());
        holes.reserve(intersections.size() + duplicates.size());
 
        remove_spikes_in_duplicates(shape, duplicates);
 
        // Fix self intersection in result by subtracting hole 2x2
        for (const Point &p : intersections) {
            Polygon hole(priv::pts_2x2);
            hole.translate(p);
            holes.push_back(hole);
        }
 
        // Fix duplicit points by hole 3x3 around duplicit point
        for (const Point &p : duplicates) {
            Polygon hole(priv::pts_3x3);
            hole.translate(p);
            holes.push_back(hole);
        }
 
        shape = Slic3r::diff_ex(shape, holes, ApplySafetyOffset::Yes);
 
        // prepare for next loop
        holes.clear();
        intersections.clear();
    }
 
    //priv::visualize_heal("C:/data/temp/heal.svg", shape);
    assert(false);
    shape = {priv::create_bounding_rect(shape)};
    return false;
}

References Slic3r::collect_duplicates(), create_bounding_rect(), Slic3r::diff_ex(), Slic3r::holes(), Slic3r::intersection_points(), pts_2x2(), pts_3x3(), remove_same_neighbor(), remove_spikes_in_duplicates(), Slic3r::to_points(), and Slic3r::MultiPoint::translate().

Referenced by Slic3r::Emboss::heal_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_edges() [1/2]

void priv::insert_edges	(	Triangulation::HalfEdges &	edges,
		uint32_t &	offset,
		const Polygon &	polygon
	)

inline

                                                                                                  {
    const Points &pts = polygon.points;
    uint32_t size = static_cast<uint32_t>(pts.size());
    uint32_t prev_index = offset + size - 1;
    for (uint32_t i = 0; i < size; ++i) {
        uint32_t index = offset + i;
        edges.push_back({prev_index, index});
        prev_index = index;
    }
    offset += size;
}

References Slic3r::offset(), and Slic3r::MultiPoint::points.

Here is the call graph for this function:

◆ insert_edges() [2/2]

void priv::insert_edges	(	Triangulation::HalfEdges &	edges,
		uint32_t &	offset,
		const Polygon &	polygon,
		const Triangulation::Changes &	changes
	)

inline

                                                                                                                                       {
    const Points &pts = polygon.points;
    uint32_t size = static_cast<uint32_t>(pts.size());
    uint32_t last_index = offset + size - 1;
    uint32_t prev_index = changes[last_index];
    for (uint32_t i = 0; i < size; ++i) {
        uint32_t index = changes[offset + i];
        // when duplicit points are neighbor
        if (prev_index == index) continue; 
        edges.push_back({prev_index, index});
        prev_index = index;
    }
    offset += size;
}

References Slic3r::offset(), and Slic3r::MultiPoint::points.

Referenced by Slic3r::Triangulation::triangulate(), Slic3r::Triangulation::triangulate(), Slic3r::Triangulation::triangulate(), and Slic3r::Triangulation::triangulate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_all_on_one_side()

bool priv::is_all_on_one_side	(	const Vec3i &	t,
		const IsOnSides &	is_on_sides
	)

Check if triangle t has all vertices out of any plane.

Parameters

t	Triangle
is_on_sides	Flag is vertex index out of plane

Returns: True when triangle is out of one of plane

                                                                          {
    for (size_t side = 0; side < 4; side++) {
        bool result = true;
        for (auto vi : t) {
            if (!is_on_sides[vi][side]) {
                result = false;
                break;
            }
        }
        if (result) return true;
    }
    return false;
}

◆ is_face_inside()

bool priv::is_face_inside	(	HI	hi,
		const CutMesh &	mesh,
		const CutMesh &	shape_mesh,
		const VertexShapeMap &	vertex_shape_map,
		const ExPolygonsIndices &	shape2index
	)

Distiquish face type for half edge.

Parameters

hi	Define face
mesh	Mesh to process
shape_mesh	Vertices of mesh made by shapes
vertex_shape_map	Keep information about source of created vertex
shape2index
shape2index	Convert index to shape point from ExPolygons

Returns: Face type defined by hi

{
    VI vi_from = mesh.source(hi);
    VI vi_to   = mesh.target(hi);
    // This face has a constrained edge.
    const IntersectingElement &shape_from = *vertex_shape_map[vi_from];
    const IntersectingElement &shape_to   = *vertex_shape_map[vi_to];
    assert(shape_from.shape_point_index != std::numeric_limits<uint32_t>::max());
    assert(shape_from.attr != (unsigned char) IntersectingElement::Type::undefined);
    assert(shape_to.shape_point_index != std::numeric_limits<uint32_t>::max());
    assert(shape_to.attr != (unsigned char) IntersectingElement::Type::undefined);
 
    // index into contour
    uint32_t                  i_from    = shape_from.shape_point_index;
    uint32_t                  i_to      = shape_to.shape_point_index;
    IntersectingElement::Type type_from = shape_from.get_type();
    IntersectingElement::Type type_to   = shape_to.get_type();
    if (i_from == i_to && type_from == type_to) {
        // intersecting element must be face
        assert(type_from == IntersectingElement::Type::face_1 ||
                type_from == IntersectingElement::Type::face_2);
 
        // count of vertices is twice as count of point in the contour
        uint32_t i = i_from * 2;
        // j is next contour point in vertices
        uint32_t j = i + 2;
        if (shape_from.is_last()) {
            ExPolygonsIndex point_id = shape2index.cvt(i_from);
            point_id.point_index  = 0;
            j = shape2index.cvt(point_id)*2;
        }
 
        // opposit point(in triangle face) to edge
        const P3 &p = mesh.point(mesh.target(mesh.next(hi)));
 
        // abc is source triangle face
        CGAL::Sign abcp = type_from == IntersectingElement::Type::face_1 ?
                        CGAL::orientation(shape_mesh.point(VI(i)),
                                            shape_mesh.point(VI(i + 1)),
                                            shape_mesh.point(VI(j)), p) :
                        // type_from == IntersectingElement::Type::face_2
                        CGAL::orientation(shape_mesh.point(VI(j)),
                                            shape_mesh.point(VI(i + 1)),
                                            shape_mesh.point(VI(j + 1)), p);
        return abcp == CGAL::POSITIVE;
    } else if (i_from < i_to || (i_from == i_to && type_from < type_to)) {
        bool is_last = shape_to.is_last() && shape_from.is_first();
        // check continuity of indicies
        assert(i_from == i_to || is_last || (i_from + 1) == i_to);
        return !is_last;
    } else {
        assert(i_from > i_to || (i_from == i_to && type_from > type_to));
        bool is_last = shape_to.is_first() && shape_from.is_last();
        // check continuity of indicies
        assert(i_from == i_to || is_last || (i_to + 1) == i_from);
        return is_last;
    }
 
    assert(false);
    return false;
}

References priv::IntersectingElement::attr, Slic3r::ExPolygonsIndices::cvt(), priv::IntersectingElement::face_1, priv::IntersectingElement::face_2, priv::IntersectingElement::get_type(), priv::IntersectingElement::is_first(), priv::IntersectingElement::is_last(), Slic3r::ExPolygonsIndex::point_index, priv::IntersectingElement::shape_point_index, and priv::IntersectingElement::undefined.

Referenced by set_face_type().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_out_of()

bool priv::is_out_of	(	const Vec3d &	v,
		const PointNormal &	point_normal
	)

Check.

Parameters

side
v
point_normals

Returns

{
    const Vec3d& p = point_normal.first;
    const Vec3d& n = point_normal.second;
    double signed_distance = (v - p).dot(n);
    return signed_distance > 1e-5;
};

References Slic3r::dot().

Referenced by set_skip_for_out_of_aoi().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_over_whole_expoly() [1/2]

bool priv::is_over_whole_expoly	(	const CutAOI &	cutAOI,
		const ExPolygon &	shape,
		const CutMesh &	mesh
	)

Checking whether patch is uninterrupted cover of whole expolygon it belongs.

Parameters

cutAOI	Part of surface to check
shape	Source shape
mesh	Source of cut

Returns: True when cover whole expolygon otherwise false

{
    // NonInterupted contour is without other point and contain all from shape    
    const VertexShapeMap &vert_shape_map = mesh.property_map<VI, const IntersectingElement*>(vert_shape_map_name).first;
    for (HI hi : cutAOI.second) { 
        const IntersectingElement *ie_s = vert_shape_map[mesh.source(hi)];
        const IntersectingElement *ie_t = vert_shape_map[mesh.target(hi)];
        if (ie_s == nullptr || ie_t == nullptr) 
            return false;
 
        assert(ie_s->attr != (unsigned char) IntersectingElement::Type::undefined);
        assert(ie_t->attr != (unsigned char) IntersectingElement::Type::undefined);
 
        // check if it is neighbor indices
        uint32_t i_s = ie_s->shape_point_index;
        uint32_t i_t = ie_t->shape_point_index;
        assert(i_s != std::numeric_limits<uint32_t>::max());
        assert(i_t != std::numeric_limits<uint32_t>::max());
        if (i_s == std::numeric_limits<uint32_t>::max() ||
            i_t == std::numeric_limits<uint32_t>::max())
            return false;
 
        // made by same index
        if (i_s == i_t) continue;
 
        // order from source to target
        if (i_s > i_t) { 
            std::swap(i_s, i_t);
            std::swap(ie_s, ie_t);
        }
        // Must be after fix order !!
        bool is_last_polygon_segment = ie_s->is_first() && ie_t->is_last();
        if (is_last_polygon_segment) {
            std::swap(i_s, i_t);
            std::swap(ie_s, ie_t);        
        }
 
        // Is continous indices
        if (!is_last_polygon_segment &&
            (ie_s->is_last() || (i_s + 1) != i_t))
            return false;
        
        IntersectingElement::Type t_s = ie_s->get_type();
        IntersectingElement::Type t_t = ie_t->get_type();
        if (t_s == IntersectingElement::Type::undefined ||
            t_t == IntersectingElement::Type::undefined)
            return false;
 
        // next segment must start with edge intersection
        if (t_t != IntersectingElement::Type::edge_1)
            return false;
 
        // After face1 must be edge2 or face2
        if (t_s == IntersectingElement::Type::face_1)
            return false;        
    }
 
    // When all open edges are on contour than there is NO holes is shape
    auto is_open = [&mesh](HI hi)->bool {
        HI opposite = mesh.opposite(hi);
        return !mesh.face(opposite).is_valid();
    };
 
    std::vector<HI> opens; // copy
    opens.reserve(cutAOI.second.size());
    for (HI hi : cutAOI.second) // from lower to bigger
        if (is_open(hi)) opens.push_back(hi);
    std::sort(opens.begin(), opens.end());
 
    for (FI fi: cutAOI.first) {
        HI face_hi = mesh.halfedge(fi);
        for (HI hi : mesh.halfedges_around_face(face_hi)) {
            if (!is_open(hi)) continue;
            // open edge
            auto lb = std::lower_bound(opens.begin(), opens.end(), hi);
            if (lb == opens.end() || *lb != hi)
                return false; // not in contour
        }
    }
    return true;
}

References priv::IntersectingElement::attr, priv::IntersectingElement::edge_1, priv::IntersectingElement::face_1, priv::IntersectingElement::get_type(), priv::IntersectingElement::is_first(), priv::IntersectingElement::is_last(), Slic3r::opposite(), priv::IntersectingElement::shape_point_index, priv::IntersectingElement::undefined, and vert_shape_map_name.

Referenced by is_over_whole_expoly(), and select_patches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_over_whole_expoly() [2/2]

bool priv::is_over_whole_expoly	(	const SurfacePatch &	patch,
		const ExPolygons &	shapes,
		const VCutAOIs &	cutAOIs,
		const CutMeshes &	meshes
	)

Checking whether patch is uninterrupted cover of whole expolygon it belongs.

Parameters

patch	Part of surface to check
shape	Source shape

Returns: True when cover whole expolygon otherwise false

{
    if (!patch.is_whole_aoi) return false;
    return is_over_whole_expoly(cutAOIs[patch.model_id][patch.aoi_id],
                                shapes[patch.shape_id],
                                meshes[patch.model_id]);
}

References priv::SurfacePatch::aoi_id, is_over_whole_expoly(), priv::SurfacePatch::is_whole_aoi, priv::SurfacePatch::model_id, and priv::SurfacePatch::shape_id.

Here is the call graph for this function:

◆ is_patch_inside_of_model()

bool priv::is_patch_inside_of_model	(	const SurfacePatch &	patch,
		const Tree &	tree,
		const Project3d &	projection
	)

Only for model without intersection Use ray (in projection direction) from a point from patch and count intersections: pair .. outside | odd .. inside.

Parameters

patch	Patch to check
tree	Model converted to AABB tree
projection	Define direction of projection

Returns: True when patch point lay inside of model defined by tree, otherwise FALSE

{
    // TODO: Solve model with hole in projection direction !!!
    const P3 &a = patch.mesh.point(VI(0));
    Vec3d a_ = to_vec3d(a);
    Vec3d b_ = projection.project(a_);
    P3 b(b_.x(), b_.y(), b_.z());
 
    Ray ray_query(a, b);
    size_t count = tree.number_of_intersected_primitives(ray_query);
    bool is_in = (count % 2) == 1;
 
    // try opposit direction result should be same, otherwise open model is used
    //Vec3f c_ = a_ - (b_ - a_); // opposit direction
    //P3 c(c_.x(), c_.y(), c_.z());
    //Ray ray_query2(a, b);
    //size_t count2 = tree.number_of_intersected_primitives(ray_query2);
    //bool is_in2 = (count2 % 2) == 1;
    assert(((tree.number_of_intersected_primitives(
                    Ray(a, P3(2 * a.x() - b.x(), 
                            2 * a.y() - b.y(),
                            2 * a.z() - b.z()))) %
                2) == 1) == is_in);
    return is_in;        
}

References priv::SurfacePatch::mesh, Slic3r::Emboss::IProject3d::project(), and to_vec3d().

Referenced by diff_models().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_text_empty()

static bool priv::is_text_empty ( const std::string & text )

static

1286{ return text.empty() || text.find_first_not_of(" \n\t\r") == std::string::npos; }

Referenced by Slic3r::GUI::GLGizmoEmboss::close(), and Slic3r::GUI::GLGizmoEmboss::draw_text_input().

Here is the caller graph for this function:

◆ is_unique()

bool priv::is_unique ( const Points & points )

inline

                                            { 
    Points pts = points; // copy
    std::sort(pts.begin(), pts.end());
    auto it = std::adjacent_find(pts.begin(), pts.end());
    return it == pts.end();
}

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_style_rename_popup(), Slic3r::GUI::GLGizmoEmboss::draw_style_save_as_popup(), and Slic3r::Triangulation::triangulate().

Here is the caller graph for this function:

◆ is_valid()

bool priv::is_valid	(	const FontFile &	font,
		unsigned int	index
	)

                                                            {
    if (font.data == nullptr) return false;
    if (font.data->empty()) return false;
    if (index >= font.infos.size()) return false;
    return true;
}

References Slic3r::Emboss::FontFile::data, and Slic3r::Emboss::FontFile::infos.

Referenced by Slic3r::Emboss::create_range_text(), cut_from_model(), get_glyph(), priv::Visitor::intersection_point_detected(), Slic3r::Emboss::letter2glyph(), and Slic3r::Emboss::text2shapes().

Here is the caller graph for this function:

◆ load_font_info()

fontinfo_opt priv::load_font_info	(	const unsigned char *	data,
		unsigned int	index = `0`
	)

{
    int font_offset = stbtt_GetFontOffsetForIndex(data, index);
    if (font_offset < 0) {
        assert(false);
        // "Font index(" << index << ") doesn't exist.";
        return {};        
    }
    stbtt_fontinfo font_info;
    if (stbtt_InitFont(&font_info, data, font_offset) == 0) {
        // Can't initialize font.
        assert(false);
        return {};
    }
    return font_info;
}

References stbtt_GetFontOffsetForIndex(), and stbtt_InitFont().

Referenced by Slic3r::Emboss::create_font_file(), Slic3r::Emboss::create_range_text(), get_glyph(), Slic3r::Emboss::is_italic(), and Slic3r::Emboss::letter2glyph().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ merge_patches()

SurfaceCut priv::merge_patches	(	SurfacePatches &	patches,
		const std::vector< bool > &	mask
	)

Merge masked patches to one surface cut.

Parameters

patches	All patches NOTE: Not const because One needs to add property for Convert indices
mask	Mash for using patch

Returns: Result surface cut

{
    SurfaceCut result;
    for (SurfacePatch &patch : patches) {
        size_t index = &patch - &patches.front();
        if (!mask[index]) continue;
        append(result, patch2cut(patch));
    }    
    return result;
}

References append(), and patch2cut().

Here is the call graph for this function:

◆ patch2cut()

SurfaceCut priv::patch2cut ( SurfacePatch & patch )

Convert patch to indexed_triangle_set.

Parameters

patch Part of surface

Returns: Converted patch

{
    CutMesh &mesh = patch.mesh;
 
    std::string convert_map_name = "v:convert";
    CutMesh::Property_map<VI, SurfaceCut::Index> convert_map = 
        mesh.add_property_map<VI, SurfaceCut::Index>(convert_map_name).first;
 
    size_t indices_size  = mesh.faces().size();
    size_t vertices_size = mesh.vertices().size();
 
    SurfaceCut sc;
    sc.indices.reserve(indices_size);
    sc.vertices.reserve(vertices_size);
    for (VI vi : mesh.vertices()) {
        // vi order is is not sorted
        // assert(vi.idx() == sc.vertices.size());
        // vi is not continous
        // assert(vi.idx() < vertices_size);
        convert_map[vi] = sc.vertices.size();
        const P3 &p = mesh.point(vi);
        sc.vertices.emplace_back(p.x(), p.y(), p.z());
    }
 
    for (FI fi : mesh.faces()) {
        HI hi = mesh.halfedge(fi);
        assert(mesh.next(hi).is_valid());
        assert(mesh.next(mesh.next(hi)).is_valid());
        // Is fi triangle?
        assert(mesh.next(mesh.next(mesh.next(hi))) == hi);
 
        // triangle indicies
        Vec3i ti;
        size_t i = 0;
        for (VI vi : { mesh.source(hi), 
                       mesh.target(hi), 
                       mesh.target(mesh.next(hi))})
            ti[i++] = convert_map[vi];
        sc.indices.push_back(ti);
    }
 
    sc.contours.reserve(patch.loops.size());
    for (const Loop &loop : patch.loops) { 
        sc.contours.push_back({});
        std::vector<SurfaceCut::Index> &contour = sc.contours.back();
        contour.reserve(loop.size());
        for (VI vi : loop) contour.push_back(convert_map[vi]);
    }
 
    // Not neccessary, clean and free memory
    mesh.remove_property_map(convert_map);
    return sc;
}

References Slic3r::contour(), Slic3r::SurfaceCut::contours, indexed_triangle_set::indices, priv::SurfacePatch::loops, priv::SurfacePatch::mesh, and indexed_triangle_set::vertices.

Referenced by merge_patches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ polygons2model_duplicit()

indexed_triangle_set priv::polygons2model_duplicit	(	const ExPolygons &	shape2d,
		const IProjection &	projection,
		const Points &	points,
		const Points &	duplicits
	)

{
    // CW order of triangle indices
    std::vector<uint32_t> changes = Triangulation::create_changes(points, duplicits);
    std::vector<Vec3i> shape_triangles = Triangulation::triangulate(shape2d, points, changes);
    uint32_t count_point = *std::max_element(changes.begin(), changes.end()) + 1;
 
    indexed_triangle_set result;
    result.vertices.reserve(2 * count_point);
    std::vector<Vec3f> &front_points = result.vertices;
    std::vector<Vec3f>  back_points;
    back_points.reserve(count_point);
 
    uint32_t max_index = std::numeric_limits<uint32_t>::max();
    for (uint32_t i = 0; i < changes.size(); ++i) { 
        uint32_t index = changes[i];
        if (max_index != std::numeric_limits<uint32_t>::max() &&
            index <= max_index) continue; // duplicit point
        assert(index == max_index + 1);
        assert(front_points.size() == index);
        assert(back_points.size() == index);
        max_index = index;
        const Point &p = points[i];
        auto p2 = projection.create_front_back(p);
        front_points.push_back(p2.first.cast<float>());
        back_points.push_back(p2.second.cast<float>());
    }
    assert(max_index+1 == count_point);    
    
    // insert back points, front are already in
    result.vertices.insert(result.vertices.end(),
                           std::make_move_iterator(back_points.begin()),
                           std::make_move_iterator(back_points.end()));
 
    result.indices.reserve(shape_triangles.size() * 2 + points.size() * 2);
    // top triangles - change to CCW
    for (const Vec3i &t : shape_triangles)
        result.indices.emplace_back(t.x(), t.z(), t.y());
    // bottom triangles - use CW
    for (const Vec3i &t : shape_triangles)
        result.indices.emplace_back(t.x() + count_point, t.y() + count_point,
                                    t.z() + count_point);
 
    // quads around - zig zag by triangles
    size_t polygon_offset = 0;
    auto add_quads = [&polygon_offset, &result, count_point, &changes]
    (const Polygon &polygon) {
        uint32_t polygon_points = polygon.points.size();
        // previous index
        uint32_t prev = changes[polygon_offset + polygon_points - 1];
        for (uint32_t p = 0; p < polygon_points; ++p) {
            uint32_t index = changes[polygon_offset + p];
            if (prev == index) continue;
            add_quad(prev, index, result, count_point);
            prev = index;
        }
        polygon_offset += polygon_points;
    };
 
    for (const ExPolygon &expolygon : shape2d) {
        add_quads(expolygon.contour);
        for (const Polygon &hole : expolygon.holes) add_quads(hole);
    }
    return result;
}

References add_quad(), Slic3r::Triangulation::create_changes(), Slic3r::Emboss::IProjection::create_front_back(), indexed_triangle_set::indices, Slic3r::Triangulation::triangulate(), and indexed_triangle_set::vertices.

Referenced by Slic3r::Emboss::polygons2model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ polygons2model_unique()

indexed_triangle_set priv::polygons2model_unique	(	const ExPolygons &	shape2d,
		const IProjection &	projection,
		const Points &	points
	)

{
    // CW order of triangle indices
    std::vector<Vec3i> shape_triangles=Triangulation::triangulate(shape2d, points);
    uint32_t           count_point     = points.size();
 
    indexed_triangle_set result;
    result.vertices.reserve(2 * count_point);
    std::vector<Vec3f> &front_points = result.vertices; // alias
    std::vector<Vec3f>  back_points;
    back_points.reserve(count_point);
 
    for (const Point &p : points) {
        auto p2 = projection.create_front_back(p);
        front_points.push_back(p2.first.cast<float>());
        back_points.push_back(p2.second.cast<float>());
    }    
    
    // insert back points, front are already in
    result.vertices.insert(result.vertices.end(),
                           std::make_move_iterator(back_points.begin()),
                           std::make_move_iterator(back_points.end()));
    result.indices.reserve(shape_triangles.size() * 2 + points.size() * 2);
    // top triangles - change to CCW
    for (const Vec3i &t : shape_triangles)
        result.indices.emplace_back(t.x(), t.z(), t.y());
    // bottom triangles - use CW
    for (const Vec3i &t : shape_triangles)
        result.indices.emplace_back(t.x() + count_point, 
                                    t.y() + count_point,
                                    t.z() + count_point);
 
    // quads around - zig zag by triangles
    size_t polygon_offset = 0;
    auto add_quads = [&polygon_offset,&result, &count_point]
    (const Polygon& polygon) {
        uint32_t polygon_points = polygon.points.size();
        // previous index
        uint32_t prev = polygon_offset + polygon_points - 1;
        for (uint32_t p = 0; p < polygon_points; ++p) { 
            uint32_t index = polygon_offset + p;
            add_quad(prev, index, result, count_point);
            prev = index;
        }
        polygon_offset += polygon_points;
    };
 
    for (const ExPolygon &expolygon : shape2d) {
        add_quads(expolygon.contour);
        for (const Polygon &hole : expolygon.holes) add_quads(hole);
    }   
 
    return result;
}

References add_quad(), Slic3r::Emboss::IProjection::create_front_back(), indexed_triangle_set::indices, Slic3r::Triangulation::triangulate(), and indexed_triangle_set::vertices.

Referenced by Slic3r::Emboss::polygons2model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process()

bool priv::process ( std::exception_ptr & eptr )

static

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

References create_message().

Referenced by collect_surface_data(), create_cut_area_of_interests(), finalize(), and flood_fill_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pts_2x2()

const Points priv::pts_2x2 ( {Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1)} )

Referenced by heal_dupl_inter(), and remove_self_intersections().

Here is the caller graph for this function:

◆ pts_3x3()

const Points priv::pts_3x3 ( {Point(-1, -1), Point(1, -1), Point(1, 1), Point(-1, 1)} )

Referenced by heal_dupl_inter(), and Slic3r::Emboss::heal_shape().

Here is the caller graph for this function:

◆ remove_bad() [1/2]

void priv::remove_bad ( ExPolygons & expolygons )

                                            {
    expolygons.erase(
        std::remove_if(expolygons.begin(), expolygons.end(), 
            [](const ExPolygon &p) { return p.contour.size() < 3; }),
        expolygons.end());
 
    for (ExPolygon &expolygon : expolygons)
         remove_bad(expolygon.holes);
}

References remove_bad().

Here is the call graph for this function:

◆ remove_bad() [2/2]

void priv::remove_bad ( Polygons & polygons )

                                        {
    polygons.erase(
        std::remove_if(polygons.begin(), polygons.end(), 
            [](const Polygon &p) { return p.size() < 3; }), 
        polygons.end());
}

Referenced by remove_bad(), and remove_spikes_in_duplicates().

Here is the caller graph for this function:

◆ remove_same_neighbor() [1/3]

bool priv::remove_same_neighbor ( ExPolygons & expolygons )

                                                      {
    if(expolygons.empty()) return false;
    bool remove_from_holes = false;
    bool remove_from_contour = false;
    for (ExPolygon &expoly : expolygons) {
        remove_from_contour |= remove_same_neighbor(expoly.contour);
        remove_from_holes |= remove_same_neighbor(expoly.holes);
    }
    // Removing of expolygons without contour
    if (remove_from_contour)
        expolygons.erase(
            std::remove_if(expolygons.begin(), expolygons.end(),
                [](const ExPolygon &p) { return p.contour.points.size() <=2; }),
            expolygons.end());
    return remove_from_holes || remove_from_contour;
}

References remove_same_neighbor().

Here is the call graph for this function:

◆ remove_same_neighbor() [2/3]

bool priv::remove_same_neighbor ( Slic3r::Polygon & polygon )

{
    Points &points = polygon.points;
    if (points.empty()) return false;
    auto last = std::unique(points.begin(), points.end());
    
    // remove first and last neighbor duplication
    if (const Point& last_point = *(last - 1);
        last_point == points.front()) {
         --last;
    }
 
    // no duplicits
    if (last == points.end()) return false;
 
    points.erase(last, points.end());
    return true;
}

References Slic3r::MultiPoint::points.

Referenced by Slic3r::Emboss::divide_segments_for_close_point(), heal_dupl_inter(), remove_same_neighbor(), remove_same_neighbor(), and remove_self_intersections().

Here is the caller graph for this function:

◆ remove_same_neighbor() [3/3]

bool priv::remove_same_neighbor ( Polygons & polygons )

                                                  {
    if (polygons.empty()) return false;
    bool exist = false;
    for (Polygon& polygon : polygons) 
        exist |= remove_same_neighbor(polygon);
    // remove empty polygons
    polygons.erase(
        std::remove_if(polygons.begin(), polygons.end(), 
            [](const Polygon &p) { return p.points.size() <= 2; }),
        polygons.end());
    return exist;
}

References remove_same_neighbor().

Here is the call graph for this function:

◆ remove_self_intersections()

bool priv::remove_self_intersections	(	ExPolygons &	shape,
		unsigned	max_iteration = `10`
	)

                                                                              {
    if (shape.empty())
        return true;
 
    Pointfs intersections_f = intersection_points(shape);
    if (intersections_f.empty())
        return true;
 
    // create loop permanent memory
    Polygons holes;
    Points intersections;
 
    while (--max_iteration) {        
        // convert intersections into Points
        assert(intersections.empty());
        intersections.reserve(intersections_f.size());
        std::transform(intersections_f.begin(), intersections_f.end(), std::back_inserter(intersections),
                       [](const Vec2d &p) { return Point(std::floor(p.x()), std::floor(p.y())); });
 
        // intersections should be unique poits
        std::sort(intersections.begin(), intersections.end());
        auto it = std::unique(intersections.begin(), intersections.end());
        intersections.erase(it, intersections.end());
 
        assert(holes.empty());
        holes.reserve(intersections.size());
 
        // Fix self intersection in result by subtracting hole 2x2
        for (const Point &p : intersections) {
            Polygon hole(priv::pts_2x2);
            hole.translate(p);
            holes.push_back(hole);
        }
        // Union of overlapped holes is not neccessary
        // Clipper calculate winding number separately for each input parameter
        // if (holes.size() > 1) holes = Slic3r::union_(holes);
        shape = Slic3r::diff_ex(shape, holes, ApplySafetyOffset::Yes);
        
        // TODO: find where diff ex could create same neighbor
        priv::remove_same_neighbor(shape);
 
        // find new intersections made by diff_ex
        intersections_f = intersection_points(shape);
        if (intersections_f.empty())
            return true;
        else {
            // clear permanent vectors
            holes.clear();
            intersections.clear();
        }
    }
    assert(max_iteration == 0);
    assert(!intersections_f.empty());
    return false;
}

References Slic3r::diff_ex(), Slic3r::holes(), Slic3r::intersection_points(), pts_2x2(), remove_same_neighbor(), and Slic3r::MultiPoint::translate().

Here is the call graph for this function:

◆ remove_small_islands()

void priv::remove_small_islands	(	ExPolygons &	shape,
		double	minimal_area
	)

                                                                           {
    if (expolygons.empty())
        return;
 
    // remove small expolygons contours
    auto expoly_it = std::remove_if(expolygons.begin(), expolygons.end(), 
        [&minimal_area](const ExPolygon &p) { return p.contour.area() < minimal_area; });
    expolygons.erase(expoly_it, expolygons.end());
 
    // remove small holes in expolygons
    for (ExPolygon &expoly : expolygons) {
        Polygons& holes = expoly.holes;
        auto it = std::remove_if(holes.begin(), holes.end(), 
            [&minimal_area](const Polygon &p) { return -p.area() < minimal_area; });
        holes.erase(it, holes.end());
    }
}

References Slic3r::holes().

Here is the call graph for this function:

◆ remove_spikes_in_duplicates()

void priv::remove_spikes_in_duplicates	(	ExPolygons &	expolygons,
		const Points &	duplicates
	)

                                                                                       { 
 
    auto check = [](Polygon &polygon, const Point &d) -> bool {
        double spike_bevel = 1 / SHAPE_SCALE;
        double spike_length = 5.;
        const static SpikeDesc sd(spike_bevel, spike_length);
        Points& pts = polygon.points;
        bool exist_remove = false;
        for (size_t i = 0; i < pts.size(); i++) {
            if (pts[i] != d)
                continue;
            exist_remove |= remove_when_spike(polygon, i, sd);
        }
        return exist_remove && pts.size() < 3;
    };
 
    bool exist_remove = false;
    for (ExPolygon &expolygon : expolygons) {
        BoundingBox bb(to_points(expolygon.contour));
        for (const Point &d : duplicates) {
            if (!bb.contains(d))
                continue;
            exist_remove |= check(expolygon.contour, d);
            for (Polygon &hole : expolygon.holes)
                exist_remove |= check(hole, d);
        }
    }
 
    if (exist_remove)
        remove_bad(expolygons);
}

References check(), Slic3r::BoundingBoxBase< PointType, APointsType >::contains(), Slic3r::MultiPoint::points, remove_bad(), remove_when_spike(), Slic3r::Emboss::SHAPE_SCALE, and Slic3r::to_points().

Referenced by heal_dupl_inter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_when_spike()

bool priv::remove_when_spike	(	Polygon &	polygon,
		size_t	index,
		const SpikeDesc &	spike_desc
	)

                                                                                        {
 
    std::optional<Point> add;
    bool do_erase = false;
    Points &pts = polygon.points;
    {
        size_t  pts_size = pts.size();
        if (pts_size < 3)
            return false;
 
        const Point &a = (index == 0) ? pts.back() : pts[index - 1];
        const Point &b = pts[index];
        const Point &c = (index == (pts_size - 1)) ? pts.front() : pts[index + 1];
 
        // calc sides
        Vec2d ba = (a - b).cast<double>();
        Vec2d bc = (c - b).cast<double>();
 
        double dot_product = ba.dot(bc);
 
        // sqrt together after multiplication save one sqrt
        double ba_size_sq = ba.squaredNorm();
        double bc_size_sq = bc.squaredNorm();
        double norm       = sqrt(ba_size_sq * bc_size_sq);
        double cos_angle  = dot_product / norm;
 
        // small angle are around 1 --> cos(0) = 1
        if (cos_angle < spike_desc.cos_angle)
            return false; // not a spike
 
        // has to be in range <-1, 1>
        // Due to preccission of floating point number could be sligtly out of range
        if (cos_angle > 1.)
            cos_angle = 1.;
        // if (cos_angle < -1.)
        //     cos_angle = -1.;
 
        // Current Spike angle
        double angle          = acos(cos_angle);
        double wanted_size    = spike_desc.half_bevel / cos(angle / 2.);
        double wanted_size_sq = wanted_size * wanted_size;
 
        bool is_ba_short = ba_size_sq < wanted_size_sq;
        bool is_bc_short = bc_size_sq < wanted_size_sq;
 
        auto a_side = [&b, &ba, &ba_size_sq, &wanted_size]() -> Point {
            Vec2d ba_norm = ba / sqrt(ba_size_sq);
            return b + (wanted_size * ba_norm).cast<coord_t>();
        };
        auto c_side = [&b, &bc, &bc_size_sq, &wanted_size]() -> Point {
            Vec2d bc_norm = bc / sqrt(bc_size_sq);
            return b + (wanted_size * bc_norm).cast<coord_t>();
        };
 
        if (is_ba_short && is_bc_short) {
            // remove short spike
            do_erase = true;
        } else if (is_ba_short) {
            // move point B on C-side
            pts[index] = c_side();
        } else if (is_bc_short) {
            // move point B on A-side
            pts[index] = a_side();
        } else {
            // move point B on C-side and add point on A-side(left - before)
            pts[index] = c_side();
            add = a_side();
            if (*add == pts[index]) {
                // should be very rare, when SpikeDesc has small base
                // will be fixed by remove B point
                add.reset();
                do_erase = true;
            }
        }
    }
    if (do_erase) {
        pts.erase(pts.begin() + index);
        return true;
    }
    if (add.has_value())
        pts.insert(pts.begin() + index, *add);
    return false;
}

References acos(), add, Slic3r::angle(), cos(), priv::SpikeDesc::cos_angle, priv::SpikeDesc::half_bevel, Slic3r::MultiPoint::points, and sqrt().

Referenced by remove_spikes_in_duplicates().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ select_patches()

std::vector< bool > priv::select_patches	(	const ProjectionDistances &	best_distances,
		const SurfacePatches &	patches,
		const ExPolygons &	shapes,
		const ExPolygonsIndices &	s2i,
		const VCutAOIs &	cutAOIs,
		const CutMeshes &	meshes,
		const Project &	projection
	)

Create mask for patches.

Parameters

best_distances	For each point selected closest distance
patches	All patches
shapes	All patches

Returns: Mask of used patch

{
    // extension to cover numerical mistake made by back projection patch from 3d to 2d
    const float extend_delta = 5.f / Emboss::SHAPE_SCALE; // [Font points scaled by Emboss::SHAPE_SCALE]
        
    // vector of patches for shape
    std::vector<std::vector<uint32_t>> used_shapes_patches(shapes.size());    
    std::vector<bool> in_distances(patches.size(), {false});
    for (const ProjectionDistance &d : best_distances) {
        // exist valid projection for shape point?
        if (d.patch_index == std::numeric_limits<uint32_t>::max()) continue;
        if (in_distances[d.patch_index]) continue;
        in_distances[d.patch_index] = true;
 
        ExPolygonsIndex id = s2i.cvt(&d - &best_distances.front());
        used_shapes_patches[id.expolygons_index].push_back(d.patch_index);
    }
 
    // vector of patches for shape
    std::vector<std::vector<uint32_t>> shapes_patches(shapes.size());
    for (const SurfacePatch &patch : patches) 
        shapes_patches[patch.shape_id].push_back(&patch - &patches.front());
 
#ifdef DEBUG_OUTPUT_DIR
    std::string store_dir = DEBUG_OUTPUT_DIR + "select_patches/";
    prepare_dir(store_dir);
#endif // DEBUG_OUTPUT_DIR
 
    for (size_t shape_index = 0; shape_index < shapes.size(); shape_index++) {
        const ExPolygon &shape = shapes[shape_index];
        std::vector<uint32_t> &used_shape_patches = used_shapes_patches[shape_index];
        if (used_shape_patches.empty()) continue;
        // is used all exist patches?
        if (used_shapes_patches.size() == shapes_patches[shape_index].size()) continue;
        if (used_shape_patches.size() == 1) { 
            uint32_t patch_index = used_shape_patches.front();
            const SurfacePatch &patch = patches[patch_index];
            if (is_over_whole_expoly(patch, shapes, cutAOIs, meshes)) continue;
        }
 
        // only shapes containing multiple patches
        // or not full filled are back projected (hard processed)
 
        // intersection of converted patches to 2d
        ExPolygons fill;
        fill.reserve(used_shape_patches.size());
 
        // Heuristics to predict which patch to be used need average patch depth
        Vec2d used_patches_depth(std::numeric_limits<double>::max(), std::numeric_limits<double>::min());
        for (uint32_t patch_index : used_shape_patches) {
            ExPolygon patch_area = to_expoly(patches[patch_index], projection, used_patches_depth);
            //*/
            ExPolygons patch_areas = offset_ex(patch_area, extend_delta);
            fill.insert(fill.end(), patch_areas.begin(), patch_areas.end());
            /*/
            // without save extension
            fill.push_back(patch_area);
            //*/
        }
        fill = union_ex(fill);
 
        // not cutted area of expolygon
        ExPolygons rest = diff_ex(ExPolygons{shape}, fill, ApplySafetyOffset::Yes);
#ifdef DEBUG_OUTPUT_DIR
        BoundingBox shape_bb = get_extents(shape);
        SVG svg(store_dir + "shape_" + std::to_string(shape_index) + ".svg", shape_bb);
        svg.draw(fill, "darkgreen");
        svg.draw(rest, "green");
#endif // DEBUG_OUTPUT_DIR
 
        // already filled by multiple patches
        if (rest.empty()) continue;
 
        // find patches overlaped rest area
        struct PatchShape{
            uint32_t patch_index;
            ExPolygon shape;
            ExPolygons intersection;
            double depth_range_center_distance; // always positive 
        };
        using PatchShapes = std::vector<PatchShape>;
        PatchShapes patch_shapes;
 
        double used_patches_depth_center = (used_patches_depth[0] + used_patches_depth[1]) / 2;
 
        // sort used_patches for faster search
        std::sort(used_shape_patches.begin(), used_shape_patches.end());
        for (uint32_t patch_index : shapes_patches[shape_index]) { 
            // check is patch already used
            auto it = std::lower_bound(used_shape_patches.begin(), used_shape_patches.end(), patch_index);
            if (it != used_shape_patches.end() && *it == patch_index) continue;
 
            // Heuristics to predict which patch to be used need average patch depth
            Vec2d patche_depth_range(std::numeric_limits<double>::max(), std::numeric_limits<double>::min());
            ExPolygon patch_shape = to_expoly(patches[patch_index], projection, patche_depth_range);
            double depth_center = (patche_depth_range[0] + patche_depth_range[1]) / 2;
            double depth_range_center_distance = std::fabs(used_patches_depth_center - depth_center);
 
            ExPolygons patch_intersection = intersection_ex(ExPolygons{patch_shape}, rest);
            if (patch_intersection.empty()) continue;
 
            patch_shapes.push_back({patch_index, patch_shape, patch_intersection, depth_range_center_distance});
        }
 
        // nothing to add
        if (patch_shapes.empty()) continue;
        // only one solution to add
        if (patch_shapes.size() == 1) {
            used_shape_patches.push_back(patch_shapes.front().patch_index);        
            continue;
        }
 
        // Idea: Get depth range of used patches and add patches in order by distance to used depth center
        std::sort(patch_shapes.begin(), patch_shapes.end(), [](const PatchShape &a, const PatchShape &b) 
            { return a.depth_range_center_distance < b.depth_range_center_distance; });
 
#ifdef DEBUG_OUTPUT_DIR
        for (size_t i = patch_shapes.size(); i > 0; --i) { 
            const PatchShape &p = patch_shapes[i - 1];
            int gray_level =  (i * 200) / patch_shapes.size();
            std::stringstream color;
            color << "#" << std::hex << std::setfill('0') << std::setw(2) << gray_level << gray_level << gray_level;
            svg.draw(p.shape, color.str());
            Point text_pos = get_extents(p.shape).center().cast<int>();
            svg.draw_text(text_pos, std::to_string(i-1).c_str(), "orange", std::ceil(shape_bb.size().x() / 20 * 0.000001));
            //svg.draw(p.intersection, color.str());
        }
#endif // DEBUG_OUTPUT_DIR
 
        for (const PatchShape &patch : patch_shapes) { 
            // Check when exist some place to fill
            ExPolygons patch_intersection = intersection_ex(patch.intersection, rest);
            if (patch_intersection.empty()) continue;
 
            // Extend for sure
            ExPolygons intersection = offset_ex(patch.intersection, extend_delta);
            rest = diff_ex(rest, intersection, ApplySafetyOffset::Yes);
 
            used_shape_patches.push_back(patch.patch_index);
            if (rest.empty()) break;
        }
 
        // QUESTION: How to select which patch to use? How to sort them?
        // Now is used back projection distance from used patches
        // 
        // Idealy by outline depth: (need ray cast into patches)
        // how to calc wanted depth - idealy by depth of outline help to overlap
        // how to calc patch depth - depth in place of outline position
        // Which outline to use between 
 
    }
 
    std::vector<bool> result(patches.size(), {false});
    for (const std::vector<uint32_t> &patches: used_shapes_patches)
        for (uint32_t patch_index : patches) { 
            assert(patch_index < result.size());
            // check only onece insertation of patch
            assert(!result[patch_index]);
            result[patch_index] = true;
        }
    return result;
}

References Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::ExPolygonsIndices::cvt(), Slic3r::diff_ex(), Slic3r::SVG::draw(), Slic3r::SVG::draw_text(), Slic3r::get_extents(), Slic3r::intersection(), Slic3r::intersection_ex(), is_over_whole_expoly(), Slic3r::offset_ex(), Slic3r::Emboss::SHAPE_SCALE, to_expoly(), and Slic3r::union_ex().

Referenced by Slic3r::cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ separate_patch()

priv::SurfacePatch priv::separate_patch	(	const std::vector< FI > &	fis,
		SurfacePatch &	patch,
		const CvtVI2VI &	cvt_from
	)

Separate triangles singned with number n.

Parameters

fis	Face indices owned by separate patch
patch	Original patch NOTE: Can't be const. For indexing vetices need temporary add property map
cvt_from	conversion map

Returns: Just separated patch

{
    assert(patch.mesh.is_valid());    
    SurfacePatch patch_new = create_surface_patch(fis, patch.mesh);
    patch_new.bb           = bounding_box(patch_new.mesh);
    patch_new.aoi_id       = patch.aoi_id;
    patch_new.model_id     = patch.model_id;
    patch_new.shape_id     = patch.shape_id;
    // fix cvt
    CvtVI2VI cvt = patch_new.mesh.property_map<VI, VI>(patch_source_name).first;
    for (VI &vi : cvt) {
        if (!vi.is_valid()) continue;
        vi = cvt_from[vi];
    }
    return patch_new;
}

References priv::SurfacePatch::aoi_id, priv::SurfacePatch::bb, bounding_box(), create_surface_patch(), priv::SurfacePatch::mesh, priv::SurfacePatch::model_id, patch_source_name, and priv::SurfacePatch::shape_id.

Referenced by divide_patch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_face_type()

void priv::set_face_type	(	FaceTypeMap &	face_type_map,
		const CutMesh &	mesh,
		const VertexShapeMap &	vertex_shape_map,
		const EdgeBoolMap &	ecm,
		const CutMesh &	shape_mesh,
		const ExPolygonsIndices &	shape2index
	)

Face with constrained edge are inside/outside by type of intersection Other set to not_constrained(still it could be inside/outside)

Parameters

face_type_map	[Output] property map with type of faces
mesh	Mesh to process
vertex_shape_map	Keep information about source of created vertex
ecm	Dynamic Edge Constrained Map of bool
shape_mesh	Vertices of mesh made by shapes
shape2index	Convert index to shape point from ExPolygons

{
    for (EI ei : mesh.edges()) {
        if (!ecm[ei]) continue;
        HI hi = mesh.halfedge(ei);
        FI fi = mesh.face(hi);
        bool is_inside = is_face_inside(hi, mesh, shape_mesh, vertex_shape_map, shape2index);        
        face_type_map[fi] = is_inside ? FaceType::inside : FaceType::outside;
        HI hi_op = mesh.opposite(hi);
        assert(hi_op.is_valid());
        if (!hi_op.is_valid()) continue;
        FI fi_op = mesh.face(hi_op);
        assert(fi_op.is_valid());
        if (!fi_op.is_valid()) continue;
        face_type_map[fi_op] = (!is_inside) ? FaceType::inside : FaceType::outside;
    }
}

References inside, is_face_inside(), and outside.

Referenced by cut_from_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_skip_by_angle()

void priv::set_skip_by_angle	(	std::vector< bool > &	skip_indicies,
		const indexed_triangle_set &	its,
		const Project3d &	projection,
		double	max_angle = `89.`
	)

Set true for indicies outward and almost parallel together. Note: internally calculate normals.

Parameters

skip_indicies	Flag to convert triangle to cgal
its	model
projection	Direction to measure angle
max_angle	Maximal allowed angle between opposit normal and projection direction [in DEG]

{
    assert(max_angle < 90. && max_angle > 89.);
    assert(skip_indicies.size() == its.indices.size());
    float threshold = static_cast<float>(cos(max_angle / 180. * M_PI));
    for (const stl_triangle_vertex_indices& face : its.indices) {
        size_t index = &face - &its.indices.front();
        if (skip_indicies[index]) continue;
        Vec3f n = its_face_normal(its, face);
        const Vec3f& v = its.vertices[face[0]];
        const Vec3d vd = v.cast<double>();
        // Improve: For Orthogonal Projection it is same for each vertex
        Vec3d projectedd  = projection.project(vd);
        Vec3f projected   = projectedd.cast<float>();
        Vec3f project_dir = projected - v;
        project_dir.normalize();
        float cos_alpha = project_dir.dot(n);
        if (cos_alpha > threshold) continue;
        skip_indicies[index] = true;
    }
}

References cos(), indexed_triangle_set::indices, Slic3r::its_face_normal(), M_PI, Slic3r::Emboss::IProject3d::project(), and indexed_triangle_set::vertices.

Referenced by Slic3r::cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_skip_for_out_of_aoi()

void priv::set_skip_for_out_of_aoi	(	std::vector< bool > &	skip_indicies,
		const indexed_triangle_set &	its,
		const Project &	projection,
		const BoundingBox &	shapes_bb
	)

Set true for indices out of area of interest.

Parameters

skip_indicies	Flag to convert triangle to cgal
its	model
projection	Convert 2d point to pair of 3d points
shapes_bb	2d bounding box define AOI

{
    assert(skip_indicies.size() == its.indices.size());
    //   1`*----* 2`
    //    /  2 /|
    // 1 *----* |
    //   |    | * 3`
    //   |    |/
    // 0 *----* 3
    std::array<std::pair<Vec3d, Vec3d>, 4> bb;
    int index = 0;
    for (Point v :
         {shapes_bb.min, Point{shapes_bb.min.x(), shapes_bb.max.y()},
          shapes_bb.max, Point{shapes_bb.max.x(), shapes_bb.min.y()}})
        bb[index++] = projection.create_front_back(v);
 
    // define planes to test
    // 0 .. under
    // 1 .. left
    // 2 .. above
    // 3 .. right
    size_t prev_i = 3;
    // plane is defined by point and normal
    PointNormals point_normals;
    for (size_t i = 0; i < 4; i++) {
        const Vec3d &p1 = bb[i].first;
        const Vec3d &p2 = bb[i].second;
        const Vec3d &p3 = bb[prev_i].first;
        prev_i = i;
 
        Vec3d v1 = p2 - p1;
        v1.normalize();
        Vec3d v2 = p3 - p1;
        v2.normalize();
 
        Vec3d normal = v2.cross(v1);
        normal.normalize(); 
 
        point_normals[i] = {p1, normal};
    }
 
    // check that projection is not left handed
    // Fix for reflected projection
    if (is_out_of(point_normals[2].first, point_normals[0])) {
        // projection is reflected so normals are reflected
        for (auto &pn : point_normals)
            pn.second *= -1;
    }    
 
    // same meaning as point normal
    IsOnSides is_on_sides(its.vertices.size(), {false,false,false,false});    
    
    // inspect all vertices when it is out of bounding box
    tbb::parallel_for(tbb::blocked_range<size_t>(0, its.vertices.size()),
    [&its, &point_normals, &is_on_sides](const tbb::blocked_range<size_t> &range) {
        for (size_t i = range.begin(); i < range.end(); ++i) {
            Vec3d v = its.vertices[i].cast<double>();
            // under + above
            for (int side : {0, 2}) {
                if (is_out_of(v, point_normals[side])) {
                    is_on_sides[i][side] = true;
                    // when it is under it can't be above
                    break;
                }
            }
            // left + right
            for (int side : {1, 3}) {
                if (is_out_of(v, point_normals[side])) {
                    is_on_sides[i][side] = true;
                    // when it is on left side it can't be on right
                    break;
                }        
            }
        }
    }); // END parallel for
 
    // inspect all triangles, when it is out of bounding box
    tbb::parallel_for(tbb::blocked_range<size_t>(0, its.indices.size()),
    [&its, &is_on_sides, &skip_indicies](const tbb::blocked_range<size_t> &range) {
        for (size_t i = range.begin(); i < range.end(); ++i) {
            if (is_all_on_one_side(its.indices[i], is_on_sides)) 
                skip_indicies[i] = true;
        }
    }); // END parallel for
}

References Slic3r::Emboss::IProjection::create_front_back(), indexed_triangle_set::indices, is_out_of(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::range(), and indexed_triangle_set::vertices.

Referenced by Slic3r::cut_surface(), and Slic3r::its_cut_AoI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start_create_object_job()

void priv::start_create_object_job	(	DataBase &	emboss_data,
		const Vec2d &	coor
	)

static

Start job for add object with text into scene.

Parameters

emboss_data	Define params of text
coor	Screen coordinat, where to create new object laying on bed

{
    // start creation of new object
    Plater        *plater    = wxGetApp().plater();
    const Camera  &camera    = plater->get_camera();
    const Pointfs &bed_shape = plater->build_volume().bed_shape();
 
    // can't create new object with distance from surface
    FontProp &prop = emboss_data.text_configuration.style.prop;
    if (prop.distance.has_value()) prop.distance.reset();
 
    // can't create new object with using surface
    if (prop.use_surface)
        prop.use_surface = false;
 
    //    Transform3d volume_tr = priv::create_transformation_on_bed(mouse_pos, camera, bed_shape, prop.emboss / 2);
    DataCreateObject data{std::move(emboss_data), coor, camera, bed_shape};
    auto             job    = std::make_unique<CreateObjectJob>(std::move(data));
    Worker          &worker = plater->get_ui_job_worker();
    queue_job(worker, std::move(job));
}

References Slic3r::BuildVolume::bed_shape(), Slic3r::GUI::Plater::build_volume(), Slic3r::FontProp::distance, Slic3r::GUI::Plater::get_camera(), Slic3r::GUI::Plater::get_ui_job_worker(), Slic3r::GUI::plater(), Slic3r::EmbossStyle::prop, Slic3r::GUI::queue_job(), Slic3r::TextConfiguration::style, Slic3r::GUI::Emboss::DataBase::text_configuration, and Slic3r::FontProp::use_surface.

Referenced by Slic3r::GUI::GLGizmoEmboss::create_volume(), and Slic3r::GUI::GLGizmoEmboss::create_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start_create_volume_job()

void priv::start_create_volume_job	(	const ModelObject *	object,
		const Transform3d	volume_trmat,
		DataBase &	emboss_data,
		ModelVolumeType	volume_type
	)

static

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

Parameters

object	Define where to add
volume_trmat	Volume transformation
emboss_data	Define text
volume_type	Type of volume

{
    bool &use_surface = emboss_data.text_configuration.style.prop.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()) {
            use_surface = false;
        } else {
            bool is_outside = volume_type == ModelVolumeType::MODEL_PART;
            // check that there is not unexpected volume type
            assert(is_outside || volume_type == ModelVolumeType::NEGATIVE_VOLUME || volume_type == ModelVolumeType::PARAMETER_MODIFIER);
            SurfaceVolumeData sfvd{volume_trmat, is_outside, std::move(sources)};
            CreateSurfaceVolumeData surface_data{std::move(emboss_data), std::move(sfvd), volume_type, object->id()};
            job = std::make_unique<CreateSurfaceVolumeJob>(std::move(surface_data));
        }
    }
    if (!use_surface) {
        // create volume
        DataCreateVolume data{std::move(emboss_data), volume_type, object->id(), volume_trmat};
        job = std::make_unique<CreateVolumeJob>(std::move(data));
    }
 
    Plater *plater = wxGetApp().plater();
    Worker &worker = plater->get_ui_job_worker();
    queue_job(worker, std::move(job));
}

References Slic3r::GUI::Emboss::create_sources(), Slic3r::GUI::Plater::get_ui_job_worker(), Slic3r::MODEL_PART, Slic3r::NEGATIVE_VOLUME, Slic3r::PARAMETER_MODIFIER, Slic3r::GUI::plater(), Slic3r::EmbossStyle::prop, Slic3r::GUI::queue_job(), Slic3r::TextConfiguration::style, Slic3r::GUI::Emboss::DataBase::text_configuration, Slic3r::FontProp::use_surface, and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLGizmoEmboss::create_volume(), 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 priv::start_create_volume_on_surface_job	(	DataBase &	emboss_data,
		ModelVolumeType	volume_type,
		const Vec2d &	screen_coor,
		const GLVolume *	gl_volume,
		RaycastManager &	raycaster,
		GLCanvas3D &	canvas
	)

static

Start job for add new volume on surface of object defined by screen coor.

Parameters

emboss_data	Define params of text
volume_type	Emboss / engrave
screen_coor	Mouse position which define position
gl_volume	Volume to find surface for create
raycaster	Ability to ray cast to model
canvas	Contain already used scene RayCasters

Returns: True when start creation, False when there is no hit surface by screen coor

{
    assert(gl_volume != nullptr);
    if (gl_volume == nullptr) return false;
    if (gl_volume->volume_idx() < 0) return false;
 
    Plater *plater = wxGetApp().plater();
    const ModelObjectPtrs &objects = plater->model().objects;
 
    int object_idx = gl_volume->object_idx();
    if (object_idx < 0 || static_cast<size_t>(object_idx) >= objects.size()) return false;
    ModelObject *obj = objects[object_idx];
    size_t vol_id = obj->volumes[gl_volume->volume_idx()]->id().id;
    auto cond = RaycastManager::AllowVolumes({vol_id});
 
    RaycastManager::Meshes meshes = create_meshes(canvas, cond);
    raycaster.actualize(*obj, &cond, &meshes);
 
    const Camera &camera = plater->get_camera();
    std::optional<RaycastManager::Hit> hit = ray_from_camera(raycaster, screen_coor, 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())
        return false;
 
    // Create result volume transformation
    Transform3d surface_trmat = create_transformation_onto_surface(hit->position, hit->normal, priv::up_limit);
    const FontProp &font_prop = emboss_data.text_configuration.style.prop;
    apply_transformation(font_prop, surface_trmat);
    Transform3d instance = gl_volume->get_instance_transformation().get_matrix();
    Transform3d volume_trmat = instance.inverse() * surface_trmat;  
    start_create_volume_job(obj, volume_trmat, emboss_data, volume_type);
    return true;
}

References Slic3r::GUI::RaycastManager::actualize(), Slic3r::Emboss::apply_transformation(), Slic3r::GUI::create_meshes(), Slic3r::Emboss::create_transformation_onto_surface(), Slic3r::GUI::Plater::get_camera(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Slic3r::GUI::Plater::model(), Slic3r::GLVolume::object_idx(), Slic3r::Model::objects, Slic3r::GUI::plater(), Slic3r::EmbossStyle::prop, Slic3r::GUI::ray_from_camera(), start_create_volume_job(), Slic3r::TextConfiguration::style, Slic3r::GUI::Emboss::DataBase::text_configuration, up_limit, Slic3r::GLVolume::volume_idx(), and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLGizmoEmboss::create_volume(), and Slic3r::GUI::GLGizmoEmboss::create_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_cgal() [1/2]

priv::CutMesh priv::to_cgal	(	const ExPolygons &	shapes,
		const Project &	projection
	)

Covert 2d shape (e.g. Glyph) to CGAL model NOTE: internaly create edge_shape_map .. Property map to store conversion from edge to contour face_shape_map .. Property map to store conversion from face to contour.

Parameters

shapes	2d shapes to project
projection	Define transformation 2d point into 3d

Returns: CGAL model of extruded shape

{
    if (shapes.empty()) return {};
        
    CutMesh result;
    EdgeShapeMap edge_shape_map = result.add_property_map<EI, IntersectingElement>(edge_shape_map_name).first;
    FaceShapeMap face_shape_map = result.add_property_map<FI, IntersectingElement>(face_shape_map_name).first;
 
    std::vector<VI> indices;
    auto insert_contour = [&projection, &indices, &result, 
        &edge_shape_map, &face_shape_map]
        (const Polygon &polygon) {
        indices.clear();
        indices.reserve(polygon.points.size() * 2);
        size_t  num_vertices_old = result.number_of_vertices();
        for (const Point &polygon_point : polygon.points) {
            auto [front, back] = projection.create_front_back(polygon_point);
            P3 v_front{front.x(), front.y(), front.z()};
            VI vi1 = result.add_vertex(v_front);
            assert(vi1.idx() == (indices.size() + num_vertices_old));
            indices.push_back(vi1);
 
            P3 v_back{back.x(), back.y(), back.z()};
            VI vi2 = result.add_vertex(v_back);
            assert(vi2.idx() == (indices.size() + num_vertices_old));
            indices.push_back(vi2);
        }
 
        auto find_edge = [&result](FI fi, VI from, VI to) {
            HI hi = result.halfedge(fi);
            for (; result.target(hi) != to; hi = result.next(hi));
            assert(result.source(hi) == from);
            assert(result.target(hi) == to);
            return result.edge(hi);
        };
 
        uint32_t contour_index = static_cast<uint32_t>(num_vertices_old / 2);
        for (int32_t i = 0; i < int32_t(indices.size()); i += 2) {
            bool    is_first  = i == 0;
            bool    is_last   = size_t(i + 2) >= indices.size();
            int32_t j = is_last ? 0 : (i + 2);
            
            FI fi1 = result.add_face(indices[i], indices[j], indices[i + 1]);
            EI ei1 = find_edge(fi1, indices[i + 1], indices[i]);
            EI ei2 = find_edge(fi1, indices[j], indices[i + 1]);
            FI fi2 = result.add_face(indices[j], indices[j + 1], indices[i + 1]);
            IntersectingElement element {contour_index, (unsigned char)IntersectingElement::Type::undefined};
            if (is_first) element.set_is_first();
            if (is_last) element.set_is_last();
            edge_shape_map[ei1] = element.set_type(IntersectingElement::Type::edge_1);
            face_shape_map[fi1] = element.set_type(IntersectingElement::Type::face_1);
            edge_shape_map[ei2] = element.set_type(IntersectingElement::Type::edge_2);
            face_shape_map[fi2] = element.set_type(IntersectingElement::Type::face_2);
            ++contour_index;
        }
    };
 
    size_t count_point = count_points(shapes);
    result.reserve(result.number_of_vertices() + 2 * count_point,
                   result.number_of_edges() + 4 * count_point,
                   result.number_of_faces() + 2 * count_point);
 
    // Identify polygon
    for (const ExPolygon &shape : shapes) {
        insert_contour(shape.contour);
        for (const Polygon &hole : shape.holes)
            insert_contour(hole);
    }
    assert(!exist_duplicit_vertex(result));
    return result;
}

References Slic3r::count_points(), Slic3r::Emboss::IProjection::create_front_back(), edge_shape_map_name, exist_duplicit_vertex(), face_shape_map_name, and priv::IntersectingElement::set_is_first().

Here is the call graph for this function:

◆ to_cgal() [2/2]

priv::CutMesh priv::to_cgal	(	const indexed_triangle_set &	its,
		const std::vector< bool > &	skip_indicies,
		bool	flip = `false`
	)

Convert triangle mesh model to CGAL Surface_mesh Filtrate out opposite triangles Add property map for source face index.

Parameters

its	Model
skip_indicies	Flags that triangle should be skiped
flip	When true triangle will flip normal

Returns: CGAL mesh - half edge mesh

{
    const std::vector<stl_vertex>                  &vertices = its.vertices;
    const std::vector<stl_triangle_vertex_indices> &indices = its.indices;
 
    std::vector<bool> use_vetices(vertices.size(), {false});
 
    size_t vertices_count = 0;
    size_t faces_count    = 0;
    size_t edges_count    = 0;
 
    for (const auto &t : indices) {     
        size_t index = &t - &indices.front();
        if (skip_indicies[index]) continue;        
        ++faces_count;
        size_t count_used_vertices = 0;
        for (const auto vi : t) {
            if (!use_vetices[vi]) {
                ++vertices_count;
                use_vetices[vi] = true;
            } else {
                ++count_used_vertices;
            }
        }
        switch (count_used_vertices) {
        case 3: break; // all edges are already counted
        case 2: edges_count += 2; break;
        case 1:
        case 0: edges_count += 3; break;
        default: assert(false);
        }        
    }
    assert(vertices_count <= vertices.size());
    assert(edges_count <= (indices.size() * 3));
    assert(faces_count <= indices.size());
 
    CutMesh result;
    result.reserve(vertices_count, edges_count, faces_count);
 
    std::vector<VI> to_filtrated_vertices_index(vertices.size());
    size_t filtrated_vertices_index = 0;
    for (size_t i = 0; i < vertices.size(); ++i) 
        if (use_vetices[i]) { 
            to_filtrated_vertices_index[i] = VI(filtrated_vertices_index);
            ++filtrated_vertices_index;
        }
 
    for (const stl_vertex& v : vertices) {
        if (!use_vetices[&v - &vertices.front()]) continue;
        result.add_vertex(CutMesh::Point{v.x(), v.y(), v.z()});
    }
 
    if (!flip) {
        for (const stl_triangle_vertex_indices &f : indices) {
            if (skip_indicies[&f - &indices.front()]) continue;
            result.add_face(to_filtrated_vertices_index[f[0]],
                            to_filtrated_vertices_index[f[1]],
                            to_filtrated_vertices_index[f[2]]);
        }
    } else {
        for (const stl_triangle_vertex_indices &f : indices) {
            if (skip_indicies[&f - &indices.front()]) continue;
            result.add_face(to_filtrated_vertices_index[f[2]],
                            to_filtrated_vertices_index[f[1]],
                            to_filtrated_vertices_index[f[0]]);
        }
    }
    
    return result;
}

References Slic3r::f(), indexed_triangle_set::indices, and indexed_triangle_set::vertices.

Referenced by Slic3r::cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_expoly()

ExPolygon priv::to_expoly	(	const SurfacePatch &	patch,
		const Project &	projection,
		Vec2d &	depth_range
	)

Unproject points from loops and create expolygons.

Parameters

patch	Patch to convert on expolygon
projection	Convert 3d point to 2d
depth_range	Range of unprojected points x .. min, y .. max value

Returns: Expolygon represent patch in 2d

{
    Polygons polys = unproject_loops(patch, projection, depth_range);
    // should not be used when no opposit triangle are counted so should not create overlaps
    ClipperLib::PolyFillType fill_type = ClipperLib::PolyFillType::pftEvenOdd;
    ExPolygons expolys = Slic3r::union_ex(polys, fill_type);
    if (expolys.size() == 1)
        return expolys.front();
 
    // It should be one expolygon
    assert(false);
 
    if (expolys.empty()) return {};
    // find biggest
    const ExPolygon *biggest = &expolys.front();
    for (size_t index = 1; index < expolys.size(); ++index) {
        const ExPolygon *current = &expolys[index];
        if (biggest->contour.size() < current->contour.size())
            biggest = current;
    }
    return *biggest;
}

References Slic3r::ExPolygon::contour, ClipperLib::pftEvenOdd, Slic3r::MultiPoint::size(), Slic3r::union_ex(), and unproject_loops().

Referenced by select_patches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_point()

Point priv::to_point ( const stbtt__point & point )

                                              {
    return Point(static_cast<int>(std::round(point.x / SHAPE_SCALE)),
                 static_cast<int>(std::round(point.y / SHAPE_SCALE)));
}

References Slic3r::Emboss::SHAPE_SCALE.

Referenced by get_glyph().

Here is the caller graph for this function:

◆ to_range_pi_pi()

template<typename T >

void priv::to_range_pi_pi ( T & angle )

{
    if (angle > PI || angle < -PI) {
        int count = static_cast<int>(std::round(angle / (2 * PI)));
        angle -= static_cast<T>(count * 2 * PI);
    }
}

References Slic3r::angle(), and PI.

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), and Slic3r::GUI::GLGizmoEmboss::on_mouse_for_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_vec3d()

Vec3d priv::to_vec3d ( const P3 & p )

inline

81{ return Vec3d(p.x(),p.y(),p.z()); }

Referenced by bounding_box(), bounding_box(), create_reduce_map(), is_patch_inside_of_model(), and unproject_loops().

Here is the caller graph for this function:

◆ try_create_mesh()

template<typename Fnc >

static TriangleMesh priv::try_create_mesh	(	DataBase &	input,
		Fnc	was_canceled
	)

static

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

Referenced by Slic3r::GUI::Emboss::UpdateJob::process().

Here is the caller graph for this function:

◆ unproject_loops()

Polygons priv::unproject_loops	(	const SurfacePatch &	patch,
		const Project &	projection,
		Vec2d &	depth_range
	)

Unptoject points from outline loops of patch.

Parameters

patch	Contain loops and vertices
projection	Know how to project from 3d to 2d
depth_range	Range of unprojected points x .. min, y .. max value

Returns: Unprojected points in loops

{
    assert(!patch.loops.empty());
    if (patch.loops.empty()) return {};
 
    // NOTE: this method is working only when patch did not contain outward faces
    Polygons polys;
    polys.reserve(patch.loops.size());
    // project conture into 2d space to fillconvert outlines to
 
    size_t count = 0;
    for (const Loop &l : patch.loops) count += l.size();
    std::vector<float> depths;
    depths.reserve(count);
 
    Points pts;
    for (const Loop &l : patch.loops) {
        pts.clear();
        pts.reserve(l.size());
        for (VI vi : l) {
            const P3 &p3 = patch.mesh.point(vi);
            Vec3d p = to_vec3d(p3);
            double depth;
            std::optional<Vec2d> p2_opt = projection.unproject(p, &depth);
            if (depth_range[0] > depth) depth_range[0] = depth; // min
            if (depth_range[1] < depth) depth_range[1] = depth; // max
            // Check when appear that skip is enough for poit which can't be unprojected
            // - it could break contour
            assert(p2_opt.has_value());
            if (!p2_opt.has_value()) continue;
 
            pts.push_back(p2_opt->cast<Point::coord_type>());
            depths.push_back(static_cast<float>(depth));
        }
        // minimal is triangle
        assert(pts.size() >= 3);
        if (pts.size() < 3) continue;
 
        polys.emplace_back(pts);
    }
 
    assert(!polys.empty());
    return polys;
}

References priv::SurfacePatch::loops, priv::SurfacePatch::mesh, to_vec3d(), and Slic3r::Emboss::IProjection::unproject().

Referenced by to_expoly().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_volume()

void priv::update_volume	(	TriangleMesh &&	mesh,
		const DataUpdate &	data,
		Transform3d *	tr = `nullptr`
	)

static

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("Empty mesh can't be created.");
 
    Plater     *plater = wxGetApp().plater();
    GLCanvas3D *canvas = plater->canvas3D();
 
    // Check emboss gizmo is still open
    GLGizmosManager &manager  = canvas->get_gizmos_manager();
    if (manager.get_current_type() != GLGizmosManager::Emboss) 
        return;
 
    std::string snap_name = GUI::format(_L("Text: %1%"), data.text_configuration.text);
    Plater::TakeSnapshot snapshot(plater, snap_name, UndoRedo::SnapshotType::GizmoAction);
    ModelVolume *volume = get_volume(plater->model().objects, data.volume_id);
 
    // 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 auto &tc = volume->text_configuration;
        assert(tc.has_value());
        if (tc.has_value() && tc->fix_3mf_tr.has_value())
            volume->set_transformation(volume->get_matrix() * tc->fix_3mf_tr->inverse());
    }
 
    UpdateJob::update_volume(volume, std::move(mesh), data.text_configuration, data.volume_name);
}

References _L, Slic3r::GUI::Plater::canvas3D(), create_message(), Slic3r::GUI::GLGizmosManager::Emboss, Slic3r::TextConfiguration::fix_3mf_tr, Slic3r::GUI::format(), Slic3r::GUI::GLGizmosManager::get_current_type(), Slic3r::GUI::GLCanvas3D::get_gizmos_manager(), Slic3r::GUI::get_volume(), Slic3r::UndoRedo::GizmoAction, Slic3r::GUI::Plater::model(), Slic3r::Model::objects, Slic3r::GUI::plater(), and Slic3r::GUI::Emboss::UpdateJob::update_volume().

Referenced by Slic3r::GUI::Emboss::UpdateJob::finalize(), and Slic3r::GUI::Emboss::UpdateSurfaceVolumeJob::finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ visualize_heal()

void priv::visualize_heal	(	const std::string &	svg_filepath,
		const ExPolygons &	expolygons
	)

                                                                                     {
    Points pts = to_points(expolygons);
    BoundingBox bb(pts);
    //double svg_scale = SHAPE_SCALE / unscale<double>(1.);
    // bb.scale(svg_scale);
    SVG svg(svg_filepath, bb);
    svg.draw(expolygons);
    
    Points duplicits = collect_duplicates(pts);
    svg.draw(duplicits, "black", 7 / SHAPE_SCALE);
 
    Pointfs intersections_f = intersection_points(expolygons);
    Points intersections;
    intersections.reserve(intersections_f.size());
    std::transform(intersections_f.begin(), intersections_f.end(), std::back_inserter(intersections),
                   [](const Vec2d &p) { return p.cast<int>(); });
    svg.draw(intersections, "red", 8 / SHAPE_SCALE);
}

References Slic3r::collect_duplicates(), Slic3r::SVG::draw(), Slic3r::intersection_points(), Slic3r::Emboss::SHAPE_SCALE, and Slic3r::to_points().

Here is the call graph for this function:

Variable Documentation

◆ edge_shape_map_name

const std::string priv::edge_shape_map_name = "e:IntersectingElement"

Referenced by cut_from_model(), and to_cgal().

◆ face_shape_map_name

const std::string priv::face_shape_map_name = "f:IntersectingElement"

Referenced by cut_from_model(), and to_cgal().

◆ face_type_map_name

const std::string priv::face_type_map_name = "f:side"

Referenced by cut_from_model().

◆ is_constrained_edge_name

const std::string priv::is_constrained_edge_name = "e:is_constrained"

Referenced by create_reduce_map(), and cut_from_model().

◆ limits

const struct priv::Limits priv::limits

static

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::set_depth(), and Slic3r::GUI::GLGizmoEmboss::set_height().

◆ patch_source_name

const std::string priv::patch_source_name = "v:patch_source"

Referenced by calc_distances(), create_surface_patch(), divide_patch(), and separate_patch().

◆ safe_extension

constexpr float priv::safe_extension = 1.0f

constexpr

Referenced by create_projection_for_cut(), and cut_surface().

◆ up_limit

constexpr double priv::up_limit = 0.9

constexpr

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), Slic3r::GUI::GLGizmoEmboss::on_stop_dragging(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), and start_create_volume_on_surface_job().

◆ vert_shape_map_name

const std::string priv::vert_shape_map_name = "v:IntersectingElement"

Referenced by calc_distances(), create_reduce_map(), cut_from_model(), get_shape_point_index(), and is_over_whole_expoly().

◆ vertex_reduction_map_name

const std::string priv::vertex_reduction_map_name = "v:reduction"

Referenced by diff_models().

◆ vertex_source_map_name

const std::string priv::vertex_source_map_name = "v:SourceIntersecting"

Classes

Typedefs

Enumerations

Functions

Variables

Class Documentation

◆ priv::ClosePoint

◆ priv::Limit

◆ priv::MinMax

◆ priv::ModelCutId

◆ priv::ProjectionDistance

◆ priv::SearchData

◆ priv::Source

◆ priv::SurfacePatch

◆ priv::SurfacePatchEx

Typedef Documentation

◆ BBS

◆ CutAOI

◆ CutAOIs

◆ CutMesh

◆ CutMeshes

◆ CvtVI2VI

◆ EdgeBoolMap

◆ EdgeShapeMap

◆ EI

◆ EpicKernel

◆ FaceShapeMap

◆ FaceTypeMap

◆ FI

◆ HI

◆ IsOnSides

◆ Loop

◆ Loops

◆ P3

◆ PatchNumber

◆ PointNormal

◆ PointNormals

◆ Polygon

◆ Primitive

◆ Project

◆ Project3d

◆ ProjectionDistances

◆ Ray

◆ ReductionMap

◆ Sources

◆ SurfacePatches

◆ SurfacePatchesEx

◆ Traits

◆ Tree

◆ Trees

◆ VCutAOIs

◆ VDistances

◆ VertexShapeMap

◆ VertexSourceMap

◆ VI

Enumeration Type Documentation

◆ FaceType

◆ IconState

◆ IconType

Function Documentation

◆ add_quad()

◆ append()

◆ apply_camera_dir()

◆ bounding_box() [1/3]

◆ bounding_box() [2/3]

◆ bounding_box() [3/3]

◆ calc_distance()

◆ calc_distances()

◆ calc_fine_position()

◆ calc_size_sq()

◆ change_window_position()

◆ check() [1/6]

◆ check() [2/6]

◆ check() [3/6]

◆ check() [4/6]

◆ check() [5/6]

◆ check() [6/6]

◆ choose_best_distance()

◆ clear()

◆ clip_cut()