Slic3r::GUI::PartPlate Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PartPlate.hpp>

Inheritance diagram for Slic3r::GUI::PartPlate:

Collaboration diagram for Slic3r::GUI::PartPlate:

Public Types
enum	HeightLimitMode { HEIGHT_LIMIT_NONE , HEIGHT_LIMIT_BOTTOM , HEIGHT_LIMIT_TOP , HEIGHT_LIMIT_BOTH }
enum class	ImexPlacementViolation { None , Object , PrimeTower }
using	Timestamp = uint64_t

Public Member Functions
	PartPlate ()
	PartPlate (PartPlateList *partplate_list, Vec3d origin, int width, int depth, double height, Plater *platerObj, Model *modelObj, bool printable=true, PrinterTechnology tech=ptFFF)
	~PartPlate ()
bool	operator< (PartPlate &) const
void	clear (bool clear_sliced_result=true)
BedType	get_bed_type (bool load_from_project=false) const
void	set_bed_type (BedType bed_type)
void	reset_bed_type ()
void	reset_skirt_start_angle ()
DynamicPrintConfig *	config ()
void	set_print_seq (PrintSequence print_seq=PrintSequence::ByDefault)
PrintSequence	get_print_seq () const
PrintSequence	get_real_print_seq (bool *plate_same_as_global=nullptr) const
std::vector< int >	get_real_filament_maps (const DynamicConfig &g_config, bool *use_global_param=nullptr) const
std::vector< int >	get_real_filament_volume_maps (const DynamicConfig &g_config, bool *use_global_param=nullptr) const
FilamentMapMode	get_real_filament_map_mode (const DynamicConfig &g_config, bool *use_global_param=nullptr) const
FilamentMapMode	get_filament_map_mode () const
void	set_filament_map_mode (const FilamentMapMode &mode)
std::vector< int >	get_filament_maps () const
void	set_filament_maps (const std::vector< int > &f_maps)
std::vector< int >	get_filament_volume_maps () const
void	set_filament_volume_maps (const std::vector< int > &f_maps)
void	clear_filament_volume_map ()
std::vector< int >	get_filament_nozzle_maps () const
void	set_filament_nozzle_maps (const std::vector< int > &f_maps)
void	clear_filament_map ()
void	clear_filament_map_mode ()
bool	has_spiral_mode_config () const
bool	get_spiral_vase_mode () const
void	set_spiral_vase_mode (bool spiral_mode, bool as_global)
std::string	get_imex_mode () const
std::string	get_effective_imex_mode () const
void	set_imex_mode (const std::string &mode)
void	reset_imex_mode ()
std::map< int, int >	get_imex_head_filament_map () const
void	set_imex_head_filament_map (const std::map< int, int > &m)
void	reset_imex_head_filament_map ()
ColorRGBA	get_imex_head_filament_color (int physical_head) const
ColorRGBA	get_imex_head_filament_color (int physical_head, const ConfigOptionInts &pem, const std::map< int, int > &plate_map) const
const std::vector< std::unique_ptr< GLVolume > > &	get_imex_ghost_volumes () const
void	update_imex_ghost_transforms (const std::function< std::optional< Transform3d >(int, int)> &primary_live_xf={})
void	update_imex_ghost_colors ()
void	invalidate_imex_ghosts ()
std::vector< Vec2d >	get_plate_wrapping_detection_area () const
void	set_index (int index)
int	get_index ()
std::string	get_plate_name () const
void	generate_plate_name_texture ()
void	set_plate_name (const std::string &name)
void	set_timelapse_warning_code (int code)
int	timelapse_warning_code ()
void	get_print (PrintBase **print, GCodeResult **result, int *index)
void	set_print (PrintBase *print, GCodeResult *result=nullptr, int index=-1)
std::string	get_gcode_filename ()
bool	is_valid_gcode_file ()
Vec3d	get_center_origin ()
void	set_pos_and_size (Vec3d &origin, int width, int depth, double height, bool with_instance_move, bool do_clear=true)
Vec2d	get_size () const
ModelObjectPtrs	get_objects ()
ModelObjectPtrs	get_objects_on_this_plate ()
ModelInstance *	get_instance (int obj_id, int instance_id)
BoundingBoxf3	get_objects_bounding_box ()
Vec3d	get_origin ()
WipeTowerFootprint	estimate_wipe_tower_footprint (const DynamicPrintConfig &config, int plate_extruder_size=0, bool use_global_objects=false) const
arrangement::ArrangePolygon	estimate_wipe_tower_polygon (const DynamicPrintConfig &config, int plate_index, Vec3d &wt_pos, Vec3d &wt_size, int plate_extruder_size=0, bool use_global_objects=false, WipeTowerRelocation *relocation=nullptr) const
bool	check_objects_empty_and_gcode3mf (std::vector< int > &result) const
std::vector< int >	get_extruders (bool conside_custom_gcode=false, bool expand_mixed_slots=true) const
std::vector< int >	get_extruders (bool conside_custom_gcode, const DynamicPrintConfig &glb_config, const DynamicPrintConfig &project_config, bool expand_mixed_slots=true) const
std::vector< int >	get_extruders_under_cli (bool conside_custom_gcode, DynamicPrintConfig &full_config, bool expand_mixed_slots=true) const
std::vector< int >	get_extruders_without_support (bool conside_custom_gcode=false) const
std::vector< int >	get_used_filaments ()
const std::vector< FilamentInfo > &	get_slice_filaments_info () const
int	get_physical_extruder_by_filament_id (const DynamicConfig &g_config, int idx) const
int	get_logical_extruder_by_filament_id (const DynamicConfig &g_config, int idx) const
std::vector< int >	get_effective_exclusion_filament_maps (const DynamicConfig &g_config, size_t filament_count, size_t extruder_count) const
std::map< int, size_t >	get_object_filament_extruders (const ModelObject &object, const DynamicConfig &g_config, size_t extruder_count) const
bool	check_filament_printable (const DynamicPrintConfig &config, wxString &error_message)
bool	check_tpu_printable_status (const DynamicPrintConfig &config, const std::vector< int > &tpu_filaments)
bool	check_mixture_of_pla_and_petg (const DynamicPrintConfig &config)
bool	check_single_extruder_mixed_filament_risk (const DynamicPrintConfig &config, std::string &warning_text) const
bool	check_mixture_filament_compatible (const DynamicPrintConfig &config, std::string &error_msg)
bool	check_compatible_of_nozzle_and_filament (const DynamicPrintConfig &config, const std::vector< std::string > &filament_presets, std::string &error_msg)
bool	contain_instance (int obj_id, int instance_id)
bool	contain_instance_totally (ModelObject *object, int instance_id) const
bool	contain_instance_totally (int obj_id, int instance_id) const
bool	contain_any_instance_totally (int obj_id) const
bool	is_left_top_of (int obj_id, int instance_id)
bool	check_outside (int obj_id, int instance_id, BoundingBoxf3 *bounding_box=nullptr)
void	clear_exclusion_volume_intersections ()
void	invalidate_exclusion_volume_preview ()
bool	intersect_instance (int obj_id, int instance_id, BoundingBoxf3 *bounding_box=nullptr)
int	add_instance (int obj_id, int instance_id, bool move_position, BoundingBoxf3 *bounding_box=nullptr)
int	remove_instance (int obj_id, int instance_id)
void	translate_all_instance (Vec3d position)
void	duplicate_all_instance (unsigned int dup_count, bool need_skip, std::map< int, bool > &skip_objects)
void	update_instance_exclude_status (int obj_id, int instance_id, BoundingBoxf3 *bounding_box=nullptr)
void	update_object_index (int obj_idx_removed, int obj_idx_max)
void	set_vase_mode_related_object_config (int obj_id=-1)
bool	empty ()
int	printable_instance_size ()
bool	has_printable_instances ()
bool	is_all_instances_unprintable ()
void	move_instances_to (PartPlate &left_plate, PartPlate &right_plate, BoundingBoxf3 *bounding_box=nullptr)
const Pointfs &	get_shape () const
bool	set_shape (const Pointfs &shape, const Pointfs &exclude_areas, const std::vector< Pointfs > &extruder_areas, const std::vector< double > &extruder_heights, Vec2d position, float height_to_lid, float height_to_rod)
const std::vector< Pointfs > &	get_extruder_areas () const
const std::vector< double > &	get_extruder_heights () const
bool	contains (const Vec3d &point) const
bool	contains (const GLVolume &v) const
bool	contains (const BoundingBoxf3 &bb) const
bool	intersects (const BoundingBoxf3 &bb) const
bool	belt_open_y () const
void	open_belt_y (BoundingBoxf3 &box) const
void	render (const Transform3d &view_matrix, const Transform3d &projection_matrix, bool bottom, bool only_body=false, bool force_background_color=false, HeightLimitMode mode=HEIGHT_LIMIT_NONE, int hover_id=-1, bool render_cali=false, bool show_grid=true, bool hide_chrome=false)
void	set_selected ()
void	set_unselected ()
void	set_hover_id (int id)
const BoundingBoxf3 &	get_bounding_box (bool extended=false)
const BoundingBox	get_bounding_box_crd ()
BoundingBoxf3	get_plate_box ()
BoundingBoxf3	get_build_volume (bool use_share=false)
Polygon	get_shared_printable_polygon () const
const std::vector< BoundingBoxf3 > &	get_exclude_areas ()
void	update_states ()
bool	is_locked () const
void	lock (bool state)
bool	is_printable () const
bool	can_slice () const
ImexPlacementViolation	imex_placement_violation ()
bool	imex_hull_violates (const Polygon &hull) const
Polygon	imex_wipe_tower_hull () const
bool	has_imex_multimaterial_conflict () const
std::optional< BoundingBoxf >	imex_primary_zone ()
const std::vector< BoundingBoxf3 > &	imex_collision_zones () const
void	update_slice_ready_status (bool ready_slice)
bool	is_apply_result_invalid () const
void	update_apply_result_invalid (bool invalid)
bool	is_slice_result_valid () const
bool	is_slice_result_ready_for_print () const
bool	is_slice_result_ready_for_export ()
void	update_slice_result_valid_state (bool valid=false)
void	update_slicing_percent (float percent)
float	get_slicing_percent ()
void	update_slice_context (BackgroundSlicingProcess &process)
Print *	fff_print ()
GCodeProcessorResult *	get_slice_result ()
std::string	get_tmp_gcode_path ()
std::string	get_temp_config_3mf_path ()
void	set_tmp_gcode_path (std::string new_path)
int	load_gcode_from_file (const std::string &filename)
int	load_thumbnail_data (std::string filename, ThumbnailData &thumb_data)
int	load_pattern_thumbnail_data (std::string filename)
int	load_pattern_box_data (std::string filename)
std::vector< int >	get_first_layer_print_sequence () const
std::vector< LayerPrintSequence >	get_other_layers_print_sequence () const
void	set_first_layer_print_sequence (const std::vector< int > &sorted_filaments)
void	set_other_layers_print_sequence (const std::vector< LayerPrintSequence > &layer_seq_list)
void	update_first_layer_print_sequence (size_t filament_nums)
void	update_first_layer_print_sequence_when_delete_filament (size_t filamen_id)
void	print () const
void	on_extruder_count_changed (int extruder_count)
void	set_filament_count (int filament_count)
void	on_filament_added ()
void	on_filament_deleted (int filament_count, int filament_id)
template<class Archive>
void	load (Archive &ar)
template<class Archive>
void	save (Archive &ar) const
ObjectID	id () const
virtual Timestamp	timestamp () const

Static Public Member Functions
static bool	is_imex_ghost_composite_id (int object_id)
static int	imex_ghost_head_from_composite_id (int object_id)
static int	imex_ghost_composite_id_for_head (int physical_head)
static void	update_render_colors ()
static void	load_render_colors ()

Public Attributes
ThumbnailData	thumbnail_data
ThumbnailData	no_light_thumbnail_data
ThumbnailData	obj_preview_thumbnail_data
ThumbnailData	top_thumbnail_data
ThumbnailData	pick_thumbnail_data
PlateBBoxData	cali_bboxes_data

Static Public Attributes
static constexpr unsigned int	PLATE_NAME_HOVER_ID = 6
static constexpr unsigned int	PLATE_FILAMENT_MAP_ID = 8
static constexpr unsigned int	PLATE_IMEX_MODE_ID = 9
static constexpr unsigned int	GRABBER_COUNT = 10
static constexpr int	IMEX_GHOST_COMPOSITE_ID_BASE = -100000
static constexpr int	IMEX_GHOST_MAX_HEADS = 256
static ColorRGBA	SELECT_COLOR = { 0.2666f, 0.2784f, 0.2784f, 1.0f }
static ColorRGBA	UNSELECT_COLOR = { 0.82f, 0.82f, 0.82f, 1.0f }
static ColorRGBA	UNSELECT_DARK_COLOR = { 0.384f, 0.384f, 0.412f, 1.0f }
static ColorRGBA	DEFAULT_COLOR = { 0.5f, 0.5f, 0.5f, 1.0f }
static ColorRGBA	LINE_BOTTOM_COLOR = { 0.8f, 0.8f, 0.8f, 0.4f }
static ColorRGBA	LINE_TOP_COLOR = { 0.89f, 0.89f, 0.89f, 1.0f }
static ColorRGBA	LINE_TOP_DARK_COLOR = { 0.431f, 0.431f, 0.463f, 1.0f }
static ColorRGBA	LINE_TOP_SEL_COLOR = { 0.5294f, 0.5451, 0.5333f, 1.0f}
static ColorRGBA	LINE_TOP_SEL_DARK_COLOR = { 0.298f, 0.298f, 0.3333f, 1.0f}
static ColorRGBA	HEIGHT_LIMIT_BOTTOM_COLOR = { 0.4f, 0.4f, 1.0f, 1.0f }
static ColorRGBA	HEIGHT_LIMIT_TOP_COLOR = { 0.6f, 0.6f, 1.0f, 1.0f }
static const int	plate_thumbnail_width = 512
static const int	plate_thumbnail_height = 512

Protected Member Functions
void	set_new_unique_id ()
void	set_invalid_id ()
void	copy_id (const ObjectBase &rhs)
virtual void	assign_new_unique_ids_recursive ()

Private Member Functions
void	init ()
bool	valid_instance (int obj_id, int instance_id) const
void	generate_print_polygon (ExPolygon &print_polygon)
void	generate_exclude_polygon (ExPolygon &exclude_polygon)
void	generate_logo_polygon (ExPolygon &logo_polygon)
void	calc_bounding_boxes () const
void	calc_triangles (const ExPolygon &poly)
void	calc_exclude_triangles (const ExPolygon &poly)
void	calc_triangles_from_polygon (const ExPolygon &poly, GLModel &render_model)
void	calc_gridlines (const ExPolygon &poly, const BoundingBox &pp_bbox)
void	calc_height_limit ()
void	calc_imex_zones ()
void	ensure_imex_zones ()
std::string	build_imex_cache_key () const
void	calc_imex_ghosts ()
void	ensure_imex_ghosts ()
std::string	build_imex_ghost_cache_key () const
bool	resolve_active_mode_tools (std::string &out_tools_str, int &out_primary_phys) const
void	render_imex_zones (bool force_default_color)
void	refresh_imex_icon ()
float	icon_scale_factor () const
void	calc_vertex_for_number (int index, bool one_number, GLModel &buffer)
void	calc_vertex_for_plate_name_edit_icon (GLTexture *texture, int index, PickingModel &model)
void	calc_vertex_for_icons (int index, PickingModel &model)
void	calc_vertex_for_imex_warn_badge (int imex_icon_index, GLModel &model)
void	render_background (bool force_default_color=false)
void	render_logo (bool bottom, bool render_cali=true)
void	render_logo_texture (GLTexture &logo_texture, GLModel &logo_buffer, bool bottom)
void	render_exclude_area (bool force_default_color)
void	render_exclusion_volume_previews (bool force_default_color)
void	render_exclusion_volume_intersections ()
void	update_exclusion_volume_preview_models ()
std::string	exclusion_volume_preview_cache_key (const std::vector< BedExcludeRegion > &regions) const
double	max_broad_phase_intersecting_object_height (const Polygons &regions) const
void	render_grid (bool bottom)
void	render_wrapping_detection_area (bool force_default_color)
void	render_height_limit (PartPlate::HeightLimitMode mode=HEIGHT_LIMIT_BOTH)
void	render_icon_texture (GLModel &buffer, GLTexture &texture)
void	set_hover_tooltip (const std::string &tooltip)
void	render_icons (bool bottom, bool only_name=false, int hover_id=-1)
void	render_only_numbers (bool bottom)
void	render_plate_name_texture ()
void	invalidate_plate_name_texture ()
void	register_raycasters_for_picking (GLCanvas3D &canvas)
int	picking_id_component (int idx) const
void	on_filament_map_mode_change ()
Polygons	wipe_tower_obstacles (const DynamicPrintConfig &config) const
template<class Archive>
void	serialize (Archive &ar)

Static Private Member Functions
static ObjectID	generate_new_id ()
template<class Archive>
static void	load_and_construct (Archive &ar, cereal::construct< ObjectBase > &construct)

Private Attributes
PartPlateList *	m_partplate_list {nullptr }
Plater *	m_plater
Model *	m_model
PrinterTechnology	printer_technology
std::set< std::pair< int, int > >	obj_to_instance_set
std::set< std::pair< int, int > >	instance_outside_set
int	m_plate_index
Vec3d	m_origin
int	m_width
int	m_depth
double	m_height
float	m_height_to_lid
float	m_height_to_rod
bool	m_printable
bool	m_locked
bool	m_ready_for_slice
bool	m_slice_result_valid
bool	m_apply_invalid {false}
float	m_slice_percent
Print *	m_print
GCodeProcessorResult *	m_gcode_result
std::vector< FilamentInfo >	slice_filaments_info
int	m_print_index
std::string	m_tmp_gcode_path
std::string	m_temp_config_3mf_path
std::string	m_gcode_path_from_3mf
Pointfs	m_shape
Pointfs	m_exclude_area
std::vector< Pointfs >	m_extruder_areas
std::vector< double >	m_extruder_heights
BoundingBoxf3	m_bounding_box
BoundingBoxf3	m_extended_bounding_box
std::vector< BoundingBoxf3 >	m_exclude_bounding_box
BoundingBoxf3	m_grabber_box
Transform3d	m_grabber_trans_matrix
Slic3r::Geometry::Transformation	position
std::vector< Vec3f >	positions
ExPolygon	m_print_polygon
PickingModel	m_triangles
GLModel	m_exclude_triangles
GLModel	m_wrapping_detection_triangles
GLModel	m_exclusion_volume_floor_triangles
GLModel	m_exclusion_volume_border_triangles
std::vector< std::pair< std::unique_ptr< GLModel >, ColorRGBA > >	m_extruder_exclusion_volume_borders
GLModel	m_active_exclusion_volume_prisms
GLModel	m_exclusion_volume_intersection_triangles
std::string	m_exclusion_volume_preview_cache_key
bool	m_exclusion_volume_preview_dirty { true }
bool	m_exclusion_volume_intersections_cleared { false }
GLModel	m_logo_triangles
GLModel	m_gridlines
GLModel	m_gridlines_bolder
std::vector< GLModel >	m_imex_copy_zones
std::vector< GLModel >	m_imex_mirror_zones
std::vector< BoundingBoxf3 >	m_imex_secondary_zone_boxes
std::vector< BoundingBoxf3 >	m_imex_collision_zones
std::vector< GLModel >	m_imex_collision_overlay
std::vector< GLModel >	m_imex_margin_overlay
std::optional< BoundingBoxf >	m_imex_primary_zone_box
std::map< int, Vec2d >	m_imex_head_zone_centers
int	m_imex_primary_head { -1 }
std::string	m_imex_zones_mode_cache { "\x01" }
std::vector< std::unique_ptr< GLVolume > >	m_imex_ghost_volumes
std::string	m_imex_ghost_cache_key { "\x01" }
GLModel	m_height_limit_common
GLModel	m_height_limit_bottom
GLModel	m_height_limit_top
PickingModel	m_del_icon
PickingModel	m_arrange_icon
PickingModel	m_orient_icon
PickingModel	m_lock_icon
PickingModel	m_plate_settings_icon
PickingModel	m_plate_filament_map_icon
PickingModel	m_plate_name_edit_icon
PickingModel	m_move_front_icon
PickingModel	m_imex_mode_icon
GLModel	m_imex_warn_icon
GLModel	m_plate_idx_icon
GLTexture	m_texture
float	m_scale_factor { 1.0f }
GLUquadricObject *	m_quadric
int	m_hover_id
bool	m_selected
int	m_timelapse_warning_code = 0
DynamicPrintConfig	m_config
std::string	m_name
GLModel	m_plate_name_icon
GLTexture	m_name_texture
wxCoord	m_name_texture_width
wxCoord	m_name_texture_height
ObjectID	m_id

Static Private Attributes
static size_t	s_last_id = 0

Friends
class	PartPlateList
class	cereal::access
class	UndoRedo::StackImpl

Detailed Description

Member Typedef Documentation

Timestamp

using Slic3r::ObjectBase::Timestamp = uint64_t

inherited

Member Enumeration Documentation

HeightLimitMode

enum Slic3r::GUI::PartPlate::HeightLimitMode

Enumerator
HEIGHT_LIMIT_NONE
HEIGHT_LIMIT_BOTTOM
HEIGHT_LIMIT_TOP
HEIGHT_LIMIT_BOTH

                        {
        HEIGHT_LIMIT_NONE,
        HEIGHT_LIMIT_BOTTOM,
        HEIGHT_LIMIT_TOP,
        HEIGHT_LIMIT_BOTH
    };

ImexPlacementViolation

enum class Slic3r::GUI::PartPlate::ImexPlacementViolation

strong

Enumerator
None
Object
PrimeTower

{ None, Object, PrimeTower };

Constructor & Destructor Documentation

PartPlate() [1/2]

Slic3r::GUI::PartPlate::PartPlate

(

)

  : ObjectBase(-1), m_plater(nullptr), m_model(nullptr), m_quadric(nullptr)
{
  assert(this->id().invalid());
  init();
}

References Slic3r::ObjectBase::ObjectBase(), init(), m_model, m_plater, and m_quadric.

Referenced by move_instances_to(), and operator<().

Here is the call graph for this function:

Here is the caller graph for this function:

PartPlate() [2/2]

Slic3r::GUI::PartPlate::PartPlate	(	PartPlateList *	partplate_list,
		Vec3d	origin,
		int	width,
		int	depth,
		double	height,
		Plater *	platerObj,
		Model *	modelObj,
		bool	printable = true,
		PrinterTechnology	tech = ptFFF )

  :m_partplate_list(partplate_list), m_plater(platerObj), m_model(modelObj), printer_technology(tech), m_origin(origin), m_width(width), m_depth(depth), m_height(height),  m_printable(printable)
{
  init();
}

References init(), m_depth, m_height, m_model, m_origin, m_partplate_list, m_plater, m_printable, m_width, PartPlateList, and printer_technology.

Here is the call graph for this function:

~PartPlate()

Slic3r::GUI::PartPlate::~PartPlate

(

)

{
  clear();
  //if (m_quadric != nullptr)
  //  ::gluDeleteQuadric(m_quadric);
 
  //boost::nowide::remove(m_tmp_gcode_path.c_str());
}

References clear().

Here is the call graph for this function:

Member Function Documentation

add_instance()

int Slic3r::GUI::PartPlate::add_instance	(	int	obj_id,
		int	instance_id,
		bool	move_position,
		BoundingBoxf3 *	bounding_box = nullptr )

{
  if (!valid_instance(obj_id, instance_id))
  {
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": plate_id %1%, invalid obj_id %2%, instance_id %3%, move_position %4%") % m_plate_index % obj_id % instance_id % move_position;
    return -1;
  }
 
  ModelObject* object = m_model->objects[obj_id];
  ModelInstance* instance = object->instances[instance_id];
  std::pair<int, int> pair(obj_id, instance_id);
 
    obj_to_instance_set.insert(pair);
    invalidate_exclusion_volume_preview();
 
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": plate_id %1%, add instance obj_id %2%, instance_id %3%, move_position %4%") % m_plate_index % obj_id % instance_id % move_position;
 
  if (move_position)
  {
    //move this instance into the new position
    Vec3d center = get_center_origin();
    center.z() = instance->get_transformation().get_offset(Z);
 
    instance->set_offset(center);
    object->invalidate_bounding_box();
  }
 
  //need to judge whether this instance has an outer part
  bool outside = check_outside(obj_id, instance_id, bounding_box);
  if (outside)
    instance_outside_set.insert(pair);
 
  if (m_ready_for_slice && outside)
  {
    m_ready_for_slice = false;
  }
  else if ((obj_to_instance_set.size() == 1) && (!m_ready_for_slice) && !outside)
  {
    m_ready_for_slice = true;
  }
 
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1% , m_ready_for_slice changes to %2%") % m_plate_index %m_ready_for_slice;
  if (m_plater)
    m_plater->mark_plate_toolbar_image_dirty();
  return 0;
}

References Slic3r::bounding_box(), Slic3r::center(), check_outside(), get_center_origin(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelInstance::get_transformation(), instance_outside_set, invalidate_exclusion_volume_preview(), m_model, m_plate_index, m_plater, m_ready_for_slice, obj_to_instance_set, Slic3r::ModelInstance::set_offset(), valid_instance(), and Slic3r::Z.

Referenced by Slic3r::GUI::PartPlateList::add_to_plate(), Slic3r::GUI::PartPlateList::construct_objects_list_for_new_plate(), move_instances_to(), Slic3r::GUI::PartPlateList::notify_instance_update(), and Slic3r::GUI::PartPlateList::reload_all_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

assign_new_unique_ids_recursive()

virtual void Slic3r::ObjectBase::assign_new_unique_ids_recursive ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::Model, Slic3r::ModelObject, and Slic3r::ModelVolume.

{ this->set_new_unique_id(); }

References set_new_unique_id().

Here is the call graph for this function:

belt_open_y()

bool Slic3r::GUI::PartPlate::belt_open_y

(

)

const

{
  // Headless (CLI) plates have no plater and no wxApp behind wxGetApp(); the CLI's own belt
  // handling lives in Print::validate().
  if (m_plater == nullptr || wxGetApp().preset_bundle == nullptr)
    return false;
  const DynamicPrintConfig &printer = wxGetApp().preset_bundle->printers.get_edited_preset().config;
  const auto *belt       = printer.option<ConfigOptionBool>("belt_printer");
  const auto *infinite_y = printer.option<ConfigOptionBool>("belt_printer_infinite_y");
  return belt != nullptr && belt->value && infinite_y != nullptr && infinite_y->value;
}

References m_plater, Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by open_belt_y().

Here is the call graph for this function:

Here is the caller graph for this function:

build_imex_cache_key()

std::string Slic3r::GUI::PartPlate::build_imex_cache_key ( ) const

private

{
    // CLI / headless slice: no GUI_App is initialized, so `wxGetApp()` returns
    // memory that segfaults on member access. `m_plater` is set only by the GUI
    // construction path; treat its absence as "no IMEX state to compute" and
    // return an empty key. Same guard pattern used by calc_imex_ghosts.
    if (!m_plater || !wxGetApp().preset_bundle)
        return "";
    const DynamicPrintConfig& printer_cfg = wxGetApp().preset_bundle->printers.get_edited_preset().config;
    auto* is_imex_opt = printer_cfg.option<ConfigOptionBool>("is_imex");
    if (!is_imex_opt || !is_imex_opt->value)
        return "";
    std::string active_mode = get_effective_imex_mode();
    // Mode NAME alone is not printer identity: two presets can define the same mode
    // name with different tool rosters/primary, and imex_firmware_managed_zones
    // suppresses ghost generation entirely. Both shape the baked zone/ghost set, so
    // key them directly (previously caught only incidentally, via the ghost key's
    // since-removed pem entry).
    std::string active_tools;
    int         primary_phys = -1;
    resolve_active_mode_tools(active_tools, primary_phys); // empty on failure — keyed as such
    // imex_tool_layout decides which physical corner tool 0 occupies (flip_x / flip_y inside
    // compute_imex_zone_layout), so every zone rectangle, collision strip and ghost offset moves
    // when it changes while every other keyed field stays put. Without it the key is identical
    // across a layout change and the baked zones go stale; that this currently appears to work is
    // incidental -- some other path happens to rebuild -- not something to rely on.
    // Geometry values go through imex_cfg_* so the key is built from the same numbers
    // compute_imex_zone_layout() lays out with; a literal here could key on a value the layout
    // never used.
    return active_mode
         + "|" + std::to_string(imex_cfg_int(printer_cfg, "imex_tools_per_gantry"))
         + "x" + std::to_string(imex_cfg_int(printer_cfg, "imex_gantry_count"))
         + "|ly" + std::to_string((int)imex_cfg_enum<ImexToolLayout>(printer_cfg, "imex_tool_layout"))
         + "|cw" + std::to_string((int)(imex_cfg_float(printer_cfg, "imex_nozzle_clearance_x") * 10))
         + "|ch" + std::to_string((int)(imex_cfg_float(printer_cfg, "imex_nozzle_clearance_y") * 10))
         + "|mg" + std::to_string((int)(imex_cfg_float(printer_cfg, "imex_carriage_margin") * 10))
         + "|t" + active_tools
         + "|p" + std::to_string(primary_phys)
         + "|fw" + (imex_cfg_bool(printer_cfg, "imex_firmware_managed_zones") ? "1" : "0");
}

References get_effective_imex_mode(), Slic3r::imex_cfg_bool(), Slic3r::imex_cfg_enum(), Slic3r::imex_cfg_float(), Slic3r::imex_cfg_int(), m_plater, Slic3r::ConfigBase::option(), and resolve_active_mode_tools().

Referenced by build_imex_ghost_cache_key(), and ensure_imex_zones().

Here is the call graph for this function:

Here is the caller graph for this function:

build_imex_ghost_cache_key()

std::string Slic3r::GUI::PartPlate::build_imex_ghost_cache_key ( ) const

private

{
    // Ghost shape depends on: mode topology (same inputs as zone key) + set of
    // objects on plate + each primary instance's transform. Filament routing and
    // colors are deliberately NOT keyed: ghost RGB is restamped live every frame
    // by update_imex_ghost_colors, so color-only changes never need a mesh rebuild.
    std::string k = build_imex_cache_key();
    if (k.empty()) return "";  // ghost-off when zones-off
 
    k += "|obj";
    for (const auto& oi : obj_to_instance_set)
        k += std::to_string(oi.first) + "." + std::to_string(oi.second) + ",";
    return k;
}

References build_imex_cache_key(), and obj_to_instance_set.

Referenced by ensure_imex_ghosts().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_bounding_boxes()

void Slic3r::GUI::PartPlate::calc_bounding_boxes ( ) const

private

                                          {
  BoundingBoxf3* bounding_box = const_cast<BoundingBoxf3*>(&m_bounding_box);
  *bounding_box = BoundingBoxf3();
  for (const Vec2d& p : m_shape) {
    bounding_box->merge({ p(0), p(1), 0.0 });
  }
 
  BoundingBoxf3* extended_bounding_box = const_cast<BoundingBoxf3*>(&m_extended_bounding_box);
  *extended_bounding_box = m_bounding_box;
 
  double half_x = bounding_box->size().x() * GRABBER_X_FACTOR;
  double half_y = bounding_box->size().y() * 1.0f * GRABBER_Y_FACTOR;
  double half_z = GRABBER_Z_VALUE;
  Vec3d center(bounding_box->center().x(), bounding_box->min(1) -half_y, GROUND_Z);
  m_grabber_box.min = Vec3d(center.x() - half_x, center.y() - half_y, center.z() - half_z);
  m_grabber_box.max = Vec3d(center.x() + half_x, center.y() + half_y, center.z() + half_z);
  m_grabber_box.defined = true;
  extended_bounding_box->merge(m_grabber_box);
 
    //calc exclude area bounding box
    m_exclude_bounding_box.clear();
    BoundingBoxf3 exclude_bb;
    for (int index = 0; index < m_exclude_area.size(); index ++) {
    const Vec2d& p = m_exclude_area[index];
 
    if (index % 4 == 0)
      exclude_bb = BoundingBoxf3();
 
    exclude_bb.merge({ p(0), p(1), 0.0 });
 
    if (index % 4 == 3)
    {
      exclude_bb.max(2) = m_depth;
      exclude_bb.min(2) = GROUND_Z;
      m_exclude_bounding_box.emplace_back(exclude_bb);
    }
  }
}

References Slic3r::bounding_box(), Slic3r::center(), GRABBER_X_FACTOR, GRABBER_Y_FACTOR, GRABBER_Z_VALUE, GROUND_Z, m_bounding_box, m_depth, m_exclude_area, m_exclude_bounding_box, m_extended_bounding_box, m_grabber_box, m_shape, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBox3Base< PointType >::merge(), and Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min.

Referenced by set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_exclude_triangles()

void Slic3r::GUI::PartPlate::calc_exclude_triangles ( const ExPolygon & poly )

private

{
    m_exclude_triangles.reset();
 
    if (!init_model_from_poly(m_exclude_triangles, poly, GROUND_Z))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":Unable to create exclude triangles\n";
}

References GROUND_Z, Slic3r::GUI::init_model_from_poly(), and m_exclude_triangles.

Referenced by set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_gridlines()

void Slic3r::GUI::PartPlate::calc_gridlines ( const ExPolygon & poly, const BoundingBox & pp_bbox )

private

                                                                                {
    m_gridlines.reset();
    m_gridlines_bolder.reset();
 
    // calculate and generate grid
    int   step          = Bed_2D::calculate_grid_step(pp_bbox, scale_(1.00));
    Vec2d scaled_origin = Vec2d(scale_(m_origin.x()),scale_(m_origin.y()));
    auto  grid_lines    = Bed_2D::generate_grid(poly, pp_bbox, scaled_origin, scale_(step), SCALED_EPSILON);
 
    Lines lines_thin = to_lines(grid_lines[0]);
  Lines lines_bold = to_lines(grid_lines[1]);
 
  // append bed contours
  Lines contour_lines = to_lines(poly);
  std::copy(contour_lines.begin(), contour_lines.end(), std::back_inserter(lines_thin));
 
  if (!init_model_from_lines(m_gridlines       , lines_thin, GROUND_Z_GRIDLINE))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to create bed grid lines\n";
 
  if (!init_model_from_lines(m_gridlines_bolder, lines_bold, GROUND_Z_GRIDLINE))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to create bed grid lines\n";
}

References Slic3r::GUI::Bed_2D::calculate_grid_step(), Slic3r::GUI::Bed_2D::generate_grid(), GROUND_Z_GRIDLINE, Slic3r::GUI::init_model_from_lines(), m_gridlines, m_gridlines_bolder, m_origin, scale_, SCALED_EPSILON, and Slic3r::to_lines().

Referenced by set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_height_limit()

void Slic3r::GUI::PartPlate::calc_height_limit ( )

private

                                  {
    m_height_limit_common.reset();
    m_height_limit_bottom.reset();
    m_height_limit_top.reset();
 
  Lines3 bottom_h_lines, top_lines, top_h_lines, common_lines;
  int shape_count = m_shape.size();
  float first_z = 0.02f;
  for (int i = 0; i < shape_count; i++) {
    auto &cur_p = m_shape[i];
    Vec3crd p1(scale_(cur_p.x()), scale_(cur_p.y()), scale_(first_z));
    Vec3crd p2(scale_(cur_p.x()), scale_(cur_p.y()), scale_(m_height_to_rod));
    Vec3crd p3(scale_(cur_p.x()), scale_(cur_p.y()), scale_(m_height_to_lid));
 
    common_lines.emplace_back(p1, p2);
    top_lines.emplace_back(p2, p3);
 
    Vec2d next_p;
    if (i < (shape_count - 1)) {
      next_p = m_shape[i+1];
 
    }
    else {
      next_p = m_shape[0];
    }
    Vec3crd p4(scale_(cur_p.x()), scale_(cur_p.y()), scale_(m_height_to_rod));
    Vec3crd p5(scale_(next_p.x()), scale_(next_p.y()), scale_(m_height_to_rod));
    bottom_h_lines.emplace_back(p4, p5);
 
    Vec3crd p6(scale_(cur_p.x()), scale_(cur_p.y()), scale_(m_height_to_lid));
    Vec3crd p7(scale_(next_p.x()), scale_(next_p.y()), scale_(m_height_to_lid));
    top_h_lines.emplace_back(p6, p7);
  }
  //std::copy(bottom_lines.begin(), bottom_lines.end(), std::back_inserter(bottom_h_lines));
  std::copy(top_lines.begin(), top_lines.end(), std::back_inserter(top_h_lines));
 
  if (!init_model_from_lines(m_height_limit_common, common_lines))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to create height limit bottom lines\n";
 
  if (!init_model_from_lines(m_height_limit_bottom, bottom_h_lines))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to create height limit bottom lines\n";
 
  if (!init_model_from_lines(m_height_limit_top, top_h_lines))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to create height limit top lines\n";
}

References Slic3r::GUI::init_model_from_lines(), m_height_limit_bottom, m_height_limit_common, m_height_limit_top, m_height_to_lid, m_height_to_rod, m_shape, and scale_.

Referenced by set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_imex_ghosts()

void Slic3r::GUI::PartPlate::calc_imex_ghosts ( )

private

{
    m_imex_ghost_volumes.clear();
    if (!m_plater || !m_model) return;
    if (obj_to_instance_set.empty()) return;
 
    std::string active_tools_str;
    int primary_phys = -1;
    if (!resolve_active_mode_tools(active_tools_str, primary_phys)) return;
 
    // IMEX firmware-managed zones: the slicer emits a centered single-half slice and the
    // firmware fans copies/mirrors out from there — placement is not slicer-authoritative.
    // Rendering secondary-tool ghosts via imex_head_transform (which assumes slicer-managed
    // placement at primary_zone_center + gantry_offset) would draw them at positions the
    // firmware doesn't honor (e.g. off-bed once the centered slice is in play). Suppress
    // ghost generation entirely so we don't lie about something the slicer doesn't own.
    if (imex_cfg_bool(wxGetApp().preset_bundle->printers.get_edited_preset().config,
                      "imex_firmware_managed_zones"))
        return;
 
    // Zone centers are the basis for ghost placement; make sure they exist before
    // we read them. render_imex_zones already ensures this, but ghost rebuild can
    // also be driven from mode/preset invalidation paths that don't touch zones.
    ensure_imex_zones();
 
    const auto heads = parse_imex_active_tools(active_tools_str);
 
    // When primary's gantry has a Span tool, paired-gantry aggregation means each
    // non-primary gantry is represented by a single ghost — its column-paired rep —
    // so non-rep tools on aggregated gantries are skipped. This single source of
    // pairing truth keeps ghost emission and zone aggregation in lockstep.
    // Grouping must divide the grid the same way compute_imex_zone_layout() does, so the key is
    // read through the same accessor rather than against a literal repeated here.
    const int tpg = std::max(1, imex_cfg_int(
        wxGetApp().preset_bundle->printers.get_edited_preset().config, "imex_tools_per_gantry"));
    const ImexGantryGrouping grouping =
        group_imex_active_tools_by_gantry(active_tools_str, tpg);
    auto is_aggregated = [&](int phys) -> bool {
        const int g = phys / tpg;
        for (const auto& grp : grouping.groups)
            if (grp.gantry_index == g) return grp.aggregate;
        return false;
    };
    auto skip_for_aggregation = [&](int phys) -> bool {
        const int g = phys / tpg;
        for (const auto& grp : grouping.groups) {
            if (grp.gantry_index != g) continue;
            return grp.aggregate && phys != grp.representative_phys;
        }
        return false;
    };
 
    auto mirror_axis_for = [&](int phys) {
        return imex_mirror_axis_for(primary_phys, phys, tpg);
    };
 
    // Zone centers are the source of truth for ghost placement: they come from the
    // same grid math that paints the colored secondary zones, so a ghost always lands
    // in its own tool's zone. extruder_offset is physical-nozzle data and is left at
    // zero on most IMEX presets — sourcing offsets from it stacks every ghost on top
    // of the primary, which is what motivated this switch.
    auto center_for = [&](int phys) -> Vec2d {
        auto it = m_imex_head_zone_centers.find(phys);
        return (it == m_imex_head_zone_centers.end()) ? Vec2d::Zero() : it->second;
    };
    const Vec2d primary_off = center_for(primary_phys);
 
    // An aggregated gantry's zone is a full-X row strip, so it has no column of its own to
    // align to. Putting BOTH the primary and target X frames on the bed centerline makes
    // gantry_offset.x zero, which is what we want: a cross-gantry tool tracks primary's X
    // (it reflects in Y, not X — see imex_mirror_axis_for) and only translates along Y.
    // NB: the X frame is NOT a reflection plane. Do not "simplify" the bed_x_center
    // substitution away on the grounds that the mirror no longer reflects in X — dropping it
    // reintroduces a nonzero gantry_offset.x and shoves aggregated ghosts a column off their
    // strip.
    auto bed_ext = get_extents(m_shape);
    const double bed_x_center = 0.5 * (bed_ext.min(0) + bed_ext.max(0));
    auto resolve_centers = [&](int phys) -> std::pair<Vec2d, Vec2d> {
        const Vec2d target_off = center_for(phys);
        if (!is_aggregated(phys)) {
            // Per-tool: target stays at its column-aligned zone center.
            return {primary_off, target_off - primary_off};
        }
        const Vec2d aggregated_primary{bed_x_center, primary_off.y()};
        const Vec2d aggregated_target {bed_x_center, target_off.y()};
        return {aggregated_primary, aggregated_target - aggregated_primary};
    };
 
    // Mesh is object-local and identical across all instances and heads of a given object.
    // Build the merged TriangleMesh once per obj_idx and reuse across the inner head loop.
    // (Per-ghost GLModel::init_from still runs once each, since GLVolume owns its GLModel by value;
    // sharing a GLModel across GLVolumes would require API changes outside this task's scope.)
    std::map<int, TriangleMesh> mesh_by_obj;
    auto get_combined_mesh = [&](int obj_idx, const ModelObject* mo) -> const TriangleMesh& {
        auto it = mesh_by_obj.find(obj_idx);
        if (it != mesh_by_obj.end()) return it->second;
        TriangleMesh combined;
        for (const ModelVolume* mv : mo->volumes) {
            if (!mv->is_model_part()) continue;
            TriangleMesh tm = mv->mesh();
            tm.transform(mv->get_matrix());
            combined.merge(tm);
        }
        return mesh_by_obj.emplace(obj_idx, std::move(combined)).first->second;
    };
 
    for (const auto& oi : obj_to_instance_set) {
        const int obj_idx  = oi.first;
        const int inst_idx = oi.second;
        if (obj_idx < 0 || obj_idx >= (int)m_model->objects.size()) continue;
        ModelObject* mo = m_model->objects[obj_idx];
        if (!mo || inst_idx < 0 || inst_idx >= (int)mo->instances.size()) continue;
        ModelInstance* mi = mo->instances[inst_idx];
 
        const Transform3d inst_world = mi->get_matrix();
        const TriangleMesh& combined = get_combined_mesh(obj_idx, mo);
 
        for (const auto& [phys, role] : heads) {
            if (phys == primary_phys) continue;
            if (phys >= IMEX_GHOST_MAX_HEADS) continue;
            if (role == ImexRole::Span) continue;  // within-gantry partner; primary's zone covers it
            if (skip_for_aggregation(phys)) continue;  // non-rep on an aggregated gantry
 
            const auto [pri_center, gantry] = resolve_centers(phys);
            // A mirror on the primary's own gantry sits beside it in X, so it reflects across
            // the vertical boundary between their zones. A mirror on another gantry sits in
            // front of / behind it, so it reflects across the horizontal boundary between the
            // row strips — the Y axis. Copy translates by `gantry`; aggregated tools resolve
            // gantry.x to 0, so a cross-gantry mirror tracks primary's X and reflects only Y.
            const Transform3d head_xf = imex_head_transform(
                primary_phys, phys, role, gantry, pri_center, mirror_axis_for(phys));
            const Transform3d ghost_xf = head_xf * inst_world;
 
            // No color at bake time: update_imex_ghost_colors is the sole author of
            // ghost color, restamping RGB + alpha from the live palette every frame.
            auto ghost = std::make_unique<GLVolume>();
            ghost->set_instance_transformation(ghost_xf);
            ghost->force_transparent    = 1;
            ghost->force_native_color   = 1;
            ghost->disabled             = 1;  // skip selection path
            // is_active defaults to true in GLVolume's ctor — leave it alone.
            ghost->zoom_to_volumes      = 0;
            // Ghosts live in secondary zones that are by definition outside the primary
            // printable area; suppress the red "outside bed" overlay for them.
            ghost->shader_outside_printer_detection_enabled = 0;
            ghost->picking              = 1;
            // object_id = sentinel-encoded physical head; volume_id = source obj_idx (for live-drag);
            // instance_id = source inst_idx.
            ghost->composite_id = GLVolume::CompositeID(
                imex_ghost_composite_id_for_head(phys), obj_idx, inst_idx);
            ghost->model.init_from(combined);
            m_imex_ghost_volumes.push_back(std::move(ghost));
        }
    }
}

References ensure_imex_zones(), Slic3r::get_extents(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::group_imex_active_tools_by_gantry(), Slic3r::ImexGantryGrouping::groups, Slic3r::imex_cfg_bool(), Slic3r::imex_cfg_int(), imex_ghost_composite_id_for_head(), IMEX_GHOST_MAX_HEADS, Slic3r::imex_head_transform(), Slic3r::imex_mirror_axis_for(), Slic3r::ModelObject::instances, Slic3r::ModelVolume::is_model_part(), m_imex_ghost_volumes, m_imex_head_zone_centers, m_model, m_plater, m_shape, Slic3r::TriangleMesh::merge(), Slic3r::ModelVolume::mesh(), obj_to_instance_set, Slic3r::parse_imex_active_tools(), resolve_active_mode_tools(), Slic3r::Span, and Slic3r::TriangleMesh::transform().

Referenced by ensure_imex_ghosts().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_imex_zones()

void Slic3r::GUI::PartPlate::calc_imex_zones ( )

private

{
    m_imex_copy_zones.clear();
    m_imex_mirror_zones.clear();
    // Clear blocking vectors at the top so early returns don't leave stale data.
    m_imex_secondary_zone_boxes.clear();
    m_imex_collision_zones.clear();
    m_imex_collision_overlay.clear();
    m_imex_margin_overlay.clear();
    m_imex_primary_zone_box = std::nullopt;
    m_imex_head_zone_centers.clear();
    m_imex_primary_head = -1;
 
    if (!wxGetApp().preset_bundle)
        return;
 
    PresetBundle&             bundle      = *wxGetApp().preset_bundle;
    const DynamicPrintConfig& printer_cfg = bundle.printers.get_edited_preset().config;
 
    // Process-preset mode is the fallback the library applies when the plate is still on
    // the reserved Primary mode; it ignores this string otherwise.
    std::string process_mode;
    if (auto* mode_opt = bundle.prints.get_edited_preset().config.option<ConfigOptionString>("imex_parallel_mode"))
        process_mode = mode_opt->value;
 
    const ImexZoneLayout layout = compute_imex_zone_layout(printer_cfg, get_imex_mode(),
                                                           process_mode, get_extents(m_shape));
 
    m_imex_primary_head         = layout.primary_head;
    m_imex_head_zone_centers    = layout.head_zone_centers;
    m_imex_primary_zone_box     = layout.primary_zone_box;
    m_imex_secondary_zone_boxes = layout.secondary_zone_boxes;
    m_imex_collision_zones      = layout.collision_zones;
 
    // No primary zone means the layout is empty (IMEX off, Primary mode, single-tool grid,
    // or a mode with no tools) -- exactly the cases that returned before touching geometry.
    if (!m_imex_primary_zone_box.has_value())
        return;
 
    ExPolygon bed_poly;
    generate_print_polygon(bed_poly);
 
    // Build a clipped filled GLModel for one zone rect and push it into a vector.
    // A rect falling entirely outside the bed outline contributes no model.
    auto push_zone_fill = [&](std::vector<GLModel>& vec, double cx0, double cx1, double cy0, double cy1) {
        ExPolygon cell;
        cell.contour.append({ scale_(cx0), scale_(cy0) });
        cell.contour.append({ scale_(cx1), scale_(cy0) });
        cell.contour.append({ scale_(cx1), scale_(cy1) });
        cell.contour.append({ scale_(cx0), scale_(cy1) });
        ExPolygons clipped = intersection_ex({ cell }, { bed_poly });
        if (!clipped.empty()) {
            GLModel m;
            if (init_model_from_poly(m, clipped.front(), GROUND_Z))
                vec.push_back(std::move(m));
        }
    };
 
    for (const BoundingBoxf& b : layout.copy_zones)
        push_zone_fill(m_imex_copy_zones, b.min.x(), b.max.x(), b.min.y(), b.max.y());
    for (const BoundingBoxf& b : layout.mirror_zones)
        push_zone_fill(m_imex_mirror_zones, b.min.x(), b.max.x(), b.min.y(), b.max.y());
    // Red-orange fill for each carriage danger strip, and the amber advisory band just
    // inside it. Both are visual only -- blocking is driven by m_imex_collision_zones.
    for (const BoundingBoxf3& b : layout.collision_zones)
        push_zone_fill(m_imex_collision_overlay, b.min.x(), b.max.x(), b.min.y(), b.max.y());
    for (const BoundingBoxf& b : layout.margin_bands)
        push_zone_fill(m_imex_margin_overlay, b.min.x(), b.max.x(), b.min.y(), b.max.y());
}

References Slic3r::MultiPoint::append(), Slic3r::ImexZoneLayout::collision_zones, Slic3r::compute_imex_zone_layout(), Slic3r::Preset::config, Slic3r::ExPolygon::contour, Slic3r::ImexZoneLayout::copy_zones, generate_print_polygon(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::get_extents(), get_imex_mode(), GROUND_Z, Slic3r::ImexZoneLayout::head_zone_centers, Slic3r::GUI::init_model_from_poly(), Slic3r::intersection_ex(), m_imex_collision_overlay, m_imex_collision_zones, m_imex_copy_zones, m_imex_head_zone_centers, m_imex_margin_overlay, m_imex_mirror_zones, m_imex_primary_head, m_imex_primary_zone_box, m_imex_secondary_zone_boxes, m_shape, Slic3r::ImexZoneLayout::margin_bands, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::ImexZoneLayout::mirror_zones, Slic3r::ConfigBase::option(), Slic3r::ImexZoneLayout::primary_head, Slic3r::ImexZoneLayout::primary_zone_box, Slic3r::PresetBundle::printers, Slic3r::PresetBundle::prints, scale_, and Slic3r::ImexZoneLayout::secondary_zone_boxes.

Referenced by ensure_imex_zones(), and set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_triangles()

void Slic3r::GUI::PartPlate::calc_triangles ( const ExPolygon & poly )

private

{
    m_triangles.reset();
 
    if (!init_model_from_poly(m_triangles.model, poly, GROUND_Z))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":Unable to create plate triangles\n";
}

References GROUND_Z, Slic3r::GUI::init_model_from_poly(), and m_triangles.

Referenced by set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_triangles_from_polygon()

void Slic3r::GUI::PartPlate::calc_triangles_from_polygon ( const ExPolygon & poly, GLModel & render_model )

private

                                                                                       {
    if (poly.empty()) {
        render_model.reset();
        return;
    }
    render_model.reset();
    if (!init_model_from_poly(render_model, poly, GROUND_Z)) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "calc_triangles_from_polygon fail";
    }
}

References GROUND_Z, Slic3r::GUI::init_model_from_poly(), and Slic3r::GUI::GLModel::reset().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_vertex_for_icons()

void Slic3r::GUI::PartPlate::calc_vertex_for_icons ( int index, PickingModel & model )

private

{
    model.reset();
 
    ExPolygon poly;
    auto  bed_ext  = get_extents(m_shape);
    Vec2d p        = bed_ext[2];
    float factor   = icon_scale_factor();
    float size     = PARTPLATE_ICON_SIZE     * factor;
    float gap_left = PARTPLATE_ICON_GAP_LEFT * factor;
    float gap_y    = PARTPLATE_ICON_GAP_Y    * factor;
    float gap_top  = PARTPLATE_ICON_GAP_TOP  * factor;
    p += Vec2d(gap_left,-1 * (index * (size + gap_y) + gap_top));
 
    if (m_plater && m_plater->get_build_volume_type() == BuildVolume_Type::Circle)
        p[1] -= std::max(0.0, (bed_ext.size()(1) - (size + gap_y) * 6 /* bed_icon_count */) / 2);
 
    poly.contour.append({ scale_(p(0))       , scale_(p(1) - size) });
    poly.contour.append({ scale_(p(0) + size), scale_(p(1) - size) });
    poly.contour.append({ scale_(p(0) + size), scale_(p(1)) });
    poly.contour.append({ scale_(p(0))       , scale_(p(1)) });
 
  if (!init_model_from_poly(model.model, poly, GROUND_Z))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to generate geometry buffers for icons\n";
 
  init_raycaster_from_model(model);
}

References Slic3r::Circle, Slic3r::get_extents(), GROUND_Z, icon_scale_factor(), Slic3r::GUI::init_model_from_poly(), Slic3r::GUI::init_raycaster_from_model(), m_plater, m_shape, Slic3r::GUI::PickingModel::model, PARTPLATE_ICON_GAP_LEFT, PARTPLATE_ICON_GAP_TOP, PARTPLATE_ICON_GAP_Y, PARTPLATE_ICON_SIZE, Slic3r::GUI::PickingModel::reset(), and scale_.

Referenced by refresh_imex_icon(), and set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_vertex_for_imex_warn_badge()

void Slic3r::GUI::PartPlate::calc_vertex_for_imex_warn_badge ( int imex_icon_index, GLModel & model )

private

{
    model.reset();
 
    auto  bed_ext  = get_extents(m_shape);
    Vec2d p        = bed_ext[2];
    auto  factor   = bed_ext.size()(1) / 200.0;
    float size     = PARTPLATE_ICON_SIZE     * factor;
    float gap_left = PARTPLATE_ICON_GAP_LEFT * factor;
    float gap_y    = PARTPLATE_ICON_GAP_Y    * factor;
    float gap_top  = PARTPLATE_ICON_GAP_TOP  * factor;
 
    // Centre of the IMEX mode icon (top-left corner = p after offset)
    p += Vec2d(gap_left, -1 * (imex_icon_index * (size + gap_y) + gap_top));
 
    // Badge is half the icon size, anchored to the bottom-right corner of the icon slot
    float badge = size * 0.55f;
    Vec2d bp(p(0) + size - badge, p(1) - size);
 
    ExPolygon poly;
    poly.contour.append({ scale_(bp(0))        , scale_(bp(1))        });
    poly.contour.append({ scale_(bp(0) + badge), scale_(bp(1))        });
    poly.contour.append({ scale_(bp(0) + badge), scale_(bp(1) + badge)});
    poly.contour.append({ scale_(bp(0))        , scale_(bp(1) + badge)});
 
    if (!init_model_from_poly(model, poly, GROUND_Z + 0.01f))
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to generate geometry for IMEX warn badge\n";
}

References Slic3r::get_extents(), GROUND_Z, Slic3r::GUI::init_model_from_poly(), m_shape, PARTPLATE_ICON_GAP_LEFT, PARTPLATE_ICON_GAP_TOP, PARTPLATE_ICON_GAP_Y, PARTPLATE_ICON_SIZE, Slic3r::GUI::GLModel::reset(), and scale_.

Referenced by refresh_imex_icon(), and set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_vertex_for_number()

void Slic3r::GUI::PartPlate::calc_vertex_for_number ( int index, bool one_number, GLModel & buffer )

private

{
    buffer.reset();
 
  ExPolygon poly;
#if 0 //in the up area
  Vec2d& p = m_shape[2];
  float offset_x = one_number?PARTPLATE_TEXT_OFFSET_X1: PARTPLATE_TEXT_OFFSET_X2;
 
  poly.contour.append({ scale_(p(0) + PARTPLATE_ICON_GAP + offset_x), scale_(p(1) - index * (PARTPLATE_ICON_SIZE + PARTPLATE_ICON_GAP) - PARTPLATE_ICON_GAP - PARTPLATE_ICON_SIZE + PARTPLATE_TEXT_OFFSET_Y) });
  poly.contour.append({ scale_(p(0) + PARTPLATE_ICON_GAP + PARTPLATE_ICON_SIZE - offset_x), scale_(p(1) - index * (PARTPLATE_ICON_SIZE + PARTPLATE_ICON_GAP)- PARTPLATE_ICON_GAP - PARTPLATE_ICON_SIZE + PARTPLATE_TEXT_OFFSET_Y) });
  poly.contour.append({ scale_(p(0) + PARTPLATE_ICON_GAP + PARTPLATE_ICON_SIZE - offset_x), scale_(p(1) - index * (PARTPLATE_ICON_SIZE + PARTPLATE_ICON_GAP)- PARTPLATE_ICON_GAP - PARTPLATE_TEXT_OFFSET_Y)});
  poly.contour.append({ scale_(p(0) + PARTPLATE_ICON_GAP + offset_x), scale_(p(1) - index * (PARTPLATE_ICON_SIZE + PARTPLATE_ICON_GAP)- PARTPLATE_ICON_GAP - PARTPLATE_TEXT_OFFSET_Y) });
#else //in the bottom
    auto bed_ext   = get_extents(m_shape);
    Vec2d p        = bed_ext[1];
    float factor   = icon_scale_factor();
    float size     = PARTPLATE_ICON_SIZE     * factor;
    float offset_y = PARTPLATE_TEXT_OFFSET_Y * factor;
    float offset_x = (one_number?PARTPLATE_TEXT_OFFSET_X1: PARTPLATE_TEXT_OFFSET_X2) * factor;
    float gap_left = PARTPLATE_ICON_GAP_LEFT * factor;
    p += Vec2d(gap_left,0);
 
    poly.contour.append({ scale_(p(0) + offset_x)       , scale_(p(1) + offset_y) });
    poly.contour.append({ scale_(p(0) + size - offset_x), scale_(p(1) + offset_y) });
    poly.contour.append({ scale_(p(0) + size - offset_x), scale_(p(1) + size - offset_y) });
    poly.contour.append({ scale_(p(0) + offset_x)       , scale_(p(1) + size - offset_y) });
#endif
    if (!init_model_from_poly(buffer, poly, GROUND_Z))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to generate geometry buffers for icons\n";
}

References Slic3r::get_extents(), GROUND_Z, icon_scale_factor(), Slic3r::GUI::init_model_from_poly(), m_shape, PARTPLATE_ICON_GAP_LEFT, PARTPLATE_ICON_SIZE, PARTPLATE_TEXT_OFFSET_X1, PARTPLATE_TEXT_OFFSET_X2, PARTPLATE_TEXT_OFFSET_Y, Slic3r::GUI::GLModel::reset(), and scale_.

Referenced by set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_vertex_for_plate_name_edit_icon()

void Slic3r::GUI::PartPlate::calc_vertex_for_plate_name_edit_icon ( GLTexture * texture, int index, PickingModel & model )

private

                                                                                                       {
    model.reset();
 
    ExPolygon poly;
    auto  bed_ext  = get_extents(m_shape);
    Vec2d p        = bed_ext[3];
    float factor   = icon_scale_factor();
    float icon_sz  = factor * PARTPLATE_EDIT_PLATE_NAME_ICON_SIZE;
    float width    = icon_sz;
    float height   = icon_sz;
    float offset_y = factor * PARTPLATE_TEXT_OFFSET_Y;
 
    float name_width = 0.0;
    if (texture && texture->get_width() > 0 && texture->get_height())
        // original width give correct ratio in here since rendering width can be much higher because of next_highest_power_of_2 for rendering
        name_width = icon_sz * texture->m_original_width / texture->get_height(); 
 
    //if (m_plater && m_plater->get_build_volume_type() == BuildVolume_Type::Circle)
    //    px = scale_(bed_ext.center()(0)) + m_name_texture_width * 0.50 - height * 0.50;
    p += Vec2d(name_width, offset_y);
 
    poly.contour.append({ scale_(p(0)        ), scale_(p(1)         ) });
    poly.contour.append({ scale_(p(0) + width), scale_(p(1)         ) });
    poly.contour.append({ scale_(p(0) + width), scale_(p(1) + height) });
    poly.contour.append({ scale_(p(0)        ), scale_(p(1) + height) });
 
    if (!init_model_from_poly(model.model, poly, GROUND_Z))
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to generate geometry buffers for icons\n";
 
    init_raycaster_from_model(model);
}

References Slic3r::get_extents(), Slic3r::GUI::GLTexture::get_height(), Slic3r::GUI::GLTexture::get_width(), GROUND_Z, icon_scale_factor(), Slic3r::GUI::init_model_from_poly(), Slic3r::GUI::init_raycaster_from_model(), Slic3r::GUI::GLTexture::m_original_width, m_shape, Slic3r::GUI::PickingModel::model, PARTPLATE_EDIT_PLATE_NAME_ICON_SIZE, PARTPLATE_TEXT_OFFSET_Y, Slic3r::GUI::PickingModel::reset(), and scale_.

Referenced by generate_plate_name_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

can_slice()

bool Slic3r::GUI::PartPlate::can_slice ( ) const

inline

    {
        return m_ready_for_slice && !m_apply_invalid;
    }

References m_apply_invalid, and m_ready_for_slice.

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::MainFrame::get_enable_slice_status(), and Slic3r::GUI::Plater::priv::update_background_process().

Here is the caller graph for this function:

check_compatible_of_nozzle_and_filament()

bool Slic3r::GUI::PartPlate::check_compatible_of_nozzle_and_filament	(	const DynamicPrintConfig &	config,
		const std::vector< std::string > &	filament_presets,
		std::string &	error_msg )

{
    float nozzle_diameter = config.option<ConfigOptionFloats>("nozzle_diameter")->values[0];
    auto  volume_type_opt = config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
 
    auto get_filament_alias = [](std::string preset_name) -> std::string {
        size_t      at_pos = preset_name.find('@');
        std::string alias  = preset_name.substr(0, at_pos);
        size_t      first  = alias.find_first_not_of(' ');
        if (first == std::string::npos) return "";
        size_t last = alias.find_last_not_of(' ');
        return alias.substr(first, last - first + 1);
    };
 
    bool with_same_volume_type = std::all_of(volume_type_opt->values.begin(), volume_type_opt->values.end(),
                                             [first_value = volume_type_opt->values[0]](int value) { return value == first_value; });
 
    std::set<std::string> selected_filament_alias;
    for (auto &filament_preset : filament_presets) { selected_filament_alias.insert(get_filament_alias(filament_preset)); }
 
    auto get_incompatible_selected = [&](const NozzleVolumeType volume_type) -> std::set<std::string> {
        std::vector<std::string> incompatible_filaments = Print::get_incompatible_filaments_by_nozzle(nozzle_diameter, volume_type);
        std::set<std::string>    ret;
        for (auto &filament : selected_filament_alias) {
            if (std::find(incompatible_filaments.begin(), incompatible_filaments.end(), filament) != incompatible_filaments.end()) ret.insert(filament);
        }
        return ret;
    };
 
    auto get_nozzle_msg = [](const float nozzle_diameter, const NozzleVolumeType volume_type) -> std::string {
        std::ostringstream oss;
        oss << std::fixed << std::setprecision(1) << nozzle_diameter;
        // TRN %1% is the nozzle diameter, %2% the nozzle volume type, for example "Standard" or "High Flow".
        return Slic3r::format(_u8L("%1%mm %2% nozzle"), oss.str(), _u8L(get_nozzle_volume_type_string(volume_type)));
    };
 
    auto get_incompatible_filament_msg = [](const std::set<std::string> &incompatible_selected_filaments) -> std::string {
        std::string filament_str;
        size_t      idx = 0;
        for (const auto &filament : incompatible_selected_filaments) {
            if (idx > 0) filament_str += ',';
            filament_str += filament;
            ++idx;
        }
        return filament_str;
    };
 
    error_msg.clear();
 
    std::set<int>                                     nozzle_volumes(volume_type_opt->values.begin(), volume_type_opt->values.end());
    std::map<NozzleVolumeType, std::set<std::string>> incompatible_selected_map;
 
    for (auto volume_type_value : nozzle_volumes) {
        NozzleVolumeType volume_type           = static_cast<NozzleVolumeType>(volume_type_value);
        auto             incompatible_selected = get_incompatible_selected(volume_type);
        if (!incompatible_selected.empty()) incompatible_selected_map[volume_type] = incompatible_selected;
    }
 
    if (incompatible_selected_map.empty()) return true;
 
    if (incompatible_selected_map.size() == 1) {
        auto             elem                  = incompatible_selected_map.begin();
        NozzleVolumeType volume_type           = elem->first;
        auto             incompatible_selected = elem->second;
        error_msg = GUI::format(_L_PLURAL("It is not recommended to print the following filament with %1%: %2%\n",
                                          "It is not recommended to print the following filaments with %1%: %2%\n", incompatible_selected.size()),
                                get_nozzle_msg(nozzle_diameter, volume_type),
                                get_incompatible_filament_msg(incompatible_selected));
    } else {
        std::string warning_msg = _u8L("It is not recommended to use the following nozzle and filament combinations:\n");
        for (auto &elem : incompatible_selected_map) {
            NozzleVolumeType volume_type           = elem.first;
            auto             incompatible_selected = elem.second;
            warning_msg += GUI::format(_L("%1% with %2%\n"),get_nozzle_msg(nozzle_diameter, volume_type), get_incompatible_filament_msg(incompatible_selected));
        }
        error_msg = warning_msg;
    }
    return false;
}

References _L, _L_PLURAL, _u8L, config(), Slic3r::format(), Slic3r::GUI::format(), Slic3r::Print::get_incompatible_filaments_by_nozzle(), Slic3r::get_nozzle_volume_type_string(), Slic3r::nozzle_diameter(), and Slic3r::ConfigOptionVector< double >::values.

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

check_filament_printable()

bool Slic3r::GUI::PartPlate::check_filament_printable	(	const DynamicPrintConfig &	config,
		wxString &	error_message )

{
    error_message.clear();
    FilamentMapMode mode = this->get_real_filament_map_mode(config);
    // only check printablity if we have explicit map result
    if (mode != fmmManual)
        return true;
 
    std::vector<int> used_filaments = get_extruders(true);  // 1 base
    if (!used_filaments.empty()) {
        const std::vector<std::string>& filament_types      = config.option<ConfigOptionStrings>("filament_type")->values;
        const std::vector<int>&         filament_printables = config.option<ConfigOptionInts>("filament_printable")->values;
        const std::vector<int>&         filament_map        = get_real_filament_maps(config);
        // This runs synchronously mid printer-switch (load_current_preset -> reload_scene), before the
        // filament-count reconciliation clears stale per-object assignments, so the plate objects can
        // still reference filament indices beyond the freshly selected printer config. Skip those to
        // avoid an out-of-range access. Matches BambuStudio's guards in the same function.
        const int filament_count = std::min({(int) filament_types.size(), (int) filament_printables.size(), (int) filament_map.size()});
        for (auto filament_idx : used_filaments) {
            int filament_id = filament_idx - 1;
            if (filament_id < 0 || filament_id >= filament_count)
                continue;
            std::string filament_type = filament_types[filament_id];
            int filament_printable_status = filament_printables[filament_id];
            int extruder_idx = filament_map[filament_id] - 1;
            if (!(filament_printable_status >> extruder_idx & 1)) {
                error_message = wxString::Format(extruder_idx == 0 ? _L("The left nozzle cannot print %s.") : _L("The right nozzle cannot print %s."),
                                                 filament_type);
                return false;
            }
        }
    }
    return true;
}

References _L, config(), Slic3r::filament_map(), Slic3r::filament_type(), Slic3r::GUI::filament_types, Slic3r::fmmManual, get_extruders(), get_real_filament_map_mode(), and get_real_filament_maps().

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene(), and Slic3r::GUI::Plater::validate_current_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

check_mixture_filament_compatible()

bool Slic3r::GUI::PartPlate::check_mixture_filament_compatible	(	const DynamicPrintConfig &	config,
		std::string &	error_msg )

{
    static std::unordered_map<std::string, std::unordered_set<std::string>> incompatible_filament_pairs;
 
    auto add_incompatibility = [&](std::string filament_type1, std::string filament_type2) {
        incompatible_filament_pairs[filament_type1].insert(filament_type2);
        incompatible_filament_pairs[filament_type2].insert(filament_type1);
    };
 
    if (incompatible_filament_pairs.empty()) { add_incompatibility("PVA", "PETG"); }
 
    std::vector<int>         used_filaments = get_extruders(true); // 1 based idx
    std::vector<std::string> filament_types;
    auto                     filament_type_opt = config.option<ConfigOptionStrings>("filament_type");
    for (auto filament : used_filaments) {
        int filament_idx = filament - 1;
        if (filament_idx >= filament_type_opt->values.size()) filament_idx = 0;
        filament_types.push_back(filament_type_opt->values[filament_idx]);
    };
 
    {
        std::unordered_set<std::string> seen;
        filament_types.erase(std::remove_if(filament_types.begin(), filament_types.end(), [&](const std::string &s) { return !seen.insert(s).second; }), filament_types.end());
    }
 
    std::vector<std::pair<std::string, std::string>> conflicts;
 
    for (size_t i = 0; i < filament_types.size(); i++) {
        auto it = incompatible_filament_pairs.find(filament_types[i]);
        if (it == incompatible_filament_pairs.end()) continue;
        for (size_t j = i + 1; j < filament_types.size(); ++j) {
            if (it->second.count(filament_types[j])) { conflicts.emplace_back(filament_types[i], filament_types[j]); }
        }
    }
 
    if (!conflicts.empty()) {
        // TODO: add the full text if has multi conflict
        auto conflict = conflicts.front();
        error_msg     = GUI::format(_L("Mixing %1% with %2% in printing is not recommended.\n"), conflict.first, conflict.second);
    }
    return conflicts.empty();
}

References _L, config(), Slic3r::GUI::filament_types, Slic3r::GUI::format(), and get_extruders().

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

check_mixture_of_pla_and_petg()

bool Slic3r::GUI::PartPlate::check_mixture_of_pla_and_petg

(

const DynamicPrintConfig &

config

)

{
    bool has_pla = false;
    bool has_petg = false;
 
    // On a toolchanger (machine_tool_change_time > 0) each filament slot maps to a
    // separate physical nozzle: only one nozzle is ever mounted or heated at a time, so
    // there is no cross-nozzle contamination between PLA and PETG.  Track which physical
    // nozzle each material is on; warn only when PLA and PETG would pass through the
    // *same* nozzle.
    //
    // NOTE: if MMU-on-toolchanger support is added (#10586), the nozzle-mapping logic
    // will need to be revisited because multiple filaments may then share one tool slot.
    bool is_toolchanger = false;
    auto *tool_change_time = config.option<ConfigOptionFloat>("machine_tool_change_time");
    if (tool_change_time && tool_change_time->value > 0)
        is_toolchanger = true;
 
    // nozzle index → whether it carries PLA / PETG
    std::map<int, bool> nozzle_has_pla;
    std::map<int, bool> nozzle_has_petg;
 
    std::vector<int> used_filaments = get_extruders(true); // 1-based
    if (!used_filaments.empty()) {
        const auto *filament_types = config.option<ConfigOptionStrings>("filament_type");
        for (auto filament_idx : used_filaments) {
            int filament_id = filament_idx - 1;
            if (filament_id < (int)filament_types->values.size()) {
                const std::string &filament_type = filament_types->values[filament_id];
                if (filament_type == "PLA") {
                    has_pla = true;
                    nozzle_has_pla[filament_id] = true;
                }
                if (filament_type == "PETG") {
                    has_petg = true;
                    nozzle_has_petg[filament_id] = true;
                }
            } else {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " check error:array bound";
            }
        }
    }
 
    if (!has_pla || !has_petg)
        return true; // no mixture — no warning
 
    if (is_toolchanger) {
        // Warn only if any single nozzle slot carries both PLA and PETG (e.g. future MMU
        // on toolchanger).  On a pure toolchanger each slot is independent, so this loop
        // will never fire and the warning is correctly suppressed. (#12073)
        for (const auto &kv : nozzle_has_pla) {
            if (nozzle_has_petg.count(kv.first))
                return false; // same nozzle → warn
        }
        return true; // different nozzles → safe, no warning
    }
 
    return false; // non-toolchanger with both PLA and PETG → warn
}

References config(), Slic3r::filament_type(), Slic3r::GUI::filament_types, and get_extruders().

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

check_objects_empty_and_gcode3mf()

bool Slic3r::GUI::PartPlate::check_objects_empty_and_gcode3mf

(

std::vector< int > &

result

)

const

{
    if (m_model->objects.empty()) {//objects is empty
        if (wxGetApp().plater()->is_gcode_3mf()) { // if gcode.3mf file
            for (int i = 0; i < slice_filaments_info.size(); i++) {
                result.push_back(slice_filaments_info[i].id + 1);
            }
        }
        return true;
    }
    return false;
}

References m_model, Slic3r::GUI::plater(), and slice_filaments_info.

Referenced by get_extruders(), get_extruders_without_support(), and get_used_filaments().

Here is the call graph for this function:

Here is the caller graph for this function:

check_outside()

bool Slic3r::GUI::PartPlate::check_outside	(	int	obj_id,
		int	instance_id,
		BoundingBoxf3 *	bounding_box = nullptr )

{
  // Ensure IDEX/IQEX zone geometry is current before any placement check.
  ensure_imex_zones();
 
  bool outside = true;
 
  ModelObject* object = m_model->objects[obj_id];
  ModelInstance* instance = object->instances[instance_id];
 
  BoundingBoxf3 instance_box = bounding_box? *bounding_box: object->instance_convex_hull_bounding_box(instance_id);
  // Reuse the hull across exclusion and IMEX checks, but do not build it for
  // instances rejected by the plate bounds or printers with no relevant zones.
  std::optional<Polygon> instance_hull;
  const auto get_instance_hull = [&]() -> const Polygon & {
    if (!instance_hull)
      instance_hull = instance->convex_hull_2d();
    return *instance_hull;
  };
  BoundingBoxf3 plate_box = get_plate_box();
  this->open_belt_y(plate_box);
  if (instance_box.max.z() > plate_box.min.z())
    plate_box.min.z() += instance_box.min.z(); // not considering outsize if sinking
 
  if (instance_box.min.z() < SINKING_Z_THRESHOLD) {
    // Orca: For sinking object, we use a more expensive algorithm so part below build plate won't be considered
    // m_height mirrors the printer's printable height and is set in CLI mode too, unlike m_plater.
    if (plate_box.intersects(instance_box)) {
      // TODO: FIXME: this does not take exclusion area into account
      const BuildVolume build_volume(get_shape(), m_height, m_extruder_areas, m_extruder_heights);
      const auto state = instance->calc_print_volume_state(build_volume);
      outside = state == ModelInstancePVS_Partly_Outside;
    }
  }
  else
  if (plate_box.contains(instance_box))
  {
        outside = false;
        const DynamicPrintConfig *config = m_plater != nullptr ? m_plater->config() : nullptr;
        bool checked_config_regions = false;
        if (config != nullptr) {
            const std::vector<std::vector<BedExcludeRegion>> regions_by_extruder =
                get_bed_excluded_regions_by_extruder(*config);
            const BedExcludeVolumeMode mode = active_bed_exclude_volume_mode(*config);
            // The legacy outside flag has no filament/nozzle context. Always
            // check the shared legacy area here, but let the newer per-extruder
            // pipeline handle nozzle-specific collision volumes.
            const Point plate_offset(scale_(m_origin.x()), scale_(m_origin.y()));
            const Polygon &hull = get_instance_hull();
 
            const size_t groups_to_check = regions_by_extruder.empty() ? 0 : 1;
            for (size_t group_id = 0; group_id < groups_to_check; ++group_id) {
                const std::vector<BedExcludeRegion> &extruder_regions = regions_by_extruder[group_id];
                for (const BedExcludeRegion &region_src : extruder_regions) {
                    if (mode != BedExcludeVolumeMode::Shared && region_src.is_collision_volume())
                        continue;
                    checked_config_regions = true;
                    Polygon region = region_src.polygon;
                    region.translate(plate_offset);
                    region.make_counter_clockwise();
 
                    if (intersection(Polygons{ region }, Polygons{ hull }).empty())
                        continue;
 
                    if (instance_box.max.z() < region_src.z_min || instance_box.min.z() > region_src.z_max)
                        continue;
 
                    BedExcludeRegion translated_region = region_src;
                    translated_region.polygon = std::move(region);
                    if (instance->intersects_bed_exclude_region(translated_region)) {
                        outside = true;
                        break;
                    }
                }
                if (outside)
                    break;
            }
        }
 
        if (!checked_config_regions && m_exclude_bounding_box.size() > 0) {
            const Polygon &hull = get_instance_hull();
            for (const BoundingBoxf3 &exclude_box : m_exclude_bounding_box) {
                Polygon p = exclude_box.polygon(true);  // instance convex hull is scaled, so we need to scale here
                if (!intersection({ p }, { hull }).empty()) {
                    outside = true;
                    break;
                }
            }
        }
  }
 
    // IDEX/IQEX placement check (prepare-mode bounding-box test).
    // Block objects that overlap secondary (copy/mirror) zones or the carriage
    // danger strip at the primary zone boundary.  Reuses the existing
    // outside=true → instance_outside_set → update_states() → blocks slicing path.
    if (!outside && (!m_imex_secondary_zone_boxes.empty() || !m_imex_collision_zones.empty()) &&
        imex_hull_violates(get_instance_hull()))
        outside = true;
 
  return outside;
}

References Slic3r::active_bed_exclude_volume_mode(), Slic3r::bounding_box(), Slic3r::ModelInstance::calc_print_volume_state(), config(), Slic3r::BoundingBox3Base< PointType >::contains(), Slic3r::ModelInstance::convex_hull_2d(), ensure_imex_zones(), Slic3r::get_bed_excluded_regions_by_extruder(), get_plate_box(), get_shape(), Slic3r::group_id(), imex_hull_violates(), Slic3r::intersection(), Slic3r::BoundingBox3Base< PointType >::intersects(), Slic3r::ModelInstance::intersects_bed_exclude_region(), m_exclude_bounding_box, m_extruder_areas, m_extruder_heights, m_height, m_imex_collision_zones, m_imex_secondary_zone_boxes, m_model, m_origin, m_plater, Slic3r::Polygon::make_counter_clockwise(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::ModelInstancePVS_Partly_Outside, open_belt_y(), Slic3r::BedExcludeRegion::polygon, scale_, Slic3r::Shared, Slic3r::SINKING_Z_THRESHOLD, and Slic3r::MultiPoint::translate().

Referenced by add_instance(), and update_instance_exclude_status().

Here is the call graph for this function:

Here is the caller graph for this function:

check_single_extruder_mixed_filament_risk()

bool Slic3r::GUI::PartPlate::check_single_extruder_mixed_filament_risk	(	const DynamicPrintConfig &	config,
		std::string &	warning_text ) const

{
    warning_text.clear();
 
    auto *nozzle_diameter_opt = config.option<ConfigOptionFloatsNullable>("nozzle_diameter");
    if (!nozzle_diameter_opt || nozzle_diameter_opt->values.size() > 1)
        return false;
 
    auto *is_mixed_opt = wxGetApp().preset_bundle->project_config.option<ConfigOptionBools>("filament_is_mixed");
    if (!is_mixed_opt || !has_any_mixed_filament(is_mixed_opt->values))
        return false;
 
    auto is_mixed_slot = [&](int extruder_1based) {
        size_t idx = (size_t)(extruder_1based - 1);
        return idx < is_mixed_opt->values.size() && is_mixed_opt->values[idx];
    };
 
    const std::string mixed_warn_msg = _u8L("Printing mixed-color filament on a single-extruder printer requires frequent filament changes and flushing, "
                                            "which may significantly increase waste and the risk of nozzle / waste-chute clogging.");
 
    for (int obj_idx = 0; obj_idx < (int)m_model->objects.size(); ++obj_idx) {
        if (!contain_any_instance_totally(obj_idx))
            continue;
        ModelObject *mo = m_model->objects[obj_idx];
        int obj_ext = mo->config.has("extruder") ? mo->config.extruder() : 1;
        if (is_mixed_slot(obj_ext)) {
            warning_text = mixed_warn_msg;
            return true;
        }
        for (ModelVolume *mv : mo->volumes) {
            int vol_ext = mv->config.has("extruder") ? mv->config.extruder() : obj_ext;
            if (is_mixed_slot(vol_ext)) {
                warning_text = mixed_warn_msg;
                return true;
            }
        }
    }
 
    return false;
}

References _u8L, config(), Slic3r::ModelObject::config, Slic3r::ModelVolume::config, contain_any_instance_totally(), Slic3r::ModelConfig::extruder(), Slic3r::ModelConfig::has(), Slic3r::has_any_mixed_filament(), m_model, Slic3r::ModelObject::volumes, and Slic3r::GUI::warning_text.

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

check_tpu_printable_status()

bool Slic3r::GUI::PartPlate::check_tpu_printable_status	(	const DynamicPrintConfig &	config,
		const std::vector< int > &	tpu_filaments )

{
  // do not limit the num of tpu filament in slicing
  return true;
}

References config().

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::CLI::run(), and Slic3r::GUI::Plater::validate_current_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void Slic3r::GUI::PartPlate::clear

(

bool

clear_sliced_result = true

)

{
  obj_to_instance_set.clear();
  instance_outside_set.clear();
    invalidate_exclusion_volume_preview();
  if (clear_sliced_result) {
    m_ready_for_slice = true;
    update_slice_result_valid_state(false);
  }
  invalidate_plate_name_texture();
  return;
}

References instance_outside_set, invalidate_exclusion_volume_preview(), invalidate_plate_name_texture(), m_ready_for_slice, obj_to_instance_set, and update_slice_result_valid_state().

Referenced by ~PartPlate(), Slic3r::GUI::PartPlateList::clear(), estimate_wipe_tower_polygon(), and set_pos_and_size().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_exclusion_volume_intersections()

void Slic3r::GUI::PartPlate::clear_exclusion_volume_intersections

(

)

{
    m_exclusion_volume_intersection_triangles.reset();
    m_exclusion_volume_intersections_cleared = true;
}

References m_exclusion_volume_intersection_triangles, and m_exclusion_volume_intersections_cleared.

clear_filament_map()

void Slic3r::GUI::PartPlate::clear_filament_map

(

)

{
    if (m_config.has("filament_map"))
        m_config.erase("filament_map");
    invalidate_exclusion_volume_preview();
}

References invalidate_exclusion_volume_preview(), and m_config.

Referenced by on_extruder_count_changed(), and set_filament_map_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_filament_map_mode()

void Slic3r::GUI::PartPlate::clear_filament_map_mode

(

)

{
    if (m_config.has("filament_map_mode"))
        m_config.erase("filament_map_mode");
}

References m_config.

Referenced by set_filament_map_mode().

Here is the caller graph for this function:

clear_filament_volume_map()

void Slic3r::GUI::PartPlate::clear_filament_volume_map

(

)

{
    if (m_config.has("filament_volume_map"))
        m_config.erase("filament_volume_map");
}

References m_config.

config()

DynamicPrintConfig * Slic3r::GUI::PartPlate::config ( )

inline

{ return &m_config; }

References m_config.

Referenced by Slic3r::GUI::PartPlateList::check_all_plate_local_bed_type(), check_compatible_of_nozzle_and_filament(), check_filament_printable(), check_mixture_filament_compatible(), check_mixture_of_pla_and_petg(), check_outside(), check_single_extruder_mixed_filament_risk(), check_tpu_printable_status(), Slic3r::GUI::collect_imex_warnings(), estimate_wipe_tower_footprint(), estimate_wipe_tower_polygon(), get_object_filament_extruders(), Slic3r::GUI::PartPlateList::notify_instance_update(), on_filament_map_mode_change(), Slic3r::GUI::Plater::open_platesettings_dialog(), Slic3r::CLI::run(), set_vase_mode_related_object_config(), update_exclusion_volume_preview_models(), and wipe_tower_obstacles().

Here is the caller graph for this function:

contain_any_instance_totally()

bool Slic3r::GUI::PartPlate::contain_any_instance_totally

(

int

obj_id

)

const

{
  if (obj_id < 0 || obj_id >= int(m_model->objects.size()))
    return false;
 
  const ModelObject *object = m_model->objects[obj_id];
  for (int instance_id = 0; instance_id < int(object->instances.size()); ++instance_id)
    if (contain_instance_totally(obj_id, instance_id))
      return true;
 
  return false;
}

References contain_instance_totally(), Slic3r::ModelObject::instances, and m_model.

Referenced by check_single_extruder_mixed_filament_risk(), estimate_wipe_tower_footprint(), get_extruders(), and get_extruders_without_support().

Here is the call graph for this function:

Here is the caller graph for this function:

contain_instance()

bool Slic3r::GUI::PartPlate::contain_instance	(	int	obj_id,
		int	instance_id )

{
  bool result = false;
  std::set<std::pair<int, int>>::iterator it;
 
  it = obj_to_instance_set.find(std::pair(obj_id, instance_id));
  if (it != obj_to_instance_set.end()) {
    result = true;
  }
 
  return result;
}

References obj_to_instance_set.

Referenced by Slic3r::GUI::PartPlateList::construct_objects_list_for_new_plate(), Slic3r::GUI::PartPlateList::find_instance(), get_instance(), Slic3r::GUI::Selection::get_volume_idxs_from_plate(), Slic3r::GUI::Plater::priv::on_select_preset(), Slic3r::GUI::ArrangeJob::prepare_partplate(), Slic3r::GUI::OrientJob::prepare_partplate(), Slic3r::GUI::GLCanvas3D::Labels::render(), and Slic3r::CLI::run().

Here is the caller graph for this function:

contain_instance_totally() [1/2]

bool Slic3r::GUI::PartPlate::contain_instance_totally	(	int	obj_id,
		int	instance_id ) const

{
  bool result = false;
  std::set<std::pair<int, int>>::iterator it;
 
  it = obj_to_instance_set.find(std::pair(obj_id, instance_id));
  if (it != obj_to_instance_set.end()) {
    it = instance_outside_set.find(std::pair(obj_id, instance_id));
    if (it == instance_outside_set.end())
      result = true;
  }
 
  return result;
}

References instance_outside_set, and obj_to_instance_set.

contain_instance_totally() [2/2]

bool Slic3r::GUI::PartPlate::contain_instance_totally	(	ModelObject *	object,
		int	instance_id ) const

{
  bool result = false;
  int obj_id = -1;
 
  for (int index = 0; index < m_model->objects.size(); index ++)
  {
    if (m_model->objects[index] == object)
    {
      obj_id = index;
      break;
    }
  }
 
  if ((obj_id >= 0 ) && (obj_id < m_model->objects.size()))
    result = contain_instance_totally(obj_id, instance_id);
 
  return result;
}

References contain_instance_totally(), and m_model.

Referenced by Slic3r::GUI::ObjectDataViewModel::AddPlate(), contain_any_instance_totally(), contain_instance_totally(), Slic3r::GUI::ensure_belt_purge_tower(), estimate_wipe_tower_footprint(), Slic3r::GUI::PartPlateList::find_instance_belongs(), Slic3r::GUI::Sidebar::has_broken_mixed_filament(), and Slic3r::GUI::Plater::priv::replace_all_with_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

contains() [1/3]

bool Slic3r::GUI::PartPlate::contains

(

const BoundingBoxf3 &

bb

)

const

{
  // Allow the objects to protrude below the print bed
  BoundingBoxf3 print_volume(Vec3d(m_bounding_box.min(0), m_bounding_box.min(1), 0.0), Vec3d(m_bounding_box.max(0), m_bounding_box.max(1), 1e3));
  print_volume.min(2) = -1e10;
  print_volume.min(0) -= Slic3r::BuildVolume::BedEpsilon;
  print_volume.min(1) -= Slic3r::BuildVolume::BedEpsilon;
  print_volume.max(0) += Slic3r::BuildVolume::BedEpsilon;
  print_volume.max(1) += Slic3r::BuildVolume::BedEpsilon;
  this->open_belt_y(print_volume);
  return print_volume.contains(bb);
}

References Slic3r::BuildVolume::BedEpsilon, Slic3r::BoundingBox3Base< PointType >::contains(), m_bounding_box, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and open_belt_y().

Here is the call graph for this function:

contains() [2/3]

bool Slic3r::GUI::PartPlate::contains

(

const GLVolume &

v

)

const

{
  return m_bounding_box.contains(v.bounding_box());
}

References Slic3r::GLVolume::bounding_box(), and m_bounding_box.

Here is the call graph for this function:

contains() [3/3]

bool Slic3r::GUI::PartPlate::contains

(

const Vec3d &

point

)

const

{
  return m_bounding_box.contains(point);
}

References m_bounding_box.

copy_id()

void Slic3r::ObjectBase::copy_id ( const ObjectBase & rhs )

inlineprotectedinherited

{ m_id = rhs.id(); }

References ObjectBase(), id(), and m_id.

Referenced by Slic3r::CutObjectBase::copy().

Here is the call graph for this function:

Here is the caller graph for this function:

duplicate_all_instance()

void Slic3r::GUI::PartPlate::duplicate_all_instance	(	unsigned int	dup_count,
		bool	need_skip,
		std::map< int, bool > &	skip_objects )

{
    std::set<std::pair<int, int>> old_obj_list = obj_to_instance_set;
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": plate_id %1%, dup_count %2%") % m_plate_index % dup_count;
    for (std::set<std::pair<int, int>>::iterator it = old_obj_list.begin(); it != old_obj_list.end(); ++it)
    {
        int obj_id = it->first;
        int instance_id = it->second;
 
        if (valid_instance(obj_id, instance_id))
        {
            ModelObject* object = m_model->objects[obj_id];
            ModelInstance* instance = object->instances[instance_id];
 
            if (need_skip)
            {
                if (skip_objects.find(instance->loaded_id) != skip_objects.end())
                {
                    instance->printable = false;
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": skipped object, loaded_id %1%, name %2%, set to unprintable, no need to duplicate") % instance->loaded_id % object->name;
                    continue;
                }
            }
            for (size_t index = 0; index < dup_count; index ++)
            {
                ModelObject* newObj = m_model->add_object(*object);
                newObj->name = object->name +"_"+ std::to_string(index+1);
                int new_obj_id = m_model->objects.size() - 1;
                for ( size_t new_instance_id = 0; new_instance_id < newObj->instances.size(); new_instance_id++ )
                {
                    obj_to_instance_set.emplace(std::pair(new_obj_id, new_instance_id));
                    invalidate_exclusion_volume_preview();
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": duplicate object into plate: index_pair [%1%,%2%], obj_id %3%") % new_obj_id % new_instance_id % newObj->id().id;
                }
            }
        }
    }
 
    for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it)
    {
        int obj_id = it->first;
        int instance_id = it->second;
 
        if (valid_instance(obj_id, instance_id))
        {
            ModelObject* object = m_model->objects[obj_id];
            ModelInstance* instance = object->instances[instance_id];
 
            if (instance->printable)
            {
                instance->loaded_id = instance->id().id;
                if (need_skip) {
                    while (skip_objects.find(instance->loaded_id) != skip_objects.end())
                    {
                        instance->loaded_id ++;
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": duplicated id %1% with skip, try new one %2%") %instance->id().id  % instance->loaded_id;
                    }
                }
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": set obj %1% instance %2%'s loaded_id to its id %3%, name %4%") % obj_id %instance_id %instance->loaded_id  % object->name;
            }
        }
    }
 
    return;
}

References Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::ModelObject::instances, invalidate_exclusion_volume_preview(), Slic3r::ModelInstance::loaded_id, m_model, m_plate_index, Slic3r::ModelObject::name, obj_to_instance_set, Slic3r::ModelInstance::printable, and valid_instance().

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

bool Slic3r::GUI::PartPlate::empty ( )

inline

{ return obj_to_instance_set.empty(); }

References obj_to_instance_set.

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), is_valid_gcode_file(), Slic3r::GUI::ArrangeJob::prepare_partplate(), Slic3r::GUI::OrientJob::prepare_partplate(), and update_exclusion_volume_preview_models().

Here is the caller graph for this function:

ensure_imex_ghosts()

void Slic3r::GUI::PartPlate::ensure_imex_ghosts ( )

private

{
    std::string key = build_imex_ghost_cache_key();
    if (key != m_imex_ghost_cache_key) {
        m_imex_ghost_cache_key = key;
        calc_imex_ghosts();
    }
}

References build_imex_ghost_cache_key(), calc_imex_ghosts(), and m_imex_ghost_cache_key.

Referenced by render_imex_zones().

Here is the call graph for this function:

Here is the caller graph for this function:

ensure_imex_zones()

void Slic3r::GUI::PartPlate::ensure_imex_zones ( )

private

{
    // CLI / headless slice: no GUI_App, no plater, no IMEX state to track. Bail out
    // before touching `wxGetApp()` (which segfaults without a GUI_App) — placement
    // checks reach this from the headless 3MF-load path through `check_outside`.
    if (!m_plater) return;
    std::string cache_key = build_imex_cache_key();
    if (cache_key != m_imex_zones_mode_cache) {
        m_imex_zones_mode_cache = cache_key;
        calc_imex_zones();
    }
}

References build_imex_cache_key(), calc_imex_zones(), m_imex_zones_mode_cache, and m_plater.

Referenced by calc_imex_ghosts(), check_outside(), imex_placement_violation(), imex_primary_zone(), render_imex_zones(), and update_imex_ghost_transforms().

Here is the call graph for this function:

Here is the caller graph for this function:

estimate_wipe_tower_footprint()

WipeTowerFootprint Slic3r::GUI::PartPlate::estimate_wipe_tower_footprint	(	const DynamicPrintConfig &	config,
		int	plate_extruder_size = 0,
		bool	use_global_objects = false ) const

{
    // The CLI calls this too, so the plate's filaments are derived from the passed config:
    // get_extruders(bool) reads the same keys off wxGetApp()'s presets, which the CLI has none of.
    // An explicit count is a floor: init-time and arrange estimates size an empty plate for that
    // many generic filaments, the lowest ids not already on the plate.
    std::vector<int> plate_extruders = get_extruders(true, config, config);
    for (int id = 1; int(plate_extruders.size()) < plate_extruder_size; ++id)
        if (std::find(plate_extruders.begin(), plate_extruders.end(), id) == plate_extruders.end())
            plate_extruders.push_back(id);
    // The wipe tower filament joins the tool ordering even when unused (Print::extruders), so
    // validation counts it - but only where there is a tower to join, which is the
    // has_wipe_tower() half of that guard.
    const ConfigOption *wipe_tower_filament_opt = config.option("wipe_tower_filament");
    const ConfigOption *enable_prime_tower_opt  = config.option("enable_prime_tower");
    const int           wipe_tower_filament     = wipe_tower_filament_opt != nullptr ? wipe_tower_filament_opt->getInt() : 0;
    if (enable_prime_tower_opt != nullptr && enable_prime_tower_opt->getBool() && plate_extruders.size() > 1 && wipe_tower_filament > 0 &&
        std::find(plate_extruders.begin(), plate_extruders.end(), wipe_tower_filament) == plate_extruders.end())
        plate_extruders.push_back(wipe_tower_filament);
    if (plate_extruders.empty())
        return WipeTowerFootprint();
 
    // Tallest object on this plate and the thinnest layer it is sliced at, resolved per object
    // as PrintObject resolves them (override, else preset) and over this plate's objects only -
    // seeding from the global value, or folding in an off-plate override, diverges from Print.
    const ConfigOption *layer_height_opt    = config.option("layer_height");
    const double        global_layer_height = layer_height_opt != nullptr ? layer_height_opt->getFloat() : 0.08;
    double              max_height          = 0.;
    double              layer_height        = std::numeric_limits<double>::max();
    for (int obj_idx = 0; obj_idx < int(m_model->objects.size()); ++obj_idx) {
        const ModelObject *object = m_model->objects[obj_idx];
        if (!use_global_objects && !contain_any_instance_totally(obj_idx))
            continue;
        // Per instance, to match PrintObject::size(); the union over instances differs once
        // they are rotated apart. The cached convex hull has the mesh's z extent and is cheap
        // enough for every scene reload.
        for (int inst_idx = 0; inst_idx < int(object->instances.size()); ++inst_idx) {
            if (!use_global_objects && !contain_instance_totally(obj_idx, inst_idx))
                continue;
            max_height = std::max(max_height, object->instance_convex_hull_bounding_box(inst_idx, true).size().z());
        }
        const ConfigOption *object_layer_height = object->config.option("layer_height");
        layer_height = std::min(layer_height, object_layer_height != nullptr ? object_layer_height->getFloat() : global_layer_height);
    }
    if (layer_height == std::numeric_limits<double>::max())
        layer_height = global_layer_height;
 
    std::vector<unsigned int> filament_ids;
    for (int id : plate_extruders)
        if (id > 0)
            filament_ids.push_back(static_cast<unsigned int>(id - 1));
    return Slic3r::estimate_wipe_tower_footprint(config, resolve_wipe_tower_type(config), filament_ids, layer_height, max_height);
}

References config(), contain_any_instance_totally(), contain_instance_totally(), Slic3r::estimate_wipe_tower_footprint(), Slic3r::filament_ids(), get_extruders(), Slic3r::ConfigOption::getBool(), Slic3r::ConfigOption::getFloat(), Slic3r::ConfigOption::getInt(), Slic3r::ObjectBase::id(), Slic3r::ModelObject::instance_convex_hull_bounding_box(), Slic3r::ModelObject::instances, Slic3r::GUI::layer_height, m_model, Slic3r::resolve_wipe_tower_type(), and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by estimate_wipe_tower_polygon(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::CLI::run(), and Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

estimate_wipe_tower_polygon()

arrangement::ArrangePolygon Slic3r::GUI::PartPlate::estimate_wipe_tower_polygon	(	const DynamicPrintConfig &	config,
		int	plate_index,
		Vec3d &	wt_pos,
		Vec3d &	wt_size,
		int	plate_extruder_size = 0,
		bool	use_global_objects = false,
		WipeTowerRelocation *	relocation = nullptr ) const

{
  float x = dynamic_cast<const ConfigOptionFloats*>(config.option("wipe_tower_x"))->get_at(plate_index);
  float y = dynamic_cast<const ConfigOptionFloats*>(config.option("wipe_tower_y"))->get_at(plate_index);
  //float a = dynamic_cast<const ConfigOptionFloat*>(config.option("wipe_tower_rotation_angle"))->value;
  const WipeTowerFootprint footprint = estimate_wipe_tower_footprint(config, plate_extruder_size, use_global_objects);
  wt_size = Vec3d(footprint.width, footprint.depth, footprint.height);
  int plate_width=m_width, plate_depth=m_depth;
  float w = wt_size(0); // effective width; differs from prime_tower_width when the rib wall squares the tower
  float depth = wt_size(1);
  // Resolved brim, not the raw option: "Auto" (-1) would yield a margin of 0 and let the
  // clamp put the brim off the bed. Matches set_default_wipe_tower_pos_for_plate.
  float wp_brim_width = float(footprint.brim_width);
  // A Type2 stabilization cone bulges past the body box like a brim does - fold its worst-axis
  // bulge into the same margin.
  const BoundingBox outline = get_extents(estimate_wipe_tower_first_layer_outline(config, resolve_wipe_tower_type(config), w, depth, wt_size.z()));
  wp_brim_width += float(std::max({0., unscaled(outline.max.x()) - w, unscaled(outline.max.y()) - depth, -unscaled(outline.min.x()), -unscaled(outline.min.y())}));
  // A position valid by WIPE_TOWER_MARGIN is the user's choice and stays untouched; an
  // invalid one is re-placed with the comfort margin (falling back to the validity bounds
  // on cramped plates). std::clamp is UB if lo > hi, so keep every hi >= lo.
  const float margin = WIPE_TOWER_MARGIN + wp_brim_width;
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("arrange wipe_tower: wp_brim_width %1%") % wp_brim_width;
  const float x_hi   = std::max(margin, (float) plate_width - w - margin);
  const float y_hi   = std::max(margin, (float) plate_depth - depth - margin);
  const float margin_c = (float) WIPE_TOWER_AUTO_MARGIN + wp_brim_width;
  float x_lo_c = margin_c, x_hi_c = (float) plate_width - w - margin_c;
  if (x_lo_c > x_hi_c) { x_lo_c = margin; x_hi_c = x_hi; }
  float y_lo_c = margin_c, y_hi_c = (float) plate_depth - depth - margin_c;
  if (y_lo_c > y_hi_c) { y_lo_c = margin; y_hi_c = y_hi; }
  // Drag clamps reach this limit through the volume's bounding box (post-slice: the real
  // mesh, a couple of mm inside this reserved estimate), so a drop can land slightly out
  // of bounds — snap it onto the bound; only far-out positions get the comfort re-place.
  const float tol = 5.f;
  const float saved_x = x, saved_y = y;
  const bool  replace_x = x < margin - tol || x > x_hi + tol;
  const bool  replace_y = y < margin - tol || y > y_hi + tol;
  x = replace_x ? std::clamp(x, x_lo_c, x_hi_c) : std::clamp(x, margin, x_hi);
  y = replace_y ? std::clamp(y, y_lo_c, y_hi_c) : std::clamp(y, margin, y_hi);
  if (relocation != nullptr && (replace_x || replace_y)) {
    relocation->moved = true;
    // The footprint keeps clear of every object and its brim, and turns about its anchor
    // as the tower does.
    Polygon tower({ {scaled(-wp_brim_width), scaled(-wp_brim_width)},
                    {scaled(w + wp_brim_width), scaled(-wp_brim_width)},
                    {scaled(w + wp_brim_width), scaled(depth + wp_brim_width)},
                    {scaled(-wp_brim_width), scaled(depth + wp_brim_width)} });
    if (const auto *rotation = config.option<ConfigOptionFloat>("wipe_tower_rotation_angle"); rotation != nullptr && rotation->value != 0.)
      tower.rotate(Geometry::deg2rad(rotation->value));
    const Polygons objects = wipe_tower_obstacles(config);
    const Point    placed(scaled(x), scaled(y));
    // The re-placed spot stands when it is clear. Otherwise take the clear spot nearest the
    // saved position, keeping the comfort margin where the plate leaves room for it.
    if (!nearest_clear_wipe_tower_anchor(BoundingBox(placed, placed), tower, objects, placed)) {
      const Point saved(scaled(saved_x), scaled(saved_y));
      std::optional<Point> clear = nearest_clear_wipe_tower_anchor(
        BoundingBox(Point(scaled(x_lo_c), scaled(y_lo_c)), Point(scaled(x_hi_c), scaled(y_hi_c))), tower, objects, saved);
      if (!clear)
        clear = nearest_clear_wipe_tower_anchor(BoundingBox(Point(scaled(margin), scaled(margin)), Point(scaled(x_hi), scaled(y_hi))),
                                                tower, objects, saved);
      if (clear) {
        x = static_cast<float>(unscaled(clear->x()));
        y = static_cast<float>(unscaled(clear->y()));
      } else {
        relocation->overlaps_objects = true;
      }
    }
  }
    wt_pos(0) = x;
    wt_pos(1) = y;
    wt_pos(2) = 0.f;
 
  arrangement::ArrangePolygon wipe_tower_ap;
  Polygon ap({
    {scaled(x - wp_brim_width), scaled(y - wp_brim_width)},
    {scaled(x + w + wp_brim_width), scaled(y - wp_brim_width)},
    {scaled(x + w + wp_brim_width), scaled(y + depth + wp_brim_width)},
    {scaled(x - wp_brim_width), scaled(y + depth + wp_brim_width)}
    });
  wipe_tower_ap.bed_idx = plate_index;
  wipe_tower_ap.setter = NULL; // do not move wipe tower
 
  wipe_tower_ap.poly.contour = std::move(ap);
  wipe_tower_ap.translation = { scaled(0.f), scaled(0.f) };
  //wipe_tower_ap.rotation = a;
  wipe_tower_ap.name = "WipeTower";
  wipe_tower_ap.is_virt_object = true;
  wipe_tower_ap.is_wipe_tower = true;
 
  return wipe_tower_ap;
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::WipeTowerFootprint::brim_width, clear(), config(), Slic3r::ExPolygon::contour, Slic3r::Geometry::deg2rad(), Slic3r::WipeTowerFootprint::depth, Slic3r::estimate_wipe_tower_first_layer_outline(), estimate_wipe_tower_footprint(), Slic3r::get_extents(), Slic3r::WipeTowerFootprint::height, Slic3r::arrangement::ArrangePolygon::is_virt_object, Slic3r::arrangement::ArrangePolygon::is_wipe_tower, m_depth, m_width, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::GUI::WipeTowerRelocation::moved, Slic3r::arrangement::ArrangePolygon::name, Slic3r::nearest_clear_wipe_tower_anchor(), Slic3r::GUI::WipeTowerRelocation::overlaps_objects, Slic3r::arrangement::ArrangePolygon::poly, Slic3r::resolve_wipe_tower_type(), Slic3r::MultiPoint::rotate(), Slic3r::scaled(), Slic3r::arrangement::ArrangePolygon::setter, Slic3r::arrangement::ArrangePolygon::translation, Slic3r::unscaled(), Slic3r::ConfigOptionSingle< T >::value, Slic3r::WipeTowerFootprint::width, WIPE_TOWER_AUTO_MARGIN, WIPE_TOWER_MARGIN, and wipe_tower_obstacles().

Referenced by Slic3r::GUI::estimate_wipe_tower_info(), imex_wipe_tower_hull(), Slic3r::GUI::GLCanvas3D::reload_scene(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

exclusion_volume_preview_cache_key()

std::string Slic3r::GUI::PartPlate::exclusion_volume_preview_cache_key ( const std::vector< BedExcludeRegion > & regions ) const

private

{
    std::ostringstream key;
    key << std::setprecision(17);
    key << "plate:" << m_origin.x() << ',' << m_origin.y() << ',' << m_height << ';';
 
    key << "regions:" << regions.size() << ';';
    for (const BedExcludeRegion &region : regions) {
        key << region.z_min << ".." << region.z_max << ':'
            << int(region.purpose) << ':' << region.has_z_range << ':'
            << region.polygon.points.size();
        for (const Point &point : region.polygon.points)
            key << ',' << point.x() << 'x' << point.y();
        key << ';';
    }
 
    key << "instances:" << obj_to_instance_set.size() << ';';
    if (m_model != nullptr) {
        for (const std::pair<int, int> &object_instance : obj_to_instance_set) {
            const int obj_id = object_instance.first;
            const int instance_id = object_instance.second;
            key << obj_id << ':' << instance_id << ':';
            if (obj_id < 0 || obj_id >= int(m_model->objects.size())) {
                key << "invalid;";
                continue;
            }
 
            const ModelObject *object = m_model->objects[obj_id];
            if (instance_id < 0 || instance_id >= int(object->instances.size())) {
                key << "invalid;";
                continue;
            }
 
            const ModelInstance *instance = object->instances[instance_id];
            key << static_cast<const void*>(object) << ':' << static_cast<const void*>(instance) << ':'
                << object->volumes.size() << ':' << instance->printable << ':';
 
            const Transform3d instance_matrix = instance->get_matrix();
            for (int r = 0; r < int(instance_matrix.matrix().rows()); ++r)
                for (int c = 0; c < int(instance_matrix.matrix().cols()); ++c)
                    key << instance_matrix.matrix()(r, c) << ',';
 
            for (const ModelVolume *volume : object->volumes) {
                key << static_cast<const void*>(volume) << ':';
                for (const int filament_id : volume->get_extruders())
                    key << 'f' << filament_id << ',';
                const Transform3d volume_matrix = volume->get_matrix();
                for (int r = 0; r < int(volume_matrix.matrix().rows()); ++r)
                    for (int c = 0; c < int(volume_matrix.matrix().cols()); ++c)
                        key << volume_matrix.matrix()(r, c) << ',';
            }
            key << ';';
        }
    }
 
    return key.str();
}

References Slic3r::ModelVolume::get_extruders(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::ModelObject::instances, m_height, m_model, m_origin, obj_to_instance_set, Slic3r::ModelInstance::printable, and Slic3r::ModelObject::volumes.

Referenced by update_exclusion_volume_preview_models().

Here is the call graph for this function:

Here is the caller graph for this function:

fff_print()

Print * Slic3r::GUI::PartPlate::fff_print ( )

inline

{ return m_print; }

References m_print.

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene(), and Slic3r::GUI::SelectMachineDialog::start_timelapse_storage_check().

Here is the caller graph for this function:

generate_exclude_polygon()

void Slic3r::GUI::PartPlate::generate_exclude_polygon ( ExPolygon & exclude_polygon )

private

{
  auto compute_exclude_points = [&exclude_polygon](Vec2d& center, double radius, double start_angle, double stop_angle, int count)
  {
    double angle_steps;
    angle_steps = (stop_angle - start_angle) / (count - 1);
    for(int j = 0; j < count; j++ )
    {
      double angle = start_angle + j * angle_steps;
      double x = center(0) + ::cos(angle) * radius;
      double y = center(1) + ::sin(angle) * radius;
      exclude_polygon.contour.append({ scale_(x), scale_(y) });
    }
  };
 
  int points_count = 8;
  if (m_exclude_area.size() == 4)
  {
    //rectangle case
    for (int i = 0; i < 4; i++)
    {
      const Vec2d& p = m_exclude_area[i];
      Vec2d center;
      double start_angle, stop_angle, radius;
      radius = 1.f; // ORCA use equal rounding for all corners
      switch (i) {
        case 0: // Left-Bottom
          center(0)   = p(0) + radius;
          center(1)   = p(1) + radius;
          start_angle = 1.0 * PI; //180
          stop_angle  = 1.5 * PI; //270
          compute_exclude_points(center, radius, start_angle, stop_angle, points_count);
        break;
        case 1: // Right-Bottom
          center(0)   = p(0) - radius;
          center(1)   = p(1) + radius;
          start_angle = 1.5 * PI; //270
          stop_angle  = 2.0 * PI; //360
          compute_exclude_points(center, radius, start_angle, stop_angle, points_count);
          break;
        case 2: // Right-Top
          center(0)   = p(0) - radius;
          center(1)   = p(1) - radius;
          start_angle = 0.0 * PI; //0
          stop_angle  = 0.5 * PI; //90
          compute_exclude_points(center, radius, start_angle, stop_angle, points_count);
          break;
        case 3: // Left-Top
          center(0)   = p(0) + radius;
          center(1)   = p(1) - radius;
          start_angle = 0.5 * PI; //90
          stop_angle  = 1.0 * PI; //180
          compute_exclude_points(center, radius, start_angle, stop_angle, points_count);
          break;
      }
    }
  }
  else {
    for (const Vec2d& p : m_exclude_area) {
      exclude_polygon.contour.append({ scale_(p(0)), scale_(p(1)) });
    }
  }
 
  exclude_polygon.contour.make_counter_clockwise();
}

References Slic3r::angle(), Slic3r::MultiPoint::append(), Slic3r::center(), Slic3r::ExPolygon::contour, count, m_exclude_area, Slic3r::Polygon::make_counter_clockwise(), PI, and scale_.

Referenced by set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_logo_polygon()

void Slic3r::GUI::PartPlate::generate_logo_polygon ( ExPolygon & logo_polygon )

private

{
  if (m_shape.size() == 4)
  {
        bool is_bbl_vendor = false;
 
    if (m_plater) {
            if (auto preset_bundle = wxGetApp().preset_bundle; preset_bundle)
                is_bbl_vendor = preset_bundle->is_bbl_vendor();
    }
 
        //rectangle case
    for (int i = 0; i < 4; i++)
    {
      const Vec2d& p = m_shape[i];
      if ((i  == 0) || (i  == 1)) {
                logo_polygon.contour.append({scale_(p(0)), scale_(is_bbl_vendor ? p(1) - 12.f : p(1))});
            }
      else {
        logo_polygon.contour.append({ scale_(p(0)), scale_(p(1)) });
      }
    }
  }
  else {
    for (const Vec2d& p : m_shape) {
      logo_polygon.contour.append({ scale_(p(0)), scale_(p(1)) });
    }
  }
}

References Slic3r::MultiPoint::append(), Slic3r::ExPolygon::contour, m_plater, m_shape, and scale_.

Referenced by set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_new_id()

ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

{ return ObjectID(++ s_last_id); }

References s_last_id.

Referenced by ObjectBase(), and set_new_unique_id().

Here is the caller graph for this function:

generate_plate_name_texture()

void Slic3r::GUI::PartPlate::generate_plate_name_texture

(

)

{
  auto canvas = this->m_partplate_list->m_plater->get_view3D_canvas3D();
  if (canvas == nullptr)
    return;
 
    m_plate_name_icon.reset();
 
  // generate m_name_texture texture from m_name with generate_from_text_string
  m_name_texture.reset();
  auto text = m_name.empty()? _L("Untitled") : from_u8(m_name);
 
    // ORCA also scale font size to prevent low res texture
    int size = wxGetApp().em_unit() * PARTPLATE_EDIT_PLATE_NAME_ICON_SIZE;
    auto l = Label::sysFont(size, true);
    wxFont* font = &l;
 
  wxColour foreground(0xf2, 0x75, 0x4e, 0xff);
  if (!m_name_texture.generate_from_text_string(text.ToUTF8().data(), *font, *wxBLACK, foreground)) {
    BOOST_LOG_TRIVIAL(error) << "PartPlate::generate_plate_name_texture(): generate_from_text_string() failed";
    return;
  }
 
    ExPolygon poly;
    auto  bed_ext  = get_extents(m_shape);
    Vec2d p        = bed_ext[3];
    float factor   = icon_scale_factor();
    float icon_sz  = factor * PARTPLATE_EDIT_PLATE_NAME_ICON_SIZE;
    float width    = icon_sz * m_name_texture.get_width() / m_name_texture.get_height(); // icon size * text_bb_ratio
    float height   = icon_sz; // scale with icon size to preserve ratio while system scaling
    float offset_y = factor * PARTPLATE_TEXT_OFFSET_Y;
 
    //if (m_plater && m_plater->get_build_volume_type() == BuildVolume_Type::Circle)
    //    px = scale_(bed_ext.center()(0)) - (width + height) / 2.00;
 
    p += Vec2d(0, offset_y);
 
    poly.contour.append({ scale_(p(0)        ), scale_(p(1)         ) });
    poly.contour.append({ scale_(p(0) + width), scale_(p(1)         ) });
    poly.contour.append({ scale_(p(0) + width), scale_(p(1) + height) });
    poly.contour.append({ scale_(p(0)        ), scale_(p(1) + height) });
 
    if (!init_model_from_poly(m_plate_name_icon, poly, GROUND_Z))
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Unable to generate geometry buffers for icons\n";
 
    canvas->remove_raycasters_for_picking(SceneRaycaster::EType::Bed, picking_id_component(6));
    calc_vertex_for_plate_name_edit_icon(&m_name_texture, 0, m_plate_name_edit_icon);
    register_model_for_picking(*canvas, m_plate_name_edit_icon, picking_id_component(6));
}

References _L, Slic3r::GUI::SceneRaycaster::Bed, calc_vertex_for_plate_name_edit_icon(), Slic3r::GUI::from_u8(), Slic3r::get_extents(), GROUND_Z, icon_scale_factor(), Slic3r::GUI::init_model_from_poly(), m_name, m_name_texture, m_partplate_list, m_plate_name_edit_icon, m_plate_name_icon, m_shape, PARTPLATE_EDIT_PLATE_NAME_ICON_SIZE, PARTPLATE_TEXT_OFFSET_Y, picking_id_component(), Slic3r::GUI::register_model_for_picking(), scale_, and Label::sysFont().

Referenced by render_plate_name_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_print_polygon()

void Slic3r::GUI::PartPlate::generate_print_polygon ( ExPolygon & print_polygon )

private

{
  auto compute_points = [&print_polygon](Vec2d& center, double radius, double start_angle, double stop_angle, int count)
  {
    double angle_steps;
    angle_steps = (stop_angle - start_angle) / (count - 1);
    for(int j = 0; j < count; j++ )
    {
      double angle = start_angle + j * angle_steps;
      double x = center(0) + ::cos(angle) * radius;
      double y = center(1) + ::sin(angle) * radius;
      print_polygon.contour.append({ scale_(x), scale_(y) });
    }
  };
 
  for (const Vec2d& p : m_shape) {
      print_polygon.contour.append({scale_(p(0)), scale_(p(1))});
    }
}

References Slic3r::angle(), Slic3r::MultiPoint::append(), Slic3r::center(), Slic3r::ExPolygon::contour, count, m_shape, and scale_.

Referenced by calc_imex_zones(), and set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

get_bed_type()

BedType Slic3r::GUI::PartPlate::get_bed_type

(

bool

load_from_project = false

)

const

{
  std::string bed_type_key = "curr_bed_type";
 
  if (m_config.has(bed_type_key)) {
    BedType bed_type = m_config.opt_enum<BedType>(bed_type_key);
    return bed_type;
  }
 
  if (!load_from_project || !m_plater || !wxGetApp().preset_bundle)
    return btDefault;
 
  DynamicConfig& proj_cfg = wxGetApp().preset_bundle->project_config;
  if (proj_cfg.has(bed_type_key))
    return proj_cfg.opt_enum<BedType>(bed_type_key);
  return btDefault;
}

References Slic3r::btDefault, Slic3r::ConfigOptionResolver::has(), m_config, m_plater, and Slic3r::DynamicConfig::opt_enum().

Referenced by Slic3r::GUI::Plater::open_platesettings_dialog(), Slic3r::GUI::PrintJob::process(), render_icons(), render_logo(), Slic3r::GUI::SendMultiMachinePage::request_params(), Slic3r::CLI::run(), and set_bed_type().

Here is the call graph for this function:

Here is the caller graph for this function:

get_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::PartPlate::get_bounding_box ( bool extended = false )

inline

{ return extended ? m_extended_bounding_box : m_bounding_box; }

References m_bounding_box, and m_extended_bounding_box.

Referenced by Slic3r::GUI::GLCanvas3D::_current_plate_box(), Slic3r::GUI::GLCanvas3D::_update_inactive_plates_visibility(), Slic3r::GUI::GLCanvas3D::get_camera_pan_anchor(), Slic3r::GUI::GLCanvas3D::plate_scene_bounding_box(), Slic3r::CLI::run(), Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate(), and Slic3r::GUI::GLCanvas3D::zoom_to_plate().

Here is the caller graph for this function:

get_bounding_box_crd()

const BoundingBox Slic3r::GUI::PartPlate::get_bounding_box_crd

(

)

{
  const auto plate_shape = Slic3r::Polygon::new_scale(m_shape);
 
  return plate_shape.bounding_box();
}

References m_shape, and Slic3r::Polygon::new_scale().

Referenced by Slic3r::GUI::FillBedJob::prepare(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), and Slic3r::GUI::GLCanvas3D::update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

get_build_volume()

BoundingBoxf3 Slic3r::GUI::PartPlate::get_build_volume

(

bool

use_share = false

)

{
    auto  eps=Slic3r::BuildVolume::SceneEpsilon;
  Vec3d up_point;
  Vec3d low_point;
  if (use_share && !m_extruder_areas.empty()) {
    Polygon bed_poly = get_shared_poly(m_extruder_areas);
    BoundingBox bbox = bed_poly.bounding_box();
 
    up_point = Vec3d(unscale_(bbox.max.x()) + eps,  unscale_(bbox.max.y()) + eps, m_origin.z() + m_height + eps);
    low_point = Vec3d(unscale_(bbox.min.x()) - eps, unscale_(bbox.min.y()) - eps, m_origin.z() - eps);
  }
  else {
    // Orca: support non-rectangular bed
    up_point  = m_bounding_box.max + Vec3d(eps, eps, m_origin.z() + m_height + eps);
    low_point = m_bounding_box.min + Vec3d(-eps, -eps, m_origin.z() - eps);
  }
    BoundingBoxf3 plate_box(low_point, up_point);
    return plate_box;
}

References Slic3r::MultiPoint::bounding_box(), Slic3r::get_shared_poly(), m_bounding_box, m_extruder_areas, m_height, m_origin, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BuildVolume::SceneEpsilon, and unscale_.

Referenced by Slic3r::GUI::GLCanvas3D::get_empty_cells(), Slic3r::GUI::Plater::get_empty_cells(), get_plate_box(), Slic3r::GUI::Selection::paste_objects_from_clipboard(), Slic3r::GUI::GLCanvas3D::render_thumbnail_internal(), and Slic3r::GUI::Plater::priv::scale_selection_to_fit_print_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

get_center_origin()

Vec3d Slic3r::GUI::PartPlate::get_center_origin

(

)

{
  Vec3d origin;
 
  origin(0) = (m_bounding_box.min(0) + m_bounding_box.max(0)) / 2;//m_origin.x() + m_width / 2;
  origin(1) = (m_bounding_box.min(1) + m_bounding_box.max(1)) / 2; //m_origin.y() + m_depth / 2;
  origin(2) = m_origin.z();
 
  return origin;
}

References m_bounding_box, and m_origin.

Referenced by add_instance(), Slic3r::GUI::MenuFactory::append_menu_item_center(), Slic3r::GUI::Selection::center(), Slic3r::GUI::Selection::center_plate(), Slic3r::GUI::Plater::priv::on_select_preset(), and Slic3r::GUI::Plater::priv::scale_selection_to_fit_print_volume().

Here is the caller graph for this function:

get_effective_exclusion_filament_maps()

std::vector< int > Slic3r::GUI::PartPlate::get_effective_exclusion_filament_maps	(	const DynamicConfig &	g_config,
		size_t	filament_count,
		size_t	extruder_count ) const

{
    std::vector<int> result(filament_count, 0);
    if (extruder_count == 0)
        return result;
 
    const std::vector<int> configured_map = get_real_filament_maps(g_config);
    const FilamentMapMode map_mode = get_real_filament_map_mode(g_config);
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    const bool is_bambu = preset_bundle != nullptr && preset_bundle->is_bbl_vendor();
    const bool automatic = is_auto_filament_map_mode(map_mode);
    const bool automatic_map_resolved = !automatic || !get_filament_maps().empty();
    for (size_t filament_id = 0; filament_id < filament_count; ++filament_id) {
        const int extruder_id = bed_exclusion_extruder_for_filament(
            filament_id, configured_map, map_mode, is_bambu, automatic_map_resolved, extruder_count);
        if (extruder_id >= 0)
            result[filament_id] = extruder_id + 1;
    }
    return result;
}

References Slic3r::bed_exclusion_extruder_for_filament(), get_filament_maps(), get_real_filament_map_mode(), get_real_filament_maps(), Slic3r::is_auto_filament_map_mode(), and Slic3r::PresetBundle::is_bbl_vendor().

Referenced by get_object_filament_extruders(), and update_exclusion_volume_preview_models().

Here is the call graph for this function:

Here is the caller graph for this function:

get_effective_imex_mode()

std::string Slic3r::GUI::PartPlate::get_effective_imex_mode

(

)

const

{
    // Per-plate mode takes priority over the process preset; set_imex_mode() erases the
    // key on Primary, which is what lets the preset's value survive the config merge and
    // reach the slicer. Resolve it the same way here.
    std::string mode = get_imex_mode();
    if (mode != kImexPrimaryMode)
        return mode;
    // wxGetApp() is not available headless -- see build_imex_cache_key, which guards on the
    // same thing. Nothing calls this from the CLI today; this keeps that from being fatal.
    if (!m_plater)
        return mode;
    if (auto* bundle = wxGetApp().preset_bundle) {
        if (auto* opt = bundle->prints.get_edited_preset().config.option<ConfigOptionString>("imex_parallel_mode"))
            if (!opt->value.empty())
                return opt->value;
    }
    return kImexPrimaryMode;
}

References get_imex_mode(), Slic3r::kImexPrimaryMode, and m_plater.

Referenced by build_imex_cache_key(), Slic3r::GUI::collect_imex_warnings(), has_imex_multimaterial_conflict(), render_icons(), Slic3r::GUI::GCodeViewer::render_markers(), and resolve_active_mode_tools().

Here is the call graph for this function:

Here is the caller graph for this function:

get_exclude_areas()

const std::vector< BoundingBoxf3 > & Slic3r::GUI::PartPlate::get_exclude_areas ( )

inline

{ return m_exclude_bounding_box; }

References m_exclude_bounding_box.

Referenced by Slic3r::GLVolumeCollection::check_outside_state(), Slic3r::GUI::Plater::get_empty_cells(), Slic3r::GUI::GLCanvas3D::load_gcode_preview(), and Slic3r::GUI::Plater::priv::scale_selection_to_fit_print_volume().

Here is the caller graph for this function:

get_extruder_areas()

const std::vector< Pointfs > & Slic3r::GUI::PartPlate::get_extruder_areas ( ) const

inline

{ return m_extruder_areas; }

References m_extruder_areas.

Referenced by Slic3r::CLI::run(), and Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate().

Here is the caller graph for this function:

get_extruder_heights()

const std::vector< double > & Slic3r::GUI::PartPlate::get_extruder_heights ( ) const

inline

{ return m_extruder_heights; }

References m_extruder_heights.

get_extruders() [1/2]

std::vector< int > Slic3r::GUI::PartPlate::get_extruders	(	bool	conside_custom_gcode,
		const DynamicPrintConfig &	glb_config,
		const DynamicPrintConfig &	project_config,
		bool	expand_mixed_slots = true ) const

{
  std::vector<int> plate_extruders;
  // A plate from a sliced .gcode.3mf holds no objects, so report the filaments the G-code
  // used. check_objects_empty_and_gcode3mf does this for get_extruders(bool), but reaches
  // the plater, which the CLI has none of; slice_filaments_info is only filled for such a plate.
  if (m_model->objects.empty()) {
    for (const FilamentInfo &info : slice_filaments_info)
      plate_extruders.push_back(info.id + 1);
    return plate_extruders;
  }
  int glb_support_intf_extr = glb_config.opt_int("support_interface_filament");
  int glb_support_extr = glb_config.opt_int("support_filament");
  int glb_outer_wall_extr = glb_config.opt_int("outer_wall_filament_id");
  int glb_inner_wall_extr = glb_config.opt_int("inner_wall_filament_id");
  if (glb_outer_wall_extr == 0) glb_outer_wall_extr = glb_inner_wall_extr;
  if (glb_inner_wall_extr == 0) glb_inner_wall_extr = glb_outer_wall_extr;
  int glb_sparse_infill_extr = glb_config.opt_int("sparse_infill_filament_id");
  int glb_internal_solid_extr = glb_config.opt_int("internal_solid_filament_id");
  int glb_top_surface_extr = glb_config.opt_int("top_surface_filament_id");
  int glb_bottom_surface_extr = glb_config.opt_int("bottom_surface_filament_id");
  if (glb_top_surface_extr == 0) glb_top_surface_extr = glb_internal_solid_extr;
  if (glb_bottom_surface_extr == 0) glb_bottom_surface_extr = glb_internal_solid_extr;
  bool glb_support = glb_config.opt_bool("enable_support");
    glb_support |= glb_config.opt_int("raft_layers") > 0;
 
  for (int obj_idx = 0; obj_idx < m_model->objects.size(); obj_idx++) {
    // Any instance on the plate counts, as PrintApply does: after an arrange, instance 0
    // can sit on a different plate.
    if (!contain_any_instance_totally(obj_idx))
      continue;
 
    ModelObject* mo = m_model->objects[obj_idx];
    for (ModelVolume* mv : mo->volumes) {
      std::vector<int> volume_extruders = mv->get_extruders();
      plate_extruders.insert(plate_extruders.end(), volume_extruders.begin(), volume_extruders.end());
    }
 
    // layer range
        for (auto layer_range : mo->layer_config_ranges) {
            if (layer_range.second.has("extruder")) {
                if (auto id = layer_range.second.option("extruder")->getInt(); id > 0)
          plate_extruders.push_back(id);
      }
    }
 
    bool obj_support = false;
    const ConfigOption* obj_support_opt = mo->config.option("enable_support");
        const ConfigOption *obj_raft_opt    = mo->config.option("raft_layers");
    if (obj_support_opt != nullptr || obj_raft_opt != nullptr) {
            if (obj_support_opt != nullptr)
        obj_support = obj_support_opt->getBool();
            if (obj_raft_opt != nullptr)
        obj_support |= obj_raft_opt->getInt() > 0;
        }
    else
      obj_support = glb_support;
 
        if (obj_support) {
            int                 obj_support_intf_extr = 0;
            const ConfigOption* support_intf_extr_opt = mo->config.option("support_interface_filament");
            if (support_intf_extr_opt != nullptr)
                obj_support_intf_extr = support_intf_extr_opt->getInt();
            if (obj_support_intf_extr != 0)
                plate_extruders.push_back(obj_support_intf_extr);
            else if (glb_support_intf_extr != 0)
                plate_extruders.push_back(glb_support_intf_extr);
 
            int                 obj_support_extr = 0;
            const ConfigOption* support_extr_opt = mo->config.option("support_filament");
            if (support_extr_opt != nullptr)
                obj_support_extr = support_extr_opt->getInt();
            if (obj_support_extr != 0)
                plate_extruders.push_back(obj_support_extr);
            else if (glb_support_extr != 0)
                plate_extruders.push_back(glb_support_extr);
        }
 
    int obj_outer_wall_extr = 0;
    if (const ConfigOption* wall_opt = mo->config.option("outer_wall_filament_id"); wall_opt != nullptr)
      obj_outer_wall_extr = wall_opt->getInt();
    if (obj_outer_wall_extr == 0)
      if (const ConfigOption* wall_opt = mo->config.option("inner_wall_filament_id"); wall_opt != nullptr)
        obj_outer_wall_extr = wall_opt->getInt();
    if (obj_outer_wall_extr != 0)
      plate_extruders.push_back(obj_outer_wall_extr);
    else if (glb_outer_wall_extr != 0)
      plate_extruders.push_back(glb_outer_wall_extr);
 
    int obj_inner_wall_extr = 0;
    if (const ConfigOption* wall_opt = mo->config.option("inner_wall_filament_id"); wall_opt != nullptr)
      obj_inner_wall_extr = wall_opt->getInt();
    if (obj_inner_wall_extr == 0)
      if (const ConfigOption* wall_opt = mo->config.option("outer_wall_filament_id"); wall_opt != nullptr)
        obj_inner_wall_extr = wall_opt->getInt();
    if (obj_inner_wall_extr != 0)
      plate_extruders.push_back(obj_inner_wall_extr);
    else if (glb_inner_wall_extr != 0)
      plate_extruders.push_back(glb_inner_wall_extr);
 
    int obj_sparse_infill_extr = 0;
    const ConfigOption* sparse_infill_opt = mo->config.option("sparse_infill_filament_id");
    if (sparse_infill_opt != nullptr)
      obj_sparse_infill_extr = sparse_infill_opt->getInt();
    if (obj_sparse_infill_extr != 0)
      plate_extruders.push_back(obj_sparse_infill_extr);
    else if (glb_sparse_infill_extr != 0)
      plate_extruders.push_back(glb_sparse_infill_extr);
 
    int obj_internal_solid_extr = 0;
    if (const ConfigOption* solid_opt = mo->config.option("internal_solid_filament_id"); solid_opt != nullptr)
      obj_internal_solid_extr = solid_opt->getInt();
    if (obj_internal_solid_extr != 0)
      plate_extruders.push_back(obj_internal_solid_extr);
    else if (glb_internal_solid_extr != 0)
      plate_extruders.push_back(glb_internal_solid_extr);
 
    int obj_top_surface_extr = 0;
    if (const ConfigOption* top_opt = mo->config.option("top_surface_filament_id"); top_opt != nullptr)
      obj_top_surface_extr = top_opt->getInt();
    if (obj_top_surface_extr == 0)
      obj_top_surface_extr = obj_internal_solid_extr;
    if (obj_top_surface_extr != 0)
      plate_extruders.push_back(obj_top_surface_extr);
    else if (glb_top_surface_extr != 0)
      plate_extruders.push_back(glb_top_surface_extr);
 
    int obj_bottom_surface_extr = 0;
    if (const ConfigOption* bottom_opt = mo->config.option("bottom_surface_filament_id"); bottom_opt != nullptr)
      obj_bottom_surface_extr = bottom_opt->getInt();
    if (obj_bottom_surface_extr == 0)
      obj_bottom_surface_extr = obj_internal_solid_extr;
    if (obj_bottom_surface_extr != 0)
      plate_extruders.push_back(obj_bottom_surface_extr);
    else if (glb_bottom_surface_extr != 0)
      plate_extruders.push_back(glb_bottom_surface_extr);
 
  }
 
  if (conside_custom_gcode) {
    //BBS
        int nums_extruders = 0;
        if (const ConfigOptionStrings *color_option = dynamic_cast<const ConfigOptionStrings *>(project_config.option("filament_colour"))) {
            nums_extruders = color_option->values.size();
      if (m_model->plates_custom_gcodes.find(m_plate_index) != m_model->plates_custom_gcodes.end()) {
        for (auto item : m_model->plates_custom_gcodes.at(m_plate_index).gcodes) {
          if (item.type == CustomGCode::Type::ToolChange && item.extruder <= nums_extruders)
            plate_extruders.push_back(item.extruder);
        }
      }
    }
  }
 
  std::sort(plate_extruders.begin(), plate_extruders.end());
  auto it_end = std::unique(plate_extruders.begin(), plate_extruders.end());
  plate_extruders.resize(std::distance(plate_extruders.begin(), it_end));
 
  // Expand mixed filament slots to their physical components. A mixed slot is virtual and
  // is never loaded into a tray, so callers (AMS mapping, filament checks) must see the
  // physical filaments it resolves to instead.
  {
    const auto* is_mixed_opt = project_config.option<ConfigOptionBools>("filament_is_mixed");
    const auto* comp_strs_opt = project_config.option<ConfigOptionStrings>("filament_mixed_components");
    if (expand_mixed_slots && is_mixed_opt && comp_strs_opt && has_any_mixed_filament(is_mixed_opt->values)) {
      std::vector<unsigned int> ext_0based;
      for (int e : plate_extruders)
        if (e >= 1) ext_0based.push_back((unsigned int)(e - 1));
      auto expanded = expand_mixed_filaments(ext_0based, is_mixed_opt->values, comp_strs_opt->values);
      plate_extruders.clear();
      for (unsigned int e : expanded)
        plate_extruders.push_back((int)(e + 1));
    }
  }
 
  return plate_extruders;
}

References Slic3r::ModelObject::config, contain_any_instance_totally(), Slic3r::expand_mixed_filaments(), Slic3r::ModelVolume::get_extruders(), Slic3r::ConfigOption::getBool(), Slic3r::ConfigOption::getInt(), Slic3r::has_any_mixed_filament(), Slic3r::ModelObject::layer_config_ranges, m_model, m_plate_index, Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_int(), Slic3r::ConfigBase::option(), Slic3r::ModelConfig::option(), slice_filaments_info, Slic3r::CustomGCode::ToolChange, Slic3r::ConfigOptionVector< unsigned char >::values, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

get_extruders() [2/2]

std::vector< int > Slic3r::GUI::PartPlate::get_extruders	(	bool	conside_custom_gcode = false,
		bool	expand_mixed_slots = true ) const

{
  std::vector<int> plate_extruders;
    if (check_objects_empty_and_gcode3mf(plate_extruders)) {
        return plate_extruders;
    }
  return get_extruders(conside_custom_gcode, wxGetApp().preset_bundle->prints.get_edited_preset().config, wxGetApp().preset_bundle->project_config, expand_mixed_slots);
}

References check_objects_empty_and_gcode3mf(), and get_extruders().

Referenced by check_filament_printable(), check_mixture_filament_compatible(), check_mixture_of_pla_and_petg(), Slic3r::GUI::collect_imex_warnings(), estimate_wipe_tower_footprint(), get_extruders(), has_imex_multimaterial_conflict(), imex_wipe_tower_hull(), Slic3r::GLVolumeCollection::load_real_wipe_tower_preview(), Slic3r::GLVolumeCollection::load_wipe_tower_preview(), Slic3r::GUI::Plater::open_filament_map_setting_dialog(), Slic3r::GUI::ArrangeJob::prepare_wipe_tower(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::try_pop_up_before_slice(), and Slic3r::GUI::Plater::validate_current_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

get_extruders_under_cli()

std::vector< int > Slic3r::GUI::PartPlate::get_extruders_under_cli	(	bool	conside_custom_gcode,
		DynamicPrintConfig &	full_config,
		bool	expand_mixed_slots = true ) const

{
    std::vector<int> plate_extruders;
 
    // if 3mf file
    int glb_support_intf_extr = full_config.opt_int("support_interface_filament");
    int glb_support_extr = full_config.opt_int("support_filament");
  int glb_outer_wall_extr = full_config.opt_int("outer_wall_filament_id");
  int glb_inner_wall_extr = full_config.opt_int("inner_wall_filament_id");
  if (glb_outer_wall_extr == 0) glb_outer_wall_extr = glb_inner_wall_extr;
  if (glb_inner_wall_extr == 0) glb_inner_wall_extr = glb_outer_wall_extr;
  int glb_sparse_infill_extr = full_config.opt_int("sparse_infill_filament_id");
  int glb_internal_solid_extr = full_config.opt_int("internal_solid_filament_id");
  int glb_top_surface_extr = full_config.opt_int("top_surface_filament_id");
  int glb_bottom_surface_extr = full_config.opt_int("bottom_surface_filament_id");
  if (glb_top_surface_extr == 0) glb_top_surface_extr = glb_internal_solid_extr;
  if (glb_bottom_surface_extr == 0) glb_bottom_surface_extr = glb_internal_solid_extr;
 
    bool glb_support = full_config.opt_bool("enable_support");
    glb_support |= full_config.opt_int("raft_layers") > 0;
 
    for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it)
    {
        int obj_id = it->first;
        int instance_id = it->second;
 
        if (valid_instance(obj_id, instance_id))
        {
            ModelObject* object = m_model->objects[obj_id];
            ModelInstance* instance = object->instances[instance_id];
 
            if (!instance->printable)
                continue;
 
            for (ModelVolume* mv : object->volumes) {
                std::vector<int> volume_extruders = mv->get_extruders();
                plate_extruders.insert(plate_extruders.end(), volume_extruders.begin(), volume_extruders.end());
            }
 
            // layer range
            for (auto layer_range : object->layer_config_ranges) {
                if (layer_range.second.has("extruder")) {
                    if (auto id = layer_range.second.option("extruder")->getInt(); id > 0)
                        plate_extruders.push_back(id);
                }
            }
 
            bool obj_support = false;
            const ConfigOption* obj_support_opt = object->config.option("enable_support");
            const ConfigOption *obj_raft_opt    = object->config.option("raft_layers");
            if (obj_support_opt != nullptr || obj_raft_opt != nullptr) {
                if (obj_support_opt != nullptr)
                    obj_support = obj_support_opt->getBool();
                if (obj_raft_opt != nullptr)
                    obj_support |= obj_raft_opt->getInt() > 0;
            }
            else
                obj_support = glb_support;
 
            if (obj_support) {
                int obj_support_intf_extr = 0;
                const ConfigOption* support_intf_extr_opt = object->config.option("support_interface_filament");
                if (support_intf_extr_opt != nullptr)
                    obj_support_intf_extr = support_intf_extr_opt->getInt();
                if (obj_support_intf_extr != 0)
                    plate_extruders.push_back(obj_support_intf_extr);
                else if (glb_support_intf_extr != 0)
                    plate_extruders.push_back(glb_support_intf_extr);
 
                int obj_support_extr = 0;
                const ConfigOption* support_extr_opt = object->config.option("support_filament");
                if (support_extr_opt != nullptr)
                    obj_support_extr = support_extr_opt->getInt();
                if (obj_support_extr != 0)
                    plate_extruders.push_back(obj_support_extr);
                else if (glb_support_extr != 0)
                    plate_extruders.push_back(glb_support_extr);
            }
 
      int obj_outer_wall_extr = 0;
      if (const ConfigOption* wall_opt = object->config.option("outer_wall_filament_id"); wall_opt != nullptr)
        obj_outer_wall_extr = wall_opt->getInt();
      if (obj_outer_wall_extr == 0)
        if (const ConfigOption* wall_opt = object->config.option("inner_wall_filament_id"); wall_opt != nullptr)
          obj_outer_wall_extr = wall_opt->getInt();
      if (obj_outer_wall_extr != 0)
        plate_extruders.push_back(obj_outer_wall_extr);
      else if (glb_outer_wall_extr != 0)
        plate_extruders.push_back(glb_outer_wall_extr);
 
      int obj_inner_wall_extr = 0;
      if (const ConfigOption* wall_opt = object->config.option("inner_wall_filament_id"); wall_opt != nullptr)
        obj_inner_wall_extr = wall_opt->getInt();
      if (obj_inner_wall_extr == 0)
        if (const ConfigOption* wall_opt = object->config.option("outer_wall_filament_id"); wall_opt != nullptr)
          obj_inner_wall_extr = wall_opt->getInt();
      if (obj_inner_wall_extr != 0)
        plate_extruders.push_back(obj_inner_wall_extr);
      else if (glb_inner_wall_extr != 0)
        plate_extruders.push_back(glb_inner_wall_extr);
 
      int obj_sparse_infill_extr = 0;
      const ConfigOption* sparse_infill_opt = object->config.option("sparse_infill_filament_id");
      if (sparse_infill_opt != nullptr)
        obj_sparse_infill_extr = sparse_infill_opt->getInt();
      if (obj_sparse_infill_extr != 0)
        plate_extruders.push_back(obj_sparse_infill_extr);
      else if (glb_sparse_infill_extr != 0)
        plate_extruders.push_back(glb_sparse_infill_extr);
 
      int obj_internal_solid_extr = 0;
      if (const ConfigOption* solid_opt = object->config.option("internal_solid_filament_id"); solid_opt != nullptr)
        obj_internal_solid_extr = solid_opt->getInt();
      if (obj_internal_solid_extr != 0)
        plate_extruders.push_back(obj_internal_solid_extr);
      else if (glb_internal_solid_extr != 0)
        plate_extruders.push_back(glb_internal_solid_extr);
 
      int obj_top_surface_extr = 0;
      if (const ConfigOption* top_opt = object->config.option("top_surface_filament_id"); top_opt != nullptr)
        obj_top_surface_extr = top_opt->getInt();
      if (obj_top_surface_extr == 0)
        obj_top_surface_extr = obj_internal_solid_extr;
      if (obj_top_surface_extr != 0)
        plate_extruders.push_back(obj_top_surface_extr);
      else if (glb_top_surface_extr != 0)
        plate_extruders.push_back(glb_top_surface_extr);
 
      int obj_bottom_surface_extr = 0;
      if (const ConfigOption* bottom_opt = object->config.option("bottom_surface_filament_id"); bottom_opt != nullptr)
        obj_bottom_surface_extr = bottom_opt->getInt();
      if (obj_bottom_surface_extr == 0)
        obj_bottom_surface_extr = obj_internal_solid_extr;
      if (obj_bottom_surface_extr != 0)
        plate_extruders.push_back(obj_bottom_surface_extr);
      else if (glb_bottom_surface_extr != 0)
        plate_extruders.push_back(glb_bottom_surface_extr);
        }
    }
 
    if (conside_custom_gcode) {
        //BBS
        int nums_extruders = 0;
        if (const ConfigOptionStrings *color_option = dynamic_cast<const ConfigOptionStrings *>(full_config.option("filament_colour"))) {
            nums_extruders = color_option->values.size();
            if (m_model->plates_custom_gcodes.find(m_plate_index) != m_model->plates_custom_gcodes.end()) {
                for (auto item : m_model->plates_custom_gcodes.at(m_plate_index).gcodes) {
                    if (item.type == CustomGCode::Type::ToolChange && item.extruder <= nums_extruders)
                        plate_extruders.push_back(item.extruder);
                }
            }
        }
    }
 
    std::sort(plate_extruders.begin(), plate_extruders.end());
    auto it_end = std::unique(plate_extruders.begin(), plate_extruders.end());
    plate_extruders.resize(std::distance(plate_extruders.begin(), it_end));
 
    // Expand mixed filament slots to their physical components. A mixed slot is virtual and
    // is never loaded into a tray, so callers (AMS mapping, filament checks) must see the
    // physical filaments it resolves to instead.
    if (expand_mixed_slots) {
        auto* is_mixed_opt = full_config.option<ConfigOptionBools>("filament_is_mixed");
        auto* comp_strs_opt = full_config.option<ConfigOptionStrings>("filament_mixed_components");
        if (is_mixed_opt && comp_strs_opt && has_any_mixed_filament(is_mixed_opt->values)) {
            std::vector<unsigned int> ext_0based;
            for (int e : plate_extruders)
                if (e >= 1) ext_0based.push_back((unsigned int)(e - 1));
            auto expanded = expand_mixed_filaments(ext_0based, is_mixed_opt->values, comp_strs_opt->values);
            plate_extruders.clear();
            for (unsigned int e : expanded)
                plate_extruders.push_back((int)(e + 1));
        }
    }
 
    return plate_extruders;
}

References Slic3r::ModelObject::config, Slic3r::expand_mixed_filaments(), Slic3r::ModelVolume::get_extruders(), Slic3r::ConfigOption::getBool(), Slic3r::ConfigOption::getInt(), Slic3r::has_any_mixed_filament(), Slic3r::ModelObject::layer_config_ranges, m_model, m_plate_index, obj_to_instance_set, Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_int(), Slic3r::ConfigBase::option(), Slic3r::ModelConfig::option(), Slic3r::ModelInstance::printable, Slic3r::CustomGCode::ToolChange, valid_instance(), Slic3r::ConfigOptionVector< unsigned char >::values, and Slic3r::ModelObject::volumes.

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

get_extruders_without_support()

std::vector< int > Slic3r::GUI::PartPlate::get_extruders_without_support

(

bool

conside_custom_gcode = false

)

const

{
  std::vector<int> plate_extruders;
    if (check_objects_empty_and_gcode3mf(plate_extruders)) {
        return plate_extruders;
    }
  // if 3mf file
  const DynamicPrintConfig& glb_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
 
  for (int obj_idx = 0; obj_idx < m_model->objects.size(); obj_idx++) {
    if (!contain_any_instance_totally(obj_idx))
      continue;
 
    ModelObject* mo = m_model->objects[obj_idx];
    for (ModelVolume* mv : mo->volumes) {
      std::vector<int> volume_extruders = mv->get_extruders();
      plate_extruders.insert(plate_extruders.end(), volume_extruders.begin(), volume_extruders.end());
    }
  }
 
  if (conside_custom_gcode) {
    //BBS
    int nums_extruders = 0;
    if (const ConfigOptionStrings* color_option = dynamic_cast<const ConfigOptionStrings*>(wxGetApp().preset_bundle->project_config.option("filament_colour"))) {
      nums_extruders = color_option->values.size();
      if (m_model->plates_custom_gcodes.find(m_plate_index) != m_model->plates_custom_gcodes.end()) {
        for (auto item : m_model->plates_custom_gcodes.at(m_plate_index).gcodes) {
          if (item.type == CustomGCode::Type::ToolChange && item.extruder <= nums_extruders)
            plate_extruders.push_back(item.extruder);
        }
      }
    }
  }
 
  std::sort(plate_extruders.begin(), plate_extruders.end());
  auto it_end = std::unique(plate_extruders.begin(), plate_extruders.end());
  plate_extruders.resize(std::distance(plate_extruders.begin(), it_end));
 
  // Expand mixed filament slots to their physical components. A mixed slot is virtual and
  // is never loaded into a tray, so callers (AMS mapping, filament checks) must see the
  // physical filaments it resolves to instead.
  {
    auto& project_config = wxGetApp().preset_bundle->project_config;
    auto* is_mixed_opt = project_config.option<ConfigOptionBools>("filament_is_mixed");
    auto* comp_strs_opt = project_config.option<ConfigOptionStrings>("filament_mixed_components");
    if (is_mixed_opt && comp_strs_opt && has_any_mixed_filament(is_mixed_opt->values)) {
      std::vector<unsigned int> ext_0based;
      for (int e : plate_extruders)
        if (e >= 1) ext_0based.push_back((unsigned int)(e - 1));
      auto expanded = expand_mixed_filaments(ext_0based, is_mixed_opt->values, comp_strs_opt->values);
      plate_extruders.clear();
      for (unsigned int e : expanded)
        plate_extruders.push_back((int)(e + 1));
    }
  }
 
  return plate_extruders;
}

References check_objects_empty_and_gcode3mf(), contain_any_instance_totally(), Slic3r::expand_mixed_filaments(), Slic3r::ModelVolume::get_extruders(), Slic3r::has_any_mixed_filament(), m_model, m_plate_index, Slic3r::CustomGCode::ToolChange, Slic3r::ConfigOptionVector< unsigned char >::values, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

get_filament_map_mode()

FilamentMapMode Slic3r::GUI::PartPlate::get_filament_map_mode

(

)

const

{
    std::string key = "filament_map_mode";
    if(m_config.has(key))
        return m_config.option<ConfigOptionEnum<FilamentMapMode>>(key)->value;
    return FilamentMapMode::fmmDefault;
}

References Slic3r::fmmDefault, and m_config.

Referenced by get_real_filament_map_mode(), Slic3r::GUI::Plater::open_filament_map_setting_dialog(), and set_filament_map_mode().

Here is the caller graph for this function:

get_filament_maps()

std::vector< int > Slic3r::GUI::PartPlate::get_filament_maps

(

)

const

{
    std::string key = "filament_map";
    if (m_config.has(key))
        return m_config.option<ConfigOptionInts>(key)->values;
 
    return {};
}

References m_config.

Referenced by Slic3r::GUI::SelectMachineDialog::get_ams_mapping_result(), Slic3r::GUI::SendMultiMachinePage::get_ams_mapping_result(), Slic3r::GUI::SyncAmsInfoDialog::get_ams_mapping_result(), get_effective_exclusion_filament_maps(), get_real_filament_maps(), and load_gcode_from_file().

Here is the caller graph for this function:

get_filament_nozzle_maps()

std::vector< int > Slic3r::GUI::PartPlate::get_filament_nozzle_maps

(

)

const

{
    std::string key = "filament_nozzle_map";
    if (m_config.has(key))
        return m_config.option<ConfigOptionInts>(key)->values;
 
    return {};
}

References m_config.

get_filament_volume_maps()

std::vector< int > Slic3r::GUI::PartPlate::get_filament_volume_maps

(

)

const

{
    std::string key = "filament_volume_map";
    if (m_config.has(key))
        return m_config.option<ConfigOptionInts>(key)->values;
 
    return {};
}

References m_config.

Referenced by Slic3r::GUI::Plater::apply_background_progress(), get_real_filament_volume_maps(), load_gcode_from_file(), Slic3r::GUI::Plater::select_plate(), Slic3r::GUI::Plater::select_plate_by_hover_id(), Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate(), and Slic3r::GUI::Plater::priv::update_background_process().

Here is the caller graph for this function:

get_first_layer_print_sequence()

std::vector< int > Slic3r::GUI::PartPlate::get_first_layer_print_sequence

(

)

const

{
    const ConfigOptionInts *op_print_sequence_1st = m_config.option<ConfigOptionInts>("first_layer_print_sequence");
    if (op_print_sequence_1st)
        return op_print_sequence_1st->values;
    else
        return std::vector<int>();
}

References m_config, and Slic3r::ConfigOptionVector< int >::values.

Referenced by Slic3r::GUI::Plater::open_platesettings_dialog(), and render_icons().

Here is the caller graph for this function:

get_gcode_filename()

std::string Slic3r::GUI::PartPlate::get_gcode_filename

(

)

{
  if (is_slice_result_valid() && get_slice_result()) {
    return m_gcode_result->filename;
  }
  return "";
}

References get_slice_result(), is_slice_result_valid(), and m_gcode_result.

Referenced by is_valid_gcode_file().

Here is the call graph for this function:

Here is the caller graph for this function:

get_imex_ghost_volumes()

const std::vector< std::unique_ptr< GLVolume > > & Slic3r::GUI::PartPlate::get_imex_ghost_volumes ( ) const

inline

                                                                             {
        return m_imex_ghost_volumes;
    }

References m_imex_ghost_volumes.

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass_imex_ghosts(), Slic3r::GUI::GLCanvas3D::_render_imex_ghost_tooltip(), and Slic3r::GUI::GLCanvas3D::_render_imex_ghosts().

Here is the caller graph for this function:

get_imex_head_filament_color() [1/2]

ColorRGBA Slic3r::GUI::PartPlate::get_imex_head_filament_color

(

int

physical_head

)

const

{
    auto* pb = wxGetApp().preset_bundle;
    if (!pb)
        return GLVolume::UNPRINTABLE_COLOR;
 
    return get_imex_head_filament_color(physical_head,
                                        effective_physical_extruder_map(*pb),
                                        get_imex_head_filament_map());
}

References Slic3r::effective_physical_extruder_map(), get_imex_head_filament_color(), get_imex_head_filament_map(), and Slic3r::GLVolume::UNPRINTABLE_COLOR.

Referenced by Slic3r::GUI::Plater::format_imex_ghost_tooltip(), get_imex_head_filament_color(), Slic3r::GUI::GCodeViewer::render_markers(), and update_imex_ghost_colors().

Here is the call graph for this function:

Here is the caller graph for this function:

get_imex_head_filament_color() [2/2]

ColorRGBA Slic3r::GUI::PartPlate::get_imex_head_filament_color	(	int	physical_head,
		const ConfigOptionInts &	pem,
		const std::map< int, int > &	plate_map ) const

{
    auto* pb = wxGetApp().preset_bundle;
    if (!pb)
        return GLVolume::UNPRINTABLE_COLOR;
 
    const int logical = resolve_filament_for_head(plate_map, pem, physical_head);
    if (logical < 0)
        return GLVolume::UNPRINTABLE_COLOR;
 
    auto* colours = pb->project_config.option<ConfigOptionStrings>("filament_colour");
    if (!colours || logical >= (int)colours->values.size())
        return GLVolume::UNPRINTABLE_COLOR;
 
    ColorRGBA rgba;
    if (!decode_color(colours->values[logical], rgba))
        return GLVolume::UNPRINTABLE_COLOR;
    return rgba;
}

References Slic3r::GUI::decode_color(), Slic3r::resolve_filament_for_head(), and Slic3r::GLVolume::UNPRINTABLE_COLOR.

Here is the call graph for this function:

get_imex_head_filament_map()

std::map< int, int > Slic3r::GUI::PartPlate::get_imex_head_filament_map

(

)

const

{
    if (!m_config.has("imex_head_filament_map"))
        return {};
    auto* opt = m_config.option<ConfigOptionString>("imex_head_filament_map");
    if (!opt) return {};
    return parse_imex_head_filament_map(opt->value);
}

References m_config, and Slic3r::parse_imex_head_filament_map().

Referenced by Slic3r::GUI::Plater::format_imex_ghost_tooltip(), get_imex_head_filament_color(), Slic3r::GUI::GCodeViewer::render_markers(), and update_imex_ghost_colors().

Here is the call graph for this function:

Here is the caller graph for this function:

get_imex_mode()

std::string Slic3r::GUI::PartPlate::get_imex_mode

(

)

const

{
    if (m_config.has("imex_parallel_mode")) {
        auto* opt = m_config.option<ConfigOptionString>("imex_parallel_mode");
        if (opt && !opt->value.empty())
            return opt->value;
    }
    return kImexPrimaryMode;
}

References Slic3r::kImexPrimaryMode, and m_config.

Referenced by Slic3r::GUI::TabPrinter::build_unregular_pages(), calc_imex_zones(), get_effective_imex_mode(), render_icons(), and Slic3r::GUI::Plater::select_plate_by_hover_id().

Here is the caller graph for this function:

get_index()

int Slic3r::GUI::PartPlate::get_index ( )

inline

{ return m_plate_index; }

References m_plate_index.

Referenced by Slic3r::GUI::ObjectDataViewModelNode::ObjectDataViewModelNode(), Slic3r::GUI::ObjectDataViewModel::AddObject(), Slic3r::GUI::ObjectDataViewModel::AddPlate(), Slic3r::GUI::PartPlateList::delete_plate(), operator<(), Slic3r::GUI::FillBedJob::prepare(), Slic3r::CLI::run(), Slic3r::GUI::Plater::priv::set_current_panel(), and Slic3r::GUI::ObjectList::update_selections().

Here is the caller graph for this function:

get_instance()

ModelInstance * Slic3r::GUI::PartPlate::get_instance	(	int	obj_id,
		int	instance_id )

{
  if (!contain_instance(obj_id, instance_id))
    return nullptr;
  else
    return m_model->objects[obj_id]->instances[instance_id];
}

References contain_instance(), and m_model.

Here is the call graph for this function:

get_logical_extruder_by_filament_id()

int Slic3r::GUI::PartPlate::get_logical_extruder_by_filament_id	(	const DynamicConfig &	g_config,
		int	idx ) const

{
  const std::vector<int>& filament_map = get_real_filament_maps(g_config);
  if (idx <= 0 || idx > (int)filament_map.size())
  {
    return -1;
  }
 
  return filament_map[idx - 1] - 1;
}

References Slic3r::filament_map(), and get_real_filament_maps().

Referenced by Slic3r::GUI::s_get_slicing_extuder_nozzles().

Here is the call graph for this function:

Here is the caller graph for this function:

get_object_filament_extruders()

std::map< int, size_t > Slic3r::GUI::PartPlate::get_object_filament_extruders	(	const ModelObject &	object,
		const DynamicConfig &	g_config,
		size_t	extruder_count ) const

{
    std::set<int> filament_ids;
    const DynamicPrintConfig &process_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    const auto effective_option = [&object, &process_config](const char *key) -> const ConfigOption * {
        if (const ConfigOption *option = object.config.option(key); option != nullptr)
            return option;
        return process_config.option(key);
    };
    const auto effective_int = [&effective_option](const char *key) {
        const ConfigOption *option = effective_option(key);
        return option != nullptr ? option->getInt() : 0;
    };
    const auto effective_float = [&effective_option](const char *key) {
        const ConfigOption *option = effective_option(key);
        return option != nullptr ? option->getFloat() : 0.0;
    };
    const auto effective_bool = [&effective_option](const char *key) {
        const ConfigOption *option = effective_option(key);
        return option != nullptr && option->getBool();
    };
 
    const bool has_brim = effective_int("brim_type") != int(BrimType::btNoBrim) && effective_float("brim_width") > 0.0;
    const int wall_loops = effective_int("wall_loops");
    const double sparse_infill_density = effective_float("sparse_infill_density");
    const int top_shell_layers = effective_int("top_shell_layers");
    const int bottom_shell_layers = effective_int("bottom_shell_layers");
    const std::array<std::pair<const char *, bool>, 6> feature_filament_keys = {
        std::pair{ "outer_wall_filament_id", wall_loops > 0 || has_brim },
        std::pair{ "inner_wall_filament_id", wall_loops > 1 },
        std::pair{ "sparse_infill_filament_id", sparse_infill_density > 0.0 },
        std::pair{ "internal_solid_filament_id", sparse_infill_density > 0.0 || top_shell_layers > 0 || bottom_shell_layers > 0 },
        std::pair{ "top_surface_filament_id", top_shell_layers > 0 },
        std::pair{ "bottom_surface_filament_id", bottom_shell_layers > 0 }
    };
    auto collect_config_filaments = [&filament_ids, &feature_filament_keys](const DynamicConfig &config) {
        for (const auto &[key, active] : feature_filament_keys) {
            if (active) {
                if (const ConfigOption *option = config.option(key); option != nullptr && option->getInt() > 0)
                    filament_ids.emplace(option->getInt());
            }
        }
        if (const ConfigOption *option = config.option("extruder"); option != nullptr && option->getInt() > 0)
            filament_ids.emplace(option->getInt());
    };
 
    for (const ModelVolume *volume : object.volumes) {
        const std::vector<int> volume_filaments = volume->get_extruders();
        filament_ids.insert(volume_filaments.begin(), volume_filaments.end());
        collect_config_filaments(volume->config.get());
    }
    collect_config_filaments(object.config.get());
    for (const auto &layer_range : object.layer_config_ranges)
        collect_config_filaments(layer_range.second.get());
 
    // Process-level feature assignments also apply when the object has no
    // override. This mirrors the relevant parts of PrintObject::printing_extruders()
    // closely enough for an unsliced placement preview.
    for (const auto &[key, active] : feature_filament_keys) {
        if (active && !object.config.has(key) && process_config.has(key) && process_config.opt_int(key) > 0)
            filament_ids.emplace(process_config.opt_int(key));
    }
 
    const bool has_support = effective_bool("enable_support") || effective_int("raft_layers") > 0;
    if (has_support) {
        const int support_filament = effective_int("support_filament");
        const int interface_filament = effective_int("support_interface_filament");
        if (support_filament > 0)
            filament_ids.emplace(support_filament);
        if (interface_filament > 0)
            filament_ids.emplace(interface_filament);
    }
 
    // Match Orca's normal fallback for an unassigned object.
    if (filament_ids.empty())
        filament_ids.emplace(1);
 
    const size_t required_filament_count = filament_ids.empty() ? 0 : size_t(*filament_ids.rbegin());
    const std::vector<int> filament_map = get_effective_exclusion_filament_maps(
        g_config, required_filament_count, extruder_count);
    std::map<int, size_t> result;
    for (const int filament_id : filament_ids) {
        if (filament_id <= 0)
            continue;
 
        const int mapped_extruder = size_t(filament_id) <= filament_map.size() && filament_map[filament_id - 1] > 0 ?
            filament_map[filament_id - 1] - 1 : -1;
        if (mapped_extruder >= 0 && size_t(mapped_extruder) < extruder_count)
            result.emplace(filament_id, size_t(mapped_extruder));
    }
    return result;
}

References Slic3r::bottom_shell_layers(), Slic3r::btNoBrim, config(), Slic3r::filament_ids(), Slic3r::filament_map(), get_effective_exclusion_filament_maps(), Slic3r::ConfigOption::getBool(), Slic3r::ConfigOption::getFloat(), Slic3r::ConfigOption::getInt(), Slic3r::ConfigOptionResolver::has(), Slic3r::DynamicConfig::opt_int(), Slic3r::ConfigBase::option(), and Slic3r::sparse_infill_density().

Referenced by Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders(), and update_exclusion_volume_preview_models().

Here is the call graph for this function:

Here is the caller graph for this function:

get_objects()

ModelObjectPtrs Slic3r::GUI::PartPlate::get_objects ( )

inline

{ return m_model->objects; }

References m_model.

Referenced by Slic3r::GUI::MenuFactory::create_plate_menu().

Here is the caller graph for this function:

get_objects_bounding_box()

BoundingBoxf3 Slic3r::GUI::PartPlate::get_objects_bounding_box

(

)

{
    BoundingBoxf3 bbox;
    for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it)
    {
        int obj_id = it->first;
        int instance_id = it->second;
 
        if ((obj_id >= 0) && (obj_id < m_model->objects.size()))
        {
            ModelObject* object = m_model->objects[obj_id];
            if ((instance_id >= 0) && (instance_id < object->instances.size()))
            {
                BoundingBoxf3 instance_bbox = object->instance_bounding_box(instance_id);
                bbox.merge(instance_bbox);
            }
        }
    }
    return bbox;
}

References m_model, Slic3r::BoundingBox3Base< PointType >::merge(), and obj_to_instance_set.

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

get_objects_on_this_plate()

ModelObjectPtrs Slic3r::GUI::PartPlate::get_objects_on_this_plate

(

)

                                                     {
    ModelObjectPtrs objects_ptr;
    int obj_id;
    for (auto it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); it++) {
        obj_id = it->first;
        objects_ptr.push_back(m_model->objects[obj_id]);
    }
    return objects_ptr;
}

References m_model, and obj_to_instance_set.

Referenced by Slic3r::GUI::PartPlateList::duplicate_plate(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::SelectMachineDialog::set_default(), Slic3r::GUI::SendMultiMachinePage::set_default(), Slic3r::GUI::SyncAmsInfoDialog::set_default(), and set_vase_mode_related_object_config().

Here is the caller graph for this function:

get_origin()

Vec3d Slic3r::GUI::PartPlate::get_origin ( )

inline

{ return m_origin; }

References m_origin.

Referenced by Slic3r::GUI::GLCanvas3D::_render_platelist(), Slic3r::GLVolumeCollection::check_outside_state(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::GUI::Plater::priv::generate_first_layer_bbox(), Slic3r::GUI::Plater::get_empty_cells(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::CLI::run(), and Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate().

Here is the caller graph for this function:

get_other_layers_print_sequence()

std::vector< LayerPrintSequence > Slic3r::GUI::PartPlate::get_other_layers_print_sequence

(

)

const

{
  const ConfigOptionInts* other_layers_print_sequence_op = m_config.option<ConfigOptionInts>("other_layers_print_sequence");
  const ConfigOptionInt* other_layers_print_sequence_nums_op = m_config.option<ConfigOptionInt>("other_layers_print_sequence_nums");
  if (other_layers_print_sequence_op && other_layers_print_sequence_nums_op) {
    const std::vector<int>& print_sequence = other_layers_print_sequence_op->values;
    int sequence_nums = other_layers_print_sequence_nums_op->value;
    auto other_layers_seqs = Slic3r::get_other_layers_print_sequence(sequence_nums, print_sequence);
    return other_layers_seqs;
  }
  else
    return {};
}

References Slic3r::get_other_layers_print_sequence(), m_config, Slic3r::print_sequence(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by Slic3r::GUI::Plater::open_platesettings_dialog(), render_icons(), update_first_layer_print_sequence(), and update_first_layer_print_sequence_when_delete_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

get_physical_extruder_by_filament_id()

int Slic3r::GUI::PartPlate::get_physical_extruder_by_filament_id	(	const DynamicConfig &	g_config,
		int	idx ) const

{
  const std::vector<int>& filament_map = get_real_filament_maps(g_config);
  if (filament_map.size() < idx)
  {
    return -1;
  }
 
  const auto the_map = g_config.option<ConfigOptionInts>("physical_extruder_map");
  if (!the_map)
  {
    return -1;
  }
 
  int zero_base_logical_idx = filament_map[idx - 1] - 1;
  return the_map->values[zero_base_logical_idx];
}

References Slic3r::filament_map(), get_real_filament_maps(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::_get_used_nozzle_idxes(), and Slic3r::GUI::s_get_slicing_extuder_nozzles().

Here is the call graph for this function:

Here is the caller graph for this function:

get_plate_box()

BoundingBoxf3 Slic3r::GUI::PartPlate::get_plate_box ( )

inline

{return get_build_volume();}

References get_build_volume().

Referenced by check_outside(), Slic3r::GUI::GLGizmoAlignment::get_parent_box(), and intersect_instance().

Here is the call graph for this function:

Here is the caller graph for this function:

get_plate_name()

std::string Slic3r::GUI::PartPlate::get_plate_name ( ) const

inline

{ return m_name; }

References m_name.

Referenced by Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), Slic3r::GUI::ObjectDataViewModel::AddPlate(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::PartPlateList::create_plate(), Slic3r::GUI::PartPlateList::delete_plate(), Slic3r::GUI::ActionRegistry::materialize_plate_actions(), Slic3r::GUI::Plater::open_platesettings_dialog(), and Slic3r::GUI::Plater::select_plate_by_hover_id().

Here is the caller graph for this function:

get_plate_wrapping_detection_area()

std::vector< Vec2d > Slic3r::GUI::PartPlate::get_plate_wrapping_detection_area

(

)

const

{
    DynamicPrintConfig  gconfig                  = wxGetApp().preset_bundle->printers.get_edited_preset().config;
    ConfigOptionPoints *wrapping_exclude_area_opt = gconfig.option<ConfigOptionPoints>("wrapping_exclude_area");
    if (wrapping_exclude_area_opt) {
        std::vector<Vec2d> wrapping_area = wrapping_exclude_area_opt->values;
        for (Vec2d& pt : wrapping_area) {
            pt += Vec2d(m_origin.x(), m_origin.y());
        }
        return wrapping_area;
    }
 
    return std::vector<Vec2d>();
}

References m_origin, Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

get_print()

void Slic3r::GUI::PartPlate::get_print	(	PrintBase **	print,
		GCodeResult **	result,
		int *	index )

{
  if (print && (printer_technology == PrinterTechnology::ptFFF))
    *print = m_print;
 
  if (result)
    *result = m_gcode_result;
 
  if (index)
    *index = m_print_index;
 
  return;
}

References m_gcode_result, m_print, m_print_index, print(), printer_technology, and Slic3r::ptFFF.

Referenced by Slic3r::GUI::PartPlateList::delete_plate(), Slic3r::GUI::Plater::export_3mf(), Slic3r::GUI::PartPlateList::get_current_fff_print(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::CLI::run(), Slic3r::GUI::Plater::select_plate(), and Slic3r::GUI::Plater::select_plate_by_hover_id().

Here is the call graph for this function:

Here is the caller graph for this function:

get_print_seq()

PrintSequence Slic3r::GUI::PartPlate::get_print_seq

(

)

const

{
    std::string print_seq_key = "print_sequence";
 
    if (m_config.has(print_seq_key)) {
        PrintSequence print_seq = m_config.opt_enum<PrintSequence>(print_seq_key);
        return print_seq;
    }
 
    return PrintSequence::ByDefault;
}

References Slic3r::ByDefault, and m_config.

Referenced by get_real_print_seq(), Slic3r::GUI::Plater::open_platesettings_dialog(), Slic3r::GUI::GLCanvas3D::reload_scene(), render_icons(), Slic3r::CLI::run(), and set_print_seq().

Here is the caller graph for this function:

get_real_filament_map_mode()

FilamentMapMode Slic3r::GUI::PartPlate::get_real_filament_map_mode	(	const DynamicConfig &	g_config,
		bool *	use_global_param = nullptr ) const

{
  auto mode = get_filament_map_mode();
  if (FilamentMapMode::fmmDefault != mode) {
    if (use_global_param) { *use_global_param = false; };
    return mode;
  }
 
  auto g_mode = g_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode")->value;
  if (use_global_param) { *use_global_param = true; }
  return g_mode;
}

References Slic3r::fmmDefault, get_filament_map_mode(), and Slic3r::ConfigBase::option().

Referenced by check_filament_printable(), Slic3r::GLVolumeCollection::check_outside_state(), Slic3r::GUI::get_applied_map_mode(), get_effective_exclusion_filament_maps(), Slic3r::CLI::run(), and Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders().

Here is the call graph for this function:

Here is the caller graph for this function:

get_real_filament_maps()

std::vector< int > Slic3r::GUI::PartPlate::get_real_filament_maps	(	const DynamicConfig &	g_config,
		bool *	use_global_param = nullptr ) const

{
  auto maps = get_filament_maps();
  if (!maps.empty()) {
    if (use_global_param) { *use_global_param = false; }
    return maps;
  }
  auto g_maps = g_config.option<ConfigOptionInts>("filament_map")->values;
  if (use_global_param) { *use_global_param = true; }
  return g_maps;
}

References get_filament_maps(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::Plater::apply_background_progress(), check_filament_printable(), Slic3r::GLVolumeCollection::check_outside_state(), Slic3r::GUI::get_applied_map(), get_effective_exclusion_filament_maps(), get_logical_extruder_by_filament_id(), get_physical_extruder_by_filament_id(), Slic3r::GUI::Plater::open_filament_map_setting_dialog(), Slic3r::CLI::run(), Slic3r::GUI::Plater::select_plate(), Slic3r::GUI::Plater::select_plate_by_hover_id(), Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate(), and Slic3r::GUI::Plater::priv::update_background_process().

Here is the call graph for this function:

Here is the caller graph for this function:

get_real_filament_volume_maps()

std::vector< int > Slic3r::GUI::PartPlate::get_real_filament_volume_maps	(	const DynamicConfig &	g_config,
		bool *	use_global_param = nullptr ) const

{
  auto maps = get_filament_volume_maps();
  if (!maps.empty()) {
    if (use_global_param) { *use_global_param = false; }
    return maps;
  }
  auto g_maps = g_config.option<ConfigOptionInts>("filament_volume_map")->values;
  if (use_global_param) { *use_global_param = true; }
  return g_maps;
}

References get_filament_volume_maps(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::get_applied_volume_map(), and Slic3r::GUI::Plater::open_filament_map_setting_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

get_real_print_seq()

PrintSequence Slic3r::GUI::PartPlate::get_real_print_seq

(

bool *

plate_same_as_global = nullptr

)

const

{
  PrintSequence global_print_seq = wxGetApp().global_print_sequence();
    PrintSequence curr_plate_seq = get_print_seq();
    if (curr_plate_seq == PrintSequence::ByDefault) {
    curr_plate_seq = global_print_seq;
    }
 
  if(plate_same_as_global)
    *plate_same_as_global = (curr_plate_seq == global_print_seq);
 
    return curr_plate_seq;
}

References Slic3r::ByDefault, and get_print_seq().

Referenced by Slic3r::GUI::Plater::priv::generate_first_layer_bbox(), Slic3r::GUI::init_arrange_params(), and Slic3r::GUI::ArrangeJob::prepare_all().

Here is the call graph for this function:

Here is the caller graph for this function:

get_shape()

const Pointfs & Slic3r::GUI::PartPlate::get_shape ( ) const

inline

{ return m_shape; }

References m_shape.

Referenced by check_outside(), Slic3r::GLVolumeCollection::check_outside_state(), Slic3r::GUI::GCodeViewer::render_markers(), Slic3r::CLI::run(), and Slic3r::GUI::Plater::priv::update_print_volume_state().

Here is the caller graph for this function:

get_shared_printable_polygon()

Polygon Slic3r::GUI::PartPlate::get_shared_printable_polygon

(

)

const

{
  return m_extruder_areas.empty() ? Polygon::new_scale(m_shape) : get_shared_poly(m_extruder_areas);
}

References Slic3r::get_shared_poly(), m_extruder_areas, m_shape, and Slic3r::Polygon::new_scale().

Referenced by Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

get_size()

Vec2d Slic3r::GUI::PartPlate::get_size ( ) const

inline

{ return Vec2d(m_width, m_depth); }

References m_depth, and m_width.

Referenced by Slic3r::GUI::GLCanvas3D::get_wipe_tower_info().

Here is the caller graph for this function:

get_slice_filaments_info()

const std::vector< FilamentInfo > & Slic3r::GUI::PartPlate::get_slice_filaments_info ( ) const

inline

{ return slice_filaments_info; }

References slice_filaments_info.

get_slice_result()

GCodeProcessorResult * Slic3r::GUI::PartPlate::get_slice_result ( )

inline

{ return m_gcode_result; }

References m_gcode_result.

Referenced by Slic3r::GUI::PartPlateList::get_current_slice_result(), get_gcode_filename(), get_used_filaments(), Slic3r::GUI::SelectMachineDialog::has_timelapse_warning(), Slic3r::GUI::SyncAmsInfoDialog::has_timelapse_warning(), Slic3r::GUI::SelectMachineDialog::on_ok_btn(), Slic3r::CLI::run(), Slic3r::GUI::SendToPrinterDialog::set_default(), Slic3r::GUI::SelectMachineDialog::set_default_normal(), Slic3r::GUI::SendMultiMachinePage::set_default_normal(), Slic3r::GUI::SelectMachineDialog::show_status(), and Slic3r::GUI::SyncAmsInfoDialog::show_status().

Here is the caller graph for this function:

get_slicing_percent()

float Slic3r::GUI::PartPlate::get_slicing_percent ( )

inline

{ return m_slice_percent; }

References m_slice_percent.

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), and Slic3r::GUI::Plater::priv::on_slicing_update().

Here is the caller graph for this function:

get_spiral_vase_mode()

bool Slic3r::GUI::PartPlate::get_spiral_vase_mode

(

)

const

{
  std::string key = "spiral_mode";
  if (m_config.has(key)) {
    return m_config.opt_bool(key);
  }
  else {
    DynamicPrintConfig* global_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
    if (global_config->has(key))
      return global_config->opt_bool(key);
  }
  return false;
}

References Slic3r::ConfigOptionResolver::has(), m_config, and Slic3r::DynamicConfig::opt_bool().

Referenced by Slic3r::GUI::Plater::open_platesettings_dialog(), and set_spiral_vase_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

get_temp_config_3mf_path()

std::string Slic3r::GUI::PartPlate::get_temp_config_3mf_path

(

)

{
  if (m_temp_config_3mf_path.empty()) {
    boost::filesystem::path temp_path(m_model->get_backup_path("Metadata"));
    temp_path /= (boost::format(".%1%.%2%_config.3mf") % get_current_pid() %
      GLOBAL_PLATE_INDEX++).str();
    m_temp_config_3mf_path = temp_path.string();
 
  }
  return m_temp_config_3mf_path;
}

References Slic3r::get_current_pid(), GLOBAL_PLATE_INDEX, m_model, and m_temp_config_3mf_path.

Referenced by Slic3r::GUI::Plater::export_config_3mf().

Here is the call graph for this function:

Here is the caller graph for this function:

get_tmp_gcode_path()

std::string Slic3r::GUI::PartPlate::get_tmp_gcode_path

(

)

{
    if (m_tmp_gcode_path.empty()) {
        boost::filesystem::path temp_path(m_model->get_backup_path("Metadata"));
        temp_path /= (boost::format(".%1%.%2%.gcode") % get_current_pid() %
                      GLOBAL_PLATE_INDEX++).str();
        m_tmp_gcode_path = temp_path.string();
    }
    return m_tmp_gcode_path;
}

References Slic3r::get_current_pid(), GLOBAL_PLATE_INDEX, m_model, and m_tmp_gcode_path.

Referenced by Slic3r::BackgroundSlicingProcess::process_fff(), Slic3r::CLI::run(), and Slic3r::GUI::Plater::send_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

get_used_filaments()

std::vector< int > Slic3r::GUI::PartPlate::get_used_filaments

(

)

{
  std::vector<int> used_filaments;
    if (check_objects_empty_and_gcode3mf(used_filaments)) {
        return used_filaments;
    }
 
  GCodeProcessorResult* result = get_slice_result();
  if (!result)
    return used_filaments;
 
  std::set<int> used_extruders_set;
  PrintEstimatedStatistics& ps = result->print_statistics;
  for (const auto& item : ps.total_volumes_per_extruder)
    used_extruders_set.emplace(item.first + 1);
 
  return std::vector(used_extruders_set.begin(), used_extruders_set.end());
}

References check_objects_empty_and_gcode3mf(), get_slice_result(), Slic3r::GCodeProcessorResult::print_statistics, and Slic3r::PrintEstimatedStatistics::total_volumes_per_extruder.

Referenced by Slic3r::GUI::_get_used_nozzle_idxes(), and Slic3r::GUI::s_get_slicing_extuder_nozzles().

Here is the call graph for this function:

Here is the caller graph for this function:

has_imex_multimaterial_conflict()

bool Slic3r::GUI::PartPlate::has_imex_multimaterial_conflict

(

)

const

{
    // Mirror the logic Print::validate uses so the plater badge fires exactly when
    // slicing would be blocked — no false positives where the badge warns but the
    // slice goes through anyway. Delegates to imex_multicolor_block_reason() so
    // both paths share one source of truth.
    auto* pb = wxGetApp().preset_bundle;
    if (!pb) return false;
    const DynamicPrintConfig& printer_cfg = pb->printers.get_edited_preset().config;
    auto* is_imex_opt = printer_cfg.option<ConfigOptionBool>("is_imex");
    if (!is_imex_opt || !is_imex_opt->value) return false;
 
    // Resolved, not the raw plate value: a plate left on Primary still slices in the
    // process preset's mode, and this badge has to fire wherever validate() would block.
    const std::string mode = get_effective_imex_mode();
    if (mode == kImexPrimaryMode) return false;
 
    // Bails rather than defaulting through imex_cfg_int(), deliberately: this reports a routing
    // CONFLICT, so it must run on the printer's real configuration or not at all. With a defaulted
    // grid the conflict would be computed against a shape the printer does not have. A false
    // conflict warning is worse than staying quiet, so an absent key means "no answer" here --
    // unlike the geometry paths, where a defaulted value still describes a drawable bed.
    auto* tpg_opt   = printer_cfg.option<ConfigOptionInt>("imex_tools_per_gantry");
    if (!tpg_opt) return false;
    // The map Print::apply() hands validate(): a printer that authors none gets the identity,
    // which the raw key's single default entry does not describe.
    const ConfigOptionInts pem = effective_physical_extruder_map(*pb);
 
    // Resolve the active mode's tools string from the printer config. Print::validate()
    // resolves the same name the same way and keeps going on an empty result -- the mixed
    // filament rule below does not depend on the roster -- so this must too, or the badge
    // goes quiet on exactly the plates the slicer refuses.
    const std::string active_tools_str = find_imex_mode(printer_cfg, mode).active_tools;
 
    // Convert PartPlate's 1-based extruder list to the 0-based form the helper expects.
    //
    // get_extruders(true) expands a mixed slot into its physical components, which is right for
    // AMS mapping but wrong here: Print::validate counts the slot itself, so an expanded list
    // makes the badge disagree with the thing it is previewing. A plate holding one 2-component
    // blend reads as 2 filaments to the badge and 1 to validate -- the badge stays silent and
    // the slice is then refused, or it warns about "multi-material objects" on a plate the user
    // sees as single-colour. Undo the expansion so both sides count the same way.
    const std::vector<int> used_1b = get_extruders(true, /*expand_mixed_slots=*/false);
    std::vector<int> used_0b;
    used_0b.reserve(used_1b.size());
    for (int e : used_1b) if (e > 0) used_0b.push_back(e - 1);
 
    // validate()'s first rule: a mixed filament is unsupported in a parallel mode outright,
    // ahead of any multi-color reasoning. The badge has to agree or it under-reports.
    if (auto* is_mixed_opt = wxGetApp().preset_bundle->project_config.option<ConfigOptionBools>("filament_is_mixed")) {
        const auto& is_mixed = is_mixed_opt->values;
        if (std::any_of(used_0b.begin(), used_0b.end(),
                        [&](int slot) { return slot >= 0 && slot < (int) is_mixed.size() && is_mixed[slot]; }))
            return true;
    }
 
    return !imex_multicolor_block_reason(mode, active_tools_str, tpg_opt->value, used_0b, pem).empty();
}

References Slic3r::ImexMode::active_tools, Slic3r::effective_physical_extruder_map(), Slic3r::find_imex_mode(), get_effective_imex_mode(), get_extruders(), Slic3r::imex_multicolor_block_reason(), Slic3r::kImexPrimaryMode, and Slic3r::ConfigBase::option().

Referenced by render_icons().

Here is the call graph for this function:

Here is the caller graph for this function:

has_printable_instances()

bool Slic3r::GUI::PartPlate::has_printable_instances

(

)

{
  bool result = false;
 
  for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it)
  {
    int obj_id = it->first;
    int instance_id = it->second;
 
    if (!valid_instance(obj_id, instance_id))
      continue;
 
    ModelObject* object = m_model->objects[obj_id];
    ModelInstance* instance = object->instances[instance_id];
 
    if ((instance->printable)&&(instance_outside_set.find(std::pair(obj_id, instance_id)) == instance_outside_set.end()))
    {
      result = true;
      break;
    }
  }
 
  return result;
}

References instance_outside_set, m_model, obj_to_instance_set, Slic3r::ModelInstance::printable, and valid_instance().

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), is_slice_result_ready_for_export(), Slic3r::GUI::GCodeViewer::load_as_gcode(), Slic3r::GUI::Plater::priv::object_list_changed(), Slic3r::GUI::Plater::reslice(), Slic3r::GUI::Plater::priv::schedule_auto_reslice_if_needed(), Slic3r::GUI::Plater::select_plate(), Slic3r::GUI::Plater::select_plate_by_hover_id(), Slic3r::GUI::Plater::priv::set_current_panel(), and Slic3r::GUI::Plater::priv::trigger_auto_reslice_now().

Here is the call graph for this function:

Here is the caller graph for this function:

has_spiral_mode_config()

bool Slic3r::GUI::PartPlate::has_spiral_mode_config

(

)

const

{
  std::string key = "spiral_mode";
  return m_config.has(key);
}

References m_config.

Referenced by Slic3r::GUI::Plater::open_platesettings_dialog(), and render_icons().

Here is the caller graph for this function:

icon_scale_factor()

float Slic3r::GUI::PartPlate::icon_scale_factor ( ) const

private

{
    const BoundingBoxf bed_ext  = get_extents(m_shape);
    const double       by_depth = bed_ext.size().y() / 200.;
    const double       by_gap   = bed_ext.size().x() * LOGICAL_PART_PLATE_GAP / (PARTPLATE_ICON_SIZE + 2 * PARTPLATE_ICON_GAP_LEFT);
    return float(std::min(by_depth, by_gap));
}

References Slic3r::get_extents(), LOGICAL_PART_PLATE_GAP, m_shape, PARTPLATE_ICON_GAP_LEFT, PARTPLATE_ICON_SIZE, and Slic3r::BoundingBoxBase< PointType, APointsType >::size().

Referenced by calc_vertex_for_icons(), calc_vertex_for_number(), calc_vertex_for_plate_name_edit_icon(), and generate_plate_name_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

{ return m_id; }

References m_id.

Referenced by Slic3r::CutObjectBase::CutObjectBase(), Slic3r::Model::Model(), Slic3r::ModelInstance::ModelInstance(), Slic3r::ModelMaterial::ModelMaterial(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), ObjectBase(), Slic3r::PrintBase::SlicingStatus::SlicingStatus(), Slic3r::PrintBase::SlicingStatus::SlicingStatus(), Slic3r::_BBS_3MF_Exporter::_add_cut_information_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::GUI::Plater::priv::actualize_slicing_warnings(), Slic3r::ModelObjectStatusDB::add(), Slic3r::ModelObjectStatusDB::add_if_new(), Slic3r::Model::add_object(), Slic3r::append_and_translate(), Slic3r::SLAPrint::apply(), Slic3r::GUI::calc_distance(), Slic3r::GUI::calc_surface_offset(), Slic3r::check_model_ids_equal(), Slic3r::check_model_ids_validity(), Slic3r::GUI::GLGizmoTextureDisplacement::close_image_adjust(), Slic3r::Model::collect_reusable_objects(), Slic3r::ModelObject::convert_units(), copy_id(), Slic3r::PrintObjectStatusDB::count(), anonymous_namespace{RaycastManager.cpp}::create_key(), Slic3r::GUI::create_meshes(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::GUI::Emboss::create_volume_sources(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GCode::do_export(), Slic3r::GUI::PartPlate::duplicate_all_instance(), Slic3r::GUI::PartPlateList::duplicate_plate(), Slic3r::GUI::PartPlate::estimate_wipe_tower_footprint(), Slic3r::Print::export_cached_data(), Slic3r::GUI::Plater::export_stl(), Slic3r::find_volume_extents(), Slic3r::PreciseSeam::detail::fragment_location(), Slic3r::GUI::Plater::priv::generate_first_layer_bbox(), Slic3r::ModelObjectStatusDB::get(), Slic3r::Model::get_backup_path(), Slic3r::GUI::GLCanvas3D::get_empty_cells(), Slic3r::ModelInstance::get_labeled_id(), Slic3r::GUI::get_model_volume(), Slic3r::PrintObjectStatusDB::get_range(), Slic3r::GUI::get_selected_volume(), Slic3r::GUI::get_volume(), Slic3r::CutObjectBase::has_same_id(), Slic3r::UndoRedo::StackImpl::immutable_object_id_impl(), Slic3r::GUI::GLGizmoFdmSupports::init_print_instance(), Slic3r::CutObjectBase::is_equal(), Slic3r::GUI::GLGizmoSVG::is_svg_object(), Slic3r::ModelVolume::is_the_only_one_part(), Slic3r::GUI::IMSlider::IsNewPrint(), Slic3r::ModelObject::load(), load_and_construct(), Slic3r::Print::load_cached_data(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::GUI::GCodeViewer::load_shells(), Slic3r::UndoRedo::StackImpl::load_snapshot(), Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers(), Slic3r::model_property_changed(), Slic3r::model_volume_list_changed(), Slic3r::model_volume_list_copy_configs(), Slic3r::ModelConfigObject::object_id_and_timestamp_match(), Slic3r::ObjectWithTimestamp::object_id_and_timestamp_match(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::open_image_adjust(), Slic3r::CutObjectBase::operator<(), Slic3r::Model::operator=(), Slic3r::ModelObject::operator=(), Slic3r::ModelObject::operator=(), Slic3r::CutObjectBase::operator==(), Slic3r::outer_inner_brim_area(), Slic3r::GUI::GLGizmoTextureDisplacement::painted_area_mm2(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), anonymous_namespace{GLGizmoEmboss.cpp}::prepare_volumes_to_slice(), Slic3r::GUI::GLGizmoTextureDisplacement::preview_part(), Slic3r::GCode::process_layer(), Slic3r::GUI::NotificationManager::push_slicing_warning_notification(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_preview_job(), Slic3r::GUI::queue_texture_displacement_debug(), Slic3r::GUI::GLGizmoEmboss::re_emboss(), Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_other_paint_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_painted_colors(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::_BBS_Backup_Manager::remove_backup(), Slic3r::Model::remove_backup_path_if_exist(), Slic3r::GUI::GLGizmoTextureDisplacement::render_image_adjust_window(), Slic3r::CLI::run(), Slic3r::GUI::GLCanvas3D::LayersEditing::select_object(), Slic3r::ModelMaterial::serialize(), Slic3r::Model::set_backup_path(), Slic3r::GUI::GLGizmoBrimEars::set_brim_data(), Slic3r::GUI::PartPlate::set_hover_id(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), Slic3r::GUI::GLGizmoSVG::set_volume_by_selection(), Slic3r::sla_instances(), Slic3r::slices_to_regions(), Slic3r::ModelObject::split(), anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job(), anonymous_namespace{SurfaceDrag.cpp}::start_dragging(), Slic3r::GUI::Emboss::start_update_volume(), Slic3r::UndoRedo::StackImpl::take_snapshot(), Slic3r::GUI::texture_displacement_bake_volume(), Slic3r::GUI::GLGizmoPainterBase::update_contours(), anonymous_namespace{EmbossJob.cpp}::update_name_in_list(), Slic3r::GUI::ObjectList::update_name_in_model(), Slic3r::GUI::update_object_cut_id(), Slic3r::GUI::GLGizmoTextureDisplacement::v2_recommendation(), Slic3r::verify_update_print_object_regions(), wipe_tower_instance_id, and wipe_tower_object_id.

imex_collision_zones()

const std::vector< BoundingBoxf3 > & Slic3r::GUI::PartPlate::imex_collision_zones ( ) const

inline

{ return m_imex_collision_zones; }

References m_imex_collision_zones.

imex_ghost_composite_id_for_head()

int Slic3r::GUI::PartPlate::imex_ghost_composite_id_for_head ( int physical_head )

inlinestatic

                                                                    {
        return IMEX_GHOST_COMPOSITE_ID_BASE - physical_head;
    }

References IMEX_GHOST_COMPOSITE_ID_BASE.

Referenced by calc_imex_ghosts().

Here is the caller graph for this function:

imex_ghost_head_from_composite_id()

int Slic3r::GUI::PartPlate::imex_ghost_head_from_composite_id ( int object_id )

inlinestatic

                                                                 {
        return IMEX_GHOST_COMPOSITE_ID_BASE - object_id;
    }

References IMEX_GHOST_COMPOSITE_ID_BASE.

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass_imex_ghosts(), update_imex_ghost_colors(), and update_imex_ghost_transforms().

Here is the caller graph for this function:

imex_hull_violates()

bool Slic3r::GUI::PartPlate::imex_hull_violates

(

const Polygon &

hull

)

const

{
    return imex_hull_violates_zones(m_imex_secondary_zone_boxes, hull)
        || imex_hull_violates_zones(m_imex_collision_zones, hull);
}

References Slic3r::imex_hull_violates_zones(), m_imex_collision_zones, and m_imex_secondary_zone_boxes.

Referenced by check_outside(), and imex_placement_violation().

Here is the call graph for this function:

Here is the caller graph for this function:

imex_placement_violation()

PartPlate::ImexPlacementViolation Slic3r::GUI::PartPlate::imex_placement_violation

(

)

{
    ensure_imex_zones();
    if (m_imex_secondary_zone_boxes.empty() && m_imex_collision_zones.empty())
        return ImexPlacementViolation::None;
    for (const auto& pr : obj_to_instance_set) {
        int obj_id = pr.first;
        int instance_id = pr.second;
        if (!valid_instance(obj_id, instance_id))
            continue;
        ModelInstance* instance = m_model->objects[obj_id]->instances[instance_id];
        if (imex_hull_violates(instance->convex_hull_2d()))
            return ImexPlacementViolation::Object;
    }
    if (imex_hull_violates(imex_wipe_tower_hull()))
        return ImexPlacementViolation::PrimeTower;
    return ImexPlacementViolation::None;
}

References Slic3r::ModelInstance::convex_hull_2d(), ensure_imex_zones(), imex_hull_violates(), imex_wipe_tower_hull(), m_imex_collision_zones, m_imex_secondary_zone_boxes, m_model, None, obj_to_instance_set, Object, PrimeTower, and valid_instance().

Referenced by Slic3r::GUI::anonymous_namespace{Plater.cpp}::imex_placement_error().

Here is the call graph for this function:

Here is the caller graph for this function:

imex_primary_zone()

std::optional< BoundingBoxf > Slic3r::GUI::PartPlate::imex_primary_zone ( )

inline

{ ensure_imex_zones(); return m_imex_primary_zone_box; }

References ensure_imex_zones(), and m_imex_primary_zone_box.

Here is the call graph for this function:

imex_wipe_tower_hull()

Polygon Slic3r::GUI::PartPlate::imex_wipe_tower_hull

(

)

const

{
    // The estimate walks m_model->objects, and this runs even on an empty plate. The
    // m_print arm is dead since the estimate stopped reading it; dropping it would newly
    // validate plates this currently skips.
    if (!m_plater || !m_print || !m_model)
        return Polygon();
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    if (!preset_bundle)
        return Polygon();
 
    const DynamicPrintConfig& print_cfg = preset_bundle->prints.get_edited_preset().config;
 
    // Whether a tower is PRINTED is normalize_fdm_2's rule, shared with the slicer through
    // prime_tower_is_printed() rather than re-derived here - re-deriving it is what let this
    // validate a tower the slicer had already cancelled. Do not substitute the footprint
    // estimate: it never reads enable_prime_tower or print_sequence, so it still sizes a tower
    // for a plate that switched the tower off or prints by object, which would hard-block a
    // plate with nothing drawn on screen to move.
    //
    // Counts are the ones normalize_fdm_2 is handed: filament slots as authored, so a mixed
    // slot counts once, and distinct objects rather than instances. filament_is_mixed is a
    // project option, hence read separately.
    const auto* mixed_opt = preset_bundle->project_config.option<ConfigOptionBools>("filament_is_mixed");
    const bool  has_mixed = mixed_opt != nullptr && has_any_mixed_filament(mixed_opt->values);
    std::set<int> plate_objects;
    for (const auto& pr : obj_to_instance_set)
        plate_objects.insert(pr.first);
    if (!prime_tower_is_printed(print_cfg, (int) get_extruders(true, /*expand_mixed_slots=*/false).size(),
                                (int) plate_objects.size(), has_mixed))
        return Polygon();
 
    // The estimate's floor counts what is purged, so a mixed slot counts as its components here.
    const int plate_extruder_size = (int) get_extruders(true).size();
 
    Vec3d wt_pos, wt_size;
    // full_config(), not the print preset: wipe_tower_x/y are project options the estimate
    // dereferences unchecked. apply_extruder=false, so the per-filament arrays arrive as the
    // concatenation of each preset's declared variants rather than one entry per filament.
    // That matters now: filament_minimal_purge_on_wipe_tower became variant-keyed upstream and
    // WipeTower2::extract_wipe_volumes indexes it by raw filament slot, so a multi-variant
    // filament preset on a single-extruder-multi-material machine would estimate the tower
    // from the wrong column. No shipped preset pairs the two today.
    // plate_extruder_size is a floor, not an override; the scene passes 0, and both counts
    // come from the same object walk.
    arrangement::ArrangePolygon ap = estimate_wipe_tower_polygon(preset_bundle->full_config(false), m_plate_index, wt_pos, wt_size, plate_extruder_size);
    if (wt_size(0) <= 0. || wt_size(1) <= 0. || ap.poly.contour.points.empty())
        return Polygon();
 
    // Only the estimated box and brim are validated. The depth is approximate, so a sliced
    // tower can exceed it (the true footprint is Print::first_layer_wipe_tower_corners(),
    // post-slice only). A Type2 cone's bulge is already in the margin the hull is built
    // from - do not add a second allowance. Object brim, skirt and supports are unvalidated
    // here too.
    Polygon hull = ap.poly.contour;
 
    // The estimate is an axis-aligned box, but the real tower is rotated about its anchor
    // corner before placement, so without this a rotated footprint escapes the hull.
    if (const auto* rot = print_cfg.option<ConfigOptionFloat>("wipe_tower_rotation_angle");
        rot && rot->value != 0.)
        hull.rotate(Geometry::deg2rad(rot->value),
                    Point(scaled(wt_pos.x()), scaled(wt_pos.y())));
 
    // Plate-local mm to plate-list coordinates, which the zones and instance hulls use.
    hull.translate(Point(scaled(m_origin.x()), scaled(m_origin.y())));
    return hull;
}

References Slic3r::Preset::config, Slic3r::ExPolygon::contour, Slic3r::Geometry::deg2rad(), estimate_wipe_tower_polygon(), Slic3r::PresetBundle::full_config(), Slic3r::PresetCollection::get_edited_preset(), get_extruders(), Slic3r::has_any_mixed_filament(), m_model, m_origin, m_plate_index, m_plater, m_print, obj_to_instance_set, Slic3r::ConfigBase::option(), Slic3r::MultiPoint::points, Slic3r::arrangement::ArrangePolygon::poly, Slic3r::prime_tower_is_printed(), Slic3r::PresetBundle::prints, Slic3r::PresetBundle::project_config, Slic3r::MultiPoint::rotate(), Slic3r::scaled(), Slic3r::MultiPoint::translate(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by imex_placement_violation().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Slic3r::GUI::PartPlate::init ( )

private

{
  m_locked = false;
  m_ready_for_slice = true;
  m_slice_result_valid = false;
  m_slice_percent = -1.0f; // ORCA create new plates with negative values or it will take "slicing" role on toolbar
                             // condition for sliced / slicing -- if (plate_list.get_plate(i)->get_slicing_percent() < 0.0f)
  m_hover_id = -1;
  m_selected = false;
  //m_quadric = ::gluNewQuadric();
  //if (m_quadric != nullptr)
  //  ::gluQuadricDrawStyle(m_quadric, GLU_FILL);
 
  m_print_index = -1;
  m_print = nullptr;
  m_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode", true)->value = FilamentMapMode::fmmAutoForFlush;
}

References Slic3r::fmmAutoForFlush, m_config, m_hover_id, m_locked, m_print, m_print_index, m_ready_for_slice, m_selected, m_slice_percent, and m_slice_result_valid.

Referenced by PartPlate(), and PartPlate().

Here is the caller graph for this function:

intersect_instance()

bool Slic3r::GUI::PartPlate::intersect_instance	(	int	obj_id,
		int	instance_id,
		BoundingBoxf3 *	bounding_box = nullptr )

{
  bool result = false;
 
  if (!valid_instance(obj_id, instance_id))
  {
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": plate_id %1%, invalid obj_id %2%, instance_id %3%") % m_plate_index % obj_id % instance_id;
    return false;
  }
 
  if (m_printable)
  {
    ModelObject* object = m_model->objects[obj_id];
    ModelInstance* instance = object->instances[instance_id];
    BoundingBoxf3 instance_box = bounding_box? *bounding_box: object->instance_convex_hull_bounding_box(instance_id);
    result = get_plate_box().intersects(instance_box);
  }
  else
  {
    result = is_left_top_of(obj_id, instance_id);
  }
 
  return result;
}

References Slic3r::bounding_box(), get_plate_box(), Slic3r::BoundingBox3Base< PointType >::intersects(), is_left_top_of(), m_model, m_plate_index, m_printable, and valid_instance().

Referenced by Slic3r::GUI::PartPlateList::construct_objects_list_for_new_plate(), Slic3r::GUI::Selection::get_volume_idxs_from_plate(), move_instances_to(), Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::GUI::ArrangeJob::prepare_partplate(), Slic3r::GUI::PartPlateList::reload_all_objects(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

intersects()

bool Slic3r::GUI::PartPlate::intersects

(

const BoundingBoxf3 &

bb

)

const

{
  // Allow the objects to protrude below the print bed
  BoundingBoxf3 print_volume(Vec3d(m_bounding_box.min(0), m_bounding_box.min(1), 0.0), Vec3d(m_bounding_box.max(0), m_bounding_box.max(1), 1e3));
  print_volume.min(2) = -1e10;
  print_volume.min(0) -= Slic3r::BuildVolume::BedEpsilon;
  print_volume.min(1) -= Slic3r::BuildVolume::BedEpsilon;
  print_volume.max(0) += Slic3r::BuildVolume::BedEpsilon;
  print_volume.max(1) += Slic3r::BuildVolume::BedEpsilon;
  this->open_belt_y(print_volume);
  return print_volume.intersects(bb);
}

References Slic3r::BuildVolume::BedEpsilon, Slic3r::BoundingBox3Base< PointType >::intersects(), m_bounding_box, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and open_belt_y().

Referenced by Slic3r::GUI::PartPlateList::find_instance(), and Slic3r::GUI::Selection::paste_objects_from_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_exclusion_volume_preview()

void Slic3r::GUI::PartPlate::invalidate_exclusion_volume_preview

(

)

{
    m_exclusion_volume_preview_dirty = true;
}

References m_exclusion_volume_preview_dirty.

Referenced by add_instance(), clear(), clear_filament_map(), duplicate_all_instance(), Slic3r::GUI::PartPlateList::duplicate_plate(), load(), remove_instance(), set_filament_map_mode(), set_filament_maps(), set_pos_and_size(), set_print(), set_shape(), translate_all_instance(), update_instance_exclude_status(), and update_object_index().

Here is the caller graph for this function:

invalidate_imex_ghosts()

void Slic3r::GUI::PartPlate::invalidate_imex_ghosts ( )

inline

{ m_imex_ghost_cache_key = "\x01"; }

References m_imex_ghost_cache_key.

invalidate_plate_name_texture()

void Slic3r::GUI::PartPlate::invalidate_plate_name_texture ( )

private

{
  m_plate_name_edit_icon.mesh_raycaster.reset();
 
  auto canvas = (m_plater != nullptr) ? m_plater->get_view3D_canvas3D() : nullptr;
  if (canvas != nullptr) {
    canvas->remove_raycasters_for_picking(SceneRaycaster::EType::Bed, picking_id_component(6));
    canvas->set_as_dirty();
  }
}

References Slic3r::GUI::SceneRaycaster::Bed, m_plate_name_edit_icon, m_plater, and picking_id_component().

Referenced by clear(), set_plate_name(), and set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

is_all_instances_unprintable()

bool Slic3r::GUI::PartPlate::is_all_instances_unprintable

(

)

{
    bool result = true;
 
    for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it) {
        int obj_id      = it->first;
        int instance_id = it->second;
 
        if (!valid_instance(obj_id, instance_id))
            continue;
 
        ModelObject *  object   = m_model->objects[obj_id];
        ModelInstance *instance = object->instances[instance_id];
 
        if ((instance->printable)) {
            result = false;
            break;
        }
    }
 
    return result;
}

References m_model, obj_to_instance_set, Slic3r::ModelInstance::printable, and valid_instance().

Here is the call graph for this function:

is_apply_result_invalid()

bool Slic3r::GUI::PartPlate::is_apply_result_invalid ( ) const

inline

    {
        return m_apply_invalid;
    }

References m_apply_invalid.

is_imex_ghost_composite_id()

bool Slic3r::GUI::PartPlate::is_imex_ghost_composite_id ( int object_id )

inlinestatic

                                                          {
        return object_id <= IMEX_GHOST_COMPOSITE_ID_BASE
            && object_id >  IMEX_GHOST_COMPOSITE_ID_BASE - IMEX_GHOST_MAX_HEADS;
    }

References IMEX_GHOST_COMPOSITE_ID_BASE, and IMEX_GHOST_MAX_HEADS.

is_left_top_of()

bool Slic3r::GUI::PartPlate::is_left_top_of	(	int	obj_id,
		int	instance_id )

{
  bool result = false;
 
  if (!valid_instance(obj_id, instance_id))
  {
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": plate_id %1%, invalid obj_id %2%, instance_id %3%") % m_plate_index % obj_id % instance_id;
    return false;
  }
 
  ModelObject* object = m_model->objects[obj_id];
  ModelInstance* instance = object->instances[instance_id];
  std::pair<int, int> pair(obj_id, instance_id);
  BoundingBoxf3 instance_box = object->instance_convex_hull_bounding_box(instance_id);
 
  result = (m_origin.x() <= instance_box.min.x()) && (m_origin.y() >= instance_box.min.y());
  return result;
}

References m_model, m_origin, m_plate_index, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and valid_instance().

Referenced by intersect_instance().

Here is the call graph for this function:

Here is the caller graph for this function:

is_locked()

bool Slic3r::GUI::PartPlate::is_locked ( ) const

inline

{ return m_locked; }

References m_locked.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_locked(), Slic3r::GUI::PartPlateList::clear(), Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_imex_zones(), Slic3r::GUI::ArrangeJob::prepare_partplate(), Slic3r::GUI::OrientJob::prepare_partplate(), and render_icons().

Here is the caller graph for this function:

is_printable()

bool Slic3r::GUI::PartPlate::is_printable ( ) const

inline

{ return m_printable; }

References m_printable.

is_slice_result_ready_for_export()

bool Slic3r::GUI::PartPlate::is_slice_result_ready_for_export ( )

inline

    {
        return is_slice_result_ready_for_print() && has_printable_instances();
    }

References has_printable_instances(), and is_slice_result_ready_for_print().

Referenced by Slic3r::GUI::MainFrame::get_enable_print_status().

Here is the call graph for this function:

Here is the caller graph for this function:

is_slice_result_ready_for_print()

bool Slic3r::GUI::PartPlate::is_slice_result_ready_for_print ( ) const

inline

    {
        bool result = m_slice_result_valid;
        if (result)
            result = m_gcode_result ?
      (!m_gcode_result->toolpath_outside && m_gcode_result->gcode_check_result.error_code == 0 && !m_gcode_result->filament_printable_reuslt.has_value()) :
      false;// && !m_gcode_result->conflict_result.has_value()  gcode conflict can also print
        return result;
    }

References m_gcode_result, and m_slice_result_valid.

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::MainFrame::can_export_gcode(), Slic3r::GUI::MainFrame::get_enable_print_status(), and is_slice_result_ready_for_export().

Here is the caller graph for this function:

is_slice_result_valid()

bool Slic3r::GUI::PartPlate::is_slice_result_valid ( ) const

inline

    {
        return m_slice_result_valid;
    }

References m_slice_result_valid.

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::Plater::apply_background_progress(), Slic3r::GUI::MainFrame::get_enable_print_status(), Slic3r::GUI::MainFrame::get_enable_slice_status(), get_gcode_filename(), Slic3r::GUI::GCodeViewer::load_as_gcode(), Slic3r::GUI::Plater::priv::on_process_completed(), Slic3r::GUI::Plater::priv::restart_background_process(), Slic3r::CLI::run(), Slic3r::GUI::Plater::select_plate(), Slic3r::GUI::Plater::select_plate_by_hover_id(), Slic3r::GUI::Plater::priv::set_current_panel(), and Slic3r::GUI::Plater::priv::update_background_process().

Here is the caller graph for this function:

is_valid_gcode_file()

bool Slic3r::GUI::PartPlate::is_valid_gcode_file

(

)

{
  if (get_gcode_filename().empty())
    return false;
  boost::filesystem::path gcode_file(m_gcode_result->filename);
  if (!boost::filesystem::exists(gcode_file)) {
    BOOST_LOG_TRIVIAL(info) << "invalid gcode file, file is missing, file = " << m_gcode_result->filename;
    return false;
  }
  return true;
}

References empty(), get_gcode_filename(), and m_gcode_result.

Referenced by Slic3r::GUI::PrintJob::process(), Slic3r::GUI::SendJob::process(), and Slic3r::GUI::SelectMachineDialog::update_show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

load()

template<class Archive>

void Slic3r::GUI::PartPlate::load ( Archive & ar )

inline

                                                   {
        std::vector<std::pair<int, int>>  objects_and_instances;
        std::vector<std::pair<int, int>>  instances_outside;
 
        ar(m_plate_index, m_name, m_print_index, m_origin, m_width, m_depth, m_height, m_locked, m_selected, m_ready_for_slice, m_slice_result_valid, m_apply_invalid, m_printable, m_tmp_gcode_path, objects_and_instances, instances_outside, m_config);
 
        for (std::vector<std::pair<int, int>>::iterator it = objects_and_instances.begin(); it != objects_and_instances.end(); ++it)
            obj_to_instance_set.insert(std::pair(it->first, it->second));
 
        for (std::vector<std::pair<int, int>>::iterator it = instances_outside.begin(); it != instances_outside.end(); ++it)
            instance_outside_set.insert(std::pair(it->first, it->second));
 
        invalidate_exclusion_volume_preview();
    }

References instance_outside_set, invalidate_exclusion_volume_preview(), m_apply_invalid, m_config, m_depth, m_height, m_locked, m_name, m_origin, m_plate_index, m_print_index, m_printable, m_ready_for_slice, m_selected, m_slice_result_valid, m_tmp_gcode_path, m_width, and obj_to_instance_set.

Here is the call graph for this function:

load_and_construct()

template<class Archive>

void Slic3r::ObjectBase::load_and_construct ( Archive & ar, cereal::construct< ObjectBase > & construct )

inlinestaticprivateinherited

{ ObjectID id; ar(id); construct(id); }

References id().

Here is the call graph for this function:

load_gcode_from_file()

int Slic3r::GUI::PartPlate::load_gcode_from_file

(

const std::string &

filename

)

{
  int ret = 0;
 
  // process gcode
  auto& preset_bundle = wxGetApp().preset_bundle;
  std::vector<int>   filament_maps = this->get_filament_maps();
  // Inject the plate's volume map (or the per-extruder defaults) exactly like the apply-time
  // composition, so the config applied over the loaded slice result matches the next
  // background-process apply and does not invalidate the embedded g-code.
  std::vector<int> f_volume_maps = this->get_filament_volume_maps();
  if (f_volume_maps.empty()) {
    f_volume_maps = preset_bundle->get_default_nozzle_volume_types_for_filaments(filament_maps);
  }
  DynamicPrintConfig full_config   = preset_bundle->full_config(false, filament_maps, f_volume_maps);
  full_config.apply(m_config, true);
  m_print->apply(*m_model, full_config, false);
  //BBS: need to apply two times, for after the first apply, the m_print got its object,
  //which will affect the config when new_full_config.normalize_fdm(used_filaments);
  m_print->apply(*m_model, full_config, false);
 
  // BBS: use backup path to save temp gcode
    // auto path = get_tmp_gcode_path();
    // if (boost::filesystem::exists(boost::filesystem::path(path))) {
    //  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": file %1% exists, delete it firstly") % filename.c_str();
    //  boost::nowide::remove(path.c_str());
    //}
 
    // std::error_code error = rename_file(filename, path);
    // if (error) {
    //  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("Failed to rename the output G-code file from %1% to %2%, error code %3%") % filename.c_str() % path.c_str() %
    //error.message();  return -1;
    //}
  if (boost::filesystem::exists(filename)) {
    assert(m_tmp_gcode_path.empty());
    m_tmp_gcode_path = filename;
    m_gcode_result->filename = filename;
    m_print->set_gcode_file_ready();
 
    update_slice_result_valid_state(true);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": found valid gcode file %1%") % filename.c_str();
  }
  else {
    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": can not find gcode file %1%") % filename.c_str();
    ret = -1;
  }
 
  m_ready_for_slice = true;
  return ret;
}

References Slic3r::ConfigBase::apply(), get_filament_maps(), get_filament_volume_maps(), m_config, m_gcode_result, m_model, m_print, m_ready_for_slice, m_tmp_gcode_path, and update_slice_result_valid_state().

Here is the call graph for this function:

load_pattern_box_data()

int Slic3r::GUI::PartPlate::load_pattern_box_data

(

std::string

filename

)

{
    try {
        nlohmann::json j;
        boost::nowide::ifstream ifs(filename);
        ifs >> j;
 
        PlateBBoxData bbox_data;
        bbox_data.from_json(j);
        cali_bboxes_data = bbox_data;
        return 0;
    }
    catch(std::exception &ex) {
        BOOST_LOG_TRIVIAL(trace) << boost::format("catch an exception %1%")%ex.what();
        return -1;
    }
}

References cali_bboxes_data, Slic3r::PlateBBoxData::from_json(), and Slic3r::trace().

Here is the call graph for this function:

load_pattern_thumbnail_data()

int Slic3r::GUI::PartPlate::load_pattern_thumbnail_data

(

std::string

filename

)

{
  /*bool result = true;
  wxImage img;
  result = load_image(filename, img);
  if (result) {
    cali_thumbnail_data.set(img.GetWidth(), img.GetHeight());
    for (int i = 0; i < img.GetWidth() * img.GetHeight(); i++) {
      memcpy(&cali_thumbnail_data.pixels[4 * i], (unsigned char*)(img.GetData() + 3 * i), 3);
      if (img.HasAlpha()) {
        cali_thumbnail_data.pixels[4 * i + 3] = *(unsigned char*)(img.GetAlpha() + i);
      }
    }
  }
  else {
    return -1;
  }*/
  return 0;
}

load_render_colors()

void Slic3r::GUI::PartPlate::load_render_colors ( )

static

{
    RenderColor::colors[RenderCol_Plate_Selected]    = ImGuiWrapper::to_ImVec4(SELECT_COLOR);
    RenderColor::colors[RenderCol_Plate_Unselected]  = ImGuiWrapper::to_ImVec4(UNSELECT_COLOR);
    RenderColor::colors[RenderCol_Plate_Default]     = ImGuiWrapper::to_ImVec4(DEFAULT_COLOR);
    RenderColor::colors[RenderCol_Plate_Line_Top]    = ImGuiWrapper::to_ImVec4(LINE_TOP_COLOR);
    RenderColor::colors[RenderCol_Plate_Line_Bottom] = ImGuiWrapper::to_ImVec4(LINE_BOTTOM_COLOR);
}

References Slic3r::RenderColor::colors, DEFAULT_COLOR, LINE_BOTTOM_COLOR, LINE_TOP_COLOR, RenderCol_Plate_Default, RenderCol_Plate_Line_Bottom, RenderCol_Plate_Line_Top, RenderCol_Plate_Selected, RenderCol_Plate_Unselected, SELECT_COLOR, Slic3r::GUI::ImGuiWrapper::to_ImVec4(), and UNSELECT_COLOR.

Referenced by Slic3r::GUI::GLCanvas3D::init().

Here is the call graph for this function:

Here is the caller graph for this function:

load_thumbnail_data()

int Slic3r::GUI::PartPlate::load_thumbnail_data	(	std::string	filename,
		ThumbnailData &	thumb_data )

{
  bool result = true;
  wxImage img;
  if (boost::algorithm::iends_with(filename, ".png")) {
    result = img.LoadFile(wxString::FromUTF8(filename.c_str()), wxBITMAP_TYPE_PNG);
    img = img.Mirror(false);
  }
  if (result) {
    thumb_data.set(img.GetWidth(), img.GetHeight());
    for (int i = 0; i < img.GetWidth() * img.GetHeight(); i++) {
      memcpy(&thumb_data.pixels[4 * i], (unsigned char*)(img.GetData() + 3 * i), 3);
      if (img.HasAlpha()) {
        thumb_data.pixels[4 * i + 3] = *(unsigned char*)(img.GetAlpha() + i);
      }
    }
  } else {
    return -1;
  }
  return 0;
}

References Slic3r::ThumbnailData::pixels, and Slic3r::ThumbnailData::set().

Here is the call graph for this function:

lock()

void Slic3r::GUI::PartPlate::lock ( bool state )

inline

{ m_locked = state; }

References m_locked.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_locked(), Slic3r::GUI::ArrangeJob::finalize(), Slic3r::GUI::PartPlateList::lock_plate(), Slic3r::GUI::ArrangeJob::prepare_all(), and Slic3r::CLI::run().

Here is the caller graph for this function:

max_broad_phase_intersecting_object_height()

double Slic3r::GUI::PartPlate::max_broad_phase_intersecting_object_height ( const Polygons & regions ) const

private

{
    if (m_model == nullptr)
        return 0.0;
 
    double max_height = 0.0;
 
    for (const std::pair<int, int> &object_instance : obj_to_instance_set) {
        const int obj_id = object_instance.first;
        const int instance_id = object_instance.second;
        if (obj_id < 0 || obj_id >= int(m_model->objects.size()))
            continue;
 
        ModelObject *object = m_model->objects[obj_id];
        if (instance_id < 0 || instance_id >= int(object->instances.size()))
            continue;
 
        ModelInstance *instance = object->instances[instance_id];
        if (!instance->printable)
            continue;
 
        Polygon hull = instance->convex_hull_2d();
        bool intersects_region = false;
        for (const Polygon &region : regions) {
            if (!intersection(Polygons{ region }, Polygons{ hull }).empty()) {
                intersects_region = true;
                break;
            }
        }
 
        if (!intersects_region)
            continue;
 
        const BoundingBoxf3 instance_box = object->instance_convex_hull_bounding_box(instance_id);
        max_height = std::max(max_height, instance_box.max.z());
    }
 
    return max_height;
}

References Slic3r::ModelInstance::convex_hull_2d(), Slic3r::ModelObject::instances, Slic3r::intersection(), m_model, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, obj_to_instance_set, and Slic3r::ModelInstance::printable.

Referenced by update_exclusion_volume_preview_models().

Here is the call graph for this function:

Here is the caller graph for this function:

move_instances_to()

void Slic3r::GUI::PartPlate::move_instances_to	(	PartPlate &	left_plate,
		PartPlate &	right_plate,
		BoundingBoxf3 *	bounding_box = nullptr )

{
  for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it)
  {
    int obj_id = it->first;
    int instance_id = it->second;
 
    if (left_plate.intersect_instance(obj_id, instance_id, bounding_box))
      left_plate.add_instance(obj_id, instance_id, false, bounding_box);
    else
      right_plate.add_instance(obj_id, instance_id, false, bounding_box);
  }
 
  return;
}

References PartPlate(), add_instance(), Slic3r::bounding_box(), intersect_instance(), and obj_to_instance_set.

Referenced by Slic3r::GUI::PartPlateList::delete_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

on_extruder_count_changed()

void Slic3r::GUI::PartPlate::on_extruder_count_changed

(

int

extruder_count

)

{
    if (extruder_count < 2) {
        std::vector<int> f_map = wxGetApp().plater()->get_global_filament_map();
        std::fill(f_map.begin(), f_map.end(), 1);
        wxGetApp().plater()->set_global_filament_map(f_map);
        // clear filament map and mode in single extruder mode
        clear_filament_map();
        //clear_filament_map_mode();
        // do not clear mode now, reset to default mode
        m_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode", true)->value = FilamentMapMode::fmmAutoForFlush;
    }
}

References clear_filament_map(), Slic3r::fmmAutoForFlush, and m_config.

Here is the call graph for this function:

on_filament_added()

void Slic3r::GUI::PartPlate::on_filament_added

(

)

{
    if (m_config.has("filament_map")) {
        std::vector<int>& filament_maps = m_config.option<ConfigOptionInts>("filament_map")->values;
        filament_maps.push_back(1);
    }
 
    if (m_config.has("filament_nozzle_map")) {
        std::vector<int>& filament_nozzle_map = m_config.option<ConfigOptionInts>("filament_nozzle_map")->values;
        filament_nozzle_map.push_back(0);
    }
 
    if (m_config.has("filament_volume_map")) {
        std::vector<int>& filament_volume_map = m_config.option<ConfigOptionInts>("filament_volume_map")->values;
        // A new filament defaults onto the first extruder, so seed its volume value from
        // that extruder's flow type.
        int volume_type = static_cast<int>(NozzleVolumeType::nvtStandard);
        auto nozzle_volumes = wxGetApp().preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
        if (nozzle_volumes && !nozzle_volumes->values.empty())
            volume_type = nozzle_volumes->values[0];
        // Orca: never store the Hybrid marker as a per-filament value; on a Hybrid extruder
        // each filament still prints with a concrete flow, defaulting to Standard.
        if (volume_type == static_cast<int>(NozzleVolumeType::nvtHybrid))
            volume_type = static_cast<int>(NozzleVolumeType::nvtStandard);
 
        filament_volume_map.push_back(volume_type);
    }
}

References Slic3r::filament_nozzle_map(), m_config, Slic3r::nvtHybrid, and Slic3r::nvtStandard.

Here is the call graph for this function:

on_filament_deleted()

void Slic3r::GUI::PartPlate::on_filament_deleted	(	int	filament_count,
		int	filament_id )

{
    if (m_config.has("filament_map")) {
        std::vector<int>& filament_maps = m_config.option<ConfigOptionInts>("filament_map")->values;
        // Guard against an out-of-range index: the per-plate filament_map can be out of sync
        // with the global filament count, and erasing at/past end() triggers an out-of-bounds
        // memmove (crash on macOS, see PartPlate::on_filament_deleted in crash reports).
        if (filament_id >= 0 && filament_id < (int) filament_maps.size())
            filament_maps.erase(filament_maps.begin() + filament_id);
    }
 
    if (m_config.has("filament_nozzle_map")) {
        std::vector<int>& filament_nozzle_map = m_config.option<ConfigOptionInts>("filament_nozzle_map")->values;
        if (filament_id >= 0 && filament_id < (int) filament_nozzle_map.size())
            filament_nozzle_map.erase(filament_nozzle_map.begin() + filament_id);
    }
 
    if (m_config.has("filament_volume_map")) {
        std::vector<int>& filament_volume_map = m_config.option<ConfigOptionInts>("filament_volume_map")->values;
        if (filament_id >= 0 && filament_id < (int) filament_volume_map.size())
            filament_volume_map.erase(filament_volume_map.begin() + filament_id);
    }
 
    update_first_layer_print_sequence_when_delete_filament(filament_id);
}

References Slic3r::filament_nozzle_map(), m_config, and update_first_layer_print_sequence_when_delete_filament().

Here is the call graph for this function:

on_filament_map_mode_change()

void Slic3r::GUI::PartPlate::on_filament_map_mode_change ( )

private

References config().

Here is the call graph for this function:

open_belt_y()

void Slic3r::GUI::PartPlate::open_belt_y ( BoundingBoxf3 & box ) const

inline

{ if (this->belt_open_y()) { box.min.y() = -1e5; box.max.y() = 1e5; } }

References belt_open_y(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, and Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min.

Referenced by check_outside(), contains(), and intersects().

Here is the call graph for this function:

Here is the caller graph for this function:

operator<()

bool Slic3r::GUI::PartPlate::operator<

(

PartPlate &

plate

)

const

{
  int index = plate.get_index();
  return (this->m_plate_index < index);
}

References PartPlate(), get_index(), and m_plate_index.

Here is the call graph for this function:

picking_id_component()

int Slic3r::GUI::PartPlate::picking_id_component ( int idx ) const

private

{
    return this->m_plate_index * GRABBER_COUNT + idx;
}

References GRABBER_COUNT, and m_plate_index.

Referenced by generate_plate_name_texture(), invalidate_plate_name_texture(), refresh_imex_icon(), and register_raycasters_for_picking().

Here is the caller graph for this function:

print()

void Slic3r::GUI::PartPlate::print

(

)

const

{
  unsigned int count=0;
 
  BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << boost::format(": plate index %1%, pointer %2%, print_index %3% print pointer %4%") % m_plate_index % this % m_print_index % m_print;
  BOOST_LOG_TRIVIAL(trace) << boost::format("\t origin {%1%,%2%,%3%}, width %4%,  depth %5%, height %6%") % m_origin.x() % m_origin.y() % m_origin.z() % m_width % m_depth % m_height;
  BOOST_LOG_TRIVIAL(trace) << boost::format("\t m_printable %1%, m_locked %2%, m_ready_for_slice %3%, m_slice_result_valid %4%,  m_tmp_gcode_path %5%, set size %6%")\
    % m_printable % m_locked % m_ready_for_slice % m_slice_result_valid % m_tmp_gcode_path % obj_to_instance_set.size();
  /*for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it) {
    int obj_id = it->first;
    int instance_id = it->second;
 
    BOOST_LOG_TRIVIAL(trace) << boost::format("\t the %1%th instance, obj_id %2%, instance id %3%") % count++ % obj_id % instance_id;
  }*/
  BOOST_LOG_TRIVIAL(trace) << boost::format("excluded instance set size %1%")%instance_outside_set.size();
  /*for (std::set<std::pair<int, int>>::iterator it = instance_outside_set.begin(); it != instance_outside_set.end(); ++it) {
    int obj_id = it->first;
    int instance_id = it->second;
 
    BOOST_LOG_TRIVIAL(trace) << boost::format("\t obj_id %1%, instance id %2%") % obj_id % instance_id;
  }*/
 
  return;
}

References count, instance_outside_set, m_depth, m_height, m_locked, m_origin, m_plate_index, m_print, m_print_index, m_printable, m_ready_for_slice, m_slice_result_valid, m_tmp_gcode_path, m_width, obj_to_instance_set, and Slic3r::trace().

Referenced by get_print(), and set_print().

Here is the call graph for this function:

Here is the caller graph for this function:

printable_instance_size()

int Slic3r::GUI::PartPlate::printable_instance_size

(

)

{
    int size = 0;
    for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it) {
        int obj_id      = it->first;
        int instance_id = it->second;
 
        if (!valid_instance(obj_id, instance_id))
            continue;
 
        ModelObject *  object   = m_model->objects[obj_id];
        ModelInstance *instance = object->instances[instance_id];
 
        if ((instance->printable) && (instance_outside_set.find(std::pair(obj_id, instance_id)) == instance_outside_set.end())) {
            size++;
        }
    }
    return size;
}

References instance_outside_set, m_model, obj_to_instance_set, Slic3r::ModelInstance::printable, and valid_instance().

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_imex_icon()

void Slic3r::GUI::PartPlate::refresh_imex_icon ( )

private

{
    if (!m_plater) return;
    PresetBundle* preset = wxGetApp().preset_bundle;
    if (!preset) return;
    bool dual_bbl = preset->is_bbl_vendor() && preset->get_printer_extruder_count() == 2;
    auto* is_imex_opt = preset->printers.get_edited_preset().config.option<ConfigOptionBool>("is_imex");
    if (is_imex_opt && is_imex_opt->value) {
        int imex_slot = dual_bbl ? 7 : 6;
        calc_vertex_for_icons(imex_slot, m_imex_mode_icon);
        calc_vertex_for_imex_warn_badge(imex_slot, m_imex_warn_icon);
 
        // calc_vertex_for_icons() destroyed the MeshRaycaster that SceneRaycaster still
        // holds by raw pointer; swap the registration as calc_vertex_for_plate_name() does.
        // Only the mode icon is picked -- the warn badge is a plain GLModel.
        if (GLCanvas3D *canvas = m_plater->get_view3D_canvas3D()) {
            canvas->remove_raycasters_for_picking(SceneRaycaster::EType::Bed,
                                                  picking_id_component(PLATE_IMEX_MODE_ID));
            register_model_for_picking(*canvas, m_imex_mode_icon, picking_id_component(PLATE_IMEX_MODE_ID));
        }
    }
}

References Slic3r::GUI::SceneRaycaster::Bed, calc_vertex_for_icons(), calc_vertex_for_imex_warn_badge(), Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetBundle::get_printer_extruder_count(), Slic3r::PresetBundle::is_bbl_vendor(), m_imex_mode_icon, m_imex_warn_icon, m_plater, Slic3r::ConfigBase::option(), picking_id_component(), PLATE_IMEX_MODE_ID, Slic3r::PresetBundle::printers, and Slic3r::GUI::register_model_for_picking().

Here is the call graph for this function:

register_raycasters_for_picking()

void Slic3r::GUI::PartPlate::register_raycasters_for_picking ( GLCanvas3D & canvas )

private

{
    register_model_for_picking(canvas, m_triangles, picking_id_component(0));
    register_model_for_picking(canvas, m_del_icon, picking_id_component(1));
    register_model_for_picking(canvas, m_orient_icon, picking_id_component(2));
    register_model_for_picking(canvas, m_arrange_icon, picking_id_component(3));
    register_model_for_picking(canvas, m_lock_icon, picking_id_component(4));
    if (m_partplate_list->render_plate_settings)
        register_model_for_picking(canvas, m_plate_settings_icon, picking_id_component(5));
 
    canvas.remove_raycasters_for_picking(SceneRaycaster::EType::Bed, picking_id_component(6));
  // Plate-name edit picking is built lazily together with the plate-name texture.
  // During reset / reload_scene the icon may not have a raycaster yet, which is valid.
  if (m_plate_name_edit_icon.mesh_raycaster != nullptr)
    register_model_for_picking(canvas, m_plate_name_edit_icon, picking_id_component(6));
    register_model_for_picking(canvas, m_move_front_icon, picking_id_component(7));
 
    // Only register filament map button for H2D (dual-extruder Bambu Lab) printers
    PresetBundle* preset = wxGetApp().preset_bundle;
    bool dual_bbl = (preset && preset->is_bbl_vendor() && preset->get_printer_extruder_count() == 2);
    if (dual_bbl)
        register_model_for_picking(canvas, m_plate_filament_map_icon, picking_id_component(PLATE_FILAMENT_MAP_ID));
 
    // Register IDEX/IQEX mode icon only when IDEX/IQEX is active and geometry is initialized.
    if (preset) {
        auto* is_imex_opt = preset->printers.get_edited_preset().config.option<ConfigOptionBool>("is_imex");
        if (is_imex_opt && is_imex_opt->value && m_imex_mode_icon.mesh_raycaster)
            register_model_for_picking(canvas, m_imex_mode_icon, picking_id_component(PLATE_IMEX_MODE_ID));
    }
}

References Slic3r::GUI::SceneRaycaster::Bed, Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetBundle::get_printer_extruder_count(), Slic3r::PresetBundle::is_bbl_vendor(), m_arrange_icon, m_del_icon, m_imex_mode_icon, m_lock_icon, m_move_front_icon, m_orient_icon, m_partplate_list, m_plate_filament_map_icon, m_plate_name_edit_icon, m_plate_settings_icon, m_triangles, Slic3r::ConfigBase::option(), picking_id_component(), PLATE_FILAMENT_MAP_ID, PLATE_IMEX_MODE_ID, Slic3r::PresetBundle::printers, Slic3r::GUI::register_model_for_picking(), and Slic3r::GUI::GLCanvas3D::remove_raycasters_for_picking().

Here is the call graph for this function:

remove_instance()

int Slic3r::GUI::PartPlate::remove_instance	(	int	obj_id,
		int	instance_id )

{
  bool result;
  std::set<std::pair<int, int>>::iterator it;
 
  it = obj_to_instance_set.find(std::pair(obj_id, instance_id));
  if (it != obj_to_instance_set.end()) {
    obj_to_instance_set.erase(it);
        invalidate_exclusion_volume_preview();
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":plate_id %1%, found obj_id %2%, instance_id %3%") % m_plate_index % obj_id % instance_id;
    result = 0;
  }
  else {
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": plate_id %1%, can not find obj_id %2%, instance_id %3%") % m_plate_index % obj_id % instance_id;
    result = -1;
    return result;
  }
 
  it = instance_outside_set.find(std::pair(obj_id, instance_id));
  if (it != instance_outside_set.end()) {
    instance_outside_set.erase(it);
  }
  if (!m_ready_for_slice)
    update_states();
 
  return result;
}

References instance_outside_set, invalidate_exclusion_volume_preview(), m_plate_index, m_ready_for_slice, obj_to_instance_set, and update_states().

Referenced by Slic3r::GUI::PartPlateList::add_to_plate(), Slic3r::GUI::PartPlateList::notify_instance_removed(), and Slic3r::GUI::PartPlateList::notify_instance_update().

Here is the call graph for this function:

Here is the caller graph for this function:

render()

void Slic3r::GUI::PartPlate::render	(	const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix,
		bool	bottom,
		bool	only_body = false,
		bool	force_background_color = false,
		HeightLimitMode	mode = HEIGHT_LIMIT_NONE,
		int	hover_id = -1,
		bool	render_cali = false,
		bool	show_grid = true,
		bool	hide_chrome = false )

{
    glsafe(::glEnable(GL_DEPTH_TEST));
 
    GLShaderProgram *shader = wxGetApp().get_shader("flat");
    if (shader != nullptr) {
        shader->start_using();
        glsafe(::glEnable(GL_BLEND));
        glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
        shader->set_uniform("view_model_matrix", view_matrix);
        shader->set_uniform("projection_matrix", projection_matrix);
 
        if (!bottom) {
            // draw background
            render_background(force_background_color);
 
            render_exclude_area(force_background_color);
            render_imex_zones(force_background_color);
            if(m_selected && wxGetApp().plater()->get_enable_wrapping_detection()){
                if(!m_wrapping_detection_triangles.is_initialized()){
                    auto points = get_plate_wrapping_detection_area();
                    if (points.size() > 0) {//wrapping_detection_area
                        ExPolygon temp_poly;
                        for (const Vec2d &p : points) {
                            temp_poly.contour.append({scale_(p(0)), scale_(p(1))});
                        }
                        auto      result = intersection(m_print_polygon, temp_poly);
                        if (result.size() > 0) {
                            ExPolygon wrapp_poly(result[0]);
                            calc_triangles_from_polygon(wrapp_poly, m_wrapping_detection_triangles);
                        }
                    }
                }
                render_wrapping_detection_area(force_background_color);
            }
            render_exclusion_volume_previews(force_background_color);
        }
 
        render_height_limit(mode);
 
        glsafe(::glDisable(GL_BLEND));
 
        // if (with_label) {
        //  render_label(canvas);
        // }
 
        shader->stop_using();
    }
 
    if (wxGetApp().show_plate_gridlines() && show_grid) {
        glsafe(::glDepthMask(bottom ? GL_TRUE : GL_FALSE));
        render_grid(bottom);
        glsafe(::glDepthMask(GL_TRUE));
    }
 
    if (!hide_chrome && !bottom && m_selected && !force_background_color) {
        if (m_partplate_list)
            render_logo(bottom, m_partplate_list->render_cali_logo && render_cali);
        else
            render_logo(bottom);
    }
 
    if (!hide_chrome) {
        render_icons(bottom, only_body, hover_id);
        if (!force_background_color) {
            render_only_numbers(bottom);
        }
    }
 
    glsafe(::glDisable(GL_DEPTH_TEST));
}

References Slic3r::MultiPoint::append(), calc_triangles_from_polygon(), Slic3r::ExPolygon::contour, get_plate_wrapping_detection_area(), GL_BLEND, GL_DEPTH_TEST, GL_FALSE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRUE, glBlendFunc, glDepthMask, glDisable, glEnable, glsafe, Slic3r::intersection(), m_partplate_list, m_print_polygon, m_selected, m_wrapping_detection_triangles, Slic3r::GUI::plater(), render_background(), render_exclude_area(), render_exclusion_volume_previews(), render_grid(), render_height_limit(), render_icons(), render_imex_zones(), render_logo(), render_only_numbers(), render_wrapping_detection_area(), scale_, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Here is the call graph for this function:

render_background()

void Slic3r::GUI::PartPlate::render_background ( bool force_default_color = false )

private

{
  //return directly for current plate
  if (m_selected && !force_default_color) return;
 
  // draw background
  glsafe(::glDepthMask(GL_FALSE));
 
  ColorRGBA color;
  if (!force_default_color) {
    if (m_selected) {
            color = PartPlate::SELECT_COLOR;
    }
    else {
            color = m_partplate_list->m_is_dark ? PartPlate::UNSELECT_DARK_COLOR : PartPlate::UNSELECT_COLOR;
    }
  }
  else {
        color = PartPlate::DEFAULT_COLOR;
  }
    m_triangles.model.set_color(color);
    m_triangles.model.render();
  glsafe(::glDepthMask(GL_TRUE));
}

References DEFAULT_COLOR, GL_FALSE, GL_TRUE, glDepthMask, glsafe, m_partplate_list, m_selected, m_triangles, SELECT_COLOR, UNSELECT_COLOR, and UNSELECT_DARK_COLOR.

Referenced by render().

Here is the caller graph for this function:

render_exclude_area()

void Slic3r::GUI::PartPlate::render_exclude_area ( bool force_default_color )

private

                                                            {
  if (force_default_color) //for thumbnail case
    return;
 
  ColorRGBA select_color{   .9f, .86f, .82f, .7f }; // ORCA
  ColorRGBA unselect_color{ .6f, .6f, .6f, .3f }; // ORCA
  //ColorRGBA default_color{ 0.9f, 0.9f, 0.9f, 1.0f };
 
  // draw exclude area
  glsafe(::glDepthMask(GL_FALSE));
 
  m_exclude_triangles.set_color(m_selected ? select_color : unselect_color);
    m_exclude_triangles.render();
  glsafe(::glDepthMask(GL_TRUE));
}

References GL_FALSE, GL_TRUE, glDepthMask, glsafe, m_exclude_triangles, and m_selected.

Referenced by render().

Here is the caller graph for this function:

render_exclusion_volume_intersections()

void Slic3r::GUI::PartPlate::render_exclusion_volume_intersections ( )

private

{
    if (!m_exclusion_volume_intersection_triangles.is_initialized())
        return;
 
    const ColorRGBA intersection_color{ .68f, .02f, .02f, .58f };
 
    glsafe(::glEnable(GL_POLYGON_OFFSET_FILL));
    glsafe(::glPolygonOffset(-1.0f, -1.0f));
 
    m_exclusion_volume_intersection_triangles.set_color(intersection_color);
    m_exclusion_volume_intersection_triangles.render();
 
    glsafe(::glDisable(GL_POLYGON_OFFSET_FILL));
}

References GL_POLYGON_OFFSET_FILL, glDisable, glEnable, glPolygonOffset, glsafe, and m_exclusion_volume_intersection_triangles.

render_exclusion_volume_previews()

void Slic3r::GUI::PartPlate::render_exclusion_volume_previews ( bool force_default_color )

private

{
    if (force_default_color)
        return;
 
    update_exclusion_volume_preview_models();
 
    const ColorRGBA floor_color = m_selected ? ColorRGBA{ .86f, .86f, .86f, .70f } : ColorRGBA{ .60f, .60f, .60f, .30f };
    const ColorRGBA ribbon_color{ .60f, .60f, .60f, .70f };
    const ColorRGBA prism_color{ .52f, .52f, .52f, .38f };
 
    glsafe(::glDepthMask(GL_FALSE));
 
    m_exclusion_volume_floor_triangles.set_color(floor_color);
    m_exclusion_volume_floor_triangles.render();
 
    m_exclusion_volume_border_triangles.set_color(ribbon_color);
    m_exclusion_volume_border_triangles.render();
 
    for (auto &colored_border : m_extruder_exclusion_volume_borders) {
        colored_border.first->set_color(colored_border.second);
        colored_border.first->render();
    }
 
    m_active_exclusion_volume_prisms.set_color(prism_color);
    m_active_exclusion_volume_prisms.render();
 
    glsafe(::glLineWidth(1.0f * m_scale_factor));
    glsafe(::glDepthMask(GL_TRUE));
}

References GL_FALSE, GL_TRUE, glDepthMask, glLineWidth, glsafe, m_active_exclusion_volume_prisms, m_exclusion_volume_border_triangles, m_exclusion_volume_floor_triangles, m_extruder_exclusion_volume_borders, m_scale_factor, m_selected, and update_exclusion_volume_preview_models().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_grid()

void Slic3r::GUI::PartPlate::render_grid ( bool bottom )

private

                                       {
  //glsafe(::glEnable(GL_MULTISAMPLE));
  // draw grid
 
    // ORCA: OpenGL Core Profile support
    // FIXME: ideally, we'd use the same shader for both the thin and thick lines, but for some reason setting the uniforms has no effect
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader == nullptr) {
        return;
    }
 
    shader->start_using();
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    const std::array<int, 4>& viewport = camera.get_viewport();
    const Transform3d& view_matrix = camera.get_view_matrix();
    const Transform3d& projection_matrix = camera.get_projection_matrix();
 
    shader->set_uniform("view_model_matrix", view_matrix);
    shader->set_uniform("projection_matrix", projection_matrix);
 
#if !SLIC3R_OPENGL_ES
    if (!OpenGLManager::get_gl_info().is_core_profile())
        glsafe(::glLineWidth(1.0f * m_scale_factor));
#endif // !SLIC3R_OPENGL_ES
 
    ColorRGBA color;
  if (bottom)
        color = LINE_BOTTOM_COLOR;
  else {
    if (m_selected)
            color = m_partplate_list->m_is_dark ? LINE_TOP_SEL_DARK_COLOR : LINE_TOP_SEL_COLOR;
    else
            color = m_partplate_list->m_is_dark ? LINE_TOP_DARK_COLOR : LINE_TOP_COLOR;
  }
    m_gridlines.set_color(color);
    m_gridlines.render();
 
    shader->stop_using();
 
    // ORCA: OpenGL Core Profile support
#if SLIC3R_OPENGL_ES
    shader = wxGetApp().get_shader("dashed_lines");
#else
    shader = OpenGLManager::get_gl_info().is_core_profile() ? wxGetApp().get_shader("dashed_thick_lines") : wxGetApp().get_shader("flat");
#endif // SLIC3R_OPENGL_ES
    if (shader == nullptr) {
        return;
    }
    shader->start_using();
 
    shader->set_uniform("view_model_matrix", view_matrix);
    shader->set_uniform("projection_matrix", projection_matrix);
 
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
        shader->set_uniform("viewport_size", Vec2d(double(viewport[2]), double(viewport[3])));
        shader->set_uniform("width", 0.25f);
#if !SLIC3R_OPENGL_ES
    } else {
        glsafe(::glLineWidth(2.0f * m_scale_factor));
    }
#endif // !SLIC3R_OPENGL_ES
 
    m_gridlines_bolder.set_color(color);
    m_gridlines_bolder.render();
 
    shader->stop_using();
}

References Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), Slic3r::GUI::Camera::get_viewport(), GL_BLEND, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, glBlendFunc, glEnable, glLineWidth, glsafe, Slic3r::GUI::OpenGLManager::GLInfo::is_core_profile(), LINE_BOTTOM_COLOR, LINE_TOP_COLOR, LINE_TOP_DARK_COLOR, LINE_TOP_SEL_COLOR, LINE_TOP_SEL_DARK_COLOR, m_gridlines, m_gridlines_bolder, m_partplate_list, m_scale_factor, m_selected, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_height_limit()

void Slic3r::GUI::PartPlate::render_height_limit ( PartPlate::HeightLimitMode mode = HEIGHT_LIMIT_BOTH )

private

{
  // Orca: a prime tower compacted by "No sparse layers" drags the nozzle back down to the plate on
  // every toolchange, so the rod and the lid limit how tall a neighbouring object may be exactly as
  // they do in sequential printing. The reference lines are just as useful there.
  const bool relevant_for_print_mode = m_print && (m_print->config().print_sequence == PrintSequence::ByObject ||
                                                   (m_print->config().print_sequence == PrintSequence::ByLayer &&
                                                    wipe_tower_sparse_layers_skipped(m_print->config()) && m_print->has_wipe_tower()));
  if (relevant_for_print_mode && mode != HEIGHT_LIMIT_NONE)
  {
    // draw lower limit
      // ORCA: OpenGL Core Profile
#if !SLIC3R_OPENGL_ES
      if (!OpenGLManager::get_gl_info().is_core_profile())
          glsafe(::glLineWidth(3.0f * m_scale_factor));
#endif // !SLIC3R_OPENGL_ES
        m_height_limit_common.set_color(HEIGHT_LIMIT_BOTTOM_COLOR);
        m_height_limit_common.render();
 
    if ((mode == HEIGHT_LIMIT_BOTTOM) || (mode == HEIGHT_LIMIT_BOTH)) {
        // ORCA: OpenGL Core Profile
#if !SLIC3R_OPENGL_ES
        if (!OpenGLManager::get_gl_info().is_core_profile())
            glsafe(::glLineWidth(3.0f * m_scale_factor));
#endif // !SLIC3R_OPENGL_ES
        m_height_limit_bottom.set_color(HEIGHT_LIMIT_BOTTOM_COLOR);
            m_height_limit_bottom.render();
    }
 
    // draw upper limit
    if ((mode == HEIGHT_LIMIT_TOP) || (mode == HEIGHT_LIMIT_BOTH)){
        // ORCA: OpenGL Core Profile
#if !SLIC3R_OPENGL_ES
        if (!OpenGLManager::get_gl_info().is_core_profile())
            glsafe(::glLineWidth(3.0f * m_scale_factor));
#endif // !SLIC3R_OPENGL_ES
        m_height_limit_top.set_color(HEIGHT_LIMIT_TOP_COLOR);
            m_height_limit_top.render();
    }
  }
}

References Slic3r::ByLayer, Slic3r::ByObject, Slic3r::GUI::OpenGLManager::get_gl_info(), glLineWidth, glsafe, HEIGHT_LIMIT_BOTH, HEIGHT_LIMIT_BOTTOM, HEIGHT_LIMIT_BOTTOM_COLOR, HEIGHT_LIMIT_NONE, HEIGHT_LIMIT_TOP, HEIGHT_LIMIT_TOP_COLOR, m_height_limit_bottom, m_height_limit_common, m_height_limit_top, m_print, m_scale_factor, Slic3r::print_sequence(), and Slic3r::wipe_tower_sparse_layers_skipped().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_icon_texture()

void Slic3r::GUI::PartPlate::render_icon_texture ( GLModel & buffer, GLTexture & texture )

private

{
  GLuint tex_id = (GLuint)texture.get_id();
  glsafe(::glBindTexture(GL_TEXTURE_2D, tex_id));
    buffer.render();
  glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
}

References Slic3r::GUI::GLTexture::get_id(), GL_TEXTURE_2D, glBindTexture, glsafe, and Slic3r::GUI::GLModel::render().

Referenced by render_icons(), and render_only_numbers().

Here is the call graph for this function:

Here is the caller graph for this function:

render_icons()

void Slic3r::GUI::PartPlate::render_icons ( bool bottom, bool only_name = false, int hover_id = -1 )

private

{
  GLShaderProgram* shader = wxGetApp().get_shader("printbed");
  if (shader != nullptr) {
    shader->start_using();
        const Camera &camera = wxGetApp().plater()->get_camera();
        shader->set_uniform("view_model_matrix", camera.get_view_matrix());
        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
    shader->set_uniform("transparent_background", bottom);
    //shader->set_uniform("svg_source", boost::algorithm::iends_with(m_partplate_list->m_del_texture.get_source(), ".svg"));
    shader->set_uniform("svg_source", 0);
 
        //if (bottom)
        //    glsafe(::glFrontFace(GL_CW));
        glsafe(::glDepthMask(GL_FALSE));
 
        glsafe(::glEnable(GL_BLEND));
        glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
        if (!only_name) {
            if (hover_id == 1) {
                render_icon_texture(m_del_icon.model, m_partplate_list->m_del_hovered_texture);
                set_hover_tooltip(_u8L("Remove current plate (if not last one)"));
            }
            else
                render_icon_texture(m_del_icon.model, m_partplate_list->m_del_texture);
 
            if (hover_id == 2) {
                render_icon_texture(m_orient_icon.model, m_partplate_list->m_orient_hovered_texture);
                set_hover_tooltip(_u8L("Auto orient objects on current plate"));
            }
            else
                render_icon_texture(m_orient_icon.model, m_partplate_list->m_orient_texture);
 
            if (hover_id == 3) {
                render_icon_texture(m_arrange_icon.model, m_partplate_list->m_arrange_hovered_texture);
                set_hover_tooltip(_u8L("Arrange objects on current plate"));
            }
            else
                render_icon_texture(m_arrange_icon.model, m_partplate_list->m_arrange_texture);
 
            if (hover_id == 4) {
                if (this->is_locked()) {
                    render_icon_texture(m_lock_icon.model,
                                        m_partplate_list->m_locked_hovered_texture);
                    set_hover_tooltip(_u8L("Unlock current plate"));
                }
                else {
                    render_icon_texture(m_lock_icon.model,
                                        m_partplate_list->m_lockopen_hovered_texture);
                    set_hover_tooltip(_u8L("Lock current plate"));
                }
            } else {
                if (this->is_locked())
                    render_icon_texture(m_lock_icon.model, m_partplate_list->m_locked_texture);
                else
                    render_icon_texture(m_lock_icon.model, m_partplate_list->m_lockopen_texture);
            }
 
            PresetBundle* preset = wxGetApp().preset_bundle;
            bool dual_bbl = (preset->is_bbl_vendor() && preset->get_printer_extruder_count() == 2);
            if (dual_bbl) {
                if (hover_id == PLATE_FILAMENT_MAP_ID){
                    render_icon_texture(m_plate_filament_map_icon.model, m_partplate_list->m_plate_set_filament_map_hovered_texture);
                    set_hover_tooltip(_u8L("Filament grouping"));
                } else
                    render_icon_texture(m_plate_filament_map_icon.model, m_partplate_list->m_plate_set_filament_map_texture);
            }
 
      if (hover_id == 6) {
                render_icon_texture(m_plate_name_edit_icon.model, m_partplate_list->m_plate_name_edit_hovered_texture);
                set_hover_tooltip(_u8L("Edit current plate name"));
      }
      else
                render_icon_texture(m_plate_name_edit_icon.model, m_partplate_list->m_plate_name_edit_texture);
 
      if (hover_id == 7) {
                render_icon_texture(m_move_front_icon.model, m_partplate_list->m_move_front_hovered_texture);
                set_hover_tooltip(_u8L("Move plate to the front"));
            } else
                render_icon_texture(m_move_front_icon.model, m_partplate_list->m_move_front_texture);
 
            // IDEX/IQEX mode icon — only when is_imex is active
            {
                PresetBundle* pb = wxGetApp().preset_bundle;
                auto* is_imex_opt = pb ? pb->printers.get_edited_preset().config.option<ConfigOptionBool>("is_imex") : nullptr;
                if (is_imex_opt && is_imex_opt->value) {
                    // The icon shows the mode the plate slices as, the one its ghosts follow.
                    std::string  active_tools;
                    int          primary_phys = -1;
                    const size_t kind = size_t(resolve_active_mode_tools(active_tools, primary_phys) ?
                                                   imex_mode_kind(active_tools) :
                                                   ImexModeKind::Primary);
                    // Both the mode name and the conflict warning describe the same hovered icon,
                    // and set_hover_tooltip records one string per frame, so they are composed here.
                    std::string hover_tip;
                    if (hover_id == (int)PLATE_IMEX_MODE_ID) {
                        render_icon_texture(m_imex_mode_icon.model, m_partplate_list->m_imex_mode_hovered_textures[kind]);
                        // The stored value, not the resolved one: this line carries the click
                        // affordances, and the menu checkmark and the left-click cycle both act
                        // on what the plate stores. Reporting the inherited mode here would leave
                        // one control saying three different things. Where they differ -- a plate
                        // on Primary under a process preset that names a mode, which is what
                        // actually slices -- the inherited mode is named after it, so the tooltip
                        // still tells the user what this plate will print as.
                        std::string cur = get_imex_mode();
                        const std::string effective = get_effective_imex_mode();
                        if (cur == kImexPrimaryMode) cur = _u8L("Primary");
                        // One format string, not two catalog fragments concatenated around a
                        // runtime value: translators need to move the mode name within the
                        // sentence, and the space-padded fragments were untranslatable alone.
                        //
                        // Guarded because this runs on the paint path: boost::format throws if a
                        // TRANSLATED string drops or malforms %1%, and an exception escaping here
                        // would take down the frame rather than show a wrong tooltip. The English
                        // literal is the fallback and cannot itself throw.
                        if (effective != get_imex_mode()) {
                            try {
                                // TRN Plate icon tooltip. %1% is the plate's IDEX/IQEX mode, %2% the mode its process preset sets.
                                hover_tip = (boost::format(_u8L("IDEX/IQEX mode: %1% (process preset: %2%) (left-click to cycle, right-click for menu)")) % cur % effective).str();
                            } catch (const std::exception&) {
                                hover_tip = (boost::format("IDEX/IQEX mode: %1% (process preset: %2%) (left-click to cycle, right-click for menu)") % cur % effective).str();
                            }
                        } else {
                            try {
                                hover_tip = (boost::format(_u8L("IDEX/IQEX mode: %1% (left-click to cycle, right-click for menu)")) % cur).str();
                            } catch (const std::exception&) {
                                hover_tip = (boost::format("IDEX/IQEX mode: %1% (left-click to cycle, right-click for menu)") % cur).str();
                            }
                        }
                    } else {
                        render_icon_texture(m_imex_mode_icon.model, m_partplate_list->m_imex_mode_textures[kind]);
                    }
                    // Warning badge: IMEX parallel mode active alongside multi-material objects
                    if (has_imex_multimaterial_conflict()) {
                        render_icon_texture(m_imex_warn_icon, m_partplate_list->m_imex_warn_texture);
                        // The warning joins the mode line rather than replacing it: one hover
                        // records one string, and the mode name carries the click affordances.
                        if (hover_id == (int)PLATE_IMEX_MODE_ID)
                            hover_tip += (hover_tip.empty() ? "" : "\n\n") +
                                         _u8L("Warning: this plate uses a parallel IDEX/IQEX mode with multi-material objects. Proceed with caution — verify your G-code handles this combination correctly.");
                    }
                    if (!hover_tip.empty())
                        set_hover_tooltip(hover_tip);
                }
            }
 
      if (m_partplate_list->render_plate_settings) {
        bool has_plate_settings = get_bed_type() != BedType::btDefault || get_print_seq() != PrintSequence::ByDefault || !get_first_layer_print_sequence().empty() || !get_other_layers_print_sequence().empty() || has_spiral_mode_config();
                if (hover_id == 5) {
                    if (!has_plate_settings)
                        render_icon_texture(m_plate_settings_icon.model, m_partplate_list->m_plate_settings_hovered_texture);
                    else
                        render_icon_texture(m_plate_settings_icon.model, m_partplate_list->m_plate_settings_changed_hovered_texture);
 
                    set_hover_tooltip(_u8L("Customize current plate"));
                } else {
                    if (!has_plate_settings)
                        render_icon_texture(m_plate_settings_icon.model, m_partplate_list->m_plate_settings_texture);
                    else
                        render_icon_texture(m_plate_settings_icon.model, m_partplate_list->m_plate_settings_changed_texture);
                }
            }
 
            if (m_plate_index >= 0 && m_plate_index < MAX_PLATE_COUNT) {
                render_icon_texture(m_plate_idx_icon, m_partplate_list->m_idx_textures[m_plate_index]);
            }
        }
    render_plate_name_texture();
 
        glsafe(::glDisable(GL_BLEND));
 
        //if (bottom)
        //    glsafe(::glFrontFace(GL_CCW));
 
        glsafe(::glDepthMask(GL_TRUE));
        shader->stop_using();
    }
}

References _u8L, Slic3r::btDefault, Slic3r::ByDefault, Slic3r::Preset::config, get_bed_type(), Slic3r::PresetCollection::get_edited_preset(), get_effective_imex_mode(), get_first_layer_print_sequence(), get_imex_mode(), get_other_layers_print_sequence(), get_print_seq(), Slic3r::PresetBundle::get_printer_extruder_count(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), GL_BLEND, GL_FALSE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRUE, glBlendFunc, glDepthMask, glDisable, glEnable, glsafe, has_imex_multimaterial_conflict(), has_spiral_mode_config(), Slic3r::imex_mode_kind(), Slic3r::PresetBundle::is_bbl_vendor(), is_locked(), Slic3r::kImexPrimaryMode, m_arrange_icon, m_del_icon, m_imex_mode_icon, m_imex_warn_icon, m_lock_icon, m_move_front_icon, m_orient_icon, m_partplate_list, m_plate_filament_map_icon, m_plate_idx_icon, m_plate_index, m_plate_name_edit_icon, m_plate_settings_icon, MAX_PLATE_COUNT, Slic3r::ConfigBase::option(), PLATE_FILAMENT_MAP_ID, PLATE_IMEX_MODE_ID, Slic3r::Primary, Slic3r::PresetBundle::printers, render_icon_texture(), render_plate_name_texture(), resolve_active_mode_tools(), set_hover_tooltip(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_imex_zones()

void Slic3r::GUI::PartPlate::render_imex_zones ( bool force_default_color )

private

{
    if (force_default_color)
        return;
 
    ensure_imex_zones();
    ensure_imex_ghosts();
 
    // Read visualization theme from printer config.
    struct IMEXTheme {
        ColorRGBA copy;     // secondary copy zone fill
        ColorRGBA mirror;   // secondary mirror zone fill
        ColorRGBA danger;   // blocking collision strip
        ColorRGBA margin;   // advisory safety margin
    };
 
    // Standard (Okabe-Ito orange + sky blue)
    // Alphas are deliberately low: these fills cover whole quadrants of the bed and sit under
    // the model for the entire session, so at the saturation that reads well on a swatch they
    // dominate the scene. The zone a tool owns only has to be legible, not loud.
    // The three themes below keep their original alphas -- they are chosen for discriminability
    // (and k_high_contrast explicitly for low vision), which is the opposite trade.
    static const IMEXTheme k_standard = {
        { 0.337f, 0.706f, 0.914f, 0.22f },   // copy   — sky blue  #56B4E9
        { 0.902f, 0.624f, 0.000f, 0.22f },   // mirror — orange    #E69F00
        // Dimmed less than the fills: this strip marks where a head collides, so it stays the
        // most prominent thing on the bed even after the surrounding zones recede.
        { 0.850f, 0.100f, 0.100f, 0.40f },   // danger — red
        { 0.300f, 0.900f, 0.200f, 0.20f },   // margin — lime green
    };
    // Deuteranopia / Protanopia: avoids red-green confusion.
    // Danger strip uses strong blue-violet (red invisible to protanopes).
    static const IMEXTheme k_deuteranopia = {
        { 0.000f, 0.447f, 0.698f, 0.50f },   // copy   — blue       #0072B2
        { 0.941f, 0.894f, 0.259f, 0.50f },   // mirror — yellow     #F0E442
        { 0.200f, 0.100f, 0.800f, 0.65f },   // danger — blue-violet (red not visible)
        { 0.800f, 0.475f, 0.655f, 0.45f },   // margin — reddish purple #CC79A7
    };
    // Tritanopia: avoids blue-yellow confusion.
    // Copy uses vermilion, mirror uses reddish-purple, margin uses teal.
    static const IMEXTheme k_tritanopia = {
        { 0.835f, 0.369f, 0.000f, 0.50f },   // copy   — vermilion  #D55E00
        { 0.800f, 0.475f, 0.655f, 0.50f },   // mirror — reddish purple #CC79A7
        { 0.850f, 0.100f, 0.100f, 0.55f },   // danger — red (visible to tritanopes)
        { 0.000f, 0.700f, 0.600f, 0.45f },   // margin — teal
    };
    // High contrast: saturated, higher alpha for low-vision users.
    static const IMEXTheme k_high_contrast = {
        { 0.000f, 0.600f, 1.000f, 0.65f },   // copy   — vivid blue
        { 1.000f, 0.600f, 0.000f, 0.65f },   // mirror — vivid orange
        { 1.000f, 0.000f, 0.000f, 0.75f },   // danger — full red
        { 0.000f, 1.000f, 0.200f, 0.60f },   // margin — bright green
    };
 
    const IMEXTheme* theme = &k_standard;
    if (wxGetApp().preset_bundle) {
        const DynamicPrintConfig& pcfg = wxGetApp().preset_bundle->printers.get_edited_preset().config;
        switch (imex_cfg_enum<ImexVizTheme>(pcfg, "imex_viz_theme")) {
        case ImexVizTheme::Deuteranopia: theme = &k_deuteranopia;  break;
        case ImexVizTheme::Tritanopia:   theme = &k_tritanopia;    break;
        case ImexVizTheme::HighContrast: theme = &k_high_contrast; break;
        default: break; // Standard
        }
    }
 
    // Both fills and border lines use the flat shader already active from render().
    glsafe(::glDepthMask(GL_FALSE));
 
    if (!m_imex_copy_zones.empty())
        for (GLModel& z : m_imex_copy_zones)
            if (z.is_initialized()) { z.set_color(theme->copy); z.render(); }
 
    if (!m_imex_mirror_zones.empty())
        for (GLModel& z : m_imex_mirror_zones)
            if (z.is_initialized()) { z.set_color(theme->mirror); z.render(); }
 
    glsafe(::glDepthMask(GL_TRUE));
 
 
    if (!m_imex_collision_overlay.empty()) {
        glsafe(::glDepthMask(GL_FALSE));
        for (GLModel& s : m_imex_collision_overlay)
            if (s.is_initialized()) { s.set_color(theme->danger); s.render(); }
        glsafe(::glDepthMask(GL_TRUE));
    }
 
    if (!m_imex_margin_overlay.empty()) {
        glsafe(::glDepthMask(GL_FALSE));
        for (GLModel& b : m_imex_margin_overlay)
            if (b.is_initialized()) { b.set_color(theme->margin); b.render(); }
        glsafe(::glDepthMask(GL_TRUE));
    }
}

References Slic3r::Deuteranopia, ensure_imex_ghosts(), ensure_imex_zones(), GL_FALSE, GL_TRUE, glDepthMask, glsafe, Slic3r::HighContrast, Slic3r::imex_cfg_enum(), m_imex_collision_overlay, m_imex_copy_zones, m_imex_margin_overlay, m_imex_mirror_zones, and Slic3r::Tritanopia.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_logo()

void Slic3r::GUI::PartPlate::render_logo ( bool bottom, bool render_cali = true )

private

{
  if (!m_partplate_list->render_bedtype_logo) {
    // render third-party printer texture logo
    if (!m_partplate_list->load_logo_texture())
      return;
 
    if (m_logo_triangles.is_initialized())
      render_logo_texture(m_partplate_list->m_logo_texture, m_logo_triangles, bottom);
    return;
  }
 
  m_partplate_list->load_bedtype_textures();
  m_partplate_list->load_cali_textures();
    m_partplate_list->load_extruder_only_area_textures();
  // btDefault should be skipped
  auto curr_bed_type = get_bed_type();
  if (curr_bed_type == btDefault) {
        DynamicConfig& proj_cfg = wxGetApp().preset_bundle->project_config;
        if (proj_cfg.has(std::string("curr_bed_type")))
            curr_bed_type = proj_cfg.opt_enum<BedType>(std::string("curr_bed_type"));
  }
  int bed_type_idx = (int)curr_bed_type;
    auto is_single_extruder = wxGetApp().preset_bundle->get_printer_extruder_count() == 1;
    if (!is_single_extruder) {
        if (m_partplate_list->m_allow_bed_type_in_double_nozzle.find(bed_type_idx) == m_partplate_list->m_allow_bed_type_in_double_nozzle.end()) {
            bed_type_idx = 0;
        }
    }
  // render bed textures
  for (auto &part : m_partplate_list->bed_texture_info[bed_type_idx].parts) {
    if (part.texture) {
      if (part.buffer && part.buffer->is_initialized()
        //&& part.vbo_id != 0
        ) {
        if (part.offset.x() != m_origin.x() || part.offset.y() != m_origin.y()) {
          part.offset = Vec2d(m_origin.x(), m_origin.y());
          part.update_buffer();
        }
        render_logo_texture(*(part.texture),
                  *(part.buffer),
                  bottom);
      }
    }
  }
 
  // render cali texture
  if (render_cali) {
    for (auto& part : m_partplate_list->cali_texture_info.parts) {
      if (part.texture) {
                if (part.buffer && part.buffer->is_initialized()) {
          if (part.offset.x() != m_origin.x() || part.offset.y() != m_origin.y()) {
            part.offset = Vec2d(m_origin.x(), m_origin.y());
            part.update_buffer();
          }
          render_logo_texture(*(part.texture),
            *(part.buffer),
            bottom);
        }
      }
    }
  }
 
  //render extruder_only_area_info
    bool is_zh        = wxGetApp().app_config->get("language") == "zh_CN";
    int  language_idx = (int) (is_zh ? ExtruderOnlyAreaType::Chinese:ExtruderOnlyAreaType::Engilish);
    if (!is_single_extruder) {
        for (auto &part : m_partplate_list->extruder_only_area_info[language_idx].parts) {
            if (part.texture) {
                if (part.buffer && part.buffer->is_initialized()) {
                    if (part.offset.x() != m_origin.x() || part.offset.y() != m_origin.y()) {
                        part.offset = Vec2d(m_origin.x(), m_origin.y());
                        part.update_buffer();
                    }
                    render_logo_texture(*(part.texture), *(part.buffer), bottom);
                }
            }
        }
  }
}

References Slic3r::btDefault, Slic3r::Chinese, Slic3r::curr_bed_type(), Slic3r::Engilish, get_bed_type(), Slic3r::ConfigOptionResolver::has(), m_logo_triangles, m_origin, m_partplate_list, Slic3r::DynamicConfig::opt_enum(), and render_logo_texture().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_logo_texture()

void Slic3r::GUI::PartPlate::render_logo_texture ( GLTexture & logo_texture, GLModel & logo_buffer, bool bottom )

private

{
  //check valid
  if (logo_texture.unsent_compressed_data_available()) {
    // sends to gpu the already available compressed levels of the main texture
    logo_texture.send_compressed_data_to_gpu();
  }
 
  if (logo_buffer.is_initialized()) {
    GLShaderProgram* shader = wxGetApp().get_shader("printbed");
    if (shader != nullptr) {
      shader->start_using();
            const Camera &camera = wxGetApp().plater()->get_camera();
            shader->set_uniform("view_model_matrix", camera.get_view_matrix());
            shader->set_uniform("projection_matrix", camera.get_projection_matrix());
      shader->set_uniform("transparent_background", 0);
      shader->set_uniform("svg_source", 0);
 
      //glsafe(::glEnable(GL_DEPTH_TEST));
      glsafe(::glDepthMask(GL_FALSE));
 
      glsafe(::glEnable(GL_BLEND));
            glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
      if (bottom)
        glsafe(::glFrontFace(GL_CW));
 
      // show the temporary texture while no compressed data is available
      GLuint tex_id = (GLuint)logo_texture.get_id();
 
      glsafe(::glBindTexture(GL_TEXTURE_2D, tex_id));
            logo_buffer.render();
      glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
      if (bottom)
        glsafe(::glFrontFace(GL_CCW));
 
            glsafe(::glDisable(GL_BLEND));
 
      glsafe(::glDepthMask(GL_TRUE));
 
      shader->stop_using();
    }
  }
}

References Slic3r::GUI::GLTexture::get_id(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), GL_BLEND, GL_CCW, GL_CW, GL_FALSE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TEXTURE_2D, GL_TRUE, glBindTexture, glBlendFunc, glDepthMask, glDisable, glEnable, glFrontFace, glsafe, Slic3r::GUI::GLModel::is_initialized(), Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLTexture::send_compressed_data_to_gpu(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), and Slic3r::GUI::GLTexture::unsent_compressed_data_available().

Referenced by render_logo().

Here is the call graph for this function:

Here is the caller graph for this function:

render_only_numbers()

void Slic3r::GUI::PartPlate::render_only_numbers ( bool bottom )

private

{
  GLShaderProgram* shader = wxGetApp().get_shader("printbed");
  if (shader != nullptr) {
    shader->start_using();
        const Camera &camera = wxGetApp().plater()->get_camera();
        shader->set_uniform("view_model_matrix", camera.get_view_matrix());
        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
    shader->set_uniform("transparent_background", bottom);
    //shader->set_uniform("svg_source", boost::algorithm::iends_with(m_partplate_list->m_del_texture.get_source(), ".svg"));
    shader->set_uniform("svg_source", 0);
 
        //if (bottom)
        //    glsafe(::glFrontFace(GL_CW));
        glsafe(::glDepthMask(GL_FALSE));
 
        glsafe(::glEnable(GL_BLEND));
        glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
        if (m_plate_index >=0 && m_plate_index < MAX_PLATE_COUNT) {
            render_icon_texture(m_plate_idx_icon, m_partplate_list->m_idx_textures[m_plate_index]);
        }
 
        glsafe(::glDisable(GL_BLEND));
 
        //if (bottom)
        //    glsafe(::glFrontFace(GL_CCW));
 
        glsafe(::glDepthMask(GL_TRUE));
        shader->stop_using();
    }
}

References Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), GL_BLEND, GL_FALSE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRUE, glBlendFunc, glDepthMask, glDisable, glEnable, glsafe, m_partplate_list, m_plate_idx_icon, m_plate_index, MAX_PLATE_COUNT, render_icon_texture(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_plate_name_texture()

void Slic3r::GUI::PartPlate::render_plate_name_texture ( )

private

{
  if (m_plate_name_edit_icon.mesh_raycaster == nullptr)
    generate_plate_name_texture();
 
  if (m_name_texture.get_id() == 0)
    return;
 
  GLuint tex_id = (GLuint)m_name_texture.get_id();
  glsafe(::glBindTexture(GL_TEXTURE_2D, tex_id));
    m_plate_name_icon.render();
  glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
}

References generate_plate_name_texture(), GL_TEXTURE_2D, glBindTexture, glsafe, m_name_texture, m_plate_name_edit_icon, and m_plate_name_icon.

Referenced by render_icons().

Here is the call graph for this function:

Here is the caller graph for this function:

render_wrapping_detection_area()

void Slic3r::GUI::PartPlate::render_wrapping_detection_area ( bool force_default_color )

private

{
    if (force_default_color || !m_wrapping_detection_triangles.is_initialized())
        return;
    ColorRGBA select_color{0.765f, 0.7686f, 0.7686f, 1.0f};
    m_wrapping_detection_triangles.set_color(select_color);
    m_wrapping_detection_triangles.render();
}

References m_wrapping_detection_triangles.

Referenced by render().

Here is the caller graph for this function:

reset_bed_type()

void Slic3r::GUI::PartPlate::reset_bed_type

(

)

{
    m_config.erase("curr_bed_type");
}

References m_config.

Referenced by Slic3r::GUI::TabPrintPlate::on_value_change(), and Slic3r::GUI::TabPrintPlate::reset_model_config().

Here is the caller graph for this function:

reset_imex_head_filament_map()

void Slic3r::GUI::PartPlate::reset_imex_head_filament_map

(

)

{
    m_config.erase("imex_head_filament_map");
    update_slice_result_valid_state(false);
}

References m_config, and update_slice_result_valid_state().

Here is the call graph for this function:

reset_imex_mode()

void Slic3r::GUI::PartPlate::reset_imex_mode

(

)

{
    m_config.erase("imex_parallel_mode");
    update_slice_result_valid_state(false);
    m_imex_zones_mode_cache = "\x01";
    m_imex_ghost_cache_key  = "\x01";
}

References m_config, m_imex_ghost_cache_key, m_imex_zones_mode_cache, and update_slice_result_valid_state().

Here is the call graph for this function:

reset_skirt_start_angle()

void Slic3r::GUI::PartPlate::reset_skirt_start_angle

(

)

{
    m_config.erase("skirt_start_angle");
}

References m_config.

resolve_active_mode_tools()

bool Slic3r::GUI::PartPlate::resolve_active_mode_tools ( std::string & out_tools_str, int & out_primary_phys ) const

private

{
    if (!wxGetApp().preset_bundle) return false;
    const DynamicPrintConfig& printer_cfg = wxGetApp().preset_bundle->printers.get_edited_preset().config;
    auto* is_imex_opt = printer_cfg.option<ConfigOptionBool>("is_imex");
    if (!is_imex_opt || !is_imex_opt->value) return false;
 
    const std::string active_mode = get_effective_imex_mode();
    if (active_mode == kImexPrimaryMode) return false;
 
    const ImexMode mode = find_imex_mode(printer_cfg, active_mode);
    if (!mode.found()) return false;
 
    // Also the ragged case: a tools array too short to reach this row hands back an empty
    // string, which has no declared primary, which is the same "no zones here" answer the
    // explicit bounds check used to give.
    const int primary_phys = imex_primary_tool_for_mode(mode.active_tools);
    if (primary_phys < 0) return false;
 
    out_tools_str    = mode.active_tools;
    out_primary_phys = primary_phys;
    return true;
}

References Slic3r::ImexMode::active_tools, Slic3r::find_imex_mode(), Slic3r::ImexMode::found(), get_effective_imex_mode(), Slic3r::imex_primary_tool_for_mode(), Slic3r::kImexPrimaryMode, and Slic3r::ConfigBase::option().

Referenced by build_imex_cache_key(), calc_imex_ghosts(), render_icons(), and update_imex_ghost_transforms().

Here is the call graph for this function:

Here is the caller graph for this function:

save()

template<class Archive>

void Slic3r::GUI::PartPlate::save ( Archive & ar ) const

inline

                                                         {
        std::vector<std::pair<int, int>>  objects_and_instances;
        std::vector<std::pair<int, int>>  instances_outside;
 
        for (std::set<std::pair<int, int>>::iterator it = instance_outside_set.begin(); it != instance_outside_set.end(); ++it)
            instances_outside.emplace_back(it->first, it->second);
 
        for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it)
            objects_and_instances.emplace_back(it->first, it->second);
 
        ar(m_plate_index, m_name, m_print_index, m_origin, m_width, m_depth, m_height, m_locked, m_selected, m_ready_for_slice, m_slice_result_valid, m_apply_invalid, m_printable, m_tmp_gcode_path, objects_and_instances, instances_outside, m_config);
    }

References instance_outside_set, m_apply_invalid, m_config, m_depth, m_height, m_locked, m_name, m_origin, m_plate_index, m_print_index, m_printable, m_ready_for_slice, m_selected, m_slice_result_valid, m_tmp_gcode_path, m_width, and obj_to_instance_set.

serialize()

template<class Archive>

void Slic3r::ObjectBase::serialize ( Archive & ar )

inlineprivateinherited

{ ar(m_id); }

References m_id.

set_bed_type()

void Slic3r::GUI::PartPlate::set_bed_type

(

BedType

bed_type

)

{
    std::string bed_type_key = "curr_bed_type";
 
    // should be called in GUI context
    assert(m_plater != nullptr);
 
    // update slice state
    BedType old_real_bed_type = get_bed_type();
    if (old_real_bed_type == btDefault) {
        DynamicConfig& proj_cfg = wxGetApp().preset_bundle->project_config;
        if (proj_cfg.has(bed_type_key))
            old_real_bed_type = proj_cfg.opt_enum<BedType>(bed_type_key);
    }
    BedType new_real_bed_type = bed_type;
    if (bed_type == BedType::btDefault) {
        DynamicConfig& proj_cfg = wxGetApp().preset_bundle->project_config;
        if (proj_cfg.has(bed_type_key))
            new_real_bed_type = proj_cfg.opt_enum<BedType>(bed_type_key);
    }
    if (old_real_bed_type != new_real_bed_type) {
        update_slice_result_valid_state(false);
    }
 
    if (bed_type == BedType::btDefault)
        m_config.erase(bed_type_key);
    else
        m_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(bed_type));
}

References Slic3r::btDefault, get_bed_type(), Slic3r::ConfigOptionResolver::has(), m_config, m_plater, Slic3r::DynamicConfig::opt_enum(), and update_slice_result_valid_state().

Referenced by Slic3r::GUI::PartPlateList::check_all_plate_local_bed_type(), and Slic3r::GUI::Plater::open_platesettings_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

set_filament_count()

void Slic3r::GUI::PartPlate::set_filament_count

(

int

filament_count

)

{
    if (m_config.has("filament_map")) {
        std::vector<int>& filament_maps = m_config.option<ConfigOptionInts>("filament_map")->values;
        filament_maps.resize(filament_count, 1);
    }
 
    if (m_config.has("filament_nozzle_map")) {
        std::vector<int>& filament_nozzle_map = m_config.option<ConfigOptionInts>("filament_nozzle_map")->values;
        filament_nozzle_map.resize(filament_count, 0);
    }
 
    if (m_config.has("filament_volume_map")) {
        std::vector<int>& filament_volume_map = m_config.option<ConfigOptionInts>("filament_volume_map")->values;
        filament_volume_map.resize(filament_count, static_cast<int>(NozzleVolumeType::nvtStandard));
    }
}

References Slic3r::filament_nozzle_map(), m_config, and Slic3r::nvtStandard.

Referenced by Slic3r::GUI::PartPlateList::create_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

set_filament_map_mode()

void Slic3r::GUI::PartPlate::set_filament_map_mode

(

const FilamentMapMode &

mode

)

{
  const auto& proj_config = wxGetApp().preset_bundle->project_config;
  FilamentMapMode global_mode = proj_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode")->value;
  FilamentMapMode old_mode = get_filament_map_mode();
  FilamentMapMode old_real_mode = old_mode == fmmDefault ? global_mode : old_mode;
  FilamentMapMode new_real_mode = mode == fmmDefault ? global_mode : mode;
 
  if (old_real_mode != new_real_mode)
    clear_filament_map();
  if (mode == fmmDefault)
    clear_filament_map_mode();
  else
    m_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode", true)->value = mode;
    invalidate_exclusion_volume_preview();
}

References clear_filament_map(), clear_filament_map_mode(), Slic3r::fmmDefault, get_filament_map_mode(), invalidate_exclusion_volume_preview(), and m_config.

Referenced by Slic3r::GUI::Plater::open_filament_map_setting_dialog(), Slic3r::GUI::GCodeViewer::render_legend_color_arr_recommen(), and Slic3r::GUI::try_pop_up_before_slice().

Here is the call graph for this function:

Here is the caller graph for this function:

set_filament_maps()

void Slic3r::GUI::PartPlate::set_filament_maps

(

const std::vector< int > &

f_maps

)

{
    m_config.option<ConfigOptionInts>("filament_map", true)->values = f_maps;
    invalidate_exclusion_volume_preview();
}

References invalidate_exclusion_volume_preview(), and m_config.

Referenced by Slic3r::GUI::Plater::open_filament_map_setting_dialog(), Slic3r::CLI::run(), and Slic3r::GUI::try_pop_up_before_slice().

Here is the call graph for this function:

Here is the caller graph for this function:

set_filament_nozzle_maps()

void Slic3r::GUI::PartPlate::set_filament_nozzle_maps

(

const std::vector< int > &

f_maps

)

{
    m_config.option<ConfigOptionInts>("filament_nozzle_map", true)->values = f_maps;
}

References m_config.

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

set_filament_volume_maps()

void Slic3r::GUI::PartPlate::set_filament_volume_maps

(

const std::vector< int > &

f_maps

)

{
    m_config.option<ConfigOptionInts>("filament_volume_map", true)->values = f_maps;
}

References m_config.

Referenced by Slic3r::GUI::Plater::open_filament_map_setting_dialog(), Slic3r::CLI::run(), and Slic3r::GUI::try_pop_up_before_slice().

Here is the caller graph for this function:

set_first_layer_print_sequence()

void Slic3r::GUI::PartPlate::set_first_layer_print_sequence

(

const std::vector< int > &

sorted_filaments

)

{
    if (sorted_filaments.size() > 0) {
    if (sorted_filaments.size() == 1 && sorted_filaments[0] == 0) {
            m_config.erase("first_layer_print_sequence");
        }
    else {
            ConfigOptionInts *op_print_sequence_1st = m_config.option<ConfigOptionInts>("first_layer_print_sequence");
            if (op_print_sequence_1st)
                op_print_sequence_1st->values = sorted_filaments;
            else
                m_config.set_key_value("first_layer_print_sequence", new ConfigOptionInts(sorted_filaments));
        }
    }
  else {
        m_config.erase("first_layer_print_sequence");
  }
}

References m_config, and Slic3r::ConfigOptionVector< int >::values.

Referenced by Slic3r::GUI::Plater::open_platesettings_dialog().

Here is the caller graph for this function:

set_hover_id()

void Slic3r::GUI::PartPlate::set_hover_id ( int id )

inline

{ m_hover_id = id; }

References Slic3r::ObjectBase::id(), and m_hover_id.

Here is the call graph for this function:

set_hover_tooltip()

void Slic3r::GUI::PartPlate::set_hover_tooltip ( const std::string & tooltip )

private

{
    m_partplate_list->m_hover_tooltip = tooltip;
}

References m_partplate_list.

Referenced by render_icons().

Here is the caller graph for this function:

set_imex_head_filament_map()

void Slic3r::GUI::PartPlate::set_imex_head_filament_map

(

const std::map< int, int > &

m

)

{
    if (m.empty()) {
        m_config.erase("imex_head_filament_map");
    } else {
        std::ostringstream os;
        bool first = true;
        for (const auto& [phys, slot] : m) {
            if (!first) os << ',';
            os << phys << ':' << slot;
            first = false;
        }
        m_config.set_key_value("imex_head_filament_map", new ConfigOptionString(os.str()));
    }
    update_slice_result_valid_state(false);
    // No ghost rebuild: routing only affects color, which update_imex_ghost_colors
    // restamps live every frame.
}

References Slic3r::ConfigOptionString, m_config, and update_slice_result_valid_state().

Here is the call graph for this function:

set_imex_mode()

void Slic3r::GUI::PartPlate::set_imex_mode

(

const std::string &

mode

)

{
    if (mode.empty() || mode == kImexPrimaryMode) {
        m_config.erase("imex_parallel_mode");
    } else {
        m_config.set_key_value("imex_parallel_mode", new ConfigOptionString(mode));
    }
    update_slice_result_valid_state(false);
    m_imex_zones_mode_cache = "\x01"; // force zone rebuild
    m_imex_ghost_cache_key = "\x01";  // force ghost rebuild
}

References Slic3r::ConfigOptionString, Slic3r::kImexPrimaryMode, m_config, m_imex_ghost_cache_key, m_imex_zones_mode_cache, and update_slice_result_valid_state().

Referenced by Slic3r::GUI::Plater::select_plate_by_hover_id().

Here is the call graph for this function:

Here is the caller graph for this function:

set_index()

void Slic3r::GUI::PartPlate::set_index

(

int

index

)

{
  BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": plate_id update from %1% to %2%") % m_plate_index % index;
 
  m_plate_index = index;
  if (m_print != nullptr)
    m_print->set_plate_index(index);
}

References m_plate_index, and m_print.

Referenced by Slic3r::GUI::PartPlateList::create_plate(), Slic3r::GUI::PartPlateList::delete_plate(), Slic3r::GUI::PartPlateList::init(), and Slic3r::GUI::PartPlateList::move_plate_to_index().

Here is the caller graph for this function:

set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

{ m_id = 0; }

References m_id.

Referenced by Slic3r::CutObjectBase::invalidate().

Here is the caller graph for this function:

set_new_unique_id()

void Slic3r::ObjectBase::set_new_unique_id ( )

inlineprotectedinherited

{ m_id = generate_new_id(); }

References generate_new_id(), and m_id.

Referenced by Slic3r::ModelVolume::ModelVolume(), Slic3r::Model::assign_new_unique_ids_recursive(), Slic3r::ModelVolume::assign_new_unique_ids_recursive(), assign_new_unique_ids_recursive(), Slic3r::CutObjectBase::init(), Slic3r::ModelMaterial::set_new_unique_id(), Slic3r::ModelObject::set_new_unique_id(), and Slic3r::ModelVolume::set_new_unique_id().

Here is the call graph for this function:

Here is the caller graph for this function:

set_other_layers_print_sequence()

void Slic3r::GUI::PartPlate::set_other_layers_print_sequence

(

const std::vector< LayerPrintSequence > &

layer_seq_list

)

{
  if (layer_seq_list.empty()) {
    m_config.erase("other_layers_print_sequence");
    m_config.erase("other_layers_print_sequence_nums");
    return;
  }
 
  int sequence_nums;
  std::vector<int> other_layers_seqs;
  Slic3r::get_other_layers_print_sequence(layer_seq_list, sequence_nums, other_layers_seqs);
  ConfigOptionInts* other_layers_print_sequence_op = m_config.option<ConfigOptionInts>("other_layers_print_sequence");
  ConfigOptionInt* other_layers_print_sequence_nums_op = m_config.option<ConfigOptionInt>("other_layers_print_sequence_nums");
  if (other_layers_print_sequence_op)
    other_layers_print_sequence_op->values = other_layers_seqs;
  else
    m_config.set_key_value("other_layers_print_sequence", new ConfigOptionInts(other_layers_seqs));
  if (other_layers_print_sequence_nums_op)
    other_layers_print_sequence_nums_op->value = sequence_nums;
  else
    m_config.set_key_value("other_layers_print_sequence_nums", new ConfigOptionInt(sequence_nums));
}

References Slic3r::get_other_layers_print_sequence(), m_config, and Slic3r::ConfigOptionVector< int >::values.

Referenced by Slic3r::GUI::Plater::open_platesettings_dialog(), update_first_layer_print_sequence(), and update_first_layer_print_sequence_when_delete_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

set_plate_name()

void Slic3r::GUI::PartPlate::set_plate_name

(

const std::string &

name

)

{ 
  // compare if name equal to m_name, case sensitive
    if (boost::equals(m_name, name))
        return;
 
  const std::string previous_name = m_name;
  m_name = name;
    if (m_print != nullptr)
        m_print->set_plate_name(name);
 
  invalidate_plate_name_texture();
 
    if (m_plater != nullptr && !m_plater->is_loading_project()) {
        LifecycleEventContext ctx;
        ctx.name = name;
        ctx.previous_name = previous_name;
        ctx.index = m_plate_index;
        fire_lifecycle_event(LifecycleEvent::PlateRenamed, ctx);
    }
}

References Slic3r::fire_lifecycle_event(), Slic3r::LifecycleEventContext::index, invalidate_plate_name_texture(), m_name, m_plate_index, m_plater, m_print, Slic3r::LifecycleEventContext::name, Slic3r::PlateRenamed, and Slic3r::LifecycleEventContext::previous_name.

Referenced by Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), Slic3r::GUI::Plater::open_platesettings_dialog(), and Slic3r::GUI::Plater::select_plate_by_hover_id().

Here is the call graph for this function:

Here is the caller graph for this function:

set_pos_and_size()

void Slic3r::GUI::PartPlate::set_pos_and_size	(	Vec3d &	origin,
		int	width,
		int	depth,
		double	height,
		bool	with_instance_move,
		bool	do_clear = true )

{
  bool size_changed = false; //size changed means the machine changed
  bool pos_changed = false;
 
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate_id %1%, before, origin {%2%,%3%,%4%}, plate_width %5%, plate_depth %6%, plate_height %7%")\
    % m_plate_index % m_origin.x() % m_origin.y() % m_origin.z() % m_width % m_depth % m_height;
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": with_instance_move %1%, after, origin {%2%,%3%,%4%}, plate_width %5%, plate_depth %6%, plate_height %7%")\
    % with_instance_move % origin.x() % origin.y() % origin.z() % width % depth % height;
  size_changed = ((width != m_width) || (depth != m_depth) || (height != m_height));
  pos_changed = (m_origin != origin);
 
  if ((!size_changed) && (!pos_changed))
  {
    //size and position the same with before, just return
    return;
  }
 
  if (with_instance_move && m_model)
  {
    for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it) {
      int obj_id = it->first;
      int instance_id = it->second;
      if (!valid_instance(obj_id, instance_id))
        continue;
 
      ModelObject* object = m_model->objects[obj_id];
      ModelInstance* instance = object->instances[instance_id];
 
      //move this instance into the new plate's same position
      Vec3d offset = instance->get_transformation().get_offset();
      int off_x, off_y;
 
      if (size_changed)
      {
        //change position due to the bed size changes
        //off_x = (width - m_width) * m_plate_index + (width - m_width) / 2;
        //off_y = (depth - m_depth) * m_plate_index + (depth - m_depth) / 2;
        off_x = origin.x() - m_origin.x() + (width - m_width) / 2;
        off_y = origin.y() - m_origin.y() + (depth - m_depth) / 2;
      }
      else
      {
        //change position due to the plate moves
        off_x = origin.x() - m_origin.x();
        off_y = origin.y() - m_origin.y();
      }
      offset.x() = offset.x() + off_x;
      offset.y() = offset.y() + off_y;
 
      BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": object %1%, instance %2%, moved {%3%,%4%} to {%5%, %6%}")\
        % obj_id % instance_id % off_x % off_y % offset.x() % offset.y();
 
      instance->set_offset(offset);
      object->invalidate_bounding_box();
    }
  }
  else if (do_clear)
  {
    clear();
  }
 
    if (m_print)
        m_print->set_plate_origin(origin);
 
  m_origin = origin;
  m_width = width;
  m_depth = depth;
  m_height = height;
    invalidate_exclusion_volume_preview();
 
  if (with_instance_move && m_plater)
    m_plater->mark_plate_toolbar_image_dirty();
 
  return;
}

References clear(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelInstance::get_transformation(), invalidate_exclusion_volume_preview(), m_depth, m_height, m_model, m_origin, m_plate_index, m_plater, m_print, m_width, obj_to_instance_set, Slic3r::offset(), Slic3r::ModelInstance::set_offset(), and valid_instance().

Referenced by Slic3r::GUI::PartPlateList::delete_plate(), Slic3r::GUI::PartPlateList::move_plate_to_index(), and Slic3r::GUI::PartPlateList::update_all_plates_pos_and_size().

Here is the call graph for this function:

Here is the caller graph for this function:

set_print()

void Slic3r::GUI::PartPlate::set_print	(	PrintBase *	print,
		GCodeResult *	result = nullptr,
		int	index = -1 )

{
  if (printer_technology == PrinterTechnology::ptFFF)
    m_print = static_cast<Print*>(print);
  //todo, for other printers
 
  m_gcode_result = result;
  if (index >= 0)
    m_print_index = index;
 
  m_print->set_plate_origin(m_origin);
    invalidate_exclusion_volume_preview();
 
  return;
}

References invalidate_exclusion_volume_preview(), m_gcode_result, m_origin, m_print, m_print_index, print(), printer_technology, and Slic3r::ptFFF.

Referenced by Slic3r::GUI::PartPlateList::create_plate(), and Slic3r::GUI::PartPlateList::init().

Here is the call graph for this function:

Here is the caller graph for this function:

set_print_seq()

void Slic3r::GUI::PartPlate::set_print_seq

(

PrintSequence

print_seq = PrintSequence::ByDefault

)

{
    std::string print_seq_key = "print_sequence";
 
    // should be called in GUI context
    assert(m_plater != nullptr);
 
    // update slice state
    PrintSequence old_real_print_seq = get_print_seq();
    if (old_real_print_seq == PrintSequence::ByDefault) {
        auto curr_preset_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
        if (curr_preset_config.has(print_seq_key))
            old_real_print_seq = curr_preset_config.option<ConfigOptionEnum<PrintSequence>>(print_seq_key)->value;
    }
 
    PrintSequence new_real_print_seq = print_seq;
 
    if (print_seq == PrintSequence::ByDefault) {
        auto curr_preset_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
        if (curr_preset_config.has(print_seq_key))
            new_real_print_seq = curr_preset_config.option<ConfigOptionEnum<PrintSequence>>(print_seq_key)->value;
    }
 
    if (old_real_print_seq != new_real_print_seq) {
        update_slice_result_valid_state(false);
    }
 
    //print_seq_same_global = same_global;
    if (print_seq == PrintSequence::ByDefault)
        m_config.erase(print_seq_key);
    else
        m_config.set_key_value(print_seq_key, new ConfigOptionEnum<PrintSequence>(print_seq));
}

References Slic3r::ByDefault, get_print_seq(), m_config, m_plater, and update_slice_result_valid_state().

Referenced by Slic3r::GUI::Plater::open_platesettings_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

set_selected()

void Slic3r::GUI::PartPlate::set_selected

(

)

                             {
  m_selected = true;
}

References m_selected.

set_shape()

bool Slic3r::GUI::PartPlate::set_shape	(	const Pointfs &	shape,
		const Pointfs &	exclude_areas,
		const std::vector< Pointfs > &	extruder_areas,
		const std::vector< double > &	extruder_heights,
		Vec2d	position,
		float	height_to_lid,
		float	height_to_rod )

{
    invalidate_exclusion_volume_preview();
 
  Pointfs new_shape, new_exclude_areas;
  m_extruder_heights = extruder_heights;
  for (const Vec2d& p : shape) {
    new_shape.push_back(Vec2d(p.x() + position.x(), p.y() + position.y()));
  }
 
  for (const Vec2d& p : exclude_areas) {
    new_exclude_areas.push_back(Vec2d(p.x() + position.x(), p.y() + position.y()));
  }
 
  std::vector<Pointfs> new_extruder_areas;
  for (const Pointfs& shape : extruder_areas) {
    Pointfs new_extruder_area;
    for (const Vec2d& p : shape) {
      Vec2d point(p(0) + position.x(), p(1) + position.y());
      new_extruder_area.push_back(point);
    }
    new_extruder_areas.push_back(new_extruder_area);
  }
  m_extruder_areas = std::move(new_extruder_areas);
 
  if ((m_shape == new_shape)&&(m_exclude_area == new_exclude_areas)
    &&(m_height_to_lid == height_to_lid)&&(m_height_to_rod == height_to_rod)) {
    BOOST_LOG_TRIVIAL(info) << "PartPlate same shape, skip directly";
    return false;
  }
 
  m_height_to_lid =  height_to_lid;
  m_height_to_rod =  height_to_rod;
 
  if ((m_shape != new_shape) || (m_exclude_area != new_exclude_areas))
  {
    /*m_shape.clear();
    for (const Vec2d& p : shape) {
      m_shape.push_back(Vec2d(p.x() + position.x(), p.y() + position.y()));
    }
 
    m_exclude_area.clear();
    for (const Vec2d& p : exclude_areas) {
      m_exclude_area.push_back(Vec2d(p.x() + position.x(), p.y() + position.y()));
    }*/
    m_shape = std::move(new_shape);
    m_exclude_area = std::move(new_exclude_areas);
 
    calc_bounding_boxes();
 
    if (m_plater != nullptr) { // render data, skip in CLI mode where m_plater is null
      ExPolygon logo_poly;
      generate_logo_polygon(logo_poly);
      m_logo_triangles.reset();
      if (!init_model_from_poly(m_logo_triangles, logo_poly, GROUND_Z + 0.02f))
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":Unable to create logo triangles\n";
 
      ExPolygon poly;
      generate_print_polygon(poly);
      calc_triangles(poly);
 
      // reset m_wrapping_detection_triangles when change printer
      m_print_polygon = poly;
      m_wrapping_detection_triangles.reset();
      init_raycaster_from_model(m_triangles);
 
      ExPolygon exclude_poly;
      generate_exclude_polygon(exclude_poly);
      calc_exclude_triangles(exclude_poly);
 
      const BoundingBox& pp_bbox = poly.contour.bounding_box();
      calc_gridlines(poly, pp_bbox);
      m_imex_zones_mode_cache = "\x01"; // force rebuild on next render
      calc_imex_zones();
 
      calc_vertex_for_icons(0, m_del_icon);
      calc_vertex_for_icons(1, m_orient_icon);
      calc_vertex_for_icons(2, m_arrange_icon);
      calc_vertex_for_icons(3, m_lock_icon);
      calc_vertex_for_icons(4, m_plate_settings_icon);
      // ORCA also change bed_icon_count number in calc_vertex_for_icons() after adding or removing icons for circular shaped beds that uses vertical alingment for icons
      bool dual_bbl = false;
      PresetBundle* preset = wxGetApp().preset_bundle;
      dual_bbl = (preset->is_bbl_vendor() && preset->get_printer_extruder_count() == 2);
      calc_vertex_for_icons(dual_bbl ? 5 : 6, m_plate_filament_map_icon);
      calc_vertex_for_icons(dual_bbl ? 6 : 5, m_move_front_icon);
      {
        auto* is_imex_opt = preset->printers.get_edited_preset().config.option<ConfigOptionBool>("is_imex");
        if (is_imex_opt && is_imex_opt->value) {
          int imex_slot = dual_bbl ? 7 : 6;
          calc_vertex_for_icons(imex_slot, m_imex_mode_icon);
          calc_vertex_for_imex_warn_badge(imex_slot, m_imex_warn_icon);
        }
      }
 
      calc_vertex_for_number(0, false, m_plate_idx_icon);
      // calc vertex for plate name
      invalidate_plate_name_texture();
    }
  }
 
  calc_height_limit();
 
  return true;
}

References calc_bounding_boxes(), calc_exclude_triangles(), calc_gridlines(), calc_height_limit(), calc_imex_zones(), calc_triangles(), calc_vertex_for_icons(), calc_vertex_for_imex_warn_badge(), calc_vertex_for_number(), Slic3r::Preset::config, generate_exclude_polygon(), generate_logo_polygon(), generate_print_polygon(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetBundle::get_printer_extruder_count(), GROUND_Z, Slic3r::GUI::init_model_from_poly(), Slic3r::GUI::init_raycaster_from_model(), invalidate_exclusion_volume_preview(), invalidate_plate_name_texture(), Slic3r::PresetBundle::is_bbl_vendor(), m_arrange_icon, m_del_icon, m_exclude_area, m_extruder_areas, m_extruder_heights, m_height_to_lid, m_height_to_rod, m_imex_mode_icon, m_imex_warn_icon, m_imex_zones_mode_cache, m_lock_icon, m_logo_triangles, m_move_front_icon, m_orient_icon, m_plate_filament_map_icon, m_plate_idx_icon, m_plate_settings_icon, m_plater, m_print_polygon, m_shape, m_triangles, m_wrapping_detection_triangles, Slic3r::ConfigBase::option(), position, and Slic3r::PresetBundle::printers.

Referenced by Slic3r::GUI::PartPlateList::create_plate(), Slic3r::GUI::PartPlateList::delete_plate(), and Slic3r::GUI::PartPlateList::set_shapes().

Here is the call graph for this function:

Here is the caller graph for this function:

set_spiral_vase_mode()

void Slic3r::GUI::PartPlate::set_spiral_vase_mode	(	bool	spiral_mode,
		bool	as_global )

{
  std::string key = "spiral_mode";
  if (as_global)
    m_config.erase(key);
  else {
    if (spiral_mode) {
      if (get_spiral_vase_mode())
        return;
      // Secondary confirmation
      auto answer = static_cast<TabPrintPlate*>(wxGetApp().plate_tab)->show_spiral_mode_settings_dialog(false);
      if (answer == wxID_YES) {
        m_config.set_key_value(key, new ConfigOptionBool(true));
        set_vase_mode_related_object_config();
      }
    }
    else
      m_config.set_key_value(key, new ConfigOptionBool(false));
  }
}

References get_spiral_vase_mode(), m_config, and set_vase_mode_related_object_config().

Referenced by Slic3r::GUI::Plater::open_platesettings_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

set_timelapse_warning_code()

void Slic3r::GUI::PartPlate::set_timelapse_warning_code ( int code )

inline

{ m_timelapse_warning_code = code; }

References m_timelapse_warning_code.

set_tmp_gcode_path()

void Slic3r::GUI::PartPlate::set_tmp_gcode_path ( std::string new_path )

inline

    {
        m_tmp_gcode_path = new_path;
    }

References m_tmp_gcode_path.

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

set_unselected()

void Slic3r::GUI::PartPlate::set_unselected

(

)

                               {
  m_selected = false;
}

References m_selected.

set_vase_mode_related_object_config()

void Slic3r::GUI::PartPlate::set_vase_mode_related_object_config

(

int

obj_id = -1

)

                                                              {
  ModelObjectPtrs obj_ptrs;
  if (obj_id != -1) {
    ModelObject* object = m_model->objects[obj_id];
    obj_ptrs.push_back(object);
  }
  else
    obj_ptrs = get_objects_on_this_plate();
 
  DynamicPrintConfig* global_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
  DynamicPrintConfig new_conf;
  new_conf.set_key_value("wall_loops", new ConfigOptionInt(1));
  new_conf.set_key_value("top_shell_layers", new ConfigOptionInt(0));
  new_conf.set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
  new_conf.set_key_value("enable_support", new ConfigOptionBool(false));
  new_conf.set_key_value("enforce_support_layers", new ConfigOptionInt(0));
  new_conf.set_key_value("detect_thin_wall", new ConfigOptionBool(false));
  new_conf.set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
  new_conf.set_key_value("overhang_reverse", new ConfigOptionBool(false));
  const auto applying_keys = global_config->diff(new_conf);
 
  for (ModelObject* object : obj_ptrs) {
    ModelConfigObject& config = object->config;
 
    for (auto opt_key : applying_keys) {
      config.set_key_value(opt_key, new_conf.option(opt_key)->clone());
    }
 
    const auto object_keys = config.get().diff(new_conf);
    for (auto opt_key : object_keys) {
      config.set_key_value(opt_key, new_conf.option(opt_key)->clone());
    }
  }
  //wxGetApp().obj_list()->update_selections();
}

References Slic3r::ConfigOption::clone(), config(), Slic3r::DynamicConfig::diff(), get_objects_on_this_plate(), m_model, Slic3r::ConfigBase::option(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::tlTraditional.

Referenced by Slic3r::GUI::PartPlateList::notify_instance_update(), and set_spiral_vase_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

timelapse_warning_code()

int Slic3r::GUI::PartPlate::timelapse_warning_code ( )

inline

{ return m_timelapse_warning_code; }

References m_timelapse_warning_code.

timestamp()

virtual Timestamp Slic3r::ObjectBase::timestamp ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::ModelConfigObject, and Slic3r::ObjectWithTimestamp.

{ return 0; }

translate_all_instance()

void Slic3r::GUI::PartPlate::translate_all_instance

(

Vec3d

position

)

{
    for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it)
    {
        int obj_id = it->first;
        int instance_id = it->second;
 
        if ((obj_id >= 0) && (obj_id < m_model->objects.size()))
        {
            ModelObject* object = m_model->objects[obj_id];
            if ((instance_id >= 0) && (instance_id < object->instances.size()))
            {
                ModelInstance* instance = object->instances[instance_id];
                const Vec3d& offset =  instance->get_offset();
                instance->set_offset(offset + position);
            }
        }
    }
    invalidate_exclusion_volume_preview();
    return;
}

References Slic3r::ModelInstance::get_offset(), invalidate_exclusion_volume_preview(), m_model, obj_to_instance_set, Slic3r::offset(), position, and Slic3r::ModelInstance::set_offset().

Referenced by Slic3r::GUI::PartPlateList::duplicate_plate(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

update_apply_result_invalid()

void Slic3r::GUI::PartPlate::update_apply_result_invalid ( bool invalid )

inline

    {
        m_apply_invalid = invalid;
    }

References m_apply_invalid.

Referenced by Slic3r::GUI::Plater::priv::update_background_process().

Here is the caller graph for this function:

update_exclusion_volume_preview_models()

void Slic3r::GUI::PartPlate::update_exclusion_volume_preview_models ( )

private

{
    if (!m_exclusion_volume_preview_dirty)
        return;
    m_exclusion_volume_preview_dirty = false;
 
    const DynamicPrintConfig *config = m_plater != nullptr ? m_plater->config() : nullptr;
    if (config == nullptr) {
        m_exclusion_volume_preview_cache_key.clear();
        m_exclusion_volume_floor_triangles.reset();
        m_exclusion_volume_border_triangles.reset();
        m_extruder_exclusion_volume_borders.clear();
        m_active_exclusion_volume_prisms.reset();
        m_exclusion_volume_intersection_triangles.reset();
        m_exclusion_volume_intersections_cleared = false;
        return;
    }
 
    const std::vector<std::vector<BedExcludeRegion>> regions_by_extruder = get_bed_excluded_regions_by_extruder(*config);
    std::vector<BedExcludeRegion> regions;
    const BedExcludeVolumeMode mode = active_bed_exclude_volume_mode(*config);
    for (size_t extruder_id = 0; extruder_id < regions_by_extruder.size(); ++extruder_id) {
        if (mode == BedExcludeVolumeMode::Shared && extruder_id > 0)
            break;
        for (const BedExcludeRegion &region : regions_by_extruder[extruder_id]) {
            if (!region.is_collision_volume() && extruder_id > 0)
                continue;
            regions.emplace_back(region);
        }
    }
    // A coloured border communicates which physical nozzle owns a footprint.
    // With only one nozzle the exclusion applies to every filament, so using
    // the first filament colour would incorrectly imply material ownership.
    const bool show_nozzle_ownership =
        regions_by_extruder.size() > 1 && mode != BedExcludeVolumeMode::Shared;
    std::ostringstream grouped_key;
    const bool show_all_volumes = m_plater->are_collision_volumes_shown();
    grouped_key << exclusion_volume_preview_cache_key(regions) << "mode:" << int(mode)
                << ";show_all:" << show_all_volumes << ";groups:";
    for (const std::vector<BedExcludeRegion> &group : regions_by_extruder)
        grouped_key << group.size() << ',';
    const std::vector<std::string> filament_colors = m_plater->get_extruder_colors_from_plater_config();
    std::vector<std::string> preview_colors(regions_by_extruder.size());
 
    // Use the same effective filament-to-nozzle policy as collision checks so
    // the coloured border never implies a mapping the validator does not use.
    const DynamicPrintConfig &project_config = wxGetApp().preset_bundle->project_config;
    const std::vector<int> filament_map = get_effective_exclusion_filament_maps(
        project_config, filament_colors.size(), regions_by_extruder.size());
    grouped_key << "map:";
    for (const int extruder_id : filament_map)
        grouped_key << extruder_id << ',';
    grouped_key << ';';
    grouped_key << "object_maps:";
    if (m_model != nullptr) {
        for (const std::pair<int, int> &object_instance : obj_to_instance_set) {
            const int object_id = object_instance.first;
            if (object_id < 0 || object_id >= int(m_model->objects.size()))
                continue;
            grouped_key << object_id << ':';
            for (const auto &[filament_id, extruder_id] : get_object_filament_extruders(
                     *m_model->objects[object_id], project_config, regions_by_extruder.size()))
                grouped_key << filament_id << '>' << extruder_id << ',';
            grouped_key << ';';
        }
    }
    for (size_t filament_id = 0; filament_id < filament_colors.size(); ++filament_id) {
        const int mapped_extruder = filament_id < filament_map.size() ? filament_map[filament_id] - 1 : int(filament_id);
        if (mapped_extruder >= 0 && size_t(mapped_extruder) < preview_colors.size() && preview_colors[mapped_extruder].empty())
            preview_colors[mapped_extruder] = filament_colors[filament_id];
    }
 
    if (const ConfigOptionStrings *extruder_colors = config->opt<ConfigOptionStrings>("extruder_colour");
        extruder_colors != nullptr) {
        for (size_t extruder_id = 0; extruder_id < preview_colors.size() && extruder_id < extruder_colors->size(); ++extruder_id)
            if (preview_colors[extruder_id].empty())
                preview_colors[extruder_id] = extruder_colors->values[extruder_id];
    }
    for (const std::string &color : preview_colors)
        grouped_key << color << ',';
    const std::string cache_key = grouped_key.str();
    if (cache_key == m_exclusion_volume_preview_cache_key && !m_exclusion_volume_intersections_cleared)
        return;
    m_exclusion_volume_preview_cache_key = cache_key;
    m_exclusion_volume_intersections_cleared = false;
 
    m_exclusion_volume_floor_triangles.reset();
    m_exclusion_volume_border_triangles.reset();
    m_extruder_exclusion_volume_borders.clear();
    m_active_exclusion_volume_prisms.reset();
    m_exclusion_volume_intersection_triangles.reset();
 
    const Point plate_offset(scale_(m_origin.x()), scale_(m_origin.y()));
    Polygons floor_regions;
    ExPolygons border_regions;
    const coord_t ribbon_width = scale_(1.6);
    struct PreviewRegion {
        BedExcludeRegion region;
        Polygon          footprint;
        size_t           extruder_id;
    };
    std::vector<PreviewRegion> preview_regions;
    Polygons preview_footprints;
    std::vector<ExclusionVolumePrismPreview> active_prisms;
 
    if (show_nozzle_ownership) {
        static const std::array<ColorRGBA, 6> fallback_colors = {
            ColorRGBA{ .18f, .52f, .95f, .92f }, ColorRGBA{ .95f, .35f, .22f, .92f },
            ColorRGBA{ .25f, .72f, .38f, .92f }, ColorRGBA{ .72f, .34f, .88f, .92f },
            ColorRGBA{ .95f, .68f, .16f, .92f }, ColorRGBA{ .18f, .76f, .78f, .92f }
        };
        const coord_t tool_border_width = scale_(0.55);
        for (size_t extruder_id = 0; extruder_id < regions_by_extruder.size(); ++extruder_id) {
            ColorRGBA color = fallback_colors[extruder_id % fallback_colors.size()];
            if (extruder_id < preview_colors.size()) {
                ColorRGBA decoded;
                if (decode_color(preview_colors[extruder_id], decoded)) {
                    color = decoded;
                    color.a(0.92f);
                }
            }
 
            for (const BedExcludeRegion &region_src : regions_by_extruder[extruder_id]) {
                if (!region_src.is_collision_volume())
                    continue;
                Polygon footprint = region_src.polygon;
                footprint.translate(plate_offset);
                footprint.make_counter_clockwise();
                const Polygons inner = offset(Polygons{ footprint }, -tool_border_width, jtMiter, 2.0);
                const ExPolygons border = inner.empty() ? ExPolygons{ expolygon_from_polygon(footprint) } : diff_ex(Polygons{ footprint }, inner);
                auto model = std::make_unique<GLModel>();
                // Nozzle colours identify the bed footprint, not the volume's
                // vertical position, so keep this border with the grey preview.
                const float border_z = GROUND_Z + 0.026f;
                if (init_model_from_expolygons(*model, border, border_z) && model->is_initialized())
                    m_extruder_exclusion_volume_borders.emplace_back(std::move(model), color);
            }
        }
    }
 
    for (size_t extruder_id = 0; extruder_id < regions_by_extruder.size(); ++extruder_id) {
        // Shared regions are identical for every nozzle. Keeping one copy
        // avoids duplicate floor, prism and intersection geometry.
        if (mode == BedExcludeVolumeMode::Shared && extruder_id > 0)
            break;
 
        for (const BedExcludeRegion &region_src : regions_by_extruder[extruder_id]) {
            // The legacy area is shared and bed-fixed, even when nozzle-specific
            // collision volumes are active. Keep only one preview copy.
            if (!region_src.is_collision_volume() && extruder_id > 0)
                continue;
            Polygon region = region_src.polygon;
            region.translate(plate_offset);
            region.make_counter_clockwise();
            BedExcludeRegion translated_region = region_src;
            translated_region.polygon = region;
            preview_regions.push_back({ std::move(translated_region), region, extruder_id });
            preview_footprints.emplace_back(region);
 
            // Legacy polygons continue to use Orca's existing grey bed preview;
            // the additional floor/ribbon belongs only to collision volumes.
            if (region_src.is_collision_volume()) {
                if (!region_src.has_z_range || region_src.z_min <= EPSILON) {
                    floor_regions.emplace_back(region);
                } else {
                    const Polygons inner = offset(Polygons{ region }, -ribbon_width, jtMiter, 2.0);
                    ExPolygons border = inner.empty() ? ExPolygons{ expolygon_from_polygon(region) } : diff_ex(Polygons{ region }, inner);
                    border_regions.insert(border_regions.end(), border.begin(), border.end());
                }
            }
        }
    }
 
    // Automatic previews stay limited to nearby objects. The View toggle lets
    // profile authors inspect the complete configured height on an empty bed.
    const double preview_height = show_all_volumes ? 0.0 :
        max_broad_phase_intersecting_object_height(preview_footprints);
    if (show_all_volumes || preview_height > EPSILON) {
        for (const PreviewRegion &preview_region : preview_regions) {
            const BedExcludeRegion &region_src = preview_region.region;
            if (!region_src.is_collision_volume())
                continue;
            const double z_min = region_src.has_z_range ? region_src.z_min : 0.0;
            const double z_max = show_all_volumes ? region_src.z_max : std::min(region_src.z_max, preview_height);
            if (z_max > z_min + EPSILON)
                active_prisms.push_back({ preview_region.footprint, z_min, z_max });
        }
    }
 
    indexed_triangle_set intersection_triangles;
    if (m_model != nullptr && !preview_regions.empty()) {
        for (const std::pair<int, int> &object_instance : obj_to_instance_set) {
            const int obj_id = object_instance.first;
            const int instance_id = object_instance.second;
            if (obj_id < 0 || obj_id >= int(m_model->objects.size()))
                continue;
 
            ModelObject *object = m_model->objects[obj_id];
            if (instance_id < 0 || instance_id >= int(object->instances.size()))
                continue;
 
            ModelInstance *instance = object->instances[instance_id];
            if (!instance->printable)
                continue;
 
            std::set<size_t> relevant_extruders;
            if (mode != BedExcludeVolumeMode::Shared) {
                for (const auto &mapping : get_object_filament_extruders(
                         *object, project_config, regions_by_extruder.size()))
                    relevant_extruders.emplace(mapping.second);
            }
 
            Polygon hull = instance->convex_hull_2d();
            const BoundingBoxf3 instance_box = object->instance_convex_hull_bounding_box(instance_id);
            for (const PreviewRegion &preview_region : preview_regions) {
                if (preview_region.region.is_collision_volume() && mode != BedExcludeVolumeMode::Shared &&
                    relevant_extruders.find(preview_region.extruder_id) == relevant_extruders.end())
                    continue;
 
                const BedExcludeRegion &region = preview_region.region;
                if (intersection(Polygons{ preview_region.footprint }, Polygons{ hull }).empty())
                    continue;
                if (instance_box.max.z() < region.z_min || instance_box.min.z() > region.z_max)
                    continue;
 
                // The preview path intentionally requests the full clipped mesh.
                // Boolean-only placement checks call this without an output mesh.
                indexed_triangle_set region_intersections;
                if (instance->intersects_bed_exclude_region(region, &region_intersections) && !region_intersections.empty())
                    its_merge(intersection_triangles, region_intersections);
            }
        }
    }
 
    if (!floor_regions.empty() && !init_model_from_polygons(m_exclusion_volume_floor_triangles, floor_regions, GROUND_Z + 0.01f))
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":Unable to create exclusion volume floor preview triangles\n";
 
    if (!border_regions.empty() && !init_model_from_expolygons(m_exclusion_volume_border_triangles, border_regions, GROUND_Z + 0.018f))
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":Unable to create exclusion volume preview border\n";
 
    if (!active_prisms.empty() && !init_exclusion_volume_prism_model(m_active_exclusion_volume_prisms, active_prisms))
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":Unable to create active exclusion volume preview prisms\n";
 
    if (!intersection_triangles.empty())
        m_exclusion_volume_intersection_triangles.init_from(intersection_triangles);
}

References Slic3r::ColorRGBA::a(), Slic3r::active_bed_exclude_volume_mode(), config(), Slic3r::ModelInstance::convex_hull_2d(), Slic3r::GUI::decode_color(), Slic3r::diff_ex(), empty(), EPSILON, exclusion_volume_preview_cache_key(), Slic3r::GUI::expolygon_from_polygon(), Slic3r::filament_map(), Slic3r::get_bed_excluded_regions_by_extruder(), get_effective_exclusion_filament_maps(), get_object_filament_extruders(), GROUND_Z, Slic3r::BedExcludeRegion::has_z_range, Slic3r::GUI::init_exclusion_volume_prism_model(), Slic3r::GUI::init_model_from_expolygons(), Slic3r::GUI::init_model_from_polygons(), Slic3r::ModelObject::instances, Slic3r::intersection(), Slic3r::ModelInstance::intersects_bed_exclude_region(), Slic3r::BedExcludeRegion::is_collision_volume(), Slic3r::its_merge(), Slic3r::jtMiter, m_active_exclusion_volume_prisms, m_exclusion_volume_border_triangles, m_exclusion_volume_floor_triangles, m_exclusion_volume_intersection_triangles, m_exclusion_volume_intersections_cleared, m_exclusion_volume_preview_cache_key, m_exclusion_volume_preview_dirty, m_extruder_exclusion_volume_borders, m_model, m_origin, m_plater, Slic3r::Polygon::make_counter_clockwise(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, max_broad_phase_intersecting_object_height(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, obj_to_instance_set, Slic3r::offset(), Slic3r::BedExcludeRegion::polygon, Slic3r::ModelInstance::printable, scale_, Slic3r::Shared, Slic3r::MultiPoint::translate(), Slic3r::BedExcludeRegion::z_max, and Slic3r::BedExcludeRegion::z_min.

Referenced by render_exclusion_volume_previews().

Here is the call graph for this function:

Here is the caller graph for this function:

update_first_layer_print_sequence()

void Slic3r::GUI::PartPlate::update_first_layer_print_sequence

(

size_t

filament_nums

)

{
  auto other_layers_seqs = get_other_layers_print_sequence();
  if (!other_layers_seqs.empty()) {
    bool need_update_data = false;
    for (auto& other_layers_seq : other_layers_seqs) {
      std::vector<int>& orders = other_layers_seq.second;
      if (orders.size() > filament_nums) {
        orders.erase(std::remove_if(orders.begin(), orders.end(), [filament_nums](int n) { return n > filament_nums; }), orders.end());
        need_update_data = true;
      }
      if (orders.size() < filament_nums) {
        for (size_t extruder_id = orders.size(); extruder_id < filament_nums; ++extruder_id) {
          orders.push_back(extruder_id + 1);
          need_update_data = true;
        }
      }
    }
    if (need_update_data)
      set_other_layers_print_sequence(other_layers_seqs);
  }
 
 
    ConfigOptionInts * op_print_sequence_1st = m_config.option<ConfigOptionInts>("first_layer_print_sequence");
    if (!op_print_sequence_1st) {
    return;
  }
 
    std::vector<int> &print_sequence_1st = op_print_sequence_1st->values;
    if (print_sequence_1st.size() == 0 || print_sequence_1st[0] == 0)
    return;
 
  if (print_sequence_1st.size() > filament_nums) {
        print_sequence_1st.erase(std::remove_if(print_sequence_1st.begin(), print_sequence_1st.end(), [filament_nums](int n) { return n > filament_nums; }),
                                 print_sequence_1st.end());
    }
  else if (print_sequence_1st.size() < filament_nums) {
        for (size_t extruder_id = print_sequence_1st.size(); extruder_id < filament_nums; ++extruder_id) {
            print_sequence_1st.push_back(extruder_id + 1);
    }
    }
}

References get_other_layers_print_sequence(), m_config, set_other_layers_print_sequence(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by Slic3r::GUI::Plater::on_filament_count_change().

Here is the call graph for this function:

Here is the caller graph for this function:

update_first_layer_print_sequence_when_delete_filament()

void Slic3r::GUI::PartPlate::update_first_layer_print_sequence_when_delete_filament

(

size_t

filamen_id

)

{
    auto other_layers_seqs = get_other_layers_print_sequence();
    if (!other_layers_seqs.empty()) {
        bool need_update_data = false;
        for (auto &other_layers_seq : other_layers_seqs) {
            std::vector<int> &orders = other_layers_seq.second;
            orders.erase(std::remove_if(orders.begin(), orders.end(), [filament_id](int n) { return n == filament_id +1; }), orders.end());
            for (auto &order : orders) {
                order = order > filament_id ? order - 1 : order;
            }
            need_update_data = true;
        }
        if (need_update_data)
            set_other_layers_print_sequence(other_layers_seqs);
    }
 
    ConfigOptionInts *op_print_sequence_1st = m_config.option<ConfigOptionInts>("first_layer_print_sequence");
    if (!op_print_sequence_1st)
        return;
 
    std::vector<int> &print_sequence_1st = op_print_sequence_1st->values;
    if (print_sequence_1st.size() == 0 || print_sequence_1st[0] == 0)
        return;
 
    print_sequence_1st.erase(std::remove_if(print_sequence_1st.begin(), print_sequence_1st.end(), [filament_id](int n) { return n == filament_id + 1; }), print_sequence_1st.end());
    for (auto &order : print_sequence_1st) {
        order = order > filament_id ? order - 1 : order;
    }
}

References get_other_layers_print_sequence(), m_config, set_other_layers_print_sequence(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by on_filament_deleted().

Here is the call graph for this function:

Here is the caller graph for this function:

update_imex_ghost_colors()

void Slic3r::GUI::PartPlate::update_imex_ghost_colors

(

)

{
    // !m_plater is the headless sentinel: without a GUI_App, calling wxGetApp()
    // below is unsafe — same guard pattern as ensure_imex_zones.
    if (m_imex_ghost_volumes.empty() || !m_plater) return;
    auto* pb = wxGetApp().preset_bundle;
    if (!pb) return;
 
    // Plate-level inputs hoisted once; per-head results memoized across instances.
    const ConfigOptionInts pem = effective_physical_extruder_map(*pb);
    const auto plate_map = get_imex_head_filament_map();
 
    std::map<int, ColorRGBA> head_colors;
    for (auto& ghost : m_imex_ghost_volumes) {
        if (!ghost) continue;
        const int head = imex_ghost_head_from_composite_id(ghost->composite_id.object_id);
        auto hc = head_colors.find(head);
        if (hc == head_colors.end())
            hc = head_colors.emplace(head, get_imex_head_filament_color(head, pem, plate_map)).first;
        ColorRGBA color = hc->second;
        color.a(IMEX_GHOST_ALPHA);
        ghost->color = color;
    }
}

References Slic3r::ColorRGBA::a(), Slic3r::effective_physical_extruder_map(), get_imex_head_filament_color(), get_imex_head_filament_map(), Slic3r::GUI::IMEX_GHOST_ALPHA, imex_ghost_head_from_composite_id(), m_imex_ghost_volumes, and m_plater.

Referenced by Slic3r::GUI::GLCanvas3D::_render_imex_ghosts().

Here is the call graph for this function:

Here is the caller graph for this function:

update_imex_ghost_transforms()

void Slic3r::GUI::PartPlate::update_imex_ghost_transforms

(

const std::function< std::optional< Transform3d >(int, int)> &

primary_live_xf = {}

)

{
    if (m_imex_ghost_volumes.empty() || !m_plater || !m_model) return;
 
    std::string active_tools_str;
    int primary_phys = -1;
    if (!resolve_active_mode_tools(active_tools_str, primary_phys)) return;
 
    // Reuse zone-center-derived offsets (same source calc_imex_ghosts uses), so
    // update and rebuild paths always agree on where each ghost belongs.
    ensure_imex_zones();
    auto center_for = [&](int phys) -> Vec2d {
        auto it = m_imex_head_zone_centers.find(phys);
        return (it == m_imex_head_zone_centers.end()) ? Vec2d::Zero() : it->second;
    };
    const Vec2d primary_off = center_for(primary_phys);
 
    // Same aggregation-aware center resolution as calc_imex_ghosts uses, so a live drag
    // moves the ghost exactly as a rebuild would place it. See the note there: for an
    // aggregated gantry both X frames sit on the bed centerline, which zeroes gantry_offset.x
    // so the cross-gantry mirror tracks primary's X and reflects in Y.
    // Same accessor, same reason as calc_imex_ghosts() above: this must group the grid the way
    // compute_imex_zone_layout() does. The grouping/is_aggregated preamble that follows is
    // duplicated from that function; the duplication predates this change and is left alone.
    const int tpg = std::max(1, imex_cfg_int(
        wxGetApp().preset_bundle->printers.get_edited_preset().config, "imex_tools_per_gantry"));
    const ImexGantryGrouping grouping =
        group_imex_active_tools_by_gantry(active_tools_str, tpg);
    auto is_aggregated = [&](int phys) -> bool {
        const int g = phys / tpg;
        for (const auto& grp : grouping.groups)
            if (grp.gantry_index == g) return grp.aggregate;
        return false;
    };
    auto bed_ext = get_extents(m_shape);
    const double bed_x_center = 0.5 * (bed_ext.min(0) + bed_ext.max(0));
    auto resolve_centers = [&](int phys) -> std::pair<Vec2d, Vec2d> {
        const Vec2d target_off = center_for(phys);
        if (!is_aggregated(phys))
            return {primary_off, target_off - primary_off};
        const Vec2d ap{bed_x_center, primary_off.y()};
        const Vec2d at{bed_x_center, target_off.y()};
        return {ap, at - ap};
    };
    auto mirror_axis_for = [&](int phys) {
        return imex_mirror_axis_for(primary_phys, phys, tpg);
    };
 
    // Build a phys → role map once so the per-ghost loop is a lookup, not a reparse.
    std::map<int, ImexRole> role_by_phys;
    for (const auto& [phys, role] : parse_imex_active_tools(active_tools_str))
        role_by_phys[phys] = role;
    auto role_for = [&](int phys) -> ImexRole {
        auto it = role_by_phys.find(phys);
        return (it == role_by_phys.end()) ? ImexRole::Copy : it->second;
    };
 
    for (auto& ghost : m_imex_ghost_volumes) {
        const int head = imex_ghost_head_from_composite_id(ghost->composite_id.object_id);
        const int inst_idx = ghost->composite_id.instance_id;
        const int obj_idx  = ghost->composite_id.volume_id;  // stashed by calc_imex_ghosts
        if (obj_idx < 0 || obj_idx >= (int)m_model->objects.size()) continue;
        const ModelObject* mo = m_model->objects[obj_idx];
        if (!mo || inst_idx < 0 || inst_idx >= (int)mo->instances.size()) continue;
 
        // Live-drag path: GLVolume carries the in-progress gizmo transform, while
        // ModelInstance::get_matrix() only reflects the last committed state. Use
        // the live lookup when the caller provides it so ghosts track drags frame
        // by frame instead of snapping on mouse-up.
        Transform3d primary_xf;
        if (primary_live_xf) {
            if (auto live = primary_live_xf(obj_idx, inst_idx))
                primary_xf = *live;
            else
                primary_xf = mo->instances[inst_idx]->get_matrix();
        } else {
            primary_xf = mo->instances[inst_idx]->get_matrix();
        }
 
        const ImexRole role = role_for(head);
        const auto [pri_center, gantry] = resolve_centers(head);
        // Mirror axis follows the gantry row — see calc_imex_ghosts(). A cross-gantry mirror
        // reflects in Y and tracks primary's X, so drag no longer pushes it off-bed and the
        // old bake-the-flip-into-the-mesh workaround is unnecessary.
        const Transform3d head_xf = imex_head_transform(
            primary_phys, head, role, gantry, pri_center, mirror_axis_for(head));
        const Transform3d ghost_xf = head_xf * primary_xf;
        ghost->set_instance_transformation(ghost_xf);
    }
}

References Slic3r::Copy, ensure_imex_zones(), Slic3r::get_extents(), Slic3r::group_imex_active_tools_by_gantry(), Slic3r::ImexGantryGrouping::groups, Slic3r::imex_cfg_int(), imex_ghost_head_from_composite_id(), Slic3r::imex_head_transform(), Slic3r::imex_mirror_axis_for(), Slic3r::ModelObject::instances, m_imex_ghost_volumes, m_imex_head_zone_centers, m_model, m_plater, m_shape, Slic3r::parse_imex_active_tools(), and resolve_active_mode_tools().

Referenced by Slic3r::GUI::GLCanvas3D::_render_imex_ghosts().

Here is the call graph for this function:

Here is the caller graph for this function:

update_instance_exclude_status()

void Slic3r::GUI::PartPlate::update_instance_exclude_status	(	int	obj_id,
		int	instance_id,
		BoundingBoxf3 *	bounding_box = nullptr )

{
  bool outside;
  std::set<std::pair<int, int>>::iterator it;
 
  outside = check_outside(obj_id, instance_id, bounding_box);
    invalidate_exclusion_volume_preview();
 
  it = instance_outside_set.find(std::pair(obj_id, instance_id));
  if (it == instance_outside_set.end()) {
    if (outside)
      instance_outside_set.insert(std::pair(obj_id, instance_id));
  }
  else {
    if (!outside)
      instance_outside_set.erase(it);
  }
}

References Slic3r::bounding_box(), check_outside(), instance_outside_set, and invalidate_exclusion_volume_preview().

Referenced by Slic3r::GUI::PartPlateList::notify_instance_update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_object_index()

void Slic3r::GUI::PartPlate::update_object_index	(	int	obj_idx_removed,
		int	obj_idx_max )

{
  std::set<std::pair<int, int>> temp_set;
  std::set<std::pair<int, int>>::iterator it;
  //update the obj_to_instance_set
  for (it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it)
  {
    if (it->first >= obj_idx_removed)
      temp_set.insert(std::pair(it->first-1, it->second));
    else
      temp_set.insert(std::pair(it->first, it->second));
  }
  obj_to_instance_set.clear();
  obj_to_instance_set = temp_set;
    invalidate_exclusion_volume_preview();
 
  //update the instance_outside_set
  temp_set.clear();
  for (it = instance_outside_set.begin(); it != instance_outside_set.end(); ++it)
  {
    if (it->first >= obj_idx_removed)
      temp_set.insert(std::pair(it->first - 1, it->second));
    else
      temp_set.insert(std::pair(it->first, it->second));
  }
  instance_outside_set.clear();
  instance_outside_set = temp_set;
 
}

References instance_outside_set, invalidate_exclusion_volume_preview(), and obj_to_instance_set.

Referenced by Slic3r::GUI::PartPlateList::notify_instance_removed().

Here is the call graph for this function:

Here is the caller graph for this function:

update_render_colors()

void Slic3r::GUI::PartPlate::update_render_colors ( )

static

{
  PartPlate::SELECT_COLOR     = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Plate_Selected]);
    PartPlate::UNSELECT_COLOR   = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Plate_Unselected]);
    PartPlate::DEFAULT_COLOR        = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Plate_Default]);
    PartPlate::LINE_TOP_COLOR       = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Plate_Line_Top]);
    PartPlate::LINE_BOTTOM_COLOR    = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Plate_Line_Bottom]);
}

References Slic3r::RenderColor::colors, DEFAULT_COLOR, Slic3r::GUI::ImGuiWrapper::from_ImVec4(), LINE_BOTTOM_COLOR, LINE_TOP_COLOR, RenderCol_Plate_Default, RenderCol_Plate_Line_Bottom, RenderCol_Plate_Line_Top, RenderCol_Plate_Selected, RenderCol_Plate_Unselected, SELECT_COLOR, and UNSELECT_COLOR.

Referenced by Slic3r::GUI::GLCanvas3D::_render_style_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

update_slice_context()

void Slic3r::GUI::PartPlate::update_slice_context

(

BackgroundSlicingProcess &

process

)

{
  auto statuscb = [this](const Slic3r::PrintBase::SlicingStatus& status) {
    Slic3r::SlicingStatusEvent *event = new Slic3r::SlicingStatusEvent(EVT_SLICING_UPDATE, 0, status);
    //BBS: GUI refactor: add plate info befor message
    if (status.message_type == Slic3r::PrintStateBase::SlicingDefaultNotification) {
      // TRN Slicing progress. %1% is the plate number, %2% the current slicing step.
      event->status.text = Slic3r::format(_u8L("Slicing plate %1%: %2%"), m_plate_index + 1, event->status.text);
    }
    wxQueueEvent(m_plater, event);
  };
 
  process.set_fff_print(m_print);
  process.set_gcode_result(m_gcode_result);
  process.select_technology(this->printer_technology);
  process.set_current_plate(this);
  m_print->set_status_callback(statuscb);
  process.switch_print_preprocess();
 
  return;
}

References _u8L, Slic3r::format(), m_gcode_result, m_plate_index, m_plater, m_print, printer_technology, and Slic3r::PrintStateBase::SlicingDefaultNotification.

Referenced by Slic3r::GUI::PartPlateList::update_slice_context_to_current_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

update_slice_ready_status()

void Slic3r::GUI::PartPlate::update_slice_ready_status ( bool ready_slice )

inline

    {
        m_ready_for_slice = ready_slice;
    }

References m_ready_for_slice.

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene(), and Slic3r::GUI::Plater::validate_current_plate().

Here is the caller graph for this function:

update_slice_result_valid_state()

void Slic3r::GUI::PartPlate::update_slice_result_valid_state

(

bool

valid = false

)

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1% , update slice result from %2% to %3%") % m_plate_index %m_slice_result_valid %valid;
    const bool changed = (m_slice_result_valid != valid);
    m_slice_result_valid = valid;
    if (valid)
        m_slice_percent = 100.0f;
    else {
        m_slice_percent = -1.0f;
    }
    // This flips the plate's slice-ready / IMEX blocked-plate state without a geometry change,
    // so the plate-selector thumbnail/warning badge must be repainted explicitly. Upstream
    // replaced the old per-idle unconditional toolbar refresh with this dirty flag, so nothing
    // else repaints the naughty-plate icon otherwise.
    if (changed && m_plater)
        m_plater->mark_plate_toolbar_image_dirty();
}

References m_plate_index, m_plater, m_slice_percent, and m_slice_result_valid.

Referenced by Slic3r::GUI::Plater::apply_background_progress(), clear(), load_gcode_from_file(), Slic3r::GUI::PartPlateList::notify_instance_removed(), Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::GUI::Plater::priv::on_process_completed(), Slic3r::GUI::Plater::open_filament_map_setting_dialog(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), reset_imex_head_filament_map(), reset_imex_mode(), Slic3r::GUI::Plater::reslice(), Slic3r::CLI::run(), Slic3r::GUI::Plater::select_plate(), Slic3r::GUI::Plater::select_plate_by_hover_id(), set_bed_type(), set_imex_head_filament_map(), set_imex_mode(), set_print_seq(), and Slic3r::GUI::Plater::priv::update_background_process().

Here is the caller graph for this function:

update_slicing_percent()

void Slic3r::GUI::PartPlate::update_slicing_percent ( float percent )

inline

    {
        m_slice_percent = percent;
    }

References m_slice_percent.

Referenced by Slic3r::GUI::Plater::priv::on_slicing_update().

Here is the caller graph for this function:

update_states()

void Slic3r::GUI::PartPlate::update_states

(

)

{
  //currently let judge outside partplate when plate is empty
  /*if (obj_to_instance_set.size() == 0)
  {
    m_ready_for_slice = false;
    return;
  }*/
  m_ready_for_slice = true;
  for (std::set<std::pair<int, int>>::iterator it = obj_to_instance_set.begin(); it != obj_to_instance_set.end(); ++it) {
    int obj_id = it->first;
    int instance_id = it->second;
 
    //if (check_outside(obj_id, instance_id))
    if (instance_outside_set.find(std::pair(obj_id, instance_id)) != instance_outside_set.end())
    {
      m_ready_for_slice = false;
      //currently only check whether ready to slice
      break;
    }
  }
 
  BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": plate %1% , m_ready_for_slice changes to %2%") % m_plate_index %m_ready_for_slice;
  return;
}

References instance_outside_set, m_plate_index, m_ready_for_slice, and obj_to_instance_set.

Referenced by Slic3r::GUI::PartPlateList::notify_instance_update(), and remove_instance().

Here is the caller graph for this function:

valid_instance()

bool Slic3r::GUI::PartPlate::valid_instance ( int obj_id, int instance_id ) const

private

{
  if ((obj_id >= 0) && (obj_id < m_model->objects.size()))
  {
    ModelObject* object = m_model->objects[obj_id];
    if ((instance_id >= 0) && (instance_id < object->instances.size()))
      return true;
  }
 
  return false;
}

References m_model.

Referenced by add_instance(), duplicate_all_instance(), get_extruders_under_cli(), has_printable_instances(), imex_placement_violation(), intersect_instance(), is_all_instances_unprintable(), is_left_top_of(), printable_instance_size(), set_pos_and_size(), and wipe_tower_obstacles().

Here is the caller graph for this function:

wipe_tower_obstacles()

Polygons Slic3r::GUI::PartPlate::wipe_tower_obstacles ( const DynamicPrintConfig & config ) const

private

{
  Polygons obstacles;
  for (const auto &[obj_id, instance_id] : obj_to_instance_set) {
    if (!valid_instance(obj_id, instance_id))
      continue;
    const ModelObject   *object   = m_model->objects[obj_id];
    const ModelInstance *instance = object->instances[instance_id];
    if (!instance->printable)
      continue;
    // A sinking object counts its whole outline, the part below the bed included.
    Polygon hull = object->convex_hull_2d(instance->get_matrix());
    if (hull.size() < 3)
      continue;
    hull.translate(-scaled(m_origin.x()), -scaled(m_origin.y()));
    // An object's own setting wins over the print preset's.
    auto option_of = [&object, &config](const char *key) {
      const ConfigOption *opt = object->config.option(key);
      return opt != nullptr ? opt : config.option(key);
    };
    // An auto brim is only sized while slicing, so it is taken at the brim width option too.
    const ConfigOption *brim_type  = option_of("brim_type");
    const ConfigOption *brim_width = option_of("brim_width");
    const double brim = brim_type != nullptr && brim_width != nullptr && brim_type->getInt() != static_cast<int>(btNoBrim) ? brim_width->getFloat() : 0.;
    append(obstacles, offset(hull, static_cast<float>(scaled(brim + WIPE_TOWER_MARGIN))));
  }
  return obstacles;
}

References Slic3r::append(), Slic3r::btNoBrim, config(), Slic3r::ModelInstance::get_matrix(), Slic3r::ConfigOption::getFloat(), Slic3r::ConfigOption::getInt(), m_model, m_origin, obj_to_instance_set, Slic3r::offset(), Slic3r::option_of(), Slic3r::ModelInstance::printable, Slic3r::scaled(), Slic3r::MultiPoint::size(), Slic3r::MultiPoint::translate(), valid_instance(), and WIPE_TOWER_MARGIN.

Referenced by estimate_wipe_tower_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

cereal::access

friend class cereal::access

friend

References cereal::access.

Referenced by cereal::access.

PartPlateList

friend class PartPlateList

friend

References PartPlateList.

Referenced by PartPlate(), and PartPlateList.

UndoRedo::StackImpl

friend class UndoRedo::StackImpl

friend

Member Data Documentation

cali_bboxes_data

PlateBBoxData Slic3r::GUI::PartPlate::cali_bboxes_data

Referenced by load_pattern_box_data().

DEFAULT_COLOR

ColorRGBA Slic3r::GUI::PartPlate::DEFAULT_COLOR = { 0.5f, 0.5f, 0.5f, 1.0f }

static

Referenced by load_render_colors(), render_background(), and update_render_colors().

GRABBER_COUNT

unsigned int Slic3r::GUI::PartPlate::GRABBER_COUNT = 10

staticconstexpr

Referenced by Slic3r::GUI::GLCanvas3D::_picking_pass(), Slic3r::GUI::GLCanvas3D::_scene_cache_key(), Slic3r::GUI::GLCanvas3D::_update_inactive_plates_visibility(), Slic3r::GUI::MenuFactory::append_menu_item_plate_name(), Slic3r::GUI::SceneRaycaster::hit(), picking_id_component(), Slic3r::GUI::PartPlateList::render(), Slic3r::GUI::Plater::select_plate_by_hover_id(), and Slic3r::GUI::PartPlateList::set_hover_id().

HEIGHT_LIMIT_BOTTOM_COLOR

ColorRGBA Slic3r::GUI::PartPlate::HEIGHT_LIMIT_BOTTOM_COLOR = { 0.4f, 0.4f, 1.0f, 1.0f }

static

Referenced by render_height_limit().

HEIGHT_LIMIT_TOP_COLOR

ColorRGBA Slic3r::GUI::PartPlate::HEIGHT_LIMIT_TOP_COLOR = { 0.6f, 0.6f, 1.0f, 1.0f }

static

Referenced by render_height_limit().

IMEX_GHOST_COMPOSITE_ID_BASE

int Slic3r::GUI::PartPlate::IMEX_GHOST_COMPOSITE_ID_BASE = -100000

staticconstexpr

Referenced by imex_ghost_composite_id_for_head(), imex_ghost_head_from_composite_id(), and is_imex_ghost_composite_id().

IMEX_GHOST_MAX_HEADS

int Slic3r::GUI::PartPlate::IMEX_GHOST_MAX_HEADS = 256

staticconstexpr

Referenced by calc_imex_ghosts(), and is_imex_ghost_composite_id().

instance_outside_set

std::set<std::pair<int, int> > Slic3r::GUI::PartPlate::instance_outside_set

private

Referenced by add_instance(), clear(), contain_instance_totally(), has_printable_instances(), load(), print(), printable_instance_size(), remove_instance(), save(), update_instance_exclude_status(), update_object_index(), and update_states().

LINE_BOTTOM_COLOR

ColorRGBA Slic3r::GUI::PartPlate::LINE_BOTTOM_COLOR = { 0.8f, 0.8f, 0.8f, 0.4f }

static

Referenced by load_render_colors(), render_grid(), and update_render_colors().

LINE_TOP_COLOR

ColorRGBA Slic3r::GUI::PartPlate::LINE_TOP_COLOR = { 0.89f, 0.89f, 0.89f, 1.0f }

static

Referenced by load_render_colors(), render_grid(), and update_render_colors().

LINE_TOP_DARK_COLOR

ColorRGBA Slic3r::GUI::PartPlate::LINE_TOP_DARK_COLOR = { 0.431f, 0.431f, 0.463f, 1.0f }

static

Referenced by render_grid().

LINE_TOP_SEL_COLOR

ColorRGBA Slic3r::GUI::PartPlate::LINE_TOP_SEL_COLOR = { 0.5294f, 0.5451, 0.5333f, 1.0f}

static

Referenced by render_grid(), and Slic3r::GUI::Bed_2D::repaint().

LINE_TOP_SEL_DARK_COLOR

ColorRGBA Slic3r::GUI::PartPlate::LINE_TOP_SEL_DARK_COLOR = { 0.298f, 0.298f, 0.3333f, 1.0f}

static

Referenced by render_grid(), and Slic3r::GUI::Bed_2D::repaint().

m_active_exclusion_volume_prisms

GLModel Slic3r::GUI::PartPlate::m_active_exclusion_volume_prisms

private

Referenced by render_exclusion_volume_previews(), and update_exclusion_volume_preview_models().

m_apply_invalid

bool Slic3r::GUI::PartPlate::m_apply_invalid {false}

private

{false};

Referenced by can_slice(), is_apply_result_invalid(), load(), save(), and update_apply_result_invalid().

m_arrange_icon

PickingModel Slic3r::GUI::PartPlate::m_arrange_icon

private

Referenced by register_raycasters_for_picking(), render_icons(), and set_shape().

m_bounding_box

BoundingBoxf3 Slic3r::GUI::PartPlate::m_bounding_box

private

Referenced by calc_bounding_boxes(), contains(), contains(), contains(), get_bounding_box(), get_build_volume(), get_center_origin(), and intersects().

m_config

DynamicPrintConfig Slic3r::GUI::PartPlate::m_config

private

Referenced by clear_filament_map(), clear_filament_map_mode(), clear_filament_volume_map(), config(), get_bed_type(), get_filament_map_mode(), get_filament_maps(), get_filament_nozzle_maps(), get_filament_volume_maps(), get_first_layer_print_sequence(), get_imex_head_filament_map(), get_imex_mode(), get_other_layers_print_sequence(), get_print_seq(), get_spiral_vase_mode(), has_spiral_mode_config(), init(), load(), load_gcode_from_file(), on_extruder_count_changed(), on_filament_added(), on_filament_deleted(), reset_bed_type(), reset_imex_head_filament_map(), reset_imex_mode(), reset_skirt_start_angle(), save(), set_bed_type(), set_filament_count(), set_filament_map_mode(), set_filament_maps(), set_filament_nozzle_maps(), set_filament_volume_maps(), set_first_layer_print_sequence(), set_imex_head_filament_map(), set_imex_mode(), set_other_layers_print_sequence(), set_print_seq(), set_spiral_vase_mode(), update_first_layer_print_sequence(), and update_first_layer_print_sequence_when_delete_filament().

m_del_icon

PickingModel Slic3r::GUI::PartPlate::m_del_icon

private

Referenced by register_raycasters_for_picking(), render_icons(), and set_shape().

m_depth

int Slic3r::GUI::PartPlate::m_depth

private

Referenced by PartPlate(), calc_bounding_boxes(), estimate_wipe_tower_polygon(), get_size(), load(), print(), save(), and set_pos_and_size().

m_exclude_area

Pointfs Slic3r::GUI::PartPlate::m_exclude_area

private

Referenced by calc_bounding_boxes(), generate_exclude_polygon(), and set_shape().

m_exclude_bounding_box

std::vector<BoundingBoxf3> Slic3r::GUI::PartPlate::m_exclude_bounding_box

mutableprivate

Referenced by calc_bounding_boxes(), check_outside(), get_exclude_areas(), and Slic3r::GUI::PartPlateList::preprocess_exclude_areas().

m_exclude_triangles

GLModel Slic3r::GUI::PartPlate::m_exclude_triangles

private

Referenced by calc_exclude_triangles(), and render_exclude_area().

m_exclusion_volume_border_triangles

GLModel Slic3r::GUI::PartPlate::m_exclusion_volume_border_triangles

private

Referenced by render_exclusion_volume_previews(), and update_exclusion_volume_preview_models().

m_exclusion_volume_floor_triangles

GLModel Slic3r::GUI::PartPlate::m_exclusion_volume_floor_triangles

private

Referenced by render_exclusion_volume_previews(), and update_exclusion_volume_preview_models().

m_exclusion_volume_intersection_triangles

GLModel Slic3r::GUI::PartPlate::m_exclusion_volume_intersection_triangles

private

Referenced by clear_exclusion_volume_intersections(), render_exclusion_volume_intersections(), and update_exclusion_volume_preview_models().

m_exclusion_volume_intersections_cleared

bool Slic3r::GUI::PartPlate::m_exclusion_volume_intersections_cleared { false }

private

{ false };

Referenced by clear_exclusion_volume_intersections(), and update_exclusion_volume_preview_models().

m_exclusion_volume_preview_cache_key

std::string Slic3r::GUI::PartPlate::m_exclusion_volume_preview_cache_key

private

Referenced by update_exclusion_volume_preview_models().

m_exclusion_volume_preview_dirty

bool Slic3r::GUI::PartPlate::m_exclusion_volume_preview_dirty { true }

private

{ true };

Referenced by invalidate_exclusion_volume_preview(), and update_exclusion_volume_preview_models().

m_extended_bounding_box

BoundingBoxf3 Slic3r::GUI::PartPlate::m_extended_bounding_box

private

Referenced by calc_bounding_boxes(), and get_bounding_box().

m_extruder_areas

std::vector<Pointfs> Slic3r::GUI::PartPlate::m_extruder_areas

private

Referenced by check_outside(), get_build_volume(), get_extruder_areas(), get_shared_printable_polygon(), and set_shape().

m_extruder_exclusion_volume_borders

std::vector<std::pair<std::unique_ptr<GLModel>, ColorRGBA> > Slic3r::GUI::PartPlate::m_extruder_exclusion_volume_borders

private

Referenced by render_exclusion_volume_previews(), and update_exclusion_volume_preview_models().

m_extruder_heights

std::vector<double> Slic3r::GUI::PartPlate::m_extruder_heights

private

Referenced by check_outside(), get_extruder_heights(), and set_shape().

m_gcode_path_from_3mf

std::string Slic3r::GUI::PartPlate::m_gcode_path_from_3mf

private

m_gcode_result

GCodeProcessorResult* Slic3r::GUI::PartPlate::m_gcode_result

private

Referenced by get_gcode_filename(), get_print(), get_slice_result(), is_slice_result_ready_for_print(), is_valid_gcode_file(), load_gcode_from_file(), set_print(), and update_slice_context().

m_grabber_box

BoundingBoxf3 Slic3r::GUI::PartPlate::m_grabber_box

mutableprivate

Referenced by calc_bounding_boxes().

m_grabber_trans_matrix

Transform3d Slic3r::GUI::PartPlate::m_grabber_trans_matrix

private

m_gridlines

GLModel Slic3r::GUI::PartPlate::m_gridlines

private

Referenced by calc_gridlines(), and render_grid().

m_gridlines_bolder

GLModel Slic3r::GUI::PartPlate::m_gridlines_bolder

private

Referenced by calc_gridlines(), and render_grid().

m_height

double Slic3r::GUI::PartPlate::m_height

private

Referenced by PartPlate(), check_outside(), exclusion_volume_preview_cache_key(), get_build_volume(), load(), print(), save(), and set_pos_and_size().

m_height_limit_bottom

GLModel Slic3r::GUI::PartPlate::m_height_limit_bottom

private

Referenced by calc_height_limit(), and render_height_limit().

m_height_limit_common

GLModel Slic3r::GUI::PartPlate::m_height_limit_common

private

Referenced by calc_height_limit(), and render_height_limit().

m_height_limit_top

GLModel Slic3r::GUI::PartPlate::m_height_limit_top

private

Referenced by calc_height_limit(), and render_height_limit().

m_height_to_lid

float Slic3r::GUI::PartPlate::m_height_to_lid

private

Referenced by calc_height_limit(), and set_shape().

m_height_to_rod

float Slic3r::GUI::PartPlate::m_height_to_rod

private

Referenced by calc_height_limit(), and set_shape().

m_hover_id

int Slic3r::GUI::PartPlate::m_hover_id

private

Referenced by init(), and set_hover_id().

m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

Referenced by ObjectBase(), ObjectBase(), ObjectBase(), copy_id(), id(), serialize(), set_invalid_id(), and set_new_unique_id().

m_imex_collision_overlay

std::vector<GLModel> Slic3r::GUI::PartPlate::m_imex_collision_overlay

private

Referenced by calc_imex_zones(), and render_imex_zones().

m_imex_collision_zones

std::vector<BoundingBoxf3> Slic3r::GUI::PartPlate::m_imex_collision_zones

private

Referenced by calc_imex_zones(), check_outside(), imex_collision_zones(), imex_hull_violates(), and imex_placement_violation().

m_imex_copy_zones

std::vector<GLModel> Slic3r::GUI::PartPlate::m_imex_copy_zones

private

Referenced by calc_imex_zones(), and render_imex_zones().

m_imex_ghost_cache_key

std::string Slic3r::GUI::PartPlate::m_imex_ghost_cache_key { "\x01" }

private

{ "\x01" };  // sentinel = unbuilt

Referenced by ensure_imex_ghosts(), invalidate_imex_ghosts(), reset_imex_mode(), and set_imex_mode().

m_imex_ghost_volumes

std::vector<std::unique_ptr<GLVolume> > Slic3r::GUI::PartPlate::m_imex_ghost_volumes

private

Referenced by calc_imex_ghosts(), get_imex_ghost_volumes(), update_imex_ghost_colors(), and update_imex_ghost_transforms().

m_imex_head_zone_centers

std::map<int, Vec2d> Slic3r::GUI::PartPlate::m_imex_head_zone_centers

private

Referenced by calc_imex_ghosts(), calc_imex_zones(), and update_imex_ghost_transforms().

m_imex_margin_overlay

std::vector<GLModel> Slic3r::GUI::PartPlate::m_imex_margin_overlay

private

Referenced by calc_imex_zones(), and render_imex_zones().

m_imex_mirror_zones

std::vector<GLModel> Slic3r::GUI::PartPlate::m_imex_mirror_zones

private

Referenced by calc_imex_zones(), and render_imex_zones().

m_imex_mode_icon

PickingModel Slic3r::GUI::PartPlate::m_imex_mode_icon

private

Referenced by refresh_imex_icon(), register_raycasters_for_picking(), render_icons(), and set_shape().

m_imex_primary_head

int Slic3r::GUI::PartPlate::m_imex_primary_head { -1 }

private

{ -1 };                         // physical-head index of the primary tool in the active mode; -1 when no mode

Referenced by calc_imex_zones().

m_imex_primary_zone_box

std::optional<BoundingBoxf> Slic3r::GUI::PartPlate::m_imex_primary_zone_box

private

Referenced by calc_imex_zones(), and imex_primary_zone().

m_imex_secondary_zone_boxes

std::vector<BoundingBoxf3> Slic3r::GUI::PartPlate::m_imex_secondary_zone_boxes

private

Referenced by calc_imex_zones(), check_outside(), imex_hull_violates(), and imex_placement_violation().

m_imex_warn_icon

GLModel Slic3r::GUI::PartPlate::m_imex_warn_icon

private

Referenced by refresh_imex_icon(), render_icons(), and set_shape().

m_imex_zones_mode_cache

std::string Slic3r::GUI::PartPlate::m_imex_zones_mode_cache { "\x01" }

private

{ "\x01" }; // cached mode+topology key; sentinel = unbuilt

Referenced by ensure_imex_zones(), reset_imex_mode(), set_imex_mode(), and set_shape().

m_lock_icon

PickingModel Slic3r::GUI::PartPlate::m_lock_icon

private

Referenced by register_raycasters_for_picking(), render_icons(), and set_shape().

m_locked

bool Slic3r::GUI::PartPlate::m_locked

private

Referenced by init(), is_locked(), load(), lock(), print(), and save().

m_logo_triangles

GLModel Slic3r::GUI::PartPlate::m_logo_triangles

private

Referenced by render_logo(), and set_shape().

m_model

Model* Slic3r::GUI::PartPlate::m_model

private

Referenced by PartPlate(), PartPlate(), add_instance(), calc_imex_ghosts(), check_objects_empty_and_gcode3mf(), check_outside(), check_single_extruder_mixed_filament_risk(), contain_any_instance_totally(), contain_instance_totally(), duplicate_all_instance(), Slic3r::GUI::PartPlateList::duplicate_plate(), estimate_wipe_tower_footprint(), exclusion_volume_preview_cache_key(), get_extruders(), get_extruders_under_cli(), get_extruders_without_support(), get_instance(), get_objects(), get_objects_bounding_box(), get_objects_on_this_plate(), get_temp_config_3mf_path(), get_tmp_gcode_path(), has_printable_instances(), imex_placement_violation(), imex_wipe_tower_hull(), intersect_instance(), is_all_instances_unprintable(), is_left_top_of(), load_gcode_from_file(), max_broad_phase_intersecting_object_height(), printable_instance_size(), set_pos_and_size(), set_vase_mode_related_object_config(), translate_all_instance(), update_exclusion_volume_preview_models(), update_imex_ghost_transforms(), valid_instance(), and wipe_tower_obstacles().

m_move_front_icon

PickingModel Slic3r::GUI::PartPlate::m_move_front_icon

private

Referenced by register_raycasters_for_picking(), render_icons(), and set_shape().

m_name

std::string Slic3r::GUI::PartPlate::m_name

private

Referenced by generate_plate_name_texture(), get_plate_name(), load(), save(), and set_plate_name().

m_name_texture

GLTexture Slic3r::GUI::PartPlate::m_name_texture

private

Referenced by generate_plate_name_texture(), and render_plate_name_texture().

m_name_texture_height

wxCoord Slic3r::GUI::PartPlate::m_name_texture_height

private

m_name_texture_width

wxCoord Slic3r::GUI::PartPlate::m_name_texture_width

private

m_orient_icon

PickingModel Slic3r::GUI::PartPlate::m_orient_icon

private

Referenced by register_raycasters_for_picking(), render_icons(), and set_shape().

m_origin

Vec3d Slic3r::GUI::PartPlate::m_origin

private

Referenced by PartPlate(), calc_gridlines(), check_outside(), Slic3r::GUI::PartPlateList::duplicate_plate(), exclusion_volume_preview_cache_key(), get_build_volume(), get_center_origin(), get_origin(), get_plate_wrapping_detection_area(), imex_wipe_tower_hull(), is_left_top_of(), load(), print(), render_logo(), save(), set_pos_and_size(), set_print(), update_exclusion_volume_preview_models(), and wipe_tower_obstacles().

m_partplate_list

PartPlateList* Slic3r::GUI::PartPlate::m_partplate_list {nullptr }

private

{nullptr };

Referenced by PartPlate(), generate_plate_name_texture(), register_raycasters_for_picking(), render(), render_background(), render_grid(), render_icons(), render_logo(), render_only_numbers(), and set_hover_tooltip().

m_plate_filament_map_icon

PickingModel Slic3r::GUI::PartPlate::m_plate_filament_map_icon

private

Referenced by register_raycasters_for_picking(), render_icons(), and set_shape().

m_plate_idx_icon

GLModel Slic3r::GUI::PartPlate::m_plate_idx_icon

private

Referenced by render_icons(), render_only_numbers(), and set_shape().

m_plate_index

int Slic3r::GUI::PartPlate::m_plate_index

private

Referenced by add_instance(), duplicate_all_instance(), get_extruders(), get_extruders_under_cli(), get_extruders_without_support(), get_index(), imex_wipe_tower_hull(), intersect_instance(), is_left_top_of(), load(), operator<(), picking_id_component(), print(), remove_instance(), render_icons(), render_only_numbers(), save(), set_index(), set_plate_name(), set_pos_and_size(), update_slice_context(), update_slice_result_valid_state(), and update_states().

m_plate_name_edit_icon

PickingModel Slic3r::GUI::PartPlate::m_plate_name_edit_icon

private

Referenced by generate_plate_name_texture(), invalidate_plate_name_texture(), register_raycasters_for_picking(), render_icons(), and render_plate_name_texture().

m_plate_name_icon

GLModel Slic3r::GUI::PartPlate::m_plate_name_icon

private

Referenced by generate_plate_name_texture(), and render_plate_name_texture().

m_plate_settings_icon

PickingModel Slic3r::GUI::PartPlate::m_plate_settings_icon

private

Referenced by register_raycasters_for_picking(), render_icons(), and set_shape().

m_plater

Plater* Slic3r::GUI::PartPlate::m_plater

private

Referenced by PartPlate(), PartPlate(), add_instance(), belt_open_y(), build_imex_cache_key(), calc_imex_ghosts(), calc_vertex_for_icons(), check_outside(), ensure_imex_zones(), generate_logo_polygon(), get_bed_type(), get_effective_imex_mode(), imex_wipe_tower_hull(), invalidate_plate_name_texture(), refresh_imex_icon(), set_bed_type(), set_plate_name(), set_pos_and_size(), set_print_seq(), set_shape(), update_exclusion_volume_preview_models(), update_imex_ghost_colors(), update_imex_ghost_transforms(), update_slice_context(), and update_slice_result_valid_state().

m_print

Print* Slic3r::GUI::PartPlate::m_print

private

Referenced by fff_print(), get_print(), imex_wipe_tower_hull(), init(), load_gcode_from_file(), print(), render_height_limit(), set_index(), set_plate_name(), set_pos_and_size(), set_print(), and update_slice_context().

m_print_index

int Slic3r::GUI::PartPlate::m_print_index

private

Referenced by Slic3r::GUI::PartPlateList::find_plate_by_print_index(), get_print(), init(), load(), print(), save(), and set_print().

m_print_polygon

ExPolygon Slic3r::GUI::PartPlate::m_print_polygon

private

Referenced by render(), and set_shape().

m_printable

bool Slic3r::GUI::PartPlate::m_printable

private

Referenced by PartPlate(), intersect_instance(), is_printable(), load(), print(), and save().

m_quadric

GLUquadricObject* Slic3r::GUI::PartPlate::m_quadric

private

Referenced by PartPlate().

m_ready_for_slice

bool Slic3r::GUI::PartPlate::m_ready_for_slice

private

Referenced by add_instance(), can_slice(), clear(), init(), load(), load_gcode_from_file(), print(), remove_instance(), save(), update_slice_ready_status(), and update_states().

m_scale_factor

float Slic3r::GUI::PartPlate::m_scale_factor { 1.0f }

private

{ 1.0f };

Referenced by render_exclusion_volume_previews(), render_grid(), and render_height_limit().

m_selected

bool Slic3r::GUI::PartPlate::m_selected

private

Referenced by init(), load(), render(), render_background(), render_exclude_area(), render_exclusion_volume_previews(), render_grid(), save(), set_selected(), and set_unselected().

m_shape

Pointfs Slic3r::GUI::PartPlate::m_shape

private

Referenced by calc_bounding_boxes(), calc_height_limit(), calc_imex_ghosts(), calc_imex_zones(), calc_vertex_for_icons(), calc_vertex_for_imex_warn_badge(), calc_vertex_for_number(), calc_vertex_for_plate_name_edit_icon(), generate_logo_polygon(), generate_plate_name_texture(), generate_print_polygon(), get_bounding_box_crd(), get_shape(), get_shared_printable_polygon(), icon_scale_factor(), set_shape(), and update_imex_ghost_transforms().

m_slice_percent

float Slic3r::GUI::PartPlate::m_slice_percent

private

Referenced by get_slicing_percent(), init(), update_slice_result_valid_state(), and update_slicing_percent().

m_slice_result_valid

bool Slic3r::GUI::PartPlate::m_slice_result_valid

private

Referenced by init(), is_slice_result_ready_for_print(), is_slice_result_valid(), load(), print(), save(), and update_slice_result_valid_state().

m_temp_config_3mf_path

std::string Slic3r::GUI::PartPlate::m_temp_config_3mf_path

private

Referenced by get_temp_config_3mf_path().

m_texture

GLTexture Slic3r::GUI::PartPlate::m_texture

private

m_timelapse_warning_code

int Slic3r::GUI::PartPlate::m_timelapse_warning_code = 0

private

Referenced by set_timelapse_warning_code(), and timelapse_warning_code().

m_tmp_gcode_path

std::string Slic3r::GUI::PartPlate::m_tmp_gcode_path

private

Referenced by get_tmp_gcode_path(), load(), load_gcode_from_file(), print(), save(), and set_tmp_gcode_path().

m_triangles

PickingModel Slic3r::GUI::PartPlate::m_triangles

private

Referenced by calc_triangles(), register_raycasters_for_picking(), render_background(), and set_shape().

m_width

int Slic3r::GUI::PartPlate::m_width

private

Referenced by PartPlate(), estimate_wipe_tower_polygon(), get_size(), load(), print(), save(), and set_pos_and_size().

m_wrapping_detection_triangles

GLModel Slic3r::GUI::PartPlate::m_wrapping_detection_triangles

private

Referenced by render(), render_wrapping_detection_area(), and set_shape().

no_light_thumbnail_data

ThumbnailData Slic3r::GUI::PartPlate::no_light_thumbnail_data

Referenced by Slic3r::GUI::Plater::invalid_all_plate_thumbnails(), Slic3r::GUI::PartPlateList::notify_instance_removed(), Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::CLI::run(), and Slic3r::GUI::Plater::update_plate_thumbnails().

obj_preview_thumbnail_data

ThumbnailData Slic3r::GUI::PartPlate::obj_preview_thumbnail_data

Referenced by Slic3r::GUI::Plater::update_obj_preview_thumbnail().

obj_to_instance_set

std::set<std::pair<int, int> > Slic3r::GUI::PartPlate::obj_to_instance_set

private

Referenced by add_instance(), build_imex_ghost_cache_key(), calc_imex_ghosts(), clear(), contain_instance(), contain_instance_totally(), duplicate_all_instance(), Slic3r::GUI::PartPlateList::duplicate_plate(), empty(), exclusion_volume_preview_cache_key(), get_extruders_under_cli(), get_objects_bounding_box(), get_objects_on_this_plate(), has_printable_instances(), imex_placement_violation(), imex_wipe_tower_hull(), is_all_instances_unprintable(), load(), max_broad_phase_intersecting_object_height(), move_instances_to(), print(), printable_instance_size(), remove_instance(), save(), set_pos_and_size(), translate_all_instance(), update_exclusion_volume_preview_models(), update_object_index(), update_states(), and wipe_tower_obstacles().

pick_thumbnail_data

ThumbnailData Slic3r::GUI::PartPlate::pick_thumbnail_data

Referenced by Slic3r::GUI::PartPlateList::notify_instance_removed(), Slic3r::GUI::PartPlateList::notify_instance_update(), and Slic3r::CLI::run().

PLATE_FILAMENT_MAP_ID

unsigned int Slic3r::GUI::PartPlate::PLATE_FILAMENT_MAP_ID = 8

staticconstexpr

Referenced by register_raycasters_for_picking(), render_icons(), and Slic3r::GUI::Plater::select_plate_by_hover_id().

PLATE_IMEX_MODE_ID

unsigned int Slic3r::GUI::PartPlate::PLATE_IMEX_MODE_ID = 9

staticconstexpr

Referenced by refresh_imex_icon(), register_raycasters_for_picking(), render_icons(), and Slic3r::GUI::Plater::select_plate_by_hover_id().

PLATE_NAME_HOVER_ID

unsigned int Slic3r::GUI::PartPlate::PLATE_NAME_HOVER_ID = 6

staticconstexpr

Referenced by Slic3r::GUI::Plater::select_plate_by_hover_id().

plate_thumbnail_height

const int Slic3r::GUI::PartPlate::plate_thumbnail_height = 512

static

Referenced by Slic3r::GUI::Plater::update_obj_preview_thumbnail(), and Slic3r::GUI::Plater::update_plate_thumbnails().

plate_thumbnail_width

const int Slic3r::GUI::PartPlate::plate_thumbnail_width = 512

static

Referenced by Slic3r::GUI::Plater::update_obj_preview_thumbnail(), and Slic3r::GUI::Plater::update_plate_thumbnails().

position

Slic3r::Geometry::Transformation Slic3r::GUI::PartPlate::position

private

Referenced by set_shape(), and translate_all_instance().

positions

std::vector<Vec3f> Slic3r::GUI::PartPlate::positions

private

printer_technology

PrinterTechnology Slic3r::GUI::PartPlate::printer_technology

private

Referenced by PartPlate(), get_print(), set_print(), and update_slice_context().

s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by generate_new_id().

SELECT_COLOR

ColorRGBA Slic3r::GUI::PartPlate::SELECT_COLOR = { 0.2666f, 0.2784f, 0.2784f, 1.0f }

static

Referenced by load_render_colors(), render_background(), and update_render_colors().

slice_filaments_info

std::vector<FilamentInfo> Slic3r::GUI::PartPlate::slice_filaments_info

private

Referenced by check_objects_empty_and_gcode3mf(), get_extruders(), and get_slice_filaments_info().

thumbnail_data

ThumbnailData Slic3r::GUI::PartPlate::thumbnail_data

Referenced by Slic3r::GUI::GLCanvas3D::_render_plate_switcher(), Slic3r::GUI::Plater::invalid_all_plate_thumbnails(), Slic3r::GUI::PartPlateList::notify_instance_removed(), Slic3r::GUI::PartPlateList::notify_instance_update(), and Slic3r::GUI::Plater::update_plate_thumbnails().

top_thumbnail_data

ThumbnailData Slic3r::GUI::PartPlate::top_thumbnail_data

Referenced by Slic3r::GUI::PartPlateList::notify_instance_removed(), Slic3r::GUI::PartPlateList::notify_instance_update(), and Slic3r::CLI::run().

UNSELECT_COLOR

ColorRGBA Slic3r::GUI::PartPlate::UNSELECT_COLOR = { 0.82f, 0.82f, 0.82f, 1.0f }

static

Referenced by load_render_colors(), render_background(), and update_render_colors().

UNSELECT_DARK_COLOR

ColorRGBA Slic3r::GUI::PartPlate::UNSELECT_DARK_COLOR = { 0.384f, 0.384f, 0.412f, 1.0f }

static

Referenced by render_background().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PartPlate.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PartPlate.cpp