Slic3r::CadDocument Class Reference

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

Collaboration diagram for Slic3r::CadDocument:

Classes
struct	MateOption
struct	DatumAxis
struct	DatumCoordSys
struct	Interference
struct	Snapshot

Public Member Functions
int	add_sketch (SketchShape shape, const SketchPlane &plane, double width, double height, double radius, const std::string &name)
int	add_sketch_profile (const SketchProfile &profile, const SketchPlane &plane, const std::string &name)
int	add_sketch_entities (const std::vector< SketchEntity > &entities, const SketchPlane &plane, const std::string &name, const std::vector< SketchEntityConstraintDef > &constraints={})
int	add_project_edges (int source_body, const std::vector< int > &edge_ids, int face, const SketchPlane &plane, const std::string &name)
int	project_edges_into_sketch (int sketch_feature, int source_body, const std::vector< int > &edge_ids, int face)
int	add_bridge (int sketch_ref, int ent_a, int end_a, int ent_b, int end_b, const std::string &name)
bool	solve_sketch_feature (int index)
int	add_extrude (int sketch_ref, double distance, bool symmetric, BooleanMode mode, const std::string &name)
int	add_extrude_entities (const std::vector< SketchEntity > &entities, const SketchPlane &plane, double distance, bool symmetric, BooleanMode mode, const std::string &name)
int	add_extrude_face (int src_face, double distance, bool symmetric, BooleanMode mode, const std::string &name)
int	add_fillet (double radius, FaceGroup faces, const std::string &name)
int	add_fillet (double radius, int edge_id, const std::string &name)
int	add_fillet (double radius, const std::vector< int > &edge_ids, const std::string &name)
int	add_chamfer (double distance, FaceGroup faces, const std::string &name)
int	add_chamfer (double distance, int edge_id, const std::string &name)
int	add_chamfer (double distance, const std::vector< int > &edge_ids, const std::string &name)
int	add_hole (double diameter, double depth, bool through, double x, double y, const SketchPlane &plane, const std::string &name)
int	add_hole_styled (double diameter, double depth, bool through, double x, double y, const SketchPlane &plane, int style, double cbore_diameter, double cbore_depth, double csink_diameter, double csink_angle, const std::string &standard, const std::string &name)
int	add_hole_standard (const std::string &designation, int style, bool through, double depth, double x, double y, const SketchPlane &plane, const std::string &name)
int	add_thread (double radius, double pitch, double height, double depth, bool internal, double x, double y, const SketchPlane &plane, const std::string &name)
int	add_revolve (int sketch_ref, double angle, int axis, bool flip, BooleanMode mode, const std::string &name)
int	add_revolve_entities (const std::vector< SketchEntity > &entities, const SketchPlane &plane, double angle, int axis, bool flip, BooleanMode mode, const std::string &name)
int	add_pattern (bool circular, int count, double spacing, int dir, double angle_deg, int target_body, const std::string &name)
int	add_pattern_on_curve (int count, int curve_sketch, int curve_entity, int target, const std::string &name)
int	add_sweep (int profile_sketch_ref, int path_sketch_ref, BooleanMode mode, const std::string &name)
int	add_loft (const std::vector< int > &profile_refs, bool ruled, BooleanMode mode, const std::string &name)
int	add_surface_loft (const std::vector< int > &profile_refs, bool ruled, const std::string &name)
int	add_surface_fill (int sketch_ref, const std::string &name)
int	add_shell (double thickness, int face, int target_body, const std::string &name)
int	add_rib (int sketch_ref, int entity, double thickness, double depth, int target_body, const std::string &name)
int	add_draft (double angle, int face, int target_body, const std::string &name)
int	add_boolean (BooleanMode op, int target_body, int tool_body, bool keep_tool, double tolerance, int target_face, int tool_face, const std::string &name)
int	add_cut (const SketchPlane &plane, double offset, bool flip, bool keep_upper, bool keep_lower, int target_body, const std::string &name)
int	add_split_by_face (int target_body, int face_body, int face, bool keep_upper, bool keep_lower, const std::string &name)
int	add_mirror (const SketchPlane &plane, int target_body, BooleanMode mode, const std::string &name)
int	add_transform (int target_body, const Vec3d &translate, const Vec3d &axis, const Vec3d &pivot, double angle_deg, bool copy, const std::string &name)
int	add_thicken (int target_body, int face, double thickness, bool flip, const std::string &name)
int	add_thicken_surface (int target_body, double thickness, bool flip, const std::string &name)
int	add_surface_offset (int target_body, double offset, const std::string &name)
int	add_delete_face (int target_body, const std::vector< int > &faces, const std::string &name)
int	add_surface_extrude (int sketch_ref, double distance, const std::string &name)
int	add_surface_revolve (int sketch_ref, double angle_deg, int axis, const std::string &name)
int	add_plane (int base, double offset, double angle_tilt, int axis, const std::string &name)
int	add_axis (AxisType axis_type, const std::string &name)
int	add_coordsys (CoordSysType type, const Vec3d &point, const std::string &name)
int	add_mate (int kind, int cs_a, int cs_b, double offset, double angle_deg, bool flip, const std::string &name)
std::vector< MateOption >	mate_options (int cs_a, int cs_b) const
int	add_helix (const SketchPlane &plane, double radius, double pitch, double height, bool left_handed, double taper_deg, const std::string &name)
TopoDS_Wire	build_helix_wire (const CadFeature &f, std::string &err) const
std::vector< std::pair< std::string, SketchPlane > >	resolve_datum_planes () const
bool	plane_of_face (int body_idx, int face_idx, SketchPlane &out) const
std::vector< DatumAxis >	resolve_datum_axes () const
std::vector< DatumCoordSys >	resolve_datum_coordsys () const
void	clear ()
bool	recompute ()
std::string	serialize_recipe () const
bool	deserialize_recipe (const std::string &blob)
bool	export_step (const std::string &path, const std::vector< Transform3d > &body_xforms, std::string &err) const
GeometryEngine::MassProps	body_mass_properties (int body_index) const
std::vector< Interference >	check_interference (double min_volume=1e-6) const
void	checkpoint ()
void	abandon_checkpoint ()
bool	can_undo () const
bool	can_redo () const
size_t	undo_depth () const
size_t	redo_depth () const
bool	undo ()
bool	redo ()
bool	remove_feature (int index)
bool	move_feature (int index, int delta)
bool	set_feature_enabled (int index, bool enabled)
bool	replace_feature (int index, const CadFeature &edited)
bool	replace_sketch_extrude (int sketch_idx, int extrude_idx, const CadFeature &edited)
int	body_touching_sketch (int sketch_ref) const
bool	preview (const CadFeature &candidate, TriangleMesh &out_mesh, std::string &err) const
bool	preview (const CadFeature &candidate, TriangleMesh &out_mesh, std::vector< TriangleMesh > &out_body_meshes, std::string &err) const
std::vector< std::pair< int, int > >	faces_made_by (int index) const

Static Public Member Functions
static bool	is_bindable_field (const std::string &field)
static bool	produces_body (CadFeatureType t)
static bool	is_sheet_shape (const TopoDS_Shape &s)

Public Attributes
std::vector< CadFeature >	features
std::map< std::string, std::string >	variables
std::vector< CadBody >	bodies
TopoDS_Shape	body
TriangleMesh	display_mesh
std::vector< TriangleMesh >	display_body_meshes
std::vector< int >	display_tri_face
std::vector< int >	display_tri_body
std::string	error
std::vector< std::pair< int, std::string > >	mate_conflicts
Vec3d	modeling_origin {Vec3d::Zero()}
bool	origin_from_recipe {false}
bool	auto_close_loops {true}
double	linear_deflection {0.003}
double	angular_deflection {0.5}
uint64_t	topo_generation {1}

Static Public Attributes
static constexpr uint32_t	ORCA_CAD_RECIPE_VERSION = 6

Private Member Functions
TopoDS_Wire	build_sketch_wire (const CadFeature &sketch, bool closed_only=false) const
TopoDS_Face	build_sketch_face (const CadFeature &sketch) const
void	apply_feature (TopoDS_Shape &result, bool &have_body, const TopoDS_Shape &context, const CadFeature &f) const
void	route_feature (std::vector< CadBody > &bodies, const CadFeature &f) const
void	bind_expressions ()
void	replay_feature (size_t fi, std::vector< CadBody > &built)
void	apply_boolean (std::vector< CadBody > &bodies, const CadFeature &f) const
void	apply_cut (std::vector< CadBody > &bodies, const CadFeature &f) const
void	apply_mirror (std::vector< CadBody > &bodies, const CadFeature &f) const
void	apply_transform (std::vector< CadBody > &bodies, const CadFeature &f) const
void	apply_thicken (std::vector< CadBody > &bodies, const CadFeature &f) const
void	apply_thicken_surface (std::vector< CadBody > &bodies, const CadFeature &f) const
void	apply_surface_offset (std::vector< CadBody > &bodies, const CadFeature &f) const
void	apply_project (const std::vector< CadBody > &bodies, CadFeature &f) const
void	apply_mate (std::vector< CadBody > &bodies, const CadFeature &f) const
void	detect_mate_conflicts ()

Static Private Member Functions
static DatumCoordSys	datum_frame (const std::vector< CadBody > &bodies, const CadFeature &f)

Private Attributes
std::vector< Snapshot >	m_undo
std::vector< Snapshot >	m_redo

Static Private Attributes
static constexpr size_t	k_undo_cap = 200

Detailed Description

---

Class Documentation

Slic3r::CadDocument::MateOption

struct Slic3r::CadDocument::MateOption

Collaboration diagram for Slic3r::CadDocument::MateOption:

Class Members
int	kind {0}
string	reason
bool	viable {true}

Slic3r::CadDocument::DatumAxis

struct Slic3r::CadDocument::DatumAxis

Collaboration diagram for Slic3r::CadDocument::DatumAxis:

Class Members
Vec3d	direction {0,0,1}
string	error
string	name
Vec3d	origin {0,0,0}

Slic3r::CadDocument::DatumCoordSys

struct Slic3r::CadDocument::DatumCoordSys

Collaboration diagram for Slic3r::CadDocument::DatumCoordSys:

Class Members
string	error
string	name
Vec3d	origin {0,0,0}
Vec3d	x {1,0,0}
Vec3d	y {0,1,0}

Slic3r::CadDocument::Interference

struct Slic3r::CadDocument::Interference

Class Members
int	body_a {-1}
int	body_b {-1}
double	volume {0}

Slic3r::CadDocument::Snapshot

struct Slic3r::CadDocument::Snapshot

Collaboration diagram for Slic3r::CadDocument::Snapshot:

Class Members
vector< CadFeature >	features
map< string, string >	variables

Member Function Documentation

abandon_checkpoint()

void Slic3r::CadDocument::abandon_checkpoint

(

)

{
    if (!m_undo.empty())
        m_undo.pop_back();
}

References m_undo.

add_axis()

int Slic3r::CadDocument::add_axis	(	AxisType	axis_type,
		const std::string &	name )

