Slic3r::BackgroundSlicingProcess Class Reference

#include <src/slic3r/GUI/BackgroundSlicingProcess.hpp>

Collaboration diagram for Slic3r::BackgroundSlicingProcess:

Classes
struct	UITask

Public Types
enum	State {   STATE_INITIAL = 0 , STATE_IDLE , STATE_STARTED , STATE_RUNNING ,   STATE_FINISHED , STATE_CANCELED , STATE_EXIT , STATE_EXITED }

Public Member Functions
	BackgroundSlicingProcess ()
	~BackgroundSlicingProcess ()
void	set_fff_print (Print *print)
void	set_sla_print (SLAPrint *print)
void	set_thumbnail_cb (ThumbnailsGeneratorCallback cb)
void	set_gcode_result (GCodeProcessorResult *result)
void	set_slicing_completed_event (int event_id)
void	set_finished_event (int event_id)
void	set_export_began_event (int event_id)
bool	select_technology (PrinterTechnology tech)
PrinterTechnology	current_printer_technology () const
const PrintBase *	current_print () const
const Print *	fff_print () const
const SLAPrint *	sla_print () const
std::string	output_filepath_for_project (const boost::filesystem::path &project_path)
bool	start ()
bool	stop ()
bool	reset ()
PrintBase::ApplyStatus	apply (const Model &model, const DynamicPrintConfig &config)
void	set_task (const PrintBase::TaskParams &params)
bool	empty () const
std::string	validate (std::vector< std::string > *warnings=nullptr)
void	schedule_export (const std::string &path, bool export_path_on_removable_media)
void	schedule_upload (Slic3r::PrintHostJob upload_job)
void	reset_export ()
bool	is_export_scheduled () const
bool	is_upload_scheduled () const
State	state () const
bool	idle () const
bool	running () const
bool	finished () const

Private Member Functions
void	thread_proc ()
void	thread_proc_safe () throw ()
void	join_background_thread ()
void	stop_internal ()
void	process_fff ()
void	process_sla ()
void	call_process (std::exception_ptr &ex) throw ()
bool	set_step_started (BackgroundSlicingProcessStep step)
void	set_step_done (BackgroundSlicingProcessStep step)
bool	is_step_done (BackgroundSlicingProcessStep step) const
bool	invalidate_step (BackgroundSlicingProcessStep step)
bool	invalidate_all_steps ()
void	throw_if_canceled () const
void	finalize_gcode ()
void	prepare_upload ()
ThumbnailsList	render_thumbnails (const ThumbnailsParams &params)
bool	execute_ui_task (std::function< void()> task)

Static Private Member Functions
static void	cancel_ui_task (std::shared_ptr< BackgroundSlicingProcess::UITask > task)

Private Attributes
PrintBase *	m_print = nullptr
Print *	m_fff_print = nullptr
SLAPrint *	m_sla_print = nullptr
GCodeProcessorResult *	m_gcode_result = nullptr
ThumbnailsGeneratorCallback	m_thumbnail_cb = nullptr
std::string	m_temp_output_path
std::string	m_export_path
bool	m_export_path_on_removable_media = false
PrintHostJob	m_upload_job
boost::thread	m_thread
std::mutex	m_mutex
std::condition_variable	m_condition
State	m_state = STATE_INITIAL
std::shared_ptr< UITask >	m_ui_task
PrintState< BackgroundSlicingProcessStep, bspsCount >	m_step_state
int	m_event_slicing_completed_id = 0
int	m_event_finished_id = 0
int	m_event_export_began_id = 0

Detailed Description

Member Enumeration Documentation

State

enum Slic3r::BackgroundSlicingProcess::State

Enumerator
STATE_INITIAL
STATE_IDLE
STATE_STARTED
STATE_RUNNING
STATE_FINISHED
STATE_CANCELED
STATE_EXIT
STATE_EXITED

             {
    // m_thread  is not running yet, or it did not reach the STATE_IDLE yet (it does not wait on the condition yet).
    STATE_INITIAL = 0,
    // m_thread is waiting for the task to execute.
    STATE_IDLE,
    STATE_STARTED,
    // m_thread is executing a task.
    STATE_RUNNING,
    // m_thread finished executing a task, and it is waiting until the UI thread picks up the results.
    STATE_FINISHED,
    // m_thread finished executing a task, the task has been canceled by the UI thread, therefore the UI thread will not be notified.
    STATE_CANCELED,
    // m_thread exited the loop and it is going to finish. The UI thread should join on m_thread.
    STATE_EXIT,
    STATE_EXITED,
  };

Constructor & Destructor Documentation

BackgroundSlicingProcess()

Slic3r::BackgroundSlicingProcess::BackgroundSlicingProcess

(

)

{
    boost::filesystem::path temp_path(wxStandardPaths::Get().GetTempDir().utf8_str().data());
    temp_path /= (boost::format(".%1%.gcode") % get_current_pid()).str();
  m_temp_output_path = temp_path.string();
}

References Slic3r::get_current_pid(), and m_temp_output_path.

Here is the call graph for this function:

~BackgroundSlicingProcess()

Slic3r::BackgroundSlicingProcess::~BackgroundSlicingProcess

(

)

{ 
  this->stop();
  this->join_background_thread();
  boost::nowide::remove(m_temp_output_path.c_str());
}

References join_background_thread(), m_temp_output_path, and stop().

Here is the call graph for this function:

Member Function Documentation

apply()

Print::ApplyStatus Slic3r::BackgroundSlicingProcess::apply	(	const Model &	model,
		const DynamicPrintConfig &	config
	)

