Slic3r::ExportLines Class Reference

Collaboration diagram for Slic3r::ExportLines:

Classes
struct	Backtrace
struct	LineData
class	Statistics

Public Types
enum class	EWriteType { BySize , ByTime }

Public Member Functions
	ExportLines (EWriteType type, const std::array< GCodeProcessor::TimeMachine, static_cast< size_t >(PrintEstimatedStatistics::ETimeMode::Count)> &machines, GCodeFileWriter &writer)
unsigned int	update (const std::string &line, size_t lines_counter, size_t g1_lines_counter)
void	append_line (const std::string &line, const bool ignore_from_move=false)
void	insert_lines (const Backtrace &backtrace, const std::string &cmd, std::function< std::string(unsigned int, const std::vector< float > &)> line_inserter, std::function< std::string(const std::string &)> line_replacer)
void	write (float backtrace_time)
void	flush ()
void	synchronize_moves (GCodeProcessorResult &result) const
unsigned int	remap_gcode_id (unsigned int gcode_id) const
size_t	get_size () const
void	reserve (size_t lines_count)

Private Types
enum	ETimeMode { Normal = static_cast<int>(PrintEstimatedStatistics::ETimeMode::Normal) , Stealth = static_cast<int>(PrintEstimatedStatistics::ETimeMode::Stealth) }

Private Attributes
Statistics	m_statistics
EWriteType	m_write_type {EWriteType::BySize}
const std::array< GCodeProcessor::TimeMachine, static_cast< size_t >(PrintEstimatedStatistics::ETimeMode::Count)> &	m_machines
GCodeFileWriter &	m_writer
std::array< float, static_cast< size_t >(PrintEstimatedStatistics::ETimeMode::Count)>	m_times {0.0f, 0.0f}
size_t	m_size {0}
std::deque< LineData >	m_lines
size_t	m_added_lines_counter {0}
std::vector< std::pair< size_t, size_t > >	m_gcode_lines_map
size_t	m_times_cache_id {0}

Detailed Description

---

Class Documentation

Slic3r::ExportLines::LineData

struct Slic3r::ExportLines::LineData

Collaboration diagram for Slic3r::ExportLines::LineData:

Class Members
string	line
array< float, static_cast< size_t >(Count)>	times {0.0f, 0.0f}

Member Enumeration Documentation

ETimeMode

enum Slic3r::ExportLines::ETimeMode

private

Enumerator
Normal
Stealth

                   {
        Normal  = static_cast<int>(PrintEstimatedStatistics::ETimeMode::Normal),
        Stealth = static_cast<int>(PrintEstimatedStatistics::ETimeMode::Stealth)
    };

EWriteType

enum class Slic3r::ExportLines::EWriteType

strong

Enumerator
BySize
ByTime

{ BySize, ByTime };

Constructor & Destructor Documentation

ExportLines()

Slic3r::ExportLines::ExportLines ( EWriteType type, const std::array< GCodeProcessor::TimeMachine, static_cast< size_t >(PrintEstimatedStatistics::ETimeMode::Count)> & machines, GCodeFileWriter & writer )

inline

        : m_statistics(*this)
        , m_write_type(type)
        , m_machines(machines)
        , m_writer(writer){}

References Slic3r::PrintEstimatedStatistics::Count, m_machines, m_statistics, m_write_type, and m_writer.

Referenced by Slic3r::ExportLines::Statistics::Statistics().

Here is the caller graph for this function:

Member Function Documentation

append_line()

void Slic3r::ExportLines::append_line ( const std::string & line, const bool ignore_from_move = false )

inline

    {
        if (line.empty())
            return;
 
        if (m_write_type == EWriteType::ByTime) {
            m_lines.push_back({line, m_times});
#ifndef NDEBUG
            m_statistics.add_line(line.length());
#endif // NDEBUG
            m_size += line.length();
        } else
            m_writer.append(line);
        ++m_added_lines_counter;
        if (!ignore_from_move) {
            assert(!m_gcode_lines_map.empty());
            m_gcode_lines_map.back().second = m_added_lines_counter;
        }
    }

References ByTime, m_added_lines_counter, m_gcode_lines_map, m_lines, m_size, m_statistics, m_times, m_write_type, and m_writer.

Referenced by Slic3r::GCodeProcessor::run_post_process().

Here is the caller graph for this function:

flush()

void Slic3r::ExportLines::flush ( )

inline

    {
        while (!m_lines.empty()) {
            m_writer.append(m_lines.front().line);
            m_lines.pop_front();
        }
        m_size = 0;
#ifndef NDEBUG
        m_statistics.remove_all_lines();
#endif // NDEBUG
        m_writer.flush();
    }

References m_lines, m_size, m_statistics, and m_writer.

Referenced by Slic3r::GCodeProcessor::run_post_process().

Here is the caller graph for this function:

get_size()

size_t Slic3r::ExportLines::get_size ( ) const

inline

{ return m_size; }

References m_size.

insert_lines()

