Slic3r::GUI::anonymous_namespace{McpControl.cpp} Namespace Reference

Classes
struct	ShapeMetrics

Functions
const char *	feature_type_name (CadFeatureType t)
std::string	rpc_result (const json &id, const json &result)
std::string	rpc_error (const json &id, int code, const std::string &msg)
json	describe_tools ()
json	describe_scene (DesignPanel *panel)
json	vec3 (const Vec3d &v)
SketchPlane	plane_from (const json &params, const CadDocument &doc)
BooleanMode	bool_from (const std::string &s)
bool	profile_from (const json &params, SketchProfile &out)
const TopoDS_Shape &	body_shape (DesignPanel *panel, const json &params)
json	query_topology (DesignPanel *panel, const json &params)
bool	resolve_ref (const TopoDS_Shape &shape, const json &ref, Vec3d &point, Vec3d &dir, bool &has_dir)
json	measure (DesignPanel *panel, const json &params)
json	mass_properties (DesignPanel *panel, const json &params)
std::vector< std::pair< std::vector< Vec3d >, bool > >	chain_segments (std::vector< std::vector< Vec3d > > segs, double tol)
json	slice_body (DesignPanel *panel, const json &params)
json	import_step (DesignPanel *panel, const json &params)
json	import_mesh (DesignPanel *panel, const json &params)
ShapeMetrics	shape_metrics (const TopoDS_Shape &s)
json	validate_against (DesignPanel *panel, const json &params)
json	action_extrude (DesignPanel *panel, const json &params)
json	action_revolve (DesignPanel *panel, const json &params)
int	target_body_arg (const json &params, const CadDocument &doc)
std::vector< int >	edge_ids_arg (const json &params, const char *verb)
json	action_fillet (DesignPanel *panel, const json &params)
json	action_chamfer (DesignPanel *panel, const json &params)
json	action_hole (DesignPanel *panel, const json &params)
json	action_hole_styled (DesignPanel *panel, const json &params)
json	action_hole_standard (DesignPanel *panel, const json &params)
json	action_boolean (DesignPanel *panel, const json &params)
json	action_pattern (DesignPanel *panel, const json &params)
json	action_pattern_on_curve (DesignPanel *panel, const json &params)
json	action_shell (DesignPanel *panel, const json &params)
json	action_rib (DesignPanel *panel, const json &params)
json	action_surface_extrude (DesignPanel *panel, const json &params)
json	action_surface_revolve (DesignPanel *panel, const json &params)
json	action_thicken_surface (DesignPanel *panel, const json &params)
json	action_surface_offset (DesignPanel *panel, const json &params)
json	action_surface_loft (DesignPanel *panel, const json &params)
json	action_surface_fill (DesignPanel *panel, const json &params)
json	action_draft (DesignPanel *panel, const json &params)
DesignSketchTool &	mcp_sketch (DesignPanel *panel)
SketchEntity	sketch_entity_from (const json &j)
json	sketch_entity_to (const SketchEntity &e, int index)
std::vector< int >	sketch_targets (const json &params, DesignSketchTool &t, bool all_if_empty)
json	action_sketch_begin (DesignPanel *panel, const json &params)
json	action_sketch_commit (DesignPanel *panel, const json &params)
json	action_sketch_cancel (DesignPanel *panel, const json &params)
json	action_sketch_add (DesignPanel *panel, const json &params)
json	action_sketch_select (DesignPanel *panel, const json &params)
json	action_sketch_delete (DesignPanel *panel, const json &params)
json	action_sketch_construction (DesignPanel *panel, const json &params)
json	action_sketch_offset (DesignPanel *panel, const json &params)
json	action_sketch_mirror (DesignPanel *panel, const json &params)
json	sketch_report (DesignSketchTool &t)
json	action_sketch_describe (DesignPanel *panel, const json &params)
json	action_sketch_validate (DesignPanel *panel, const json &params)
json	action_sketch_heal (DesignPanel *panel, const json &params)
json	action_sketch_set_value (DesignPanel *panel, const json &params)
bool	verb_is_modal (const char *id)
json	action_list_verbs (DesignPanel *panel, const json &params)
json	action_run_verb (DesignPanel *panel, const json &params)
json	action_mirror (DesignPanel *panel, const json &params)
json	action_transform (DesignPanel *panel, const json &params)
json	action_thicken (DesignPanel *panel, const json &params)
json	action_split (DesignPanel *panel, const json &params)
json	action_project (DesignPanel *panel, const json &params)
json	action_delete_face (DesignPanel *panel, const json &params)
json	action_bridge (DesignPanel *panel, const json &params)
json	action_axis (DesignPanel *panel, const json &params)
json	action_coordsys (DesignPanel *panel, const json &params)
json	action_helix (DesignPanel *panel, const json &params)
json	action_mate (DesignPanel *panel, const json &params)
json	action_check_interference (DesignPanel *panel, const json &params)
json	action_set_variable (DesignPanel *panel, const json &params)
json	action_set_feature_expr (DesignPanel *panel, const json &params)
std::string	handle_on_main (const std::string &method, const json &params, const json &id)
std::string	dispatch_request (const std::string &line)
void	serve_client (int cfd)
void	remove_socket_at_exit ()
void	server_thread (std::string sock_path)

Variables
std::string	g_sock_path

---

Class Documentation

Slic3r::GUI::anonymous_namespace{McpControl.cpp}::ShapeMetrics

struct Slic3r::GUI::anonymous_namespace{McpControl.cpp}::ShapeMetrics

Class Members
Vec3d	bmax
Vec3d	bmin
Vec3d	centroid
double	volume

Function Documentation

action_axis()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_axis	(	DesignPanel *	panel,
		const json &	params )

{
    CadDocument& doc = panel->mcp_doc();
    std::string t = params.value("type", std::string("two_points"));
    AxisType at = AxisType::TwoPoints;
    if (t == "face_normal")        at = AxisType::FaceNormal;
    else if (t == "cylinder")      at = AxisType::CylinderCenterline;
    else if (t == "plane_intersection") at = AxisType::PlaneIntersection;
    else if (t == "along_edge")    at = AxisType::AlongEdge;
    doc.checkpoint();
    int idx = doc.add_axis(at, "Axis");
    CadFeature& f = doc.features[idx];
    if (params.contains("p1") && params["p1"].is_array() && params["p1"].size() >= 3)
        f.axis_p1 = Vec3d(params["p1"][0].get<double>(), params["p1"][1].get<double>(), params["p1"][2].get<double>());
    if (params.contains("p2") && params["p2"].is_array() && params["p2"].size() >= 3)
        f.axis_p2 = Vec3d(params["p2"][0].get<double>(), params["p2"][1].get<double>(), params["p2"][2].get<double>());
    f.axis_body     = params.value("body", -1);
    f.axis_face     = params.value("face", -1);
    f.axis_edge     = params.value("edge", -1);
    f.axis_plane_a  = params.value("plane_a", -1);
    f.axis_plane_b  = params.value("plane_b", -1);
    // Datum features don't produce a body; check for an error returned by resolve.
    bool recompute_ok = doc.recompute();
    auto axes = doc.resolve_datum_axes();
    std::string err = doc.error;
    if (recompute_ok && err.empty() && !axes.empty() && !axes.back().error.empty())
        err = axes.back().error;
    panel->mcp_after_change();
    return json{{"ok", true}, {"axis_index", idx}, {"error", err}};
}

References action_axis(), Slic3r::CadDocument::add_axis(), Slic3r::AlongEdge, Slic3r::CadDocument::checkpoint(), Slic3r::CylinderCenterline, Slic3r::CadDocument::error, Slic3r::f(), Slic3r::FaceNormal, Slic3r::CadDocument::features, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::PlaneIntersection, Slic3r::CadDocument::recompute(), Slic3r::CadDocument::resolve_datum_axes(), and Slic3r::TwoPoints.