{
  assert(m_print != nullptr);
  assert(config.opt_enum<PrinterTechnology>("printer_technology") == m_print->technology());
  Print::ApplyStatus invalidated = m_print->apply(model, config);
  if ((invalidated & PrintBase::APPLY_STATUS_INVALIDATED) != 0 && m_print->technology() == ptFFF &&
    !m_fff_print->is_step_done(psGCodeExport)) {
    // Some FFF status was invalidated, and the G-code was not exported yet.
    // Let the G-code preview UI know that the final G-code preview is not valid.
    // In addition, this early memory deallocation reduces memory footprint.
    if (m_gcode_result != nullptr)
      m_gcode_result->reset();
  }
  return invalidated;
}

References Slic3r::PrintBase::apply(), Slic3r::PrintBase::APPLY_STATUS_INVALIDATED, Slic3r::Print::is_step_done(), m_fff_print, m_gcode_result, m_print, Slic3r::ConfigBase::opt_enum(), Slic3r::psGCodeExport, Slic3r::ptFFF, Slic3r::GCodeProcessorResult::reset(), and Slic3r::PrintBase::technology().

Here is the call graph for this function:

call_process()

void Slic3r::BackgroundSlicingProcess::call_process ( std::exception_ptr &  ex ) throw ( )

private

{
  try {
    assert(m_print != nullptr);
    switch (m_print->technology()) {
    case ptFFF: this->process_fff(); break;
    case ptSLA: this->process_sla(); break;
    default: m_print->process(); break;
    }
  } catch (CanceledException& /* ex */) {
    // Canceled, this is all right.
    assert(m_print->canceled());
    ex = std::current_exception();
  } catch (...) {
    ex = std::current_exception();
  }
}

References Slic3r::ptFFF, and Slic3r::ptSLA.

Referenced by thread_proc().

Here is the caller graph for this function:

cancel_ui_task()

void Slic3r::BackgroundSlicingProcess::cancel_ui_task ( std::shared_ptr< BackgroundSlicingProcess::UITask >  task )

staticprivate

{
  if (task) {
    std::unique_lock<std::mutex> lck(task->mutex);
    task->state = UITask::Canceled;
    lck.unlock();
    task->condition.notify_all();
  }
}

References Slic3r::BackgroundSlicingProcess::UITask::Canceled.

Referenced by stop(), and stop_internal().

Here is the caller graph for this function:

current_print()

const PrintBase * Slic3r::BackgroundSlicingProcess::current_print ( ) const

inline

{ return m_print; }

References m_print.

Referenced by prepare_upload(), and process_sla().

Here is the caller graph for this function:

current_printer_technology()

PrinterTechnology Slic3r::BackgroundSlicingProcess::current_printer_technology

(

)

const

{
  return m_print->technology();
}

References m_print, and Slic3r::PrintBase::technology().

Referenced by Slic3r::GUI::GLCanvas3D::current_printer_technology(), Slic3r::GUI::Preview::load_print(), Slic3r::GUI::Preview::load_print_as_fff(), Slic3r::GUI::Preview::load_print_as_sla(), and Slic3r::GUI::Preview::on_layers_slider_scroll_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

bool Slic3r::BackgroundSlicingProcess::empty

(

)

const

{
  assert(m_print != nullptr);
  return m_print->empty();
}

References Slic3r::PrintBase::empty(), and m_print.

Here is the call graph for this function:

execute_ui_task()

bool Slic3r::BackgroundSlicingProcess::execute_ui_task ( std::function< void()>  task )

private

{
  bool running = false;
  if (m_mutex.try_lock()) {
    // Cancellation is either not in process, or already canceled and waiting for us to finish.
    // There must be no UI task planned.
    assert(! m_ui_task);
    if (! m_print->canceled()) {
      running = true;
      m_ui_task = std::make_shared<UITask>();
    }
    m_mutex.unlock();
  } else {
    // Cancellation is in process.
  }
 
  bool result = false;
  if (running) {
    std::shared_ptr<UITask> ctx = m_ui_task;
    GUI::wxGetApp().mainframe->m_plater->CallAfter([task, ctx]() {
      // Running on the UI thread, thus ctx->state does not need to be guarded with mutex against ::cancel_ui_task().
      assert(ctx->state == UITask::Planned || ctx->state == UITask::Canceled);
      if (ctx->state == UITask::Planned) {
        task();
        std::unique_lock<std::mutex> lck(ctx->mutex);
          ctx->state = UITask::Finished;
        }
        // Wake up the worker thread from the UI thread.
        ctx->condition.notify_all();
      });
 
      {
      std::unique_lock<std::mutex> lock(ctx->mutex);
        ctx->condition.wait(lock, [&ctx]{ return ctx->state == UITask::Finished || ctx->state == UITask::Canceled; });
      }
      result = ctx->state == UITask::Finished;
    m_ui_task.reset();
  }
 
  return result;
}

References Slic3r::PrintBase::canceled(), Slic3r::BackgroundSlicingProcess::UITask::Canceled, Slic3r::BackgroundSlicingProcess::UITask::Finished, m_mutex, m_print, m_ui_task, Slic3r::BackgroundSlicingProcess::UITask::Planned, and running().

Referenced by render_thumbnails().

Here is the call graph for this function:

Here is the caller graph for this function:

fff_print()

const Print * Slic3r::BackgroundSlicingProcess::fff_print ( ) const

inline

{ return m_fff_print; }

References m_fff_print.