void Slic3r::ExportLines::insert_lines ( const Backtrace & backtrace, const std::string & cmd, std::function< std::string(unsigned int, const std::vector< float > &)> line_inserter, std::function< std::string(const std::string &)> line_replacer )

inline

    {
        // Orca: find start pos by seaching G28/G29/PRINT_START/START_PRINT commands
        auto is_start_pos = [](const std::string& curr_cmd) {
            return ascii_iequals(curr_cmd, "G28") || ascii_iequals(curr_cmd, "G29") || ascii_iequals(curr_cmd, "PRINT_START") ||
                   ascii_iequals(curr_cmd, "START_PRINT");
        };
        assert(!m_lines.empty());
        const float time_step           = backtrace.time_step();
        size_t      rev_it_dist         = 0;    // distance from the end of the cache of the starting point of the backtrace
        float       last_time_insertion = 0.0f; // used to avoid inserting two lines at the same time
        for (int i = 0; i < backtrace.steps; ++i) {
            const float backtrace_time_i = (i + 1) * time_step;
            const float time_threshold_i = m_times[Normal] - backtrace_time_i;
            auto        rev_it           = m_lines.rbegin() + rev_it_dist;
            auto        start_rev_it     = rev_it;
 
            std::string curr_cmd = GCodeReader::GCodeLine::extract_cmd(rev_it->line);
            // backtrace into the cache to find the place where to insert the line
            while (rev_it != m_lines.rend() && rev_it->times[Normal] > time_threshold_i && curr_cmd != cmd && !is_start_pos(curr_cmd)) {
                rev_it->line = line_replacer(rev_it->line);
                ++rev_it;
                if (rev_it != m_lines.rend())
                    curr_cmd = GCodeReader::GCodeLine::extract_cmd(rev_it->line);
            }
 
            // we met the previous evenience of cmd, or the start position, stop inserting lines
            if (rev_it != m_lines.rend() && (curr_cmd == cmd || is_start_pos(curr_cmd)))
                break;
 
            // insert the line for the current step
            if (rev_it != m_lines.rend() && rev_it != start_rev_it && rev_it->times[Normal] != last_time_insertion) {
                last_time_insertion = rev_it->times[Normal];
                std::vector<float> time_diffs;
                time_diffs.push_back(m_times[Normal] - last_time_insertion);
                if (!m_machines[Stealth].g1_times_cache.empty())
                    time_diffs.push_back(m_times[Stealth] - rev_it->times[Stealth]);
                const std::string out_line = line_inserter(i + 1, time_diffs);
                rev_it_dist                = std::distance(m_lines.rbegin(), rev_it) + 1;
                m_lines.insert(rev_it.base(), {out_line, rev_it->times});
#ifndef NDEBUG
                m_statistics.add_line(out_line.length());
#endif // NDEBUG
                m_size += out_line.length();
                // synchronize gcode lines map
                for (auto map_it = m_gcode_lines_map.rbegin(); map_it != m_gcode_lines_map.rbegin() + rev_it_dist - 1; ++map_it) {
                    ++map_it->second;
                }
 
                ++m_added_lines_counter;
            }
        }
    }

References Slic3r::ascii_iequals(), Slic3r::GCodeReader::GCodeLine::extract_cmd(), m_added_lines_counter, m_gcode_lines_map, m_lines, m_machines, m_size, m_statistics, m_times, Normal, Stealth, Slic3r::ExportLines::Backtrace::steps, and Slic3r::ExportLines::Backtrace::time_step().

Referenced by Slic3r::GCodeProcessor::run_post_process().

Here is the call graph for this function:

Here is the caller graph for this function:

remap_gcode_id()

unsigned int Slic3r::ExportLines::remap_gcode_id ( unsigned int gcode_id ) const

inline

    {
        if (gcode_id == static_cast<unsigned int>(-1))
            return gcode_id;
        auto it = std::lower_bound(m_gcode_lines_map.begin(), m_gcode_lines_map.end(), static_cast<size_t>(gcode_id),
            [](const std::pair<size_t, size_t>& e, size_t v) { return e.first < v; });
        if (it != m_gcode_lines_map.end() && it->first == static_cast<size_t>(gcode_id))
            return static_cast<unsigned int>(it->second);
        return gcode_id;
    }

References m_gcode_lines_map.

Referenced by Slic3r::GCodeProcessor::run_post_process().

Here is the caller graph for this function:

reserve()

void Slic3r::ExportLines::reserve ( size_t lines_count )

inline

{ m_gcode_lines_map.reserve(lines_count); }

References m_gcode_lines_map.

Referenced by Slic3r::GCodeProcessor::run_post_process().

Here is the caller graph for this function:

synchronize_moves()

void Slic3r::ExportLines::synchronize_moves ( GCodeProcessorResult & result ) const

inline

    {
        auto it = m_gcode_lines_map.begin();
        for (GCodeProcessorResult::MoveVertex& move : result.moves) {
            while (it != m_gcode_lines_map.end() && it->first < move.gcode_id) {
                ++it;
            }
            if (it != m_gcode_lines_map.end() && it->first == move.gcode_id)
                move.gcode_id = it->second;
        }
    }

