3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-12 09:17:52 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

GCodeTimeEstimator: refactoring of forward and reverse passes on blocks

Browse source
This commit is contained in:
Enrico Turri 2018-01-04 13:00:34 +01:00
parent 011281df86
commit 3f57e20235
2 changed files with 49 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

58
xs/src/libslic3r/GCodeTimeEstimator.cpp
View file

@ -897,75 +897,63 @@ namespace Slic3r {
void GCodeTimeEstimator::_forward_pass() void GCodeTimeEstimator::_forward_pass()
{ {
Block* block[2] = { nullptr, nullptr }; if (_blocks.size() > 1)
for (Block& b : _blocks)
{ {
block[0] = block[1]; for (unsigned int i = 0; i < (unsigned int)_blocks.size() - 1; ++i)
block[1] = &b; {
_planner_forward_pass_kernel(block[0], block[1]); _planner_forward_pass_kernel(_blocks[i], _blocks[i + 1]);
}
} }
_planner_forward_pass_kernel(block[1], nullptr);
} }
void GCodeTimeEstimator::_reverse_pass() void GCodeTimeEstimator::_reverse_pass()
{ {
Block* block[2] = { nullptr, nullptr }; if (_blocks.size() > 1)
for (int i = (int)_blocks.size() - 1; i >= 0; --i)
{ {
block[1] = block[0]; for (int i = (int)_blocks.size() - 1; i >= 1; --i)
block[0] = &_blocks[i]; {
_planner_reverse_pass_kernel(block[0], block[1]); _planner_reverse_pass_kernel(_blocks[i - 1], _blocks[i]);
}
} }
} }
void GCodeTimeEstimator::_planner_forward_pass_kernel(Block* prev, Block* curr) void GCodeTimeEstimator::_planner_forward_pass_kernel(Block& prev, Block& curr)
{ {
if (prev == nullptr || curr == nullptr)
//FIXME something is fishy here. Review and compare with the firmware.
// if (prev == nullptr)
return;
// If the previous block is an acceleration block, but it is not long enough to complete the // If the previous block is an acceleration block, but it is not long enough to complete the
// full speed change within the block, we need to adjust the entry speed accordingly. Entry // full speed change within the block, we need to adjust the entry speed accordingly. Entry
// speeds have already been reset, maximized, and reverse planned by reverse planner. // speeds have already been reset, maximized, and reverse planned by reverse planner.
// If nominal length is true, max junction speed is guaranteed to be reached. No need to recheck. // If nominal length is true, max junction speed is guaranteed to be reached. No need to recheck.
if (!prev->flags.nominal_length) if (!prev.flags.nominal_length)
{ {
if (prev->feedrate.entry < curr->feedrate.entry) if (prev.feedrate.entry < curr.feedrate.entry)
{ {
float entry_speed = std::min(curr->feedrate.entry, Block::max_allowable_speed(-prev->acceleration, prev->feedrate.entry, prev->move_length())); float entry_speed = std::min(curr.feedrate.entry, Block::max_allowable_speed(-prev.acceleration, prev.feedrate.entry, prev.move_length()));
// Check for junction speed change // Check for junction speed change
if (curr->feedrate.entry != entry_speed) if (curr.feedrate.entry != entry_speed)
{ {
curr->feedrate.entry = entry_speed; curr.feedrate.entry = entry_speed;
curr->flags.recalculate = true; curr.flags.recalculate = true;
} }
} }
} }
} }
void GCodeTimeEstimator::_planner_reverse_pass_kernel(Block* curr, Block* next) void GCodeTimeEstimator::_planner_reverse_pass_kernel(Block& curr, Block& next)
{ {
if ((curr == nullptr) || (next == nullptr))
return;
// If entry speed is already at the maximum entry speed, no need to recheck. Block is cruising. // If entry speed is already at the maximum entry speed, no need to recheck. Block is cruising.
// If not, block in state of acceleration or deceleration. Reset entry speed to maximum and // If not, block in state of acceleration or deceleration. Reset entry speed to maximum and
// check for maximum allowable speed reductions to ensure maximum possible planned speed. // check for maximum allowable speed reductions to ensure maximum possible planned speed.
if (curr->feedrate.entry != curr->max_entry_speed) if (curr.feedrate.entry != curr.max_entry_speed)
{ {
// If nominal length true, max junction speed is guaranteed to be reached. Only compute // If nominal length true, max junction speed is guaranteed to be reached. Only compute
// for max allowable speed if block is decelerating and nominal length is false. // for max allowable speed if block is decelerating and nominal length is false.
if (!curr->flags.nominal_length && (curr->max_entry_speed > next->feedrate.entry)) if (!curr.flags.nominal_length && (curr.max_entry_speed > next.feedrate.entry))
curr->feedrate.entry = std::min(curr->max_entry_speed, Block::max_allowable_speed(-curr->acceleration, next->feedrate.entry, curr->move_length())); curr.feedrate.entry = std::min(curr.max_entry_speed, Block::max_allowable_speed(-curr.acceleration, next.feedrate.entry, curr.move_length()));
else else
curr->feedrate.entry = curr->max_entry_speed; curr.feedrate.entry = curr.max_entry_speed;
curr->flags.recalculate = true; curr.flags.recalculate = true;
} }
} }

4
xs/src/libslic3r/GCodeTimeEstimator.hpp
View file

@ -305,8 +305,8 @@ namespace Slic3r {
void _forward_pass(); void _forward_pass();
void _reverse_pass(); void _reverse_pass();
void _planner_forward_pass_kernel(Block* prev, Block* curr); void _planner_forward_pass_kernel(Block& prev, Block& curr);
void _planner_reverse_pass_kernel(Block* curr, Block* next); void _planner_reverse_pass_kernel(Block& curr, Block& next);
void _recalculate_trapezoids(); void _recalculate_trapezoids();
}; };