Referenced by Slic3r::GUI::Preview::load_print_as_fff(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the caller graph for this function:

finalize_gcode()

void Slic3r::BackgroundSlicingProcess::finalize_gcode ( )

private

{
  m_print->set_status(95, _u8L("Running post-processing scripts"));
 
  // Perform the final post-processing of the export path by applying the print statistics over the file name.
  std::string export_path = m_fff_print->print_statistics().finalize_output_path(m_export_path);
  std::string output_path = m_temp_output_path;
  // Both output_path and export_path ar in-out parameters.
  // If post processed, output_path will differ from m_temp_output_path as run_post_process_scripts() will make a copy of the G-code to not
  // collide with the G-code viewer memory mapping of the unprocessed G-code. G-code viewer maps unprocessed G-code, because m_gcode_result 
  // is calculated for the unprocessed G-code and it references lines in the memory mapped G-code file by line numbers.
  // export_path may be changed by the post-processing script as well if the post processing script decides so, see GH #6042.
  bool post_processed = run_post_process_scripts(output_path, true, "File", export_path, m_fff_print->full_print_config());
  auto remove_post_processed_temp_file = [post_processed, &output_path]() {
    if (post_processed)
      try {
        boost::filesystem::remove(output_path);
      } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << "Failed to remove temp file " << output_path << ": " << ex.what();
      }
  };
 
  //FIXME localize the messages
  std::string error_message;
  int copy_ret_val = CopyFileResult::SUCCESS;
  try
  {
    copy_ret_val = copy_file(output_path, export_path, error_message, m_export_path_on_removable_media);
    remove_post_processed_temp_file();
  }
  catch (...)
  {
    remove_post_processed_temp_file();
    throw Slic3r::ExportError(_u8L("Unknown error occured during exporting G-code."));
  }
  switch (copy_ret_val) {
  case CopyFileResult::SUCCESS: break; // no error
  case CopyFileResult::FAIL_COPY_FILE:
    throw Slic3r::ExportError(GUI::format(_L("Copying of the temporary G-code to the output G-code failed. Maybe the SD card is write locked?\nError message: %1%"), error_message));
    break;
  case CopyFileResult::FAIL_FILES_DIFFERENT:
    throw Slic3r::ExportError(GUI::format(_L("Copying of the temporary G-code to the output G-code failed. There might be problem with target device, please try exporting again or using different device. The corrupted output G-code is at %1%.tmp."), export_path));
    break;
  case CopyFileResult::FAIL_RENAMING:
    throw Slic3r::ExportError(GUI::format(_L("Renaming of the G-code after copying to the selected destination folder has failed. Current path is %1%.tmp. Please try exporting again."), export_path));
    break;
  case CopyFileResult::FAIL_CHECK_ORIGIN_NOT_OPENED:
    throw Slic3r::ExportError(GUI::format(_L("Copying of the temporary G-code has finished but the original code at %1% couldn't be opened during copy check. The output G-code is at %2%.tmp."), output_path, export_path));
    break;
  case CopyFileResult::FAIL_CHECK_TARGET_NOT_OPENED:
    throw Slic3r::ExportError(GUI::format(_L("Copying of the temporary G-code has finished but the exported code couldn't be opened during copy check. The output G-code is at %1%.tmp."), export_path));
    break;
  default:
    throw Slic3r::ExportError(_u8L("Unknown error occured during exporting G-code."));
    BOOST_LOG_TRIVIAL(error) << "Unexpected fail code(" << (int)copy_ret_val << ") durring copy_file() to " << export_path << ".";
    break;
  }
 
  m_print->set_status(100, GUI::format(_L("G-code file exported to %1%"), export_path));
}

References _L, _u8L, Slic3r::copy_file(), error, Slic3r::FAIL_CHECK_ORIGIN_NOT_OPENED, Slic3r::FAIL_CHECK_TARGET_NOT_OPENED, Slic3r::FAIL_COPY_FILE, Slic3r::FAIL_FILES_DIFFERENT, Slic3r::FAIL_RENAMING, Slic3r::PrintStatistics::finalize_output_path(), Slic3r::GUI::format(), Slic3r::PrintBase::full_print_config(), m_export_path, m_export_path_on_removable_media, m_fff_print, m_print, m_temp_output_path, Slic3r::Print::print_statistics(), Slic3r::run_post_process_scripts(), Slic3r::PrintBase::set_status(), and Slic3r::SUCCESS.

Referenced by process_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

finished()

bool Slic3r::BackgroundSlicingProcess::finished ( ) const

inline

{ return m_print->finished(); }

References Slic3r::PrintBase::finished(), and m_print.

Here is the call graph for this function:

idle()

bool Slic3r::BackgroundSlicingProcess::idle ( ) const

inline

{ return m_state == STATE_IDLE; }

References m_state, and STATE_IDLE.

Referenced by start().

Here is the caller graph for this function:

invalidate_all_steps()

bool Slic3r::BackgroundSlicingProcess::invalidate_all_steps ( )

private

{ 
  return m_step_state.invalidate_all([this](){ this->stop_internal(); });
}

References Slic3r::PrintState< StepType, COUNT >::invalidate_all(), m_step_state, and stop_internal().

Referenced by reset().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_step()

bool Slic3r::BackgroundSlicingProcess::invalidate_step ( BackgroundSlicingProcessStep  step )

private

{
    bool invalidated = m_step_state.invalidate(step, [this](){ this->stop_internal(); });
    return invalidated;
}

References Slic3r::PrintState< StepType, COUNT >::invalidate(), m_step_state, and stop_internal().

Referenced by reset_export(), schedule_export(), and schedule_upload().

Here is the call graph for this function:

Here is the caller graph for this function:

is_export_scheduled()

bool Slic3r::BackgroundSlicingProcess::is_export_scheduled ( ) const

inline

{ return ! m_export_path.empty(); }

References m_export_path.

is_step_done()

bool Slic3r::BackgroundSlicingProcess::is_step_done ( BackgroundSlicingProcessStep  step ) const

private

{ 
  return m_step_state.is_done(step, m_print->state_mutex());
}

References Slic3r::PrintState< StepType, COUNT >::is_done(), m_print, m_step_state, and Slic3r::PrintBase::state_mutex().

Here is the call graph for this function:

is_upload_scheduled()

bool Slic3r::BackgroundSlicingProcess::is_upload_scheduled ( ) const

