priv Namespace Reference

Classes
struct	IntersectingElement
	IntersectingElement. More...
struct	SurfacePatch
struct	ModelCutId
class	ModelCut2index
	Keep conversion from VCutAOIs to Index and vice versa Model_index .. contour(or hole) poin from ExPolygons Index .. continous number. More...
struct	ProjectionDistance
	To select surface near projection distance. More...
struct	Visitor
	Track source of intersection Help for anotate inner and outer faces. More...
struct	ClosePoint
struct	SearchData
struct	Source
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...
struct	SurfacePatchEx

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_3<EpicKernel, Primitive>
using	Ray = EpicKernel::Ray_3
using	Tree = CGAL::AABB_tree<Traits>
using	Trees = std::vector<Tree>

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

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 BoundingBox &shapes_bb, 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 Vec3i32 &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.
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)
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)

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"

---

Class Documentation

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::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::ClosePoint

struct priv::ClosePoint

Class Members
float	dist_sq = std::numeric_limits<float>::max()
uint32_t	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::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 = std::vector<BoundingBoxf3>

CutAOI

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

CutAOIs

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

CutMesh

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

CutMeshes

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

CvtVI2VI

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

EdgeBoolMap

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

EdgeShapeMap

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

EI

using priv::EI = CGAL::SM_Edge_index

EpicKernel

using priv::EpicKernel = CGAL::Exact_predicates_inexact_constructions_kernel

FaceShapeMap

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

FaceTypeMap

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

FI

using priv::FI = CGAL::SM_Face_index

HI

using priv::HI = CGAL::SM_Halfedge_index

IsOnSides

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

Loop

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

Loops

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

P3

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

PointNormal

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

PointNormals

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

Primitive

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

Project

using priv::Project = Emboss::IProjection

Project3d

using priv::Project3d = Emboss::IProject3d

ProjectionDistances

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

Ray

using priv::Ray = EpicKernel::Ray_3

ReductionMap

using priv::ReductionMap = CvtVI2VI

Sources

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

SurfacePatches

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

SurfacePatchesEx

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

Traits

using priv::Traits = CGAL::AABB_traits_3<EpicKernel, Primitive>

Tree

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

Trees

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

VCutAOIs

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

VDistances

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

VertexShapeMap

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

VertexSourceMap

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

VI

using priv::VI = 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
};

Function Documentation

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, Slic3r::its_merge(), and Slic3r::offset().

Referenced by merge_patches().

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).value();
        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).value();
        // 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_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:

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);
    assert(unfinished_index < s2i.get_count());
    if (unfinished_index >= s2i.get_count())
        // no point to select
        return result;
 
#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 << ").";
}

References count.

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; 
    auto is_mesh_usable_for_clip = [](const CutMesh &mesh) {
        return !mesh.is_empty() &&
               mesh.number_of_vertices() >= 3 &&
               mesh.number_of_faces() > 0 &&
               mesh.is_valid(false);
    };
 
    if (!is_mesh_usable_for_clip(tm) || !is_mesh_usable_for_clip(clipper))
        return false;
 
    // Hard-stop pathological inputs before entering corefinement internals.
    if (CGAL::Polygon_mesh_processing::does_self_intersect(tm) ||
        CGAL::Polygon_mesh_processing::does_self_intersect(clipper))
        return false;
 
    // 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_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, and outside.

Referenced by create_cut_area_of_interests().

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(), and count.

Referenced by diff_models().

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(), and inside.

Referenced by cut_from_model().

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_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).value();
    const EdgeBoolMap ecm = mesh.property_map<EI, bool>(is_constrained_edge_name).value();
 
    // 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, 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_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;
}

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).value();
    const FaceShapeMap face_shape_map = cgal_shape.property_map<FI, IntersectingElement>(face_shape_map_name).value();
    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, 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:

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).value();
 
    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_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, and Slic3r::GUI::IconManager::Icon::tl.

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, Slic3r::empty(), fill_polygon_distances(), priv::ClosePoint::index, and Slic3r::MultiPoint::points.

Referenced by choose_best_distance().

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);
    if (sd.tree.nodes().size() == 0){
        // no lines in expolygon, check whether exist point to start
        double closest_square_distance = INFINITY;
        uint32_t closest_id = -1; 
        for (uint32_t i = 0; i < mask.size(); i++) 
            if (mask[i]){
                ExPolygonsIndex ei = s2i.cvt(i);
                const Point& s_p = ei.is_contour()? 
                    shapes[ei.expolygons_index].contour[ei.point_index]:
                shapes[ei.expolygons_index].holes[ei.hole_index()][ei.point_index];
                double square_distance = (p - s_p).cast<double>().squaredNorm();
                if (closest_id >= mask.size() || 
                    closest_square_distance > square_distance) {
                    closest_id = i;
                    closest_square_distance = square_distance;
                }
            }
        assert(closest_id < mask.size());
        return closest_id;
    }
    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 Slic3r::cast(), create_search_data(), Slic3r::ExPolygonsIndices::cvt(), Slic3r::ExPolygonsIndex::expolygons_index, get_closest_point_index(), Slic3r::ExPolygonsIndex::hole_index(), Slic3r::ExPolygonsIndex::is_contour(), priv::SearchData::lines, Slic3r::AABBTreeIndirect::Tree< ANumDimensions, ACoordType >::nodes(), Slic3r::ExPolygonsIndex::point_index, 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, count, 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:

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, and not_constrained.

Referenced by cut_from_model().

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];
        Vec2crd p_ = p.cast<coord_t>();
        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_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).value();
    // 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:

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 !get_intersections(lines).empty();
}

References Slic3r::get_intersections().

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

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 Vec3i32 &	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).value();
    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 count, 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_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::Triangulation::triangulate().

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
        Vec3i32 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, priv::SurfacePatch::loops, and priv::SurfacePatch::mesh.

Referenced by merge_patches().

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 BoundingBox &	shapes_bb,
		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	Shape to cut
shapes_bb	Bound of shapes
s2i
cutAOIs
meshes
projection

Returns

Mask of used patch

{
    // extension to cover numerical mistake made by back projection patch from 3d to 2d
    // Calculated as one percent of average size(width and height)
    Point s = shapes_bb.size();
    const float extend_delta = (s.x() + s.y())/ float(2 * 100);
        
    // 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::BoundingBoxBase< PointType, APointsType >::size(), to_expoly(), Slic3r::union_ex(), and Slic3r::Yes.

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).value();
    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 Slic3r::its_face_normal(), M_PI, and Slic3r::Emboss::IProject3d::project().

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(), is_out_of(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::normal(), and Slic3r::range().

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:

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(), priv::IntersectingElement::edge_1, priv::IntersectingElement::edge_2, edge_shape_map_name, exist_duplicit_vertex(), priv::IntersectingElement::face_1, priv::IntersectingElement::face_2, face_shape_map_name, priv::IntersectingElement::set_is_first(), priv::IntersectingElement::set_is_last(), priv::IntersectingElement::set_type(), and priv::IntersectingElement::undefined.

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().

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
    PolyFillType fill_type = 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, Slic3r::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_vec3d()

Vec3d priv::to_vec3d ( const P3 & p )

inline

{ 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:

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 count, 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:

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().

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().

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"