Referenced by action_axis(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_boolean()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_boolean	(	DesignPanel *	panel,
		const json &	params )

{
    BooleanMode m = bool_from(params.value("op", std::string("subtract")));
    if (m == BooleanMode::New) throw std::runtime_error("op must be union | subtract | intersect");
    const int target = params.value("target", 0);
    const int tool   = params.value("tool", 1);
    const bool keep  = params.value("keep_tool", false);
    const double tol = params.value("tolerance", 0.0);
    CadDocument& doc = panel->mcp_doc();
    int n = int(doc.bodies.size());
    if (target < 0 || target >= n || tool < 0 || tool >= n)
        throw std::runtime_error("target/tool body index out of range (have " + std::to_string(n) + ")");
    if (target == tool) throw std::runtime_error("target and tool must differ");
    doc.checkpoint();
    int b = doc.add_boolean(m, target, tool, keep, tol, -1, -1, "Boolean");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"boolean_index", b}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_boolean(), Slic3r::CadDocument::add_boolean(), Slic3r::CadDocument::bodies, bool_from(), Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::New, Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_boolean(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_bridge()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_bridge	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("sketch")) throw std::runtime_error("bridge needs 'sketch' (feature index)");
    if (!params.contains("ent_a"))  throw std::runtime_error("bridge needs 'ent_a' (entity index)");
    if (!params.contains("ent_b"))  throw std::runtime_error("bridge needs 'ent_b' (entity index)");
    int sketch = params["sketch"].get<int>();
    int ent_a  = params["ent_a"].get<int>();
    int ent_b  = params["ent_b"].get<int>();
    int end_a  = params.value("end_a", 1);
    int end_b  = params.value("end_b", 0);
    CadDocument& doc = panel->mcp_doc();
    doc.checkpoint();
    int ei = doc.add_bridge(sketch, ent_a, end_a, ent_b, end_b, "Bridge");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"sketch_index", sketch}, {"entity_index", ei},
                {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_bridge(), Slic3r::CadDocument::add_bridge(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_bridge(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_chamfer()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_chamfer	(	DesignPanel *	panel,
		const json &	params )

{
    const std::vector<int> edges = edge_ids_arg(params, "chamfer");
    const double dist = params.value("distance", 1.0);
    if (dist <= 0) throw std::runtime_error("distance must be > 0");
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to chamfer");
    int bi = target_body_arg(params, doc);
    doc.checkpoint();
    int c = doc.add_chamfer(dist, edges, "Chamfer");
    if (bi >= 0) doc.features[c].target_body = bi;   // edge id resolved against THIS body's shape
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"chamfer_index", c}, {"body", bi < 0 ? int(doc.bodies.size()) - 1 : bi},
                {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_chamfer(), Slic3r::CadDocument::add_chamfer(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::Geometry::dist(), edge_ids_arg(), Slic3r::CadDocument::error, Slic3r::CadDocument::features, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_chamfer(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_check_interference()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_check_interference	(	DesignPanel *	panel,
		const json &	params )

{
    const double min_volume = params.value("min_volume", 1e-6);
    CadDocument& doc = panel->mcp_doc();
    // Read-only: no checkpoint(), no recompute(), no mcp_after_change().
    const auto hits = doc.check_interference(min_volume);
    json arr = json::array();
    for (const auto& h : hits) {
        arr.push_back(json{{"body_a", h.body_a}, {"body_b", h.body_b}, {"volume", h.volume}});
    }
    return json{{"ok", true}, {"count", int(hits.size())}, {"interferences", arr}};
}

References action_check_interference(), Slic3r::CadDocument::check_interference(), and Slic3r::GUI::DesignPanel::mcp_doc().

Referenced by action_check_interference(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_coordsys()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_coordsys	(	DesignPanel *	panel,
		const json &	params )

{
    CadDocument& doc = panel->mcp_doc();
    std::string t = params.value("type", std::string("point_world"));
    CoordSysType ct = CoordSysType::PointWorld;
    if (t == "face_and_direction") ct = CoordSysType::FaceAndDirection;
    Vec3d pt(0, 0, 0);
    if (params.contains("point") && params["point"].is_array() && params["point"].size() >= 3)
        pt = Vec3d(params["point"][0].get<double>(), params["point"][1].get<double>(), params["point"][2].get<double>());
    doc.checkpoint();
    int idx = doc.add_coordsys(ct, pt, "CoordSys");
    CadFeature& f = doc.features[idx];
    f.coordsys_body  = params.value("body", -1);
    f.coordsys_face  = params.value("face", -1);
    f.coordsys_edge  = params.value("edge", -1);
    if (params.contains("x_hint") && params["x_hint"].is_array() && params["x_hint"].size() >= 3)
        f.coordsys_x_hint = Vec3d(params["x_hint"][0].get<double>(), params["x_hint"][1].get<double>(), params["x_hint"][2].get<double>());
    bool recompute_ok = doc.recompute();
    auto css = doc.resolve_datum_coordsys();
    std::string err = doc.error;
    if (recompute_ok && err.empty() && !css.empty() && !css.back().error.empty())
        err = css.back().error;
    panel->mcp_after_change();
    return json{{"ok", true}, {"coordsys_index", idx}, {"error", err}};
}

References action_coordsys(), Slic3r::CadDocument::add_coordsys(), Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::f(), Slic3r::FaceAndDirection, Slic3r::CadDocument::features, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::PointWorld, Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::resolve_datum_coordsys().

Referenced by action_coordsys(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_delete_face()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_delete_face	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("faces")) throw std::runtime_error("delete_face needs 'faces' (array of face ids)");
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to delete faces from");
    int bi = target_body_arg(params, doc);
    std::vector<int> faces;
    if (params["faces"].is_array())
        for (const auto& v : params["faces"]) faces.push_back(v.get<int>());
    doc.checkpoint();
    int idx = doc.add_delete_face(bi, faces, "DeleteFace");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"feature_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_delete_face(), Slic3r::CadDocument::add_delete_face(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_delete_face(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_draft()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_draft	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("face")) throw std::runtime_error("draft needs 'face' (id from query_topology)");
    const double angle = params.value("angle", 5.0);
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to draft");
    int bi = target_body_arg(params, doc);
    doc.checkpoint();
    int d = doc.add_draft(angle, params["face"].get<int>(), bi, "Draft");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"draft_index", d}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_draft(), Slic3r::CadDocument::add_draft(), Slic3r::angle(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_draft(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_extrude()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_extrude	(	DesignPanel *	panel,
		const json &	params )

{
    const double d = params.value("distance", 10.0);
    if (d <= 0) throw std::runtime_error("distance must be > 0");
    CadDocument& doc = panel->mcp_doc();
    SketchPlane pl = plane_from(params, doc);
    BooleanMode mode = bool_from(params.value("boolean", std::string("new")));
 
    SketchProfile prof;
    bool has_prof = profile_from(params, prof);
    double w = 0, h = 0;
    if (!has_prof) {
        w = params.value("width", 20.0); h = params.value("height", 20.0);
        if (w <= 0 || h <= 0) throw std::runtime_error("width and height must be > 0");
    }
    doc.checkpoint();
    int s = has_prof ? doc.add_sketch_profile(prof, pl, "Sketch")
                     : doc.add_sketch(SketchShape::Rectangle, pl, w, h, 0.0, "Sketch");
    int e = doc.add_extrude(s, d, /*symmetric*/false, mode, "Extrude");
    // End condition (Onshape parity). apply reads extrude_end directly; the kernel `symmetric`
    // bool is unused, so set the field here. up_to_face id comes from query_topology on the
    // target (last) body. taper_deg lofts the side wall; flip negates the direction.
    const std::string end = params.value("end", std::string("blind"));
    CadFeature& fe = doc.features[e];
    fe.flip      = params.value("flip", false);
    fe.taper_deg = params.value("taper", 0.0);
    if      (end == "symmetric")   fe.extrude_end = ExtrudeEnd::Symmetric;
    else if (end == "two_sided")  { fe.extrude_end = ExtrudeEnd::TwoSided; fe.distance2 = params.value("distance2", d); }
    else if (end == "through_all")  fe.extrude_end = ExtrudeEnd::ThroughAll;
    else if (end == "up_to_face")  { fe.extrude_end = ExtrudeEnd::UpToFace; fe.up_to_face = params.value("up_to_face", -1); }
    else                            fe.extrude_end = ExtrudeEnd::Blind;
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"sketch_index", s}, {"extrude_index", e}, {"end", end},
                {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_extrude(), Slic3r::CadDocument::add_extrude(), Slic3r::CadDocument::add_sketch(), Slic3r::CadDocument::add_sketch_profile(), Slic3r::Blind, Slic3r::CadDocument::bodies, bool_from(), Slic3r::CadDocument::checkpoint(), Slic3r::CadFeature::distance2, Slic3r::CadDocument::error, Slic3r::CadFeature::extrude_end, Slic3r::CadDocument::features, Slic3r::CadFeature::flip, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), plane_from(), profile_from(), Slic3r::CadDocument::recompute(), Slic3r::Rectangle, Slic3r::Symmetric, Slic3r::CadFeature::taper_deg, Slic3r::ThroughAll, Slic3r::TwoSided, Slic3r::CadDocument::undo(), Slic3r::CadFeature::up_to_face, and Slic3r::UpToFace.

Referenced by action_extrude(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_fillet()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_fillet	(	DesignPanel *	panel,
		const json &	params )

{
    const std::vector<int> edges = edge_ids_arg(params, "fillet");
    const double radius = params.value("radius", 1.0);
    if (radius <= 0) throw std::runtime_error("radius must be > 0");
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to fillet");
    int bi = target_body_arg(params, doc);
    doc.checkpoint();
    int f = doc.add_fillet(radius, edges, "Fillet");
    if (bi >= 0) doc.features[f].target_body = bi;   // edge id resolved against THIS body's shape
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"fillet_index", f}, {"body", bi < 0 ? int(doc.bodies.size()) - 1 : bi},
                {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_fillet(), Slic3r::CadDocument::add_fillet(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), edge_ids_arg(), Slic3r::CadDocument::error, Slic3r::f(), Slic3r::CadDocument::features, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_fillet(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_helix()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_helix	(	DesignPanel *	panel,
		const json &	params )

{
    const double radius      = params.value("radius", 10.0);
    const double pitch       = params.value("pitch", 5.0);
    const double height      = params.value("height", 20.0);
    const bool   left_handed = params.value("left_handed", false);
    const double taper       = params.value("taper_deg", 0.0);
    CadDocument& doc = panel->mcp_doc();
    doc.checkpoint();
    int idx = doc.add_helix(plane_from(params, doc), radius, pitch, height, left_handed, taper, "Helix");
    panel->mcp_after_change();
    return json{{"ok", true}, {"helix_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_helix(), Slic3r::CadDocument::add_helix(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), and plane_from().

Referenced by action_helix(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_hole()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole	(	DesignPanel *	panel,
		const json &	params )

{
    const double dia   = params.value("diameter", 5.0);
    const double depth = params.value("depth", 10.0);
    const bool   thru  = params.value("through", false);
    const double x = params.value("x", 0.0), y = params.value("y", 0.0);
    if (dia <= 0) throw std::runtime_error("diameter must be > 0");
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to drill");
    SketchPlane pl = plane_from(params, doc);
    doc.checkpoint();
    int h = doc.add_hole(dia, depth, thru, x, y, pl, "Hole");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"hole_index", h}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_hole(), Slic3r::CadDocument::add_hole(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), plane_from(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_hole(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_hole_standard()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_standard	(	DesignPanel *	panel,
		const json &	params )

{
    const std::string desig = params.value("designation", std::string(""));
    if (desig.empty()) throw std::runtime_error("designation is required");
    const int    style  = params.value("style", 0);
    const bool   thru   = params.value("through", true);
    const double depth  = params.value("depth", 10.0);
    const double x = params.value("x", 0.0), y = params.value("y", 0.0);
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to drill");
    SketchPlane pl = plane_from(params, doc);
    doc.checkpoint();
    try {
        int h = doc.add_hole_standard(desig, style, thru, depth, x, y, pl, "Hole");
        bool ok = doc.recompute();
        if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
        panel->mcp_after_change();
        return json{{"ok", ok}, {"hole_index", h}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
    } catch (const std::exception& ex) {
        doc.undo();
        panel->mcp_after_change();
        return json{{"ok", false}, {"error", ex.what()}};
    }
}

References action_hole_standard(), Slic3r::CadDocument::add_hole_standard(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), plane_from(), Slic3r::CadDocument::recompute(), style, and Slic3r::CadDocument::undo().

Referenced by action_hole_standard(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_hole_styled()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_hole_styled	(	DesignPanel *	panel,
		const json &	params )

{
    const double dia   = params.value("diameter", 5.0);
    const double depth = params.value("depth", 10.0);
    const bool   thru  = params.value("through", true);
    const double x = params.value("x", 0.0), y = params.value("y", 0.0);
    const int    style          = params.value("style", 0);
    const double cbore_diameter = params.value("cbore_diameter", 0.0);
    const double cbore_depth    = params.value("cbore_depth", 0.0);
    const double csink_diameter = params.value("csink_diameter", 0.0);
    const double csink_angle    = params.value("csink_angle", 90.0);
    const std::string standard  = params.value("standard", std::string(""));
    if (dia <= 0) throw std::runtime_error("diameter must be > 0");
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to drill");
    SketchPlane pl = plane_from(params, doc);
    doc.checkpoint();
    int h = doc.add_hole_styled(dia, depth, thru, x, y, pl, style,
                                cbore_diameter, cbore_depth,
                                csink_diameter, csink_angle, standard, "Hole");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"hole_index", h}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_hole_styled(), Slic3r::CadDocument::add_hole_styled(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), plane_from(), Slic3r::CadDocument::recompute(), style, and Slic3r::CadDocument::undo().

Referenced by action_hole_styled(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_list_verbs()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_list_verbs	(	DesignPanel *	panel,
		const json &	params )

{
    const int      kind      = panel->mcp_offer_selection_kind();
    const uint32_t bit       = offer_bit(OfferSel(kind));
    const bool     applicable_only = params.value("applicable_only", false);
    const bool     has_sketch_mode = params.contains("sketch_mode");
    const bool     want_sketch_mode = has_sketch_mode && params["sketch_mode"].get<bool>();
 
    json verbs = json::array();
    for (int i = 0; i < kOfferVerbCount; ++i) {
        const OfferVerb& v = kOfferVerbs[i];
        const bool applies = (v.accepts & bit) != 0;
        if (applicable_only && !applies) continue;
        if (has_sketch_mode && v.sketch_mode != want_sketch_mode) continue;
        // Verbs whose action is nullptr exist in the vocabulary but have no GUI path yet — report
        // them with a null action rather than dropping them.
        verbs.push_back(json{
            {"id", v.id},
            {"name", v.name},
            {"row", v.row},
            {"row_name", kOfferRowNames[v.row]},
            {"key", v.key ? json(v.key) : json(nullptr)},
            {"action", v.action ? json(v.action) : json(nullptr)},
            {"sketch_mode", v.sketch_mode},
            {"applies", applies},
            {"modal", verb_is_modal(v.id)},   // opening a dialog: this key will want a mouse
            {"hint", v.hint ? json(v.hint) : json(nullptr)},
        });
    }
    return json{{"ok", true}, {"selection_kind", kind}, {"count", verbs.size()},
                {"verbs", std::move(verbs)}};
}

References Slic3r::GUI::OfferVerb::accepts, Slic3r::GUI::OfferVerb::action, action_list_verbs(), Slic3r::GUI::OfferVerb::hint, Slic3r::GUI::OfferVerb::id, Slic3r::GUI::OfferVerb::key, Slic3r::GUI::kOfferRowNames, Slic3r::GUI::kOfferVerbCount, Slic3r::GUI::kOfferVerbs, Slic3r::GUI::DesignPanel::mcp_offer_selection_kind(), Slic3r::GUI::OfferVerb::name, Slic3r::GUI::offer_bit(), Slic3r::GUI::OfferVerb::row, Slic3r::GUI::OfferVerb::sketch_mode, and verb_is_modal().

Referenced by action_list_verbs(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_mate()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mate	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("cs_a")) throw std::runtime_error("mate needs 'cs_a' (CoordSys feature index)");
    if (!params.contains("cs_b")) throw std::runtime_error("mate needs 'cs_b' (CoordSys feature index)");
    const int kind      = params.value("kind", 0);
    const int cs_a      = params["cs_a"].get<int>();
    const int cs_b      = params["cs_b"].get<int>();
    const double offset = params.value("offset", 0.0);
    const double angle  = params.value("angle", 0.0);
    const bool flip     = params.value("flip", false);
    CadDocument& doc = panel->mcp_doc();
    doc.checkpoint();
    int idx = doc.add_mate(kind, cs_a, cs_b, offset, angle, flip, "Mate");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"mate_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_mate(), Slic3r::CadDocument::add_mate(), Slic3r::angle(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::offset(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_mate(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_mirror()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_mirror	(	DesignPanel *	panel,
		const json &	params )

{
    std::string m_str = params.value("mode", std::string("new"));
    BooleanMode m = (m_str == "add") ? BooleanMode::Add : BooleanMode::New;
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to mirror");
    int bi = target_body_arg(params, doc);
    bool keep = params.value("keep_original", true);
    doc.checkpoint();
    int idx = doc.add_mirror(plane_from(params, doc), bi, m, "Mirror");
    doc.features[idx].mirror_keep_original = keep;
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"mirror_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_mirror(), Slic3r::Add, Slic3r::CadDocument::add_mirror(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::CadDocument::features, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::New, plane_from(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_mirror(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_pattern()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_pattern	(	DesignPanel *	panel,
		const json &	params )

{
    const bool   circular = params.value("circular", false);
    const int    count    = params.value("count", 3);
    const double spacing  = params.value("spacing", 10.0);   // linear step (mm)
    const int    dir      = params.value("dir", 0);          // 0 = plane X, 1 = plane Y
    const double angle    = params.value("angle", 360.0);    // circular total sweep (deg)
    if (count < 1) throw std::runtime_error("count must be >= 1");
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to pattern");
    int bi = target_body_arg(params, doc);
    doc.checkpoint();
    int p = doc.add_pattern(circular, count, spacing, dir, angle, bi, "Pattern");
    doc.features[p].plane = plane_from(params, doc);   // axis (circular) / step dirs (linear)
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"pattern_index", p}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_pattern(), Slic3r::CadDocument::add_pattern(), Slic3r::angle(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), count, Slic3r::CadDocument::error, Slic3r::CadDocument::features, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), plane_from(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_pattern(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_pattern_on_curve()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_pattern_on_curve	(	DesignPanel *	panel,
		const json &	params )

{
    const int count  = params.value("count", 3);
    if (count < 1) throw std::runtime_error("count must be >= 1");
    if (!params.contains("sketch")) throw std::runtime_error("pattern_on_curve needs 'sketch' (feature index)");
    if (!params.contains("entity")) throw std::runtime_error("pattern_on_curve needs 'entity' (entity index)");
    const int sketch = params["sketch"].get<int>();
    const int entity = params["entity"].get<int>();
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to pattern");
    int bi = target_body_arg(params, doc);
    doc.checkpoint();
    int p = doc.add_pattern_on_curve(count, sketch, entity, bi, "PatternOnCurve");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"pattern_index", p}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_pattern_on_curve(), count, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), and target_body_arg().

Referenced by action_pattern_on_curve(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_project()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_project	(	DesignPanel *	panel,
		const json &	params )

{
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no source body to project from");
    int source_body = params.value("source_body", -1);
    int face = params.value("face", -1);
    std::vector<int> edges;
    if (params.contains("edges") && params["edges"].is_array())
        for (const auto& v : params["edges"]) edges.push_back(v.get<int>());
    SketchPlane pl = plane_from(params, doc);
    doc.checkpoint();
    int idx = doc.add_project_edges(source_body, edges, face, pl, "Project");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"project_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_project(), Slic3r::CadDocument::add_project_edges(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), plane_from(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_project(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_revolve()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_revolve	(	DesignPanel *	panel,
		const json &	params )

{
    const double angle = params.value("angle", 360.0);
    const int    axis  = params.value("axis", 0);          // 0 = plane X, 1 = plane Y
    const bool   flip  = params.value("flip", false);
    CadDocument& doc = panel->mcp_doc();
    SketchPlane pl = plane_from(params, doc);
    BooleanMode mode = bool_from(params.value("boolean", std::string("new")));
 
    SketchProfile prof;
    bool has_prof = profile_from(params, prof);
    double w = 0, h = 0;
    if (!has_prof) {   // ponytail: rectangle centred on the axis may self-overlap; offset via `profile`
        w = params.value("width", 20.0); h = params.value("height", 10.0);
        if (w <= 0 || h <= 0) throw std::runtime_error("width and height must be > 0");
    }
    doc.checkpoint();
    int s = has_prof ? doc.add_sketch_profile(prof, pl, "Sketch")
                     : doc.add_sketch(SketchShape::Rectangle, pl, w, h, 0.0, "Sketch");
    int r = doc.add_revolve(s, angle, axis, flip, mode, "Revolve");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"sketch_index", s}, {"revolve_index", r},
                {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_revolve(), Slic3r::CadDocument::add_revolve(), Slic3r::CadDocument::add_sketch(), Slic3r::CadDocument::add_sketch_profile(), Slic3r::angle(), Slic3r::CadDocument::bodies, bool_from(), Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), plane_from(), profile_from(), Slic3r::CadDocument::recompute(), Slic3r::Rectangle, and Slic3r::CadDocument::undo().

Referenced by action_revolve(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_rib()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_rib	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("sketch")) throw std::runtime_error("rib needs 'sketch' (feature index)");
    if (!params.contains("entity")) throw std::runtime_error("rib needs 'entity' (entity index)");
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to rib");
    int sketch    = params["sketch"].get<int>();
    int entity    = params["entity"].get<int>();
    double thickness = params.value("thickness", 2.0);
    double depth     = params.value("depth", 10.0);
    int bi = target_body_arg(params, doc);
    doc.checkpoint();
    int idx = doc.add_rib(sketch, entity, thickness, depth, bi, "Rib");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"rib_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_rib(), Slic3r::CadDocument::add_rib(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_rib(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_run_verb()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_run_verb	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("verb")) throw std::runtime_error("run_verb needs 'verb' (an offer verb id)");
    const std::string verb = params["verb"].get<std::string>();
 
    // Scan the offer table BEFORE dispatching so the failure message can tell an unknown id from
    // one that exists in the vocabulary but has no GUI path (action == nullptr).
    bool known = false;
    bool has_action = false;
    const char* action = nullptr;
    for (int i = 0; i < kOfferVerbCount; ++i) {
        if (std::strcmp(kOfferVerbs[i].id, verb.c_str()) == 0) {
            known = true;
            has_action = (kOfferVerbs[i].action != nullptr);
            action = kOfferVerbs[i].action;
            break;
        }
    }
 
    if (!known)      throw std::runtime_error("run_verb: unknown verb '" + verb + "'");
    if (!has_action) throw std::runtime_error("run_verb: '" + verb + "' has no GUI path yet");
 
    // Whether the verb would be OFFERED for the current selection. Not a refusal: the GUI lets
    // you press a tool's shortcut whatever is selected, and refusing here would make the socket
    // stricter than the keyboard for no reason. Reported so a caller can tell "did nothing
    // because it did not apply" from "did nothing because it is broken".
    const int      kind    = panel->mcp_offer_selection_kind();
    const uint32_t bit     = offer_bit(OfferSel(kind));
    bool           applies = false;
    for (int i = 0; i < kOfferVerbCount; ++i)
        if (std::strcmp(kOfferVerbs[i].id, verb.c_str()) == 0) { applies = (kOfferVerbs[i].accepts & bit) != 0; break; }
 
    // The rule is not "validate more", it is "the socket should offer exactly what the GUI
    // offers, no more and no less". A "btn:"/"fly:" verb is reachable in the GUI ONLY through
    // the offer menu, which GREYS its row when it does not apply to the current selection — so
    // a socket caller must not be able to fire it either. But a "key:" verb is reachable from
    // the KEYBOARD whatever is selected, and the app permits that, so refusing it would make
    // the socket stricter than the keyboard for no reason. Refuse only the menu-only verbs.
    if (!applies && action &&
        (std::strncmp(action, "btn:", 4) == 0 || std::strncmp(action, "fly:", 4) == 0)) {
        throw std::runtime_error("run_verb: '" + verb +
                                 "' does not apply to the current selection (selection_kind " +
                                 std::to_string(kind) + ")");
    }
 
    // Dispatch on the NEXT turn of the event loop, never inline. See verb_is_modal above: a verb
    // that opens a dialog would otherwise block the thread this call is running on. Deferring
    // costs the ability to report the verb's outcome — which run_offer_action never returned
    // anyway — and buys a socket that cannot be wedged by any verb in the table.
    wxGetApp().CallAfter([panel, verb]() { panel->mcp_run_verb(verb.c_str()); });
 
    return json{{"ok", true}, {"verb", verb}, {"dispatched", true},
                {"applies", applies}, {"modal", verb_is_modal(verb.c_str())},
                {"selection_kind", kind}};
}

References action_run_verb(), Slic3r::GUI::kOfferVerbCount, Slic3r::GUI::kOfferVerbs, Slic3r::GUI::DesignPanel::mcp_offer_selection_kind(), Slic3r::GUI::DesignPanel::mcp_run_verb(), Slic3r::GUI::offer_bit(), and verb_is_modal().

Referenced by action_run_verb(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_set_feature_expr()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_feature_expr	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("feature")) throw std::runtime_error("set_feature_expr needs 'feature' index");
    if (!params.contains("field"))   throw std::runtime_error("set_feature_expr needs 'field' name");
    if (!params.contains("expr"))    throw std::runtime_error("set_feature_expr needs 'expr' string");
    CadDocument& doc = panel->mcp_doc();
    int fi = params["feature"].get<int>();
    if (fi < 0 || fi >= (int)doc.features.size())
        return json{{"ok", false}, {"error", "feature index out of range"}};
    std::string field = params["field"].get<std::string>();
    std::string expr  = params["expr"].get<std::string>();
    std::string old = doc.features[fi].expr.count(field) ? doc.features[fi].expr[field] : "";
    doc.checkpoint();
    doc.features[fi].expr[field] = expr;
    bool ok = doc.recompute();
    // undo() recomputes, which succeeds and clears doc.error; carry the reason across so
    // the JSON reply below reports why the edit was rejected instead of an empty string.
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"feature", fi}, {"field", field}, {"error", doc.error}};
}

References action_set_feature_expr(), Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::CadDocument::features, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_set_feature_expr(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_set_variable()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_set_variable	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("name")) throw std::runtime_error("set_variable needs 'name'");
    if (!params.contains("expr")) throw std::runtime_error("set_variable needs 'expr'");
    CadDocument& doc = panel->mcp_doc();
    std::string name = params["name"].get<std::string>();
    std::string expr = params["expr"].get<std::string>();
    std::string old = doc.variables.count(name) ? doc.variables[name] : "";
    doc.checkpoint();
    doc.variables[name] = expr;
    bool ok = doc.recompute();
    // undo() recomputes, which succeeds and clears doc.error; carry the reason across so
    // the JSON reply below reports why the edit was rejected instead of an empty string.
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"name", name}, {"error", doc.error}};
}

References action_set_variable(), Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), Slic3r::CadDocument::undo(), and Slic3r::CadDocument::variables.

Referenced by action_set_variable(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_shell()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_shell	(	DesignPanel *	panel,
		const json &	params )

{
    const double thickness = params.value("thickness", 1.0);
    if (thickness <= 0) throw std::runtime_error("thickness must be > 0");
    const int face = params.value("face", -1);   // face id to leave open (-1 = closed hollow)
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to shell");
    int bi = target_body_arg(params, doc);
    doc.checkpoint();
    int s = doc.add_shell(thickness, face, bi, "Shell");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"shell_index", s}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_shell(), Slic3r::CadDocument::add_shell(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_shell(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_add()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_add	(	DesignPanel *	panel,
		const json &	params )

{
    DesignSketchTool& t = mcp_sketch(panel);
    std::vector<SketchEntity> ents;
    if (params.contains("entities")) {
        for (const auto& j : params.at("entities")) ents.push_back(sketch_entity_from(j));
    } else if (params.contains("type")) {
        ents.push_back(sketch_entity_from(params));      // single-entity shorthand
    } else if (params.contains("rect")) {
        // Corner rectangle as four shared-endpoint lines, so it arrives as ONE closed loop
        // rather than four segments that happen to touch.
        const json& r = params.at("rect");
        if (!r.is_array() || r.size() < 4) throw std::runtime_error("rect must be [x0, y0, x1, y1]");
        const double x0 = r[0].get<double>(), y0 = r[1].get<double>();
        const double x1 = r[2].get<double>(), y1 = r[3].get<double>();
        const bool c = params.value("construction", false);
        auto seg = [&](Vec2d a, Vec2d b) { SketchEntity e; e.type = SketchEntity::Type::Line;
                                           e.p0 = a; e.p1 = b; e.construction = c; return e; };
        ents.push_back(seg({x0, y0}, {x1, y0}));
        ents.push_back(seg({x1, y0}, {x1, y1}));
        ents.push_back(seg({x1, y1}, {x0, y1}));
        ents.push_back(seg({x0, y1}, {x0, y0}));
    } else {
        throw std::runtime_error("sketch_add needs 'entities', a single 'type', or 'rect'");
    }
    const int base = t.add_entities_scripted(ents);
    panel->mcp_viewport()->request_repaint();
    return json{{"ok", base >= 0}, {"first_index", base}, {"added", int(ents.size())},
                {"entities", int(t.entities().size())}, {"dof", t.dof()}};
}

References action_sketch_add(), Slic3r::GUI::DesignSketchTool::add_entities_scripted(), Slic3r::SketchEntity::construction, Slic3r::GUI::DesignSketchTool::dof(), Slic3r::GUI::DesignSketchTool::entities(), Slic3r::SketchEntity::Line, mcp_sketch(), Slic3r::GUI::DesignPanel::mcp_viewport(), Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::GUI::DesignCanvas::request_repaint(), sketch_entity_from(), and Slic3r::SketchEntity::type.

Referenced by action_sketch_add(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_begin()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_begin	(	DesignPanel *	panel,
		const json &	params )

{
    DesignCanvas* vp = panel->mcp_viewport();
    if (vp == nullptr) throw std::runtime_error("no viewport");
    if (vp->is_sketching()) throw std::runtime_error("a sketch is already open");
    const std::string pl = params.value("plane", std::string("XY"));
    SketchPlane plane = SketchPlane::XY();
    if      (pl == "XZ") plane = SketchPlane::XZ();
    else if (pl == "YZ") plane = SketchPlane::YZ();
    else if (pl != "XY") throw std::runtime_error("plane must be XY, XZ or YZ");
    vp->begin_sketch(plane, DesignSketchTool::Mode::Select);
    // The panel has to enter sketch mode too, or the app is half in it: the tool sketches, the
    // offer menu offers sketch verbs, and every sketch KEY is dead because key dispatch tests
    // m_ui_mode while the menu tests the viewport. Driving the socket must leave the GUI in the
    // state a user would be in, not a state only the socket can produce.
    panel->mcp_set_sketch_mode(true);
    return json{{"ok", true}, {"plane", pl}};
}

References action_sketch_begin(), Slic3r::GUI::DesignCanvas::begin_sketch(), Slic3r::GUI::DesignCanvas::is_sketching(), Slic3r::GUI::DesignPanel::mcp_set_sketch_mode(), Slic3r::GUI::DesignPanel::mcp_viewport(), Slic3r::GUI::DesignSketchTool::Select, Slic3r::SketchPlane::XY(), Slic3r::SketchPlane::XZ(), and Slic3r::SketchPlane::YZ().

Referenced by action_sketch_begin(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_cancel()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_cancel	(	DesignPanel *	panel,
		const json &	params )

{
    (void)params;
    DesignCanvas* vp = panel->mcp_viewport();
    if (vp == nullptr || !vp->is_sketching()) throw std::runtime_error("no sketch is open");
    vp->cancel_sketch();
    panel->mcp_set_sketch_mode(false);
    return json{{"ok", true}};
}

References action_sketch_cancel(), Slic3r::GUI::DesignCanvas::cancel_sketch(), Slic3r::GUI::DesignCanvas::is_sketching(), Slic3r::GUI::DesignPanel::mcp_set_sketch_mode(), and Slic3r::GUI::DesignPanel::mcp_viewport().

Referenced by action_sketch_cancel(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_commit()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_commit	(	DesignPanel *	panel,
		const json &	params )

{
    (void)params;
    DesignCanvas* vp = panel->mcp_viewport();
    if (vp == nullptr || !vp->is_sketching()) throw std::runtime_error("no sketch is open");
    vp->finish_sketch();
    panel->mcp_set_sketch_mode(false);
    panel->mcp_after_change();
    return json{{"ok", true}, {"features", int(panel->mcp_doc().features.size())}};
}

References action_sketch_commit(), Slic3r::CadDocument::features, Slic3r::GUI::DesignCanvas::finish_sketch(), Slic3r::GUI::DesignCanvas::is_sketching(), Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::GUI::DesignPanel::mcp_set_sketch_mode(), and Slic3r::GUI::DesignPanel::mcp_viewport().

Referenced by action_sketch_commit(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_construction()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_construction	(	DesignPanel *	panel,
		const json &	params )

{
    DesignSketchTool& t = mcp_sketch(panel);
    const std::vector<int> tgt = sketch_targets(params, t, false);
    if (tgt.empty()) throw std::runtime_error("nothing selected and no 'entities' given");
    t.select_indices(tgt);
    const int n = t.toggle_selection_construction();
    panel->mcp_viewport()->request_repaint();
    return json{{"ok", n > 0}, {"changed", n}};
}

References action_sketch_construction(), mcp_sketch(), Slic3r::GUI::DesignPanel::mcp_viewport(), Slic3r::GUI::DesignCanvas::request_repaint(), Slic3r::GUI::DesignSketchTool::select_indices(), sketch_targets(), and Slic3r::GUI::DesignSketchTool::toggle_selection_construction().

Referenced by action_sketch_construction(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_delete()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_delete	(	DesignPanel *	panel,
		const json &	params )

{
    DesignSketchTool& t = mcp_sketch(panel);
    const std::vector<int> tgt = sketch_targets(params, t, false);
    if (tgt.empty()) throw std::runtime_error("nothing selected and no 'entities' given");
    const int before = int(t.entities().size());
    t.select_indices(tgt);
    t.delete_selected();
    panel->mcp_viewport()->request_repaint();
    return json{{"ok", true}, {"removed", before - int(t.entities().size())},
                {"entities", int(t.entities().size())}};
}

References action_sketch_delete(), Slic3r::GUI::DesignSketchTool::delete_selected(), Slic3r::GUI::DesignSketchTool::entities(), mcp_sketch(), Slic3r::GUI::DesignPanel::mcp_viewport(), Slic3r::GUI::DesignCanvas::request_repaint(), Slic3r::GUI::DesignSketchTool::select_indices(), and sketch_targets().

Referenced by action_sketch_delete(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_describe()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_describe	(	DesignPanel *	panel,
		const json &	params )

{
    (void)params;
    DesignSketchTool& t = mcp_sketch(panel);
    json ents = json::array();
    for (int i = 0; i < int(t.entities().size()); ++i)
        ents.push_back(sketch_entity_to(t.entities()[i], i));
    // The armed TOOL and its pending anchors. Without these the only way to tell which tool a
    // menu row actually armed is to draw with it and infer from what came out — which is how a
    // menu walk that lands one row off gets diagnosed as "the tool is broken".
    static const char* const kModeNames[] = {
        "select", "dimension", "polyline", "line", "rect_corner", "rect_center", "rect_oblique",
        "rect_rounded", "circle_center", "circle_2pt", "point",
        "circle_3pt", "arc_3pt", "arc_tangent", "arc_center", "slot", "slot_arc", "polygon",
        "ellipse", "ellipse_arc", "spline",
        "fillet", "chamfer", "offset", "mirror",
        "trim", "extend",
        "move", "rotate", "scale", "array", "array_polar",
        "transform_art",
        "constrain" };
    const int mi = int(t.mode());
    json out{{"ok", true},
             {"entities", ents},
             {"constraints", int(t.constraints().size())},
             {"dof", t.dof()},
             {"solve_ok", t.solve_ok()},
             {"tool", (mi >= 0 && mi < int(sizeof(kModeNames) / sizeof(kModeNames[0])))
                          ? kModeNames[mi] : "unknown"},
             {"pending", t.pending_points()},
             {"editing", t.value_field_open()},
             {"selection", t.selection()}};
    out.update(sketch_report(t));
    return out;
}

References action_sketch_describe(), Slic3r::GUI::DesignSketchTool::constraints(), Slic3r::GUI::DesignSketchTool::dof(), Slic3r::GUI::DesignSketchTool::entities(), mcp_sketch(), Slic3r::GUI::DesignSketchTool::mode(), Slic3r::GUI::DesignSketchTool::pending_points(), Slic3r::GUI::DesignSketchTool::selection(), sketch_entity_to(), sketch_report(), Slic3r::GUI::DesignSketchTool::solve_ok(), and Slic3r::GUI::DesignSketchTool::value_field_open().

Referenced by action_sketch_describe(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_heal()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_heal	(	DesignPanel *	panel,
		const json &	params )

{
    DesignSketchTool& t = mcp_sketch(panel);
    const double tol = params.value("tolerance", 1e-3);
    const bool   ic  = params.value("ignore_construction", true);
    const int welded = t.heal_coincidences(tol, ic);
    panel->mcp_viewport()->request_repaint();
    json out{{"ok", true}, {"welded", welded}, {"tolerance", tol},
             {"dof", t.dof()}, {"solve_ok", t.solve_ok()}};
    out.update(sketch_report(t));
    return out;
}

References action_sketch_heal(), Slic3r::GUI::DesignSketchTool::dof(), Slic3r::GUI::DesignSketchTool::heal_coincidences(), mcp_sketch(), Slic3r::GUI::DesignPanel::mcp_viewport(), Slic3r::GUI::DesignCanvas::request_repaint(), sketch_report(), and Slic3r::GUI::DesignSketchTool::solve_ok().

Referenced by action_sketch_heal(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_mirror()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_mirror	(	DesignPanel *	panel,
		const json &	params )

{
    DesignSketchTool& t = mcp_sketch(panel);
    auto pt = [&](const char* k, double dx, double dy) {
        if (!params.contains(k)) return Vec2d(dx, dy);
        const json& a = params.at(k);
        if (!a.is_array() || a.size() < 2) throw std::runtime_error(std::string(k) + " must be [x, y]");
        return Vec2d(a[0].get<double>(), a[1].get<double>());
    };
    const Vec2d a = pt("axis_a", 0, 0), b = pt("axis_b", 0, 1);
    const std::vector<int> tgt = sketch_targets(params, t, true);
    std::vector<SketchEntity> src;
    for (int i : tgt)
        if (i >= 0 && i < int(t.entities().size())) src.push_back(t.entities()[i]);
    if (src.empty()) throw std::runtime_error("nothing to mirror");
    const auto out = SketchEngine::mirror_entities(src, a, b);
    const int base = t.add_entities_scripted(out);
    panel->mcp_viewport()->request_repaint();
    return json{{"ok", true}, {"first_index", base}, {"added", int(out.size())}, {"dof", t.dof()}};
}

References action_sketch_mirror(), Slic3r::GUI::DesignSketchTool::add_entities_scripted(), Slic3r::GUI::DesignSketchTool::dof(), Slic3r::GUI::DesignSketchTool::entities(), mcp_sketch(), Slic3r::GUI::DesignPanel::mcp_viewport(), Slic3r::SketchEngine::mirror_entities(), Slic3r::GUI::DesignCanvas::request_repaint(), and sketch_targets().

Referenced by action_sketch_mirror(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_offset()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_offset	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("distance")) throw std::runtime_error("sketch_offset needs 'distance'");
    DesignSketchTool& t = mcp_sketch(panel);
    const double d = params.at("distance").get<double>();
    const std::vector<int> tgt = sketch_targets(params, t, true);
    std::vector<SketchEntity> src;
    for (int i : tgt)
        if (i >= 0 && i < int(t.entities().size())) src.push_back(t.entities()[i]);
    if (src.empty()) throw std::runtime_error("nothing to offset");
    const auto out = SketchEngine::offset_entities(src, d);
    if (out.empty()) throw std::runtime_error("offset produced nothing (ellipses and splines are not offset)");
    const int base = t.add_entities_scripted(out);
    panel->mcp_viewport()->request_repaint();
    return json{{"ok", true}, {"first_index", base}, {"added", int(out.size())}, {"dof", t.dof()}};
}

References action_sketch_offset(), Slic3r::GUI::DesignSketchTool::add_entities_scripted(), Slic3r::GUI::DesignSketchTool::dof(), Slic3r::GUI::DesignSketchTool::entities(), mcp_sketch(), Slic3r::GUI::DesignPanel::mcp_viewport(), Slic3r::SketchEngine::offset_entities(), Slic3r::GUI::DesignCanvas::request_repaint(), and sketch_targets().

Referenced by action_sketch_offset(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_select()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_select	(	DesignPanel *	panel,
		const json &	params )

{
    DesignSketchTool& t = mcp_sketch(panel);
    std::vector<int> idx;
    if (params.contains("entities"))
        for (const auto& v : params.at("entities")) idx.push_back(v.get<int>());
    const bool any = t.select_indices(idx);
    panel->mcp_viewport()->request_repaint();
    return json{{"ok", true}, {"selected", int(t.selection().size())}, {"any", any}};
}

References action_sketch_select(), mcp_sketch(), Slic3r::GUI::DesignPanel::mcp_viewport(), Slic3r::GUI::DesignCanvas::request_repaint(), Slic3r::GUI::DesignSketchTool::select_indices(), and Slic3r::GUI::DesignSketchTool::selection().

Referenced by action_sketch_select(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_set_value()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_set_value	(	DesignPanel *	panel,
		const json &	params )

{
    DesignSketchTool& t = mcp_sketch(panel);
    if (!params.contains("value")) throw std::runtime_error("sketch_set_value needs 'value'");
    const double value = params["value"].get<double>();
    const DesignSketchTool::DimType kind = t.dimension_kind();
    if (kind == DesignSketchTool::DimType::None)
        throw std::runtime_error("the selection has no value to set — pick a line, an arc, a circle, or two entities");
 
    const char* kind_name = "none";
    switch (kind) {
    case DesignSketchTool::DimType::Length:         kind_name = "length"; break;
    case DesignSketchTool::DimType::Radius:         kind_name = "radius"; break;
    case DesignSketchTool::DimType::Diameter:       kind_name = "diameter"; break;
    case DesignSketchTool::DimType::Angle:          kind_name = "angle"; break;
    case DesignSketchTool::DimType::Distance:       kind_name = "distance"; break;
    case DesignSketchTool::DimType::DistanceToLine: kind_name = "distance_to_line"; break;
    default: break;
    }
 
    // Validate BEFORE apply_dimension, at the socket boundary. The tool only MOVES geometry when
    // the value passes its own per-case thresholds, but it records the driving constraint
    // UNCONDITIONALLY afterwards — a negative/zero/NaN value that moved nothing would still be
    // pushed to the solver as a constraint it must satisfy and cannot, silently corrupting the
    // sketch rather than failing. (apply_dimension has the same flaw for any other caller; this
    // guard protects the socket, not the tool.) Fail loudly instead of recording a poison value.
    if (!std::isfinite(value))
        throw std::runtime_error("dimension must be finite — NaN or infinity is not a dimension");
    switch (kind) {
    case DesignSketchTool::DimType::Length:
    case DesignSketchTool::DimType::Radius:
    case DesignSketchTool::DimType::Diameter:
        if (value <= 0.0)
            throw std::runtime_error(std::string(kind_name) + " must be positive (got " + std::to_string(value) + ")");
        break;
    case DesignSketchTool::DimType::Distance:
    case DesignSketchTool::DimType::DistanceToLine:
        if (value < 0.0)
            throw std::runtime_error(std::string(kind_name) + " must be >= 0 (zero means coincident / on the line)");
        break;
    case DesignSketchTool::DimType::Angle:
    default:
        break;   // any finite angle is valid
    }
 
    const double before = t.dimension_current();
    t.apply_dimension(value);
    panel->mcp_viewport()->request_repaint();
 
    json out{{"ok", true}, {"kind", kind_name}, {"before", before}, {"value", value},
             {"dof", t.dof()}, {"solve_ok", t.solve_ok()}};
    out.update(sketch_report(t));
    return out;
}

References action_sketch_set_value(), Slic3r::GUI::DesignSketchTool::Angle, Slic3r::GUI::DesignSketchTool::apply_dimension(), Slic3r::GUI::DesignSketchTool::Diameter, Slic3r::GUI::DesignSketchTool::dimension_current(), Slic3r::GUI::DesignSketchTool::dimension_kind(), Slic3r::GUI::DesignSketchTool::Distance, Slic3r::GUI::DesignSketchTool::DistanceToLine, Slic3r::GUI::DesignSketchTool::dof(), Slic3r::GUI::DesignSketchTool::Length, mcp_sketch(), Slic3r::GUI::DesignPanel::mcp_viewport(), Slic3r::GUI::DesignSketchTool::None, Slic3r::GUI::DesignSketchTool::Radius, Slic3r::GUI::DesignCanvas::request_repaint(), sketch_report(), and Slic3r::GUI::DesignSketchTool::solve_ok().

Referenced by action_sketch_set_value(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_sketch_validate()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_sketch_validate	(	DesignPanel *	panel,
		const json &	params )

{
    DesignSketchTool& t = mcp_sketch(panel);
    const double tol = params.value("tolerance", 1e-3);
    json out{{"ok", true}, {"tolerance", tol}, {"dof", t.dof()}, {"solve_ok", t.solve_ok()}};
    out.update(sketch_report(t));
    return out;
}

References action_sketch_validate(), Slic3r::GUI::DesignSketchTool::dof(), mcp_sketch(), sketch_report(), and Slic3r::GUI::DesignSketchTool::solve_ok().

Referenced by action_sketch_validate(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_split()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_split	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("face")) throw std::runtime_error("split needs 'face' (id from query_topology)");
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to split");
    int bi = target_body_arg(params, doc);
    int face_body = params.value("face_body", -1);
    int face = params["face"].get<int>();
    bool keep_upper = params.value("keep_upper", true);
    bool keep_lower = params.value("keep_lower", true);
    doc.checkpoint();
    int idx = doc.add_split_by_face(bi, face_body, face, keep_upper, keep_lower, "Split");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"split_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_split(), Slic3r::CadDocument::add_split_by_face(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_split(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_surface_extrude()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_extrude	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("sketch")) throw std::runtime_error("surface_extrude needs 'sketch' (feature index)");
    CadDocument& doc = panel->mcp_doc();
    int sketch = params["sketch"].get<int>();
    double distance = params.value("distance", 10.0);
    doc.checkpoint();
    int idx = doc.add_surface_extrude(sketch, distance, "SurfaceExtrude");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"feature_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_surface_extrude(), Slic3r::CadDocument::add_surface_extrude(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_surface_extrude(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_surface_fill()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_fill	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("sketch")) throw std::runtime_error("surface_fill needs 'sketch' (feature index)");
    CadDocument& doc = panel->mcp_doc();
    int sketch = params["sketch"].get<int>();
    doc.checkpoint();
    int idx = doc.add_surface_fill(sketch, "SurfaceFill");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"feature_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_surface_fill(), Slic3r::CadDocument::add_surface_fill(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_surface_fill(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_surface_loft()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_loft	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("profiles") || !params["profiles"].is_array())
        throw std::runtime_error("surface_loft needs 'profiles' (array of int feature indices)");
    CadDocument& doc = panel->mcp_doc();
    std::vector<int> profiles;
    for (const json& j : params["profiles"]) profiles.push_back(j.get<int>());
    bool ruled = params.value("ruled", false);
    doc.checkpoint();
    int idx = doc.add_surface_loft(profiles, ruled, "SurfaceLoft");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"feature_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_surface_loft(), Slic3r::CadDocument::add_surface_loft(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_surface_loft(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_surface_offset()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_offset	(	DesignPanel *	panel,
		const json &	params )

{
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no sheet body to offset");
    int bi = target_body_arg(params, doc);
    double offset = params.value("offset", 1.0);
    doc.checkpoint();
    int idx = doc.add_surface_offset(bi, offset, "SurfaceOffset");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"feature_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_surface_offset(), Slic3r::CadDocument::add_surface_offset(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::offset(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_surface_offset(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_surface_revolve()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_surface_revolve	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("sketch")) throw std::runtime_error("surface_revolve needs 'sketch' (feature index)");
    CadDocument& doc = panel->mcp_doc();
    int sketch = params["sketch"].get<int>();
    double angle = params.value("angle", 360.0);
    int axis = params.value("axis", 0);
    doc.checkpoint();
    int idx = doc.add_surface_revolve(sketch, angle, axis, "SurfaceRevolve");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"feature_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_surface_revolve(), Slic3r::CadDocument::add_surface_revolve(), Slic3r::angle(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by action_surface_revolve(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_thicken()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("face")) throw std::runtime_error("thicken needs 'face' (id from query_topology)");
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to thicken");
    int bi = target_body_arg(params, doc);
    int face = params["face"].get<int>();
    double thickness = params.value("thickness", 2.0);
    bool flip = params.value("flip", false);
    doc.checkpoint();
    int idx = doc.add_thicken(bi, face, thickness, flip, "Thicken");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"thicken_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_thicken(), Slic3r::CadDocument::add_thicken(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_thicken(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_thicken_surface()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_thicken_surface	(	DesignPanel *	panel,
		const json &	params )

{
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no sheet body to thicken");
    int bi = target_body_arg(params, doc);
    double thickness = params.value("thickness", 2.0);
    bool flip = params.value("flip", false);
    doc.checkpoint();
    int idx = doc.add_thicken_surface(bi, thickness, flip, "ThickenSurface");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"feature_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_thicken_surface(), Slic3r::CadDocument::add_thicken_surface(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), and Slic3r::CadDocument::undo().

Referenced by action_thicken_surface(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

action_transform()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::action_transform	(	DesignPanel *	panel,
		const json &	params )

{
    CadDocument& doc = panel->mcp_doc();
    if (doc.bodies.empty()) throw std::runtime_error("no body to transform");
    int bi = target_body_arg(params, doc);
    Vec3d translate(params.value("dx", 0.0), params.value("dy", 0.0), params.value("dz", 0.0));
    Vec3d axis(params.value("axis_x", 0.0), params.value("axis_y", 0.0), params.value("axis_z", 1.0));
    Vec3d pivot(params.value("pivot_x", 0.0), params.value("pivot_y", 0.0), params.value("pivot_z", 0.0));
    double angle = params.value("angle", 0.0);
    bool copy = params.value("copy", false);
    doc.checkpoint();
    int idx = doc.add_transform(bi, translate, axis, pivot, angle, copy, "Transform");
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"transform_index", idx}, {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References action_transform(), Slic3r::CadDocument::add_transform(), Slic3r::angle(), Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::CadDocument::recompute(), target_body_arg(), Slic3r::translate(), and Slic3r::CadDocument::undo().

Referenced by action_transform(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

body_shape()

const TopoDS_Shape & Slic3r::GUI::anonymous_namespace{McpControl.cpp}::body_shape	(	DesignPanel *	panel,
		const json &	params )

{
    CadDocument& doc = panel->mcp_doc();
    int idx = params.value("body", 0);
    if (idx < 0 || idx >= int(doc.bodies.size()))
        throw std::runtime_error("body index out of range (have " + std::to_string(doc.bodies.size()) + ")");
    if (doc.bodies[idx].shape.IsNull())
        throw std::runtime_error("body has no shape");
    return doc.bodies[idx].shape;
}

References Slic3r::CadDocument::bodies, body_shape(), and Slic3r::GUI::DesignPanel::mcp_doc().

Referenced by body_shape(), mass_properties(), measure(), query_topology(), slice_body(), and validate_against().

Here is the call graph for this function:

Here is the caller graph for this function:

bool_from()

BooleanMode Slic3r::GUI::anonymous_namespace{McpControl.cpp}::bool_from

(

const std::string &

s

)

{
    if (s == "union" || s == "add")       return BooleanMode::Add;
    if (s == "subtract" || s == "cut")    return BooleanMode::Cut;
    if (s == "intersect" || s == "common")return BooleanMode::Intersect;
    return BooleanMode::New;
}

References Slic3r::Add, bool_from(), Slic3r::Cut, Slic3r::Intersect, and Slic3r::New.

Referenced by action_boolean(), action_extrude(), action_revolve(), and bool_from().

Here is the call graph for this function:

Here is the caller graph for this function:

chain_segments()

std::vector< std::pair< std::vector< Vec3d >, bool > > Slic3r::GUI::anonymous_namespace{McpControl.cpp}::chain_segments	(	std::vector< std::vector< Vec3d > >	segs,
		double	tol )

{
    std::vector<std::pair<std::vector<Vec3d>, bool>> contours;
    std::vector<char> used(segs.size(), 0);
    auto meets = [&](const Vec3d& a, const Vec3d& b) { return (a - b).norm() <= tol; };
    for (size_t i = 0; i < segs.size(); ++i) {
        if (used[i] || segs[i].size() < 2) continue;
        used[i] = 1;
        std::vector<Vec3d> c = segs[i];
        for (int side = 0; side < 2; ) {           // grow tail; reverse once when stuck
            bool grew = false;
            for (size_t j = 0; j < segs.size(); ++j) {
                if (used[j] || segs[j].size() < 2) continue;
                if (meets(c.back(), segs[j].front())) {
                    c.insert(c.end(), segs[j].begin() + 1, segs[j].end()); used[j] = 1; grew = true;
                } else if (meets(c.back(), segs[j].back())) {
                    for (auto it = segs[j].rbegin() + 1; it != segs[j].rend(); ++it) c.push_back(*it);
                    used[j] = 1; grew = true;
                }
            }
            if (grew) { side = 0; continue; }
            std::reverse(c.begin(), c.end()); ++side;   // try the other end
        }
        bool closed = c.size() > 2 && meets(c.front(), c.back());
        contours.emplace_back(std::move(c), closed);
    }
    return contours;
}

References chain_segments().

Referenced by chain_segments(), and slice_body().

Here is the call graph for this function:

Here is the caller graph for this function:

describe_scene()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::describe_scene

(

DesignPanel *

panel

)

{
    CadDocument& doc = panel->mcp_doc();
 
    json features = json::array();
    for (size_t i = 0; i < doc.features.size(); ++i) {
        const CadFeature& f = doc.features[i];
        features.push_back(json{
            {"index", int(i)}, {"type", feature_type_name(f.type)},
            {"name", f.name}, {"enabled", f.enabled}});
    }
 
    json bodies = json::array();
    for (size_t i = 0; i < doc.bodies.size(); ++i) {
        // The user's name when the body has one, the derived maker name otherwise — the same
        // rule the Bodies row shows, so a driver and a person read the same thing.
        json b{{"index", int(i)},
               {"name", doc.bodies[i].has_user_name ? doc.bodies[i].user_name : doc.bodies[i].name},
               {"user_name", doc.bodies[i].has_user_name},
               {"has_color", doc.bodies[i].has_color}};
        // Per-body bbox/centre from the already-tessellated display meshes.
        if (i < doc.display_body_meshes.size() && !doc.display_body_meshes[i].empty()) {
            BoundingBoxf3 bb = doc.display_body_meshes[i].bounding_box();
            b["bbox"] = json{{"min", {bb.min.x(), bb.min.y(), bb.min.z()}},
                             {"max", {bb.max.x(), bb.max.y(), bb.max.z()}}};
            Vec3d c = bb.center();
            b["center"] = {c.x(), c.y(), c.z()};
        }
        bodies.push_back(std::move(b));
    }
 
    return json{
        {"modeling_origin", {doc.modeling_origin.x(), doc.modeling_origin.y(), doc.modeling_origin.z()}},
        {"features", std::move(features)},
        {"bodies", std::move(bodies)},
        {"error", doc.error},
        // Pass this back as "generation" on any call that takes a face or edge id and the call
        // is refused if the topology has moved on. See the note on the dispatcher.
        {"generation", doc.topo_generation},
    };
}

References Slic3r::CadDocument::bodies, Slic3r::BoundingBox3Base< PointType >::center(), describe_scene(), Slic3r::CadDocument::display_body_meshes, Slic3r::CadDocument::error, Slic3r::f(), feature_type_name(), Slic3r::CadDocument::features, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::CadDocument::modeling_origin, and Slic3r::CadDocument::topo_generation.

Referenced by describe_scene(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

describe_tools()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::describe_tools

(

)

{
    // Hand-written descriptor. The bridge turns this into MCP tool schemas; later
    // slices grow this list (ideally from the kernel directly).
    return json{
        {"app", "Orca CAD"},
        {"protocol", "jsonrpc-2.0"},
        {"slice", 5},
        // Read this before using any face or edge id.
        {"id_lifetime",
         "Global face and edge ids are indices into the CURRENT topology and expire the moment "
         "a feature rebuilds the model. Reading the scene once and then issuing several "
         "operations addresses the wrong edge on every call after the first, and does NOT "
         "error, because a stale id still names a real edge. Either re-read query_topology "
         "before each id-taking call, or pass the 'generation' you were given back with the "
         "call and have it refused if the model has moved on."},
        {"tools", json::array({
            json{{"name", "describe_tools"}, {"summary", "List callable tools and their parameters."},
                 {"params", json::array()}},
            json{{"name", "describe_scene"}, {"summary", "Feature tree + per-body bounding boxes of the Design document."},
                 {"params", json::array()}},
            json{{"name", "extrude"}, {"summary", "Extrude a profile to a depth. Give an explicit closed `profile` (list of [x,y]) or default to a centred width x height rectangle. End conditions match Onshape."},
                 {"params", json::array({
                     json{{"name", "width"},    {"type", "number"}, {"unit", "mm"}, {"default", 20}, {"min", 0.01}},
                     json{{"name", "height"},   {"type", "number"}, {"unit", "mm"}, {"default", 20}, {"min", 0.01}},
                     json{{"name", "distance"}, {"type", "number"}, {"unit", "mm"}, {"default", 10}, {"min", 0.01}},
                     json{{"name", "plane"},    {"type", "string"}, {"enum", json::array({"XY", "XZ", "YZ"})}, {"default", "XY"}},
                     json{{"name", "profile"},  {"type", "array"}, {"default", json::array()}, {"description", "optional closed contour [[x,y],...] in plane mm; overrides width/height"}},
                     json{{"name", "boolean"},  {"type", "string"}, {"enum", json::array({"new", "union", "subtract", "intersect"})}, {"default", "new"}},
                     json{{"name", "end"},      {"type", "string"}, {"enum", json::array({"blind", "symmetric", "two_sided", "through_all", "up_to_face"})}, {"default", "blind"}},
                     json{{"name", "distance2"},{"type", "number"}, {"unit", "mm"}, {"default", 0}, {"description", "second-side depth when end=two_sided (else falls back to distance)"}},
                     json{{"name", "up_to_face"},{"type", "integer"}, {"default", -1}, {"description", "target face id (query_topology on the last body) when end=up_to_face"}},
                     json{{"name", "taper"},    {"type", "number"}, {"unit", "deg"}, {"default", 0}, {"description", "draft/taper of the side wall"}},
                     json{{"name", "flip"},     {"type", "boolean"}, {"default", false}},
                 })}},
            json{{"name", "revolve"}, {"summary", "Revolve a profile about a plane axis. Give an explicit `profile` offset from the axis (or a rectangle) — angle degrees about axis 0=plane X / 1=plane Y."},
                 {"params", json::array({
                     json{{"name", "width"},   {"type", "number"}, {"unit", "mm"}, {"default", 20}, {"min", 0.01}},
                     json{{"name", "height"},  {"type", "number"}, {"unit", "mm"}, {"default", 10}, {"min", 0.01}},
                     json{{"name", "angle"},   {"type", "number"}, {"unit", "deg"}, {"default", 360}},
                     json{{"name", "axis"},    {"type", "integer"}, {"enum", json::array({0, 1})}, {"default", 0}},
                     json{{"name", "flip"},    {"type", "boolean"}, {"default", false}},
                     json{{"name", "plane"},   {"type", "string"}, {"enum", json::array({"XY", "XZ", "YZ"})}, {"default", "XY"}},
                     json{{"name", "profile"}, {"type", "array"}, {"default", json::array()}, {"description", "optional closed contour [[x,y],...] in plane mm; overrides width/height"}},
                     json{{"name", "boolean"}, {"type", "string"}, {"enum", json::array({"new", "union", "subtract", "intersect"})}, {"default", "new"}},
                 })}},
            json{{"name", "fillet"}, {"summary", "Round measured edges of a body (edge ids from query_topology on that body)."},
                 {"params", json::array({
                     json{{"name", "edge"},   {"type", "integer|array"}, {"description", "one edge id, or an array of ids rounded together in one feature"}},
                     json{{"name", "radius"}, {"type", "number"}, {"unit", "mm"}, {"default", 1}, {"min", 0.01}},
                     json{{"name", "body"},   {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body. edge id is resolved against THIS body."}},
                 })}},
            json{{"name", "chamfer"}, {"summary", "Chamfer measured edges of a body (edge ids from query_topology on that body)."},
                 {"params", json::array({
                     json{{"name", "edge"},     {"type", "integer|array"}, {"description", "one edge id, or an array of ids chamfered together in one feature"}},
                     json{{"name", "distance"}, {"type", "number"}, {"unit", "mm"}, {"default", 1}, {"min", 0.01}},
                     json{{"name", "body"},     {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body. edge id is resolved against THIS body."}},
                 })}},
            json{{"name", "hole"}, {"summary", "Drill a circular hole into the current body at (x,y) on a plane."},
                 {"params", json::array({
                     json{{"name", "diameter"}, {"type", "number"}, {"unit", "mm"}, {"default", 5}, {"min", 0.01}},
                     json{{"name", "depth"},    {"type", "number"}, {"unit", "mm"}, {"default", 10}, {"min", 0.01}},
                     json{{"name", "through"},  {"type", "boolean"}, {"default", false}},
                     json{{"name", "x"},        {"type", "number"}, {"unit", "mm"}, {"default", 0}, {"description", "in the sketch plane's frame (origin = describe_scene.modeling_origin), NOT world"}},
                     json{{"name", "y"},        {"type", "number"}, {"unit", "mm"}, {"default", 0}, {"description", "in the sketch plane's frame (origin = describe_scene.modeling_origin), NOT world"}},
                     json{{"name", "plane"},    {"type", "string"}, {"enum", json::array({"XY", "XZ", "YZ"})}, {"default", "XY"}},
                 })}},
            json{{"name", "hole_styled"}, {"summary", "Drill a hole with optional counterbore (style=1) or countersink (style=2) at (x,y) on a plane."},
                 {"params", json::array({
                     json{{"name", "diameter"},        {"type", "number"}, {"unit", "mm"}, {"default", 5}, {"min", 0.01}},
                     json{{"name", "depth"},           {"type", "number"}, {"unit", "mm"}, {"default", 10}, {"min", 0.01}},
                     json{{"name", "through"},         {"type", "boolean"}, {"default", true}},
                     json{{"name", "x"},               {"type", "number"}, {"unit", "mm"}, {"default", 0}, {"description", "in the sketch plane's frame (origin = describe_scene.modeling_origin), NOT world"}},
                     json{{"name", "y"},               {"type", "number"}, {"unit", "mm"}, {"default", 0}, {"description", "in the sketch plane's frame (origin = describe_scene.modeling_origin), NOT world"}},
                     json{{"name", "plane"},           {"type", "string"}, {"enum", json::array({"XY", "XZ", "YZ"})}, {"default", "XY"}},
                     json{{"name", "style"},           {"type", "integer"}, {"default", 0}, {"description", "0=simple, 1=counterbore, 2=countersink"}},
                     json{{"name", "cbore_diameter"},  {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "cbore_depth"},     {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "csink_diameter"},  {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "csink_angle"},     {"type", "number"}, {"unit", "deg"}, {"default", 90}},
                     json{{"name", "standard"},        {"type", "string"}, {"default", ""}, {"description", "provenance designation, e.g. M6"}},
                 })}},
            json{{"name", "hole_standard"}, {"summary", "Drill a standard clearance hole (ISO 273 / ANSI) at (x,y) on a plane. style: 0=simple, 1=counterbore, 2=countersink."},
                 {"params", json::array({
                     json{{"name", "designation"},  {"type", "string"}, {"description", "e.g. M6, 1/4-20"}},
                     json{{"name", "style"},        {"type", "integer"}, {"default", 0}},
                     json{{"name", "through"},      {"type", "boolean"}, {"default", true}},
                     json{{"name", "depth"},        {"type", "number"}, {"unit", "mm"}, {"default", 10}, {"min", 0.01}},
                     json{{"name", "x"},            {"type", "number"}, {"unit", "mm"}, {"default", 0}, {"description", "in the sketch plane's frame (origin = describe_scene.modeling_origin), NOT world"}},
                     json{{"name", "y"},            {"type", "number"}, {"unit", "mm"}, {"default", 0}, {"description", "in the sketch plane's frame (origin = describe_scene.modeling_origin), NOT world"}},
                     json{{"name", "plane"},        {"type", "string"}, {"enum", json::array({"XY", "XZ", "YZ"})}, {"default", "XY"}},
                 })}},
            json{{"name", "boolean"}, {"summary", "Combine two bodies: union | subtract (tool from target) | intersect."},
                 {"params", json::array({
                     json{{"name", "op"},        {"type", "string"}, {"enum", json::array({"union", "subtract", "intersect"})}, {"default", "subtract"}},
                     json{{"name", "target"},    {"type", "integer"}, {"default", 0}},
                     json{{"name", "tool"},      {"type", "integer"}, {"default", 1}},
                     json{{"name", "keep_tool"}, {"type", "boolean"}, {"default", false}},
                     json{{"name", "tolerance"}, {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                 })}},
            json{{"name", "pattern"}, {"summary", "Replicate a body: linear (count along a plane axis at spacing) or circular (count over an angle about the plane normal)."},
                 {"params", json::array({
                     json{{"name", "circular"}, {"type", "boolean"}, {"default", false}},
                     json{{"name", "count"},    {"type", "integer"}, {"default", 3}, {"min", 1}},
                     json{{"name", "spacing"},  {"type", "number"}, {"unit", "mm"}, {"default", 10}, {"description", "linear step"}},
                     json{{"name", "dir"},      {"type", "integer"}, {"enum", json::array({0, 1})}, {"default", 0}, {"description", "linear axis: 0=plane X, 1=plane Y"}},
                     json{{"name", "angle"},    {"type", "number"}, {"unit", "deg"}, {"default", 360}, {"description", "circular total sweep"}},
                     json{{"name", "plane"},    {"type", "string"}, {"enum", json::array({"XY", "XZ", "YZ"})}, {"default", "XY"}},
                     json{{"name", "body"},     {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                 })}},
            json{{"name", "pattern_on_curve"}, {"summary", "Replicate a body along a sketch curve: `count` copies placed at equal-parameter points on the entity, each translated by (P_i - P_0)."},
                 {"params", json::array({
                     json{{"name", "count"},  {"type", "integer"}, {"default", 3}, {"min", 1}},
                     json{{"name", "sketch"}, {"type", "integer"}, {"description", "feature index of the sketch holding the guide curve"}},
                     json{{"name", "entity"}, {"type", "integer"}, {"description", "entity index of the guide curve within that sketch"}},
                     json{{"name", "body"},   {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                 })}},
            json{{"name", "shell"}, {"summary", "Hollow a body to a wall thickness (inward); optionally leave one face open."},
                 {"params", json::array({
                     json{{"name", "thickness"}, {"type", "number"}, {"unit", "mm"}, {"default", 1}, {"min", 0.01}},
                     json{{"name", "face"},      {"type", "integer"}, {"default", -1}, {"description", "face id to leave open (query_topology); omit for a closed hollow"}},
                     json{{"name", "body"},      {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                 })}},
            json{{"name", "draft"}, {"summary", "Taper a body face by an angle about its base (pull direction +Z)."},
                 {"params", json::array({
                     json{{"name", "face"},  {"type", "integer"}, {"description", "face id to draft (query_topology)"}},
                     json{{"name", "angle"}, {"type", "number"}, {"unit", "deg"}, {"default", 5}},
                     json{{"name", "body"},  {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                 })}},
            json{{"name", "mirror"}, {"summary", "Mirror a body about a base plane. mode=new creates a mirrored copy; mode=add fuses the mirror back into the source."},
                 {"params", json::array({
                     json{{"name", "plane"},        {"type", "string"}, {"enum", json::array({"XY", "XZ", "YZ"})}, {"default", "XZ"}},
                     json{{"name", "mode"},         {"type", "string"}, {"enum", json::array({"new", "add"})},     {"default", "new"}},
                     json{{"name", "keep_original"},{"type", "boolean"}, {"default", true}, {"description", "when mode=new, keep the source body"}},
                     json{{"name", "body"},         {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                 })}},
            json{{"name", "transform"}, {"summary", "Move and/or rotate a body (B-rep transform). copy=true keeps the source and appends the transformed copy as a new body."},
                 {"params", json::array({
                     json{{"name", "body"},    {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                     json{{"name", "dx"},      {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "dy"},      {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "dz"},      {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "axis_x"},  {"type", "number"}, {"default", 0}},
                     json{{"name", "axis_y"},  {"type", "number"}, {"default", 0}},
                     json{{"name", "axis_z"},  {"type", "number"}, {"default", 1}},
                     json{{"name", "pivot_x"}, {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "pivot_y"}, {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "pivot_z"}, {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "angle"},   {"type", "number"}, {"unit", "deg"}, {"default", 0}},
                     json{{"name", "copy"},    {"type", "boolean"}, {"default", false}},
                 })}},
            json{{"name", "axis"}, {"summary", "Create a datum axis (reference line): two points, face normal, cylinder centreline, plane intersection, or along edge."},
                 {"params", json::array({
                     json{{"name", "type"},     {"type", "string"}, {"enum", json::array({"two_points", "face_normal", "cylinder", "plane_intersection", "along_edge"})}, {"default", "two_points"}},
                     json{{"name", "p1"},       {"type", "array"}, {"default", json::array({0,0,0})}, {"description", "first point [x,y,z] for two_points"}},
                     json{{"name", "p2"},       {"type", "array"}, {"default", json::array({0,0,10})}, {"description", "second point [x,y,z] for two_points"}},
                     json{{"name", "body"},     {"type", "integer"}, {"default", -1}, {"description", "body for face/edge refs"}},
                     json{{"name", "face"},     {"type", "integer"}, {"default", -1}, {"description", "face id (query_topology) for face_normal/cylinder"}},
                     json{{"name", "edge"},     {"type", "integer"}, {"default", -1}, {"description", "edge id (query_topology) for along_edge"}},
                     json{{"name", "plane_a"},  {"type", "integer"}, {"default", -1}, {"description", "first datum plane feature index for plane_intersection"}},
                     json{{"name", "plane_b"},  {"type", "integer"}, {"default", -1}, {"description", "second datum plane feature index for plane_intersection"}},
                 })}},
            json{{"name", "coordsys"}, {"summary", "Create a datum coordinate system (origin + orthonormal axes). PointWorld aligns to world; FaceAndDirection uses a face for Z and an edge/hint for X."},
                 {"params", json::array({
                     json{{"name", "type"},      {"type", "string"}, {"enum", json::array({"point_world", "face_and_direction"})}, {"default", "point_world"}},
                     json{{"name", "point"},     {"type", "array"}, {"default", json::array({0,0,0})}, {"description", "origin [x,y,z] for point_world"}},
                     json{{"name", "body"},      {"type", "integer"}, {"default", -1}, {"description", "body for face/edge refs"}},
                     json{{"name", "face"},      {"type", "integer"}, {"default", -1}, {"description", "face id (query_topology) for Z axis"}},
                     json{{"name", "edge"},      {"type", "integer"}, {"default", -1}, {"description", "edge id (query_topology) for X axis hint"}},
                     json{{"name", "x_hint"},    {"type", "array"}, {"default", json::array({1,0,0})}, {"description", "fallback X direction hint if no edge given"}},
                 })}},
            json{{"name", "helix"}, {"summary", "Create a helical curve (consumed by sweep as a path to build springs/coils/augers). pitch = axial rise per turn. left_handed flips the winding. taper_deg != 0 gives a conical helix."},
                 {"params", json::array({
                     json{{"name", "radius"},      {"type", "number"}, {"unit", "mm"},  {"default", 10}, {"min", 0.01}},
                     json{{"name", "pitch"},       {"type", "number"}, {"unit", "mm"},  {"default", 5},  {"min", 0.01}},
                     json{{"name", "height"},      {"type", "number"}, {"unit", "mm"},  {"default", 20}, {"min", 0.01}},
                     json{{"name", "left_handed"}, {"type", "boolean"}, {"default", false}},
                     json{{"name", "taper_deg"},   {"type", "number"}, {"unit", "deg"}, {"default", 0}},
                     json{{"name", "plane"},       {"type", "string"}, {"enum", json::array({"XY", "XZ", "YZ"})}, {"default", "XY"}},
                 })}},
            json{{"name", "thicken"}, {"summary", "Offset a face of a body by a wall thickness, producing a new thin solid body."},
                 {"params", json::array({
                     json{{"name", "body"},      {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                     json{{"name", "face"},      {"type", "integer"}, {"description", "face id to thicken (query_topology)"}},
                     json{{"name", "thickness"}, {"type", "number"}, {"unit", "mm"}, {"default", 2}, {"min", 0.01}},
                     json{{"name", "flip"},      {"type", "boolean"}, {"default", false}},
                 })}},
            json{{"name", "split"}, {"summary", "Split a body along the plane of a picked face."},
                 {"params", json::array({
                     json{{"name", "body"},      {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                     json{{"name", "face_body"}, {"type", "integer"}, {"default", -1}, {"description", "body that owns the face; -1 = target"}},
                     json{{"name", "face"},      {"type", "integer"}, {"description", "face id to split along (query_topology)"}},
                     json{{"name", "keep_upper"},{"type", "boolean"}, {"default", true}},
                     json{{"name", "keep_lower"},{"type", "boolean"}, {"default", true}},
                 })}},
             json{{"name", "project"}, {"summary", "Project edges of a solid onto a sketch plane, producing a new sketch feature."},
                  {"params", json::array({
                      json{{"name", "source_body"}, {"type", "integer"}, {"default", -1}, {"description", "body owning the edges; -1 = last body"}},
                      json{{"name", "face"},        {"type", "integer"}, {"default", -1}, {"description", "global face id on the source body; when set, all its edges are projected"}},
                      json{{"name", "edges"},       {"type", "array"}, {"default", json::array()}, {"description", "global edge ids to project; empty => project the face"}},
                      json{{"name", "plane"},       {"type", "string"}, {"default", "XY"}, {"description", "target sketch plane (XY/XZ/YZ)"}},
                  })}},
             json{{"name", "delete_face"}, {"summary", "Remove faces from a solid, healing the gap via OCCT defeaturing."},
                  {"params", json::array({
                      json{{"name", "body"},  {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                      json{{"name", "faces"}, {"type", "array"}, {"description", "global face ids to delete"}},
                  })}},
            json{{"name", "bridge"}, {"summary", "Build a cubic-Bezier G1 bridge (BSpline) between two sketch-entity endpoints within a sketch feature."},
                  {"params", json::array({
                      json{{"name", "sketch"}, {"type", "integer"}, {"description", "sketch feature index"}},
                      json{{"name", "ent_a"},  {"type", "integer"}, {"description", "first entity index within the sketch"}},
                      json{{"name", "end_a"},  {"type", "integer"}, {"enum", json::array({0, 1})}, {"default", 1}, {"description", "0 = start/p0 side, 1 = end/p1 side"}},
                      json{{"name", "ent_b"},  {"type", "integer"}, {"description", "second entity index within the sketch"}},
                      json{{"name", "end_b"},  {"type", "integer"}, {"enum", json::array({0, 1})}, {"default", 0}, {"description", "0 = start/p0 side, 1 = end/p1 side"}},
                  })}},
            json{{"name", "rib"}, {"summary", "Grow a thin rib wall (stiffener) from an open Line sketch entity, fused to a body."},
                  {"params", json::array({
                      json{{"name", "sketch"},    {"type", "integer"}, {"description", "sketch feature index holding the open line"}},
                      json{{"name", "entity"},    {"type", "integer"}, {"description", "entity index of the open Line within the sketch"}},
                      json{{"name", "thickness"}, {"type", "number"}, {"unit", "mm"}, {"default", 2}, {"min", 0.01}},
                      json{{"name", "depth"},     {"type", "number"}, {"unit", "mm"}, {"default", 10}, {"min", 0.01}},
                      json{{"name", "body"},      {"type", "integer"}, {"default", -1}, {"description", "target body; omit for the last body"}},
                  })}},
            json{{"name", "surface_extrude"}, {"summary", "Extrude a sketch wire with no end caps -> an open sheet body."},
                  {"params", json::array({
                      json{{"name", "sketch"},  {"type", "integer"}, {"description", "sketch feature index"}},
                      json{{"name", "distance"},{"type", "number"}, {"unit", "mm"}, {"default", 10}, {"min", 0.01}},
                  })}},
            json{{"name", "surface_revolve"}, {"summary", "Revolve a sketch wire with no caps -> an open sheet body."},
                  {"params", json::array({
                      json{{"name", "sketch"},  {"type", "integer"}, {"description", "sketch feature index"}},
                      json{{"name", "angle"},   {"type", "number"}, {"unit", "deg"}, {"default", 360}},
                      json{{"name", "axis"},    {"type", "integer"}, {"enum", json::array({0, 1})}, {"default", 0}},
                  })}},
            json{{"name", "mate"}, {"summary", "Mate two bodies: transform the moving body (cs_b) so its connector lands on the fixed one (cs_a). kind: 0=Fastened, 1=Planar, 2=Revolute, 3=Slider, 4=Cylindrical."},
                 {"params", json::array({
                     json{{"name", "kind"},    {"type", "integer"}, {"default", 0}, {"description", "0=Fastened (rigid), 1=Planar (normal only), 2=Revolute (free rotation about axis), 3=Slider (free translation along axis), 4=Cylindrical (free rotation+translation)"}},
                     json{{"name", "cs_a"},    {"type", "integer"}, {"description", "feature index of the fixed CoordSys (mate connector A)"}},
                     json{{"name", "cs_b"},    {"type", "integer"}, {"description", "feature index of the CoordSys on the body that moves"}},
                     json{{"name", "offset"},  {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                     json{{"name", "angle"},   {"type", "number"}, {"unit", "deg"}, {"default", 0}},
                     json{{"name", "flip"},    {"type", "boolean"}, {"default", false}},
                 })}},
            json{{"name", "check_interference"}, {"summary", "Solid bodies that overlap, as {body_a, body_b, volume}. Read-only; bodies that merely touch enclose no volume and are not reported."},
                 {"params", json::array({
                     json{{"name", "min_volume"}, {"type", "number"}, {"unit", "mm^3"}, {"default", 1e-6}, {"description", "overlap volume above which a pair counts as interfering"}},
                 })}},
            json{{"name", "query_topology"}, {"summary", "Measured faces (centroid/normal/cylinder) and edges (length/circle) of a body."},
                 {"params", json::array({
                     json{{"name", "body"}, {"type", "integer"}, {"default", 0}},
                 })}},
            json{{"name", "measure"}, {"summary", "Distance (and angle, when both have direction) between two refs {face|edge|point} on a body."},
                 {"params", json::array({
                     json{{"name", "body"}, {"type", "integer"}, {"default", 0}},
                     json{{"name", "a"}, {"type", "object"}},
                     json{{"name", "b"}, {"type", "object"}},
                 })}},
            json{{"name", "mass_properties"}, {"summary", "Volume / surface area / centre of mass / inertia tensor of a body."},
                 {"params", json::array({
                     json{{"name", "body"}, {"type", "integer"}, {"default", 0}},
                 })}},
            json{{"name", "slice_body"}, {"summary", "Cross-section of a body by a base plane at an offset (sections-as-evidence); returns ordered world contours, each flagged closed/open."},
                 {"params", json::array({
                     json{{"name", "body"}, {"type", "integer"}, {"default", 0}},
                     json{{"name", "plane"}, {"type", "string"}, {"enum", json::array({"XY", "XZ", "YZ"})}, {"default", "XY"}},
                     json{{"name", "offset"}, {"type", "number"}, {"unit", "mm"}, {"default", 0}},
                 })}},
            json{{"name", "import_step"}, {"summary", "Import a STEP file as native B-rep bodies (the reference part to measure)."},
                 {"params", json::array({
                     json{{"name", "path"}, {"type", "string"}},
                 })}},
            json{{"name", "import_mesh"}, {"summary", "Convert a triangle mesh (STL/OBJ) into an editable B-rep body. Reports whether the result is a real solid or an open shell, and why."},
                 {"params", json::array({
                     json{{"name", "path"}, {"type", "string"}},
                     json{{"name", "tolerance"}, {"type", "number"}, {"default", 0.01}},
                     json{{"name", "merge_angle_deg"}, {"type", "number"}, {"default", 5.0}},
                 })}},
            json{{"name", "validate_against"}, {"summary", "Volume + bbox/centroid + surface deviation (max/mean/rms mm) of a body vs a reference {step:path|body:id} (the RE acceptance metric)."},
                 {"params", json::array({
                     json{{"name", "body"}, {"type", "integer"}, {"default", 0}},
                     json{{"name", "reference"}, {"type", "object"}},
                 })}},
        })},
    };
}

References describe_tools().

Referenced by describe_tools(), and handle_on_main().

Here is the call graph for this function:

Here is the caller graph for this function:

dispatch_request()

std::string Slic3r::GUI::anonymous_namespace{McpControl.cpp}::dispatch_request

(

const std::string &

line

)

{
    json req;
    try { req = json::parse(line); }
    catch (const std::exception& ex) { return rpc_error(nullptr, -32700, std::string("parse error: ") + ex.what()); }
 
    json id           = req.contains("id") ? req["id"] : json(nullptr);
    std::string method = req.value("method", std::string());
    json params        = req.contains("params") ? req["params"] : json::object();
    if (method.empty()) return rpc_error(id, -32600, "missing method");
 
    auto prom = std::make_shared<std::promise<std::string>>();
    auto fut  = prom->get_future();
    // 0 = queued, 1 = running, 2 = abandoned. A request that timed out while still QUEUED must
    // never run: the client has been told it failed, and a retry would otherwise apply it twice.
    auto state = std::make_shared<std::atomic<int>>(0);
    // Nothing may escape this lambda. It is invoked by the wx event loop, which has no
    // handler of its own, so an escaping exception is std::terminate — the socket would
    // become a way for any client to kill the application. handle_on_main() catches what
    // it knows about; this catches what it does not, and still answers the caller.
    wxGetApp().CallAfter([prom, state, method, params, id]() {
        int queued = 0;
        if (!state->compare_exchange_strong(queued, 1)) return;   // abandoned by a timeout
        try {
            prom->set_value(handle_on_main(method, params, id));
        } catch (const std::exception& ex) {
            prom->set_value(rpc_error(id, -32000, std::string("internal error: ") + ex.what()));
        } catch (...) {
            prom->set_value(rpc_error(id, -32000, "internal error: unknown exception"));
        }
    });
    if (fut.wait_for(std::chrono::seconds(15)) != std::future_status::ready) {
        int queued = 0;
        if (state->compare_exchange_strong(queued, 2))
            return rpc_error(id, -32000, "main-thread timeout: the command was NOT run");
        // Already running: it will finish, so wait for its real answer rather than report a
        // failure for a command that is in fact being applied.
        fut.wait();
    }
    return fut.get();
}

References dispatch_request(), handle_on_main(), and rpc_error().

Referenced by dispatch_request(), and serve_client().

Here is the call graph for this function:

Here is the caller graph for this function:

edge_ids_arg()

std::vector< int > Slic3r::GUI::anonymous_namespace{McpControl.cpp}::edge_ids_arg	(	const json &	params,
		const char *	verb )

{
    if (!params.contains("edge"))
        throw std::runtime_error(std::string(verb) + " needs 'edge' (id or array of ids from query_topology)");
    const json& e = params["edge"];
    std::vector<int> ids;
    if (e.is_array()) for (const json& v : e) ids.push_back(v.get<int>());
    else              ids.push_back(e.get<int>());
    if (ids.empty()) throw std::runtime_error(std::string(verb) + ": 'edge' is an empty array");
    return ids;
}

References edge_ids_arg().

Referenced by action_chamfer(), action_fillet(), and edge_ids_arg().

Here is the call graph for this function:

Here is the caller graph for this function:

feature_type_name()

const char * Slic3r::GUI::anonymous_namespace{McpControl.cpp}::feature_type_name

(

CadFeatureType

t

)

{
    switch (t) {
        case CadFeatureType::Sketch:  return "Sketch";
        case CadFeatureType::Extrude: return "Extrude";
        case CadFeatureType::Fillet:  return "Fillet";
        case CadFeatureType::Chamfer: return "Chamfer";
        case CadFeatureType::Hole:    return "Hole";
        case CadFeatureType::Thread:  return "Thread";
        case CadFeatureType::Shell:   return "Shell";
        case CadFeatureType::Revolve: return "Revolve";
        case CadFeatureType::Sweep:   return "Sweep";
        case CadFeatureType::Pattern: return "Pattern";
        case CadFeatureType::Plane:   return "Plane";
        case CadFeatureType::Loft:    return "Loft";
        case CadFeatureType::Draft:   return "Draft";
        case CadFeatureType::Import:  return "Import";
        case CadFeatureType::Boolean: return "Boolean";
         case CadFeatureType::Cut:     return "Cut";
        case CadFeatureType::Mirror:  return "Mirror";
        case CadFeatureType::Axis:    return "Axis";
        case CadFeatureType::CoordSys: return "CoordSys";
        case CadFeatureType::Helix:    return "Helix";
        case CadFeatureType::Transform: return "Transform";
        case CadFeatureType::Thicken:  return "Thicken";
        case CadFeatureType::Project:  return "Project";
        case CadFeatureType::DeleteFace: return "DeleteFace";
        case CadFeatureType::Rib:        return "Rib";
        case CadFeatureType::SurfaceExtrude: return "SurfaceExtrude";
        case CadFeatureType::SurfaceRevolve: return "SurfaceRevolve";
        case CadFeatureType::ThickenSurface: return "ThickenSurface";
        case CadFeatureType::SurfaceOffset:   return "SurfaceOffset";
        case CadFeatureType::SurfaceLoft:     return "SurfaceLoft";
        case CadFeatureType::SurfaceFill:     return "SurfaceFill";
        case CadFeatureType::Mate:      return "Mate";
    }
    return "Unknown";
}

References Slic3r::Axis, Slic3r::Boolean, Slic3r::Chamfer, Slic3r::CoordSys, Slic3r::Cut, Slic3r::DeleteFace, Slic3r::Draft, Slic3r::Extrude, feature_type_name(), Slic3r::Fillet, Slic3r::Helix, Slic3r::Hole, Slic3r::Import, Slic3r::Loft, Slic3r::Mate, Slic3r::Mirror, Slic3r::Pattern, Slic3r::Plane, Slic3r::Project, Slic3r::Revolve, Slic3r::Rib, Slic3r::Shell, Slic3r::Sketch, Slic3r::SurfaceExtrude, Slic3r::SurfaceFill, Slic3r::SurfaceLoft, Slic3r::SurfaceOffset, Slic3r::SurfaceRevolve, Slic3r::Sweep, Slic3r::Thicken, Slic3r::ThickenSurface, Slic3r::Thread, and Slic3r::Transform.

Referenced by describe_scene(), and feature_type_name().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_on_main()

std::string Slic3r::GUI::anonymous_namespace{McpControl.cpp}::handle_on_main	(	const std::string &	method,
		const json &	params,
		const json &	id )

{
    // The panel is built on first use, and in a headless session nobody clicks the tab that
    // would build it -- so build it here rather than refusing. Safe: this runs on the main
    // thread (see the CallAfter that dispatches us).
    DesignPanel* panel = DesignPanel::ensure();
    if (!panel)
        return rpc_error(id, -32001, "Design panel not ready");
    // A project opened without ever showing the Design tab has its recipe only in the Model;
    // load it, as showing the tab would, before anything reads or writes the document.
    panel->hydrate_from_model();
 
    // Methods that only LOOK. Everything else changes the document or the live sketch, and
    // must not do it under a GUI editor, a sketch session it does not own, or a rebuild in
    // progress (the GUI's worker thread holds the document then).
    static const std::set<std::string> kReadOnly = {
        "describe_tools", "describe_scene", "query_topology", "measure", "mass_properties",
        "slice_body", "validate_against", "list_verbs", "sketch_describe", "sketch_validate",
        "check_interference" };
    if (kReadOnly.count(method) == 0) {
        std::string why;
        if (panel->mcp_busy(method.rfind("sketch_", 0) == 0, why))
            return rpc_error(id, -32002, "Design tab busy: " + why);
    }
 
    // Stale-id guard, checked here rather than in each handler.
    //
    // Global face and edge ids are indices into TopExp::MapShapes, valid only against the
    // topology that produced them. Every dress-up rewrites those maps, so the natural way to
    // drive this socket — read the scene once, then issue several operations — silently
    // addresses the WRONG edge on every call after the first. Measured on a box: four chamfers
    // with ids re-read each time remove 0.400/0.397/0.397/0.395 mm3; the same four with ids
    // captured up front remove 0.400/0.008/0.397/0.280. Neither run errors, because a stale id
    // still resolves to a real edge — just not the one that was asked for.
    //
    // So a caller may pass back the "generation" it got from describe_scene or query_topology,
    // and a mismatch is refused instead of silently obeyed. Optional by design: omitting it
    // keeps every existing script working exactly as before, and supplying it is what buys the
    // guarantee. One check at the dispatcher rather than one per handler, so a method added
    // later cannot forget it.
    //
    // The type check is not decoration: this runs OUTSIDE the try below, and a bare
    // get<uint64_t>() on `"generation": "x"` throws nlohmann::type_error straight out of
    // the CallAfter lambda that invoked us — through a wx event loop, which does not catch,
    // so the whole GUI went down on one malformed line. Refuse it as a parameter error.
    if (params.is_object() && params.contains("generation")) {
        if (!params["generation"].is_number_unsigned())
            return rpc_error(id, -32602, "generation must be an unsigned integer");
        const uint64_t want = params["generation"].get<uint64_t>();
        const uint64_t have = panel->mcp_doc().topo_generation;
        if (want != have)
            return rpc_error(id, -32010,
                "stale face/edge ids: they were read at generation " + std::to_string(want)
                + " but the model is now at " + std::to_string(have)
                + ". Re-read query_topology and use the new ids — the old ones still name real "
                  "edges, just not the ones you measured.");
    }
 
    try {
        if (method == "describe_tools") return rpc_result(id, describe_tools());
        if (method == "describe_scene") return rpc_result(id, describe_scene(panel));
        if (method == "query_topology") return rpc_result(id, query_topology(panel, params));
        if (method == "measure")        return rpc_result(id, measure(panel, params));
        if (method == "mass_properties") return rpc_result(id, mass_properties(panel, params));
        if (method == "slice_body")     return rpc_result(id, slice_body(panel, params));
        if (method == "import_step")    return rpc_result(id, import_step(panel, params));
        if (method == "import_mesh")    return rpc_result(id, import_mesh(panel, params));
        if (method == "validate_against") return rpc_result(id, validate_against(panel, params));
        if (method == "extrude")        return rpc_result(id, action_extrude(panel, params));
        if (method == "revolve")        return rpc_result(id, action_revolve(panel, params));
        if (method == "fillet")         return rpc_result(id, action_fillet(panel, params));
        if (method == "chamfer")        return rpc_result(id, action_chamfer(panel, params));
        if (method == "hole")           return rpc_result(id, action_hole(panel, params));
        if (method == "hole_styled")   return rpc_result(id, action_hole_styled(panel, params));
        if (method == "hole_standard") return rpc_result(id, action_hole_standard(panel, params));
        if (method == "boolean")        return rpc_result(id, action_boolean(panel, params));
        if (method == "pattern")        return rpc_result(id, action_pattern(panel, params));
        if (method == "pattern_on_curve") return rpc_result(id, action_pattern_on_curve(panel, params));
        if (method == "shell")          return rpc_result(id, action_shell(panel, params));
        if (method == "rib")            return rpc_result(id, action_rib(panel, params));
        if (method == "draft")          return rpc_result(id, action_draft(panel, params));
        if (method == "mirror")         return rpc_result(id, action_mirror(panel, params));
        if (method == "sketch_begin")   return rpc_result(id, action_sketch_begin(panel, params));
        if (method == "sketch_commit")  return rpc_result(id, action_sketch_commit(panel, params));
        if (method == "sketch_cancel")  return rpc_result(id, action_sketch_cancel(panel, params));
        if (method == "sketch_add")     return rpc_result(id, action_sketch_add(panel, params));
        if (method == "sketch_select")  return rpc_result(id, action_sketch_select(panel, params));
        if (method == "sketch_delete")  return rpc_result(id, action_sketch_delete(panel, params));
        if (method == "sketch_construction") return rpc_result(id, action_sketch_construction(panel, params));
        if (method == "sketch_offset")  return rpc_result(id, action_sketch_offset(panel, params));
        if (method == "sketch_mirror")  return rpc_result(id, action_sketch_mirror(panel, params));
        if (method == "sketch_describe") return rpc_result(id, action_sketch_describe(panel, params));
        if (method == "sketch_validate") return rpc_result(id, action_sketch_validate(panel, params));
        if (method == "sketch_heal")    return rpc_result(id, action_sketch_heal(panel, params));
        if (method == "sketch_set_value") return rpc_result(id, action_sketch_set_value(panel, params));
        if (method == "list_verbs")     return rpc_result(id, action_list_verbs(panel, params));
        if (method == "run_verb")       return rpc_result(id, action_run_verb(panel, params));
        if (method == "transform")      return rpc_result(id, action_transform(panel, params));
        if (method == "thicken")        return rpc_result(id, action_thicken(panel, params));
        if (method == "split")          return rpc_result(id, action_split(panel, params));
        if (method == "project")        return rpc_result(id, action_project(panel, params));
        if (method == "delete_face")    return rpc_result(id, action_delete_face(panel, params));
        if (method == "bridge")         return rpc_result(id, action_bridge(panel, params));
        if (method == "axis")           return rpc_result(id, action_axis(panel, params));
        if (method == "coordsys")       return rpc_result(id, action_coordsys(panel, params));
        if (method == "helix")          return rpc_result(id, action_helix(panel, params));
        if (method == "set_variable")     return rpc_result(id, action_set_variable(panel, params));
        if (method == "set_feature_expr") return rpc_result(id, action_set_feature_expr(panel, params));
        if (method == "surface_extrude")  return rpc_result(id, action_surface_extrude(panel, params));
        if (method == "surface_revolve")  return rpc_result(id, action_surface_revolve(panel, params));
        if (method == "thicken_surface")  return rpc_result(id, action_thicken_surface(panel, params));
        if (method == "surface_offset")   return rpc_result(id, action_surface_offset(panel, params));
        if (method == "surface_loft")    return rpc_result(id, action_surface_loft(panel, params));
        if (method == "surface_fill")    return rpc_result(id, action_surface_fill(panel, params));
        if (method == "mate")          return rpc_result(id, action_mate(panel, params));
        if (method == "check_interference") return rpc_result(id, action_check_interference(panel, params));
        return rpc_error(id, -32601, "Unknown method: " + method);
    } catch (const Standard_Failure& ex) {   // derives from std::exception, so it comes first
        return rpc_error(id, -32000, std::string("OCCT: ") + (*ex.what() ? ex.what() : "failure"));
    } catch (const std::exception& ex) {
        return rpc_error(id, -32000, ex.what());
    }
}

References action_axis(), action_boolean(), action_bridge(), action_chamfer(), action_check_interference(), action_coordsys(), action_delete_face(), action_draft(), action_extrude(), action_fillet(), action_helix(), action_hole(), action_hole_standard(), action_hole_styled(), action_list_verbs(), action_mate(), action_mirror(), action_pattern(), action_pattern_on_curve(), action_project(), action_revolve(), action_rib(), action_run_verb(), action_set_feature_expr(), action_set_variable(), action_shell(), action_sketch_add(), action_sketch_begin(), action_sketch_cancel(), action_sketch_commit(), action_sketch_construction(), action_sketch_delete(), action_sketch_describe(), action_sketch_heal(), action_sketch_mirror(), action_sketch_offset(), action_sketch_select(), action_sketch_set_value(), action_sketch_validate(), action_split(), action_surface_extrude(), action_surface_fill(), action_surface_loft(), action_surface_offset(), action_surface_revolve(), action_thicken(), action_thicken_surface(), action_transform(), describe_scene(), describe_tools(), Slic3r::GUI::LazyInstance< DesignPanel >::ensure(), handle_on_main(), Slic3r::GUI::DesignPanel::hydrate_from_model(), import_mesh(), import_step(), mass_properties(), Slic3r::GUI::DesignPanel::mcp_busy(), Slic3r::GUI::DesignPanel::mcp_doc(), measure(), query_topology(), rpc_error(), rpc_result(), slice_body(), Slic3r::CadDocument::topo_generation, and validate_against().

Referenced by dispatch_request(), and handle_on_main().

Here is the caller graph for this function:

import_mesh()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_mesh	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("path")) throw std::runtime_error("import_mesh needs 'path'");
    const std::string path       = params["path"].get<std::string>();
    const double tolerance       = params.value("tolerance", 0.01);
    const double merge_angle_deg = params.value("merge_angle_deg", 5.0);
 
    TriangleMesh mesh;
    const std::string ext = boost::algorithm::to_lower_copy(
        boost::filesystem::path(path).extension().string());
    if (ext == ".stl") {
        if (!mesh.ReadSTLFile(path.c_str())) throw std::runtime_error("could not read STL: " + path);
    } else if (ext == ".obj") {
        ObjInfo obj_info; std::string obj_err;
        if (!load_obj(path.c_str(), &mesh, obj_info, obj_err))
            throw std::runtime_error("could not read OBJ: " + obj_err);
    } else {
        throw std::runtime_error("unsupported mesh format (want .stl or .obj): " + ext);
    }
 
    GeometryEngine::MeshBrepStats st;
    const TopoDS_Shape shape = GeometryEngine::mesh_to_brep(mesh.its, tolerance, merge_angle_deg, st);
    if (shape.IsNull()) throw std::runtime_error("mesh conversion produced no geometry");
 
    CadDocument& doc = panel->mcp_doc();
    doc.checkpoint();
    const int first = int(doc.features.size());
    CadFeature f;
    f.type           = CadFeatureType::Import;
    f.name           = "Mesh" + std::to_string(first + 1);
    f.imported_solid = shape;
    f.mode           = BooleanMode::New;
    doc.features.push_back(f);
 
    const bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"first_feature", first}, {"bodies", int(doc.bodies.size())},
                {"input_triangles", st.input_tris}, {"kept_triangles", st.kept_tris},
                {"degenerate_collapsed", st.degenerate_collapsed},
                {"degenerate_sliver", st.degenerate_sliver},
                {"faces_built", st.faces_built}, {"faces_failed", st.faces_failed},
                {"faces_final", st.faces_final}, {"unique_edges", st.unique_edges},
                {"boundary_edges", st.boundary_edges},
                {"nonmanifold_edges", st.nonmanifold_edges},
                {"watertight", st.watertight}, {"is_solid", st.is_solid},
                {"volume", st.volume}, {"error", doc.error}};
}

References Slic3r::CadDocument::bodies, Slic3r::GeometryEngine::MeshBrepStats::boundary_edges, Slic3r::CadDocument::checkpoint(), Slic3r::GeometryEngine::MeshBrepStats::degenerate_collapsed, Slic3r::GeometryEngine::MeshBrepStats::degenerate_sliver, Slic3r::CadDocument::error, Slic3r::f(), Slic3r::GeometryEngine::MeshBrepStats::faces_built, Slic3r::GeometryEngine::MeshBrepStats::faces_failed, Slic3r::GeometryEngine::MeshBrepStats::faces_final, Slic3r::CadDocument::features, Slic3r::Import, import_mesh(), Slic3r::GeometryEngine::MeshBrepStats::input_tris, Slic3r::GeometryEngine::MeshBrepStats::is_solid, Slic3r::TriangleMesh::its, Slic3r::GeometryEngine::MeshBrepStats::kept_tris, Slic3r::load_obj(), Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::GeometryEngine::mesh_to_brep(), Slic3r::New, Slic3r::GeometryEngine::MeshBrepStats::nonmanifold_edges, Slic3r::TriangleMesh::ReadSTLFile(), Slic3r::CadDocument::recompute(), Slic3r::CadDocument::undo(), Slic3r::GeometryEngine::MeshBrepStats::unique_edges, Slic3r::GeometryEngine::MeshBrepStats::volume, and Slic3r::GeometryEngine::MeshBrepStats::watertight.

Referenced by handle_on_main(), and import_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

import_step()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::import_step	(	DesignPanel *	panel,
		const json &	params )

{
    if (!params.contains("path")) throw std::runtime_error("import_step needs 'path'");
    const std::string path = params["path"].get<std::string>();
    std::string err;
    std::vector<TopoDS_Shape> solids = GeometryEngine::read_step_solids(path, err);
    if (solids.empty()) throw std::runtime_error(err.empty() ? "no solids in STEP" : err);
 
    CadDocument& doc = panel->mcp_doc();
    doc.checkpoint();
    int first = int(doc.features.size());
    for (const TopoDS_Shape& s : solids) {
        CadFeature f;
        f.type           = CadFeatureType::Import;
        f.name           = "STEP" + std::to_string(int(doc.features.size()) + 1);
        f.imported_solid = s;
        f.mode           = BooleanMode::New;   // each solid = its own coexisting body
        doc.features.push_back(f);
    }
    bool ok = doc.recompute();
    if (!ok) { const std::string why = doc.error; doc.undo(); doc.error = why; }
    panel->mcp_after_change();
    return json{{"ok", ok}, {"imported", int(solids.size())}, {"first_feature", first},
                {"bodies", int(doc.bodies.size())}, {"error", doc.error}};
}

References Slic3r::CadDocument::bodies, Slic3r::CadDocument::checkpoint(), Slic3r::CadDocument::error, Slic3r::f(), Slic3r::CadDocument::features, Slic3r::Import, import_step(), Slic3r::GUI::DesignPanel::mcp_after_change(), Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::New, Slic3r::GeometryEngine::read_step_solids(), Slic3r::CadDocument::recompute(), and Slic3r::CadDocument::undo().

Referenced by handle_on_main(), and import_step().

Here is the call graph for this function:

Here is the caller graph for this function:

mass_properties()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::mass_properties	(	DesignPanel *	panel,
		const json &	params )

{
    const TopoDS_Shape& shape = body_shape(panel, params);
    auto mp = GeometryEngine::mass_properties(shape);
    if (!mp.valid) throw std::runtime_error("mass properties could not be computed (null/empty shape)");
    // A sheet body has no volume and no inertia. Report the area and say so, rather than
    // returning numbers a caller would reasonably treat as a material check.
    if (!mp.is_solid)
        return json{
            {"surface_area", mp.surface_area},
            {"volume", 0.0},
            {"is_solid", false},
            {"valid", mp.valid},
            {"note", "sheet body (open shell): it encloses no material, so volume and inertia "
                     "are not defined; surface_area is exact"},
        };
    return json{
        {"volume", mp.volume},
        {"surface_area", mp.surface_area},
        {"center_of_mass", json::array({mp.center_of_mass.x(), mp.center_of_mass.y(), mp.center_of_mass.z()})},
        {"inertia", mp.inertia},
        {"is_solid", true},
        {"valid", mp.valid},
    };
}

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

Referenced by handle_on_main(), and mass_properties().

Here is the call graph for this function:

Here is the caller graph for this function:

mcp_sketch()

DesignSketchTool & Slic3r::GUI::anonymous_namespace{McpControl.cpp}::mcp_sketch

(

DesignPanel *

panel

)

{
    DesignCanvas* vp = panel->mcp_viewport();
    if (vp == nullptr) throw std::runtime_error("no viewport");
    if (!vp->is_sketching())
        throw std::runtime_error("no sketch is open — call sketch_begin first");
    return vp->mcp_sketch_tool();
}

References Slic3r::GUI::DesignCanvas::is_sketching(), mcp_sketch(), Slic3r::GUI::DesignCanvas::mcp_sketch_tool(), and Slic3r::GUI::DesignPanel::mcp_viewport().

Referenced by action_sketch_add(), action_sketch_construction(), action_sketch_delete(), action_sketch_describe(), action_sketch_heal(), action_sketch_mirror(), action_sketch_offset(), action_sketch_select(), action_sketch_set_value(), action_sketch_validate(), and mcp_sketch().

Here is the call graph for this function:

Here is the caller graph for this function:

measure()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::measure	(	DesignPanel *	panel,
		const json &	params )

{
    const TopoDS_Shape& shape = body_shape(panel, params);
    Vec3d pa, pb, da, db; bool hda = false, hdb = false;
    if (!params.contains("a") || !params.contains("b"))
        throw std::runtime_error("measure needs refs 'a' and 'b' ({face|edge|point})");
    if (!resolve_ref(shape, params["a"], pa, da, hda) || !resolve_ref(shape, params["b"], pb, db, hdb))
        throw std::runtime_error("could not resolve a measurement reference");
    json r{{"distance", (pa - pb).norm()}, {"point_a", vec3(pa)}, {"point_b", vec3(pb)}};
    if (hda && hdb) {
        double c = std::max(-1.0, std::min(1.0, da.normalized().dot(db.normalized())));
        r["angle_deg"] = std::acos(c) * 180.0 / M_PI;
    }
    return r;
}

References body_shape(), M_PI, measure(), resolve_ref(), and vec3().

Referenced by handle_on_main(), and measure().

Here is the call graph for this function:

Here is the caller graph for this function:

plane_from()

SketchPlane Slic3r::GUI::anonymous_namespace{McpControl.cpp}::plane_from	(	const json &	params,
		const CadDocument &	doc )

{
    std::string n = params.value("plane", std::string("XY"));
    SketchPlane pl = n == "XZ" ? SketchPlane::XZ() : n == "YZ" ? SketchPlane::YZ() : SketchPlane::XY();
    pl.origin = doc.modeling_origin;   // land on the bed centre, like the GUI
    return pl;
}

References Slic3r::CadDocument::modeling_origin, Slic3r::SketchPlane::origin, plane_from(), Slic3r::SketchPlane::XY(), Slic3r::SketchPlane::XZ(), and Slic3r::SketchPlane::YZ().

Referenced by action_extrude(), action_helix(), action_hole(), action_hole_standard(), action_hole_styled(), action_mirror(), action_pattern(), action_project(), action_revolve(), and plane_from().

Here is the call graph for this function:

Here is the caller graph for this function:

profile_from()

bool Slic3r::GUI::anonymous_namespace{McpControl.cpp}::profile_from	(	const json &	params,
		SketchProfile &	out )

{
    if (!params.contains("profile")) return false;
    out.points.clear();
    for (const auto& p : params["profile"]) out.points.emplace_back(p[0].get<double>(), p[1].get<double>());
    out.closed = true;
    return out.points.size() >= 3;
}

References Slic3r::SketchProfile::closed, Slic3r::SketchProfile::points, and profile_from().

Referenced by action_extrude(), action_revolve(), and profile_from().

Here is the call graph for this function:

Here is the caller graph for this function:

query_topology()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::query_topology	(	DesignPanel *	panel,
		const json &	params )

{
    const TopoDS_Shape& shape = body_shape(panel, params);
    // Enumerate once. The _by_index accessors rescan the shape on every call (edge_by_index
    // rebuilds the whole indexed map), so indexing a body face-by-face is quadratic: ~15 s on a
    // 4.7k-face imported solid, on the UI thread. faces_of/edges_of keep the very same ids.
    const std::vector<TopoDS_Face> all_faces = GeometryEngine::faces_of(shape);
    const std::vector<TopoDS_Edge> all_edges = GeometryEngine::edges_of(shape);
 
    json faces = json::array();
    const int nf = int(all_faces.size());
    for (int i = 0; i < nf; ++i) {
        const TopoDS_Face& f = all_faces[i];
        if (f.IsNull()) continue;
        json jf{{"id", i}, {"centroid", vec3(GeometryEngine::face_centroid_world(f))},
                {"normal", vec3(GeometryEngine::face_normal_world(f))}, {"kind", "planar"}};
        GeometryEngine::CylinderFace cyl = GeometryEngine::cylinder_of_face(f);
        if (cyl.ok) { jf["kind"] = "cylindrical"; jf["radius"] = cyl.radius;
                      jf["axis"] = vec3(cyl.axis); jf["internal"] = cyl.internal; }
        faces.push_back(std::move(jf));
    }
    json edges = json::array();
    const int ne = int(all_edges.size());
    for (int i = 0; i < ne; ++i) {
        const TopoDS_Edge& e = all_edges[i];
        if (e.IsNull()) continue;
        std::vector<Vec3d> pts = GeometryEngine::sample_edge_world(e);
        if (pts.size() < 2) continue;
        double len = 0; for (size_t k = 1; k < pts.size(); ++k) len += (pts[k] - pts[k-1]).norm();
        json je{{"id", i}, {"length", len}, {"p0", vec3(pts.front())}, {"p1", vec3(pts.back())},
                {"kind", "line"}};
        GeometryEngine::CylinderFace circ = GeometryEngine::circle_of_edge(e);
        if (circ.ok) { je["kind"] = "circle"; je["radius"] = circ.radius; je["center"] = vec3(circ.base); }
        edges.push_back(std::move(je));
    }
    return json{{"body", params.value("body", 0)}, {"face_count", nf}, {"edge_count", ne},
                {"faces", std::move(faces)}, {"edges", std::move(edges)},
                // The ids above are indices into this exact topology and expire with it. Echo
                // this back as "generation" on the calls that consume them.
                {"generation", panel->mcp_doc().topo_generation}};
}

References Slic3r::GeometryEngine::CylinderFace::axis, Slic3r::GeometryEngine::CylinderFace::base, body_shape(), Slic3r::GeometryEngine::circle_of_edge(), Slic3r::GeometryEngine::cylinder_of_face(), Slic3r::GeometryEngine::edges_of(), Slic3r::f(), Slic3r::GeometryEngine::face_centroid_world(), Slic3r::GeometryEngine::face_normal_world(), Slic3r::GeometryEngine::faces_of(), Slic3r::GeometryEngine::CylinderFace::internal, Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::GeometryEngine::CylinderFace::ok, query_topology(), Slic3r::GeometryEngine::CylinderFace::radius, Slic3r::GeometryEngine::sample_edge_world(), Slic3r::CadDocument::topo_generation, and vec3().

Referenced by handle_on_main(), and query_topology().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_socket_at_exit()

void Slic3r::GUI::anonymous_namespace{McpControl.cpp}::remove_socket_at_exit

(

)

{
    struct stat st{};
    if (!g_sock_path.empty() && ::lstat(g_sock_path.c_str(), &st) == 0 && S_ISSOCK(st.st_mode))
        ::unlink(g_sock_path.c_str());
}

References g_sock_path, and remove_socket_at_exit().

Referenced by remove_socket_at_exit(), and server_thread().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_ref()

bool Slic3r::GUI::anonymous_namespace{McpControl.cpp}::resolve_ref	(	const TopoDS_Shape &	shape,
		const json &	ref,
		Vec3d &	point,
		Vec3d &	dir,
		bool &	has_dir )

{
    has_dir = false;
    if (ref.contains("point")) { auto p = ref["point"]; point = Vec3d(p[0], p[1], p[2]); return true; }
    if (ref.contains("face")) {
        TopoDS_Face f = GeometryEngine::face_by_index(shape, ref["face"].get<int>());
        if (f.IsNull()) return false;
        point = GeometryEngine::face_centroid_world(f);
        dir = GeometryEngine::face_normal_world(f); has_dir = true; return true;
    }
    if (ref.contains("edge")) {
        TopoDS_Edge e = GeometryEngine::edge_by_index(shape, ref["edge"].get<int>());
        if (e.IsNull()) return false;
        std::vector<Vec3d> pts = GeometryEngine::sample_edge_world(e);
        if (pts.empty()) return false;
        point = pts[pts.size() / 2];                       // midpoint sample
        if (pts.size() >= 2) { dir = (pts.back() - pts.front()).normalized(); has_dir = true; }
        return true;
    }
    return false;
}

References Slic3r::GeometryEngine::edge_by_index(), Slic3r::f(), Slic3r::GeometryEngine::face_by_index(), Slic3r::GeometryEngine::face_centroid_world(), Slic3r::GeometryEngine::face_normal_world(), resolve_ref(), and Slic3r::GeometryEngine::sample_edge_world().

Referenced by measure(), and resolve_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_error()

std::string Slic3r::GUI::anonymous_namespace{McpControl.cpp}::rpc_error	(	const json &	id,
		int	code,
		const std::string &	msg )

{
    return json{{"jsonrpc", "2.0"}, {"id", id},
                {"error", {{"code", code}, {"message", msg}}}}.dump();
}

References rpc_error().

Referenced by dispatch_request(), handle_on_main(), and rpc_error().

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_result()

std::string Slic3r::GUI::anonymous_namespace{McpControl.cpp}::rpc_result	(	const json &	id,
		const json &	result )

{
    return json{{"jsonrpc", "2.0"}, {"id", id}, {"result", result}}.dump();
}

References rpc_result().

Referenced by handle_on_main(), and rpc_result().

Here is the call graph for this function:

Here is the caller graph for this function:

serve_client()

void Slic3r::GUI::anonymous_namespace{McpControl.cpp}::serve_client

(

int

cfd

)

{
    constexpr size_t kMaxLine = 16u << 20;   // 16 MB — far above any real request
    std::string buf;
    char chunk[4096];
    for (;;) {
        ssize_t n = ::read(cfd, chunk, sizeof(chunk));
        if (n <= 0) break;
        buf.append(chunk, size_t(n));
        if (buf.size() > kMaxLine && buf.find('\n') == std::string::npos) {
            BOOST_LOG_TRIVIAL(error) << "MCP: request line over " << kMaxLine << " bytes; closing the connection";
            return;
        }
        size_t nl;
        while ((nl = buf.find('\n')) != std::string::npos) {
            std::string line = buf.substr(0, nl);
            buf.erase(0, nl + 1);
            if (line.empty()) continue;
            std::string reply = dispatch_request(line);
            reply.push_back('\n');
            // Never a bare write(): a client that hangs up between its request and our
            // reply raises SIGPIPE, whose default action kills the process — so closing
            // a socket mid-call would take the GUI with it.
#ifdef MSG_NOSIGNAL
            if (::send(cfd, reply.data(), reply.size(), MSG_NOSIGNAL) < 0) return;
#else
            if (::write(cfd, reply.data(), reply.size()) < 0) return;   // SO_NOSIGPIPE set at accept
#endif
        }
    }
}

References dispatch_request(), and serve_client().

Referenced by serve_client(), and server_thread().

Here is the call graph for this function:

Here is the caller graph for this function:

server_thread()

void Slic3r::GUI::anonymous_namespace{McpControl.cpp}::server_thread

(

std::string

sock_path

)

{
    // Clear a stale socket from an earlier run — and ONLY a socket. ORCA_CAD_MCP names a path,
    // and unlinking it unconditionally deleted whatever file that path happened to be.
    {
        struct stat st{};
        if (::lstat(sock_path.c_str(), &st) == 0) {
            if (!S_ISSOCK(st.st_mode)) {
                BOOST_LOG_TRIVIAL(error) << "MCP: " << sock_path << " exists and is not a socket; refusing to replace it";
                return;
            }
            ::unlink(sock_path.c_str());
        }
    }
    int sfd = ::socket(AF_UNIX, SOCK_STREAM, 0);
    if (sfd < 0) { BOOST_LOG_TRIVIAL(error) << "MCP: socket() failed"; return; }
 
    sockaddr_un addr{};
    addr.sun_family = AF_UNIX;
    std::strncpy(addr.sun_path, sock_path.c_str(), sizeof(addr.sun_path) - 1);
    // The socket is the full CAD command surface, including import_step on absolute paths.
    // It lands in a world-writable directory by default (/tmp), so its access control is
    // its file mode and nothing else — leaving that to the ambient umask means any local
    // process may drive the modeller. umask around bind() makes it 0600 with no window in
    // which a wider mode exists; the chmod afterwards covers platforms that do not apply
    // umask to sockets.
    const mode_t old_umask = ::umask(0177);
    const int bind_rc = ::bind(sfd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
    ::umask(old_umask);
    if (bind_rc < 0) {
        BOOST_LOG_TRIVIAL(error) << "MCP: bind() failed on " << sock_path;
        ::close(sfd); return;
    }
    if (::chmod(sock_path.c_str(), S_IRUSR | S_IWUSR) < 0) {
        BOOST_LOG_TRIVIAL(error) << "MCP: cannot restrict " << sock_path << " to the owner; refusing to listen";
        ::close(sfd); ::unlink(sock_path.c_str()); return;
    }
    if (::listen(sfd, 1) < 0) { BOOST_LOG_TRIVIAL(error) << "MCP: listen() failed"; ::close(sfd); return; }
    g_sock_path = sock_path;
    std::atexit(remove_socket_at_exit);   // do not leave the socket file behind
    BOOST_LOG_TRIVIAL(info) << "MCP control listening on " << sock_path;
 
    for (;;) {
        int cfd = ::accept(sfd, nullptr, nullptr);
        if (cfd < 0) continue;
#if !defined(MSG_NOSIGNAL) && defined(SO_NOSIGPIPE)
        const int on = 1;                                   // macOS/BSD equivalent of MSG_NOSIGNAL
        ::setsockopt(cfd, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof(on));
#endif
        serve_client(cfd);
        ::close(cfd);
    }
}

References g_sock_path, remove_socket_at_exit(), serve_client(), and server_thread().

Referenced by server_thread().

Here is the call graph for this function:

Here is the caller graph for this function:

shape_metrics()

ShapeMetrics Slic3r::GUI::anonymous_namespace{McpControl.cpp}::shape_metrics

(

const TopoDS_Shape &

s

)

{
    GProp_GProps vp; BRepGProp::VolumeProperties(s, vp);
    gp_Pnt c = vp.CentreOfMass();
    Bnd_Box bb; BRepBndLib::Add(s, bb);
    double x0, y0, z0, x1, y1, z1; bb.Get(x0, y0, z0, x1, y1, z1);
    return {vp.Mass(), Vec3d(c.X(), c.Y(), c.Z()), Vec3d(x0, y0, z0), Vec3d(x1, y1, z1)};
}

References shape_metrics().

Referenced by shape_metrics(), and validate_against().

Here is the call graph for this function:

Here is the caller graph for this function:

sketch_entity_from()

SketchEntity Slic3r::GUI::anonymous_namespace{McpControl.cpp}::sketch_entity_from

(

const json &

j

)

{
    const std::string t = j.value("type", std::string(""));
    SketchEntity e;
    auto p = [&](const char* k, double dx, double dy) {
        if (!j.contains(k)) return Vec2d(dx, dy);
        const json& a = j.at(k);
        if (!a.is_array() || a.size() < 2) throw std::runtime_error(std::string(k) + " must be [x, y]");
        return Vec2d(a[0].get<double>(), a[1].get<double>());
    };
    e.construction = j.value("construction", false);
    // A circle and an arc are defined BY their centre, so a request that does not carry one is
    // incomplete, not a request for a circle at the origin. Defaulting it silently put geometry
    // somewhere the caller never asked for and then reported perfectly consistent loops, areas
    // and hole attribution ABOUT THAT WRONG GEOMETRY — which is far more expensive to disbelieve
    // than an error would have been. `p0` is accepted as an alias because that is exactly what a
    // circle stores internally (e.p0 = e.center below), so a caller who writes p0 means centre.
    auto centre_of = [&](const char* what) {
        if (j.contains("center")) return p("center", 0, 0);
        if (j.contains("centre")) return p("centre", 0, 0);
        if (j.contains("p0"))     return p("p0", 0, 0);
        throw std::runtime_error(std::string(what) + " needs a 'center' (or 'p0')");
    };
    if (t == "line") {
        e.type = SketchEntity::Type::Line;
        e.p0 = p("p0", 0, 0); e.p1 = p("p1", 0, 0);
    } else if (t == "circle") {
        e.type   = SketchEntity::Type::Circle;
        e.center = centre_of("circle");
        e.radius = j.value("radius", 0.0);
        e.p0     = e.center;
        if (e.radius <= 0.0) throw std::runtime_error("circle needs a positive 'radius'");
    } else if (t == "arc") {
        e.type        = SketchEntity::Type::Arc;
        e.center      = centre_of("arc");
        e.radius      = j.value("radius", 0.0);
        e.start_angle = j.value("start_angle", 0.0);
        e.end_angle   = j.value("end_angle", 0.0);
        if (e.radius <= 0.0) throw std::runtime_error("arc needs a positive 'radius'");
        e.p0 = e.center + e.radius * Vec2d(std::cos(e.start_angle), std::sin(e.start_angle));
        e.p1 = e.center + e.radius * Vec2d(std::cos(e.end_angle),   std::sin(e.end_angle));
    } else if (t == "point") {
        e.type = SketchEntity::Type::Point;
        e.p0   = p("p", 0, 0);
    } else {
        throw std::runtime_error("unknown entity type '" + t + "' (line, arc, circle, point)");
    }
    return e;
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::center, Slic3r::SketchEntity::Circle, Slic3r::SketchEntity::construction, Slic3r::SketchEntity::end_angle, Slic3r::SketchEntity::Line, Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::Point, Slic3r::SketchEntity::radius, sketch_entity_from(), Slic3r::SketchEntity::start_angle, and Slic3r::SketchEntity::type.

Referenced by action_sketch_add(), and sketch_entity_from().

Here is the call graph for this function:

Here is the caller graph for this function:

sketch_entity_to()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::sketch_entity_to	(	const SketchEntity &	e,
		int	index )

{
    json j{{"index", index}, {"construction", e.construction}};
    switch (e.type) {
    case SketchEntity::Type::Line:
        j["type"] = "line";
        j["p0"] = json::array({e.p0.x(), e.p0.y()});
        j["p1"] = json::array({e.p1.x(), e.p1.y()});
        j["length"] = (e.p1 - e.p0).norm();
        break;
    case SketchEntity::Type::Circle:
        j["type"] = "circle";
        j["center"] = json::array({e.center.x(), e.center.y()});
        j["radius"] = e.radius;
        break;
    case SketchEntity::Type::Arc:
        j["type"] = "arc";
        j["center"] = json::array({e.center.x(), e.center.y()});
        j["radius"] = e.radius;
        j["start_angle"] = e.start_angle;
        j["end_angle"]   = e.end_angle;
        j["p0"] = json::array({e.p0.x(), e.p0.y()});
        j["p1"] = json::array({e.p1.x(), e.p1.y()});
        break;
    case SketchEntity::Type::Point:
        j["type"] = "point";
        j["p"] = json::array({e.p0.x(), e.p0.y()});
        break;
    // Ellipses and splines used to serialise as a TYPE NAME and nothing else, so every
    // parameter they have was invisible to the only read-back this project has. A ladder could
    // count them and grade the faceted area of the loop they close (2e-2, the faceting error) —
    // it could not check a single axis, angle or pole. "Precise definition of every aspect"
    // cannot be asserted about an entity whose aspects the instrument cannot see.
    case SketchEntity::Type::Ellipse:
        j["type"]     = "ellipse";
        j["center"]   = json::array({e.center.x(), e.center.y()});
        j["radius"]   = e.radius;     // semi-major (a)
        j["rminor"]   = e.rminor;     // semi-minor (b)
        j["rotation"] = e.rotation;   // major-axis angle, radians
        break;
    case SketchEntity::Type::EllipseArc:
        j["type"]        = "ellipse_arc";
        j["center"]      = json::array({e.center.x(), e.center.y()});
        j["radius"]      = e.radius;
        j["rminor"]      = e.rminor;
        j["rotation"]    = e.rotation;
        j["start_angle"] = e.start_angle;
        j["end_angle"]   = e.end_angle;
        j["p0"] = json::array({e.p0.x(), e.p0.y()});
        j["p1"] = json::array({e.p1.x(), e.p1.y()});
        break;
    case SketchEntity::Type::BSpline: {
        j["type"] = "spline";
        json poles = json::array();
        for (const Vec2d& c : e.ctrl) poles.push_back(json::array({c.x(), c.y()}));
        j["ctrl"] = poles;
        j["p0"] = json::array({e.p0.x(), e.p0.y()});
        j["p1"] = json::array({e.p1.x(), e.p1.y()});
        break;
    }
    }
    return j;
}

References Slic3r::SketchEntity::Arc, Slic3r::SketchEntity::BSpline, Slic3r::SketchEntity::center, Slic3r::SketchEntity::Circle, Slic3r::SketchEntity::construction, Slic3r::SketchEntity::ctrl, Slic3r::SketchEntity::Ellipse, Slic3r::SketchEntity::EllipseArc, Slic3r::SketchEntity::end_angle, Slic3r::SketchEntity::Line, Slic3r::SketchEntity::p0, Slic3r::SketchEntity::p1, Slic3r::SketchEntity::Point, Slic3r::SketchEntity::radius, Slic3r::SketchEntity::rminor, Slic3r::SketchEntity::rotation, sketch_entity_to(), Slic3r::SketchEntity::start_angle, and Slic3r::SketchEntity::type.

Referenced by action_sketch_describe(), and sketch_entity_to().

Here is the call graph for this function:

Here is the caller graph for this function:

sketch_report()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::sketch_report

(

DesignSketchTool &

t

)

{
    const auto rep = t.loop_report();
    json loops = json::array();
    for (const auto& l : rep.loops) {
        json holes = json::array();
        for (int h : l.holes) holes.push_back(h);
        loops.push_back(json{{"entities", l.ents}, {"holes", holes},
                             {"closed", l.closed}, {"area", l.area}});
    }
    json open_ends = json::array();
    for (const Vec2d& p : rep.open_ends) open_ends.push_back(json::array({p.x(), p.y()}));
    // A profile is buildable when at least one loop closed, nothing is left dangling and no loop
    // crosses or folds back on itself.
    json defects = json::array();
    for (const auto& l : rep.loops)
        if (l.defect) defects.push_back(json::array({l.defect_at.x(), l.defect_at.y()}));
    const bool buildable = !rep.loops.empty() && rep.open_ends.empty() && defects.empty();
    return json{{"closed_loops", loops}, {"open_ends", open_ends}, {"defects", defects}, {"buildable", buildable}};
}

References Slic3r::holes(), Slic3r::GUI::DesignSketchTool::loop_report(), and sketch_report().

Referenced by action_sketch_describe(), action_sketch_heal(), action_sketch_set_value(), action_sketch_validate(), and sketch_report().

Here is the call graph for this function:

Here is the caller graph for this function:

sketch_targets()

std::vector< int > Slic3r::GUI::anonymous_namespace{McpControl.cpp}::sketch_targets	(	const json &	params,
		DesignSketchTool &	t,
		bool	all_if_empty )

{
    std::vector<int> out;
    if (params.contains("entities")) {
        for (const auto& v : params.at("entities")) out.push_back(v.get<int>());
        return out;
    }
    out = t.selection();
    if (out.empty() && all_if_empty)
        for (int i = 0; i < int(t.entities().size()); ++i) out.push_back(i);
    return out;
}

References Slic3r::GUI::DesignSketchTool::entities(), Slic3r::GUI::DesignSketchTool::selection(), and sketch_targets().

Referenced by action_sketch_construction(), action_sketch_delete(), action_sketch_mirror(), action_sketch_offset(), and sketch_targets().

Here is the call graph for this function:

Here is the caller graph for this function:

slice_body()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::slice_body	(	DesignPanel *	panel,
		const json &	params )

{
    const TopoDS_Shape& shape = body_shape(panel, params);
    const std::string plane_name = params.value("plane", std::string("XY"));
    const double offset = params.value("offset", 0.0);
    // Base plane normal; offset shifts the plane along it.
    gp_Dir n = plane_name == "XZ" ? gp_Dir(0, 1, 0)
             : plane_name == "YZ" ? gp_Dir(1, 0, 0)
                                  : gp_Dir(0, 0, 1);
    gp_Pnt o(n.X() * offset, n.Y() * offset, n.Z() * offset);
    BRepAlgoAPI_Section sect(shape, gp_Pln(o, n), false);
    sect.ComputePCurveOn1(false);
    sect.Approximation(true);
    sect.Build();
    if (!sect.IsDone()) throw std::runtime_error("section failed");
    std::vector<std::vector<Vec3d>> segs;
    for (TopExp_Explorer ex(sect.Shape(), TopAbs_EDGE); ex.More(); ex.Next()) {
        std::vector<Vec3d> pts = GeometryEngine::sample_edge_world(TopoDS::Edge(ex.Current()));
        if (pts.size() >= 2) segs.push_back(std::move(pts));
    }
    const int raw = int(segs.size());
    auto contours = chain_segments(std::move(segs), 1e-3);
    json jcont = json::array();
    int closed_n = 0;
    for (auto& pc : contours) {
        if (pc.second) ++closed_n;
        json pts = json::array();
        for (const Vec3d& p : pc.first) pts.push_back(vec3(p));
        jcont.push_back(json{{"closed", pc.second}, {"points", std::move(pts)}});
    }
    return json{{"body", params.value("body", 0)}, {"plane", plane_name}, {"offset", offset},
                {"segment_count", raw}, {"contour_count", int(contours.size())},
                {"closed_count", closed_n}, {"contours", std::move(jcont)}};
}

References body_shape(), chain_segments(), Slic3r::offset(), Slic3r::GeometryEngine::sample_edge_world(), slice_body(), and vec3().

Referenced by handle_on_main(), and slice_body().

Here is the call graph for this function:

Here is the caller graph for this function:

target_body_arg()

int Slic3r::GUI::anonymous_namespace{McpControl.cpp}::target_body_arg	(	const json &	params,
		const CadDocument &	doc )

{
    int bi = params.value("body", -1);
    if (bi >= int(doc.bodies.size()))
        throw std::runtime_error("body index out of range (have " + std::to_string(doc.bodies.size()) + ")");
    return bi;   // <0 -> kernel uses the last body
}

References Slic3r::CadDocument::bodies, and target_body_arg().

Referenced by action_chamfer(), action_delete_face(), action_draft(), action_fillet(), action_mirror(), action_pattern(), action_pattern_on_curve(), action_rib(), action_shell(), action_split(), action_surface_offset(), action_thicken(), action_thicken_surface(), action_transform(), and target_body_arg().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_against()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::validate_against	(	DesignPanel *	panel,
		const json &	params )

{
    const TopoDS_Shape& cand = body_shape(panel, params);   // candidate = the reconstruction
    if (!params.contains("reference")) throw std::runtime_error("validate_against needs 'reference' {step|body}");
    const json& r = params["reference"];
 
    TopoDS_Shape ref;
    if (r.contains("step")) {
        std::string err;
        std::vector<TopoDS_Shape> solids = GeometryEngine::read_step_solids(r["step"].get<std::string>(), err);
        if (solids.empty()) throw std::runtime_error(err.empty() ? "reference STEP has no solids" : err);
        BRep_Builder b; TopoDS_Compound comp; b.MakeCompound(comp);
        for (const TopoDS_Shape& s : solids) if (!s.IsNull()) b.Add(comp, s);
        ref = comp;
    } else if (r.contains("body")) {
        CadDocument& doc = panel->mcp_doc();
        int idx = r["body"].get<int>();
        if (idx < 0 || idx >= int(doc.bodies.size()) || doc.bodies[idx].shape.IsNull())
            throw std::runtime_error("reference body index out of range / null");
        ref = doc.bodies[idx].shape;
    } else {
        throw std::runtime_error("reference must be {\"step\": path} or {\"body\": id}");
    }
 
    ShapeMetrics a = shape_metrics(cand), b = shape_metrics(ref);
    double dv = b.volume > 0 ? (a.volume - b.volume) / b.volume * 100.0 : 0.0;
    Vec3d coff = a.centroid - b.centroid;
    Vec3d dmin = a.bmin - b.bmin, dmax = a.bmax - b.bmax;
    // Surface-level deviation (one-sided Hausdorff, candidate vertices -> reference solid):
    // catches local shape error that matching volume + bbox can hide.
    GeometryEngine::Deviation dev = GeometryEngine::surface_deviation(cand, ref);
    return json{
        {"volume", a.volume}, {"volume_reference", b.volume}, {"volume_delta_pct", dv},
        {"centroid_offset", vec3(coff)}, {"centroid_offset_mm", coff.norm()},
        {"bbox", json{{"min", vec3(a.bmin)}, {"max", vec3(a.bmax)}}},
        {"bbox_reference", json{{"min", vec3(b.bmin)}, {"max", vec3(b.bmax)}}},
        {"bbox_delta", json{{"min", vec3(dmin)}, {"max", vec3(dmax)}}},
        {"surface_deviation", json{{"max_mm", dev.max_mm}, {"mean_mm", dev.mean_mm},
                                   {"rms_mm", dev.rms_mm}, {"samples", dev.sample_count}}},
    };
}

References Slic3r::GUI::anonymous_namespace{McpControl.cpp}::ShapeMetrics::bmax, Slic3r::GUI::anonymous_namespace{McpControl.cpp}::ShapeMetrics::bmin, Slic3r::CadDocument::bodies, body_shape(), Slic3r::GUI::anonymous_namespace{McpControl.cpp}::ShapeMetrics::centroid, Slic3r::GeometryEngine::Deviation::max_mm, Slic3r::GUI::DesignPanel::mcp_doc(), Slic3r::GeometryEngine::Deviation::mean_mm, Slic3r::GeometryEngine::read_step_solids(), Slic3r::GeometryEngine::Deviation::rms_mm, Slic3r::GeometryEngine::Deviation::sample_count, shape_metrics(), Slic3r::GeometryEngine::surface_deviation(), validate_against(), vec3(), and Slic3r::GUI::anonymous_namespace{McpControl.cpp}::ShapeMetrics::volume.

Referenced by handle_on_main(), and validate_against().

Here is the call graph for this function:

Here is the caller graph for this function:

vec3()

json Slic3r::GUI::anonymous_namespace{McpControl.cpp}::vec3 ( const Vec3d & v )

inline

{ return json::array({v.x(), v.y(), v.z()}); }

References vec3().

Referenced by measure(), query_topology(), slice_body(), validate_against(), and vec3().

Here is the call graph for this function:

Here is the caller graph for this function:

verb_is_modal()

bool Slic3r::GUI::anonymous_namespace{McpControl.cpp}::verb_is_modal

(

const char *

id

)

{
    static const char* kModal[] = { "sk_text", "sk_svg", "colour" };
    for (const char* m : kModal)
        if (std::strcmp(m, id) == 0) return true;
    return false;
}

References verb_is_modal().

Referenced by action_list_verbs(), action_run_verb(), and verb_is_modal().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_sock_path

std::string Slic3r::GUI::anonymous_namespace{McpControl.cpp}::g_sock_path

Referenced by remove_socket_at_exit(), and server_thread().