inline

{ return ! m_upload_job.empty(); }

References Slic3r::PrintHostJob::empty(), and m_upload_job.

Here is the call graph for this function:

join_background_thread()

void Slic3r::BackgroundSlicingProcess::join_background_thread ( )

private

{
  std::unique_lock<std::mutex> lck(m_mutex);
  if (m_state == STATE_INITIAL) {
    // Worker thread has not been started yet.
    assert(! m_thread.joinable());
  } else {
    assert(m_state == STATE_IDLE);
    assert(m_thread.joinable());
    // Notify the worker thread to exit.
    m_state = STATE_EXIT;
    lck.unlock();
    m_condition.notify_one();
    // Wait until the worker thread exits.
    m_thread.join();
  }
}

References m_condition, m_mutex, m_state, m_thread, STATE_EXIT, STATE_IDLE, and STATE_INITIAL.

Referenced by ~BackgroundSlicingProcess().

Here is the caller graph for this function:

output_filepath_for_project()

std::string Slic3r::BackgroundSlicingProcess::output_filepath_for_project

(

const boost::filesystem::path &

project_path

)

{
  assert(m_print != nullptr);
    if (project_path.empty())
        return m_print->output_filepath("");
    return m_print->output_filepath(project_path.parent_path().string(), project_path.stem().string());
}

References m_print, and Slic3r::PrintBase::output_filepath().

Here is the call graph for this function:

prepare_upload()

void Slic3r::BackgroundSlicingProcess::prepare_upload ( )

private

{
  // Generate a unique temp path to which the gcode/zip file is copied/exported
  boost::filesystem::path source_path = boost::filesystem::temp_directory_path()
    / boost::filesystem::unique_path("." SLIC3R_APP_KEY ".upload.%%%%-%%%%-%%%%-%%%%");
 
  if (m_print == m_fff_print) {
    m_print->set_status(95, _u8L("Running post-processing scripts"));
    std::string error_message;
    if (copy_file(m_temp_output_path, source_path.string(), error_message) != SUCCESS)
      throw Slic3r::RuntimeError("Copying of the temporary G-code to the output G-code failed");
        m_upload_job.upload_data.upload_path = m_fff_print->print_statistics().finalize_output_path(m_upload_job.upload_data.upload_path.string());
        // Make a copy of the source path, as run_post_process_scripts() is allowed to change it when making a copy of the source file
        // (not here, but when the final target is a file). 
        std::string source_path_str = source_path.string();
        std::string output_name_str = m_upload_job.upload_data.upload_path.string();
    if (run_post_process_scripts(source_path_str, false, m_upload_job.printhost->get_name(), output_name_str, m_fff_print->full_print_config()))
      m_upload_job.upload_data.upload_path = output_name_str;
    } else {
        m_upload_job.upload_data.upload_path = m_sla_print->print_statistics().finalize_output_path(m_upload_job.upload_data.upload_path.string());
        
        ThumbnailsList thumbnails = this->render_thumbnails(
          ThumbnailsParams{current_print()->full_print_config().option<ConfigOptionPoints>("thumbnails")->values, true, true, true, true});
        m_sla_print->export_print(source_path.string(),thumbnails, m_upload_job.upload_data.upload_path.filename().string());
    }
 
    m_print->set_status(100, GUI::format(_L("Scheduling upload to `%1%`. See Window -> Print Host Upload Queue"), m_upload_job.printhost->get_host()));
 
  m_upload_job.upload_data.source_path = std::move(source_path);
 
  GUI::wxGetApp().printhost_job_queue().enqueue(std::move(m_upload_job));
}

References _L, _u8L, Slic3r::copy_file(), current_print(), Slic3r::SLAPrint::export_print(), Slic3r::PrintStatistics::finalize_output_path(), Slic3r::SLAPrintStatistics::finalize_output_path(), Slic3r::GUI::format(), Slic3r::PrintBase::full_print_config(), m_fff_print, m_print, m_sla_print, m_temp_output_path, m_upload_job, Slic3r::ConfigBase::option(), Slic3r::Print::print_statistics(), Slic3r::SLAPrint::print_statistics(), Slic3r::PrintHostJob::printhost, render_thumbnails(), Slic3r::run_post_process_scripts(), Slic3r::PrintBase::set_status(), Slic3r::PrintHostUpload::source_path, Slic3r::SUCCESS, Slic3r::PrintHostJob::upload_data, and Slic3r::PrintHostUpload::upload_path.

Referenced by process_fff(), and process_sla().

Here is the call graph for this function:

Here is the caller graph for this function:

process_fff()

void Slic3r::BackgroundSlicingProcess::process_fff ( )

private

{
  assert(m_print == m_fff_print);
  m_print->process();
  wxCommandEvent evt(m_event_slicing_completed_id);
  // Post the Slicing Finished message for the G-code viewer to update.
  // Passing the timestamp 
  evt.SetInt((int)(m_fff_print->step_state_with_timestamp(PrintStep::psSlicingFinished).timestamp));
  wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, evt.Clone());
  m_fff_print->export_gcode(m_temp_output_path, m_gcode_result, [this](const ThumbnailsParams& params) { return this->render_thumbnails(params); });
  if (this->set_step_started(bspsGCodeFinalize)) {
      if (! m_export_path.empty()) {
      wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, new wxCommandEvent(m_event_export_began_id));
      finalize_gcode();
      } else if (! m_upload_job.empty()) {
      wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, new wxCommandEvent(m_event_export_began_id));
      prepare_upload();
      } else {
      m_print->set_status(100, _u8L("Slicing complete"));
      }
    this->set_step_done(bspsGCodeFinalize);
  }
}