{
    CadFeature f;
    f.type      = CadFeatureType::Axis;
    f.name      = name;
    f.axis_type = axis_type_;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::Axis, Slic3r::f(), and features.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_axis().

Here is the call graph for this function:

Here is the caller graph for this function:

add_boolean()

int Slic3r::CadDocument::add_boolean	(	BooleanMode	op,
		int	target_body,
		int	tool_body,
		bool	keep_tool,
		double	tolerance,
		int	target_face,
		int	tool_face,
		const std::string &	name )

{
    CadFeature f;
    f.type             = CadFeatureType::Boolean;
    f.name             = name;
    f.mode             = op;
    f.target_body      = target_body;
    f.bool_tool_body   = tool_body;
    f.bool_keep_tool   = keep_tool;
    f.bool_tolerance   = tolerance;
    f.bool_target_face = target_face;
    f.bool_tool_face   = tool_face;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::Boolean, Slic3r::f(), and features.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_boolean().

Here is the call graph for this function:

Here is the caller graph for this function:

add_bridge()

int Slic3r::CadDocument::add_bridge	(	int	sketch_ref,
		int	ent_a,
		int	end_a,
		int	ent_b,
		int	end_b,
		const std::string &	name )

{
    (void)name;
    if (sketch_ref < 0 || sketch_ref >= int(features.size())
        || features[sketch_ref].type != CadFeatureType::Sketch)
        throw std::runtime_error("bridge: sketch_ref must refer to a Sketch feature");
    auto& ents = features[sketch_ref].entities;
    if (ent_a < 0 || ent_a >= int(ents.size()) || ent_b < 0 || ent_b >= int(ents.size()))
        throw std::runtime_error("bridge: entity index out of range in sketch");
    SketchEntity br = SketchEngine::make_bridge(ents[ent_a], end_a, ents[ent_b], end_b);
    ents.push_back(br);
    return int(ents.size()) - 1;
}

References features, Slic3r::SketchEngine::make_bridge(), and Slic3r::Sketch.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_bridge().

Here is the call graph for this function:

Here is the caller graph for this function:

add_chamfer() [1/3]

int Slic3r::CadDocument::add_chamfer	(	double	distance,
		const std::vector< int > &	edge_ids,
		const std::string &	name )

{
    if (edge_ids.size() == 1) return add_chamfer(distance, edge_ids.front(), name);
    CadFeature f;
    f.type          = CadFeatureType::Chamfer;
    f.name          = name;
    f.dressup_size  = distance;
    f.dressup_edges = edge_ids;
    f.dressup_edge  = edge_ids.empty() ? -1 : edge_ids.front();
    features.push_back(f);
    return int(features.size()) - 1;
}

References add_chamfer(), Slic3r::Chamfer, Slic3r::f(), and features.

Here is the call graph for this function:

add_chamfer() [2/3]

int Slic3r::CadDocument::add_chamfer	(	double	distance,
		FaceGroup	faces,
		const std::string &	name )

{
    CadFeature f;
    f.type         = CadFeatureType::Chamfer;
    f.name         = name;
    f.dressup_size = distance;
    f.face_group   = faces;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::Chamfer, Slic3r::f(), and features.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_chamfer(), and add_chamfer().

Here is the call graph for this function:

Here is the caller graph for this function:

add_chamfer() [3/3]

int Slic3r::CadDocument::add_chamfer	(	double	distance,
		int	edge_id,
		const std::string &	name )

{
    CadFeature f;
    f.type         = CadFeatureType::Chamfer;
    f.name         = name;
    f.dressup_size = distance;
    f.dressup_edge = edge_id;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::Chamfer, Slic3r::f(), and features.

Here is the call graph for this function:

add_coordsys()

int Slic3r::CadDocument::add_coordsys	(	CoordSysType	type,
		const Vec3d &	point,
		const std::string &	name )

{
    CadFeature f;
    f.type           = CadFeatureType::CoordSys;
    f.name           = name;
    f.coordsys_type  = type;
    f.coordsys_point = point;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::CoordSys, Slic3r::f(), and features.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_coordsys().

Here is the call graph for this function:

Here is the caller graph for this function:

add_cut()

int Slic3r::CadDocument::add_cut	(	const SketchPlane &	plane,
		double	offset,
		bool	flip,
		bool	keep_upper,
		bool	keep_lower,
		int	target_body,
		const std::string &	name )

{
    CadFeature f;
    f.type           = CadFeatureType::Cut;
    f.name           = name;
    f.plane          = plane;
    f.cut_offset     = offset;
    f.cut_flip       = flip;
    f.cut_keep_upper = keep_upper;
    f.cut_keep_lower = keep_lower;
    f.target_body    = target_body;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::Cut, Slic3r::f(), features, and Slic3r::offset().

Here is the call graph for this function:

add_delete_face()

int Slic3r::CadDocument::add_delete_face	(	int	target_body,
		const std::vector< int > &	faces,
		const std::string &	name )

{
    CadFeature f;
    f.type         = CadFeatureType::DeleteFace;
    f.name         = name;
    f.target_body  = target_body;
    f.delete_faces = faces;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::DeleteFace, Slic3r::f(), and features.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_delete_face().

Here is the call graph for this function:

Here is the caller graph for this function:

add_draft()

int Slic3r::CadDocument::add_draft	(	double	angle,
		int	face,
		int	target_body,
		const std::string &	name )

{
    CadFeature f;
    f.type        = CadFeatureType::Draft;
    f.name        = name;
    f.draft_angle = angle;
    f.draft_face  = face;
    f.target_body = target_body;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::angle(), Slic3r::Draft, Slic3r::f(), and features.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_draft().

Here is the call graph for this function:

Here is the caller graph for this function:

add_extrude()

int Slic3r::CadDocument::add_extrude	(	int	sketch_ref,
		double	distance,
		bool	symmetric,
		BooleanMode	mode,
		const std::string &	name )

{
    CadFeature f;
    f.type       = CadFeatureType::Extrude;
    f.name       = name;
    f.sketch_ref = sketch_ref;
    f.distance   = distance;
    f.symmetric  = symmetric;
    f.mode       = mode;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::Extrude, Slic3r::f(), and features.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude().

Here is the call graph for this function:

Here is the caller graph for this function:

add_extrude_entities()

int Slic3r::CadDocument::add_extrude_entities	(	const std::vector< SketchEntity > &	entities,
		const SketchPlane &	plane,
		double	distance,
		bool	symmetric,
		BooleanMode	mode,
		const std::string &	name )

{
    // Self-contained extrude of a single loop: the entity subset lives on the feature
    // itself (sketch_ref = -1), so build_sketch_wire(f) uses f.entities directly. The
    // source sketch stays a separate feature, so its other loops remain selectable.
    CadFeature f;
    f.type       = CadFeatureType::Extrude;
    f.name       = name;
    f.sketch_ref = -1;
    f.entities   = entities;
    f.plane      = plane;
    f.distance   = distance;
    f.symmetric  = symmetric;
    f.mode       = mode;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::Extrude, Slic3r::f(), and features.

Here is the call graph for this function:

add_extrude_face()

int Slic3r::CadDocument::add_extrude_face	(	int	src_face,
		double	distance,
		bool	symmetric,
		BooleanMode	mode,
		const std::string &	name )

{
    CadFeature f;
    f.type             = CadFeatureType::Extrude;
    f.name             = name;
    f.sketch_ref       = -1;
    f.extrude_src_face = src_face;
    f.distance         = distance;
    f.symmetric        = symmetric;
    f.mode             = mode;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::Extrude, Slic3r::f(), and features.

Here is the call graph for this function:

add_fillet() [1/3]

int Slic3r::CadDocument::add_fillet	(	double	radius,
		const std::vector< int > &	edge_ids,
		const std::string &	name )

{
    if (edge_ids.size() == 1) return add_fillet(radius, edge_ids.front(), name);
    CadFeature f;
    f.type          = CadFeatureType::Fillet;
    f.name          = name;
    f.dressup_size  = radius;
    f.dressup_edges = edge_ids;
    f.dressup_edge  = edge_ids.empty() ? -1 : edge_ids.front();
    features.push_back(f);
    return int(features.size()) - 1;
}

References add_fillet(), Slic3r::f(), features, and Slic3r::Fillet.

Here is the call graph for this function:

add_fillet() [2/3]

int Slic3r::CadDocument::add_fillet	(	double	radius,
		FaceGroup	faces,
		const std::string &	name )

{
    CadFeature f;
    f.type         = CadFeatureType::Fillet;
    f.name         = name;
    f.dressup_size = radius;
    f.face_group   = faces;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Fillet.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_fillet(), and add_fillet().

Here is the call graph for this function:

Here is the caller graph for this function:

add_fillet() [3/3]

int Slic3r::CadDocument::add_fillet	(	double	radius,
		int	edge_id,
		const std::string &	name )

{
    CadFeature f;
    f.type         = CadFeatureType::Fillet;
    f.name         = name;
    f.dressup_size = radius;
    f.dressup_edge = edge_id;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Fillet.

Here is the call graph for this function:

add_helix()

int Slic3r::CadDocument::add_helix	(	const SketchPlane &	plane,
		double	radius,
		double	pitch,
		double	height,
		bool	left_handed,
		double	taper_deg,
		const std::string &	name )

{
    CadFeature f;
    f.type              = CadFeatureType::Helix;
    f.name              = name;
    f.plane             = plane;
    f.helix_radius      = radius;
    f.helix_pitch       = pitch;
    f.helix_height      = height;
    f.helix_left_handed = left_handed;
    f.helix_taper_deg   = taper_deg;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Helix.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_helix().

Here is the call graph for this function:

Here is the caller graph for this function:

add_hole()

int Slic3r::CadDocument::add_hole	(	double	diameter,
		double	depth,
		bool	through,
		double	x,
		double	y,
		const SketchPlane &	plane,
		const std::string &	name )

{
    CadFeature f;
    f.type          = CadFeatureType::Hole;
    f.name          = name;
    f.plane         = plane;
    f.hole_diameter = diameter;
    f.hole_depth    = depth;
    f.hole_through  = through;
    f.hole_x        = x;
    f.hole_y        = y;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Hole.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole().

Here is the call graph for this function:

Here is the caller graph for this function:

add_hole_standard()

int Slic3r::CadDocument::add_hole_standard	(	const std::string &	designation,
		int	style,
		bool	through,
		double	depth,
		double	x,
		double	y,
		const SketchPlane &	plane,
		const std::string &	name )

{
    const HoleStdEntry* e = hole_std_lookup(designation);
    if (e == nullptr)
        throw std::runtime_error(format(_u8L("unknown hole standard \"%1%\""), designation));
    return add_hole_styled(e->clearance, depth, through, x, y, plane, style,
                           e->cbore_d, e->cbore_depth, e->csink_d, e->csink_angle, e->desig, name);
}

References _u8L, add_hole_styled(), Slic3r::HoleStdEntry::cbore_d, Slic3r::HoleStdEntry::cbore_depth, Slic3r::HoleStdEntry::clearance, Slic3r::HoleStdEntry::csink_angle, Slic3r::HoleStdEntry::csink_d, Slic3r::HoleStdEntry::desig, Slic3r::format(), Slic3r::hole_std_lookup(), and style.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_standard().

Here is the call graph for this function:

Here is the caller graph for this function:

add_hole_styled()

int Slic3r::CadDocument::add_hole_styled	(	double	diameter,
		double	depth,
		bool	through,
		double	x,
		double	y,
		const SketchPlane &	plane,
		int	style,
		double	cbore_diameter,
		double	cbore_depth,
		double	csink_diameter,
		double	csink_angle,
		const std::string &	standard,
		const std::string &	name )

{
    CadFeature f;
    f.type                = CadFeatureType::Hole;
    f.name                = name;
    f.plane               = plane;
    f.hole_diameter       = diameter;
    f.hole_depth          = depth;
    f.hole_through        = through;
    f.hole_x              = x;
    f.hole_y              = y;
    f.hole_style          = style;
    f.hole_cbore_diameter = cbore_diameter;
    f.hole_cbore_depth    = cbore_depth;
    f.hole_csink_diameter = csink_diameter;
    f.hole_csink_angle    = csink_angle;
    f.hole_standard       = standard;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::Hole, and style.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_styled(), and add_hole_standard().

Here is the call graph for this function:

Here is the caller graph for this function:

add_loft()

int Slic3r::CadDocument::add_loft	(	const std::vector< int > &	profile_refs,
		bool	ruled,
		BooleanMode	mode,
		const std::string &	name )

{
    CadFeature f;
    f.type              = CadFeatureType::Loft;
    f.name              = name;
    f.loft_profile_refs = profile_refs;
    f.loft_ruled        = ruled;
    f.mode              = mode;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Loft.

Here is the call graph for this function:

add_mate()

int Slic3r::CadDocument::add_mate	(	int	kind,
		int	cs_a,
		int	cs_b,
		double	offset,
		double	angle_deg,
		bool	flip,
		const std::string &	name )

{
    CadFeature f;
    f.type       = CadFeatureType::Mate;
    f.name       = name;
    f.mate_kind  = kind;
    f.mate_cs_a  = cs_a;
    f.mate_cs_b  = cs_b;
    f.mate_offset = offset;
    f.mate_angle  = angle_deg;
    f.mate_flip   = flip;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::Mate, and Slic3r::offset().

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mate().

Here is the call graph for this function:

Here is the caller graph for this function:

add_mirror()

int Slic3r::CadDocument::add_mirror	(	const SketchPlane &	plane,
		int	target_body,
		BooleanMode	mode,
		const std::string &	name )

{
    CadFeature f;
    f.type                 = CadFeatureType::Mirror;
    f.name                 = name;
    f.plane                = plane;
    f.target_body          = target_body;
    f.mode                 = mode;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Mirror.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mirror().

Here is the call graph for this function:

Here is the caller graph for this function:

add_pattern()

int Slic3r::CadDocument::add_pattern	(	bool	circular,
		int	count,
		double	spacing,
		int	dir,
		double	angle_deg,
		int	target_body,
		const std::string &	name )

{
    CadFeature f;
    f.type             = CadFeatureType::Pattern;
    f.name             = name;
    f.pattern_circular = circular;
    f.pattern_count    = count;
    f.pattern_spacing  = spacing;
    f.pattern_dir      = dir;
    f.pattern_angle    = angle_deg;
    f.pattern_inclusive = true;
    f.target_body      = target_body;
    // The pattern's plane — its linear axes and the circular pattern's pivot — defaults to the
    // XY plane through the MODELING origin (the bed centre), like every other default plane in
    // the tab. Left at SketchPlane::XY() it pivoted about the bed's corner.
    f.plane            = SketchPlane::XY();
    f.plane.origin    += modeling_origin;
    features.push_back(f);
    return int(features.size()) - 1;
}

References count, Slic3r::f(), features, modeling_origin, Slic3r::Pattern, and Slic3r::SketchPlane::XY().

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

add_pattern_on_curve()

int Slic3r::CadDocument::add_pattern_on_curve	(	int	count,
		int	curve_sketch,
		int	curve_entity,
		int	target,
		const std::string &	name )

{
    CadFeature f;
    f.type                 = CadFeatureType::Pattern;
    f.name                 = name;
    f.pattern_count        = count;
    f.pattern_curve_sketch = curve_sketch;
    f.pattern_curve_entity = curve_entity;
    f.target_body          = target;
    f.pattern_circular     = false;
    features.push_back(f);
    return int(features.size()) - 1;
}

References count, Slic3r::f(), features, and Slic3r::Pattern.

Here is the call graph for this function:

add_plane()

int Slic3r::CadDocument::add_plane	(	int	base,
		double	offset,
		double	angle_tilt,
		int	axis,
		const std::string &	name )

{
    CadFeature f;
    f.type             = CadFeatureType::Plane;
    f.name             = name;
    f.plane_base       = base;
    f.plane_offset     = offset;
    f.plane_angle_tilt = angle_tilt;
    f.plane_axis       = axis;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::offset(), and Slic3r::Plane.

Here is the call graph for this function:

add_project_edges()

int Slic3r::CadDocument::add_project_edges	(	int	source_body,
		const std::vector< int > &	edge_ids,
		int	face,
		const SketchPlane &	plane,
		const std::string &	name )

{
    CadFeature f;
    f.type                = CadFeatureType::Project;
    f.name                = name;
    f.project_source_body = source_body;
    f.project_edges       = edge_ids;
    f.project_face        = face;
    f.plane               = plane;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Project.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_project().

Here is the call graph for this function:

Here is the caller graph for this function:

add_revolve()

int Slic3r::CadDocument::add_revolve	(	int	sketch_ref,
		double	angle,
		int	axis,
		bool	flip,
		BooleanMode	mode,
		const std::string &	name )

{
    CadFeature f;
    f.type          = CadFeatureType::Revolve;
    f.name          = name;
    f.sketch_ref    = sketch_ref;
    f.revolve_angle = angle;
    f.revolve_axis  = axis;
    f.flip          = flip;
    f.mode          = mode;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::angle(), Slic3r::f(), features, and Slic3r::Revolve.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_revolve().

Here is the call graph for this function:

Here is the caller graph for this function:

add_revolve_entities()

int Slic3r::CadDocument::add_revolve_entities	(	const std::vector< SketchEntity > &	entities,
		const SketchPlane &	plane,
		double	angle,
		int	axis,
		bool	flip,
		BooleanMode	mode,
		const std::string &	name )

{
    CadFeature f;
    f.type          = CadFeatureType::Revolve;
    f.name          = name;
    f.sketch_ref    = -1;
    f.entities      = entities;
    f.plane         = plane;
    f.revolve_angle = angle;
    f.revolve_axis  = axis;
    f.flip          = flip;
    f.mode          = mode;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::angle(), Slic3r::f(), features, and Slic3r::Revolve.

Here is the call graph for this function:

add_rib()

int Slic3r::CadDocument::add_rib	(	int	sketch_ref,
		int	entity,
		double	thickness,
		double	depth,
		int	target_body,
		const std::string &	name )

{
    CadFeature f;
    f.type           = CadFeatureType::Rib;
    f.name           = name;
    f.rib_sketch_ref = sketch_ref;
    f.rib_entity     = entity;
    f.rib_thickness  = thickness;
    f.rib_depth      = depth;
    f.target_body    = target_body;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Rib.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_rib().

Here is the call graph for this function:

Here is the caller graph for this function:

add_shell()

int Slic3r::CadDocument::add_shell	(	double	thickness,
		int	face,
		int	target_body,
		const std::string &	name )

{
    CadFeature f;
    f.type            = CadFeatureType::Shell;
    f.name            = name;
    f.shell_thickness = thickness;
    f.shell_face      = face;
    f.target_body     = target_body;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Shell.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_shell().

Here is the call graph for this function:

Here is the caller graph for this function:

add_sketch()

int Slic3r::CadDocument::add_sketch	(	SketchShape	shape,
		const SketchPlane &	plane,
		double	width,
		double	height,
		double	radius,
		const std::string &	name )

{
    CadFeature f;
    f.type   = CadFeatureType::Sketch;
    f.name   = name;
    f.shape  = shape;
    f.plane  = plane;
    f.width  = width;
    f.height = height;
    f.radius = radius;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Sketch.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude(), and Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_revolve().

Here is the call graph for this function:

Here is the caller graph for this function:

add_sketch_entities()

int Slic3r::CadDocument::add_sketch_entities	(	const std::vector< SketchEntity > &	entities,
		const SketchPlane &	plane,
		const std::string &	name,
		const std::vector< SketchEntityConstraintDef > &	constraints = {} )

{
    CadFeature f;
    f.type               = CadFeatureType::Sketch;
    f.name               = name;
    f.plane              = plane;
    f.entities           = entities;
    f.entity_constraints = constraints;   // driving dimensions, solved by solve_sketch_feature
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Sketch.

Here is the call graph for this function:

add_sketch_profile()

int Slic3r::CadDocument::add_sketch_profile	(	const SketchProfile &	profile,
		const SketchPlane &	plane,
		const std::string &	name )

{
    CadFeature f;
    f.type    = CadFeatureType::Sketch;
    f.name    = name;
    f.plane   = plane;
    f.profile = profile;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Sketch.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude(), and Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_revolve().

Here is the call graph for this function:

Here is the caller graph for this function:

add_split_by_face()

int Slic3r::CadDocument::add_split_by_face	(	int	target_body,
		int	face_body,
		int	face,
		bool	keep_upper,
		bool	keep_lower,
		const std::string &	name )

{
    CadFeature f;
    f.type           = CadFeatureType::Cut;
    f.name           = name;
    f.target_body    = target_body;
    f.cut_face_body  = face_body;
    f.cut_face       = face;
    f.cut_keep_upper = keep_upper;
    f.cut_keep_lower = keep_lower;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::Cut, Slic3r::f(), and features.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_split().

Here is the call graph for this function:

Here is the caller graph for this function:

add_surface_extrude()

int Slic3r::CadDocument::add_surface_extrude	(	int	sketch_ref,
		double	distance,
		const std::string &	name )

{
    CadFeature f;
    f.type       = CadFeatureType::SurfaceExtrude;
    f.name       = name;
    f.sketch_ref = sketch_ref;
    f.distance   = distance;
    f.mode       = BooleanMode::New;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::New, and Slic3r::SurfaceExtrude.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_extrude().

Here is the call graph for this function:

Here is the caller graph for this function:

add_surface_fill()

int Slic3r::CadDocument::add_surface_fill	(	int	sketch_ref,
		const std::string &	name )

{
    CadFeature f;
    f.type       = CadFeatureType::SurfaceFill;
    f.name       = name;
    f.sketch_ref = sketch_ref;
    f.mode       = BooleanMode::New;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::New, and Slic3r::SurfaceFill.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_fill().

Here is the call graph for this function:

Here is the caller graph for this function:

add_surface_loft()

int Slic3r::CadDocument::add_surface_loft	(	const std::vector< int > &	profile_refs,
		bool	ruled,
		const std::string &	name )

{
    CadFeature f;
    f.type              = CadFeatureType::SurfaceLoft;
    f.name              = name;
    f.loft_profile_refs = profile_refs;
    f.loft_ruled        = ruled;
    f.mode              = BooleanMode::New;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::New, and Slic3r::SurfaceLoft.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_loft().

Here is the call graph for this function:

Here is the caller graph for this function:

add_surface_offset()

int Slic3r::CadDocument::add_surface_offset	(	int	target_body,
		double	offset,
		const std::string &	name )

{
    CadFeature f;
    f.type         = CadFeatureType::SurfaceOffset;
    f.name         = name;
    f.target_body  = target_body;
    f.plane_offset = offset;
    f.mode         = BooleanMode::New;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::New, Slic3r::offset(), and Slic3r::SurfaceOffset.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

add_surface_revolve()

int Slic3r::CadDocument::add_surface_revolve	(	int	sketch_ref,
		double	angle_deg,
		int	axis,
		const std::string &	name )

{
    CadFeature f;
    f.type          = CadFeatureType::SurfaceRevolve;
    f.name          = name;
    f.sketch_ref    = sketch_ref;
    f.revolve_angle = angle_deg;
    f.revolve_axis  = axis;
    f.mode          = BooleanMode::New;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::New, and Slic3r::SurfaceRevolve.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_revolve().

Here is the call graph for this function:

Here is the caller graph for this function:

add_sweep()

int Slic3r::CadDocument::add_sweep	(	int	profile_sketch_ref,
		int	path_sketch_ref,
		BooleanMode	mode,
		const std::string &	name )

{
    CadFeature f;
    f.type           = CadFeatureType::Sweep;
    f.name           = name;
    f.sketch_ref     = profile_sketch_ref;
    f.sweep_path_ref = path_sketch_ref;
    f.mode           = mode;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Sweep.

Here is the call graph for this function:

add_thicken()

int Slic3r::CadDocument::add_thicken	(	int	target_body,
		int	face,
		double	thickness,
		bool	flip,
		const std::string &	name )

{
    CadFeature f;
    f.type             = CadFeatureType::Thicken;
    f.name             = name;
    f.target_body      = target_body;
    f.thicken_face     = face;
    f.thicken_thickness = thickness;
    f.thicken_flip     = flip;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Thicken.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken().

Here is the call graph for this function:

Here is the caller graph for this function:

add_thicken_surface()

int Slic3r::CadDocument::add_thicken_surface	(	int	target_body,
		double	thickness,
		bool	flip,
		const std::string &	name )

{
    CadFeature f;
    f.type              = CadFeatureType::ThickenSurface;
    f.name              = name;
    f.target_body       = target_body;
    f.thicken_thickness = thickness;
    f.thicken_flip      = flip;
    f.mode              = BooleanMode::New;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::New, and Slic3r::ThickenSurface.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

add_thread()

int Slic3r::CadDocument::add_thread	(	double	radius,
		double	pitch,
		double	height,
		double	depth,
		bool	internal,
		double	x,
		double	y,
		const SketchPlane &	plane,
		const std::string &	name )

{
    CadFeature f;
    f.type            = CadFeatureType::Thread;
    f.name            = name;
    f.plane           = plane;
    f.thread_radius   = radius;
    f.thread_pitch    = pitch;
    f.thread_height   = height;
    f.thread_depth    = depth;
    f.thread_internal = internal;
    f.thread_x        = x;
    f.thread_y        = y;
    f.thread_major_nominal = true;   // `radius` is the major (nominal) radius
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, and Slic3r::Thread.

Here is the call graph for this function:

add_transform()

int Slic3r::CadDocument::add_transform	(	int	target_body,
		const Vec3d &	translate,
		const Vec3d &	axis,
		const Vec3d &	pivot,
		double	angle_deg,
		bool	copy,
		const std::string &	name )

{
    CadFeature f;
    f.type         = CadFeatureType::Transform;
    f.name         = name;
    f.target_body  = target_body;
    f.xf_translate = translate;
    f.xf_axis      = axis;
    f.xf_pivot     = pivot;
    f.xf_angle_deg = angle_deg;
    f.xf_copy      = copy;
    features.push_back(f);
    return int(features.size()) - 1;
}

References Slic3r::f(), features, Slic3r::Transform, and Slic3r::translate().

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_transform().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_boolean()

void Slic3r::CadDocument::apply_boolean ( std::vector< CadBody > & bodies, const CadFeature & f ) const

private

{
    const int nb   = int(bodies.size());
    const int tgt  = pick_body(f.target_body, nb);
    const int tool = f.bool_tool_body == -1 ? -1 : pick_body(f.bool_tool_body, nb);
    // Same rule as Cut, Mirror and Transform: an operation that cannot run says why, rather
    // than leaving the bodies as they were and reporting success.
    if (tgt < 0)     throw std::runtime_error(_u8L("boolean: no target body"));
    if (tool < 0)    throw std::runtime_error(_u8L("boolean: no tool body — pick a second body"));
    if (tgt == tool) throw std::runtime_error(_u8L("boolean: the target and the tool are the same body"));
    const TopoDS_Shape A = bodies[tgt].shape;          // target survives
    const TopoDS_Shape B = bodies[tool].shape;         // tool, consumed unless kept
    if (A.IsNull() || B.IsNull()) throw std::runtime_error(_u8L("boolean: a body has no geometry"));
 
    NCollection_List<TopoDS_Shape> args, tools;
    args.Append(A);
    tools.Append(B);
    auto run = [&](BRepAlgoAPI_BooleanOperation& bop) -> TopoDS_Shape {
        bop.SetArguments(args);
        bop.SetTools(tools);
        if (f.bool_tolerance > 0.0) bop.SetFuzzyValue(f.bool_tolerance);   // OCCT fuzzy: merge near-coincident faces
        bop.Build();
        if (!bop.IsDone()) throw std::runtime_error(_u8L("boolean operation failed"));
        return bop.Shape();
    };
    TopoDS_Shape result;
    switch (f.mode) {
    case BooleanMode::Add:       { BRepAlgoAPI_Fuse   op; result = run(op); break; }   // union
    case BooleanMode::Cut:       { BRepAlgoAPI_Cut    op; result = run(op); break; }   // target - tool
    case BooleanMode::Intersect: { BRepAlgoAPI_Common op; result = run(op); break; }   // overlap
    default: throw std::runtime_error("boolean: choose Union, Subtract or Intersect");   // New means nothing between two bodies
    }
    if (result.IsNull()) throw std::runtime_error(_u8L("boolean produced an empty shape"));
 
    bodies[tgt].shape = result;
    if (!f.bool_keep_tool) bodies.erase(bodies.begin() + tool);   // consume the tool body
}

References _u8L, Slic3r::Add, bodies, Slic3r::Cut, Slic3r::f(), Slic3r::Intersect, and Slic3r::pick_body().

Referenced by route_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_cut()

void Slic3r::CadDocument::apply_cut ( std::vector< CadBody > & bodies, const CadFeature & f ) const

private

{
    const int nb  = int(bodies.size());
    if (nb == 0) throw std::runtime_error(_u8L("cut: no target body"));
    const int tgt = pick_body(f.target_body, nb);
    if (tgt < 0 || bodies[tgt].shape.IsNull()) throw std::runtime_error(_u8L("cut: no target body"));
 
    if (!f.cut_keep_upper && !f.cut_keep_lower)
        throw std::runtime_error(_u8L("cut keeps nothing"));
 
    SketchPlane cp;
    if (f.cut_face >= 0) {
        const int fb = f.cut_face_body == -1 ? tgt : pick_body(f.cut_face_body, nb);
        if (bodies[fb].shape.IsNull()) throw std::runtime_error(_u8L("cut: face body is empty"));
        TopoDS_Face fc = GeometryEngine::face_by_index(bodies[fb].shape, f.cut_face);
        if (fc.IsNull()) throw std::runtime_error(_u8L("cut: face not found"));
        cp = SketchPlane::from_face(fc);
    } else {
        cp = f.plane;
    }
    cp.origin += cp.normal * f.cut_offset;
    if (f.cut_flip) cp.normal = -cp.normal;
 
    // Build a large square wire in the cut plane, centered at plane origin.
    const double L = 1.0e5;
    Vec3d x = cp.x_axis * L;
    Vec3d y = cp.y_axis * L;
    Vec3d o = cp.origin;
    auto p = [&](double sx, double sy) {
        Vec3d v = o + x * sx + y * sy;
        return gp_Pnt(v.x(), v.y(), v.z());
    };
    BRepBuilderAPI_MakePolygon poly;
    poly.Add(p( 1,  1));
    poly.Add(p( 1, -1));
    poly.Add(p(-1, -1));
    poly.Add(p(-1,  1));
    poly.Close();
    if (!poly.IsDone()) throw std::runtime_error(_u8L("cut: failed to build cut wire"));
    TopoDS_Wire wire = poly.Wire();
 
    TopoDS_Shape upper_piece, lower_piece;
    const TopoDS_Shape& target = bodies[tgt].shape;
 
    if (f.cut_keep_upper) {
        TopoDS_Shape upper_tool = SketchEngine::make_extrude(wire, cp, L, false, 0.0);
        BRepAlgoAPI_Common common(target, upper_tool);
        if (!common.IsDone()) throw std::runtime_error(_u8L("cut operation failed"));
        upper_piece = common.Shape();
    }
 
    if (f.cut_keep_lower) {
        SketchPlane lp = cp;
        lp.normal = -lp.normal;
        TopoDS_Shape lower_tool = SketchEngine::make_extrude(wire, lp, L, false, 0.0);
        BRepAlgoAPI_Common common(target, lower_tool);
        if (!common.IsDone()) throw std::runtime_error(_u8L("cut operation failed"));
        lower_piece = common.Shape();
    }
 
    if (f.cut_keep_upper && f.cut_keep_lower) {
        bodies[tgt].shape = upper_piece;
        bodies.insert(bodies.begin() + tgt + 1,
                      CadBody{ lower_piece, bodies[tgt].name + " (2)" });
    } else if (f.cut_keep_upper) {
        bodies[tgt].shape = upper_piece;
    } else {
        bodies[tgt].shape = lower_piece;
    }
}

References _u8L, bodies, Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), Slic3r::SketchPlane::from_face(), L, Slic3r::SketchEngine::make_extrude(), Slic3r::SketchPlane::normal, Slic3r::SketchPlane::origin, Slic3r::pick_body(), Slic3r::SketchPlane::x_axis, and Slic3r::SketchPlane::y_axis.

Referenced by route_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_feature()

void Slic3r::CadDocument::apply_feature ( TopoDS_Shape & result, bool & have_body, const TopoDS_Shape & context, const CadFeature & f ) const

private

{
    switch (f.type) {
    case CadFeatureType::Sketch:
        return; // sketches carry no solid; consumed by an extrude
    case CadFeatureType::Project:
        return; // edges-to-sketch: consumed downstream, no solid body
    case CadFeatureType::Helix:
        return; // helical curve; consumed by Sweep as a path (like Sketch)
    case CadFeatureType::Boolean:
        return; // body-body boolean is handled in route_feature/apply_boolean, never here
    case CadFeatureType::Import:
        // Imported B-rep (STEP): rigid data carried on the feature, not built from
        // parameters — adopt it as the new body (New-path: result starts empty).
        result    = f.imported_solid;
        have_body = !result.IsNull();
        return;
    case CadFeatureType::Extrude: {
        const bool sym = (f.extrude_end == ExtrudeEnd::Symmetric);
        const double signed_d = f.flip ? -f.distance : f.distance;
        TopoDS_Shape tool;
        if (f.extrude_src_face >= 0) {
            // The source face is read from `context` (the owner body), which for a New
            // face-extrude is the source solid while `result` is the empty new body.
            if (context.IsNull()) throw std::runtime_error(_u8L("face-extrude needs a body"));
            TopoDS_Face srcf = GeometryEngine::face_by_index(context, f.extrude_src_face);
            if (srcf.IsNull()) throw std::runtime_error("face-extrude: invalid face id");
            SketchPlane fpl = SketchPlane::from_face(srcf);
            // from_face takes the surface's geometric normal and IGNORES the topological
            // face orientation, so for a REVERSED face (e.g. the top cap of an extruded
            // prism) it points INTO the solid -> a default push would fuse to nothing.
            // Orient it outward so push/pull grows away from the material (Onshape default);
            // the Flip checkbox (signed_d) still lets the user drive it inward for a cut.
            if (srcf.Orientation() == TopAbs_REVERSED) fpl.normal = -fpl.normal;
            tool = SketchEngine::make_extrude_face(srcf, fpl, signed_d, sym);
        } else {
            // Use the referenced sketch when sketch_ref is a valid Sketch index,
            // otherwise fall back to f's own inline sketch params (this makes a
            // single self-contained candidate previewable).
            const CadFeature& sk = (f.sketch_ref >= 0 && f.sketch_ref < int(features.size())
                                    && (features[f.sketch_ref].type == CadFeatureType::Sketch
                                        || features[f.sketch_ref].type == CadFeatureType::Project))
                                   ? features[f.sketch_ref] : f;
            // Imported rigid art (Text/SVG) extrudes via the faces-with-holes path
            // (with its placement transform applied); otherwise build the sketch's planar
            // region (outer loop + holes) from entities/profile/shape.
            tool = !sk.imported_regions.empty()
                ? SketchEngine::make_extrude_regions(
                      transform_regions(sk.imported_regions, sk.import_offset,
                                        sk.import_scale_x, sk.import_scale_y),
                      sk.plane,
                      f.extrude_end == ExtrudeEnd::ThroughAll ? 1e5 : signed_d,
                      f.extrude_end == ExtrudeEnd::ThroughAll ? true : (sym || f.extrude_end == ExtrudeEnd::TwoSided))
                : [&]() {
                      const TopoDS_Face profile = build_sketch_face(sk);
                      // A tapered extrude offsets the profile; a holed profile would have to
                      // offset its inner loops the opposite way, which is not implemented yet.
                      auto taper = [&](double L) -> TopoDS_Shape {
                          // Count the loops off the face we ALREADY built, rather than rebuilding
                          // every wire from the entities a second time to ask how many there are.
                          // It is also the more honest test: what matters is whether the profile
                          // being extruded has holes, not what the entity list could produce.
                          int nloops = 0;
                          for (TopExp_Explorer ex(profile, TopAbs_WIRE); ex.More(); ex.Next()) ++nloops;
                          if (nloops > 1)
                              throw std::runtime_error(_u8L("tapered extrude of a sketch with holes is not supported yet"));
                          return SketchEngine::make_extrude_taper(build_sketch_wire(sk, true), sk.plane, L, f.taper_deg);
                      };
                      TopoDS_Shape t;
                      switch (f.extrude_end) {
                          case ExtrudeEnd::Blind:
                              t = (std::abs(f.taper_deg) > 1e-6)
                                  ? taper(signed_d)
                                  : SketchEngine::make_extrude(profile, sk.plane, signed_d, false);
                              break;
                          case ExtrudeEnd::Symmetric:  t = SketchEngine::make_extrude(profile, sk.plane, f.distance, true); break;
                          case ExtrudeEnd::TwoSided:   t = SketchEngine::make_extrude_two_sided(profile, sk.plane, f.distance, f.distance2); break;
                          case ExtrudeEnd::ThroughAll: t = SketchEngine::make_extrude(profile, sk.plane, 1.0e5, true); break;
                          case ExtrudeEnd::UpToFace: {
                              const TopoDS_Face tgt = GeometryEngine::face_by_index(context, f.up_to_face);
                              double L = signed_d;
                              if (!tgt.IsNull()) {
                                  const Vec3d c = GeometryEngine::face_centroid_world(tgt);
                                  L = (c - sk.plane.origin).dot(sk.plane.normal);
                              }
                              t = (std::abs(f.taper_deg) > 1e-6)
                                  ? taper(L)
                                  : SketchEngine::make_extrude(profile, sk.plane, L, false);
                              break;
                          }
                          case ExtrudeEnd::UpToVertex: {
                              const double L = (f.up_to_point - sk.plane.origin).dot(sk.plane.normal);
                              t = SketchEngine::make_extrude(profile, sk.plane, L, false);
                              break;
                          }
                          default: t = SketchEngine::make_extrude(profile, sk.plane, signed_d, false); break;
                      }
                      return t;
                  }();
        }
        // New / first-of-a-body => result becomes the tool (route_feature sends New extrudes
        // here with an empty result, so a face-extrude New builds a fresh body from the source
        // face in `context` without touching it). Add/Cut/Intersect boolean into `result`.
        if (!have_body || f.mode == BooleanMode::New) {
            result = tool;
            have_body = true;
        } else if (f.mode == BooleanMode::Add) {
            BRepAlgoAPI_Fuse fuse(result, tool);
            if (!fuse.IsDone()) throw std::runtime_error(_u8L("fuse failed"));
            result = fuse.Shape();
        } else if (f.mode == BooleanMode::Cut) {
            BRepAlgoAPI_Cut cut(result, tool);
            if (!cut.IsDone()) throw std::runtime_error(_u8L("cut failed"));
            result = cut.Shape();
        } else if (f.mode == BooleanMode::Intersect) {
            BRepAlgoAPI_Common common(result, tool);
            if (!common.IsDone()) throw std::runtime_error(_u8L("intersect failed"));
            result = common.Shape();
        }
        break;
    }
    case CadFeatureType::Revolve: {
        // Resolve the profile sketch like Extrude: referenced Sketch when valid,
        // else this feature's own inline entities/profile (self-contained candidate).
        const CadFeature& sk = (f.sketch_ref >= 0 && f.sketch_ref < int(features.size())
                                && (features[f.sketch_ref].type == CadFeatureType::Sketch
                                    || features[f.sketch_ref].type == CadFeatureType::Project))
                               ? features[f.sketch_ref] : f;
        TopoDS_Wire wire = build_sketch_wire(sk, true);
        const double ang = f.flip ? -f.revolve_angle : f.revolve_angle;
        TopoDS_Shape tool = SketchEngine::make_revolve(wire, revolve_axis_of(f, sk), ang);
        if (!have_body || f.mode == BooleanMode::New) {
            result = tool;
            have_body = true;
        } else if (f.mode == BooleanMode::Add) {
            BRepAlgoAPI_Fuse fuse(result, tool);
            if (!fuse.IsDone()) throw std::runtime_error(_u8L("fuse failed"));
            result = fuse.Shape();
        } else if (f.mode == BooleanMode::Cut) {
            BRepAlgoAPI_Cut cut(result, tool);
            if (!cut.IsDone()) throw std::runtime_error(_u8L("cut failed"));
            result = cut.Shape();
        } else if (f.mode == BooleanMode::Intersect) {
            BRepAlgoAPI_Common common(result, tool);
            if (!common.IsDone()) throw std::runtime_error(_u8L("intersect failed"));
            result = common.Shape();
        }
        break;
    }
    case CadFeatureType::SurfaceExtrude: {
        if (f.sketch_ref < 0 || f.sketch_ref >= int(features.size()))
            throw std::runtime_error("surface-extrude: bad sketch ref");
        const CadFeature& sk = features[f.sketch_ref];
        if (sk.type != CadFeatureType::Sketch && sk.type != CadFeatureType::Project)
            throw std::runtime_error("surface-extrude: ref is not a sketch");
        TopoDS_Wire wire = build_sketch_wire(sk);
        if (wire.IsNull()) throw std::runtime_error(_u8L("surface-extrude: empty profile"));
        gp_Dir nrm(sk.plane.normal.x(), sk.plane.normal.y(), sk.plane.normal.z());
        try {
            result = SketchEngine::make_prism(wire, gp_Vec(nrm.XYZ() * f.distance));
        } catch (const std::exception& e) {
            throw std::runtime_error(format(_u8L("surface-extrude: %1%"), *e.what() ? e.what() : _u8L("prism failed")));
        }
        have_body = true;
        break;
    }
    case CadFeatureType::SurfaceRevolve: {
        if (f.sketch_ref < 0 || f.sketch_ref >= int(features.size()))
            throw std::runtime_error("surface-revolve: bad sketch ref");
        const CadFeature& sk = features[f.sketch_ref];
        if (sk.type != CadFeatureType::Sketch && sk.type != CadFeatureType::Project)
            throw std::runtime_error("surface-revolve: ref is not a sketch");
        TopoDS_Wire wire = build_sketch_wire(sk);
        if (wire.IsNull()) throw std::runtime_error(_u8L("surface-revolve: empty profile"));
        gp_Ax1 axis = revolve_axis_of(f, sk);
        // Same angle rules as the solid Revolve (flip reverses it, and a negative sweep is a
        // positive one about the reversed axis — MakeRevol wants (0, 2 pi]); this surface
        // version used to ignore both.
        double ang = (f.flip ? -f.revolve_angle : f.revolve_angle) * M_PI / 180.0;
        if (ang < 0) { axis.Reverse(); ang = -ang; }
        BRepPrimAPI_MakeRevol rev(wire, axis, ang, false);
        if (!rev.IsDone()) throw std::runtime_error(_u8L("surface-revolve: revolve failed"));
        result = rev.Shape(); have_body = true;
        break;
    }
    case CadFeatureType::SurfaceLoft: {
        std::vector<TopoDS_Wire> profiles;
        for (int ref : f.loft_profile_refs) {
            if (ref < 0 || ref >= int(features.size())
                || (features[ref].type != CadFeatureType::Sketch
                    && features[ref].type != CadFeatureType::Project))
                continue;
            profiles.push_back(build_sketch_wire(features[ref]));
        }
        if (profiles.size() < 2)
            throw std::runtime_error(_u8L("surface-loft needs 2+ valid profile sketches"));
        TopoDS_Shape skin = SketchEngine::make_loft_surface(profiles, f.loft_ruled);
        if (skin.IsNull()) throw std::runtime_error(_u8L("surface-loft: loft failed"));
        result = skin; have_body = true;
        break;
    }
    case CadFeatureType::SurfaceFill: {
        if (f.sketch_ref < 0 || f.sketch_ref >= int(features.size()))
            throw std::runtime_error("surface-fill: bad sketch ref");
        const CadFeature& sk = features[f.sketch_ref];
        if (sk.type != CadFeatureType::Sketch && sk.type != CadFeatureType::Project)
            throw std::runtime_error("surface-fill: ref is not a sketch");
        TopoDS_Wire wire = build_sketch_wire(sk);
        if (wire.IsNull()) throw std::runtime_error(_u8L("surface-fill: empty boundary"));
        BRepOffsetAPI_MakeFilling fill;
        int nedges = 0;
        for (TopExp_Explorer ex(wire, TopAbs_EDGE); ex.More(); ex.Next()) {
            fill.Add(TopoDS::Edge(ex.Current()), GeomAbs_C0);
            ++nedges;
        }
        if (nedges == 0) throw std::runtime_error(_u8L("surface-fill: boundary has no edges"));
        fill.Build();
        if (!fill.IsDone()) throw std::runtime_error(_u8L("surface-fill: fill failed"));
        TopoDS_Shape face = fill.Shape();
        if (face.IsNull()) throw std::runtime_error(_u8L("surface-fill: produced no geometry"));
        result = face; have_body = true;
        break;
    }
    case CadFeatureType::Sweep: {
        const CadFeature& sk = (f.sketch_ref >= 0 && f.sketch_ref < int(features.size())
                                && (features[f.sketch_ref].type == CadFeatureType::Sketch
                                    || features[f.sketch_ref].type == CadFeatureType::Project))
                               ? features[f.sketch_ref] : f;
        if (f.sweep_path_ref < 0 || f.sweep_path_ref >= int(features.size()))
            throw std::runtime_error(_u8L("sweep needs a valid path reference"));
        const CadFeature& path_feat = features[f.sweep_path_ref];
        TopoDS_Wire path;
        if (path_feat.type == CadFeatureType::Helix) {
            std::string helix_err;
            path = make_helix_spine(path_feat, helix_err);
            if (path.IsNull()) throw std::runtime_error(format(_u8L("helix path: %1%"), helix_err));
        } else if (path_feat.type == CadFeatureType::Sketch) {
            path = build_sketch_wire(path_feat);
        } else {
            throw std::runtime_error(_u8L("sweep path must be a sketch or helix"));
        }
        TopoDS_Wire profile = build_sketch_wire(sk, true);
        TopoDS_Shape tool   = SketchEngine::make_sweep(profile, path);
        if (!have_body || f.mode == BooleanMode::New) {
            result = tool;
            have_body = true;
        } else if (f.mode == BooleanMode::Add) {
            BRepAlgoAPI_Fuse fuse(result, tool);
            if (!fuse.IsDone()) throw std::runtime_error(_u8L("fuse failed"));
            result = fuse.Shape();
        } else if (f.mode == BooleanMode::Cut) {
            BRepAlgoAPI_Cut cut(result, tool);
            if (!cut.IsDone()) throw std::runtime_error(_u8L("cut failed"));
            result = cut.Shape();
        } else if (f.mode == BooleanMode::Intersect) {
            BRepAlgoAPI_Common common(result, tool);
            if (!common.IsDone()) throw std::runtime_error(_u8L("intersect failed"));
            result = common.Shape();
        }
        break;
    }
    case CadFeatureType::Loft: {
        // Loft through 2+ closed profile Sketches, in recipe order. Each profile builds
        // a wire via build_sketch_wire (so it keeps its own plane); make_loft skins them.
        std::vector<TopoDS_Wire> profiles;
        for (int ref : f.loft_profile_refs) {
            if (ref < 0 || ref >= int(features.size())
                || (features[ref].type != CadFeatureType::Sketch
                    && features[ref].type != CadFeatureType::Project))
                continue;
            profiles.push_back(build_sketch_wire(features[ref], true));
        }
        if (profiles.size() < 2)
            throw std::runtime_error(_u8L("loft needs 2+ valid profile sketches"));
        TopoDS_Shape tool = SketchEngine::make_loft(profiles, f.loft_ruled);
        if (!have_body || f.mode == BooleanMode::New) {
            result = tool;
            have_body = true;
        } else if (f.mode == BooleanMode::Add) {
            BRepAlgoAPI_Fuse fuse(result, tool);
            if (!fuse.IsDone()) throw std::runtime_error(_u8L("fuse failed"));
            result = fuse.Shape();
        } else if (f.mode == BooleanMode::Cut) {
            BRepAlgoAPI_Cut cut(result, tool);
            if (!cut.IsDone()) throw std::runtime_error(_u8L("cut failed"));
            result = cut.Shape();
        } else if (f.mode == BooleanMode::Intersect) {
            BRepAlgoAPI_Common common(result, tool);
            if (!common.IsDone()) throw std::runtime_error(_u8L("intersect failed"));
            result = common.Shape();
        }
        break;
    }
    case CadFeatureType::Pattern: {
        // Pattern along a curve: when pattern_curve_sketch >= 0 this mode takes
        // precedence over linear/circular. Copies are placed at equal-parameter points
        // along the referenced sketch entity, translated by (P_i - P_0).
        if (f.pattern_curve_sketch >= 0) {
            if (f.pattern_curve_sketch >= (int)features.size())
                throw std::runtime_error("pattern-on-curve: bad sketch ref");
            const CadFeature& gs = features[f.pattern_curve_sketch];
            if (gs.type != CadFeatureType::Sketch)
                throw std::runtime_error("pattern-on-curve: ref is not a sketch");
            if (f.pattern_curve_entity < 0 || f.pattern_curve_entity >= (int)gs.entities.size())
                throw std::runtime_error("pattern-on-curve: bad entity");
            if (!have_body) throw std::runtime_error(_u8L("pattern needs a body"));
            const SketchEntity& gc = gs.entities[f.pattern_curve_entity];
            const int n = std::max(1, f.pattern_count);
            const TopoDS_Shape seed = result;
            Vec3d p0 = gs.plane.to_world(sample_entity_2d(gc, 0.0));
            for (int i = 1; i < n; ++i) {
                double t = double(i) / double(n - 1 > 0 ? n - 1 : 1);
                Vec3d pi = gs.plane.to_world(sample_entity_2d(gc, t));
                Vec3d d  = pi - p0;
                gp_Trsf trsf;
                trsf.SetTranslation(gp_Vec(d.x(), d.y(), d.z()));
                TopoDS_Shape copy = BRepBuilderAPI_Transform(seed, trsf, true).Shape();
                BRepAlgoAPI_Fuse fuse(result, copy);
                if (!fuse.IsDone()) throw std::runtime_error(_u8L("pattern fuse failed"));
                result = fuse.Shape();
            }
            break;
        }
        // Replicate the target body. Each copy is a rigid gp_Trsf of the seed, all
        // fused into one body. Linear: i*spacing along plane axis pattern_dir
        // (0=X,1=Y). Circular: i*(angle/count) about the plane normal through the
        // plane origin (so a seed offset from the origin orbits the axis).
        if (!have_body) throw std::runtime_error(_u8L("pattern needs a body"));
        const int n = std::max(1, f.pattern_count);
        const TopoDS_Shape seed = result;
        for (int i = 1; i < n; ++i) {
            gp_Trsf trsf;
            if (f.pattern_circular) {
                Vec3d  o = f.plane.to_world(Vec2d(0, 0));
                gp_Ax1 ax(gp_Pnt(o.x(), o.y(), o.z()),
                          gp_Dir(f.plane.normal.x(), f.plane.normal.y(), f.plane.normal.z()));
                const bool full = std::abs(std::abs(f.pattern_angle) - 360.0) < 1e-9;
                const double div = (f.pattern_inclusive && !full && n > 1) ? double(n - 1) : double(n);
                const double step = (f.pattern_angle * M_PI / 180.0) / div;
                trsf.SetRotation(ax, step * i);
            } else {
                const Vec3d& d = (f.pattern_dir == 1) ? f.plane.y_axis : f.plane.x_axis;
                trsf.SetTranslation(gp_Vec(d.x() * f.pattern_spacing * i,
                                           d.y() * f.pattern_spacing * i,
                                           d.z() * f.pattern_spacing * i));
            }
            TopoDS_Shape copy = BRepBuilderAPI_Transform(seed, trsf, true).Shape();
            BRepAlgoAPI_Fuse fuse(result, copy);
            if (!fuse.IsDone()) throw std::runtime_error(_u8L("pattern fuse failed"));
            result = fuse.Shape();
        }
        break;
    }
    case CadFeatureType::Rib: {
        if (!have_body) throw std::runtime_error(_u8L("rib needs a body"));
        if (f.rib_sketch_ref < 0 || f.rib_sketch_ref >= (int)features.size())
            throw std::runtime_error("rib: bad sketch ref");
        const CadFeature& sk = features[f.rib_sketch_ref];
        // Project counts as sketch-like here exactly as it does for Extrude, SurfaceExtrude
        // and SurfaceRevolve: it carries plane + Line entities, which is all a rib reads.
        // Ribbing along a projected body edge is otherwise unreachable.
        if (sk.type != CadFeatureType::Sketch && sk.type != CadFeatureType::Project)
            throw std::runtime_error("rib: ref is not a sketch");
        if (f.rib_entity < 0 || f.rib_entity >= (int)sk.entities.size())
            throw std::runtime_error("rib: bad entity");
        const SketchEntity& ln = sk.entities[f.rib_entity];
        if (ln.type != SketchEntity::Type::Line)
            throw std::runtime_error(_u8L("rib: entity must be a line")); // ponytail: line-only for now
        // Thin rectangle centred on the line, in the sketch plane: offset both endpoints by
        // +/-thickness/2 along the in-plane perpendicular of the line direction.
        const SketchPlane& pl = sk.plane;
        Vec2d a = ln.p0, b = ln.p1;
        Vec2d dir = (b - a); double L = dir.norm();
        if (L < 1e-9) throw std::runtime_error(_u8L("rib: degenerate line"));
        dir /= L;
        Vec2d perp(-dir.y(), dir.x());
        double h = f.rib_thickness * 0.5;
        Vec2d q0 = a + perp*h, q1 = b + perp*h, q2 = b - perp*h, q3 = a - perp*h;
        auto w3 = [&](const Vec2d& p){ Vec3d w = pl.to_world(p); return gp_Pnt(w.x(),w.y(),w.z()); };
        BRepBuilderAPI_MakePolygon poly(w3(q0), w3(q1), w3(q2), w3(q3), true);
        if (!poly.IsDone()) throw std::runtime_error(_u8L("rib: profile failed"));
        TopoDS_Shape wall = SketchEngine::make_extrude(poly.Wire(), pl, f.rib_depth, false, 0.0);
        if (wall.IsNull()) throw std::runtime_error(_u8L("rib: extrude failed"));
        BRepAlgoAPI_Fuse fuse(result, wall);
        if (!fuse.IsDone()) throw std::runtime_error(_u8L("rib: fuse failed"));
        result = fuse.Shape();
        break;
    }
    case CadFeatureType::Fillet:
        if (!have_body) throw std::runtime_error(_u8L("fillet needs a body"));
        if (f.dressup_edge >= 0 || !f.dressup_edges.empty())
            result = GeometryEngine::apply_fillet(result, f.dressup_size, f.dressup_edge_ids());
        else
            result = GeometryEngine::apply_fillet(result, f.dressup_size, f.face_group);
        break;
    case CadFeatureType::Chamfer:
        if (!have_body) throw std::runtime_error(_u8L("chamfer needs a body"));
        if (f.dressup_edge >= 0 || !f.dressup_edges.empty())
            result = GeometryEngine::apply_chamfer(result, f.dressup_size, f.dressup_edge_ids());
        else
            result = GeometryEngine::apply_chamfer(result, f.dressup_size, f.face_group);
        break;
    case CadFeatureType::Hole: {
        if (!have_body) throw std::runtime_error(_u8L("hole needs a body"));
        // Circle wire centered at the positioned point on the plane
        Vec3d c = f.plane.to_world(Vec2d(f.hole_x, f.hole_y));
        gp_Pnt o(c.x(), c.y(), c.z());
        gp_Dir n(f.plane.normal.x(), f.plane.normal.y(), f.plane.normal.z());
        gp_Circ circ(gp_Ax2(o, n), f.hole_diameter * 0.5);
        TopoDS_Edge e = BRepBuilderAPI_MakeEdge(circ).Edge();
        BRepBuilderAPI_MakeWire wm(e);
        if (!wm.IsDone()) throw std::runtime_error(_u8L("hole wire failed"));
        // Through = symmetric huge cut (passes fully through any body);
        // Blind = +normal extrude of hole_depth into the body.
        TopoDS_Shape tool = f.hole_through
            ? SketchEngine::make_extrude(wm.Wire(), f.plane, 1.0e5, true, 0.0)
            : SketchEngine::make_extrude(wm.Wire(), f.plane, f.hole_depth, false, 0.0);
        BRepAlgoAPI_Cut cut(result, tool);
        if (!cut.IsDone()) throw std::runtime_error(_u8L("hole cut failed"));
        result = cut.Shape();
 
        // Enlarge the entry for a screw head (style 1 = counterbore, 2 = countersink).
        if (f.hole_style == 1 && f.hole_cbore_diameter > f.hole_diameter
                              && f.hole_cbore_depth > 1e-6) {
            gp_Ax2 cbax(o, n);
            TopoDS_Shape cb = BRepPrimAPI_MakeCylinder(cbax, f.hole_cbore_diameter * 0.5,
                                                       f.hole_cbore_depth).Shape();
            BRepAlgoAPI_Cut cbc(result, cb);
            if (cbc.IsDone() && !cbc.Shape().IsNull()) result = cbc.Shape();
        } else if (f.hole_style == 2 && f.hole_csink_diameter > f.hole_diameter) {
            const double Rmaj = f.hole_csink_diameter * 0.5;
            const double Rmin = f.hole_diameter * 0.5;
            const double half = f.hole_csink_angle * 0.5 * M_PI / 180.0;
            const double h = (Rmaj - Rmin) / std::tan(half);
            if (h > 1e-6) {
                gp_Ax2 csax(o, n);
                TopoDS_Shape cs = BRepPrimAPI_MakeCone(csax, Rmaj, Rmin, h).Shape();
                BRepAlgoAPI_Cut csc(result, cs);
                if (csc.IsDone() && !csc.Shape().IsNull()) result = csc.Shape();
            }
        }
        break;
    }
    case CadFeatureType::Thread: {
        // Reject degenerate parameters that make OCCT's helical sweep / boolean unstable (a tiny
        // pitch, depth >= half-pitch, an enormous turn count, depth eating the whole wall), and
        // SAY which: a thread that quietly did nothing read, for an internal one, as "the tool
        // does not intersect the body", and for an external one as nothing at all.
        {
            const double R = f.thread_radius, P = f.thread_pitch, H = f.thread_height, D = f.thread_depth;
            // ISO external thread depth is ~0.61*P, so allow up to 0.7*P (0.49 wrongly rejected
            // every real thread -> nothing rendered). Still bound it well under a full pitch.
            // R >= 0.5 (not >): M1, the smallest size in the standards table, is exactly 0.5.
            const char* why = R < 0.5                   ? L("thread: the diameter must be at least 1 mm")
                            : P <= 0.1                  ? L("thread: the pitch must be more than 0.1 mm")
                            : (D <= 1e-3 || D >= 0.7 * P) ? L("thread: the depth must be between 0 and 0.7 x the pitch")
                            : D >= 0.45 * R             ? L("thread: the depth is too large for this diameter")
                            : H <= 0.5 * P              ? L("thread: the length must be more than half a pitch")
                            : H / P >= 400.0            ? L("thread: too many turns (length / pitch must stay under 400)")
                                                        : nullptr;
            // Legacy recipes keep their old outcome (the body left as it was) so a project that
            // opened before still opens; every thread made now reports the reason instead.
            if (why != nullptr) {
                if (f.thread_major_nominal) throw std::runtime_error(Slic3r::I18N::translate(why));
                break;
            }
        }
        // Axis at the positioned point on the plane; +normal = thread rise.
        Vec3d c3 = f.plane.to_world(Vec2d(f.thread_x, f.thread_y));
        gp_Pnt  c(c3.x(), c3.y(), c3.z());
        gp_Dir  zdir(f.plane.normal.x(), f.plane.normal.y(), f.plane.normal.z());
        gp_Dir  xdir(f.plane.x_axis.x(), f.plane.x_axis.y(), f.plane.x_axis.z());
        gp_Ax3  ax3(c, zdir, xdir);
        gp_Ax2  ax2(c, zdir, xdir);
        const double R = f.thread_radius, D = f.thread_depth;
        // Root the V CLEARLY inside the material (a real overlap, not a tangency) so the boolean
        // has clean intersections — near-coincident faces are what make OCCT's fuse/cut unstable.
        const double over = std::min(std::max(D, 0.25), R * 0.4);
 
        // Sweep a V profile along the helix (guarded — never fatal). `helix_r` is the radius the
        // helix runs at: the profile is placed relative to it.
        auto sweep = [&](double helix_r, const TopoDS_Wire& prof, TopoDS_Shape& out) {
            try {
                TopoDS_Wire spine = make_helix_wire(ax3, helix_r, f.thread_pitch, f.thread_height);
                // MakePipeShell with a FIXED BINORMAL = cylinder axis keeps the V-profile's
                // orientation constant along the helix (axial edge always parallel to the axis).
                // The plain MakePipe used a Frenet frame that TWISTED the profile around the helix.
                BRepOffsetAPI_MakePipeShell pipe(spine);
                pipe.SetMode(zdir);
                pipe.Add(prof);
                pipe.Build();
                if (pipe.IsDone() && pipe.MakeSolid()) out = pipe.Shape();
            } catch (const Standard_Failure&) {   // on OCCT >= 8 it derives from std::exception: first
            } catch (const std::exception&) {
            }
            return !out.IsNull();
        };
        auto cut_from = [](TopoDS_Shape& target, const TopoDS_Shape& tool) {
            BRepAlgoAPI_Cut cut(target, tool);
            if (cut.IsDone() && !cut.Shape().IsNull()) target = cut.Shape();
        };
 
        if (f.thread_major_nominal) {
            if (f.thread_internal) {
                // Tapped hole: bore to the minor radius R - D, then cut the groove out to the
                // major radius R. The bore sits 10 um inside the minor radius so that, threading
                // an existing tap-drill hole, it does not coincide with that hole's wall.
                if (!have_body) throw std::runtime_error(_u8L("internal thread needs a body"));
                const double bore_r = R - D - 0.01;
                cut_from(result, BRepPrimAPI_MakeCylinder(ax2, bore_r, f.thread_height).Shape());
                TopoDS_Shape groove;
                if (sweep(R, make_thread_v(c, xdir, zdir, R - D - over, R, f.thread_pitch), groove))
                    cut_from(result, groove);
            } else {
                // External thread: the crests are at R. A groove is cut INTO the rod down to
                // R - D; with no body yet, the rod is made first.
                if (!have_body || result.IsNull()) {
                    result    = BRepPrimAPI_MakeCylinder(ax2, R, f.thread_height).Shape();
                    have_body = true;
                }
                TopoDS_Shape groove;
                if (sweep(R, make_thread_v(c, xdir, zdir, R + over, R - D, f.thread_pitch), groove))
                    cut_from(result, groove);
            }
            break;
        }
 
        // ---- legacy recipes (thread_major_nominal == false): built exactly as they always were.
        TopoDS_Shape ridge;
        const bool have_ridge = sweep(R, make_thread_profile(c, xdir, zdir, f.thread_radius,
                                                             f.thread_pitch, f.thread_depth,
                                                             f.thread_internal), ridge);
        if (f.thread_internal) {
            if (!have_body) throw std::runtime_error(_u8L("internal thread needs a body"));
            // Tapped bore: cut a clean pocket at radius - depth, then carve the helical groove
            // outward into its wall.
            const double bore_r = std::max(0.5, f.thread_radius - f.thread_depth);
            TopoDS_Shape bore = BRepPrimAPI_MakeCylinder(ax2, bore_r, f.thread_height).Shape();
            try {
                BRepAlgoAPI_Cut cut_bore(result, bore);
                if (cut_bore.IsDone() && !cut_bore.Shape().IsNull())
                    result = cut_bore.Shape();
            } catch (const std::exception&) { /* keep existing bore */ }
            if (have_ridge) cut_from(result, ridge);
        } else {
            // External thread: FUSE the helical ridge onto the existing body, or onto a
            // standalone rod when there is none.
            if (have_body && !result.IsNull()) {
                if (have_ridge) {
                    BRepAlgoAPI_Fuse fuse(result, ridge);
                    if (fuse.IsDone() && !fuse.Shape().IsNull()) result = fuse.Shape();
                }
            } else {
                TopoDS_Shape rod = BRepPrimAPI_MakeCylinder(ax2, f.thread_radius,
                                                            f.thread_height).Shape();
                if (have_ridge) {
                    BRepAlgoAPI_Fuse fuse(rod, ridge);
                    if (fuse.IsDone()) rod = fuse.Shape();
                }
                result = rod;
                have_body = true;
            }
        }
        break;
    }
    case CadFeatureType::Shell: {
        if (!have_body) throw std::runtime_error(_u8L("shell needs a body"));
        // Hollow the body to a wall thickness; the picked face (if any) is removed so the
        // shell is open there. MakeThickSolidByJoin with a NEGATIVE offset shells inward.
        NCollection_List<TopoDS_Shape> remove;
        if (f.shell_face >= 0) {
            TopoDS_Face fc = GeometryEngine::face_by_index(result, f.shell_face);
            if (!fc.IsNull()) remove.Append(fc);
        }
        BRepOffsetAPI_MakeThickSolid mts;
        mts.MakeThickSolidByJoin(result, remove, -std::abs(f.shell_thickness), 1.0e-3);
        mts.Build();
        if (!mts.IsDone()) throw std::runtime_error(_u8L("shell failed"));
        result = mts.Shape();
        if (result.IsNull()) throw std::runtime_error(_u8L("shell produced no geometry"));
        break;
    }
    case CadFeatureType::Draft: {
        if (!have_body) throw std::runtime_error(_u8L("draft needs a body"));
        if (f.draft_face < 0) throw std::runtime_error(_u8L("draft needs a picked face"));
        TopoDS_Face fc = GeometryEngine::face_by_index(result, f.draft_face);
        if (fc.IsNull()) throw std::runtime_error(_u8L("draft: face not found"));
        // Neutral plane = horizontal plane through the body's bbox bottom, pull direction +Z.
        // The face pivots about the line where it meets the neutral plane and tilts by the angle.
        // ponytail: neutral plane / pull direction fixed to world up; pick-based neutral plane
        // deferred (same as the datum-plane pick types, dgv).
        Bnd_Box bb; BRepBndLib::Add(result, bb);
        double xmin, ymin, zmin, xmax, ymax, zmax;
        bb.Get(xmin, ymin, zmin, xmax, ymax, zmax);
        gp_Dir pull(0, 0, 1);
        gp_Pln neutral(gp_Pnt(0, 0, zmin), pull);
        BRepOffsetAPI_DraftAngle draft(result);
        draft.Add(fc, pull, f.draft_angle * M_PI / 180.0, neutral);
        if (!draft.AddDone())
            throw std::runtime_error(_u8L("draft: face cannot be drafted (is it parallel to the base?)"));
        draft.Build();
        if (!draft.IsDone()) throw std::runtime_error(_u8L("draft failed"));
        result = draft.Shape();
        if (result.IsNull()) throw std::runtime_error(_u8L("draft produced no geometry"));
        break;
    }
    case CadFeatureType::DeleteFace: {
        if (!have_body) throw std::runtime_error(_u8L("delete_face needs a body"));
        if (f.delete_faces.empty()) throw std::runtime_error(_u8L("delete_face needs at least one face"));
        BRepAlgoAPI_Defeaturing df;
        df.SetShape(result);
        for (int fi : f.delete_faces) {
            TopoDS_Face fc = GeometryEngine::face_by_index(result, fi);
            if (fc.IsNull()) throw std::runtime_error(_u8L("delete_face: face not found"));
            df.AddFaceToRemove(fc);
        }
        df.Build();
        if (!df.IsDone()) throw std::runtime_error(_u8L("delete_face failed"));
        result = df.Shape();
        if (result.IsNull()) throw std::runtime_error(_u8L("delete_face produced no geometry"));
        break;
    }
    }
}

References _u8L, Slic3r::Add, Slic3r::GeometryEngine::apply_chamfer(), Slic3r::GeometryEngine::apply_fillet(), Slic3r::Blind, Slic3r::Boolean, build_sketch_face(), build_sketch_wire(), Slic3r::Chamfer, Slic3r::Cut, Slic3r::DeleteFace, Slic3r::dot(), Slic3r::Draft, Slic3r::CadFeature::entities, Slic3r::Extrude, Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), Slic3r::GeometryEngine::face_centroid_world(), features, Slic3r::Fillet, Slic3r::format(), Slic3r::SketchPlane::from_face(), Slic3r::Helix, Slic3r::Hole, Slic3r::Import, Slic3r::CadFeature::import_offset, Slic3r::CadFeature::import_scale_x, Slic3r::CadFeature::import_scale_y, Slic3r::CadFeature::imported_regions, Slic3r::Intersect, L, Slic3r::SketchEntity::Line, Slic3r::Loft, M_PI, Slic3r::SketchEngine::make_extrude(), Slic3r::SketchEngine::make_extrude_face(), Slic3r::SketchEngine::make_extrude_regions(), Slic3r::SketchEngine::make_extrude_taper(), Slic3r::SketchEngine::make_extrude_two_sided(), Slic3r::make_helix_spine(), Slic3r::make_helix_wire(), Slic3r::SketchEngine::make_loft(), Slic3r::SketchEngine::make_loft_surface(), Slic3r::SketchEngine::make_prism(), Slic3r::SketchEngine::make_revolve(), Slic3r::SketchEngine::make_sweep(), Slic3r::make_thread_profile(), Slic3r::make_thread_v(), Slic3r::New, Slic3r::SketchPlane::normal, Slic3r::SketchPlane::origin, Slic3r::P, Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::Pattern, Slic3r::perp(), Slic3r::CadFeature::plane, Slic3r::Project, Slic3r::pull, Slic3r::Revolve, Slic3r::revolve_axis_of(), Slic3r::Rib, Slic3r::sample_entity_2d(), Slic3r::Shell, Slic3r::Sketch, Slic3r::SurfaceExtrude, Slic3r::SurfaceFill, Slic3r::SurfaceLoft, Slic3r::SurfaceRevolve, Slic3r::Sweep, Slic3r::Symmetric, Slic3r::Thread, Slic3r::ThroughAll, Slic3r::SketchPlane::to_world(), Slic3r::transform_regions(), Slic3r::I18N::translate(), Slic3r::TwoSided, Slic3r::CadFeature::type, Slic3r::SketchEntity::type, Slic3r::UpToFace, and Slic3r::UpToVertex.

Referenced by route_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_mate()

void Slic3r::CadDocument::apply_mate ( std::vector< CadBody > & bodies, const CadFeature & f ) const

private

{
    const int nc = int(features.size());
    if (f.mate_cs_a < 0 || f.mate_cs_a >= nc)
        throw std::runtime_error("mate: mate_cs_a out of range");
    if (f.mate_cs_b < 0 || f.mate_cs_b >= nc)
        throw std::runtime_error("mate: mate_cs_b out of range");
 
    const CadFeature& fa = features[f.mate_cs_a];
    const CadFeature& fb = features[f.mate_cs_b];
    if (fa.type != CadFeatureType::CoordSys || !fa.enabled)
        throw std::runtime_error("mate: mate_cs_a is not a valid CoordSys feature");
    if (fb.type != CadFeatureType::CoordSys || !fb.enabled)
        throw std::runtime_error("mate: mate_cs_b is not a valid CoordSys feature");
 
    CadDocument::DatumCoordSys A = datum_frame(bodies, fa);
    CadDocument::DatumCoordSys B = datum_frame(bodies, fb);
    if (!A.error.empty()) throw std::runtime_error(format(_u8L("mate: %1%"), A.error));
    if (!B.error.empty()) throw std::runtime_error(format(_u8L("mate: %1%"), B.error));
 
    const int tgt_body = fb.coordsys_body;
    if (tgt_body < 0)
        throw std::runtime_error("mate: mate_cs_b has no associated body");
    if (tgt_body >= int(bodies.size()) || bodies[tgt_body].shape.IsNull())
        throw std::runtime_error("mate: target body out of range or null");
 
    Vec3d xA(A.x), yA(A.y), oA(A.origin);
    Vec3d zA = xA.cross(yA).normalized();
    Vec3d xB(B.x), yB(B.y), oB(B.origin);
    Vec3d zB = xB.cross(yB).normalized();
 
    auto make_4x4 = [&](const Vec3d& x, const Vec3d& y, const Vec3d& z, const Vec3d& o) {
        gp_Trsf T;
        T.SetValues(x.x(), y.x(), z.x(), o.x(),
                    x.y(), y.y(), z.y(), o.y(),
                    x.z(), y.z(), z.z(), o.z());
        return T;
    };
    gp_Trsf M_A = make_4x4(xA, yA, zA, oA);
    gp_Trsf M_B = make_4x4(xB, yB, zB, oB);
 
    gp_Trsf F;
    if (f.mate_flip) {
        // Rx(pi): flip y→-y, z→-z
        F.SetValues(1,  0,  0, 0,
                    0, -1,  0, 0,
                    0,  0, -1, 0);
    }
 
    if (f.mate_kind < 0 || f.mate_kind > 4)
        throw std::runtime_error("mate: unknown mate type " + std::to_string(f.mate_kind));
    gp_Trsf T;
    if (f.mate_kind == 0) {
        // Fastened: T = M_A * Rz(mate_angle) * Tz(mate_offset) * F * M_B^-1
        gp_Trsf Rz;
        Rz.SetRotation(gp_Ax1(gp_Pnt(0,0,0), gp_Dir(0,0,1)), f.mate_angle * M_PI / 180.0);
        gp_Trsf Tz;
        Tz.SetTranslation(gp_Vec(0, 0, f.mate_offset));
        gp_Trsf M_B_inv = M_B.Inverted();
        T = M_A * Rz * Tz * F * M_B_inv;
    } else {
        Vec3d z_target = f.mate_flip ? -zA : zA;
 
        // Minimum-rotation helper: compute R that rotates zB onto z_target
        // about an axis through oB. Reused by Planar / Revolute / Cylindrical.
        auto make_z_align = [&](const Vec3d& zsrc, const Vec3d& zdst) -> gp_Trsf {
            double ddot = zsrc.dot(zdst);
            Vec3d rot_axis;
            double rot_angle = 0;
            if (ddot <= -0.9999) {
                Vec3d ref = (std::abs(zsrc.z()) < 0.9) ? Vec3d(0, 0, 1) : Vec3d(1, 0, 0);
                rot_axis = zsrc.cross(ref).normalized();
                rot_angle = M_PI;
            } else {
                rot_axis = zsrc.cross(zdst);
                if (rot_axis.squaredNorm() > 1e-18) {
                    rot_axis.normalize();
                    rot_angle = std::acos(std::max(-1.0, std::min(1.0, ddot)));
                }
            }
            gp_Trsf R;
            if (rot_angle > 1e-12) {
                R.SetRotation(gp_Ax1(gp_Pnt(oB.x(), oB.y(), oB.z()),
                                     gp_Dir(rot_axis.x(), rot_axis.y(), rot_axis.z())),
                              rot_angle);
            }
            return R;
        };
 
        if (f.mate_kind == 1 || f.mate_kind == 2 || f.mate_kind == 4) {
            // Planar (1) / Revolute (2) / Cylindrical (4):
            // all share the same minimum-rotation z-alignment.
            gp_Trsf R_align = make_z_align(zB, z_target);
 
            gp_Trsf Rz_about_target;
            if (std::abs(f.mate_angle) > 1e-12) {
                Rz_about_target.SetRotation(
                    gp_Ax1(gp_Pnt(oB.x(), oB.y(), oB.z()),
                           gp_Dir(z_target.x(), z_target.y(), z_target.z())),
                    f.mate_angle * M_PI / 180.0);
            }
            gp_Trsf R = Rz_about_target * R_align;
 
            // Translation: depends on which DOFs are constrained
            Vec3d trans;
            if (f.mate_kind == 1) {
                // Planar: normal distance becomes mate_offset
                double d = (oB - oA).dot(zA);
                trans = zA * (f.mate_offset - d);
            } else if (f.mate_kind == 2) {
                // Revolute: full position on the axis line
                trans = (oA + zA * f.mate_offset) - oB;
            } else {
                // Cylindrical (4): fix perpendicular, preserve axial
                double axial = (oB - oA).dot(zA);
                trans = (oA + zA * (axial + f.mate_offset)) - oB;
            }
 
            T.SetValues(1, 0, 0, trans.x(),
                        0, 1, 0, trans.y(),
                        0, 0, 1, trans.z());
            T = T * R;
        } else {
            // Slider (mate_kind == 3): full orientation alignment,
            // fix perpendicular position, preserve axial translation.
            Vec3d x_target = xA;
            Vec3d y_target = f.mate_flip ? -yA : yA;
 
            // R = target * B^T  (both bases orthonormal)
            double r11 = x_target.x() * xB.x() + y_target.x() * yB.x() + z_target.x() * zB.x();
            double r12 = x_target.x() * xB.y() + y_target.x() * yB.y() + z_target.x() * zB.y();
            double r13 = x_target.x() * xB.z() + y_target.x() * yB.z() + z_target.x() * zB.z();
            double r21 = x_target.y() * xB.x() + y_target.y() * yB.x() + z_target.y() * zB.x();
            double r22 = x_target.y() * xB.y() + y_target.y() * yB.y() + z_target.y() * zB.y();
            double r23 = x_target.y() * xB.z() + y_target.y() * yB.z() + z_target.y() * zB.z();
            double r31 = x_target.z() * xB.x() + y_target.z() * yB.x() + z_target.z() * zB.x();
            double r32 = x_target.z() * xB.y() + y_target.z() * yB.y() + z_target.z() * zB.y();
            double r33 = x_target.z() * xB.z() + y_target.z() * yB.z() + z_target.z() * zB.z();
 
            // Build rotation about oB: R_full * p = R * (p - oB) + oB
            double tx = oB.x() - (r11 * oB.x() + r12 * oB.y() + r13 * oB.z());
            double ty = oB.y() - (r21 * oB.x() + r22 * oB.y() + r23 * oB.z());
            double tz = oB.z() - (r31 * oB.x() + r32 * oB.y() + r33 * oB.z());
            gp_Trsf R_full;
            R_full.SetValues(r11, r12, r13, tx,
                             r21, r22, r23, ty,
                             r31, r32, r33, tz);
 
            double axial = (oB - oA).dot(zA);
            Vec3d trans = (oA + zA * (axial + f.mate_offset)) - oB;
 
            T.SetValues(1, 0, 0, trans.x(),
                        0, 1, 0, trans.y(),
                        0, 0, 1, trans.z());
            T = T * R_full;
        }
    }
 
    BRepBuilderAPI_Transform xform(bodies[tgt_body].shape, T, true /*copy*/);
    if (!xform.IsDone()) throw std::runtime_error(_u8L("mate: transform failed"));
    bodies[tgt_body].shape = xform.Shape();
}

References _u8L, bodies, Slic3r::CoordSys, Slic3r::CadFeature::coordsys_body, datum_frame(), Slic3r::dot(), Slic3r::CadFeature::enabled, Slic3r::CadDocument::DatumCoordSys::error, Slic3r::F, Slic3r::f(), features, Slic3r::format(), M_PI, Slic3r::CadDocument::DatumCoordSys::origin, Slic3r::CadFeature::type, Slic3r::CadDocument::DatumCoordSys::x, and Slic3r::CadDocument::DatumCoordSys::y.

Referenced by route_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_mirror()

void Slic3r::CadDocument::apply_mirror ( std::vector< CadBody > & bodies, const CadFeature & f ) const

private

{
    const int nb  = int(bodies.size());
    if (nb == 0) throw std::runtime_error(_u8L("mirror: no target body"));
    const int tgt = pick_body(f.target_body, nb);
    if (tgt < 0 || bodies[tgt].shape.IsNull()) throw std::runtime_error(_u8L("mirror: no target body"));
 
    const TopoDS_Shape& src = bodies[tgt].shape;
 
    gp_Trsf trsf;
    trsf.SetMirror(gp_Ax2(gp_Pnt(f.plane.origin.x(), f.plane.origin.y(), f.plane.origin.z()),
                          gp_Dir(f.plane.normal.x(), f.plane.normal.y(), f.plane.normal.z())));
    BRepBuilderAPI_Transform xform(src, trsf, true /*copy*/);
    if (!xform.IsDone()) throw std::runtime_error(_u8L("mirror: transform failed"));
    TopoDS_Shape mirrored = xform.Shape();
 
    // A mirror reverses orientation — verify the result has positive volume.
    {
        GProp_GProps props;
        BRepGProp::VolumeProperties(mirrored, props);
        if (props.Mass() <= 0.0) {
            // Flip orientation to get a valid forward solid.
            mirrored.Reverse();
            BRepGProp::VolumeProperties(mirrored, props);
            if (props.Mass() <= 0.0)
                throw std::runtime_error(_u8L("mirror: result has zero or negative volume"));
        }
    }
 
    switch (f.mode) {
    case BooleanMode::Add: {
        BRepAlgoAPI_Fuse fuse(src, mirrored);
        if (!fuse.IsDone()) throw std::runtime_error(_u8L("mirror fuse failed"));
        bodies[tgt].shape = fuse.Shape();
        break;
    }
    case BooleanMode::New: {
        if (!f.mirror_keep_original)
            bodies.erase(bodies.begin() + tgt);   // replace: the mirrored copy takes the source slot
        bodies.push_back({mirrored, f.name.empty() ? _u8L("Mirror") : f.name});
        break;
    }
    default:
        throw std::runtime_error("mirror: mode must be New or Add");
    }
}

References _u8L, Slic3r::Add, bodies, Slic3r::f(), Slic3r::New, and Slic3r::pick_body().

Referenced by route_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_project()

void Slic3r::CadDocument::apply_project ( const std::vector< CadBody > & bodies, CadFeature & f ) const

private

{
    f.entities.clear();
    const int nb = int(bodies.size());
    if (nb == 0) throw std::runtime_error(_u8L("project: no source body"));
    const int src = pick_body(f.project_source_body, nb);
    if (src < 0 || bodies[src].shape.IsNull()) throw std::runtime_error(_u8L("project: source body is empty"));
    const TopoDS_Shape& shape = bodies[src].shape;
 
    std::vector<TopoDS_Edge> edges;
    if (!f.project_edges.empty()) {
        for (int id : f.project_edges) {
            TopoDS_Edge e = GeometryEngine::edge_by_index(shape, id);
            if (e.IsNull()) throw std::runtime_error(_u8L("project: edge not found"));
            edges.push_back(e);
        }
    } else if (f.project_face >= 0) {
        TopoDS_Face fc = GeometryEngine::face_by_index(shape, f.project_face);
        if (fc.IsNull()) throw std::runtime_error(_u8L("project: face not found"));
        edges = GeometryEngine::edges_of_face(fc);
    } else {
        // No face and no explicit selection means "all edges" — the state the Project card
        // starts in, and its label says so. Edges perpendicular to the target plane collapse
        // to a point when projected; they are dropped below rather than emitted as
        // zero-length lines.
        edges = GeometryEngine::edges_of(shape);
    }
    if (edges.empty()) throw std::runtime_error(_u8L("project: no edges to project"));
 
    project_edges_to_entities(edges, f.plane, /*construction=*/false, f.entities);
 
    if (f.entities.empty()) throw std::runtime_error(_u8L("project: produced no entities"));
}

References _u8L, bodies, Slic3r::GeometryEngine::edge_by_index(), Slic3r::GeometryEngine::edges_of(), Slic3r::GeometryEngine::edges_of_face(), Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), Slic3r::pick_body(), and Slic3r::project_edges_to_entities().

Referenced by replay_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_surface_offset()

void Slic3r::CadDocument::apply_surface_offset ( std::vector< CadBody > & bodies, const CadFeature & f ) const

private

{
    const int nb = int(bodies.size());
    if (nb == 0) throw std::runtime_error(_u8L("surface-offset: no target body"));
    const int tgt = pick_body(f.target_body, nb);
    if (tgt < 0 || bodies[tgt].shape.IsNull()) throw std::runtime_error(_u8L("surface-offset: no target body"));
    if (!is_sheet_shape(bodies[tgt].shape)) throw std::runtime_error(_u8L("surface-offset: target is not a sheet body"));
    const double d = f.plane_offset;
    if (std::abs(d) < 1e-9) throw std::runtime_error(_u8L("surface-offset: zero offset"));
 
    BRepOffsetAPI_MakeOffsetShape mos;
    mos.PerformBySimple(bodies[tgt].shape, d);
    if (!mos.IsDone()) throw std::runtime_error(_u8L("surface-offset: failed"));
    TopoDS_Shape off_shape = mos.Shape();
    if (off_shape.IsNull()) throw std::runtime_error(_u8L("surface-offset: produced no geometry"));
 
    bodies.push_back({off_shape, f.name.empty() ? _u8L("Surface Offset") : f.name});
}

References _u8L, bodies, Slic3r::f(), is_sheet_shape(), and Slic3r::pick_body().

Referenced by route_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_thicken()

void Slic3r::CadDocument::apply_thicken ( std::vector< CadBody > & bodies, const CadFeature & f ) const

private

{
    const int nb = int(bodies.size());
    if (nb == 0) throw std::runtime_error(_u8L("thicken: no target body"));
    const int tgt = pick_body(f.target_body, nb);
    if (tgt < 0 || bodies[tgt].shape.IsNull()) throw std::runtime_error(_u8L("thicken: no target body"));
 
    TopoDS_Face fc = GeometryEngine::face_by_index(bodies[tgt].shape, f.thicken_face);
    if (fc.IsNull()) throw std::runtime_error(_u8L("thicken: face not found"));
    if (std::abs(f.thicken_thickness) < 1e-9) throw std::runtime_error(_u8L("thicken: thickness is zero"));
 
    TopoDS_Shell shell;
    BRep_Builder bb;
    bb.MakeShell(shell);
    bb.Add(shell, fc);
 
    const double off = f.thicken_flip ? -std::abs(f.thicken_thickness)
                                      :  std::abs(f.thicken_thickness);
    BRepOffsetAPI_MakeThickSolid mts;
    mts.MakeThickSolidBySimple(shell, off);
    mts.Build();
    if (!mts.IsDone()) throw std::runtime_error(_u8L("thicken: failed"));
    TopoDS_Shape solid = mts.Shape();
    if (solid.IsNull()) throw std::runtime_error(_u8L("thicken: produced no geometry"));
 
    // MakeThickSolidBySimple may produce a reversed solid. Ensure positive volume.
    {
        GProp_GProps props;
        BRepGProp::VolumeProperties(solid, props);
        if (props.Mass() < 0.0) solid.Reverse();
    }
 
    bodies.push_back({solid, f.name.empty() ? _u8L("Thicken") : f.name});
}

References _u8L, bodies, Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), and Slic3r::pick_body().

Referenced by route_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_thicken_surface()

void Slic3r::CadDocument::apply_thicken_surface ( std::vector< CadBody > & bodies, const CadFeature & f ) const

private

{
    const int nb = int(bodies.size());
    if (nb == 0) throw std::runtime_error(_u8L("thicken-surface: no target body"));
    const int tgt = pick_body(f.target_body, nb);
    if (tgt < 0 || bodies[tgt].shape.IsNull()) throw std::runtime_error(_u8L("thicken-surface: no target body"));
    if (!is_sheet_shape(bodies[tgt].shape)) throw std::runtime_error(_u8L("thicken-surface: target is not a sheet body"));
    if (std::abs(f.thicken_thickness) < 1e-9) throw std::runtime_error(_u8L("thicken-surface: thickness is zero"));
 
    const double off = f.thicken_flip ? -std::abs(f.thicken_thickness)
                                      :  std::abs(f.thicken_thickness);
    const TopoDS_Shape& sheet = bodies[tgt].shape;
 
    // MakeThickSolidBySimple offsets each face along its own normal and sews the result; it never
    // extends neighbours to meet, so at every edge where two faces join at an angle the corner
    // material is simply absent. A flat sheet is therefore exact while a 4-walled box is not
    // (measured: 29648 against the 44000 that (60^2-50^2)*40 requires).
    //
    // ByJoin is the call that mitres those corners, and it is what the Shell feature already uses
    // successfully a few hundred lines up — but it CANNOT be handed an open sheet. In OCCT,
    // BRepOffset_MakeOffset::MakeThickSolid builds the solid only inside `if (!myFaces.IsEmpty())`
    // (BRepOffset_MakeOffset.cxx:1115): with no closing faces it stops after the offset shell and
    // returns that. So it reports IsDone() and a non-null shape containing no TopAbs_SOLID at all
    // — which is exactly how two earlier attempts failed, and why no parameter could have fixed it.
    //
    // So close the sheet first, then use the working call: cap the free rims, sew into a closed
    // shell, make a solid, and hollow it inward passing the caps as the faces to remove. The caps
    // come back off, leaving the wall.
    // A SINGLE face has no edge shared with a neighbour, so there is no corner to mitre and
    // BySimple is already exact on it (flat 60x60 by 5 -> 18000.000). It also has a free
    // boundary, so "does it have free wires" is NOT the question to ask here — capping a lone
    // face with its own rim sews a zero-thickness shell and the offset then measures 6000.
    int n_faces = 0;
    for (TopExp_Explorer fe(sheet, TopAbs_FACE); fe.More(); fe.Next()) ++n_faces;
 
    NCollection_List<TopoDS_Shape> caps;
    if (n_faces > 1) {
        ShapeAnalysis_FreeBounds fb(sheet);
        for (TopExp_Explorer we(fb.GetClosedWires(), TopAbs_WIRE); we.More(); we.Next()) {
            BRepBuilderAPI_MakeFace mk(TopoDS::Wire(we.Current()));
            if (!mk.IsDone())
                throw std::runtime_error(_u8L("thicken-surface: cannot cap the sheet rim "
                                              "(is it planar?)"));
            caps.Append(mk.Face());
        }
    }
 
    TopoDS_Shape solid;
    if (caps.IsEmpty()) {
        BRepOffsetAPI_MakeThickSolid mts;
        mts.MakeThickSolidBySimple(sheet, off);
        mts.Build();
        if (!mts.IsDone()) throw std::runtime_error(_u8L("thicken-surface: failed"));
        solid = mts.Shape();
    } else {
        BRepBuilderAPI_Sewing sewer(1.0e-3);
        sewer.Add(sheet);
        for (NCollection_List<TopoDS_Shape>::Iterator it(caps); it.More(); it.Next())
            sewer.Add(it.Value());
        sewer.Perform();
 
        TopoDS_Shell closed_shell;
        for (TopExp_Explorer se(sewer.SewedShape(), TopAbs_SHELL); se.More(); se.Next()) {
            if (!closed_shell.IsNull())
                throw std::runtime_error(_u8L("thicken-surface: the capped sheet split into "
                                              "more than one shell"));
            closed_shell = TopoDS::Shell(se.Current());
        }
        if (closed_shell.IsNull() || !BRep_Tool::IsClosed(closed_shell))
            throw std::runtime_error(_u8L("thicken-surface: the capped sheet is not closed"));
 
        // A shell sewn from an extruded sheet carries no guarantee that its faces point outward,
        // and BRepBuilderAPI_MakeSolid does not fix that. Offsetting an inside-out solid sends the
        // wall the wrong way: measured bbox 70x70x40 for an inward offset on a 60x60 box, with a
        // volume larger than its own bounding box because the result then overlaps itself. A
        // negative mass IS the inverted orientation, so use it as the test.
        TopoDS_Solid capped = BRepBuilderAPI_MakeSolid(closed_shell).Solid();
        {
            GProp_GProps vp;
            BRepGProp::VolumeProperties(capped, vp);
            if (vp.Mass() < 0.0) capped.Reverse();
        }
 
        BRepOffsetAPI_MakeThickSolid mts;
        mts.MakeThickSolidByJoin(capped, caps, -std::abs(off), 1.0e-3);
        mts.Build();
        if (!mts.IsDone()) throw std::runtime_error(_u8L("thicken-surface: failed"));
        solid = mts.Shape();
    }
    if (solid.IsNull()) throw std::runtime_error(_u8L("thicken-surface: produced no geometry"));
    // IsDone() is NOT a success test here — the failed attempts had IsDone() true and no solid.
    if (!TopExp_Explorer(solid, TopAbs_SOLID).More())
        throw std::runtime_error(_u8L("thicken-surface: produced a shell, not a solid"));
 
    {
        GProp_GProps props;
        BRepGProp::VolumeProperties(solid, props);
        if (props.Mass() < 0.0) solid.Reverse();
    }
 
    bodies.push_back({solid, f.name.empty() ? _u8L("Thicken Surface") : f.name});
}

References _u8L, bodies, Slic3r::f(), is_sheet_shape(), and Slic3r::pick_body().

Referenced by route_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_transform()

void Slic3r::CadDocument::apply_transform ( std::vector< CadBody > & bodies, const CadFeature & f ) const

private

{
    const int nb  = int(bodies.size());
    if (nb == 0) throw std::runtime_error(_u8L("transform: no target body"));
    const int tgt = pick_body(f.target_body, nb);
    if (tgt < 0 || bodies[tgt].shape.IsNull()) throw std::runtime_error(_u8L("transform: no target body"));
 
    gp_Trsf rot;
    if (std::abs(f.xf_angle_deg) > 1e-12) {
        if (f.xf_axis.norm() < 1e-9)
            throw std::runtime_error(_u8L("transform: rotation axis is degenerate"));
        rot.SetRotation(gp_Ax1(gp_Pnt(f.xf_pivot.x(), f.xf_pivot.y(), f.xf_pivot.z()),
                               gp_Dir(f.xf_axis.x(), f.xf_axis.y(), f.xf_axis.z())),
                        f.xf_angle_deg * M_PI / 180.0);
    }
    gp_Trsf tr;
    tr.SetTranslation(gp_Vec(f.xf_translate.x(), f.xf_translate.y(), f.xf_translate.z()));
    const gp_Trsf trsf = tr * rot;          // rotate first, then translate
 
    BRepBuilderAPI_Transform xform(bodies[tgt].shape, trsf, true /*copy*/);
    if (!xform.IsDone()) throw std::runtime_error(_u8L("transform: failed"));
    TopoDS_Shape moved = xform.Shape();
 
    if (f.xf_copy)
        bodies.push_back({moved, f.name.empty() ? _u8L("Transform") : f.name});
    else
        bodies[tgt].shape = moved;
}

References _u8L, bodies, Slic3r::f(), M_PI, and Slic3r::pick_body().

Referenced by route_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

bind_expressions()

void Slic3r::CadDocument::bind_expressions ( )

private

{
    std::map<std::string, double> varvals = evaluate_variables(variables);
    for (CadFeature& f : features)
        for (const auto& [field, e] : f.expr)
            assign_field(f, field, eval_expr(e, varvals));
}

References Slic3r::assign_field(), Slic3r::eval_expr(), Slic3r::evaluate_variables(), Slic3r::f(), features, and variables.

Referenced by faces_made_by(), and recompute().

Here is the call graph for this function:

Here is the caller graph for this function:

body_mass_properties()

GeometryEngine::MassProps Slic3r::CadDocument::body_mass_properties

(

int

body_index

)

const

{
    if (body_index < 0 || body_index >= int(bodies.size())) return {};
    return GeometryEngine::mass_properties(bodies[body_index].shape);
}

References bodies, and Slic3r::GeometryEngine::mass_properties().

Here is the call graph for this function:

body_touching_sketch()

int Slic3r::CadDocument::body_touching_sketch

(

int

sketch_ref

)

const

{
    if (sketch_ref < 0 || sketch_ref >= int(features.size())
        || features[sketch_ref].type != CadFeatureType::Sketch)
        return -1;
    // A query that only picks a default: any failure answers "touches nothing".
    try {
        const TopoDS_Face face = build_sketch_face(features[sketch_ref]);
        if (face.IsNull()) return -1;
        for (int i = int(bodies.size()) - 1; i >= 0; --i) {   // newest first: the likeliest target
            const TopoDS_Shape& b = bodies[i].shape;
            if (b.IsNull() || is_sheet_shape(b)) continue;
            BRepExtrema_DistShapeShape d(face, b);
            if (d.IsDone() && d.Value() <= 1e-4)
                return i;
        }
    } catch (const Standard_Failure&) {   // before std::exception: on OCCT >= 8 it derives from it
    } catch (const std::exception&) {
    }
    return -1;
}

References bodies, build_sketch_face(), features, is_sheet_shape(), and Slic3r::Sketch.

Here is the call graph for this function:

build_helix_wire()

TopoDS_Wire Slic3r::CadDocument::build_helix_wire	(	const CadFeature &	f,
		std::string &	err ) const

{
    return make_helix_spine(f, err);
}

References Slic3r::f(), and Slic3r::make_helix_spine().

Here is the call graph for this function:

build_sketch_face()

TopoDS_Face Slic3r::CadDocument::build_sketch_face ( const CadFeature & sketch ) const

private

{
    if (!sketch.entities.empty()) {
        const std::vector<TopoDS_Wire> loops = SketchEngine::entities_to_wires(sketch.entities, sketch.plane, true);
        if (loops.empty())
            // Same courtesy as build_sketch_wire: name WHERE the sketch is open. Extrude
            // reaches its failure through here, not through build_sketch_wire, so without
            // this the most common way to hit an open profile is also the least informative.
            throw std::runtime_error(open_loop_message(sketch));
        return SketchEngine::wires_to_face(loops, sketch.plane);
    }
    return BRepBuilderAPI_MakeFace(build_sketch_wire(sketch, true)).Face();
}

References build_sketch_wire(), Slic3r::CadFeature::entities, Slic3r::SketchEngine::entities_to_wires(), Slic3r::open_loop_message(), Slic3r::CadFeature::plane, and Slic3r::SketchEngine::wires_to_face().

Referenced by apply_feature(), and body_touching_sketch().

Here is the call graph for this function:

Here is the caller graph for this function:

build_sketch_wire()

TopoDS_Wire Slic3r::CadDocument::build_sketch_wire ( const CadFeature & sketch, bool closed_only = false ) const

private

{
    if (!sketch.entities.empty()) {
        TopoDS_Wire w = SketchEngine::entities_to_wire(sketch.entities, sketch.plane, closed_only);
        if (!w.IsNull()) return w;
        // An entity sketch that yields no wire is an ERROR, not a cue to fall through. The
        // legacy tail of this function ends in a default rectangle built from width/height,
        // which for an entity sketch are whatever they happened to be initialised to — so a
        // sketch entities_to_wire cannot handle (a circle coexisting with a line, two circles:
        // 88v) used to extrude into a box the user never drew, silently. Failing here
        // costs the caller an error message; falling through cost them wrong geometry that
        // looked deliberate. The legacy profile/shape paths below are still reached by sketches
        // that legitimately carry no entities at all.
        throw std::runtime_error(
            open_loop_message(sketch,
                _u8L("sketch has entities but they do not form a single closed wire — a closed "
                     "entity (circle/ellipse) combined with other entities, or several closed "
                     "entities, is not supported yet")));
    }
    if (!sketch.profile.points.empty()) {
        SketchProfile prof = sketch.profile;
        prof.closed = true;               // extrude needs a closed wire
        TopoDS_Wire w = prof.to_occt_wire(sketch.plane);
        if (w.IsNull()) throw std::runtime_error(_u8L("sketch profile wire failed"));
        return w;
    }
    if (sketch.shape == SketchShape::Circle) {
        gp_Pnt o(sketch.plane.origin.x(), sketch.plane.origin.y(), sketch.plane.origin.z());
        gp_Dir n(sketch.plane.normal.x(), sketch.plane.normal.y(), sketch.plane.normal.z());
        gp_Circ circ(gp_Ax2(o, n), sketch.radius);
        TopoDS_Edge e = BRepBuilderAPI_MakeEdge(circ).Edge();
        BRepBuilderAPI_MakeWire wm(e);
        if (!wm.IsDone()) throw std::runtime_error(_u8L("circle wire failed"));
        return wm.Wire();
    }
    // Rectangle centered on the plane origin
    SketchProfile prof;
    double hw = sketch.width * 0.5, hh = sketch.height * 0.5;
    prof.points.push_back(Vec2d(-hw, -hh));
    prof.points.push_back(Vec2d( hw, -hh));
    prof.points.push_back(Vec2d( hw,  hh));
    prof.points.push_back(Vec2d(-hw,  hh));
    prof.closed = true;
    return prof.to_occt_wire(sketch.plane);
}

References _u8L, Slic3r::Circle, Slic3r::SketchProfile::closed, Slic3r::CadFeature::entities, Slic3r::SketchEngine::entities_to_wire(), Slic3r::CadFeature::height, Slic3r::SketchPlane::normal, Slic3r::open_loop_message(), Slic3r::SketchPlane::origin, Slic3r::CadFeature::plane, Slic3r::SketchProfile::points, Slic3r::CadFeature::profile, Slic3r::CadFeature::radius, Slic3r::CadFeature::shape, Slic3r::SketchProfile::to_occt_wire(), and Slic3r::CadFeature::width.

Referenced by apply_feature(), and build_sketch_face().

Here is the call graph for this function:

Here is the caller graph for this function:

can_redo()

bool Slic3r::CadDocument::can_redo ( ) const

inline

{ return !m_redo.empty(); }

References m_redo.

can_undo()

bool Slic3r::CadDocument::can_undo ( ) const

inline

{ return !m_undo.empty(); }

References m_undo.

check_interference()

std::vector< CadDocument::Interference > Slic3r::CadDocument::check_interference

(

double

min_volume = 1e-6

)

const

{
    std::vector<Interference> out;
    const int n = int(bodies.size());
 
    for (int i = 0; i < n; ++i) {
        if (bodies[i].shape.IsNull() || is_sheet_shape(bodies[i].shape)) continue;
        for (int j = i + 1; j < n; ++j) {
            if (bodies[j].shape.IsNull() || is_sheet_shape(bodies[j].shape)) continue;
 
            double v = 0;
            // A boolean that fails on one pair must not lose the report for the others.
            try {
                BRepAlgoAPI_Common common(bodies[i].shape, bodies[j].shape);
                common.Build();
                if (!common.IsDone()) continue;
                const TopoDS_Shape s = common.Shape();
                if (s.IsNull()) continue;
                GProp_GProps props;
                BRepGProp::VolumeProperties(s, props);
                v = std::abs(props.Mass());
            } catch (const Standard_Failure&) {
                continue;
            }
 
            // Bodies that merely touch share a face and enclose no volume, so the
            // threshold is what separates contact from interference.
            if (v > min_volume) out.push_back({i, j, v});
        }
    }
    return out;
}

References bodies, and is_sheet_shape().

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_check_interference().

Here is the call graph for this function:

Here is the caller graph for this function:

checkpoint()

void Slic3r::CadDocument::checkpoint

(

)

{
    m_undo.push_back(Snapshot{features, variables});   // snapshot the pre-mutation recipe
    m_redo.clear();                                    // any new action invalidates the redo branch
    if (m_undo.size() > k_undo_cap)
        m_undo.erase(m_undo.begin());
}

References features, k_undo_cap, m_redo, m_undo, and variables.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_axis(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_boolean(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_bridge(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_chamfer(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_coordsys(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_delete_face(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_draft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_fillet(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_helix(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_standard(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_styled(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mate(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mirror(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_pattern(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_project(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_rib(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_feature_expr(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_variable(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_shell(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_split(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_fill(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_loft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_offset(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken_surface(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_transform(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_mesh(), and Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_step().

Here is the caller graph for this function:

clear()

void Slic3r::CadDocument::clear

(

)

{
    features.clear();
    body = TopoDS_Shape();
    bodies.clear();                // multibody result — must clear too (else solids linger)
    display_mesh = TriangleMesh{};
    display_body_meshes.clear();
    display_tri_face.clear();
    display_tri_body.clear();
    origin_from_recipe = false;
    auto_close_loops   = true;
    // Variables are document state like the features: left behind, the previous project's
    // variables were written into the next project's recipe.
    variables.clear();
    error.clear();
    mate_conflicts.clear();
    ++topo_generation;       // every face/edge id handed out before this is stale now
    // A cleared document is a fresh start with no history.
    m_undo.clear();
    m_redo.clear();
}

References auto_close_loops, bodies, body, display_body_meshes, display_mesh, display_tri_body, display_tri_face, error, features, m_redo, m_undo, mate_conflicts, origin_from_recipe, topo_generation, and variables.

datum_frame()

CadDocument::DatumCoordSys Slic3r::CadDocument::datum_frame ( const std::vector< CadBody > & bodies, const CadFeature & f )

staticprivate

{
    CadDocument::DatumCoordSys ds;
    ds.name = f.name;
 
    auto resolve_face = [&](int body_idx, int face_idx) -> TopoDS_Face {
        if (face_idx < 0 || body_idx < 0 || body_idx >= int(bodies.size()))
            return TopoDS_Face();
        return GeometryEngine::face_by_index(bodies[body_idx].shape, face_idx);
    };
    auto resolve_edge = [&](int body_idx, int edge_idx,
                             Vec3d& p0, Vec3d& dir) -> bool {
        if (edge_idx < 0 || body_idx < 0 || body_idx >= int(bodies.size()))
            return false;
        TopoDS_Edge e = GeometryEngine::edge_by_index(bodies[body_idx].shape, edge_idx);
        if (e.IsNull()) return false;
        auto pts = GeometryEngine::sample_edge_world(e);
        if (pts.size() < 2) return false;
        p0  = pts.front();
        dir = (pts.back() - pts.front()).normalized();
        return true;
    };
 
    switch (f.coordsys_type) {
    case CoordSysType::PointWorld: {
        ds.origin = f.coordsys_point;
        ds.x      = Vec3d(1, 0, 0);
        ds.y      = Vec3d(0, 1, 0);
        break;
    }
    case CoordSysType::FaceAndDirection: {
        TopoDS_Face fc = resolve_face(f.coordsys_body, f.coordsys_face);
        Vec3d p0, edge_dir;
        bool have_edge = resolve_edge(f.coordsys_body, f.coordsys_edge, p0, edge_dir);
        if (fc.IsNull()) { ds.error = _u8L("face not found"); break; }
        ds.origin = GeometryEngine::face_centroid_world(fc);
        Vec3d Z = GeometryEngine::face_normal_world(fc);
        // Tentative X: an explicit edge reference wins. Failing that, derive X from the
        // face's OWN first usable edge, so the frame rotates with the body. Reading it from
        // coordsys_x_hint — a world constant — meant a face-only connector could not encode
        // spin about its own normal: Z followed the body, X did not, so Fastened and Slider
        // claimed to fix an orientation the frame could not see. The hint survives only as a
        // last resort, for faces that offer no usable direction (a full circular edge has
        // coincident endpoints, and a cylinder's seam projects to nothing in-plane).
        Vec3d X_tent = Vec3d::Zero();
        if (have_edge) {
            X_tent = edge_dir;
        } else {
            for (const TopoDS_Edge& fe : GeometryEngine::edges_of_face(fc)) {
                auto pts = GeometryEngine::sample_edge_world(fe);
                if (pts.size() < 2) continue;
                Vec3d d = pts.back() - pts.front();
                if (d.squaredNorm() < 1e-18) continue;      // closed edge: endpoints coincide
                Vec3d in_plane = d - Z * Z.dot(d);          // drop any out-of-plane component
                if (in_plane.squaredNorm() < 1e-18) continue;
                X_tent = in_plane;
                break;
            }
            if (X_tent.squaredNorm() < 1e-18) X_tent = f.coordsys_x_hint;
        }
        if (X_tent.squaredNorm() < 1e-18) { ds.error = _u8L("zero-length direction"); break; }
        X_tent.normalize();
        // Gram-Schmidt: ensure orthonormal, right-handed frame.
        // Y = Z x X_tent,  X = Y x Z  (this makes X perpendicular to Z, not X_tent)
        Vec3d Y = Z.cross(X_tent);
        if (Y.squaredNorm() < 1e-12) {
            // Edge/hint is parallel to Z -> X is degenerate; fall back to world X/Y orthonormalised.
            Vec3d ref = (std::abs(Z.z()) < 0.9) ? Vec3d(0, 0, 1) : Vec3d(1, 0, 0);
            Y = Z.cross(ref);
            if (Y.squaredNorm() < 1e-12) Y = Z.cross(Vec3d(0, 1, 0));
        }
        Y.normalize();
        ds.x = Y.cross(Z).normalized();
        ds.y = Y;
        break;
    }
    }
    return ds;
}

References _u8L, bodies, Slic3r::GeometryEngine::edge_by_index(), Slic3r::GeometryEngine::edges_of_face(), Slic3r::CadDocument::DatumCoordSys::error, Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), Slic3r::GeometryEngine::face_centroid_world(), Slic3r::GeometryEngine::face_normal_world(), Slic3r::FaceAndDirection, Slic3r::CadDocument::DatumCoordSys::name, Slic3r::CadDocument::DatumCoordSys::origin, Slic3r::PointWorld, Slic3r::GeometryEngine::sample_edge_world(), Slic3r::CadDocument::DatumCoordSys::x, Slic3r::Y, Slic3r::CadDocument::DatumCoordSys::y, and Slic3r::Z.

Referenced by apply_mate(), and resolve_datum_coordsys().

Here is the call graph for this function:

Here is the caller graph for this function:

deserialize_recipe()

bool Slic3r::CadDocument::deserialize_recipe

(

const std::string &

blob

)

{
    error.clear();
    try {
        std::istringstream iss(blob);
        cereal::BinaryInputArchive ar(iss);
        uint32_t v;
        ar(v);
        if (v > ORCA_CAD_RECIPE_VERSION) {
            error = format(_u8L("saved with a newer version of the Design tab (format v%1%, this build reads up to v%2%)"),
                           v, ORCA_CAD_RECIPE_VERSION);
            return false;
        }
        // The framed layout has been byte-identical since v5 (v6 advanced the stamp without
        // touching the bytes), so every version from 5 up is read below. A future bump that DOES
        // change the framing must exclude itself there — this is what forces that decision
        // instead of letting a v7 blob be silently misread by the v5 reader.
        static_assert(ORCA_CAD_RECIPE_VERSION <= 6,
                      "recipe version bumped: confirm the new version still uses the v5 framing");
        if (v >= 5) {
            // Framed path: every feature is a length-prefixed self-contained cereal stream, so
            // the same four lines handle BOTH directions of mismatch. Older file, newer build:
            // the sub-stream ends early, fa(f) throws, and the fields already assigned are kept
            // (cereal assigns sequentially, so a mid-list throw leaves the earlier fields set)
            // while the rest default. Newer file, older build: the sub-stream has MORE bytes
            // than this build knows how to read; it reads what it knows and simply stops, and
            // the outer stream is unaffected because the length prefix was consumed in full.
            features.clear();
            uint32_t count;
            ar(count);
            for (uint32_t i = 0; i < count; ++i) {
                uint32_t len;
                ar(len);
                std::string buf(len, '\0');
                if (len > 0)
                    ar(cereal::binary_data(&buf[0], len));   // consume EXACTLY len bytes from the outer stream
                CadFeature f;
                try {
                    std::istringstream fs(buf);
                    cereal::BinaryInputArchive fa(fs);
                    fa(f);
                } catch (...) {
                    // An OLDER file: the blob ran out before this build's field list did. Everything read
                    // so far is kept and the remaining fields stay at their defaults. Deliberately NOT an
                    // error — a field a project predates is not a corrupt project.
                }
                features.push_back(f);
            }
            variables.clear();
            uint32_t vlen;
            ar(vlen);
            std::string vbuf(vlen, '\0');
            if (vlen > 0)
                ar(cereal::binary_data(&vbuf[0], vlen));
            try {
                std::istringstream vs(vbuf);
                cereal::BinaryInputArchive va(vs);
                va(variables);
            } catch (...) {
                // Variables blob predates this build: keep what was read, default the rest.
            }
            // Body names, if this project carries them. A project written before the block
            // simply ends here, so the read throws and there are no names — not an error.
            std::map<uint32_t, std::string> named;
            try {
                uint32_t blen;
                ar(blen);
                std::string bbuf(blen, '\0');
                if (blen > 0)
                    ar(cereal::binary_data(&bbuf[0], blen));
                std::istringstream bs(bbuf);
                cereal::BinaryInputArchive ba(bs);
                ba(named);
            } catch (...) {
                named.clear();
            }
            // Document extras (origin, colours), when the project has them. The origin must be
            // in place BEFORE the rebuild: datum planes are resolved against it.
            std::map<uint32_t, std::array<float, 4>> colours;
            try {
                uint32_t xlen;
                ar(xlen);
                std::string xbuf(xlen, '\0');
                if (xlen > 0)
                    ar(cereal::binary_data(&xbuf[0], xlen));
                std::istringstream xs(xbuf);
                cereal::BinaryInputArchive xa(xs);
                double ox = 0, oy = 0, oz = 0;
                bool   weld = true;
                xa(ox, oy, oz, colours, weld);
                modeling_origin    = Vec3d(ox, oy, oz);
                origin_from_recipe = true;
                auto_close_loops   = weld;
            } catch (...) {
                colours.clear();   // older project: the caller's origin stands
            }
            // AFTER the rebuild, never before: recompute() replaces the bodies vector wholesale.
            const bool ok = recompute();
            for (const auto& kv : named)
                if (kv.first < bodies.size()) {
                    bodies[kv.first].has_user_name = true;
                    bodies[kv.first].user_name     = kv.second;
                }
            for (const auto& kv : colours)
                if (kv.first < bodies.size()) {
                    bodies[kv.first].has_color = true;
                    bodies[kv.first].color     = ColorRGBA(kv.second[0], kv.second[1], kv.second[2], kv.second[3]);
                }
            return ok;
        }
        if (v == 4) {
            // Pre-framing flat path: v4 projects keep opening, read with the FROZEN v4 field list
            // (CadFeature::load_flat_v4) so fields appended to the framed layout since cannot
            // shift every byte after them.
            cereal::size_type n = 0;
            ar(cereal::make_size_tag(n));
            features.assign(size_t(n), CadFeature{});
            for (CadFeature& f : features) f.load_flat_v4(ar);
            ar(variables);
            return recompute();
        }
        // v < 4: the field lists for v2/v3 no longer exist in this code, so those files
        // cannot be recovered here. This fix is for the future, not the past.
        error = format(_u8L("saved with an older version of the Design tab (format v%1%); this project cannot be opened by this build"), v);
        return false;
    } catch (const std::exception& e) {
        error = *e.what() ? format(_u8L("CAD data could not be read: %1%"), e.what())
                          : _u8L("CAD data could not be read");
        return false;
    } catch (...) {
        error = _u8L("CAD data could not be read");
        return false;
    }
}

References _u8L, auto_close_loops, bodies, count, error, Slic3r::f(), features, Slic3r::format(), modeling_origin, ORCA_CAD_RECIPE_VERSION, origin_from_recipe, recompute(), and variables.

Here is the call graph for this function:

detect_mate_conflicts()

void Slic3r::CadDocument::detect_mate_conflicts ( )

private

{
    mate_conflicts.clear();
 
    const int n = int(features.size());
    std::map<int, int> first_driver; // body -> feature index of first mate that drives it
    std::map<int, std::vector<int>> graph; // dst -> list of src (body indices)
 
    for (int fi = 0; fi < n; ++fi) {
        const CadFeature& f = features[fi];
        if (f.type != CadFeatureType::Mate || !f.enabled) continue;
 
        if (f.mate_cs_a < 0 || f.mate_cs_a >= n) continue;
        if (f.mate_cs_b < 0 || f.mate_cs_b >= n) continue;
        const CadFeature& fa = features[f.mate_cs_a];
        const CadFeature& fb = features[f.mate_cs_b];
        if (fa.type != CadFeatureType::CoordSys || !fa.enabled) continue;
        if (fb.type != CadFeatureType::CoordSys || !fb.enabled) continue;
 
        const int src = fa.coordsys_body;
        const int dst = fb.coordsys_body;
        if (dst < 0) continue; // apply_mate already reports this one
 
        // (a) duplicate target: a second mate driving the same body
        auto it = first_driver.find(dst);
        if (it != first_driver.end()) {
            int first_fi = it->second;
            std::string first_name = features[first_fi].name.empty() ? _u8L("Mate") : features[first_fi].name;
            std::string this_name = f.name.empty() ? _u8L("Mate") : f.name;
            mate_conflicts.push_back({fi,
                format(_u8L("Body %1% is already positioned by \"%2%\" (feature %3%), so \"%4%\" overrides it"),
                       dst + 1, first_name, first_fi + 1, this_name)});
        } else {
            first_driver[dst] = fi;
        }
 
        // (b) self-mate or cycle detection
        if (src >= 0 && dst >= 0) {
            if (src == dst) {
                mate_conflicts.push_back({fi,
                    format(_u8L("This mate positions Body %1% against itself"), dst + 1)});
            } else {
                graph[dst].push_back(src);
            }
        }
    }
 
    // DFS cycle detection on the graph built above.
    // ponytail: iterative DFS avoids recursion depth issues on long chains.
    // Colour: 0 = unvisited, 1 = in-progress (grey), 2 = done (black).
    std::map<int, int> colour;
    struct Frame { int node; size_t next; };
    std::vector<Frame> stack;
 
    for (const auto& [start, _] : graph) {
        if (colour[start] == 2) continue;
        stack.clear();
        stack.push_back({start, 0});
        colour[start] = 1;
        while (!stack.empty()) {
            Frame& top = stack.back();
            auto git = graph.find(top.node);
            if (git == graph.end() || top.next >= git->second.size()) {
                colour[top.node] = 2;
                stack.pop_back();
                continue;
            }
            int child = git->second[top.next++];
            if (colour[child] == 1) {
                // Back edge found — find the mate whose (dst==top.node, src==child).
                for (int fi = 0; fi < n; ++fi) {
                    const CadFeature& f = features[fi];
                    if (f.type != CadFeatureType::Mate || !f.enabled) continue;
                    if (f.mate_cs_a < 0 || f.mate_cs_a >= n) continue;
                    if (f.mate_cs_b < 0 || f.mate_cs_b >= n) continue;
                    const CadFeature& fa2 = features[f.mate_cs_a];
                    const CadFeature& fb2 = features[f.mate_cs_b];
                    if (fa2.type != CadFeatureType::CoordSys || !fa2.enabled) continue;
                    if (fb2.type != CadFeatureType::CoordSys || !fb2.enabled) continue;
                    int sd = fb2.coordsys_body;
                    int ss = fa2.coordsys_body;
                    if (sd == top.node && ss == child) {
                        mate_conflicts.push_back({fi,
                            // Worded for ANY cycle length: "leads back" is true transitively,
                            // where "depends back on" would be a lie for a 3+ body chain.
                            format(_u8L("Mate chain is circular: Body %1% depends on Body %2%, which leads "
                                        "back to Body %1% — the result depends on feature order"),
                                   top.node + 1, child + 1)});
                        break;
                    }
                }
                continue;
            }
            if (colour[child] == 0) {
                colour[child] = 1;
                stack.push_back({child, 0});
            }
        }
    }
 
    // Deliberately NOT in scope: computing the numeric disagreement between two mates
    // ("Mate3 puts it at X=10, Mate7 at X=15"). That needs speculative per-mate evaluation.
}

References _, _u8L, Slic3r::CoordSys, Slic3r::CadFeature::coordsys_body, Slic3r::CadFeature::enabled, Slic3r::f(), features, Slic3r::format(), Slic3r::Mate, mate_conflicts, and Slic3r::CadFeature::type.

Referenced by recompute().

Here is the call graph for this function:

Here is the caller graph for this function:

export_step()

bool Slic3r::CadDocument::export_step	(	const std::string &	path,
		const std::vector< Transform3d > &	body_xforms,
		std::string &	err ) const

{
    err.clear();
    if (bodies.empty()) { err = _u8L("nothing to export"); return false; }
    try {
        // Compound every body at its displayed (Move-gizmo) position so the STEP matches
        // what Commit ships. Move transforms are rigid, so gp_Trsf::SetValues is valid.
        BRep_Builder bld;
        TopoDS_Compound comp;
        bld.MakeCompound(comp);
        for (size_t i = 0; i < bodies.size(); ++i) {
            if (bodies[i].shape.IsNull()) continue;
            TopoDS_Shape s = bodies[i].shape;
            if (i < body_xforms.size() && !body_xforms[i].isApprox(Transform3d::Identity())) {
                const Transform3d& m = body_xforms[i];
                gp_Trsf t;
                t.SetValues(m(0,0), m(0,1), m(0,2), m(0,3),
                            m(1,0), m(1,1), m(1,2), m(1,3),
                            m(2,0), m(2,1), m(2,2), m(2,3));
                s = BRepBuilderAPI_Transform(s, t, true).Shape();
            }
            bld.Add(comp, s);
        }
        STEPControl_Writer writer;
        if (writer.Transfer(comp, STEPControl_AsIs) != IFSelect_RetDone) {
            err = _u8L("STEP transfer failed");
            return false;
        }
        if (writer.Write(path.c_str()) != IFSelect_RetDone) {
            err = _u8L("cannot write STEP file");
            return false;
        }
    } catch (const std::exception& e) {
        err = *e.what() ? e.what() : _u8L("OCCT failed to write STEP");
        return false;
    }
    return true;
}

References _u8L, and bodies.

faces_made_by()

std::vector< std::pair< int, int > > Slic3r::CadDocument::faces_made_by

(

int

index

)

const

{
    std::vector<std::pair<int, int>> out;
    if (index < 0 || index >= int(features.size()) || !features[index].enabled
        || !produces_body(features[index].type) || bodies.empty())
        return out;
 
    // Replay up to the feature, then the feature alone on a copy, so a body it left alone is the
    // same shape on both sides. On a scratch document, as a replay settles references in the
    // features it runs; it reads only the features, the variables and the process-wide weld rule.
    CadDocument tmp;
    tmp.features  = features;
    tmp.variables = variables;
    std::vector<CadBody> before, after;
    try {
        set_sketch_auto_close(auto_close_loops);
        tmp.bind_expressions();
        for (size_t fi = 0; fi < size_t(index); ++fi)
            tmp.replay_feature(fi, before);
        after = before;
        tmp.replay_feature(size_t(index), after);
    } catch (...) {   // OCCT's Standard_Failure as well as std::exception
        return out;
    }
 
    // The bodies the step made or replaced. A face on any other body was on the boundary before
    // the step too, so only these are probed after it.
    std::vector<int>     changed;
    std::vector<CadBody> changed_bodies;
    for (int j = 0; j < int(after.size()); ++j)
        if (std::none_of(before.begin(), before.end(), [&](const CadBody& w) { return w.shape.IsSame(after[j].shape); })) {
            changed.push_back(j);
            changed_bodies.push_back(after[j]);
        }
    const std::vector<FaceProbe> was = face_probes(before), now = face_probes(changed_bodies);
    for (int b = 0; b < int(bodies.size()); ++b) {
        int id = 0;
        for (TopExp_Explorer e(bodies[b].shape, TopAbs_FACE); e.More(); e.Next(), ++id) {
            gp_Pnt p;
            gp_Dir n;
            try {
                if (interior_point(TopoDS::Face(e.Current()), p, n) && on_boundary(now, p, n) && !on_boundary(was, p, n))
                    out.emplace_back(b, id);
            } catch (const Standard_Failure&) {
                // A face that cannot be sampled is left out, not the whole answer.
            }
        }
    }
    if (!out.empty())
        return out;
 
    // No face of its own: answer with every face of each body the step changed, found again in
    // the finished model by the id a body keeps across the rest of the history.
    for (int j : changed) {
        const int b = find_body(bodies, body_id_of(after, j));
        if (b < 0) continue;
        const int n = GeometryEngine::face_count(bodies[b].shape);
        for (int id = 0; id < n; ++id)
            out.emplace_back(b, id);
    }
    return out;
}

References auto_close_loops, bind_expressions(), bodies, Slic3r::body_id_of(), Slic3r::GeometryEngine::face_count(), features, Slic3r::find_body(), produces_body(), replay_feature(), Slic3r::set_sketch_auto_close(), and variables.

Here is the call graph for this function:

is_bindable_field()

bool Slic3r::CadDocument::is_bindable_field ( const std::string & field )

static

{
    CadFeature probe;
    try { assign_field(probe, field, 0.0); return true; }
    catch (const std::exception&) { return false; }
}

References Slic3r::assign_field().

Referenced by Slic3r::GUI::DesignPanel::on_set_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

is_sheet_shape()

bool Slic3r::CadDocument::is_sheet_shape ( const TopoDS_Shape & s )

static

{
    return !TopExp_Explorer(s, TopAbs_SOLID).More();
}

Referenced by apply_surface_offset(), apply_thicken_surface(), body_touching_sketch(), check_interference(), Slic3r::GUI::DesignPanel::offer_selection_kind(), Slic3r::GUI::DesignPanel::populate_sheet_body_choices(), and Slic3r::GUI::DesignPanel::show_offer_menu().

Here is the caller graph for this function:

mate_options()

std::vector< CadDocument::MateOption > Slic3r::CadDocument::mate_options	(	int	cs_a,
		int	cs_b ) const

{
    std::vector<MateOption> out(5);
    for (int k = 0; k < 5; ++k) out[k].kind = k;
 
    auto is_connector = [&](int idx) -> bool {
        return idx >= 0 && idx < int(features.size()) &&
               features[idx].type == CadFeatureType::CoordSys &&
               features[idx].enabled;
    };
    if (!is_connector(cs_a) || !is_connector(cs_b)) {
        const char side = is_connector(cs_a) ? 'B' : 'A';
        const std::string reason = format(_u8L("connector %1% is not a coordinate system"), side);
        for (auto& o : out) { o.viable = false; o.reason = reason; }
        return out;
    }
    if (cs_a == cs_b) {
        for (auto& o : out) { o.viable = false; o.reason = _u8L("a mate needs two different connectors"); }
        return out;
    }
 
    // B is the connector on the body that MOVES, so B must belong to one; A is the fixed
    // reference and needs no body. Without this every kind was offered on a Point(world)
    // connector and the mate only failed at RECOMPUTE, with "mate_cs_b has no associated body" —
    // one step too late, after the feature already existed in the tree. The same two conditions
    // the apply path throws on are checked here, so the offer and the kernel cannot disagree.
    const int body_b = features[cs_b].coordsys_body;
    if (body_b < 0) {
        for (auto& o : out) {
            o.viable = false;
            o.reason = _u8L("connector B is not attached to a body — a mate moves B's body");
        }
        return out;
    }
    if (body_b >= int(bodies.size()) || bodies[body_b].shape.IsNull()) {
        for (auto& o : out) {
            o.viable = false;
            o.reason = _u8L("connector B's body no longer exists");
        }
        return out;
    }
 
    const int ka = features[cs_a].coordsys_face_kind;
    const int kb = features[cs_b].coordsys_face_kind;
 
    // Planar: needs a flat face at both ends.
    const bool plan_bad_a = ka >= 0 && ka != GeomAbs_Plane;
    const bool plan_bad_b = kb >= 0 && kb != GeomAbs_Plane;
    if (plan_bad_a || plan_bad_b) {
        out[1].viable = false;
        if (plan_bad_a && plan_bad_b)
            out[1].reason = _u8L("needs a flat face at both ends — both connectors are on curved faces");
        else
            out[1].reason = format(_u8L("needs a flat face at both ends — connector %1% is on a curved face"),
                                   plan_bad_a ? 'A' : 'B');
    }
 
    // Revolute and Cylindrical: need a cylindrical face at both ends.
    for (int k : {2, 4}) {
        const bool ax_bad_a = ka >= 0 && ka != GeomAbs_Cylinder;
        const bool ax_bad_b = kb >= 0 && kb != GeomAbs_Cylinder;
        if (!ax_bad_a && !ax_bad_b) continue;
        out[k].viable = false;
        if (ax_bad_a && ax_bad_b)
            out[k].reason = (ka == GeomAbs_Plane && kb == GeomAbs_Plane)
                ? _u8L("needs a cylindrical face at both ends — both connectors are on flat faces")
                : _u8L("needs a cylindrical face at both ends — both connectors are on non-cylindrical faces");
        else
            out[k].reason = format((ax_bad_a ? ka : kb) == GeomAbs_Plane
                                       ? _u8L("needs a cylindrical face at both ends — connector %1% is on a flat face")
                                       : _u8L("needs a cylindrical face at both ends — connector %1% is on a curved face"),
                                   ax_bad_a ? 'A' : 'B');
    }
 
    return out;
}

References _u8L, bodies, Slic3r::CoordSys, features, and Slic3r::format().

Here is the call graph for this function:

move_feature()

bool Slic3r::CadDocument::move_feature	(	int	index,
		int	delta )

{
    if (index < 0 || index >= int(features.size()))
        return false;
    int target = index + delta;
    if (target < 0 || target >= int(features.size()))
        return true; // clamped at the ends — no-op, not a failure
 
    std::vector<CadFeature> snapshot = features;
    stage_history_change(features,
        [index, target](int i) { return i == index ? target : i == target ? index : i; },
        [this](int i) { return features[i].enabled; });
    std::swap(features[index], features[target]);
 
    // The two slots traded places: fix every feature reference that pointed at either —
    // a mate's connectors as well as sketch_ref, for the reason given in remove_feature().
    auto swap_ref = [index, target](int& ref) {
        if (ref == index)       ref = target;
        else if (ref == target) ref = index;
    };
    for (auto& f : features)
        for_each_feature_ref(f, swap_ref);
 
    // History runs top to bottom: a feature may only consume what comes BEFORE it. Moving a
    // consumer above its sketch (or a sketch below its consumer) would make it read whatever the
    // input held the last time round — or, for a Project, nothing. Refuse the move and say so.
    for (int fi = 0; fi < int(features.size()); ++fi) {
        CadFeature& f = features[fi];
        std::string bad;
        auto check = [&](int& ref) { if (ref >= fi && bad.empty()) bad = features[ref].name; };
        check(f.sketch_ref); check(f.sweep_path_ref); check(f.pattern_curve_sketch); check(f.rib_sketch_ref);
        for (int& r : f.loft_profile_refs) check(r);
        if (!bad.empty()) {
            // TRN Feature reorder error. %1% is the moved feature, %2% the feature it depends on.
            error = format(_u8L("\"%1%\" uses \"%2%\", so it cannot come before it"), f.name, bad);
            features.swap(snapshot);
            return false;
        }
    }
 
    return commit_or_rollback(*this, snapshot);
}

References _u8L, Slic3r::commit_or_rollback(), error, Slic3r::f(), features, Slic3r::for_each_feature_ref(), Slic3r::format(), and Slic3r::stage_history_change().

Here is the call graph for this function:

plane_of_face()

bool Slic3r::CadDocument::plane_of_face	(	int	body_idx,
		int	face_idx,
		SketchPlane &	out ) const

{
    if (face_idx < 0 || body_idx < 0 || body_idx >= int(bodies.size())) return false;
    const TopoDS_Face f = GeometryEngine::face_by_index(bodies[body_idx].shape, face_idx);
    if (f.IsNull()) return false;
    // Planar only. face_normal_world evaluates the normal at the mid parameter, which on a cylinder
    // or a fillet is a tangent plane at one arbitrary point — usable for a datum offset, wrong as a
    // sketch plane. Refuse rather than sketch somewhere the user did not point at.
    BRepAdaptor_Surface surf(f);
    if (surf.GetType() != GeomAbs_Plane) return false;
    out = frame_from(GeometryEngine::face_centroid_world(f), GeometryEngine::face_normal_world(f));
    return true;
}

References bodies, Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), Slic3r::GeometryEngine::face_centroid_world(), Slic3r::GeometryEngine::face_normal_world(), and Slic3r::frame_from().

Here is the call graph for this function:

preview() [1/2]

bool Slic3r::CadDocument::preview	(	const CadFeature &	candidate,
		TriangleMesh &	out_mesh,
		std::string &	err ) const

{
    std::vector<TriangleMesh> ignore;
    return preview(candidate, out_mesh, ignore, err);
}

References preview().

Referenced by preview().

Here is the call graph for this function:

Here is the caller graph for this function:

preview() [2/2]

bool Slic3r::CadDocument::preview	(	const CadFeature &	candidate,
		TriangleMesh &	out_mesh,
		std::vector< TriangleMesh > &	out_body_meshes,
		std::string &	err ) const

{
    err.clear();
    out_body_meshes.clear();
    std::vector<CadBody> tmp = bodies;     // start from the current committed bodies
    try {
        route_feature(tmp, candidate);     // candidate may append a new body or mutate one
    } catch (const std::exception& e) {
        err = *e.what() ? e.what() : _u8L("OCCT operation failed");
        return false;
    } catch (...) {
        err = _u8L("unknown geometry error");
        return false;
    }
    if (tmp.empty()) {
        err = _u8L("preview produced no geometry");
        return false;
    }
    // Tessellate per body (same path as recompute) so the GUI can re-apply its display-only
    // per-body Move transforms to the ghost; out_mesh is the merged whole.
    std::vector<int> tf, tb;
    out_mesh = tessellate_bodies(tmp, tf, tb, out_body_meshes, linear_deflection, angular_deflection);
    if (out_mesh.its.indices.empty()) {
        err = _u8L("preview produced an empty mesh");
        return false;
    }
    return true;
}

References _u8L, angular_deflection, bodies, Slic3r::TriangleMesh::its, linear_deflection, route_feature(), and Slic3r::tessellate_bodies().

Here is the call graph for this function:

produces_body()

bool Slic3r::CadDocument::produces_body ( CadFeatureType t )

static

{
    switch (t) {
    case CadFeatureType::Sketch: case CadFeatureType::Helix: case CadFeatureType::Plane:
    case CadFeatureType::Axis:   case CadFeatureType::CoordSys: case CadFeatureType::Project:
        return false;
    default:
        return true;
    }
}

References Slic3r::Axis, Slic3r::CoordSys, Slic3r::Helix, Slic3r::Plane, Slic3r::Project, and Slic3r::Sketch.

Referenced by Slic3r::GUI::DesignPanel::can_zoom_to_feature(), Slic3r::commit_or_rollback(), faces_made_by(), and Slic3r::GUI::DesignPanel::feature_faces().

Here is the caller graph for this function:

project_edges_into_sketch()

int Slic3r::CadDocument::project_edges_into_sketch	(	int	sketch_feature,
		int	source_body,
		const std::vector< int > &	edge_ids,
		int	face )

{
    if (sketch_feature < 0 || sketch_feature >= int(features.size())) return -1;
    CadFeature& sk = features[sketch_feature];
    if (sk.type != CadFeatureType::Sketch && sk.type != CadFeatureType::Project) return -1;
    if (source_body < 0 || source_body >= int(bodies.size())
        || bodies[source_body].shape.IsNull()) return -1;
    const TopoDS_Shape& shape = bodies[source_body].shape;
 
    std::vector<TopoDS_Edge> edges;
    if (!edge_ids.empty()) {
        for (int id : edge_ids) {
            TopoDS_Edge e = GeometryEngine::edge_by_index(shape, id);
            if (e.IsNull()) return -1;
            edges.push_back(e);
        }
    } else if (face >= 0) {
        TopoDS_Face fc = GeometryEngine::face_by_index(shape, face);
        if (fc.IsNull()) return -1;
        edges = GeometryEngine::edges_of_face(fc);
    } else {
        edges = GeometryEngine::edges_of(shape);
    }
    if (edges.empty()) return -1;
 
    const size_t before = sk.entities.size();
    project_edges_to_entities(edges, sk.plane, /*construction=*/true, sk.entities);
    return int(sk.entities.size() - before);
}

References bodies, Slic3r::GeometryEngine::edge_by_index(), Slic3r::GeometryEngine::edges_of(), Slic3r::GeometryEngine::edges_of_face(), Slic3r::CadFeature::entities, Slic3r::GeometryEngine::face_by_index(), features, Slic3r::CadFeature::plane, Slic3r::Project, Slic3r::project_edges_to_entities(), Slic3r::Sketch, and Slic3r::CadFeature::type.

Here is the call graph for this function:

recompute()

bool Slic3r::CadDocument::recompute

(

)

{
    error.clear();
    set_sketch_auto_close(auto_close_loops);   // this document's weld rule, not the last one's
    detect_mate_conflicts();
    std::vector<CadBody> built;
    // Did any feature in this document even ASK for a solid? A document made only of sketches
    // and datums has nothing to build, and that is a legitimate state — it is every document
    // between drawing the first profile and extruding it. Reporting it as a failure is what
    // made a sketch-only design unsaveable AND unopenable: DesignPanel::recompute_guarded syncs
    // the 3MF recipe only "on success", so nothing was written, and deserialize_recipe ends with
    // `return recompute()`, so a project that did carry a recipe was refused on load with
    // "Could not restore the CAD model" while its features sat correctly in the list. mtav.
    const bool any_solid_feature = std::any_of(features.begin(), features.end(), [](const CadFeature& f) {
        return f.enabled && produces_body(f.type);
    });
    try {
        bind_expressions();
        for (size_t fi = 0; fi < features.size(); ++fi)
            replay_feature(fi, built);
    } catch (const std::exception& e) {
        error = *e.what() ? e.what() : _u8L("OCCT operation failed");
        return false;
    } catch (...) {
        error = _u8L("unknown geometry error");
        return false;
    }
    if (built.empty() && any_solid_feature) { error = _u8L("no solid-producing features"); return false; }
 
    // A feature that leaves a body with a null shape must fail loudly. Until this existed,
    // recompute() returned true and the document kept advertising the body: describe_scene
    // counted it, error was empty, and only mass_properties on that specific body revealed
    // anything was wrong. Returning false hands the caller its normal rollback path, so the
    // operation that destroyed the body is undone rather than committed.
    for (size_t i = 0; i < built.size(); ++i) {
        if (!built[i].shape.IsNull()) continue;
        const int src = built[i].source_feature;
        // source_feature is -1 for a body no feature claims. "feature 0" would be a lie, and
        // this message exists precisely to be trusted about which feature to look at.
        const std::string fname =
            (src < 0 || src >= int(features.size()))
                ? _u8L("an unidentified feature")
                : (features[src].name.empty() ? format(_u8L("feature %1%"), src + 1)
                                              : features[src].name);
        error = format(_u8L("body %1% was destroyed by %2% (the operation produced an empty shape)"), i + 1, fname);
        return false;
    }
 
    // recompute() replaces the bodies vector wholesale, which would drop any per-body
    // colour override (Color tool) and the name the user gave a body. They are carried forward
    // by the body's IDENTITY — the feature that made it and which of its bodies it is — not by
    // its index: a Boolean consuming its tool, a Mirror replacing its source or a Cut splitting
    // one body into two all shift every later index, and by index the colour and the name
    // moved to a different body.
    for (size_t i = 0; i < bodies.size(); ++i) {
        if (!bodies[i].has_color && !bodies[i].has_user_name) continue;
        const int j = find_body(built, body_id_of(bodies, int(i)));
        if (j < 0) continue;
        if (bodies[i].has_color) {
            built[j].has_color = true;
            built[j].color     = bodies[i].color;
        }
        if (bodies[i].has_user_name) {
            built[j].has_user_name = true;
            built[j].user_name     = bodies[i].user_name;
        }
    }
    bodies = std::move(built);
    // Datum references index the FINISHED body list; settle them against it, and close every
    // pending re-point now that both kinds have been through settle_body_refs.
    try {
        for (CadFeature& f : features) {
            if (!f.enabled) continue;   // a hidden feature keeps its pending re-point for when it returns
            settle_body_refs(f, bodies, false);
            f.body_refs_pending = false;
        }
    } catch (const std::exception& e) {
        error = e.what();
        return false;
    }
    // The face and edge maps have just been rebuilt, so every global id handed out before this
    // point now means something else. Bump here rather than in each mutator: this is the single
    // line where the topology is actually replaced, so it cannot be forgotten by a new feature
    // type the way a per-mutator bump would be.
    ++topo_generation;
 
    // Face-drift fingerprint for FaceAndDirection CoordSys connectors. This runs AFTER the
    // bodies are final and APPENDS to mate_conflicts (detect_mate_conflicts() cleared it at
    // the top of recompute() and must not run again here). A mismatch is a WARNING, not an
    // error: a legitimate Draft on a mated face renumbers nothing but a real renumber after a
    // dress-up silently points the connector at a different face, and that must not abort.
    for (int fi = 0; fi < int(features.size()); ++fi) {
        CadFeature& f = features[fi];
        if (!f.enabled) continue;
        if (f.type != CadFeatureType::CoordSys) continue;
        if (f.coordsys_type != CoordSysType::FaceAndDirection) continue;
        if (f.coordsys_body < 0 || f.coordsys_body >= int(bodies.size())) continue;
        TopoDS_Face face = GeometryEngine::face_by_index(bodies[f.coordsys_body].shape, f.coordsys_face);
        if (face.IsNull()) continue; // "face not found" is already reported by datum_frame()
        const int kind  = int(BRepAdaptor_Surface(face).GetType());
        const int edges = int(GeometryEngine::edges_of_face(face).size());
        if (f.coordsys_face_kind < 0) {
            // No fingerprint yet (old recipe, or a connector never resolved): adopt the state
            // the user last saw. Self-heals old recipes on first load, and gives both existing
            // writers the fingerprint for free.
            f.coordsys_face_kind  = kind;
            f.coordsys_face_edges = edges;
            continue;
        }
        if (f.coordsys_face_kind != kind || f.coordsys_face_edges != edges) {
            mate_conflicts.emplace_back(int(fi),
                format(_u8L("Connector \"%1%\" may have moved to a different face (an upstream edit "
                            "renumbered this body's faces)"), f.name));
        }
    }
 
    body = compound_of(bodies);
    display_mesh = tessellate_bodies(bodies, display_tri_face, display_tri_body,
                                     display_body_meshes,
                                     linear_deflection, angular_deflection);
    if (display_mesh.its.indices.empty() && any_solid_feature) {
        // Empty only because there are no bodies to tessellate is the same legitimate state as
        // above: a sketch-only document has nothing to draw as a solid, and that is not a fault.
        error = _u8L("tessellation produced an empty mesh");
        return false;
    }
    return true;
}

References _u8L, angular_deflection, auto_close_loops, bind_expressions(), bodies, body, Slic3r::body_id_of(), Slic3r::compound_of(), Slic3r::CoordSys, detect_mate_conflicts(), display_body_meshes, display_mesh, display_tri_body, display_tri_face, Slic3r::GeometryEngine::edges_of_face(), error, Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), Slic3r::FaceAndDirection, features, Slic3r::find_body(), Slic3r::format(), linear_deflection, mate_conflicts, replay_feature(), Slic3r::set_sketch_auto_close(), Slic3r::settle_body_refs(), Slic3r::tessellate_bodies(), and topo_generation.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_axis(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_boolean(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_bridge(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_chamfer(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_coordsys(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_delete_face(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_draft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_fillet(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_standard(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_styled(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mate(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mirror(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_pattern(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_project(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_rib(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_feature_expr(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_variable(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_shell(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_split(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_fill(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_loft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_offset(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken_surface(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_transform(), Slic3r::commit_or_rollback(), deserialize_recipe(), Slic3r::GUI::DesignPanel::fill_body_choice(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_mesh(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_step(), Slic3r::GUI::DesignPanel::populate_body_choices(), redo(), and undo().

Here is the call graph for this function:

Here is the caller graph for this function:

redo()

bool Slic3r::CadDocument::redo

(

)

{
    if (m_redo.empty())
        return false;
    m_undo.push_back(Snapshot{std::move(features), std::move(variables)});
    features  = std::move(m_redo.back().features);
    variables = std::move(m_redo.back().variables);
    m_redo.pop_back();
    recompute();
    return true;
}

References features, m_redo, m_undo, recompute(), and variables.

Here is the call graph for this function:

redo_depth()

size_t Slic3r::CadDocument::redo_depth ( ) const

inline

{ return m_redo.size(); }

References m_redo.

remove_feature()

bool Slic3r::CadDocument::remove_feature

(

int

index

)

{
    if (index < 0 || index >= int(features.size()))
        return false;
 
    std::vector<CadFeature> snapshot = features;
 
    // Deleting a Sketch cascades to every feature that consumes it AS ITS PROFILE — the
    // reason is the original one ("a dangling Extrude would have no wire"), and it applies
    // unchanged to Revolve, Sweep, Rib and the Surface* family, which all read the profile
    // through sketch_ref, plus the sweep spine and the rib line. Testing the FIELD rather
    // than the type is what makes that true without a list to keep up to date.
    //
    // pattern_curve_sketch and loft_profile_refs are deliberately NOT cascaded: a Pattern or
    // a Loft that loses one of several inputs is degraded, not meaningless, so those refs go
    // to -1 in the remap below and the feature survives. A lone Sketch is harmless either way.
    std::vector<int> remove{index};
    if (features[index].type == CadFeatureType::Sketch) {
        for (int j = 0; j < int(features.size()); ++j) {
            const CadFeature& c = features[j];
            if (c.sketch_ref == index || c.sweep_path_ref == index || c.rib_sketch_ref == index)
                remove.push_back(j);
        }
    }
    std::sort(remove.begin(), remove.end());
    remove.erase(std::unique(remove.begin(), remove.end()), remove.end());
 
    stage_history_change(features,
        [&remove](int i) {
            if (std::binary_search(remove.begin(), remove.end(), i)) return -1;
            int shift = 0;
            for (int r : remove) if (r < i) ++shift;
            return i - shift;
        },
        [this](int i) { return features[i].enabled; });
 
    // Erase high-to-low so earlier indices stay valid.
    for (auto it = remove.rbegin(); it != remove.rend(); ++it)
        features.erase(features.begin() + *it);
 
    // Remap surviving feature references through the deletions: subtract the count of
    // removed indices that sat before it; orphaned refs (target removed) -> -1.
    //
    // This must cover EVERY field holding a feature index, not just sketch_ref. A mate's two
    // connectors are such indices, and leaving them behind slid them onto whatever features
    // landed on those slots — silently, because recompute() only rejects out-of-range and
    // non-CoordSys targets, and a shifted index usually lands on the assembly's other CoordSys.
    auto remap = [&remove](int& ref) {
        if (ref < 0)
            return;
        if (std::binary_search(remove.begin(), remove.end(), ref)) {
            ref = -1;
        } else {
            int shift = 0;
            for (int r : remove)
                if (r < ref) ++shift;
            ref -= shift;
        }
    };
    for (auto& f : features)
        for_each_feature_ref(f, remap);
 
    return commit_or_rollback(*this, snapshot);
}

References Slic3r::commit_or_rollback(), Slic3r::f(), features, Slic3r::for_each_feature_ref(), Slic3r::CadFeature::rib_sketch_ref, Slic3r::Sketch, Slic3r::CadFeature::sketch_ref, Slic3r::stage_history_change(), and Slic3r::CadFeature::sweep_path_ref.

Here is the call graph for this function:

replace_feature()

bool Slic3r::CadDocument::replace_feature	(	int	index,
		const CadFeature &	edited )

{
    if (index < 0 || index >= int(features.size()))
        return false;
 
    std::vector<CadFeature> snapshot = features;
 
    // Preserve identity (name) and the structural link (sketch_ref) from the
    // original; only the user-editable parameters come from `edited`.
    CadFeature f      = edited;
    f.name            = features[index].name;
    f.type            = features[index].type;
    if (f.type == CadFeatureType::Extrude)
        f.sketch_ref  = features[index].sketch_ref;
    features[index]   = f;
 
    return commit_or_rollback(*this, snapshot);
}

References Slic3r::commit_or_rollback(), Slic3r::Extrude, Slic3r::f(), and features.

Referenced by Slic3r::GUI::DesignPanel::refresh_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_sketch_extrude()

bool Slic3r::CadDocument::replace_sketch_extrude	(	int	sketch_idx,
		int	extrude_idx,
		const CadFeature &	edited )

{
    if (sketch_idx  < 0 || sketch_idx  >= int(features.size())) return false;
    if (extrude_idx < 0 || extrude_idx >= int(features.size())) return false;
 
    std::vector<CadFeature> snapshot = features;
 
    // A box in the tree is two linked features: the Sketch consumes the profile
    // params (shape/plane/width/height/radius), the Extrude consumes the solid
    // params (distance/symmetric/mode). `edited` carries all of them; split it
    // back into the two slots, preserving each slot's name/type and the link.
    CadFeature& sk = features[sketch_idx];
    sk.shape  = edited.shape;
    sk.plane  = edited.plane;
    sk.width  = edited.width;
    sk.height = edited.height;
    sk.radius = edited.radius;
 
    CadFeature& ex = features[extrude_idx];
    ex.distance  = edited.distance;
    ex.symmetric = edited.symmetric;
    ex.mode      = edited.mode;
 
    return commit_or_rollback(*this, snapshot);
}

References Slic3r::commit_or_rollback(), Slic3r::CadFeature::distance, features, Slic3r::CadFeature::height, Slic3r::CadFeature::mode, Slic3r::CadFeature::plane, Slic3r::CadFeature::radius, Slic3r::CadFeature::shape, Slic3r::CadFeature::symmetric, and Slic3r::CadFeature::width.

Here is the call graph for this function:

replay_feature()

void Slic3r::CadDocument::replay_feature ( size_t fi, std::vector< CadBody > & built )

private

{
    CadFeature& f = features[fi];
    if (!f.enabled) return;
    if (f.type == CadFeatureType::Sketch) return; // consumed by an extrude
    if (f.type == CadFeatureType::Helix)  return; // consumed by Sweep as a path
    if (f.type == CadFeatureType::Plane)   return; // datum: no solid, derived on demand
    if (f.type == CadFeatureType::Axis)    return; // datum axis
    if (f.type == CadFeatureType::CoordSys) return; // datum coordinate system
    settle_body_refs(f, built, true);
    if (f.type == CadFeatureType::Project) { apply_project(built, f); }
    else                                   { route_feature(built, f); }
    // Record which feature made each body. "Still unset?" is the whole rule, and it is
    // sufficient because of an invariant worth stating: NO feature ever replaces a whole
    // CadBody. Every in-place op writes only `.shape` (boolean, cut, mirror-fuse,
    // transform, dress-up — checked, all 8 sites), so an existing body keeps the stamp it
    // was born with; a consumed body is erased outright, taking its stamp with it; and
    // the only bodies still at -1 here are the ones THIS feature just pushed. That also
    // means a feature type added later needs no change here, as long as it keeps to the
    // same invariant.
    for (CadBody& b : built)
        if (b.source_feature < 0)
            b.source_feature = int(fi);
}

References apply_project(), Slic3r::Axis, Slic3r::CoordSys, Slic3r::f(), features, Slic3r::Helix, Slic3r::Plane, Slic3r::Project, route_feature(), Slic3r::settle_body_refs(), and Slic3r::Sketch.

Referenced by faces_made_by(), and recompute().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_datum_axes()

std::vector< CadDocument::DatumAxis > Slic3r::CadDocument::resolve_datum_axes

(

)

const

{
    std::vector<DatumAxis> out;
    // For PlaneIntersection we need the already-resolved datum planes.
    std::vector<std::pair<std::string, SketchPlane>> datum_planes = resolve_datum_planes();
 
    auto resolve_face = [&](int body_idx, int face_idx) -> TopoDS_Face {
        if (face_idx < 0 || body_idx < 0 || body_idx >= int(bodies.size()))
            return TopoDS_Face();
        return GeometryEngine::face_by_index(bodies[body_idx].shape, face_idx);
    };
    auto resolve_edge = [&](int body_idx, int edge_idx,
                             Vec3d& p0, Vec3d& dir) -> bool {
        if (edge_idx < 0 || body_idx < 0 || body_idx >= int(bodies.size()))
            return false;
        TopoDS_Edge e = GeometryEngine::edge_by_index(bodies[body_idx].shape, edge_idx);
        if (e.IsNull()) return false;
        auto pts = GeometryEngine::sample_edge_world(e);
        if (pts.size() < 2) return false;
        p0 = pts.front();
        dir = (pts.back() - pts.front()).normalized();
        return true;
    };
 
    for (const CadFeature& f : features) {
        if (f.type != CadFeatureType::Axis || !f.enabled) continue;
 
        DatumAxis da;
        da.name = f.name;
        switch (f.axis_type) {
        case AxisType::TwoPoints: {
            Vec3d dir = f.axis_p2 - f.axis_p1;
            if (dir.squaredNorm() < 1e-18) { da.error = _u8L("two points are coincident"); break; }
            da.origin    = f.axis_p1;
            da.direction = dir.normalized();
            break;
        }
        case AxisType::FaceNormal: {
            TopoDS_Face fc = resolve_face(f.axis_body, f.axis_face);
            if (fc.IsNull()) { da.error = _u8L("face not found"); break; }
            da.origin    = GeometryEngine::face_centroid_world(fc);
            da.direction = GeometryEngine::face_normal_world(fc);
            break;
        }
        case AxisType::CylinderCenterline: {
            TopoDS_Face fc = resolve_face(f.axis_body, f.axis_face);
            if (fc.IsNull()) { da.error = _u8L("face not found"); break; }
            GeometryEngine::CylinderFace cyl = GeometryEngine::cylinder_of_face(fc);
            if (!cyl.ok) { da.error = _u8L("face is not a cylinder"); break; }
            da.origin    = cyl.base;
            da.direction = cyl.axis;
            break;
        }
        case AxisType::AlongEdge: {
            Vec3d p0, dir;
            if (!resolve_edge(f.axis_body, f.axis_edge, p0, dir)) {
                da.error = _u8L("edge not found"); break;
            }
            da.origin    = p0;
            da.direction = dir;
            break;
        }
        case AxisType::PlaneIntersection: {
            // Same reference encoding as CadFeature::plane_base, because the GUI fills these
            // two fields from populate_plane_choices() — whose rows are XY/XZ/YZ followed by
            // the datum planes — and stores the row verbatim. Indexing datum_planes[ref]
            // directly, as this did, is off by three: picking XY resolved to datum plane 0 and
            // picking the first datum ran off the end with "plane ref not found", so the
            // PlaneIntersection axis type could not work at all. Two base planes are also a
            // perfectly ordinary way to define an axis (XY x XZ = the X axis), so they must
            // resolve rather than be rejected as out of scope.
            auto base_plane = [&](int ref, Vec3d& origin, Vec3d& normal) -> bool {
                SketchPlane p;
                if      (ref == 0) { p = SketchPlane::XY(); p.origin += modeling_origin; }
                else if (ref == 1) { p = SketchPlane::XZ(); p.origin += modeling_origin; }
                else if (ref == 2) { p = SketchPlane::YZ(); p.origin += modeling_origin; }
                else if (ref >= 3 && ref - 3 < int(datum_planes.size()))
                    p = datum_planes[ref - 3].second;      // datums are already world-space
                else
                    return false;
                origin = p.origin;
                normal = p.normal;
                return true;
            };
            bool ok0 = base_plane(f.axis_plane_a, da.origin, da.direction); // direction reused as normal0
            Vec3d origin1, normal1;
            bool ok1 = base_plane(f.axis_plane_b, origin1, normal1);
            if (!ok0 || !ok1) { da.error = _u8L("plane ref not found"); break; }
            // Direction = cross product of the two plane normals.
            Vec3d dir = da.direction.cross(normal1); // da.direction was normal0
            if (dir.squaredNorm() < 1e-18) {
                da.error = _u8L("planes are parallel (no intersection)"); break;
            }
            dir.normalize();
            // Find a point on the intersection line: closest points between two planes.
            // Project origin of plane A onto the intersection line.
            Vec3d n0 = da.direction;   // normal of plane A (stored temporarily)
            Vec3d n1 = normal1;
            Vec3d p0 = da.origin;
            Vec3d p1 = origin1;
            // Solve for point on line of intersection using vector formula.
            double d0 = n0.dot(p0);
            double d1 = n1.dot(p1);
            double n0n1 = n0.dot(n1);
            double det = 1.0 - n0n1 * n0n1;
            if (std::abs(det) < 1e-18) { da.error = _u8L("planes are parallel (no intersection)"); break; }
            double t0 = (d0 - d1 * n0n1) / det;
            double t1 = (d1 - d0 * n0n1) / det;
            da.origin    = n0 * t0 + n1 * t1;
            da.direction = dir;
            break;
        }
        }
        out.push_back(da);
    }
    return out;
}

References _u8L, Slic3r::AlongEdge, Slic3r::Axis, Slic3r::GeometryEngine::CylinderFace::axis, Slic3r::GeometryEngine::CylinderFace::base, bodies, Slic3r::GeometryEngine::cylinder_of_face(), Slic3r::CylinderCenterline, Slic3r::CadDocument::DatumAxis::direction, Slic3r::GeometryEngine::edge_by_index(), Slic3r::CadDocument::DatumAxis::error, Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), Slic3r::GeometryEngine::face_centroid_world(), Slic3r::GeometryEngine::face_normal_world(), Slic3r::FaceNormal, features, modeling_origin, Slic3r::CadDocument::DatumAxis::name, Slic3r::normal(), Slic3r::SketchPlane::normal, Slic3r::GeometryEngine::CylinderFace::ok, Slic3r::CadDocument::DatumAxis::origin, Slic3r::SketchPlane::origin, Slic3r::PlaneIntersection, resolve_datum_planes(), Slic3r::GeometryEngine::sample_edge_world(), Slic3r::TwoPoints, Slic3r::SketchPlane::XY(), Slic3r::SketchPlane::XZ(), and Slic3r::SketchPlane::YZ().

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_axis().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_datum_coordsys()

std::vector< CadDocument::DatumCoordSys > Slic3r::CadDocument::resolve_datum_coordsys

(

)

const

{
    std::vector<DatumCoordSys> out;
    for (const CadFeature& f : features) {
        if (f.type != CadFeatureType::CoordSys || !f.enabled) continue;
        out.push_back(datum_frame(bodies, f));
    }
    return out;
}

References bodies, Slic3r::CoordSys, datum_frame(), Slic3r::f(), and features.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_coordsys().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_datum_planes()

std::vector< std::pair< std::string, SketchPlane > > Slic3r::CadDocument::resolve_datum_planes

(

)

const

{
    std::vector<std::pair<std::string, SketchPlane>> out;
    for (const CadFeature& f : features) {
        if (f.type != CadFeatureType::Plane || !f.enabled) continue;
 
        // Resolve base reference plane. The default XY/XZ/YZ planes pass through the modeling
        // origin (bed centre); datum bases (>=3) are already in world coords from earlier passes.
        SketchPlane base;
        bool base_missing = false;
        if      (f.plane_base == 1) { base = SketchPlane::XZ(); base.origin += modeling_origin; }
        else if (f.plane_base == 2) { base = SketchPlane::YZ(); base.origin += modeling_origin; }
        else if (f.plane_base >= 3) {
            const int di = f.plane_base - 3;
            if (di < int(out.size())) base = out[di].second;
            else {
                // The datum it was built on is gone or hidden. Fall back to XY through the
                // modeling origin like the other defaults, and SAY so in the plane's name —
                // this list is what the GUI shows — instead of quietly becoming world XY.
                base = SketchPlane::XY(); base.origin += modeling_origin;
                base_missing = true;
            }
        }
        else                        { base = SketchPlane::XY(); base.origin += modeling_origin; }
 
        // --- Resolve refs from bodies ---
        auto resolve_face = [&](int body_idx, int face_idx) -> TopoDS_Face {
            if (face_idx < 0 || body_idx < 0 || body_idx >= int(bodies.size()))
                return TopoDS_Face();
            return GeometryEngine::face_by_index(bodies[body_idx].shape, face_idx);
        };
        auto resolve_edge = [&](int body_idx, int edge_idx,
                                 Vec3d& p0, Vec3d& dir) -> bool {
            if (edge_idx < 0 || body_idx < 0 || body_idx >= int(bodies.size()))
                return false;
            TopoDS_Edge e = GeometryEngine::edge_by_index(bodies[body_idx].shape, edge_idx);
            if (e.IsNull()) return false;
            auto pts = GeometryEngine::sample_edge_world(e);
            if (pts.size() < 2) return false;
            p0 = pts.front();
            dir = (pts.back() - pts.front()).normalized();
            return true;
        };
 
        // Face A
        TopoDS_Face faceA = resolve_face(f.plane_face_body, f.plane_face);
        SketchPlane faceA_plane;
        bool has_faceA = false;
        if (!faceA.IsNull()) {
            faceA_plane = frame_from(
                GeometryEngine::face_centroid_world(faceA),
                GeometryEngine::face_normal_world(faceA));
            has_faceA = true;
        }
 
        // Face B
        TopoDS_Face faceB = resolve_face(f.plane_face2_body, f.plane_face2);
        SketchPlane faceB_plane;
        bool has_faceB = false;
        if (!faceB.IsNull()) {
            faceB_plane = frame_from(
                GeometryEngine::face_centroid_world(faceB),
                GeometryEngine::face_normal_world(faceB));
            has_faceB = true;
        }
 
        // Edge A
        Vec3d eA_p0, eA_dir;
        bool has_edgeA = resolve_edge(f.plane_edge_body, f.plane_edge, eA_p0, eA_dir);
 
        // Edge B
        Vec3d eB_p0, eB_dir;
        bool has_edgeB = resolve_edge(f.plane_edge2_body, f.plane_edge2, eB_p0, eB_dir);
 
        // --- Dispatch on plane_type ---
        auto fallback_offset = [&]() {
            return offset_angle_plane(base, f.plane_offset, f.plane_angle_tilt, f.plane_axis);
        };
 
        SketchPlane result;
        switch (f.plane_type) {
 
        case PlaneType::Offset: {
            // From a picked face: pure offset along its normal. From a base/datum plane:
            // offset + the legacy tilt-about-axis (keeps the old Offset/Tilt controls live).
            if (has_faceA)
                result = frame_from(faceA_plane.origin + faceA_plane.normal * f.plane_offset,
                                    faceA_plane.normal);
            else
                result = offset_angle_plane(base, f.plane_offset, f.plane_angle_tilt, f.plane_axis);
            break;
        }
 
        case PlaneType::Coincident: {
            result = has_faceA ? faceA_plane : base;
            break;
        }
 
        case PlaneType::Angle: {
            if (!has_edgeA) { result = fallback_offset(); break; }
            const SketchPlane& ref = has_faceA ? faceA_plane : base;
            Vec3d n0 = ref.normal - eA_dir * ref.normal.dot(eA_dir);
            if (n0.squaredNorm() < 1e-12) {
                Vec3d perp = (std::abs(eA_dir.z()) < 0.9) ? Vec3d(0, 0, 1) : Vec3d(1, 0, 0);
                n0 = perp - eA_dir * perp.dot(eA_dir);
            }
            n0.normalize();
            const double a = f.plane_angle_tilt * M_PI / 180.0;
            Vec3d n_rot = n0 * std::cos(a) + eA_dir.cross(n0) * std::sin(a)
                          + eA_dir * (eA_dir.dot(n0)) * (1.0 - std::cos(a));
            result = frame_from(eA_p0, n_rot);
            break;
        }
 
        case PlaneType::Midplane: {
            if (!has_faceA || !has_faceB) { result = fallback_offset(); break; }
            Vec3d origin = 0.5 * (faceA_plane.origin + faceB_plane.origin);
            Vec3d nB = (faceA_plane.normal.dot(faceB_plane.normal) >= 0)
                           ? faceB_plane.normal : -faceB_plane.normal;
            Vec3d normal = (faceA_plane.normal + nB).normalized();
            result = frame_from(origin, normal);
            break;
        }
 
        case PlaneType::Tangent: {
            if (!has_faceA) { result = fallback_offset(); break; }
            GeometryEngine::CylinderFace cyl = GeometryEngine::cylinder_of_face(faceA);
            if (!cyl.ok) { result = fallback_offset(); break; }
            Vec3d refdir = (std::abs(cyl.axis.z()) < 0.9) ? Vec3d(0, 0, 1) : Vec3d(1, 0, 0);
            refdir = refdir - cyl.axis * refdir.dot(cyl.axis);
            refdir.normalize();
            const double theta = f.plane_angle_tilt * M_PI / 180.0;
            Vec3d r = refdir * std::cos(theta) + cyl.axis.cross(refdir) * std::sin(theta);
            Vec3d touch = cyl.base + r * cyl.radius;
            result = frame_from(touch, r);
            break;
        }
 
        case PlaneType::TwoEdges: {
            if (!has_edgeA) { result = fallback_offset(); break; }
            if (!has_edgeB) { result = fallback_offset(); break; }
            Vec3d cross = eA_dir.cross(eB_dir);
            if (cross.squaredNorm() > 1e-12) {
                result = frame_from(eA_p0, cross.normalized());
            } else {
                Vec3d v = eA_dir.cross(eB_p0 - eA_p0);
                if (v.squaredNorm() > 1e-12) {
                    result = frame_from(eA_p0, v.normalized());
                } else {
                    result = fallback_offset();
                }
            }
            break;
        }
 
        }
 
        // TRN Datum plane entry in the reference plane list. %1% is the plane name.
        out.emplace_back(base_missing ? format(_u8L("%1% (base plane missing)"), f.name) : f.name, result);
    }
    return out;
}

References _u8L, Slic3r::Angle, Slic3r::GeometryEngine::CylinderFace::axis, Slic3r::GeometryEngine::CylinderFace::base, bodies, Slic3r::Coincident, Slic3r::cross(), Slic3r::GeometryEngine::cylinder_of_face(), Slic3r::GeometryEngine::edge_by_index(), Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), Slic3r::GeometryEngine::face_centroid_world(), Slic3r::GeometryEngine::face_normal_world(), features, Slic3r::format(), Slic3r::frame_from(), M_PI, Slic3r::Midplane, modeling_origin, Slic3r::normal(), Slic3r::SketchPlane::normal, Slic3r::Offset, Slic3r::offset_angle_plane(), Slic3r::GeometryEngine::CylinderFace::ok, Slic3r::SketchPlane::origin, Slic3r::perp(), Slic3r::Plane, Slic3r::GeometryEngine::CylinderFace::radius, Slic3r::GeometryEngine::sample_edge_world(), Slic3r::Tangent, Slic3r::TwoEdges, Slic3r::SketchPlane::XY(), Slic3r::SketchPlane::XZ(), and Slic3r::SketchPlane::YZ().

Referenced by resolve_datum_axes().

Here is the call graph for this function:

Here is the caller graph for this function:

route_feature()

void Slic3r::CadDocument::route_feature ( std::vector< CadBody > & bodies, const CadFeature & f ) const

private

{
    if (f.type == CadFeatureType::Plane)   return;   // datum plane: not part of the body pipeline
    if (f.type == CadFeatureType::Axis)    return;   // datum axis
    if (f.type == CadFeatureType::CoordSys) return; // datum coordinate system
    if (f.type == CadFeatureType::Helix)   return;   // helical curve; consumed by Sweep
    if (f.type == CadFeatureType::Boolean) { apply_boolean(bodies, f); return; }   // body-body op
    if (f.type == CadFeatureType::Cut)     { apply_cut(bodies, f);     return; }   // plane-split body
    if (f.type == CadFeatureType::Mirror)  { apply_mirror(bodies, f);  return; }   // mirror body about plane
    if (f.type == CadFeatureType::Transform) { apply_transform(bodies, f); return; }   // move/rotate body
    if (f.type == CadFeatureType::Mate)     { apply_mate(bodies, f);     return; }   // assembly mate
    if (f.type == CadFeatureType::Thicken) { apply_thicken(bodies, f); return; }   // face -> plate
    if (f.type == CadFeatureType::ThickenSurface) { apply_thicken_surface(bodies, f); return; }
    if (f.type == CadFeatureType::SurfaceOffset) { apply_surface_offset(bodies, f); return; }
    if (f.type == CadFeatureType::Project) return;   // sketch-like: consumed downstream, no body
    // Resolve the target body: explicit target_body when valid, else the last body.
    const int t = pick_body(f.target_body, int(bodies.size()));
    const TopoDS_Shape context = (t >= 0) ? bodies[t].shape : TopoDS_Shape();
    // A New extrude (or the very first solid feature) starts a fresh body; everything else
    // mutates the target body in place.
    const bool starts_new = bodies.empty()
        || f.type == CadFeatureType::Import   // an imported solid is always its own base body
        || f.type == CadFeatureType::SurfaceExtrude || f.type == CadFeatureType::SurfaceRevolve
        || f.type == CadFeatureType::ThickenSurface || f.type == CadFeatureType::SurfaceOffset
        || f.type == CadFeatureType::SurfaceLoft || f.type == CadFeatureType::SurfaceFill
        || ((f.type == CadFeatureType::Extrude || f.type == CadFeatureType::Revolve
             || f.type == CadFeatureType::Sweep || f.type == CadFeatureType::Loft)
            && f.mode == BooleanMode::New);
 
    if (starts_new) {
        TopoDS_Shape result;            // empty -> apply_feature fills it (New path)
        bool have_body = false;
        apply_feature(result, have_body, context, f);
        if (have_body && !result.IsNull())
            bodies.push_back({ result, f.name.empty() ? _u8L("Body") : f.name });
    } else {
        if (t < 0) throw std::runtime_error(_u8L("feature needs a body"));
        TopoDS_Shape result = bodies[t].shape;   // shallow handle; apply_feature mutates it
        bool have_body = true;
        // A subtraction whose tool misses the target is a legal boolean that removes nothing, so
        // OCCT reports IsDone() and the feature lands in the recipe reporting success. A caller —
        // an agent especially — then has no signal at all that the hole it asked for was never
        // drilled: same body, same volume, ok:true. Measure the volume across the op and refuse
        // the no-op. Only for removals: every other feature type may legitimately leave the volume
        // alone (a Transform certainly does). daf.
        const bool removes = f.type == CadFeatureType::Hole
                          || f.type == CadFeatureType::Thread
                          || ((f.type == CadFeatureType::Extrude || f.type == CadFeatureType::Revolve
                               || f.type == CadFeatureType::Sweep  || f.type == CadFeatureType::Loft)
                              && f.mode == BooleanMode::Cut);
        const double before = removes ? solid_volume(result) : 0.0;
        apply_feature(result, have_body, context, f);
        if (removes && before > 0.0) {
            const double after = solid_volume(result);
            // Relative tolerance: a cut that shaves a numerically invisible sliver is a miss too,
            // and an absolute epsilon would be wrong across the mm-to-metre range of real parts.
            if (after >= before - 1e-9 * std::max(1.0, before))
                throw std::runtime_error(
                    f.type == CadFeatureType::Hole ?
                        _u8L("hole removed no material — the tool does not intersect the target body"
                             " (coordinates are in the sketch plane's frame, not world)") :
                    f.type == CadFeatureType::Thread ?
                        _u8L("thread removed no material — the tool does not intersect the target body"
                             " (coordinates are in the sketch plane's frame, not world)") :
                        _u8L("cut removed no material — the tool does not intersect the target body"
                             " (coordinates are in the sketch plane's frame, not world)"));
        }
        bodies[t].shape = result;
    }
}

References _u8L, apply_boolean(), apply_cut(), apply_feature(), apply_mate(), apply_mirror(), apply_surface_offset(), apply_thicken(), apply_thicken_surface(), apply_transform(), Slic3r::Axis, bodies, Slic3r::Boolean, Slic3r::CoordSys, Slic3r::Cut, Slic3r::Extrude, Slic3r::f(), Slic3r::Helix, Slic3r::Hole, Slic3r::Import, Slic3r::Loft, Slic3r::Mate, Slic3r::Mirror, Slic3r::New, Slic3r::pick_body(), Slic3r::Plane, Slic3r::Project, Slic3r::Revolve, Slic3r::solid_volume(), Slic3r::SurfaceExtrude, Slic3r::SurfaceFill, Slic3r::SurfaceLoft, Slic3r::SurfaceOffset, Slic3r::SurfaceRevolve, Slic3r::Sweep, Slic3r::Thicken, Slic3r::ThickenSurface, Slic3r::Thread, and Slic3r::Transform.

Referenced by preview(), and replay_feature().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize_recipe()

std::string Slic3r::CadDocument::serialize_recipe

(

)

const

{
    std::ostringstream oss;
    {
        cereal::BinaryOutputArchive ar(oss);
        uint32_t v = ORCA_CAD_RECIPE_VERSION;
        ar(v);
        uint32_t n = static_cast<uint32_t>(features.size());
        ar(n);
        for (const CadFeature& f : features) {
            std::ostringstream fos;
            {
                cereal::BinaryOutputArchive fa(fos);
                fa(f);
            }
            std::string fb = fos.str();
            uint32_t len = static_cast<uint32_t>(fb.size());
            ar(len);
            ar(cereal::binary_data(fb.data(), fb.size()));
        }
        std::ostringstream vos;
        {
            cereal::BinaryOutputArchive va(vos);
            va(variables);
        }
        std::string vb = vos.str();
        uint32_t vlen = static_cast<uint32_t>(vb.size());
        ar(vlen);
        ar(cereal::binary_data(vb.data(), vb.size()));
        // BODY NAMES, appended after the variables block. Bodies are not serialised — they are
        // recomputed — so a name the user gave one has nowhere else to live, and without this it
        // would survive a recompute (see the carry-over in recompute()) but not a save.
        //
        // APPENDED RATHER THAN VERSION-BUMPED, on purpose: a build that predates this block
        // reads features and variables, returns, and never looks at the trailing bytes, so its
        // projects still open here AND this build's projects still open there. A version bump
        // would have made every project written today unreadable by yesterday's build for the
        // sake of one optional field. Written as (index, name) pairs so an unnamed body costs
        // nothing.
        // A map, not a vector of pairs: cereal's map support is already included here and its
        // pair support is not, and one more include for one more field is not worth it.
        std::map<uint32_t, std::string> named;
        for (uint32_t i = 0; i < bodies.size(); ++i)
            if (bodies[i].has_user_name && !bodies[i].user_name.empty())
                named[i] = bodies[i].user_name;
        std::ostringstream bos;
        {
            cereal::BinaryOutputArchive ba(bos);
            ba(named);
        }
        std::string bb = bos.str();
        uint32_t blen = static_cast<uint32_t>(bb.size());
        ar(blen);
        ar(cereal::binary_data(bb.data(), bb.size()));
        // DOCUMENT EXTRAS, appended after the body names on the same terms (older builds stop
        // reading before it): the modeling origin, and the body colours. A colour set with the
        // Color tool used to live only until the project was closed.
        std::map<uint32_t, std::array<float, 4>> colours;
        for (uint32_t i = 0; i < bodies.size(); ++i)
            if (bodies[i].has_color)
                colours[i] = { bodies[i].color.r(), bodies[i].color.g(), bodies[i].color.b(), bodies[i].color.a() };
        std::ostringstream xos;
        {
            cereal::BinaryOutputArchive xa(xos);
            xa(modeling_origin.x(), modeling_origin.y(), modeling_origin.z(), colours, auto_close_loops);
        }
        std::string xb = xos.str();
        uint32_t xlen = static_cast<uint32_t>(xb.size());
        ar(xlen);
        ar(cereal::binary_data(xb.data(), xb.size()));
    }
    return oss.str();
}

References auto_close_loops, bodies, Slic3r::f(), features, modeling_origin, ORCA_CAD_RECIPE_VERSION, and variables.

Here is the call graph for this function:

set_feature_enabled()

bool Slic3r::CadDocument::set_feature_enabled	(	int	index,
		bool	enabled )

{
    if (index < 0 || index >= int(features.size())) return false;
    if (features[index].enabled == enabled) return true;
    std::vector<CadFeature> snapshot = features;
    stage_history_change(features, [](int i) { return i; },
        [this, index, enabled](int i) { return i == index ? enabled : features[i].enabled; });
    features[index].enabled = enabled;
    return commit_or_rollback(*this, snapshot);
}

References Slic3r::commit_or_rollback(), features, and Slic3r::stage_history_change().

Here is the call graph for this function:

solve_sketch_feature()

bool Slic3r::CadDocument::solve_sketch_feature

(

int

index

)

{
    if (index < 0 || index >= int(features.size())) return false;
    CadFeature& f = features[index];
    if (f.type != CadFeatureType::Sketch) return false;
 
    // Onshape-style entity sketches solve against entity endpoints (Fase 4.2).
    if (!f.entities.empty())
        return solve_sketch_entities(f.entities, f.entity_constraints);
 
    if (f.constraints.empty()) return true;
 
    // Legacy point-profile path. Every index is checked before the solver sees it: an unset
    // (-1) or stale index made get_point/residuals read m_vars[2*-1]. A constraint type this
    // solver cannot express is a failure, not a silent no-op, and the points are written back
    // only when the solve succeeded — the entity path's rule (SketchSolver.cpp) too.
    const int np = int(f.profile.points.size());
    auto ok_idx = [np](std::initializer_list<int> ids) {
        for (int i : ids) if (i < 0 || i >= np) return false;
        return true;
    };
    SketchConstraints sc;
    for (const Vec2d& p : f.profile.points)
        sc.add_point(p.x(), p.y());
 
    for (const SketchConstraintDef& c : f.constraints) {
        bool valid = true;
        switch (c.type) {
        case SketchConstraintType::Fix:          if ((valid = ok_idx({c.a}))) sc.fix_point(c.a); break;
        case SketchConstraintType::Coincident:   if ((valid = ok_idx({c.a, c.b}))) sc.coincident(c.a, c.b); break;
        case SketchConstraintType::Horizontal:   if ((valid = ok_idx({c.a, c.b}))) sc.horizontal(c.a, c.b); break;
        case SketchConstraintType::Vertical:     if ((valid = ok_idx({c.a, c.b}))) sc.vertical(c.a, c.b); break;
        case SketchConstraintType::Distance:     if ((valid = ok_idx({c.a, c.b}))) sc.distance(c.a, c.b, c.value); break;
        case SketchConstraintType::LockX:        if ((valid = ok_idx({c.a}))) sc.lock_x(c.a, c.value); break;
        case SketchConstraintType::LockY:        if ((valid = ok_idx({c.a}))) sc.lock_y(c.a, c.value); break;
        case SketchConstraintType::EqualLength:  if ((valid = ok_idx({c.a, c.b, c.c, c.d}))) sc.equal_length(c.a, c.b, c.c, c.d); break;
        case SketchConstraintType::Parallel:     if ((valid = ok_idx({c.a, c.b, c.c, c.d}))) sc.parallel(c.a, c.b, c.c, c.d); break;
        case SketchConstraintType::Perpendicular:if ((valid = ok_idx({c.a, c.b, c.c, c.d}))) sc.perpendicular(c.a, c.b, c.c, c.d); break;
        // The legacy solver implements these too; they used to be dropped without a word.
        case SketchConstraintType::Midpoint:     if ((valid = ok_idx({c.a, c.b, c.c}))) sc.midpoint(c.a, c.b, c.c); break;
        case SketchConstraintType::Symmetric:    if ((valid = ok_idx({c.a, c.b, c.c, c.d}))) sc.symmetric(c.a, c.b, c.c, c.d); break;
        case SketchConstraintType::Angle:        if ((valid = ok_idx({c.a, c.b, c.c, c.d}))) sc.angle(c.a, c.b, c.c, c.d, c.value); break;
        case SketchConstraintType::PointOnLine:  if ((valid = ok_idx({c.a, c.b, c.c}))) sc.point_line_distance(c.a, c.b, c.c, c.value); break;
        default:                                 valid = false; break;   // entity-only types
        }
        if (!valid) return false;
    }
 
    if (!sc.solve()) return false;
    for (size_t i = 0; i < f.profile.points.size(); ++i)
        f.profile.points[i] = sc.get_point(int(i));
    return true;
}

References Slic3r::SketchConstraintDef::a, Slic3r::SketchConstraints::add_point(), Slic3r::Angle, Slic3r::SketchConstraints::angle(), Slic3r::SketchConstraintDef::b, Slic3r::SketchConstraintDef::c, Slic3r::Coincident, Slic3r::SketchConstraints::coincident(), Slic3r::SketchConstraintDef::d, Slic3r::Distance, Slic3r::SketchConstraints::distance(), Slic3r::SketchConstraints::equal_length(), Slic3r::EqualLength, Slic3r::f(), features, Slic3r::Fix, Slic3r::SketchConstraints::fix_point(), Slic3r::SketchConstraints::get_point(), Slic3r::Horizontal, Slic3r::SketchConstraints::horizontal(), Slic3r::SketchConstraints::lock_x(), Slic3r::SketchConstraints::lock_y(), Slic3r::LockX, Slic3r::LockY, Slic3r::Midpoint, Slic3r::SketchConstraints::midpoint(), Slic3r::Parallel, Slic3r::SketchConstraints::parallel(), Slic3r::Perpendicular, Slic3r::SketchConstraints::perpendicular(), Slic3r::SketchConstraints::point_line_distance(), Slic3r::PointOnLine, Slic3r::Sketch, Slic3r::SketchConstraints::solve(), Slic3r::solve_sketch_entities(), Slic3r::Symmetric, Slic3r::SketchConstraints::symmetric(), Slic3r::SketchConstraintDef::type, Slic3r::SketchConstraintDef::value, Slic3r::Vertical, and Slic3r::SketchConstraints::vertical().

Here is the call graph for this function:

undo()

bool Slic3r::CadDocument::undo

(

)

{
    if (m_undo.empty())
        return false;
    m_redo.push_back(Snapshot{std::move(features), std::move(variables)});   // current state becomes redoable
    features  = std::move(m_undo.back().features);
    variables = std::move(m_undo.back().variables);
    m_undo.pop_back();
    recompute();   // benign-empty (only a sketch / empty doc) is a valid undo target
    return true;
}

References features, m_redo, m_undo, recompute(), and variables.

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_boolean(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_bridge(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_chamfer(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_delete_face(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_draft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_fillet(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_standard(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_styled(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mate(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mirror(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_pattern(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_project(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_rib(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_feature_expr(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_variable(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_shell(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_split(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_fill(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_loft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_offset(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken_surface(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_transform(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_mesh(), and Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_step().

Here is the call graph for this function:

Here is the caller graph for this function:

undo_depth()

size_t Slic3r::CadDocument::undo_depth ( ) const

inline

{ return m_undo.size(); }

References m_undo.

Member Data Documentation

angular_deflection

double Slic3r::CadDocument::angular_deflection {0.5}

{0.5};

Referenced by preview(), and recompute().

auto_close_loops

bool Slic3r::CadDocument::auto_close_loops {true}

{true};

Referenced by clear(), deserialize_recipe(), faces_made_by(), recompute(), and serialize_recipe().

bodies

std::vector<CadBody> Slic3r::CadDocument::bodies

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_boolean(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_bridge(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_chamfer(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_delete_face(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_draft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_fillet(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_helix(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_standard(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_styled(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mate(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mirror(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_pattern(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_project(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_rib(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_shell(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_split(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_fill(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_loft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_offset(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken_surface(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_transform(), apply_boolean(), apply_cut(), apply_mate(), apply_mirror(), apply_project(), apply_surface_offset(), apply_thicken(), apply_thicken_surface(), apply_transform(), body_mass_properties(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::body_shape(), body_touching_sketch(), check_interference(), clear(), Slic3r::commit_or_rollback(), datum_frame(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::describe_scene(), deserialize_recipe(), export_step(), faces_made_by(), Slic3r::GUI::DesignPanel::fill_body_choice(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_mesh(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_step(), mate_options(), plane_of_face(), Slic3r::GUI::DesignPanel::populate_body_choices(), preview(), project_edges_into_sketch(), recompute(), resolve_datum_axes(), resolve_datum_coordsys(), resolve_datum_planes(), route_feature(), serialize_recipe(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::target_body_arg(), and Slic3r::GUI::anonymous_namespace{McpControl.cpp}::validate_against().

body

TopoDS_Shape Slic3r::CadDocument::body

Referenced by clear(), Slic3r::commit_or_rollback(), and recompute().

display_body_meshes

std::vector<TriangleMesh> Slic3r::CadDocument::display_body_meshes

Referenced by clear(), Slic3r::commit_or_rollback(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::describe_scene(), recompute(), and Slic3r::GUI::DesignPanel::refresh_preview().

display_mesh

TriangleMesh Slic3r::CadDocument::display_mesh

Referenced by clear(), Slic3r::commit_or_rollback(), and recompute().

display_tri_body

std::vector<int> Slic3r::CadDocument::display_tri_body

Referenced by clear(), Slic3r::commit_or_rollback(), and recompute().

display_tri_face

std::vector<int> Slic3r::CadDocument::display_tri_face

Referenced by clear(), Slic3r::commit_or_rollback(), and recompute().

error

std::string Slic3r::CadDocument::error

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_axis(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_boolean(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_bridge(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_chamfer(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_coordsys(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_delete_face(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_draft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_fillet(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_helix(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_standard(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_styled(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mate(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mirror(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_pattern(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_project(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_rib(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_feature_expr(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_variable(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_shell(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_split(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_fill(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_loft(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_offset(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_revolve(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken_surface(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_transform(), clear(), Slic3r::commit_or_rollback(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::describe_scene(), deserialize_recipe(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_mesh(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_step(), move_feature(), recompute(), and Slic3r::GUI::DesignPanel::refresh_preview().

features

std::vector<CadFeature> Slic3r::CadDocument::features

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_axis(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_chamfer(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_coordsys(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_fillet(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mirror(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_pattern(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_feature_expr(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_commit(), add_axis(), add_boolean(), add_bridge(), add_chamfer(), add_chamfer(), add_chamfer(), add_coordsys(), add_cut(), add_delete_face(), add_draft(), add_extrude(), add_extrude_entities(), add_extrude_face(), add_fillet(), add_fillet(), add_fillet(), add_helix(), add_hole(), add_hole_styled(), add_loft(), add_mate(), add_mirror(), add_pattern(), add_pattern_on_curve(), add_plane(), add_project_edges(), add_revolve(), add_revolve_entities(), add_rib(), add_shell(), add_sketch(), add_sketch_entities(), add_sketch_profile(), add_split_by_face(), add_surface_extrude(), add_surface_fill(), add_surface_loft(), add_surface_offset(), add_surface_revolve(), add_sweep(), add_thicken(), add_thicken_surface(), add_thread(), add_transform(), apply_feature(), apply_mate(), bind_expressions(), body_touching_sketch(), checkpoint(), clear(), Slic3r::commit_or_rollback(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::describe_scene(), deserialize_recipe(), detect_mate_conflicts(), faces_made_by(), Slic3r::GUI::DesignPanel::fill_body_choice(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_mesh(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_step(), mate_options(), move_feature(), Slic3r::GUI::DesignPanel::populate_body_choices(), project_edges_into_sketch(), recompute(), redo(), remove_feature(), replace_feature(), replace_sketch_extrude(), replay_feature(), resolve_datum_axes(), resolve_datum_coordsys(), resolve_datum_planes(), serialize_recipe(), set_feature_enabled(), solve_sketch_feature(), and undo().

k_undo_cap

size_t Slic3r::CadDocument::k_undo_cap = 200

staticconstexprprivate

Referenced by checkpoint().

linear_deflection

double Slic3r::CadDocument::linear_deflection {0.003}

{0.003};

Referenced by preview(), and recompute().

m_redo

std::vector<Snapshot> Slic3r::CadDocument::m_redo

private

Referenced by can_redo(), checkpoint(), clear(), redo(), redo_depth(), and undo().

m_undo

std::vector<Snapshot> Slic3r::CadDocument::m_undo

private

Referenced by abandon_checkpoint(), can_undo(), checkpoint(), clear(), redo(), undo(), and undo_depth().

mate_conflicts

std::vector<std::pair<int, std::string> > Slic3r::CadDocument::mate_conflicts

Referenced by clear(), detect_mate_conflicts(), and recompute().

modeling_origin

Vec3d Slic3r::CadDocument::modeling_origin {Vec3d::Zero()}

{Vec3d::Zero()};

Referenced by add_pattern(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::describe_scene(), deserialize_recipe(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::plane_from(), resolve_datum_axes(), resolve_datum_planes(), and serialize_recipe().

ORCA_CAD_RECIPE_VERSION

uint32_t Slic3r::CadDocument::ORCA_CAD_RECIPE_VERSION = 6

staticconstexpr

Referenced by deserialize_recipe(), and serialize_recipe().

origin_from_recipe

bool Slic3r::CadDocument::origin_from_recipe {false}

{false};   // modeling_origin came from the loaded project

Referenced by clear(), and deserialize_recipe().

topo_generation

uint64_t Slic3r::CadDocument::topo_generation {1}

{1};

Referenced by clear(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::describe_scene(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::handle_on_main(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::query_topology(), and recompute().

variables

std::map<std::string, std::string> Slic3r::CadDocument::variables

Referenced by Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_variable(), bind_expressions(), checkpoint(), clear(), deserialize_recipe(), faces_made_by(), redo(), serialize_recipe(), and undo().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/CAD/CadDocument.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/CAD/CadDocument.cpp