References Slic3r::GCodeProcessorResult::MoveVertex::gcode_id, m_gcode_lines_map, Slic3r::GCodeProcessorResult::moves, and Slic3r::GCodeProcessor::result().

Referenced by Slic3r::GCodeProcessor::run_post_process().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

unsigned int Slic3r::ExportLines::update ( const std::string & line, size_t lines_counter, size_t g1_lines_counter )

inline

    {
        unsigned int ret = 0;
        m_gcode_lines_map.push_back({lines_counter, 0});
 
        if (GCodeReader::GCodeLine::cmd_is(line, "G0") || GCodeReader::GCodeLine::cmd_is(line, "G1") ||
            GCodeReader::GCodeLine::cmd_is(line, "G2") || GCodeReader::GCodeLine::cmd_is(line, "G3") ||
            GCodeReader::GCodeLine::cmd_is(line, "G28"))
            ++g1_lines_counter;
        else
            return ret;
 
        auto init_it = m_machines[Normal].g1_times_cache.begin() + m_times_cache_id;
        auto it      = init_it;
        while (it != m_machines[Normal].g1_times_cache.end() && it->id < g1_lines_counter) {
            ++it;
            ++m_times_cache_id;
        }
 
        if (it == m_machines[Normal].g1_times_cache.end() || it->id > g1_lines_counter)
            return ret;
 
        // search for internal G1 lines
        if (GCodeReader::GCodeLine::cmd_is(line, "G2") || GCodeReader::GCodeLine::cmd_is(line, "G3")) {
            while (it != m_machines[Normal].g1_times_cache.end() && it->remaining_internal_g1_lines > 0) {
                ++it;
                ++m_times_cache_id;
                ++g1_lines_counter;
                ++ret;
            }
        }
 
        if (it != m_machines[Normal].g1_times_cache.end() && it->id == g1_lines_counter) {
            m_times[Normal] = it->elapsed_time;
            if (!m_machines[Stealth].g1_times_cache.empty())
                m_times[Stealth] = (m_machines[Stealth].g1_times_cache.begin() +
                                    std::distance(m_machines[Normal].g1_times_cache.begin(), it))
                                       ->elapsed_time;
        }
 
        return ret;
    }

References Slic3r::GCodeReader::GCodeLine::cmd_is(), m_gcode_lines_map, m_machines, m_times, m_times_cache_id, Normal, and Stealth.

Referenced by Slic3r::GCodeProcessor::run_post_process().

Here is the call graph for this function:

Here is the caller graph for this function:

write()

void Slic3r::ExportLines::write ( float backtrace_time )

inline

    {
        if (m_write_type != EWriteType::ByTime)
            return;
 
        while (!m_lines.empty() && m_lines.front().times[Normal] < m_times[Normal] - backtrace_time) {
            const LineData& data = m_lines.front();
            m_writer.append(data.line);
            m_size -= data.line.length();
            m_lines.pop_front();
#ifndef NDEBUG
            m_statistics.remove_line();
#endif // NDEBUG
        }
    }

References ByTime, Slic3r::ExportLines::LineData::line, m_lines, m_size, m_statistics, m_times, m_write_type, m_writer, and Normal.

Referenced by Slic3r::GCodeProcessor::run_post_process().

Here is the caller graph for this function:

Member Data Documentation

m_added_lines_counter

size_t Slic3r::ExportLines::m_added_lines_counter {0}

private

{0};

Referenced by append_line(), and insert_lines().

m_gcode_lines_map

std::vector<std::pair<size_t, size_t> > Slic3r::ExportLines::m_gcode_lines_map

private

Referenced by append_line(), insert_lines(), remap_gcode_id(), reserve(), synchronize_moves(), and update().

m_lines

std::deque<LineData> Slic3r::ExportLines::m_lines

private

Referenced by append_line(), flush(), insert_lines(), and write().

m_machines

const std::array<GCodeProcessor::TimeMachine, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)>& Slic3r::ExportLines::m_machines

private

Referenced by ExportLines(), insert_lines(), and update().

m_size

size_t Slic3r::ExportLines::m_size {0}

private

{0};

Referenced by append_line(), flush(), get_size(), insert_lines(), and write().

m_statistics

Statistics Slic3r::ExportLines::m_statistics

private

Referenced by ExportLines(), append_line(), flush(), insert_lines(), and write().

m_times

std::array<float, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)> Slic3r::ExportLines::m_times {0.0f, 0.0f}

private

{0.0f, 0.0f};

Referenced by append_line(), insert_lines(), update(), and write().

m_times_cache_id

size_t Slic3r::ExportLines::m_times_cache_id {0}

private

{0};

Referenced by update().

m_write_type

EWriteType Slic3r::ExportLines::m_write_type {EWriteType::BySize}

private

{EWriteType::BySize};

Referenced by ExportLines(), append_line(), and write().

m_writer

GCodeFileWriter& Slic3r::ExportLines::m_writer

private

Referenced by ExportLines(), append_line(), flush(), and write().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/GCodeProcessor.cpp