References _u8L, Slic3r::bspsGCodeFinalize, Slic3r::PrintHostJob::empty(), Slic3r::Print::export_gcode(), finalize_gcode(), m_event_export_began_id, m_event_slicing_completed_id, m_export_path, m_fff_print, m_gcode_result, m_print, m_temp_output_path, m_upload_job, prepare_upload(), Slic3r::PrintBase::process(), Slic3r::psSlicingFinished, render_thumbnails(), Slic3r::PrintBase::set_status(), set_step_done(), set_step_started(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_timestamp(), and Slic3r::PrintStateBase::StateWithTimeStamp::timestamp.

Here is the call graph for this function:

process_sla()

void Slic3r::BackgroundSlicingProcess::process_sla ( )

private

{
    assert(m_print == m_sla_print);
    m_print->process();
    if (this->set_step_started(bspsGCodeFinalize)) {
        if (! m_export_path.empty()) {
      wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, new wxCommandEvent(m_event_export_began_id));
 
            const std::string export_path = m_sla_print->print_statistics().finalize_output_path(m_export_path);
 
            ThumbnailsList thumbnails = this->render_thumbnails(
              ThumbnailsParams{current_print()->full_print_config().option<ConfigOptionPoints>("thumbnails")->values, true, true, true, true});
 
            m_sla_print->export_print(export_path, thumbnails);
 
            m_print->set_status(100, GUI::format(_L("Masked SLA file exported to %1%"), export_path));
        } else if (! m_upload_job.empty()) {
      wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, new wxCommandEvent(m_event_export_began_id));
            prepare_upload();
        } else {
      m_print->set_status(100, _u8L("Slicing complete"));
        }
        this->set_step_done(bspsGCodeFinalize);
    }
}

References _L, _u8L, Slic3r::bspsGCodeFinalize, current_print(), Slic3r::PrintHostJob::empty(), Slic3r::SLAPrint::export_print(), Slic3r::SLAPrintStatistics::finalize_output_path(), Slic3r::GUI::format(), Slic3r::PrintBase::full_print_config(), m_event_export_began_id, m_export_path, m_print, m_sla_print, m_upload_job, Slic3r::ConfigBase::option(), prepare_upload(), Slic3r::SLAPrint::print_statistics(), Slic3r::PrintBase::process(), render_thumbnails(), Slic3r::PrintBase::set_status(), set_step_done(), and set_step_started().

Here is the call graph for this function:

render_thumbnails()

ThumbnailsList Slic3r::BackgroundSlicingProcess::render_thumbnails ( const ThumbnailsParams &  params )

private

{
  ThumbnailsList thumbnails;
  if (m_thumbnail_cb)
    this->execute_ui_task([this, &params, &thumbnails](){ thumbnails = m_thumbnail_cb(params); });
  return thumbnails;
}

References execute_ui_task(), and m_thumbnail_cb.

Referenced by prepare_upload(), process_fff(), and process_sla().

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

bool Slic3r::BackgroundSlicingProcess::reset

(

)

{
  bool stopped = this->stop();
  this->reset_export();
  m_print->clear();
  this->invalidate_all_steps();
  return stopped;
}

References Slic3r::PrintBase::clear(), invalidate_all_steps(), m_print, reset_export(), and stop().

Referenced by select_technology().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_export()

void Slic3r::BackgroundSlicingProcess::reset_export

(

)

{
  assert(! this->running());
  if (! this->running()) {
    m_export_path.clear();
    m_export_path_on_removable_media = false;
    // invalidate_step expects the mutex to be locked.
    std::scoped_lock<std::mutex> lock(m_print->state_mutex());
    this->invalidate_step(bspsGCodeFinalize);
  }
}

References Slic3r::bspsGCodeFinalize, invalidate_step(), m_export_path, m_export_path_on_removable_media, m_print, running(), and Slic3r::PrintBase::state_mutex().

Referenced by reset().

Here is the call graph for this function:

Here is the caller graph for this function:

running()

bool Slic3r::BackgroundSlicingProcess::running ( ) const

inline

{ return m_state == STATE_STARTED || m_state == STATE_RUNNING || m_state == STATE_FINISHED || m_state == STATE_CANCELED; }

References m_state, STATE_CANCELED, STATE_FINISHED, STATE_RUNNING, and STATE_STARTED.

Referenced by execute_ui_task(), reset_export(), and start().

Here is the caller graph for this function:

schedule_export()

void Slic3r::BackgroundSlicingProcess::schedule_export	(	const std::string &	path,
		bool	export_path_on_removable_media
	)

{ 
  assert(m_export_path.empty());
  if (! m_export_path.empty())
    return;
 
  // Guard against entering the export step before changing the export path.
  std::scoped_lock<std::mutex> lock(m_print->state_mutex());
  this->invalidate_step(bspsGCodeFinalize);
  m_export_path = path;
  m_export_path_on_removable_media = export_path_on_removable_media;
}

References Slic3r::bspsGCodeFinalize, invalidate_step(), m_export_path, m_export_path_on_removable_media, m_print, and Slic3r::PrintBase::state_mutex().

Here is the call graph for this function:

schedule_upload()

void Slic3r::BackgroundSlicingProcess::schedule_upload

(

Slic3r::PrintHostJob

upload_job

)

{
  assert(m_export_path.empty());
  if (! m_export_path.empty())
    return;
 
  // Guard against entering the export step before changing the export path.
  std::scoped_lock<std::mutex> lock(m_print->state_mutex());
  this->invalidate_step(bspsGCodeFinalize);
  m_export_path.clear();
  m_upload_job = std::move(upload_job);
}

References Slic3r::bspsGCodeFinalize, invalidate_step(), m_export_path, m_print, m_upload_job, and Slic3r::PrintBase::state_mutex().

Here is the call graph for this function:

select_technology()

bool Slic3r::BackgroundSlicingProcess::select_technology

(

PrinterTechnology

tech

)

