mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-10-04 22:31:02 +00:00
GCodeWriter: extract MachineKinematics, delete BeltGCodeWriter
BeltGCodeWriter subclassed GCodeWriter and overrode seven methods, five of them
by copying the base body and changing the transform. The base writer already
carried an axis remap and already branched at each of its seven
coordinate-emission decisions; the subclass did the same branching with a
different transform, and the two copies had begun to drift.
Replace the inheritance with a strategy object owned by GCodeWriter:
CartesianKinematics to_machine = the existing apply_axis_remap; today's base
behaviour, moved rather than changed.
BeltKinematics to_machine = MachineFrameTransform o axis_remap o
BeltBackTransform, plus a world_coordinates variant for
the PA calibration generators.
New: src/libslic3r/GCode/MachineKinematics.{hpp,cpp}, GCode/BeltKinematics.{hpp,cpp}
Deleted: src/libslic3r/BeltGCodeWriter.{hpp,cpp} (341 lines)
Points worth a reviewer's attention:
* The predicate is must_emit_all_axes(), not couples_axes(). The base returns
true for any non-identity remap, including pure permutations that do not
physically couple axes, so the question is "must every axis word be
emitted", not a statement about kinematics.
* Every per-site word-omission branch is preserved. The base deliberately
emits X/Y only, or Z only, or drops Z when its quantised value is unchanged.
The strategy changes which transform applies, never whether words are
omitted.
* set_kinematics() replays the configured remap and build volume onto a newly
installed strategy, because BeltGCode::init_belt_writer runs before
GCode.cpp calls set_axis_remap/set_build_volume_max.
* uses_pointwise_travel_speed() preserves a pre-existing divergence rather
than introducing one: the base travel_to_xyz emits the raw configured travel
speed in its final branch, ignoring the first-layer value computed at the
top, whereas the belt path used the first-layer-aware value throughout. Both
are kept. Unifying them changes feedrates and belongs in its own change.
* The [BELT-DEBUG] block is deleted; it rate-limited itself with a
function-local static thread_local in the hot emission path, and this is the
commit that would otherwise have moved it into shared code.
This commit is intended to preserve existing export output. That is reviewed by
construction -- each emission site keeps its own omission branch and each policy
divergence is preserved -- and is NOT verified against a G-code diff corpus.
Building that corpus is the outstanding work here.
Two API-equivalence exceptions, neither reachable by any caller today:
* Belt kinematics with no plane pointer installed, m_is_first_layer true,
initial and normal travel speeds differing, travel_to_xyz() reaching its
final branch: the old belt writer selected the initial-layer speed, the new
writer selects the normal travel speed. The pending-lift and XY-only
branches keep their previous selection.
* Belt kinematics installed without set_force_normal_lift(true) and a
non-normal lift requested: the old belt writer forced a normal lift, the new
writer can take the slope branch.
The PA-pattern generator reaches the writer through explicit travel_to_z() /
travel_to_xy(), not travel_to_xyz() or the lazy/eager lift paths, and normal
belt export installs both the plane and the forced-normal-lift policy, so
neither exception changes output produced today. They are recorded because a
future caller could reach them.
tests/fff_print/test_gcodewriter.cpp was also not compiling before this branch:
it called writer.to_machine_coords(), a method that existed only on
BeltGCodeWriter. It never surfaced because the build targets OrcaSlicer, not
all, and BUILD_TESTS defaults to OFF, so that translation unit was outside every
compile path. Fixed here; the existing 30-degree coordinate assertions are kept
verbatim as the best available regression net.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011jgzj1sf53KMLPweZ8yeUQ
This commit is contained in:
harrierpigeon
co-authored by
Claude Opus 5
Claude Opus 5
parent
c96945490b
commit
e695da66df
@@ -1,5 +1,6 @@
|
||||
#include "BeltGCode.hpp"
|
||||
#include "BeltGCodeWriter.hpp"
|
||||
#include "GCodeWriter.hpp"
|
||||
#include "GCode/BeltKinematics.hpp"
|
||||
#include "BeltTransform.hpp"
|
||||
#include "Print.hpp"
|
||||
|
||||
@@ -10,11 +11,12 @@ void BeltGCode::init_belt_writer(Print &print, bool is_bbl_printers)
|
||||
if (!print.config().belt_printer.value)
|
||||
return;
|
||||
|
||||
auto belt_writer = std::make_unique<BeltGCodeWriter>();
|
||||
auto belt_writer = std::make_unique<GCodeWriter>();
|
||||
belt_writer->set_is_bbl_machine(is_bbl_printers);
|
||||
// Axis remap and build volume max are set by base GCode after init_belt_writer returns.
|
||||
belt_writer->set_belt_back_transform(print.config());
|
||||
belt_writer->set_machine_frame_transform(print.config());
|
||||
// Axis remap and build volume max are set by base GCode after init_belt_writer
|
||||
// returns; set_kinematics() replays them, so install order does not matter.
|
||||
install_belt_kinematics(*belt_writer, print.config());
|
||||
belt_writer->set_force_normal_lift(true);
|
||||
m_writer = std::move(belt_writer);
|
||||
}
|
||||
|
||||
|
||||
@@ -7,7 +7,7 @@ namespace Slic3r {
|
||||
// Belt-printer-specific GCode export.
|
||||
//
|
||||
// Inherits from GCode and overrides virtual hooks to:
|
||||
// - Create a BeltGCodeWriter instead of a plain GCodeWriter
|
||||
// - Install a BeltKinematics on the GCodeWriter
|
||||
// - Write belt configuration to the G-code header
|
||||
// - Adjust the origin for global pre-slice transforms when switching instances
|
||||
// - Disable arc fitting (G2/G3 not supported on belt printers)
|
||||
|
||||
@@ -1,277 +0,0 @@
|
||||
#include "BeltGCodeWriter.hpp"
|
||||
#include "FirstLayerPlane.hpp"
|
||||
#include "Geometry.hpp"
|
||||
#include <boost/log/trivial.hpp>
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
namespace {
|
||||
|
||||
// Decide whether a particular destination point gets first-layer treatment.
|
||||
// When the plane evaluator is active, distance from the plane wins; otherwise
|
||||
// fall back to the layer-coarse m_is_first_layer flag set by the caller.
|
||||
inline bool belt_point_on_first_layer(
|
||||
const FirstLayerPlane *plane,
|
||||
double first_layer_thickness_mm,
|
||||
bool layer_first_flag,
|
||||
const Vec3d &point_slicing_mm)
|
||||
{
|
||||
if (plane && plane->is_active())
|
||||
return plane->is_first_layer(point_slicing_mm, first_layer_thickness_mm);
|
||||
return layer_first_flag;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// ---- Belt configuration ---------------------------------------------------
|
||||
|
||||
void BeltGCodeWriter::set_belt_back_transform(const PrintConfig &config)
|
||||
{
|
||||
m_belt_back_transform.init_from_config(config);
|
||||
}
|
||||
|
||||
void BeltGCodeWriter::set_machine_frame_transform(const PrintConfig &config)
|
||||
{
|
||||
m_machine_frame_transform.init_from_config(config);
|
||||
}
|
||||
|
||||
Vec3d BeltGCodeWriter::to_machine_coords(const Vec3d &pos) const
|
||||
{
|
||||
// Step 1+2: To Cartesian (back_transform + axis_remap).
|
||||
// In world-coordinates mode (PA line / PA pattern calibration) the input
|
||||
// already describes a point relative to the belt surface, so the
|
||||
// slicer->world back-transform is skipped and only the machine kinematics
|
||||
// (axis remap + frame shear/scale) are applied.
|
||||
Vec3d after_back = m_world_coordinates ? pos : m_belt_back_transform.apply(pos);
|
||||
Vec3d result = apply_axis_remap(after_back);
|
||||
Vec3d after_remap = result;
|
||||
// Step 3: Machine-frame transform (belt frame tilt) applied LAST so it acts
|
||||
// as a global linear transform on the placed coords.
|
||||
Vec3d final = m_machine_frame_transform.apply(result);
|
||||
|
||||
// [BELT-DEBUG] One-shot log per layer transition (i.e. when the input Z
|
||||
// crosses an integer mm boundary) to keep the log volume manageable while
|
||||
// still capturing one sample per ~5 layers. Shows the full pipeline so
|
||||
// Case A vs Case B can be compared step-by-step.
|
||||
static thread_local int s_last_logged_z = std::numeric_limits<int>::min();
|
||||
int z_bucket = static_cast<int>(std::floor(pos.z() * 5.0)); // every 0.2mm
|
||||
if (z_bucket != s_last_logged_z) {
|
||||
s_last_logged_z = z_bucket;
|
||||
BOOST_LOG_TRIVIAL(trace) << "[BELT-DEBUG] to_machine_coords"
|
||||
<< " slicer_in=(" << pos.x() << "," << pos.y() << "," << pos.z() << ")"
|
||||
<< " after_back=(" << after_back.x() << "," << after_back.y() << "," << after_back.z() << ")"
|
||||
<< " after_remap=(" << after_remap.x() << "," << after_remap.y() << "," << after_remap.z() << ")"
|
||||
<< " final=(" << final.x() << "," << final.y() << "," << final.z() << ")"
|
||||
<< " mft_active=" << m_machine_frame_transform.is_active()
|
||||
<< " back_active=" << m_belt_back_transform.is_active();
|
||||
}
|
||||
return final;
|
||||
}
|
||||
|
||||
// ---- Overridden movement methods ------------------------------------------
|
||||
|
||||
std::string BeltGCodeWriter::travel_to_xy(const Vec2d &point, const std::string &comment)
|
||||
{
|
||||
m_pos(0) = point(0);
|
||||
m_pos(1) = point(1);
|
||||
|
||||
this->set_current_position_clear(true);
|
||||
Vec2d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset };
|
||||
|
||||
// Belt printer: transform to machine coordinates (XY travel also needs Z due to YZ rotation)
|
||||
Vec3d machine = to_machine_coords(Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()));
|
||||
|
||||
GCodeG1Formatter w;
|
||||
w.emit_xyz(machine);
|
||||
const bool first_layer_for_point = belt_point_on_first_layer(
|
||||
m_first_layer_plane, m_first_layer_thickness_mm, m_is_first_layer,
|
||||
Vec3d(point.x(), point.y(), m_pos.z()));
|
||||
auto speed = first_layer_for_point
|
||||
? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
|
||||
: this->config.travel_speed.get_at(m_cached_extruder_idx);
|
||||
w.emit_f(speed * 60.0);
|
||||
w.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
return w.string();
|
||||
}
|
||||
|
||||
std::string BeltGCodeWriter::lazy_lift(LiftType lift_type, bool spiral_vase)
|
||||
{
|
||||
// Belt printer: force NormalLift since SpiralLift and SlopeLift compute
|
||||
// slope angles that don't account for the YZ coordinate rotation.
|
||||
return GCodeWriter::lazy_lift(LiftType::NormalLift, spiral_vase);
|
||||
}
|
||||
|
||||
std::string BeltGCodeWriter::eager_lift(const LiftType type)
|
||||
{
|
||||
// Belt printer: force NormalLift (SpiralLift/SlopeLift don't account for YZ rotation).
|
||||
return GCodeWriter::eager_lift(LiftType::NormalLift);
|
||||
}
|
||||
|
||||
std::string BeltGCodeWriter::_travel_to_z(double z, const std::string &comment)
|
||||
{
|
||||
m_pos(2) = z;
|
||||
|
||||
double speed = this->config.travel_speed_z.get_at(m_cached_extruder_idx);
|
||||
if (speed == 0.) {
|
||||
const bool first_layer_for_point = belt_point_on_first_layer(
|
||||
m_first_layer_plane, m_first_layer_thickness_mm, m_is_first_layer,
|
||||
Vec3d(m_pos.x(), m_pos.y(), z));
|
||||
speed = first_layer_for_point ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
|
||||
: this->config.travel_speed.get_at(m_cached_extruder_idx);
|
||||
}
|
||||
|
||||
// Belt printer: a Z-only move in slicing frame needs to emit both Y and Z in machine coords.
|
||||
Vec3d machine = to_machine_coords(Vec3d(m_pos.x() - m_x_offset, m_pos.y() - m_y_offset, z));
|
||||
|
||||
GCodeG1Formatter w;
|
||||
w.emit_xyz(machine);
|
||||
w.emit_f(speed * 60.0);
|
||||
w.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
return w.string();
|
||||
}
|
||||
|
||||
std::string BeltGCodeWriter::extrude_to_xy(const Vec2d &point, double dE, const std::string &comment, bool force_no_extrusion)
|
||||
{
|
||||
m_pos(0) = point(0);
|
||||
m_pos(1) = point(1);
|
||||
if (std::abs(dE) <= std::numeric_limits<double>::epsilon())
|
||||
force_no_extrusion = true;
|
||||
|
||||
if (!force_no_extrusion)
|
||||
filament()->extrude(dE);
|
||||
|
||||
Vec2d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset };
|
||||
|
||||
// Belt printer: transform and emit XYZ (Y and Z are coupled)
|
||||
Vec3d machine = to_machine_coords(Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()));
|
||||
|
||||
GCodeG1Formatter w;
|
||||
w.emit_xyz(machine);
|
||||
if (!force_no_extrusion)
|
||||
w.emit_e(filament()->E());
|
||||
w.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
return w.string();
|
||||
}
|
||||
|
||||
std::string BeltGCodeWriter::extrude_to_xyz(const Vec3d &point, double dE, const std::string &comment, bool force_no_extrusion)
|
||||
{
|
||||
m_pos = point;
|
||||
m_lifted = 0;
|
||||
if (!force_no_extrusion)
|
||||
filament()->extrude(dE);
|
||||
|
||||
Vec3d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset, point(2) };
|
||||
point_on_plate = to_machine_coords(point_on_plate);
|
||||
|
||||
GCodeG1Formatter w;
|
||||
w.emit_xyz(point_on_plate);
|
||||
if (!force_no_extrusion)
|
||||
w.emit_e(filament()->E());
|
||||
w.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
return w.string();
|
||||
}
|
||||
|
||||
std::string BeltGCodeWriter::travel_to_xyz(const Vec3d &point, const std::string &comment, bool force_z)
|
||||
{
|
||||
// Belt-specific override of travel_to_xyz.
|
||||
// Key differences from base:
|
||||
// 1. All coordinates go through to_machine_coords()
|
||||
// 2. Always emit full XYZ (can't split XY and Z due to coupling)
|
||||
// 3. Lift type forced to NormalLift (handled by lazy_lift/eager_lift overrides)
|
||||
|
||||
Vec3d dest_point = point;
|
||||
const bool first_layer_for_point = belt_point_on_first_layer(
|
||||
m_first_layer_plane, m_first_layer_thickness_mm, m_is_first_layer, point);
|
||||
auto travel_speed =
|
||||
first_layer_for_point ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
|
||||
: this->config.travel_speed.get_at(m_cached_extruder_idx);
|
||||
|
||||
// Handle pending z_hop
|
||||
if (std::abs(m_to_lift) > EPSILON) {
|
||||
assert(std::abs(m_lifted) < EPSILON);
|
||||
if ((!this->is_current_position_clear() || m_pos != dest_point) &&
|
||||
m_to_lift + m_pos(2) > point(2)) {
|
||||
m_lifted = m_to_lift + m_pos(2) - point(2);
|
||||
dest_point(2) = m_to_lift + m_pos(2);
|
||||
}
|
||||
m_to_lift = 0.;
|
||||
|
||||
std::string slop_move;
|
||||
Vec3d source = { m_pos(0) - m_x_offset, m_pos(1) - m_y_offset, m_pos(2) };
|
||||
Vec3d target = { dest_point(0) - m_x_offset, dest_point(1) - m_y_offset, dest_point(2) };
|
||||
Vec3d delta = target - source;
|
||||
Vec2d delta_no_z = { delta(0), delta(1) };
|
||||
|
||||
if (delta(2) > 0 && delta_no_z.norm() != 0.0f) {
|
||||
// Belt: SpiralLift and SlopeLift are disabled (lazy_lift forces NormalLift),
|
||||
// but handle NormalLift and fallthrough.
|
||||
if (m_to_lift_type == LiftType::SlopeLift &&
|
||||
this->is_current_position_clear() &&
|
||||
atan2(delta(2), delta_no_z.norm()) < this->filament()->travel_slope()) {
|
||||
Vec2d temp = delta_no_z.normalized() * delta(2) / tan(this->filament()->travel_slope());
|
||||
Vec3d slope_top_point = Vec3d(temp(0), temp(1), delta(2)) + source;
|
||||
slope_top_point = to_machine_coords(slope_top_point);
|
||||
GCodeG1Formatter w0;
|
||||
w0.emit_xyz(slope_top_point);
|
||||
w0.emit_f(travel_speed * 60.0);
|
||||
w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
slop_move = w0.string();
|
||||
}
|
||||
else if (m_to_lift_type == LiftType::NormalLift && this->is_current_position_clear()) {
|
||||
// Only lift-in-place when the current position is known. On a normal
|
||||
// printer _travel_to_z emits a Z-only move, but in belt mode Z is coupled
|
||||
// to Y/X, so _travel_to_z re-emits the current m_pos through the belt
|
||||
// shear. At print start (and after custom gcode) m_pos.xy is still the
|
||||
// uninitialised origin (0,0), which shears into a bogus machine point
|
||||
// (e.g. X=bed_max, Y=layer_z) far up the gantry. Skipping the separate
|
||||
// lift here is safe: there is nothing to lift over yet, and the
|
||||
// xy_z_move below travels straight to the destination with full XYZ,
|
||||
// establishing the correct position. This mirrors the SlopeLift branch
|
||||
// above, which already guards on is_current_position_clear().
|
||||
slop_move = _travel_to_z(target.z(), "normal lift Z");
|
||||
}
|
||||
}
|
||||
|
||||
std::string xy_z_move;
|
||||
{
|
||||
Vec3d emit_target = to_machine_coords(target);
|
||||
GCodeG1Formatter w0;
|
||||
// Belt mode: always emit full XYZ since Y and Z are coupled
|
||||
w0.emit_xyz(emit_target);
|
||||
w0.emit_f(travel_speed * 60.0);
|
||||
w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
xy_z_move = w0.string();
|
||||
}
|
||||
m_pos = dest_point;
|
||||
this->set_current_position_clear(true);
|
||||
return slop_move + xy_z_move;
|
||||
}
|
||||
else if (!force_z && !this->will_move_z(point(2))) {
|
||||
double nominal_z = m_pos(2) - m_lifted;
|
||||
m_lifted -= (point(2) - nominal_z);
|
||||
if (std::abs(m_lifted) < EPSILON)
|
||||
m_lifted = 0.;
|
||||
this->set_current_position_clear(true);
|
||||
return this->travel_to_xy(to_2d(point));
|
||||
}
|
||||
else {
|
||||
m_lifted = 0;
|
||||
}
|
||||
|
||||
Vec3d point_on_plate = { dest_point(0) - m_x_offset, dest_point(1) - m_y_offset, dest_point(2) };
|
||||
point_on_plate = to_machine_coords(point_on_plate);
|
||||
|
||||
// Belt mode: always emit full XYZ
|
||||
GCodeG1Formatter w;
|
||||
w.emit_xyz(point_on_plate);
|
||||
// Use the first-layer-aware travel_speed computed at the top of this function,
|
||||
// not the raw config travel_speed, so initial-layer travels are correctly slowed.
|
||||
w.emit_f(travel_speed * 60.0);
|
||||
w.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
|
||||
m_pos = dest_point;
|
||||
this->set_current_position_clear(true);
|
||||
return w.string();
|
||||
}
|
||||
|
||||
} // namespace Slic3r
|
||||
@@ -1,64 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "GCodeWriter.hpp"
|
||||
#include "GCode/BeltBackTransform.hpp"
|
||||
#include "GCode/MachineFrameTransform.hpp"
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
class FirstLayerPlane;
|
||||
|
||||
// Belt-printer-specific GCode writer.
|
||||
//
|
||||
// Inherits from GCodeWriter and overrides movement methods to apply
|
||||
// coordinate transformation (back-transform, axis remap, machine-frame
|
||||
// transform) and emit coupled XYZ moves (Y and Z are coupled due to belt tilt).
|
||||
class BeltGCodeWriter : public GCodeWriter
|
||||
{
|
||||
public:
|
||||
BeltGCodeWriter() : GCodeWriter() {}
|
||||
|
||||
// Belt configuration (axis remap is inherited from GCodeWriter)
|
||||
void set_belt_back_transform(const PrintConfig &config);
|
||||
void set_machine_frame_transform(const PrintConfig &config);
|
||||
Vec3d to_machine_coords(const Vec3d &pos) const;
|
||||
|
||||
// World-coordinates mode: incoming coordinates are treated as points
|
||||
// relative to the physical belt surface (X across, Y along the belt,
|
||||
// Z height above it) instead of slicing-frame coordinates — the
|
||||
// slicer->world back-transform is skipped. Used by the PA line / PA
|
||||
// pattern calibration generators, whose logical bed coordinates describe
|
||||
// first-layer drawings on the build surface.
|
||||
void set_world_coordinates(bool enable) { m_world_coordinates = enable; }
|
||||
|
||||
// First-layer plane: when set to a non-null active evaluator, travel
|
||||
// speed selection consults the plane per-move and uses
|
||||
// initial_layer_travel_speed for points within first_layer_height_mm
|
||||
// of the plane (regardless of slicing layer index).
|
||||
void set_first_layer_plane(const FirstLayerPlane *plane,
|
||||
double first_layer_height_mm) {
|
||||
m_first_layer_plane = plane;
|
||||
m_first_layer_thickness_mm = first_layer_height_mm;
|
||||
}
|
||||
|
||||
// Overridden movement methods
|
||||
std::string travel_to_xy(const Vec2d &point, const std::string &comment = std::string()) override;
|
||||
std::string travel_to_xyz(const Vec3d &point, const std::string &comment = std::string(), bool force_z = false) override;
|
||||
std::string extrude_to_xy(const Vec2d &point, double dE, const std::string &comment = std::string(), bool force_no_extrusion = false) override;
|
||||
std::string extrude_to_xyz(const Vec3d &point, double dE, const std::string &comment = std::string(), bool force_no_extrusion = false) override;
|
||||
std::string lazy_lift(LiftType lift_type = LiftType::NormalLift, bool spiral_vase = false) override;
|
||||
std::string eager_lift(const LiftType type) override;
|
||||
|
||||
protected:
|
||||
std::string _travel_to_z(double z, const std::string &comment) override;
|
||||
|
||||
private:
|
||||
BeltBackTransform m_belt_back_transform;
|
||||
MachineFrameTransform m_machine_frame_transform;
|
||||
bool m_world_coordinates = false;
|
||||
// Borrowed pointer; lifetime owned by GCode. null = inactive.
|
||||
const FirstLayerPlane *m_first_layer_plane = nullptr;
|
||||
double m_first_layer_thickness_mm = 0.;
|
||||
};
|
||||
|
||||
} // namespace Slic3r
|
||||
@@ -84,8 +84,6 @@ set(lisbslic3r_sources
|
||||
BeltBrim.hpp
|
||||
BeltGCode.cpp
|
||||
BeltGCode.hpp
|
||||
BeltGCodeWriter.cpp
|
||||
BeltGCodeWriter.hpp
|
||||
BeltPurge.cpp
|
||||
BeltSliceStrategy.cpp
|
||||
BeltSliceStrategy.hpp
|
||||
@@ -243,6 +241,10 @@ set(lisbslic3r_sources
|
||||
GCode/BeltBackTransform.hpp
|
||||
GCode/MachineFrameTransform.cpp
|
||||
GCode/MachineFrameTransform.hpp
|
||||
GCode/BeltKinematics.cpp
|
||||
GCode/BeltKinematics.hpp
|
||||
GCode/MachineKinematics.cpp
|
||||
GCode/MachineKinematics.hpp
|
||||
GCode/ConflictChecker.cpp
|
||||
GCode/ConflictChecker.hpp
|
||||
GCode/CoolingBuffer.cpp
|
||||
|
||||
@@ -56,7 +56,7 @@ MachineZAffine compute_machine_z_affine(const PrintConfig &config)
|
||||
out.constant = trans;
|
||||
|
||||
if (config.gcode_back_transform.value && config.belt_printer.value) {
|
||||
// BeltGCodeWriter applies F^-1 before R when back-transform is on.
|
||||
// BeltKinematics applies F^-1 before R when back-transform is on.
|
||||
// So machine_Z(slicing) = r_row · (F^-1 · slicing) + trans
|
||||
// = (r_row^T · F^-1) · slicing + trans
|
||||
// We need to compose r_row with F^-1 from the LEFT (treating r_row as
|
||||
|
||||
+11
-8
@@ -2986,8 +2986,11 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
|
||||
// circuit to the legacy Layer::id() == 0 path so g-code stays bit-
|
||||
// identical to the pre-feature behavior.
|
||||
m_first_layer_plane = std::make_unique<FirstLayerPlane>(print.config());
|
||||
if (auto *belt_writer = dynamic_cast<BeltGCodeWriter*>(m_writer.get())) {
|
||||
belt_writer->set_first_layer_plane(
|
||||
// Belt writers only: the plane also switches travel-speed selection to be
|
||||
// per-point (see GCodeWriter::uses_pointwise_travel_speed()), which must not
|
||||
// change for non-belt printers.
|
||||
if (print.config().belt_printer.value) {
|
||||
m_writer->set_first_layer_plane(
|
||||
m_first_layer_plane.get(),
|
||||
print.config().initial_layer_print_height.value);
|
||||
}
|
||||
@@ -3888,12 +3891,12 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
|
||||
// ORCA-Belt: the PA line test draws directly on the build surface in
|
||||
// logical bed coordinates — on a belt printer that surface is the
|
||||
// belt plane, not the slicing plane.
|
||||
BeltGCodeWriter* belt_writer = dynamic_cast<BeltGCodeWriter*>(m_writer.get());
|
||||
if (belt_writer != nullptr)
|
||||
belt_writer->set_world_coordinates(true);
|
||||
const bool belt_world_coords = print.config().belt_printer.value;
|
||||
if (belt_world_coords)
|
||||
install_belt_kinematics(*m_writer, print.config(), /*world_coordinates=*/true);
|
||||
gcode += pa_test.generate_test(params.start, params.step, std::llround(std::ceil((params.end - params.start) / params.step)) + 1);
|
||||
if (belt_writer != nullptr)
|
||||
belt_writer->set_world_coordinates(false);
|
||||
if (belt_world_coords)
|
||||
install_belt_kinematics(*m_writer, print.config(), /*world_coordinates=*/false);
|
||||
|
||||
file.write(gcode);
|
||||
} else {
|
||||
@@ -8400,7 +8403,7 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
|
||||
// mesh transform is now rotation ∘ pre-remap, both orthogonal, so |det(T)|
|
||||
// is always 1 and this is currently a no-op; it is retained as a guard in
|
||||
// case a non-orthogonal mesh transform is ever reintroduced. (Machine-frame
|
||||
// shear/scale acts on the g-code in BeltGCodeWriter, not here.)
|
||||
// shear/scale acts on the g-code in BeltKinematics, not here.)
|
||||
if (m_config.belt_printer.value) {
|
||||
double det = std::abs(BeltTransformPipeline::build_forward_transform(m_config).linear().determinant());
|
||||
if (det > EPSILON)
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
#include "libslic3r.h"
|
||||
#include "ExPolygon.hpp"
|
||||
#include "GCodeWriter.hpp"
|
||||
#include "BeltGCodeWriter.hpp"
|
||||
#include "GCode/BeltKinematics.hpp"
|
||||
#include "FirstLayerPlane.hpp"
|
||||
#include "Layer.hpp"
|
||||
#include "Point.hpp"
|
||||
|
||||
@@ -13,7 +13,7 @@ namespace Slic3r {
|
||||
// machine's real coordinate space.
|
||||
//
|
||||
// Initialized once from PrintConfig, then applied per-point in
|
||||
// GCodeWriter::to_machine_coords() before axis remapping.
|
||||
// BeltKinematics::to_machine() before axis remapping.
|
||||
//
|
||||
// Active when gcode_back_transform is true AND at least one of:
|
||||
// - a shear axis has global mode enabled, or
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
#include "BeltKinematics.hpp"
|
||||
#include "../BeltTransform.hpp"
|
||||
#include "../PrintConfig.hpp"
|
||||
#include "../GCodeWriter.hpp"
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
BeltKinematics::BeltKinematics(const PrintConfig &config, bool world_coordinates)
|
||||
: m_world_coordinates(world_coordinates)
|
||||
{
|
||||
m_back_active = m_back_transform.init_from_config(config);
|
||||
m_machine_frame.init_from_config(config);
|
||||
if (m_back_active)
|
||||
// BeltBackTransform stores the inverse of this; keep the forward so
|
||||
// to_logical() can reverse the whole chain.
|
||||
m_back_forward = BeltTransformPipeline::build_forward_transform(config);
|
||||
}
|
||||
|
||||
Vec3d BeltKinematics::to_machine(const Vec3d &p) const
|
||||
{
|
||||
const Vec3d after_back = m_world_coordinates ? p : m_back_transform.apply(p);
|
||||
const Vec3d after_remap = this->apply_axis_remap(after_back);
|
||||
return m_machine_frame.apply(after_remap);
|
||||
}
|
||||
|
||||
Vec3d BeltKinematics::to_logical(const Vec3d &machine) const
|
||||
{
|
||||
const Vec3d before_frame = m_machine_frame.apply_inverse(machine);
|
||||
const Vec3d before_remap = this->apply_axis_remap_inverse(before_frame);
|
||||
if (m_world_coordinates || ! m_back_active)
|
||||
return before_remap;
|
||||
return m_back_forward * before_remap;
|
||||
}
|
||||
|
||||
void install_belt_kinematics(GCodeWriter &writer, const PrintConfig &config, bool world_coordinates)
|
||||
{
|
||||
writer.set_kinematics(std::make_unique<BeltKinematics>(config, world_coordinates));
|
||||
}
|
||||
|
||||
} // namespace Slic3r
|
||||
@@ -0,0 +1,66 @@
|
||||
#ifndef slic3r_BeltKinematics_hpp_
|
||||
#define slic3r_BeltKinematics_hpp_
|
||||
|
||||
#include "MachineKinematics.hpp"
|
||||
#include "BeltBackTransform.hpp"
|
||||
#include "MachineFrameTransform.hpp"
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
class PrintConfig;
|
||||
class GCodeWriter;
|
||||
|
||||
// Belt-printer machine frame.
|
||||
//
|
||||
// Forward order, as applied per emitted point:
|
||||
// machine = MachineFrameTransform( axis_remap( BeltBackTransform( logical ) ) )
|
||||
//
|
||||
// i.e. the slicer->world back-transform runs FIRST and the machine-frame
|
||||
// shear/scale LAST, so the latter acts as a global linear transform on the
|
||||
// already-placed coordinates.
|
||||
//
|
||||
// world_coordinates mode (the PA line / PA pattern calibration generators)
|
||||
// treats the incoming point as already relative to the belt surface -- X across,
|
||||
// Y along the belt, Z above it -- and therefore skips the back-transform while
|
||||
// keeping the remap and the machine frame. It is a different coordinate map, not
|
||||
// a writer mode, which is why it is fixed at construction.
|
||||
class BeltKinematics : public CartesianKinematics
|
||||
{
|
||||
public:
|
||||
explicit BeltKinematics(const PrintConfig &config, bool world_coordinates = false);
|
||||
|
||||
Vec3d to_machine(const Vec3d &p) const override;
|
||||
Vec3d to_logical(const Vec3d &machine) const override;
|
||||
// Machine -> build-volume frame. Only the machine-frame shear/scale is undone,
|
||||
// matching what GCodeProcessor's bounds validation wants. This is deliberately
|
||||
// NOT to_logical().
|
||||
Vec3d to_build_volume(const Vec3d &machine) const override
|
||||
{ return m_machine_frame.apply_inverse(machine); }
|
||||
|
||||
// A belt writer has always emitted full XYZ on every move, whether or not any
|
||||
// individual stage reports itself active. Making this conditional would change
|
||||
// emitted G-code for an identity-transform belt configuration.
|
||||
bool must_emit_all_axes() const override { return true; }
|
||||
bool suppress_lift_at_unknown_position() const override { return true; }
|
||||
|
||||
bool world_coordinates() const { return m_world_coordinates; }
|
||||
|
||||
private:
|
||||
BeltBackTransform m_back_transform;
|
||||
MachineFrameTransform m_machine_frame;
|
||||
// Forward of what m_back_transform inverts, kept so to_logical() can undo it.
|
||||
Transform3d m_back_forward { Transform3d::Identity() };
|
||||
bool m_back_active { false };
|
||||
bool m_world_coordinates { false };
|
||||
};
|
||||
|
||||
// Install a belt machine frame on any GCodeWriter. Any axis remap and build
|
||||
// volume already configured on the writer are carried over, so this may be
|
||||
// called before or after those setters. Re-calling it with a different
|
||||
// world_coordinates value swaps the map (used around the PA line generator).
|
||||
void install_belt_kinematics(GCodeWriter &writer, const PrintConfig &config,
|
||||
bool world_coordinates = false);
|
||||
|
||||
} // namespace Slic3r
|
||||
|
||||
#endif // slic3r_BeltKinematics_hpp_
|
||||
@@ -2774,7 +2774,7 @@ bool GCodeProcessor::check_multi_extruder_gcode_valid(const int
|
||||
};
|
||||
|
||||
// Belt-printer post-gcode shear/scale/post_remap is applied as the final
|
||||
// step of BeltGCodeWriter::to_machine_coords, so MoveVertex.position is
|
||||
// step of BeltKinematics::to_machine, so MoveVertex.position is
|
||||
// in the printer's machine frame. Undo it here so XY area and Z height
|
||||
// checks operate in the build-volume frame that printable_area /
|
||||
// printable_height are defined in. For non-belt printers
|
||||
@@ -7111,7 +7111,7 @@ void GCodeProcessor::store_move_vertex(EMoveType type, EMovePathType path_type,
|
||||
// During the start G-code "prepare" stage the toolhead Z is not yet a real
|
||||
// print height on a normal printer, so it is pinned to the first-layer height
|
||||
// to keep the preview tidy. Belt printers are the exception: there the Z is
|
||||
// written explicitly by BeltGCodeWriter and the designed-view back-transform
|
||||
// written explicitly by the belt kinematics and the designed-view back-transform
|
||||
// couples machine Z into the rendered model Y (the belt tilt mixes the height
|
||||
// and belt-feed axes). Overriding Z therefore back-transforms the last
|
||||
// prepare-stage move (the unretract before the first extrusion) to model
|
||||
|
||||
@@ -9,7 +9,7 @@ namespace Slic3r {
|
||||
|
||||
// Post-stage machine-frame transform for belt printers.
|
||||
//
|
||||
// Applied in BeltGCodeWriter::to_machine_coords AFTER the back-transform and
|
||||
// Applied in BeltKinematics::to_machine AFTER the back-transform and
|
||||
// the gcode_remap_* axis remap. Maps Cartesian (axis-permuted) G-code
|
||||
// coordinates into the printer's physical machine frame.
|
||||
//
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
#include "MachineKinematics.hpp"
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
// Moved verbatim from GCodeWriter::apply_axis_remap().
|
||||
Vec3d CartesianKinematics::apply_axis_remap(const Vec3d &pos) const
|
||||
{
|
||||
if (!has_axis_remap())
|
||||
return pos;
|
||||
auto remap = [this, &pos](int r) -> double {
|
||||
int axis = r % 3;
|
||||
if (r < 3) return pos[axis];
|
||||
if (r < 6) return -pos[axis];
|
||||
return m_build_vol_max[axis] - pos[axis];
|
||||
};
|
||||
return { remap(m_remap_x), remap(m_remap_y), remap(m_remap_z) };
|
||||
}
|
||||
|
||||
// Inverse of the above. Output axis i is fed by source axis (r_i % 3); walking
|
||||
// the three outputs therefore fills every source component exactly once, so long
|
||||
// as the remap is a permutation (which set_axis_remap callers guarantee).
|
||||
Vec3d CartesianKinematics::apply_axis_remap_inverse(const Vec3d &machine) const
|
||||
{
|
||||
if (!has_axis_remap())
|
||||
return machine;
|
||||
Vec3d out = Vec3d::Zero();
|
||||
const int r[3] = { m_remap_x, m_remap_y, m_remap_z };
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
const int axis = r[i] % 3;
|
||||
if (r[i] < 3) out[axis] = machine[i];
|
||||
else if (r[i] < 6) out[axis] = -machine[i];
|
||||
else out[axis] = m_build_vol_max[axis] - machine[i];
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
Vec3d CartesianKinematics::to_machine(const Vec3d &p) const
|
||||
{
|
||||
return this->apply_axis_remap(p);
|
||||
}
|
||||
|
||||
Vec3d CartesianKinematics::to_logical(const Vec3d &machine) const
|
||||
{
|
||||
return this->apply_axis_remap_inverse(machine);
|
||||
}
|
||||
|
||||
} // namespace Slic3r
|
||||
@@ -0,0 +1,95 @@
|
||||
#ifndef slic3r_MachineKinematics_hpp_
|
||||
#define slic3r_MachineKinematics_hpp_
|
||||
|
||||
#include "../Point.hpp"
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
// The frame contract for emitted movement.
|
||||
//
|
||||
// GCodeWriter produces points in the *logical placed* frame: plate offsets have
|
||||
// already been subtracted, but no machine-specific mapping has been applied.
|
||||
// A MachineKinematics turns that into the coordinates actually written to
|
||||
// G-code, and answers the two structural questions the writer needs in order to
|
||||
// decide which axis words it may omit.
|
||||
//
|
||||
// This is a seam for writer-generated movement only. Start/end/custom G-code,
|
||||
// classic wipe-tower output and GCodeWriter::extrude_arc_to_xy() do NOT pass
|
||||
// through it; see doc in 09-orca-machinekinematics-split-plan.md section 6.
|
||||
class MachineKinematics
|
||||
{
|
||||
public:
|
||||
virtual ~MachineKinematics() = default;
|
||||
|
||||
// Logical placed point -> emitted machine point.
|
||||
virtual Vec3d to_machine(const Vec3d &p) const = 0;
|
||||
|
||||
// Inverse of to_machine(), back to the logical placed frame. Intended for
|
||||
// consumers that must reconstruct model coordinates from emitted G-code
|
||||
// (the G-code viewer's upright preview).
|
||||
virtual Vec3d to_logical(const Vec3d &machine) const = 0;
|
||||
|
||||
// Machine point -> build-volume frame, for bounds validation only. This is
|
||||
// deliberately NOT to_logical(): the build-volume check wants the physical
|
||||
// frame the printable area is expressed in, not the model frame. Keeping
|
||||
// them separate stops the two contracts from being confused.
|
||||
virtual Vec3d to_build_volume(const Vec3d &machine) const = 0;
|
||||
|
||||
// True when a move must emit X, Y and Z because omitting a word would be
|
||||
// wrong under this mapping. Deliberately not called "couples_axes": a pure
|
||||
// axis permutation forces full emission without physically coupling axes.
|
||||
virtual bool must_emit_all_axes() const = 0;
|
||||
|
||||
// True when a separate in-place lift must be suppressed while the current
|
||||
// position is unknown, because _travel_to_z() re-emits the logical X/Y
|
||||
// through this mapping and an uninitialised position would map to a bogus
|
||||
// machine point.
|
||||
virtual bool suppress_lift_at_unknown_position() const = 0;
|
||||
|
||||
// Configuration. GCodeWriter forwards its setters here so that the state
|
||||
// lives with the strategy and a strategy installed before the setters run
|
||||
// still receives it.
|
||||
virtual void set_axis_remap(int rx, int ry, int rz) = 0;
|
||||
virtual void set_build_volume_max(const Vec3d &max) = 0;
|
||||
};
|
||||
|
||||
// Axis remap only -- the historical GCodeWriter behaviour, moved verbatim.
|
||||
//
|
||||
// The remap encodes, per output axis, which source axis feeds it and how:
|
||||
// r < 3 : source axis r, unchanged
|
||||
// r < 6 : source axis r-3, negated
|
||||
// else : source axis r-6, reversed within the build volume
|
||||
class CartesianKinematics : public MachineKinematics
|
||||
{
|
||||
public:
|
||||
Vec3d to_machine(const Vec3d &p) const override;
|
||||
Vec3d to_logical(const Vec3d &machine) const override;
|
||||
Vec3d to_build_volume(const Vec3d &machine) const override { return machine; }
|
||||
|
||||
bool must_emit_all_axes() const override { return this->has_axis_remap(); }
|
||||
// The base writer has never suppressed the lift, not even under a remap that
|
||||
// makes _travel_to_z re-emit X/Y. That is arguably a latent bug, but fixing
|
||||
// it here would change emitted G-code, so today's behaviour is preserved and
|
||||
// the divergence from BeltKinematics is deliberate.
|
||||
bool suppress_lift_at_unknown_position() const override { return false; }
|
||||
|
||||
void set_axis_remap(int rx, int ry, int rz) override
|
||||
{ m_remap_x = rx; m_remap_y = ry; m_remap_z = rz; }
|
||||
void set_build_volume_max(const Vec3d &max) override { m_build_vol_max = max; }
|
||||
|
||||
bool has_axis_remap() const
|
||||
{ return m_remap_x != 0 || m_remap_y != 1 || m_remap_z != 2; }
|
||||
|
||||
protected:
|
||||
Vec3d apply_axis_remap(const Vec3d &pos) const;
|
||||
Vec3d apply_axis_remap_inverse(const Vec3d &pos) const;
|
||||
|
||||
int m_remap_x { 0 };
|
||||
int m_remap_y { 1 };
|
||||
int m_remap_z { 2 };
|
||||
Vec3d m_build_vol_max { Vec3d::Zero() };
|
||||
};
|
||||
|
||||
} // namespace Slic3r
|
||||
|
||||
#endif // slic3r_MachineKinematics_hpp_
|
||||
@@ -1,4 +1,5 @@
|
||||
#include "GCodeWriter.hpp"
|
||||
#include "FirstLayerPlane.hpp"
|
||||
#include "CustomGCode.hpp"
|
||||
#include "Geometry.hpp"
|
||||
#include "I18N.hpp"
|
||||
@@ -24,34 +25,46 @@ namespace Slic3r {
|
||||
|
||||
bool GCodeWriter::full_gcode_comment = true;
|
||||
|
||||
bool GCodeWriter::point_on_first_layer(const Vec3d &point_logical) const
|
||||
{
|
||||
if (m_first_layer_plane && m_first_layer_plane->is_active())
|
||||
return m_first_layer_plane->is_first_layer(point_logical, m_first_layer_thickness_mm);
|
||||
return m_is_first_layer;
|
||||
}
|
||||
|
||||
void GCodeWriter::set_axis_remap(int rx, int ry, int rz)
|
||||
{
|
||||
m_remap_x = rx;
|
||||
m_remap_y = ry;
|
||||
m_remap_z = rz;
|
||||
m_kinematics->set_axis_remap(rx, ry, rz);
|
||||
}
|
||||
|
||||
void GCodeWriter::set_build_volume_max(const Vec3d &max)
|
||||
{
|
||||
m_build_vol_max = max;
|
||||
m_kinematics->set_build_volume_max(max);
|
||||
}
|
||||
|
||||
void GCodeWriter::set_kinematics(std::unique_ptr<MachineKinematics> kinematics)
|
||||
{
|
||||
assert(kinematics);
|
||||
m_kinematics = std::move(kinematics);
|
||||
// Replay whatever was configured on the previous strategy so callers may
|
||||
// install the kinematics before or after set_axis_remap/set_build_volume_max.
|
||||
m_kinematics->set_axis_remap(m_remap_x, m_remap_y, m_remap_z);
|
||||
m_kinematics->set_build_volume_max(m_build_vol_max);
|
||||
}
|
||||
|
||||
// Kept as the writer-facing name for "this move must emit every axis word".
|
||||
bool GCodeWriter::has_axis_remap() const
|
||||
{
|
||||
return m_remap_x != 0 || m_remap_y != 1 || m_remap_z != 2;
|
||||
return m_kinematics->must_emit_all_axes();
|
||||
}
|
||||
|
||||
Vec3d GCodeWriter::apply_axis_remap(const Vec3d &pos) const
|
||||
{
|
||||
if (!has_axis_remap())
|
||||
return pos;
|
||||
auto remap = [this, &pos](int r) -> double {
|
||||
int axis = r % 3;
|
||||
if (r < 3) return pos[axis];
|
||||
if (r < 6) return -pos[axis];
|
||||
return m_build_vol_max[axis] - pos[axis];
|
||||
};
|
||||
return { remap(m_remap_x), remap(m_remap_y), remap(m_remap_z) };
|
||||
return m_kinematics->to_machine(pos);
|
||||
}
|
||||
|
||||
bool GCodeWriter::supports_separate_travel_acceleration(GCodeFlavor flavor)
|
||||
@@ -795,7 +808,7 @@ std::string GCodeWriter::travel_to_xy(const Vec2d &point, const std::string &com
|
||||
} else {
|
||||
w.emit_xy(point_on_plate);
|
||||
}
|
||||
auto speed = m_is_first_layer
|
||||
auto speed = this->point_on_first_layer(Vec3d(point.x(), point.y(), m_pos.z()))
|
||||
? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx) : this->config.travel_speed.get_at(m_cached_extruder_idx);
|
||||
w.emit_f(speed * 60.0);
|
||||
//BBS
|
||||
@@ -808,6 +821,8 @@ it will not perform subsequent lifts, even if Z was raised manually
|
||||
(i.e. with travel_to_z()) and thus _lifted was reduced. */
|
||||
std::string GCodeWriter::lazy_lift(LiftType lift_type, bool spiral_vase)
|
||||
{
|
||||
if (m_force_normal_lift)
|
||||
lift_type = LiftType::NormalLift;
|
||||
// check whether the above/below conditions are met
|
||||
double target_lift = 0;
|
||||
{
|
||||
@@ -836,7 +851,7 @@ std::string GCodeWriter::lazy_lift(LiftType lift_type, bool spiral_vase)
|
||||
// BBS: immediately execute an undelayed lift move with a spiral lift pattern
|
||||
// designed specifically for subsequent gcode injection (e.g. timelapse)
|
||||
std::string GCodeWriter::eager_lift(const LiftType type) {
|
||||
const LiftType effective_type = type;
|
||||
const LiftType effective_type = m_force_normal_lift ? LiftType::NormalLift : type;
|
||||
std::string lift_move;
|
||||
double target_lift = 0;
|
||||
{
|
||||
@@ -888,7 +903,12 @@ std::string GCodeWriter::travel_to_xyz(const Vec3d &point, const std::string &co
|
||||
// BBS
|
||||
Vec3d dest_point = point;
|
||||
auto travel_speed =
|
||||
m_is_first_layer ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx) : this->config.travel_speed.get_at(m_cached_extruder_idx);
|
||||
this->point_on_first_layer(point) ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx) : this->config.travel_speed.get_at(m_cached_extruder_idx);
|
||||
// See uses_pointwise_travel_speed(): the historical path deliberately emits the
|
||||
// raw configured speed in the final branch below, ignoring travel_speed.
|
||||
const double final_travel_speed = this->uses_pointwise_travel_speed()
|
||||
? travel_speed
|
||||
: this->config.travel_speed.get_at(m_cached_extruder_idx);
|
||||
//BBS: a z_hop need to be handle when travel
|
||||
if (std::abs(m_to_lift) > EPSILON) {
|
||||
assert(std::abs(m_lifted) < EPSILON);
|
||||
@@ -946,7 +966,16 @@ std::string GCodeWriter::travel_to_xyz(const Vec3d &point, const std::string &co
|
||||
w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
slop_move = w0.string();
|
||||
}
|
||||
else if (m_to_lift_type == LiftType::NormalLift) {
|
||||
else if (m_to_lift_type == LiftType::NormalLift &&
|
||||
(! m_kinematics->suppress_lift_at_unknown_position() ||
|
||||
this->is_current_position_clear())) {
|
||||
// Only lift in place when the current position is known, for a mapping
|
||||
// that makes _travel_to_z re-emit logical X/Y: at print start (and after
|
||||
// custom gcode) m_pos.xy is still the uninitialised origin, which would
|
||||
// map to a bogus machine point. The xy_z_move below then travels straight
|
||||
// to the destination with full XYZ and establishes the correct position.
|
||||
// Mappings that do not need this (the historical Cartesian behaviour)
|
||||
// report false and keep lifting unconditionally.
|
||||
slop_move = _travel_to_z(target.z(), "normal lift Z");
|
||||
}
|
||||
}
|
||||
@@ -1002,20 +1031,20 @@ std::string GCodeWriter::travel_to_xyz(const Vec3d &point, const std::string &co
|
||||
if (has_axis_remap()) {
|
||||
// Remap may couple XY with Z; emit full XYZ in machine coordinates.
|
||||
w.emit_xyz(apply_axis_remap(point_on_plate));
|
||||
w.emit_f(this->config.travel_speed.get_at(m_cached_extruder_idx) * 60.0);
|
||||
w.emit_f(final_travel_speed * 60.0);
|
||||
w.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
out_string = w.string();
|
||||
} else if (!this->is_current_position_clear())
|
||||
{
|
||||
//force to move xy first then z after filament change
|
||||
w.emit_xy(Vec2d(point_on_plate.x(), point_on_plate.y()));
|
||||
w.emit_f(this->config.travel_speed.get_at(m_cached_extruder_idx) * 60.0);
|
||||
w.emit_f(final_travel_speed * 60.0);
|
||||
w.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
out_string = w.string() + _travel_to_z(point_on_plate.z(), comment);
|
||||
} else {
|
||||
GCodeG1Formatter w;
|
||||
w.emit_xyz(point_on_plate);
|
||||
w.emit_f(this->config.travel_speed.get_at(m_cached_extruder_idx) * 60.0);
|
||||
w.emit_f(final_travel_speed * 60.0);
|
||||
w.emit_comment(GCodeWriter::full_gcode_comment, comment);
|
||||
out_string = w.string();
|
||||
}
|
||||
@@ -1050,8 +1079,9 @@ std::string GCodeWriter::_travel_to_z(double z, const std::string &comment)
|
||||
|
||||
double speed = this->config.travel_speed_z.get_at(m_cached_extruder_idx);
|
||||
if (speed == 0.) {
|
||||
speed = m_is_first_layer ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
|
||||
: this->config.travel_speed.get_at(m_cached_extruder_idx);
|
||||
speed = this->point_on_first_layer(Vec3d(m_pos.x(), m_pos.y(), z))
|
||||
? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
|
||||
: this->config.travel_speed.get_at(m_cached_extruder_idx);
|
||||
}
|
||||
|
||||
GCodeG1Formatter w;
|
||||
|
||||
@@ -9,8 +9,12 @@
|
||||
#include "Polygon.hpp"
|
||||
#include "PrintConfig.hpp"
|
||||
#include "GCode/CoolingBuffer.hpp"
|
||||
#include "GCode/MachineKinematics.hpp"
|
||||
#include <memory>
|
||||
namespace Slic3r {
|
||||
|
||||
class FirstLayerPlane;
|
||||
|
||||
class GCodeWriter {
|
||||
public:
|
||||
virtual ~GCodeWriter() = default;
|
||||
@@ -28,7 +32,8 @@ public:
|
||||
m_lifted(0),
|
||||
m_to_lift(0),
|
||||
m_to_lift_type(LiftType::NormalLift),
|
||||
m_current_speed(3600), m_is_first_layer(true)
|
||||
m_current_speed(3600), m_is_first_layer(true),
|
||||
m_kinematics(std::make_unique<CartesianKinematics>())
|
||||
{}
|
||||
Extruder* filament(size_t extruder_id) { assert(extruder_id < m_curr_filament_extruder.size()); return m_curr_filament_extruder[extruder_id]; }
|
||||
const Extruder* filament(size_t extruder_id) const { assert(extruder_id < m_curr_filament_extruder.size()); return m_curr_filament_extruder[extruder_id]; }
|
||||
@@ -142,10 +147,28 @@ public:
|
||||
void set_build_volume_max(const Vec3d &max);
|
||||
bool has_axis_remap() const;
|
||||
|
||||
// Install the machine frame mapping. Any axis remap / build volume already
|
||||
// configured is carried over, so install order does not matter.
|
||||
void set_kinematics(std::unique_ptr<MachineKinematics> kinematics);
|
||||
const MachineKinematics& kinematics() const { return *m_kinematics; }
|
||||
|
||||
// First-layer plane evaluator. When set to an active plane, travel speed
|
||||
// selection consults the plane per destination point instead of the
|
||||
// layer-coarse m_is_first_layer flag. Borrowed pointer; lifetime is owned
|
||||
// by GCode, which constructs the plane after the writer exists -- so this is
|
||||
// deliberately a setter and not a constructor argument.
|
||||
void set_first_layer_plane(const FirstLayerPlane *plane, double first_layer_height_mm)
|
||||
{ m_first_layer_plane = plane; m_first_layer_thickness_mm = first_layer_height_mm; }
|
||||
|
||||
// Force every lift to a plain vertical lift. Spiral and slope lifts compute
|
||||
// their slope in the logical frame and do not account for a machine mapping
|
||||
// that couples axes.
|
||||
void set_force_normal_lift(bool force) { m_force_normal_lift = force; }
|
||||
|
||||
// Returns whether this flavor supports separate print and travel acceleration.
|
||||
static bool supports_separate_travel_acceleration(GCodeFlavor flavor);
|
||||
protected:
|
||||
// Position/lift/offset state — accessible to subclasses (e.g. BeltGCodeWriter)
|
||||
// Position/lift/offset state.
|
||||
Vec3d m_pos = Vec3d::Zero();
|
||||
double m_x_offset{ 0 };
|
||||
double m_y_offset{ 0 };
|
||||
@@ -158,17 +181,44 @@ protected:
|
||||
|
||||
virtual std::string _travel_to_z(double z, const std::string &comment);
|
||||
|
||||
// Axis remap state — accessible to subclasses.
|
||||
// Whether a destination gets first-layer treatment. With an active plane
|
||||
// evaluator, distance from the plane decides; otherwise the layer-coarse
|
||||
// m_is_first_layer flag does.
|
||||
bool point_on_first_layer(const Vec3d &point_logical) const;
|
||||
|
||||
// True when travel speed is selected per destination point rather than per
|
||||
// layer. Set for writers that install a first-layer plane. The historical
|
||||
// path emits the raw configured travel speed in the final branch of
|
||||
// travel_to_xyz(), ignoring the first-layer selection computed at the top of
|
||||
// that function; a plane-driven writer uses the first-layer-aware value
|
||||
// throughout. Both are preserved exactly -- unifying them would change
|
||||
// emitted feedrates and belongs in its own commit.
|
||||
bool uses_pointwise_travel_speed() const { return m_first_layer_plane != nullptr; }
|
||||
|
||||
// Borrowed; null = inactive.
|
||||
const FirstLayerPlane *m_first_layer_plane = nullptr;
|
||||
double m_first_layer_thickness_mm = 0.;
|
||||
bool m_force_normal_lift = false;
|
||||
|
||||
// The machine frame mapping. Owns the axis-remap state that used to live
|
||||
// here as m_remap_* / m_build_vol_max; the setters above forward to it.
|
||||
// Never null: a CartesianKinematics at the identity remap reproduces the
|
||||
// historical behaviour exactly.
|
||||
std::unique_ptr<MachineKinematics> m_kinematics;
|
||||
|
||||
// Last configured remap / build volume, replayed onto a newly installed
|
||||
// kinematics so set_kinematics() and the setters are order-independent.
|
||||
int m_remap_x = 0; // RemapAxis: 0=+X, 1=+Y, 2=+Z, 3=-X, etc.
|
||||
int m_remap_y = 1;
|
||||
int m_remap_z = 2;
|
||||
Vec3d m_build_vol_max = Vec3d::Zero();
|
||||
|
||||
// Apply axis remap to a point. Returns pos unchanged if remap is identity.
|
||||
// Apply the machine frame mapping to a point. Returns pos unchanged when the
|
||||
// mapping is the identity.
|
||||
Vec3d apply_axis_remap(const Vec3d &pos) const;
|
||||
|
||||
// Motion uses the global/base process variant until a filament becomes active.
|
||||
// Protected so BeltGCodeWriter indexes the per-extruder speed options (travel_speed,
|
||||
// Protected so subclasses index the per-extruder speed options (travel_speed,
|
||||
// travel_speed_z, initial_layer_travel_speed) exactly as the base writer does.
|
||||
size_t m_cached_extruder_idx;
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
#include "calib.hpp"
|
||||
#include "BeltGCodeWriter.hpp"
|
||||
#include "GCode/BeltKinematics.hpp"
|
||||
#include "BoundingBox.hpp"
|
||||
#include "Config.hpp"
|
||||
#include "Model.hpp"
|
||||
@@ -855,10 +855,8 @@ void CalibPressureAdvancePattern::_refresh_writer(bool is_bbl_machine, const Mod
|
||||
// needs the machine kinematics (axis remap + frame shear/scale) with the
|
||||
// coordinates interpreted as world points (see set_world_coordinates).
|
||||
if (print_config.belt_printer.value) {
|
||||
auto belt_writer = std::make_shared<BeltGCodeWriter>();
|
||||
belt_writer->set_belt_back_transform(print_config);
|
||||
belt_writer->set_machine_frame_transform(print_config);
|
||||
belt_writer->set_world_coordinates(true);
|
||||
auto belt_writer = std::make_shared<GCodeWriter>();
|
||||
install_belt_kinematics(*belt_writer, print_config, /*world_coordinates=*/true);
|
||||
const int rx = int(print_config.gcode_remap_x.value);
|
||||
const int ry = int(print_config.gcode_remap_y.value);
|
||||
const int rz = int(print_config.gcode_remap_z.value);
|
||||
@@ -869,7 +867,9 @@ void CalibPressureAdvancePattern::_refresh_writer(bool is_bbl_machine, const Mod
|
||||
print_config.printable_height.value));
|
||||
}
|
||||
m_writer = std::move(belt_writer);
|
||||
} else if (dynamic_cast<BeltGCodeWriter*>(m_writer.get()) != nullptr) {
|
||||
} else if (m_writer && dynamic_cast<const BeltKinematics *>(&m_writer->kinematics()) != nullptr) {
|
||||
// Previously configured for a belt printer; drop back to a plain writer,
|
||||
// exactly as the old dynamic_cast<BeltGCodeWriter*> check did.
|
||||
m_writer = std::make_shared<GCodeWriter>();
|
||||
}
|
||||
|
||||
|
||||
@@ -377,7 +377,7 @@ private:
|
||||
|
||||
const Calib_Params &m_params;
|
||||
|
||||
// Polymorphic so belt printers get a BeltGCodeWriter in world-coordinates
|
||||
// Polymorphic so belt printers get belt kinematics in world-coordinates
|
||||
// mode (_refresh_writer); shared_ptr keeps the class copyable — the writer
|
||||
// is rebuilt by refresh_setup() before every use anyway.
|
||||
std::shared_ptr<GCodeWriter> m_writer{std::make_shared<GCodeWriter>()};
|
||||
|
||||
@@ -1147,7 +1147,7 @@ std::vector<int> GCodeViewer::get_plater_extruder()
|
||||
|
||||
// Belt printers: compute the full machine->model back-transform from the print
|
||||
// config, so the "designed" (upright) G-code preview maps each toolpath vertex
|
||||
// back to Cartesian space. The G-code forward pipeline is (BeltGCodeWriter::
|
||||
// back to Cartesian space. The G-code forward pipeline is (BeltKinematics::
|
||||
// to_machine_coords): gcode = MachineFrame( AxisRemap( X ) ), with X = model if
|
||||
// gcode_back_transform (write already un-rotated to Cartesian) else BeltForward(
|
||||
// model). So the inverse is:
|
||||
|
||||
@@ -15760,7 +15760,7 @@ void Plater::_calib_apply_belt_mode()
|
||||
void Plater::calib_pa(const Calib_Params& params)
|
||||
{
|
||||
// ORCA-Belt: PA Line / PA Pattern have the belt plumbing in place
|
||||
// (BeltGCodeWriter::set_world_coordinates draws them on the belt surface)
|
||||
// (belt kinematics in world-coordinates mode draws them on the belt surface)
|
||||
// but are not validated yet — keep them gated to the PA Tower for now.
|
||||
{
|
||||
double angle_rad = 0.;
|
||||
|
||||
@@ -98,7 +98,7 @@ std::vector<wxString> make_shaper_type_labels()
|
||||
}
|
||||
|
||||
// ORCA-Belt: PA Line / PA Pattern have belt plumbing in place (drawn on the
|
||||
// belt surface via BeltGCodeWriter world-coordinates mode) but are not
|
||||
// belt surface via BeltKinematics world-coordinates mode) but are not
|
||||
// validated yet — belt printers are restricted to the PA Tower for now.
|
||||
bool is_belt_printer_selected()
|
||||
{
|
||||
|
||||
@@ -19,7 +19,7 @@
|
||||
#include "libslic3r/GCode/GCodeProcessor.hpp"
|
||||
#include <algorithm>
|
||||
#include <limits>
|
||||
#include "libslic3r/BeltGCodeWriter.hpp"
|
||||
#include "libslic3r/GCode/BeltKinematics.hpp"
|
||||
#include "libslic3r/BeltTransform.hpp"
|
||||
#include "libslic3r/GCodeReader.hpp"
|
||||
#include "libslic3r/PrintConfig.hpp"
|
||||
@@ -39,9 +39,8 @@ TEST_CASE("Belt machine coordinates retain a non-45-degree slicing angle", "[GCo
|
||||
config.gcode_remap_y.value = RemapAxis::PosZ;
|
||||
config.gcode_remap_z.value = RemapAxis::PosY;
|
||||
|
||||
BeltGCodeWriter writer;
|
||||
writer.set_belt_back_transform(config);
|
||||
writer.set_machine_frame_transform(config);
|
||||
GCodeWriter writer;
|
||||
install_belt_kinematics(writer, config);
|
||||
writer.set_axis_remap(int(config.gcode_remap_x.value),
|
||||
int(config.gcode_remap_y.value),
|
||||
int(config.gcode_remap_z.value));
|
||||
@@ -52,7 +51,7 @@ TEST_CASE("Belt machine coordinates retain a non-45-degree slicing angle", "[GCo
|
||||
// machine-frame shear/scale are applied.
|
||||
const Vec3d model(4., 10., 3.);
|
||||
Transform3d forward = BeltTransformPipeline::build_forward_transform(config);
|
||||
const Vec3d machine = writer.to_machine_coords(forward * model);
|
||||
const Vec3d machine = writer.kinematics().to_machine(forward * model);
|
||||
|
||||
// The conventional X-tilt remap produces (x, z, y). At 30 degrees the
|
||||
// gantry coordinate is z/sin(30) and belt travel is y + z*cot(30).
|
||||
@@ -905,7 +904,7 @@ TEST_CASE("Custom G-code motion limits are restored before generated moves", "[G
|
||||
// is_current_position_clear(), mirroring the SlopeLift branch.
|
||||
SCENARIO("Belt: the first travel does not lift through the uninitialised origin", "[GCodeWriter][belt]")
|
||||
{
|
||||
GIVEN("A fresh BeltGCodeWriter configured for an X-tilt 45 degree belt") {
|
||||
GIVEN("A fresh belt-kinematics GCodeWriter configured for an X-tilt 45 degree belt") {
|
||||
// Machine-frame + slicer->world back-transform config (X tilt, 45 deg).
|
||||
PrintConfig belt_config;
|
||||
belt_config.belt_printer.value = true;
|
||||
@@ -917,9 +916,8 @@ SCENARIO("Belt: the first travel does not lift through the uninitialised origin"
|
||||
belt_config.belt_frame_tilt_decouple.value = false;
|
||||
belt_config.belt_frame_tilt_angle.value = 45.0;
|
||||
|
||||
BeltGCodeWriter writer;
|
||||
writer.set_machine_frame_transform(belt_config);
|
||||
writer.set_belt_back_transform(belt_config);
|
||||
GCodeWriter writer;
|
||||
install_belt_kinematics(writer, belt_config);
|
||||
|
||||
std::vector<unsigned int> extruder_ids { 0 };
|
||||
writer.set_extruders(extruder_ids);
|
||||
|
||||
Reference in New Issue
Block a user