{
  bool changed = false;
  if (m_print == nullptr || m_print->technology() != tech) {
    if (m_print != nullptr)
      this->reset();
    switch (tech) {
    case ptFFF: m_print = m_fff_print; break;
    case ptSLA: m_print = m_sla_print; break;
        default: assert(false); break;
    }
    changed = true;
  }
  assert(m_print != nullptr);
  return changed;
}

References m_fff_print, m_print, m_sla_print, Slic3r::ptFFF, Slic3r::ptSLA, reset(), and Slic3r::PrintBase::technology().

Here is the call graph for this function:

set_export_began_event()

void Slic3r::BackgroundSlicingProcess::set_export_began_event ( int  event_id )

inline

{ m_event_export_began_id = event_id; }

References m_event_export_began_id.

set_fff_print()

void Slic3r::BackgroundSlicingProcess::set_fff_print ( Print *  print )

inline

{ m_fff_print = print; }

References m_fff_print.

set_finished_event()

void Slic3r::BackgroundSlicingProcess::set_finished_event ( int  event_id )

inline

{ m_event_finished_id = event_id; }

References m_event_finished_id.

set_gcode_result()

void Slic3r::BackgroundSlicingProcess::set_gcode_result ( GCodeProcessorResult *  result )

inline

{ m_gcode_result = result; }

References m_gcode_result.

set_sla_print()

void Slic3r::BackgroundSlicingProcess::set_sla_print ( SLAPrint *  print )

inline

{ m_sla_print = print; }

References m_sla_print.

set_slicing_completed_event()

void Slic3r::BackgroundSlicingProcess::set_slicing_completed_event ( int  event_id )

inline

{ m_event_slicing_completed_id = event_id; }

References m_event_slicing_completed_id.

set_step_done()

void Slic3r::BackgroundSlicingProcess::set_step_done ( BackgroundSlicingProcessStep  step )

private

{ 
  m_step_state.set_done(step, m_print->state_mutex(), [this](){ this->throw_if_canceled(); });
}

References m_print, m_step_state, Slic3r::PrintState< StepType, COUNT >::set_done(), and Slic3r::PrintBase::state_mutex().

Referenced by process_fff(), and process_sla().

Here is the call graph for this function:

Here is the caller graph for this function:

set_step_started()

bool Slic3r::BackgroundSlicingProcess::set_step_started ( BackgroundSlicingProcessStep  step )

private

{ 
  return m_step_state.set_started(step, m_print->state_mutex(), [this](){ this->throw_if_canceled(); });
}

References m_print, m_step_state, Slic3r::PrintState< StepType, COUNT >::set_started(), and Slic3r::PrintBase::state_mutex().

Referenced by process_fff(), and process_sla().

Here is the call graph for this function:

Here is the caller graph for this function:

set_task()

void Slic3r::BackgroundSlicingProcess::set_task

(

const PrintBase::TaskParams &

params

)

{
  assert(m_print != nullptr);
  m_print->set_task(params);
}

References m_print, and Slic3r::PrintBase::set_task().

Here is the call graph for this function:

set_thumbnail_cb()

void Slic3r::BackgroundSlicingProcess::set_thumbnail_cb ( ThumbnailsGeneratorCallback  cb )

inline

{ m_thumbnail_cb = cb; }

References m_thumbnail_cb.

sla_print()

const SLAPrint * Slic3r::BackgroundSlicingProcess::sla_print ( ) const

inline

{ return m_sla_print; }

References m_sla_print.

Referenced by Slic3r::GUI::Preview::load_print_as_sla().

Here is the caller graph for this function:

start()

bool Slic3r::BackgroundSlicingProcess::start

(

)

{
  if (m_print->empty())
    // The print is empty (no object in Model, or all objects are out of the print bed).
    return false;
 
  std::unique_lock<std::mutex> lck(m_mutex);
  if (m_state == STATE_INITIAL) {
    // The worker thread is not running yet. Start it.
    assert(! m_thread.joinable());
    m_thread = create_thread([this]{
#ifdef _WIN32
      this->thread_proc_safe_seh_throw();
#else // _WIN32
      this->thread_proc_safe();
#endif // _WIN32
    });
    // Wait until the worker thread is ready to execute the background processing task.
    m_condition.wait(lck, [this](){ return m_state == STATE_IDLE; });
  }
  assert(m_state == STATE_IDLE || this->running());
  if (this->running())
    // The background processing thread is already running.
    return false;
  if (! this->idle())
    throw Slic3r::RuntimeError("Cannot start a background task, the worker thread is not idle.");
  m_state = STATE_STARTED;
  m_print->set_cancel_callback([this](){ this->stop_internal(); });
  lck.unlock();
  m_condition.notify_one();
  return true;
}

References Slic3r::create_thread(), Slic3r::PrintBase::empty(), idle(), m_condition, m_mutex, m_print, m_state, m_thread, running(), Slic3r::PrintBase::set_cancel_callback(), STATE_IDLE, STATE_INITIAL, STATE_STARTED, stop_internal(), and thread_proc_safe().

Here is the call graph for this function:

state()

State Slic3r::BackgroundSlicingProcess::state ( ) const

inline

{ return m_state; }

References m_state.

stop()

bool Slic3r::BackgroundSlicingProcess::stop

(

)

{
  // m_print->state_mutex() shall NOT be held. Unfortunately there is no interface to test for it.
  std::unique_lock<std::mutex> lck(m_mutex);
  if (m_state == STATE_INITIAL) {
//    m_export_path.clear();
    return false;
  }
//  assert(this->running());
  if (m_state == STATE_STARTED || m_state == STATE_RUNNING) {
    // Cancel any task planned by the background thread on UI thread.
    cancel_ui_task(m_ui_task);
    m_print->cancel();
    // Wait until the background processing stops by being canceled.
    m_condition.wait(lck, [this](){ return m_state == STATE_CANCELED; });
    // In the "Canceled" state. Reset the state to "Idle".
    m_state = STATE_IDLE;
    m_print->set_cancel_callback([](){});
  } else if (m_state == STATE_FINISHED || m_state == STATE_CANCELED) {
    // In the "Finished" or "Canceled" state. Reset the state to "Idle".
    m_state = STATE_IDLE;
    m_print->set_cancel_callback([](){});
  }
//  m_export_path.clear();
  return true;
}

References Slic3r::PrintBase::cancel(), cancel_ui_task(), m_condition, m_mutex, m_print, m_state, m_ui_task, Slic3r::PrintBase::set_cancel_callback(), STATE_CANCELED, STATE_FINISHED, STATE_IDLE, STATE_INITIAL, STATE_RUNNING, and STATE_STARTED.

Referenced by ~BackgroundSlicingProcess(), and reset().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_internal()

void Slic3r::BackgroundSlicingProcess::stop_internal ( )

private

{
  // m_print->state_mutex() shall be held. Unfortunately there is no interface to test for it.
  if (m_state == STATE_IDLE)
    // The worker thread is waiting on m_mutex/m_condition for wake up. The following lock of the mutex would block.
    return;
  std::unique_lock<std::mutex> lck(m_mutex);
  assert(m_state == STATE_STARTED || m_state == STATE_RUNNING || m_state == STATE_FINISHED || m_state == STATE_CANCELED);
  if (m_state == STATE_STARTED || m_state == STATE_RUNNING) {
    // Cancel any task planned by the background thread on UI thread.
    cancel_ui_task(m_ui_task);
    // At this point of time the worker thread may be blocking on m_print->state_mutex().
    // Set the print state to canceled before unlocking the state_mutex(), so when the worker thread wakes up,
    // it throws the CanceledException().
    m_print->cancel_internal();
    // Allow the worker thread to wake up if blocking on a milestone.
    m_print->state_mutex().unlock();
    // Wait until the background processing stops by being canceled.
    m_condition.wait(lck, [this](){ return m_state == STATE_CANCELED; });
    // Lock it back to be in a consistent state.
    m_print->state_mutex().lock();
  }
  // In the "Canceled" state. Reset the state to "Idle".
  m_state = STATE_IDLE;
  m_print->set_cancel_callback([](){});
}

References Slic3r::PrintBase::cancel_internal(), cancel_ui_task(), m_condition, m_mutex, m_print, m_state, m_ui_task, Slic3r::PrintBase::set_cancel_callback(), STATE_CANCELED, STATE_FINISHED, STATE_IDLE, Slic3r::PrintBase::state_mutex(), STATE_RUNNING, and STATE_STARTED.

Referenced by invalidate_all_steps(), invalidate_step(), and start().

Here is the call graph for this function:

Here is the caller graph for this function:

thread_proc()

void Slic3r::BackgroundSlicingProcess::thread_proc ( )

private

{
  set_current_thread_name("slic3r_BgSlcPcs");
    name_tbb_thread_pool_threads_set_locale();
 
    // Set "C" locales and enforce OSX QoS level on all threads entering an arena.
    // The cost of the callback is quite low: The callback is called once per thread
    // entering a parallel loop and the callback is guarded with a thread local
    // variable to be executed just once.
  TBBLocalesSetter setter;
 
  assert(m_print != nullptr);
  assert(m_print == m_fff_print || m_print == m_sla_print);
  std::unique_lock<std::mutex> lck(m_mutex);
  // Let the caller know we are ready to run the background processing task.
  m_state = STATE_IDLE;
  lck.unlock();
  m_condition.notify_one();
  for (;;) {
    assert(m_state == STATE_IDLE || m_state == STATE_CANCELED || m_state == STATE_FINISHED);
    // Wait until a new task is ready to be executed, or this thread should be finished.
    lck.lock();
    m_condition.wait(lck, [this](){ return m_state == STATE_STARTED || m_state == STATE_EXIT; });
    if (m_state == STATE_EXIT)
      // Exiting this thread.
      break;
    // Process the background slicing task.
    m_state = STATE_RUNNING;
    lck.unlock();
    std::exception_ptr exception;
#ifdef _WIN32
    this->call_process_seh_throw(exception);
#else
    this->call_process(exception);
#endif
    m_print->finalize();
    lck.lock();
    m_state = m_print->canceled() ? STATE_CANCELED : STATE_FINISHED;
    if (m_print->cancel_status() != Print::CANCELED_INTERNAL) {
      // Only post the canceled event, if canceled by user.
      // Don't post the canceled event, if canceled from Print::apply().
      SlicingProcessCompletedEvent evt(m_event_finished_id, 0, 
        (m_state == STATE_CANCELED) ? SlicingProcessCompletedEvent::Cancelled :
        exception ? SlicingProcessCompletedEvent::Error : SlicingProcessCompletedEvent::Finished, exception);
          wxQueueEvent(GUI::wxGetApp().mainframe->m_plater, evt.Clone());
          // Cancelled by the user, not internally, thus cleanup() was not called yet.
          // Otherwise cleanup() is called from Print::apply()
          m_print->cleanup();
        }
      m_print->restart();
    lck.unlock();
    // Let the UI thread wake up if it is waiting for the background task to finish.
      m_condition.notify_one();
      // Let the UI thread see the result.
  }
  m_state = STATE_EXITED;
  lck.unlock();
  // End of the background processing thread. The UI thread should join m_thread now.
}

References call_process(), Slic3r::PrintBase::cancel_status(), Slic3r::PrintBase::canceled(), Slic3r::PrintBase::CANCELED_INTERNAL, Slic3r::SlicingProcessCompletedEvent::Cancelled, Slic3r::PrintBase::cleanup(), Slic3r::SlicingProcessCompletedEvent::Clone(), Slic3r::SlicingProcessCompletedEvent::Error, Slic3r::PrintBase::finalize(), Slic3r::SlicingProcessCompletedEvent::Finished, m_condition, m_event_finished_id, m_fff_print, m_mutex, m_print, m_sla_print, m_state, Slic3r::name_tbb_thread_pool_threads_set_locale(), Slic3r::PrintBase::restart(), Slic3r::set_current_thread_name(), STATE_CANCELED, STATE_EXIT, STATE_EXITED, STATE_FINISHED, STATE_IDLE, STATE_RUNNING, and STATE_STARTED.

Referenced by thread_proc_safe().

Here is the call graph for this function:

Here is the caller graph for this function:

thread_proc_safe()

void Slic3r::BackgroundSlicingProcess::thread_proc_safe ( ) throw ( )

private

{
  try {
    this->thread_proc();
  } catch (...) {
    wxTheApp->OnUnhandledException();
    }
}

References thread_proc().

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

throw_if_canceled()

void Slic3r::BackgroundSlicingProcess::throw_if_canceled ( ) const

inlineprivate

{ if (m_print->canceled()) throw CanceledException(); }

References Slic3r::PrintBase::canceled(), and m_print.

Here is the call graph for this function:

validate()

std::string Slic3r::BackgroundSlicingProcess::validate

(

std::vector< std::string > *

warnings = nullptr

)

{
  assert(m_print != nullptr);
    return m_print->validate(warnings);
}

References m_print, and Slic3r::PrintBase::validate().

Here is the call graph for this function:

Member Data Documentation

m_condition

std::condition_variable Slic3r::BackgroundSlicingProcess::m_condition

private

Referenced by join_background_thread(), start(), stop(), stop_internal(), and thread_proc().

m_event_export_began_id

int Slic3r::BackgroundSlicingProcess::m_event_export_began_id = 0

private

Referenced by process_fff(), process_sla(), and set_export_began_event().

m_event_finished_id

int Slic3r::BackgroundSlicingProcess::m_event_finished_id = 0

private

Referenced by set_finished_event(), and thread_proc().

m_event_slicing_completed_id

int Slic3r::BackgroundSlicingProcess::m_event_slicing_completed_id = 0

private

Referenced by process_fff(), and set_slicing_completed_event().

m_export_path

std::string Slic3r::BackgroundSlicingProcess::m_export_path

private

Referenced by finalize_gcode(), is_export_scheduled(), process_fff(), process_sla(), reset_export(), schedule_export(), and schedule_upload().

m_export_path_on_removable_media

bool Slic3r::BackgroundSlicingProcess::m_export_path_on_removable_media = false

private

Referenced by finalize_gcode(), reset_export(), and schedule_export().

m_fff_print

Print* Slic3r::BackgroundSlicingProcess::m_fff_print = nullptr

private

Referenced by apply(), fff_print(), finalize_gcode(), prepare_upload(), process_fff(), select_technology(), set_fff_print(), and thread_proc().

m_gcode_result

GCodeProcessorResult* Slic3r::BackgroundSlicingProcess::m_gcode_result = nullptr

private

Referenced by apply(), process_fff(), and set_gcode_result().

m_mutex

std::mutex Slic3r::BackgroundSlicingProcess::m_mutex

private

Referenced by execute_ui_task(), join_background_thread(), start(), stop(), stop_internal(), and thread_proc().

m_print

PrintBase* Slic3r::BackgroundSlicingProcess::m_print = nullptr

private

Referenced by apply(), current_print(), current_printer_technology(), empty(), execute_ui_task(), finalize_gcode(), finished(), is_step_done(), output_filepath_for_project(), prepare_upload(), process_fff(), process_sla(), reset(), reset_export(), schedule_export(), schedule_upload(), select_technology(), set_step_done(), set_step_started(), set_task(), start(), stop(), stop_internal(), thread_proc(), throw_if_canceled(), and validate().

m_sla_print

SLAPrint* Slic3r::BackgroundSlicingProcess::m_sla_print = nullptr

private

Referenced by prepare_upload(), process_sla(), select_technology(), set_sla_print(), sla_print(), and thread_proc().

m_state

State Slic3r::BackgroundSlicingProcess::m_state = STATE_INITIAL

private

Referenced by idle(), join_background_thread(), running(), start(), state(), stop(), stop_internal(), and thread_proc().

m_step_state

PrintState<BackgroundSlicingProcessStep, bspsCount> Slic3r::BackgroundSlicingProcess::m_step_state

private

Referenced by invalidate_all_steps(), invalidate_step(), is_step_done(), set_step_done(), and set_step_started().

m_temp_output_path

std::string Slic3r::BackgroundSlicingProcess::m_temp_output_path

private

Referenced by BackgroundSlicingProcess(), ~BackgroundSlicingProcess(), finalize_gcode(), prepare_upload(), and process_fff().

m_thread

boost::thread Slic3r::BackgroundSlicingProcess::m_thread

private

Referenced by join_background_thread(), and start().

m_thumbnail_cb

ThumbnailsGeneratorCallback Slic3r::BackgroundSlicingProcess::m_thumbnail_cb = nullptr

private

Referenced by render_thumbnails(), and set_thumbnail_cb().

m_ui_task

std::shared_ptr<UITask> Slic3r::BackgroundSlicingProcess::m_ui_task

private

Referenced by execute_ui_task(), stop(), and stop_internal().

m_upload_job

PrintHostJob Slic3r::BackgroundSlicingProcess::m_upload_job

private

Referenced by is_upload_scheduled(), prepare_upload(), process_fff(), process_sla(), and schedule_upload().

---

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

• src/slic3r/GUI/BackgroundSlicingProcess.hpp
• src/slic3r/GUI/BackgroundSlicingProcess.cpp