Merge branch 'xs-model'
This commit is contained in:
Alessandro Ranellucci
commit
38ea5f79d7
@ -62,7 +62,7 @@ our $Options = {
|
||||
# printer options
|
||||
'print_center' => {
|
||||
label => 'Print center',
|
||||
tooltip => 'Enter the G-code coordinates of the point you want to center your print around.',
|
||||
tooltip => 'These G-code coordinates are used to center your plater viewport.',
|
||||
sidetext => 'mm',
|
||||
cli => 'print-center=s',
|
||||
type => 'point',
|
||||
|
||||
@ -6,7 +6,7 @@ use Slic3r::Geometry qw(X Y unscale);
|
||||
|
||||
has 'print' => (is => 'ro', required => 1, handles => [qw(extruders)]);
|
||||
has 'gcodegen' => (is => 'ro', required => 1);
|
||||
has 'shift' => (is => 'ro', required => 1);
|
||||
has 'shift' => (is => 'ro', default => sub { [0,0] });
|
||||
|
||||
has 'spiralvase' => (is => 'lazy');
|
||||
has 'vibration_limit' => (is => 'lazy');
|
||||
|
||||
@ -54,6 +54,7 @@ our $Settings = {
|
||||
_ => {
|
||||
mode => 'simple',
|
||||
version_check => 1,
|
||||
autocenter => 1,
|
||||
},
|
||||
};
|
||||
|
||||
@ -88,6 +89,7 @@ sub OnInit {
|
||||
$Settings = $ini if $ini;
|
||||
$last_version = $Settings->{_}{version};
|
||||
$Settings->{_}{mode} ||= 'expert';
|
||||
$Settings->{_}{autocenter} //= 1;
|
||||
}
|
||||
$Settings->{_}{version} = $Slic3r::VERSION;
|
||||
Slic3r::GUI->save_settings;
|
||||
|
||||
@ -49,6 +49,7 @@ sub new {
|
||||
bed_size print_center complete_objects extruder_clearance_radius skirts skirt_distance
|
||||
));
|
||||
$self->{model} = Slic3r::Model->new;
|
||||
$self->{print} = Slic3r::Print->new;
|
||||
$self->{objects} = [];
|
||||
|
||||
$self->{canvas} = Wx::Panel->new($self, -1, wxDefaultPosition, CANVAS_SIZE, wxTAB_TRAVERSAL);
|
||||
@ -222,7 +223,7 @@ sub new {
|
||||
});
|
||||
|
||||
$self->_update_bed_size;
|
||||
$self->recenter;
|
||||
$self->update;
|
||||
|
||||
{
|
||||
my $presets;
|
||||
@ -408,7 +409,14 @@ sub load_model_object {
|
||||
|
||||
# add a default instance and center object around origin
|
||||
$o->center_around_origin;
|
||||
$o->add_instance(offset => [30,30]);
|
||||
$o->add_instance(offset => [ @{$self->{config}->print_center} ]);
|
||||
}
|
||||
|
||||
$self->{print}->add_model_object($o);
|
||||
|
||||
# if user turned autocentering off, automatic arranging would disappoint them
|
||||
if (!$Slic3r::GUI::Settings->{_}{autocenter}) {
|
||||
$need_arrange = 0;
|
||||
}
|
||||
|
||||
$self->object_loaded($#{ $self->{objects} }, no_arrange => !$need_arrange);
|
||||
@ -429,7 +437,7 @@ sub object_loaded {
|
||||
|
||||
$self->make_thumbnail($obj_idx);
|
||||
$self->arrange unless $params{no_arrange};
|
||||
$self->recenter;
|
||||
$self->update;
|
||||
$self->{list}->Update;
|
||||
$self->{list}->Select($obj_idx, 1);
|
||||
$self->object_list_changed;
|
||||
@ -446,11 +454,12 @@ sub remove {
|
||||
|
||||
splice @{$self->{objects}}, $obj_idx, 1;
|
||||
$self->{model}->delete_object($obj_idx);
|
||||
$self->{print}->delete_object($obj_idx);
|
||||
$self->{list}->DeleteItem($obj_idx);
|
||||
$self->object_list_changed;
|
||||
|
||||
$self->select_object(undef);
|
||||
$self->recenter;
|
||||
$self->update;
|
||||
$self->{canvas}->Refresh;
|
||||
}
|
||||
|
||||
@ -459,6 +468,7 @@ sub reset {
|
||||
|
||||
@{$self->{objects}} = ();
|
||||
$self->{model}->delete_all_objects;
|
||||
$self->{print}->delete_all_objects;
|
||||
$self->{list}->DeleteAllItems;
|
||||
$self->object_list_changed;
|
||||
|
||||
@ -472,13 +482,20 @@ sub increase {
|
||||
my ($obj_idx, $object) = $self->selected_object;
|
||||
my $model_object = $self->{model}->objects->[$obj_idx];
|
||||
my $last_instance = $model_object->instances->[-1];
|
||||
$model_object->add_instance(
|
||||
my $i = $model_object->add_instance(
|
||||
offset => [ map 10+$_, @{$last_instance->offset} ],
|
||||
scaling_factor => $last_instance->scaling_factor,
|
||||
rotation => $last_instance->rotation,
|
||||
);
|
||||
$self->{print}->objects->[$obj_idx]->add_copy(@{$i->offset});
|
||||
$self->{list}->SetItem($obj_idx, 1, $model_object->instances_count);
|
||||
|
||||
# only autoarrange if user has autocentering enabled
|
||||
if ($Slic3r::GUI::Settings->{_}{autocenter}) {
|
||||
$self->arrange;
|
||||
} else {
|
||||
$self->{canvas}->Refresh;
|
||||
}
|
||||
}
|
||||
|
||||
sub decrease {
|
||||
@ -488,6 +505,7 @@ sub decrease {
|
||||
my $model_object = $self->{model}->objects->[$obj_idx];
|
||||
if ($model_object->instances_count >= 2) {
|
||||
$model_object->delete_last_instance;
|
||||
$self->{print}->objects->[$obj_idx]->delete_last_copy;
|
||||
$self->{list}->SetItem($obj_idx, 1, $model_object->instances_count);
|
||||
} else {
|
||||
$self->remove;
|
||||
@ -497,7 +515,7 @@ sub decrease {
|
||||
$self->{list}->Select($obj_idx, 0);
|
||||
$self->{list}->Select($obj_idx, 1);
|
||||
}
|
||||
$self->recenter;
|
||||
$self->update;
|
||||
$self->{canvas}->Refresh;
|
||||
}
|
||||
|
||||
@ -522,10 +540,15 @@ sub rotate {
|
||||
my $new_angle = $model_instance->rotation + $angle;
|
||||
$_->rotation($new_angle) for @{ $model_object->instances };
|
||||
$model_object->update_bounding_box;
|
||||
|
||||
# update print
|
||||
$self->{print}->delete_object($obj_idx);
|
||||
$self->{print}->add_model_object($model_object, $obj_idx);
|
||||
|
||||
$object->transform_thumbnail($self->{model}, $obj_idx);
|
||||
}
|
||||
$self->selection_changed; # refresh info (size etc.)
|
||||
$self->recenter;
|
||||
$self->update;
|
||||
$self->{canvas}->Refresh;
|
||||
}
|
||||
|
||||
@ -553,10 +576,16 @@ sub changescale {
|
||||
}
|
||||
$_->scaling_factor($scale) for @{ $model_object->instances };
|
||||
$model_object->update_bounding_box;
|
||||
|
||||
# update print
|
||||
$self->{print}->delete_object($obj_idx);
|
||||
$self->{print}->add_model_object($model_object, $obj_idx);
|
||||
|
||||
$object->transform_thumbnail($self->{model}, $obj_idx);
|
||||
}
|
||||
$self->selection_changed(1); # refresh info (size, volume etc.)
|
||||
$self->arrange;
|
||||
$self->update;
|
||||
$self->{canvas}->Refresh;
|
||||
}
|
||||
|
||||
sub arrange {
|
||||
@ -567,7 +596,7 @@ sub arrange {
|
||||
};
|
||||
# ignore arrange warnings on purpose
|
||||
|
||||
$self->recenter;
|
||||
$self->update(1);
|
||||
$self->{canvas}->Refresh;
|
||||
}
|
||||
|
||||
@ -715,57 +744,45 @@ sub export_gcode2 {
|
||||
threads->exit();
|
||||
} if $Slic3r::have_threads;
|
||||
|
||||
my $print = Slic3r::Print->new(
|
||||
config => $config,
|
||||
extra_variables => $extra_variables,
|
||||
);
|
||||
my $print = $self->{print};
|
||||
$print->apply_config($config);
|
||||
$print->apply_extra_variables($extra_variables);
|
||||
|
||||
eval {
|
||||
$print->config->validate;
|
||||
$print->add_model_object($_) for @{ $self->{model}->objects };
|
||||
$print->validate;
|
||||
|
||||
{
|
||||
my @warnings = ();
|
||||
local $SIG{__WARN__} = sub { push @warnings, $_[0] };
|
||||
|
||||
my %params = (
|
||||
output_file => $output_file,
|
||||
status_cb => sub { $params{progressbar}->(@_) },
|
||||
quiet => 1,
|
||||
);
|
||||
$print->status_cb(sub { $params{progressbar}->(@_) });
|
||||
if ($params{export_svg}) {
|
||||
$print->export_svg(%params);
|
||||
$print->export_svg(output_file => $output_file);
|
||||
} else {
|
||||
$print->export_gcode(%params);
|
||||
$print->process;
|
||||
$print->export_gcode(output_file => $output_file);
|
||||
}
|
||||
$print->status_cb(undef);
|
||||
Slic3r::GUI::warning_catcher($self, $Slic3r::have_threads ? sub {
|
||||
Wx::PostEvent($self, Wx::PlThreadEvent->new(-1, $MESSAGE_DIALOG_EVENT, shared_clone([@_])));
|
||||
} : undef)->($_) for @warnings;
|
||||
}
|
||||
|
||||
my $message = "Your files were successfully sliced";
|
||||
if ($print->processing_time) {
|
||||
$message .= ' in';
|
||||
my $minutes = int($print->processing_time/60);
|
||||
$message .= sprintf " %d minutes and", $minutes if $minutes;
|
||||
$message .= sprintf " %.1f seconds", $print->processing_time - $minutes*60;
|
||||
}
|
||||
$message .= ".";
|
||||
$params{on_completed}->($message);
|
||||
$params{on_completed}->();
|
||||
};
|
||||
$params{catch_error}->();
|
||||
}
|
||||
|
||||
sub on_export_completed {
|
||||
my $self = shift;
|
||||
my ($message) = @_;
|
||||
|
||||
$self->{export_thread}->detach if $self->{export_thread};
|
||||
$self->{export_thread} = undef;
|
||||
$self->statusbar->SetCancelCallback(undef);
|
||||
$self->statusbar->StopBusy;
|
||||
$self->statusbar->SetStatusText("G-code file exported to $self->{output_file}");
|
||||
my $message = "G-code file exported to $self->{output_file}";
|
||||
$self->statusbar->SetStatusText($message);
|
||||
&Wx::wxTheApp->notify($message);
|
||||
}
|
||||
|
||||
@ -844,7 +861,7 @@ sub on_thumbnail_made {
|
||||
my ($obj_idx) = @_;
|
||||
|
||||
$self->{objects}[$obj_idx]->transform_thumbnail($self->{model}, $obj_idx);
|
||||
$self->recenter;
|
||||
$self->update;
|
||||
$self->{canvas}->Refresh;
|
||||
}
|
||||
|
||||
@ -856,26 +873,23 @@ sub clean_instance_thumbnails {
|
||||
}
|
||||
}
|
||||
|
||||
# this method gets called whenever bed is resized or the objects' bounding box changes
|
||||
# this method gets called whenever print center is changed or the objects' bounding box changes
|
||||
# (i.e. when an object is added/removed/moved/rotated/scaled)
|
||||
sub recenter {
|
||||
my $self = shift;
|
||||
sub update {
|
||||
my ($self, $force_autocenter) = @_;
|
||||
|
||||
return unless @{$self->{objects}};
|
||||
if ($Slic3r::GUI::Settings->{_}{autocenter} || $force_autocenter) {
|
||||
$self->{model}->center_instances_around_point($self->{config}->print_center);
|
||||
}
|
||||
|
||||
# get model bounding box in pixels
|
||||
my $print_bb = $self->{model}->bounding_box;
|
||||
$print_bb->scale($self->{scaling_factor});
|
||||
# sync model and print object instances
|
||||
for my $obj_idx (0..$#{$self->{objects}}) {
|
||||
my $model_object = $self->{model}->objects->[$obj_idx];
|
||||
my $print_object = $self->{print}->objects->[$obj_idx];
|
||||
|
||||
# get model size in pixels
|
||||
my $print_size = $print_bb->size;
|
||||
|
||||
# $self->{shift} contains the offset in pixels to add to object thumbnails
|
||||
# in order to center them
|
||||
$self->{shift} = [
|
||||
-$print_bb->x_min + ($self->{canvas}->GetSize->GetWidth - $print_size->[X]) / 2,
|
||||
-$print_bb->y_min + ($self->{canvas}->GetSize->GetHeight - $print_size->[Y]) / 2,
|
||||
];
|
||||
$print_object->delete_all_copies;
|
||||
$print_object->add_copy(@{$_->offset}) for @{$model_object->instances};
|
||||
}
|
||||
}
|
||||
|
||||
sub on_config_change {
|
||||
@ -901,6 +915,7 @@ sub on_config_change {
|
||||
} elsif ($self->{config}->has($opt_key)) {
|
||||
$self->{config}->set($opt_key, $value);
|
||||
$self->_update_bed_size if $opt_key eq 'bed_size';
|
||||
$self->update if $opt_key eq 'print_center';
|
||||
}
|
||||
}
|
||||
|
||||
@ -912,7 +927,7 @@ sub _update_bed_size {
|
||||
# when the canvas is not rendered yet, its GetSize() method returns 0,0
|
||||
# scaling_factor is expressed in pixel / mm
|
||||
$self->{scaling_factor} = CANVAS_SIZE->[X] / max(@{ $self->{config}->bed_size });
|
||||
$self->recenter;
|
||||
$self->update;
|
||||
}
|
||||
|
||||
# this is called on the canvas
|
||||
@ -970,10 +985,8 @@ sub repaint {
|
||||
my $instance = $model_object->instances->[$instance_idx];
|
||||
next if !defined $object->transformed_thumbnail;
|
||||
|
||||
my $thumbnail = $object->transformed_thumbnail->clone; # in scaled coordinates
|
||||
$thumbnail->scale(&Slic3r::SCALING_FACTOR * $parent->{scaling_factor}); # in unscaled pixels
|
||||
$thumbnail->translate(map $_ * $parent->{scaling_factor}, @{$instance->offset});
|
||||
$thumbnail->translate(@{$parent->{shift}});
|
||||
my $thumbnail = $object->transformed_thumbnail->clone; # in scaled model coordinates
|
||||
$thumbnail->translate(map scale($_), @{$instance->offset});
|
||||
|
||||
$object->instance_thumbnails->[$instance_idx] = $thumbnail;
|
||||
|
||||
@ -986,7 +999,7 @@ sub repaint {
|
||||
}
|
||||
foreach my $expolygon (@$thumbnail) {
|
||||
my $points = $expolygon->contour->pp;
|
||||
$dc->DrawPolygon($parent->_y($points), 0, 0);
|
||||
$dc->DrawPolygon($parent->points_to_pixel($points, 1), 0, 0);
|
||||
}
|
||||
|
||||
if (0) {
|
||||
@ -994,7 +1007,6 @@ sub repaint {
|
||||
my $bb = $model_object->instance_bounding_box($instance_idx);
|
||||
$bb->scale($parent->{scaling_factor});
|
||||
# no need to translate by instance offset because instance_bounding_box() does that
|
||||
$bb->translate(@{$parent->{shift}}, 0);
|
||||
my $points = $bb->polygon->pp;
|
||||
$dc->SetPen($parent->{clearance_pen});
|
||||
$dc->SetBrush($parent->{transparent_brush});
|
||||
@ -1003,10 +1015,10 @@ sub repaint {
|
||||
|
||||
# if sequential printing is enabled and we have more than one object, draw clearance area
|
||||
if ($parent->{config}->complete_objects && (map @{$_->instances}, @{$parent->{model}->objects}) > 1) {
|
||||
my ($clearance) = @{offset([$thumbnail->convex_hull], ($parent->{config}->extruder_clearance_radius / 2) * $parent->{scaling_factor}, 100, JT_ROUND)};
|
||||
my ($clearance) = @{offset([$thumbnail->convex_hull], (scale($parent->{config}->extruder_clearance_radius) / 2), 1, JT_ROUND, scale(0.1))};
|
||||
$dc->SetPen($parent->{clearance_pen});
|
||||
$dc->SetBrush($parent->{transparent_brush});
|
||||
$dc->DrawPolygon($parent->_y($clearance), 0, 0);
|
||||
$dc->DrawPolygon($parent->points_to_pixel($clearance, 1), 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1015,10 +1027,11 @@ sub repaint {
|
||||
if (@{$parent->{objects}} && $parent->{config}->skirts) {
|
||||
my @points = map @{$_->contour}, map @$_, map @{$_->instance_thumbnails}, @{$parent->{objects}};
|
||||
if (@points >= 3) {
|
||||
my ($convex_hull) = @{offset([convex_hull(\@points)], $parent->{config}->skirt_distance * $parent->{scaling_factor}, 100, JT_ROUND)};
|
||||
my @o = @{Slic3r::Geometry::Clipper::simplify_polygons([convex_hull(\@points)])};
|
||||
my ($convex_hull) = @{offset([convex_hull(\@points)], scale($parent->{config}->skirt_distance), 1, JT_ROUND, scale(0.1))};
|
||||
$dc->SetPen($parent->{skirt_pen});
|
||||
$dc->SetBrush($parent->{transparent_brush});
|
||||
$dc->DrawPolygon($parent->_y($convex_hull), 0, 0);
|
||||
$dc->DrawPolygon($parent->points_to_pixel($convex_hull, 1), 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1030,7 +1043,8 @@ sub mouse_event {
|
||||
my $parent = $self->GetParent;
|
||||
|
||||
my $point = $event->GetPosition;
|
||||
my $pos = Slic3r::Point->new(@{$parent->_y([[$point->x, $point->y]])->[0]}); # in pixels
|
||||
my $pos = $parent->point_to_model_units([ $point->x, $point->y ]); #]]
|
||||
$pos = Slic3r::Point->new_scale(@$pos);
|
||||
if ($event->ButtonDown(&Wx::wxMOUSE_BTN_LEFT)) {
|
||||
$parent->select_object(undef);
|
||||
for my $obj_idx (0 .. $#{$parent->{objects}}) {
|
||||
@ -1040,9 +1054,10 @@ sub mouse_event {
|
||||
if ($thumbnail->contains_point($pos)) {
|
||||
$parent->select_object($obj_idx);
|
||||
my $instance = $parent->{model}->objects->[$obj_idx]->instances->[$instance_idx];
|
||||
$self->{drag_start_pos} = [ # displacement between the click and the instance origin
|
||||
$pos->x - $parent->{shift}[X] - ($instance->offset->[X] * $parent->{scaling_factor}),
|
||||
$pos->y - $parent->{shift}[Y] - ($instance->offset->[Y] * $parent->{scaling_factor}),
|
||||
my $instance_origin = [ map scale($_), @{$instance->offset} ];
|
||||
$self->{drag_start_pos} = [ # displacement between the click and the instance origin in scaled model units
|
||||
$pos->x - $instance_origin->[X],
|
||||
$pos->y - $instance_origin->[Y], #-
|
||||
];
|
||||
$self->{drag_object} = [ $obj_idx, $instance_idx ];
|
||||
}
|
||||
@ -1050,7 +1065,7 @@ sub mouse_event {
|
||||
}
|
||||
$parent->Refresh;
|
||||
} elsif ($event->ButtonUp(&Wx::wxMOUSE_BTN_LEFT)) {
|
||||
$parent->recenter;
|
||||
$parent->update;
|
||||
$parent->Refresh;
|
||||
$self->{drag_start_pos} = undef;
|
||||
$self->{drag_object} = undef;
|
||||
@ -1062,8 +1077,8 @@ sub mouse_event {
|
||||
my ($obj_idx, $instance_idx) = @{ $self->{drag_object} };
|
||||
my $model_object = $parent->{model}->objects->[$obj_idx];
|
||||
$model_object->instances->[$instance_idx]->offset([
|
||||
($pos->[X] - $self->{drag_start_pos}[X] - $parent->{shift}[X]) / $parent->{scaling_factor},
|
||||
($pos->[Y] - $self->{drag_start_pos}[Y] - $parent->{shift}[Y]) / $parent->{scaling_factor},
|
||||
unscale($pos->[X] - $self->{drag_start_pos}[X]),
|
||||
unscale($pos->[Y] - $self->{drag_start_pos}[Y]),
|
||||
]);
|
||||
$model_object->update_bounding_box;
|
||||
$parent->Refresh;
|
||||
@ -1240,21 +1255,48 @@ sub statusbar {
|
||||
return $self->skeinpanel->GetParent->{statusbar};
|
||||
}
|
||||
|
||||
sub to_pixel {
|
||||
my $self = shift;
|
||||
return $_[0] * $self->{scaling_factor} * &Slic3r::SCALING_FACTOR;
|
||||
# coordinates of the model origin (0,0) in pixels
|
||||
sub model_origin_to_pixel {
|
||||
my ($self) = @_;
|
||||
|
||||
return [
|
||||
CANVAS_SIZE->[X]/2 - ($self->{config}->print_center->[X] * $self->{scaling_factor}),
|
||||
CANVAS_SIZE->[Y]/2 - ($self->{config}->print_center->[Y] * $self->{scaling_factor}),
|
||||
];
|
||||
}
|
||||
|
||||
sub to_units {
|
||||
my $self = shift;
|
||||
return $_[0] / $self->{scaling_factor} / &Slic3r::SCALING_FACTOR;
|
||||
# convert a model coordinate into a pixel coordinate, assuming preview has square shape
|
||||
sub point_to_pixel {
|
||||
my ($self, $point) = @_;
|
||||
|
||||
my $canvas_height = $self->{canvas}->GetSize->GetHeight;
|
||||
my $zero = $self->model_origin_to_pixel;
|
||||
return [
|
||||
$point->[X] * $self->{scaling_factor} + $zero->[X],
|
||||
$canvas_height - ($point->[Y] * $self->{scaling_factor} + $zero->[Y]),
|
||||
];
|
||||
}
|
||||
|
||||
sub _y {
|
||||
my $self = shift;
|
||||
my ($points) = @_;
|
||||
my $height = $self->{canvas}->GetSize->GetHeight;
|
||||
return [ map [ $_->[X], $height - $_->[Y] ], @$points ];
|
||||
sub points_to_pixel {
|
||||
my ($self, $points, $unscale) = @_;
|
||||
|
||||
my $result = [];
|
||||
foreach my $point (@$points) {
|
||||
$point = [ map unscale($_), @$point ] if $unscale;
|
||||
push @$result, $self->point_to_pixel($point);
|
||||
}
|
||||
return $result;
|
||||
}
|
||||
|
||||
sub point_to_model_units {
|
||||
my ($self, $point) = @_;
|
||||
|
||||
my $canvas_height = $self->{canvas}->GetSize->GetHeight;
|
||||
my $zero = $self->model_origin_to_pixel;
|
||||
return [
|
||||
($point->[X] - $zero->[X]) / $self->{scaling_factor},
|
||||
(($canvas_height - $point->[Y] - $zero->[Y]) / $self->{scaling_factor}),
|
||||
];
|
||||
}
|
||||
|
||||
package Slic3r::GUI::Plater::DropTarget;
|
||||
|
||||
@ -37,6 +37,13 @@ sub new {
|
||||
tooltip => 'If this is enabled, Slic3r will prompt the last output directory instead of the one containing the input files.',
|
||||
default => $Slic3r::GUI::Settings->{_}{remember_output_path},
|
||||
},
|
||||
{
|
||||
opt_key => 'autocenter',
|
||||
type => 'bool',
|
||||
label => 'Auto-center parts',
|
||||
tooltip => 'If this is enabled, Slic3r will auto-center objects around the configured print center.',
|
||||
default => $Slic3r::GUI::Settings->{_}{autocenter},
|
||||
},
|
||||
],
|
||||
on_change => sub { $self->{values}{$_[0]} = $_[1] },
|
||||
label_width => 100,
|
||||
|
||||
@ -144,6 +144,7 @@ sub quick_slice {
|
||||
}
|
||||
$model->arrange_objects($config);
|
||||
}
|
||||
$model->center_instances_around_point($config->print_center);
|
||||
|
||||
$print->add_model_object($_) for @{ $model->objects };
|
||||
$print->validate;
|
||||
@ -179,31 +180,26 @@ sub quick_slice {
|
||||
local $SIG{__WARN__} = sub { push @warnings, $_[0] };
|
||||
my %export_params = (
|
||||
output_file => $output_file,
|
||||
status_cb => sub {
|
||||
);
|
||||
$print->status_cb(sub {
|
||||
my ($percent, $message) = @_;
|
||||
if (&Wx::wxVERSION_STRING =~ / 2\.(8\.|9\.[2-9])/) {
|
||||
$process_dialog->Update($percent, "$message…");
|
||||
}
|
||||
},
|
||||
);
|
||||
});
|
||||
if ($params{export_svg}) {
|
||||
$print->export_svg(%export_params);
|
||||
} else {
|
||||
$print->process;
|
||||
$print->export_gcode(%export_params);
|
||||
}
|
||||
$print->status_cb(undef);
|
||||
Slic3r::GUI::warning_catcher($self)->($_) for @warnings;
|
||||
}
|
||||
$process_dialog->Destroy;
|
||||
undef $process_dialog;
|
||||
|
||||
my $message = "$input_file_basename was successfully sliced";
|
||||
if ($print->processing_time) {
|
||||
$message .= ' in';
|
||||
my $minutes = int($print->processing_time/60);
|
||||
$message .= sprintf " %d minutes and", $minutes if $minutes;
|
||||
$message .= sprintf " %.1f seconds", $print->processing_time - $minutes*60;
|
||||
}
|
||||
$message .= ".";
|
||||
my $message = "$input_file_basename was successfully sliced.";
|
||||
&Wx::wxTheApp->notify($message);
|
||||
Wx::MessageDialog->new($self, $message, 'Slicing Done!',
|
||||
wxOK | wxICON_INFORMATION)->ShowModal;
|
||||
|
||||
@ -165,4 +165,14 @@ sub y_max {
|
||||
return $self->extents->[Y][MAX];
|
||||
}
|
||||
|
||||
sub z_min {
|
||||
my $self = shift;
|
||||
return $self->extents->[Z][MIN];
|
||||
}
|
||||
|
||||
sub z_max {
|
||||
my $self = shift;
|
||||
return $self->extents->[Z][MAX];
|
||||
}
|
||||
|
||||
1;
|
||||
|
||||
@ -222,6 +222,28 @@ sub align_to_origin {
|
||||
}
|
||||
}
|
||||
|
||||
# input point is expressed in unscaled coordinates
|
||||
sub center_instances_around_point {
|
||||
my ($self, $point) = @_;
|
||||
|
||||
my $bb = $self->bounding_box;
|
||||
return if !defined $bb;
|
||||
|
||||
my $size = $bb->size;
|
||||
my @shift = (
|
||||
-$bb->x_min + $point->[X] - $size->[X]/2,
|
||||
-$bb->y_min + $point->[Y] - $size->[Y]/2,
|
||||
);
|
||||
|
||||
foreach my $object (@{$self->objects}) {
|
||||
foreach my $instance (@{$object->instances}) {
|
||||
$instance->offset->[X] += $shift[X];
|
||||
$instance->offset->[Y] += $shift[Y];
|
||||
}
|
||||
$object->update_bounding_box;
|
||||
}
|
||||
}
|
||||
|
||||
sub translate {
|
||||
my $self = shift;
|
||||
my @shift = @_;
|
||||
@ -516,11 +538,18 @@ has 'scaling_factor' => (is => 'rw', default => sub { 1 });
|
||||
has 'offset' => (is => 'rw'); # must be arrayref in *unscaled* coordinates
|
||||
|
||||
sub transform_mesh {
|
||||
my ($self, $mesh) = @_;
|
||||
my ($self, $mesh, $dont_translate) = @_;
|
||||
|
||||
$mesh->rotate($self->rotation, Slic3r::Point->new(0,0)); # rotate around mesh origin
|
||||
$mesh->scale($self->scaling_factor); # scale around mesh origin
|
||||
$mesh->translate(@{$self->offset}, 0);
|
||||
$mesh->translate(@{$self->offset}, 0) unless $dont_translate;
|
||||
}
|
||||
|
||||
sub transform_polygon {
|
||||
my ($self, $polygon) = @_;
|
||||
|
||||
$polygon->rotate($self->rotation, Slic3r::Point->new(0,0)); # rotate around origin
|
||||
$polygon->scale($self->scaling_factor); # scale around origin
|
||||
}
|
||||
|
||||
1;
|
||||
|
||||
@ -8,13 +8,12 @@ use Slic3r::ExtrusionPath ':roles';
|
||||
use Slic3r::Geometry qw(X Y Z X1 Y1 X2 Y2 MIN MAX PI scale unscale move_points chained_path
|
||||
convex_hull);
|
||||
use Slic3r::Geometry::Clipper qw(diff_ex union_ex union_pt intersection_ex intersection offset
|
||||
offset2 union_pt_chained JT_ROUND JT_SQUARE);
|
||||
use Time::HiRes qw(gettimeofday tv_interval);
|
||||
offset2 union union_pt_chained JT_ROUND JT_SQUARE);
|
||||
|
||||
has 'config' => (is => 'rw', default => sub { Slic3r::Config->new_from_defaults }, trigger => 1);
|
||||
has 'config' => (is => 'rw', default => sub { Slic3r::Config->new_from_defaults }, trigger => \&init_config);
|
||||
has 'extra_variables' => (is => 'rw', default => sub {{}});
|
||||
has 'objects' => (is => 'rw', default => sub {[]});
|
||||
has 'processing_time' => (is => 'rw');
|
||||
has 'status_cb' => (is => 'rw');
|
||||
has 'extruders' => (is => 'rw', default => sub {[]});
|
||||
has 'regions' => (is => 'rw', default => sub {[]});
|
||||
has 'support_material_flow' => (is => 'rw');
|
||||
@ -31,10 +30,11 @@ sub BUILD {
|
||||
my $self = shift;
|
||||
|
||||
# call this manually because the 'default' coderef doesn't trigger the trigger
|
||||
$self->_trigger_config;
|
||||
$self->init_config;
|
||||
}
|
||||
|
||||
sub _trigger_config {
|
||||
# this method needs to be idempotent
|
||||
sub init_config {
|
||||
my $self = shift;
|
||||
|
||||
# store config in a handy place
|
||||
@ -68,6 +68,14 @@ sub _trigger_config {
|
||||
$self->config->set('retract_lift', [ map $self->config->retract_lift->[0], @{$self->config->retract_lift} ]);
|
||||
}
|
||||
|
||||
sub apply_config {
|
||||
my ($self, $config) = @_;
|
||||
|
||||
$self->config->apply($config);
|
||||
$self->init_config;
|
||||
$_->init_config for @{$self->objects};
|
||||
}
|
||||
|
||||
sub _build_has_support_material {
|
||||
my $self = shift;
|
||||
return (first { $_->config->support_material } @{$self->objects})
|
||||
@ -79,14 +87,17 @@ sub _build_has_support_material {
|
||||
# and have explicit instance positions
|
||||
sub add_model_object {
|
||||
my $self = shift;
|
||||
my ($object) = @_;
|
||||
my ($object, $obj_idx) = @_;
|
||||
|
||||
# read the material mapping provided by the model object, if any
|
||||
my %matmap = %{ $object->material_mapping || {} };
|
||||
$_-- for values %matmap; # extruders in the mapping are 1-indexed but we want 0-indexed
|
||||
|
||||
my %meshes = (); # region_id => TriangleMesh
|
||||
foreach my $volume (@{$object->volumes}) {
|
||||
my %volumes = (); # region_id => [ volume_id, ... ]
|
||||
foreach my $volume_id (0..$#{$object->volumes}) {
|
||||
my $volume = $object->volumes->[$volume_id];
|
||||
|
||||
# determine what region should this volume be mapped to
|
||||
my $region_id;
|
||||
if (defined $volume->material_id) {
|
||||
if (!exists $matmap{ $volume->material_id }) {
|
||||
@ -97,59 +108,46 @@ sub add_model_object {
|
||||
} else {
|
||||
$region_id = 0;
|
||||
}
|
||||
$volumes{$region_id} //= [];
|
||||
push @{ $volumes{$region_id} }, $volume_id;
|
||||
|
||||
# instantiate region if it does not exist
|
||||
$self->regions->[$region_id] //= Slic3r::Print::Region->new;
|
||||
|
||||
# if a mesh is already associated to this region, append this one to it
|
||||
$meshes{$region_id} //= Slic3r::TriangleMesh->new;
|
||||
$meshes{$region_id}->merge($volume->mesh);
|
||||
}
|
||||
|
||||
# bounding box of the original meshes in original position in unscaled coordinates
|
||||
my $bb1 = Slic3r::Geometry::BoundingBox->merge(map $_->bounding_box, values %meshes);
|
||||
|
||||
foreach my $mesh (values %meshes) {
|
||||
# we ignore the per-instance transformations currently and only
|
||||
# consider the first one
|
||||
$object->instances->[0]->transform_mesh($mesh);
|
||||
}
|
||||
|
||||
# we align object also after transformations so that we only work with positive coordinates
|
||||
# and the assumption that bounding_box === size works
|
||||
my $bb2 = Slic3r::Geometry::BoundingBox->merge(map $_->bounding_box, values %meshes);
|
||||
$_->translate(@{$bb2->vector_to_origin}) for values %meshes;
|
||||
|
||||
# prepare scaled object size
|
||||
my $scaled_bb = $bb2->clone;
|
||||
$scaled_bb->translate(@{$bb2->vector_to_origin}); # not needed for getting size, but who knows
|
||||
$scaled_bb->scale(1 / &Slic3r::SCALING_FACTOR);
|
||||
|
||||
# prepare copies
|
||||
my @copies = ();
|
||||
foreach my $instance (@{ $object->instances }) {
|
||||
push @copies, Slic3r::Point->new(
|
||||
scale($instance->offset->[X] - $bb1->extents->[X][MIN]),
|
||||
scale($instance->offset->[Y] - $bb1->extents->[Y][MIN]),
|
||||
);
|
||||
}
|
||||
|
||||
# initialize print object
|
||||
push @{$self->objects}, Slic3r::Print::Object->new(
|
||||
my $o = Slic3r::Print::Object->new(
|
||||
print => $self,
|
||||
meshes => [ map $meshes{$_}, 0..$#{$self->regions} ],
|
||||
copies => [ @copies ],
|
||||
size => $scaled_bb->size, # transformed size
|
||||
input_file => $object->input_file,
|
||||
model_object => $object,
|
||||
region_volumes => [ map $volumes{$_}, 0..$#{$self->regions} ],
|
||||
copies => [ map Slic3r::Point->new_scale(@{ $_->offset }), @{ $object->instances } ],
|
||||
config_overrides => $object->config,
|
||||
layer_height_ranges => $object->layer_height_ranges,
|
||||
);
|
||||
if (defined $obj_idx) {
|
||||
splice @{$self->objects}, $obj_idx, 0, $o;
|
||||
} else {
|
||||
push @{$self->objects}, $o;
|
||||
}
|
||||
|
||||
if (!defined $self->extra_variables->{input_filename}) {
|
||||
if (defined (my $input_file = $object->input_file)) {
|
||||
@{$self->extra_variables}{qw(input_filename input_filename_base)} = parse_filename($input_file);
|
||||
}
|
||||
}
|
||||
# TODO: invalidate skirt and brim
|
||||
}
|
||||
|
||||
sub delete_object {
|
||||
my ($self, $obj_idx) = @_;
|
||||
splice @{$self->objects}, $obj_idx, 1;
|
||||
# TODO: invalidate skirt and brim
|
||||
}
|
||||
|
||||
sub delete_all_objects {
|
||||
my ($self) = @_;
|
||||
@{$self->objects} = ();
|
||||
# TODO: invalidate skirt and brim
|
||||
}
|
||||
|
||||
sub validate {
|
||||
@ -159,20 +157,33 @@ sub validate {
|
||||
# check horizontal clearance
|
||||
{
|
||||
my @a = ();
|
||||
for my $obj_idx (0 .. $#{$self->objects}) {
|
||||
my $clearance;
|
||||
{
|
||||
my @points = map Slic3r::Point->new(@$_[X,Y]), map @{$_->vertices}, @{$self->objects->[$obj_idx]->meshes};
|
||||
my $convex_hull = convex_hull(\@points);
|
||||
($clearance) = @{offset([$convex_hull], scale $Slic3r::Config->extruder_clearance_radius / 2, 1, JT_ROUND)};
|
||||
}
|
||||
for my $copy (@{$self->objects->[$obj_idx]->copies}) {
|
||||
my $copy_clearance = $clearance->clone;
|
||||
$copy_clearance->translate(@$copy);
|
||||
if (@{ intersection(\@a, [$copy_clearance]) }) {
|
||||
foreach my $object (@{$self->objects}) {
|
||||
# get convex hulls of all meshes assigned to this print object
|
||||
my @mesh_convex_hulls = map $object->model_object->volumes->[$_]->mesh->convex_hull,
|
||||
map @$_,
|
||||
grep defined $_,
|
||||
@{$object->region_volumes};
|
||||
|
||||
# make a single convex hull for all of them
|
||||
my $convex_hull = convex_hull([ map @$_, @mesh_convex_hulls ]);
|
||||
|
||||
# apply the same transformations we apply to the actual meshes when slicing them
|
||||
$object->model_object->instances->[0]->transform_polygon($convex_hull, 1);
|
||||
|
||||
# align object to Z = 0 and apply XY shift
|
||||
$convex_hull->translate(@{$object->_copies_shift});
|
||||
|
||||
# grow convex hull with the clearance margin
|
||||
($convex_hull) = @{offset([$convex_hull], scale $self->config->extruder_clearance_radius / 2, 1, JT_ROUND, scale(0.1))};
|
||||
|
||||
# now we need that no instance of $convex_hull does not intersect any of the previously checked object instances
|
||||
for my $copy (@{$object->_shifted_copies}) {
|
||||
my $p = $convex_hull->clone;
|
||||
$p->translate(@$copy);
|
||||
if (@{ intersection(\@a, [$p]) }) {
|
||||
die "Some objects are too close; your extruder will collide with them.\n";
|
||||
}
|
||||
@a = map $_->clone, map @$_, @{union_ex([ @a, $copy_clearance ])};
|
||||
@a = @{union([@a, $p])};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -286,7 +297,7 @@ sub bounding_box {
|
||||
|
||||
my @points = ();
|
||||
foreach my $object (@{$self->objects}) {
|
||||
foreach my $copy (@{$object->copies}) {
|
||||
foreach my $copy (@{$object->_shifted_copies}) {
|
||||
push @points,
|
||||
[ $copy->[X], $copy->[Y] ],
|
||||
[ $copy->[X] + $object->size->[X], $copy->[Y] + $object->size->[Y] ];
|
||||
@ -310,13 +321,11 @@ sub _simplify_slices {
|
||||
}
|
||||
}
|
||||
|
||||
sub export_gcode {
|
||||
my $self = shift;
|
||||
my %params = @_;
|
||||
sub process {
|
||||
my ($self) = @_;
|
||||
|
||||
$self->init_extruders;
|
||||
my $status_cb = $params{status_cb} || sub {};
|
||||
my $t0 = [gettimeofday];
|
||||
my $status_cb = $self->status_cb // sub {};
|
||||
|
||||
# skein the STL into layers
|
||||
# each layer has surfaces with holes
|
||||
@ -433,6 +442,13 @@ sub export_gcode {
|
||||
eval "use Slic3r::Test::SectionCut";
|
||||
Slic3r::Test::SectionCut->new(print => $self)->export_svg("section_cut.svg");
|
||||
}
|
||||
}
|
||||
|
||||
sub export_gcode {
|
||||
my $self = shift;
|
||||
my %params = @_;
|
||||
|
||||
my $status_cb = $self->status_cb // sub {};
|
||||
|
||||
# output everything to a G-code file
|
||||
my $output_file = $self->expanded_output_filepath($params{output_file});
|
||||
@ -448,19 +464,6 @@ sub export_gcode {
|
||||
system($_, $output_file);
|
||||
}
|
||||
}
|
||||
|
||||
# output some statistics
|
||||
unless ($params{quiet}) {
|
||||
$self->processing_time(tv_interval($t0));
|
||||
printf "Done. Process took %d minutes and %.3f seconds\n",
|
||||
int($self->processing_time/60),
|
||||
$self->processing_time - int($self->processing_time/60)*60;
|
||||
|
||||
# TODO: more statistics!
|
||||
print map sprintf("Filament required: %.1fmm (%.1fcm3)\n",
|
||||
$_->absolute_E, $_->extruded_volume/1000),
|
||||
@{$self->extruders};
|
||||
}
|
||||
}
|
||||
|
||||
sub export_svg {
|
||||
@ -510,7 +513,7 @@ EOF
|
||||
|
||||
# sort slices so that the outermost ones come first
|
||||
my @slices = sort { $a->contour->contains_point($b->contour->first_point) ? 0 : 1 } @{$layer->slices};
|
||||
foreach my $copy (@{$self->objects->[$obj_idx]->copies}) {
|
||||
foreach my $copy (@{$self->objects->[$obj_idx]->_shifted_copies}) {
|
||||
foreach my $slice (@slices) {
|
||||
my $expolygon = $slice->clone;
|
||||
$expolygon->translate(@$copy);
|
||||
@ -558,6 +561,8 @@ sub make_skirt {
|
||||
return unless $Slic3r::Config->skirts > 0
|
||||
|| ($Slic3r::Config->ooze_prevention && @{$self->extruders} > 1);
|
||||
|
||||
$self->skirt->clear; # method must be idempotent
|
||||
|
||||
# collect points from all layers contained in skirt height
|
||||
my @points = ();
|
||||
foreach my $obj_idx (0 .. $#{$self->objects}) {
|
||||
@ -572,7 +577,7 @@ sub make_skirt {
|
||||
(map @{$_->polyline}, map @{$_->support_fills}, grep $_->support_fills, @support_layers),
|
||||
(map @{$_->polyline}, map @{$_->support_interface_fills}, grep $_->support_interface_fills, @support_layers);
|
||||
}
|
||||
push @points, map move_points($_, @layer_points), @{$object->copies};
|
||||
push @points, map move_points($_, @layer_points), @{$object->_shifted_copies};
|
||||
}
|
||||
return if @points < 3; # at least three points required for a convex hull
|
||||
|
||||
@ -593,7 +598,7 @@ sub make_skirt {
|
||||
my $distance = scale $Slic3r::Config->skirt_distance;
|
||||
for (my $i = $Slic3r::Config->skirts; $i > 0; $i--) {
|
||||
$distance += scale $spacing;
|
||||
my $loop = offset([$convex_hull], $distance, 0.0001, JT_ROUND)->[0];
|
||||
my $loop = offset([$convex_hull], $distance, 1, JT_ROUND, scale(0.1))->[0];
|
||||
$self->skirt->append(Slic3r::ExtrusionLoop->new(
|
||||
polygon => Slic3r::Polygon->new(@$loop),
|
||||
role => EXTR_ROLE_SKIRT,
|
||||
@ -621,6 +626,8 @@ sub make_brim {
|
||||
my $self = shift;
|
||||
return unless $Slic3r::Config->brim_width > 0;
|
||||
|
||||
$self->brim->clear; # method must be idempotent
|
||||
|
||||
my $flow = $self->objects->[0]->layers->[0]->regions->[0]->perimeter_flow;
|
||||
|
||||
my $grow_distance = $flow->scaled_width / 2;
|
||||
@ -640,7 +647,7 @@ sub make_brim {
|
||||
(map @{$_->polyline->grow($grow_distance)}, @{$support_layer0->support_interface_fills})
|
||||
if $support_layer0->support_interface_fills;
|
||||
}
|
||||
foreach my $copy (@{$object->copies}) {
|
||||
foreach my $copy (@{$object->_shifted_copies}) {
|
||||
push @islands, map { $_->translate(@$copy); $_ } map $_->clone, @object_islands;
|
||||
}
|
||||
}
|
||||
@ -750,14 +757,6 @@ sub write_gcode {
|
||||
# TODO: make sure we select the first *used* extruder
|
||||
print $fh $gcodegen->set_extruder($self->extruders->[0]);
|
||||
|
||||
# calculate X,Y shift to center print around specified origin
|
||||
my $print_bb = $self->bounding_box;
|
||||
my $print_size = $print_bb->size;
|
||||
my @shift = (
|
||||
$Slic3r::Config->print_center->[X] - unscale($print_size->[X]/2 + $print_bb->x_min),
|
||||
$Slic3r::Config->print_center->[Y] - unscale($print_size->[Y]/2 + $print_bb->y_min),
|
||||
);
|
||||
|
||||
# initialize a motion planner for object-to-object travel moves
|
||||
if ($Slic3r::Config->avoid_crossing_perimeters) {
|
||||
my $distance_from_objects = 1;
|
||||
@ -770,9 +769,8 @@ sub write_gcode {
|
||||
# discard layers only containing thin walls (offset would fail on an empty polygon)
|
||||
if (@$convex_hull) {
|
||||
my $expolygon = Slic3r::ExPolygon->new($convex_hull);
|
||||
$expolygon->translate(scale $shift[X], scale $shift[Y]);
|
||||
my @island = @{$expolygon->offset_ex(scale $distance_from_objects, 1, JT_SQUARE)};
|
||||
foreach my $copy (@{ $self->objects->[$obj_idx]->copies }) {
|
||||
foreach my $copy (@{ $self->objects->[$obj_idx]->shifted_copies }) {
|
||||
push @islands, map { my $c = $_->clone; $c->translate(@$copy); $c } @island;
|
||||
}
|
||||
}
|
||||
@ -799,7 +797,6 @@ sub write_gcode {
|
||||
my $layer_gcode = Slic3r::GCode::Layer->new(
|
||||
print => $self,
|
||||
gcodegen => $gcodegen,
|
||||
shift => \@shift,
|
||||
);
|
||||
|
||||
# do all objects for each layer
|
||||
@ -816,7 +813,7 @@ sub write_gcode {
|
||||
# this happens before Z goes down to layer 0 again, so that
|
||||
# no collision happens hopefully.
|
||||
if ($finished_objects > 0) {
|
||||
$gcodegen->set_shift(map $shift[$_] + unscale $copy->[$_], X,Y);
|
||||
$gcodegen->set_shift(map unscale $copy->[$_], X,Y);
|
||||
print $fh $gcodegen->retract;
|
||||
print $fh $gcodegen->G0(Slic3r::Point->new(0,0), undef, 0, 'move to origin position for next object');
|
||||
}
|
||||
@ -850,7 +847,7 @@ sub write_gcode {
|
||||
}
|
||||
} else {
|
||||
# order objects using a nearest neighbor search
|
||||
my @obj_idx = @{chained_path([ map Slic3r::Point->new(@{$_->copies->[0]}), @{$self->objects} ])};
|
||||
my @obj_idx = @{chained_path([ map Slic3r::Point->new(@{$_->_shifted_copies->[0]}), @{$self->objects} ])};
|
||||
|
||||
# sort layers by Z
|
||||
my %layers = (); # print_z => [ [layers], [layers], [layers] ] by obj_idx
|
||||
@ -871,7 +868,7 @@ sub write_gcode {
|
||||
foreach my $obj_idx (@obj_idx) {
|
||||
foreach my $layer (@{ $layers{$print_z}[$obj_idx] // [] }) {
|
||||
print $fh $buffer->append(
|
||||
$layer_gcode->process_layer($layer, $layer->object->copies),
|
||||
$layer_gcode->process_layer($layer, $layer->object->_shifted_copies),
|
||||
$layer->object . ref($layer), # differentiate $obj_id between normal layers and support layers
|
||||
$layer->id,
|
||||
$layer->print_z,
|
||||
@ -917,7 +914,7 @@ sub expanded_output_filepath {
|
||||
@$extra_variables{qw(input_filename input_filename_base)} = parse_filename($input_file);
|
||||
} else {
|
||||
# if no input file was supplied, take the first one from our objects
|
||||
$input_file = $self->objects->[0]->input_file // return undef;
|
||||
$input_file = $self->objects->[0]->model_object->input_file // return undef;
|
||||
}
|
||||
|
||||
if ($path && -d $path) {
|
||||
@ -931,7 +928,6 @@ sub expanded_output_filepath {
|
||||
} else {
|
||||
# path is a full path to a file so we use it as it is
|
||||
}
|
||||
|
||||
return $self->config->replace_options($path, { %{$self->extra_variables}, %$extra_variables });
|
||||
}
|
||||
|
||||
@ -944,4 +940,9 @@ sub parse_filename {
|
||||
return ($filename, $filename_base);
|
||||
}
|
||||
|
||||
sub apply_extra_variables {
|
||||
my ($self, $extra) = @_;
|
||||
$self->extra_variables->{$_} = $extra->{$_} for keys %$extra;
|
||||
}
|
||||
|
||||
1;
|
||||
|
||||
@ -8,15 +8,18 @@ use Slic3r::Geometry::Clipper qw(diff diff_ex intersection intersection_ex union
|
||||
use Slic3r::Surface ':types';
|
||||
|
||||
has 'print' => (is => 'ro', weak_ref => 1, required => 1);
|
||||
has 'input_file' => (is => 'rw', required => 0);
|
||||
has 'meshes' => (is => 'rw', default => sub { [] }); # by region_id
|
||||
has 'size' => (is => 'rw', required => 1); # XYZ in scaled coordinates
|
||||
has 'copies' => (is => 'rw', trigger => 1); # in scaled coordinates
|
||||
has 'layers' => (is => 'rw', default => sub { [] });
|
||||
has 'support_layers' => (is => 'rw', default => sub { [] });
|
||||
has 'model_object' => (is => 'ro', required => 1);
|
||||
has 'region_volumes' => (is => 'rw', default => sub { [] }); # by region_id
|
||||
has 'copies' => (is => 'ro'); # Slic3r::Point objects in scaled G-code coordinates
|
||||
has 'config_overrides' => (is => 'rw', default => sub { Slic3r::Config->new });
|
||||
has 'config' => (is => 'rw');
|
||||
has 'layer_height_ranges' => (is => 'rw', default => sub { [] }); # [ z_min, z_max, layer_height ]
|
||||
|
||||
has 'size' => (is => 'rw'); # XYZ in scaled coordinates
|
||||
has '_copies_shift' => (is => 'rw'); # scaled coordinates to add to copies (to compensate for the alignment operated when creating the object but still preserving a coherent API for external callers)
|
||||
has '_shifted_copies' => (is => 'rw'); # Slic3r::Point objects in scaled G-code coordinates in our coordinates
|
||||
has 'layers' => (is => 'rw', default => sub { [] });
|
||||
has 'support_layers' => (is => 'rw', default => sub { [] });
|
||||
has 'fill_maker' => (is => 'lazy');
|
||||
|
||||
sub BUILD {
|
||||
@ -24,6 +27,96 @@ sub BUILD {
|
||||
|
||||
$self->init_config;
|
||||
|
||||
# translate meshes so that we work with smaller coordinates
|
||||
{
|
||||
# compute the bounding box of the supplied meshes
|
||||
my @meshes = map $self->model_object->volumes->[$_]->mesh,
|
||||
map @$_,
|
||||
grep defined $_,
|
||||
@{$self->region_volumes};
|
||||
my $bb = Slic3r::Geometry::BoundingBox->merge(map $_->bounding_box, @meshes);
|
||||
|
||||
# Translate meshes so that our toolpath generation algorithms work with smaller
|
||||
# XY coordinates; this translation is an optimization and not strictly required.
|
||||
# However, this also aligns object to Z = 0, which on the contrary is required
|
||||
# since we don't assume input is already aligned.
|
||||
# We store the XY translation so that we can place copies correctly in the output G-code
|
||||
# (copies are expressed in G-code coordinates and this translation is not publicly exposed).
|
||||
$self->_copies_shift(Slic3r::Point->new_scale($bb->x_min, $bb->y_min));
|
||||
$self->_trigger_copies;
|
||||
|
||||
# Scale the object size and store it
|
||||
my $scaled_bb = $bb->clone;
|
||||
$scaled_bb->scale(1 / &Slic3r::SCALING_FACTOR);
|
||||
$self->size($scaled_bb->size);
|
||||
}
|
||||
}
|
||||
|
||||
sub _build_fill_maker {
|
||||
my $self = shift;
|
||||
return Slic3r::Fill->new(bounding_box => $self->bounding_box);
|
||||
}
|
||||
|
||||
sub _trigger_copies {
|
||||
my $self = shift;
|
||||
|
||||
return if !defined $self->_copies_shift;
|
||||
|
||||
# order copies with a nearest neighbor search and translate them by _copies_shift
|
||||
$self->_shifted_copies([
|
||||
map {
|
||||
my $c = $_->clone;
|
||||
$c->translate(@{ $self->_copies_shift });
|
||||
$c;
|
||||
} @{$self->copies}[@{chained_path($self->copies)}]
|
||||
]);
|
||||
}
|
||||
|
||||
# in unscaled coordinates
|
||||
sub add_copy {
|
||||
my ($self, $x, $y) = @_;
|
||||
push @{$self->copies}, Slic3r::Point->new_scale($x, $y);
|
||||
$self->_trigger_copies;
|
||||
}
|
||||
|
||||
sub delete_last_copy {
|
||||
my ($self) = @_;
|
||||
pop @{$self->copies};
|
||||
$self->_trigger_copies;
|
||||
}
|
||||
|
||||
sub delete_all_copies {
|
||||
my ($self) = @_;
|
||||
@{$self->copies} = ();
|
||||
$self->_trigger_copies;
|
||||
}
|
||||
|
||||
sub init_config {
|
||||
my $self = shift;
|
||||
$self->config(Slic3r::Config->merge($self->print->config, $self->config_overrides));
|
||||
}
|
||||
|
||||
sub layer_count {
|
||||
my $self = shift;
|
||||
return scalar @{ $self->layers };
|
||||
}
|
||||
|
||||
sub bounding_box {
|
||||
my $self = shift;
|
||||
|
||||
# since the object is aligned to origin, bounding box coincides with size
|
||||
return Slic3r::Geometry::BoundingBox->new_from_points([ map Slic3r::Point->new(@$_[X,Y]), [0,0], $self->size ]);
|
||||
}
|
||||
|
||||
# this should be idempotent
|
||||
sub slice {
|
||||
my $self = shift;
|
||||
my %params = @_;
|
||||
|
||||
# init layers
|
||||
{
|
||||
@{$self->layers} = ();
|
||||
|
||||
# make layers taking custom heights into account
|
||||
my $print_z = my $slice_z = my $height = my $id = 0;
|
||||
|
||||
@ -74,41 +167,6 @@ sub BUILD {
|
||||
}
|
||||
}
|
||||
|
||||
sub _build_fill_maker {
|
||||
my $self = shift;
|
||||
return Slic3r::Fill->new(bounding_box => $self->bounding_box);
|
||||
}
|
||||
|
||||
# This should be probably moved in Print.pm at the point where we sort Layer objects
|
||||
sub _trigger_copies {
|
||||
my $self = shift;
|
||||
return unless @{$self->copies} > 1;
|
||||
|
||||
# order copies with a nearest neighbor search
|
||||
@{$self->copies} = @{$self->copies}[@{chained_path($self->copies)}];
|
||||
}
|
||||
|
||||
sub init_config {
|
||||
my $self = shift;
|
||||
$self->config(Slic3r::Config->merge($self->print->config, $self->config_overrides));
|
||||
}
|
||||
|
||||
sub layer_count {
|
||||
my $self = shift;
|
||||
return scalar @{ $self->layers };
|
||||
}
|
||||
|
||||
sub bounding_box {
|
||||
my $self = shift;
|
||||
|
||||
# since the object is aligned to origin, bounding box coincides with size
|
||||
return Slic3r::Geometry::BoundingBox->new_from_points([ map Slic3r::Point->new(@$_[X,Y]), [0,0], $self->size ]);
|
||||
}
|
||||
|
||||
sub slice {
|
||||
my $self = shift;
|
||||
my %params = @_;
|
||||
|
||||
# make sure all layers contain layer region objects for all regions
|
||||
my $regions_count = $self->print->regions_count;
|
||||
foreach my $layer (@{ $self->layers }) {
|
||||
@ -116,8 +174,26 @@ sub slice {
|
||||
}
|
||||
|
||||
# process facets
|
||||
for my $region_id (0 .. $#{$self->meshes}) {
|
||||
my $mesh = $self->meshes->[$region_id] // next; # ignore undef meshes
|
||||
for my $region_id (0..$#{$self->region_volumes}) {
|
||||
next if !defined $self->region_volumes->[$region_id];
|
||||
|
||||
# compose mesh
|
||||
my $mesh;
|
||||
foreach my $volume_id (@{$self->region_volumes->[$region_id]}) {
|
||||
if (defined $mesh) {
|
||||
$mesh->merge($self->model_object->volumes->[$volume_id]->mesh);
|
||||
} else {
|
||||
$mesh = $self->model_object->volumes->[$volume_id]->mesh->clone;
|
||||
}
|
||||
}
|
||||
|
||||
# transform mesh
|
||||
# we ignore the per-instance transformations currently and only
|
||||
# consider the first one
|
||||
$self->model_object->instances->[0]->transform_mesh($mesh, 1);
|
||||
|
||||
# align mesh to Z = 0 and apply XY shift
|
||||
$mesh->translate((map unscale(-$_), @{$self->_copies_shift}), -$self->model_object->bounding_box->z_min);
|
||||
|
||||
{
|
||||
my $loops = $mesh->slice([ map $_->slice_z, @{$self->layers} ]);
|
||||
@ -127,15 +203,8 @@ sub slice {
|
||||
}
|
||||
# TODO: read slicing_errors
|
||||
}
|
||||
|
||||
# free memory
|
||||
undef $mesh;
|
||||
undef $self->meshes->[$region_id];
|
||||
}
|
||||
|
||||
# free memory
|
||||
$self->meshes(undef);
|
||||
|
||||
# remove last layer(s) if empty
|
||||
pop @{$self->layers} while @{$self->layers} && (!map @{$_->slices}, @{$self->layers->[-1]->regions});
|
||||
|
||||
|
||||
@ -108,6 +108,7 @@ sub init_print {
|
||||
$model_name = [$model_name] if ref($model_name) ne 'ARRAY';
|
||||
for my $model (map model($_, %params), @$model_name) {
|
||||
$model->arrange_objects($config);
|
||||
$model->center_instances_around_point($config->print_center);
|
||||
$print->add_model_object($_) for @{$model->objects};
|
||||
}
|
||||
$print->validate;
|
||||
@ -119,6 +120,7 @@ sub gcode {
|
||||
my ($print) = @_;
|
||||
|
||||
my $fh = IO::Scalar->new(\my $gcode);
|
||||
$print->process;
|
||||
$print->export_gcode(output_fh => $fh, quiet => 1);
|
||||
$fh->close;
|
||||
|
||||
|
||||
@ -79,7 +79,7 @@ sub _plot {
|
||||
my (@rectangles, @circles) = ();
|
||||
|
||||
foreach my $object (@{$self->print->objects}) {
|
||||
foreach my $copy (@{$object->copies}) {
|
||||
foreach my $copy (@{$object->shifted_copies}) {
|
||||
foreach my $layer (@{$object->layers}, @{$object->support_layers}) {
|
||||
# get all ExtrusionPath objects
|
||||
my @paths =
|
||||
|
||||
28
slic3r.pl
28
slic3r.pl
@ -13,6 +13,7 @@ use List::Util qw(first);
|
||||
use POSIX qw(setlocale LC_NUMERIC);
|
||||
use Slic3r;
|
||||
use Slic3r::Geometry qw(X Y);
|
||||
use Time::HiRes qw(gettimeofday tv_interval);
|
||||
$|++;
|
||||
|
||||
our %opt = ();
|
||||
@ -144,26 +145,39 @@ if (@ARGV) { # slicing from command line
|
||||
# if all input objects have defined position(s) apply duplication to the whole model
|
||||
$model->duplicate($config, $config->duplicate);
|
||||
}
|
||||
$model->center_instances_around_point($config->print_center);
|
||||
|
||||
if ($opt{info}) {
|
||||
$model->print_info;
|
||||
next;
|
||||
}
|
||||
|
||||
my $print = Slic3r::Print->new(config => $config);
|
||||
$print->add_model_object($_) for @{$model->objects};
|
||||
$print->validate;
|
||||
my %params = (
|
||||
output_file => $opt{output},
|
||||
my $print = Slic3r::Print->new(
|
||||
config => $config,
|
||||
status_cb => sub {
|
||||
my ($percent, $message) = @_;
|
||||
printf "=> %s\n", $message;
|
||||
},
|
||||
);
|
||||
$print->add_model_object($_) for @{$model->objects};
|
||||
undef $model; # free memory
|
||||
$print->validate;
|
||||
if ($opt{export_svg}) {
|
||||
$print->export_svg(%params);
|
||||
$print->export_svg(output_file => $opt{output});
|
||||
} else {
|
||||
$print->export_gcode(%params);
|
||||
my $t0 = [gettimeofday];
|
||||
$print->process;
|
||||
$print->export_gcode(output_file => $opt{output});
|
||||
|
||||
# output some statistics
|
||||
{
|
||||
my $duration = tv_interval($t0);
|
||||
printf "Done. Process took %d minutes and %.3f seconds\n",
|
||||
int($duration/60), ($duration - int($duration/60)*60); # % truncates to integer
|
||||
}
|
||||
print map sprintf("Filament required: %.1fmm (%.1fcm3)\n",
|
||||
$_->absolute_E, $_->extruded_volume/1000),
|
||||
@{$print->extruders};
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
use Test::More tests => 3;
|
||||
use Test::More;
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
@ -11,6 +11,9 @@ use List::Util qw(first);
|
||||
use Slic3r;
|
||||
use Slic3r::Test;
|
||||
|
||||
plan skip_all => 'this test is currently disabled'; # needs to be adapted to the new API
|
||||
plan tests => 3;
|
||||
|
||||
{
|
||||
my $config = Slic3r::Config->new_from_defaults;
|
||||
$config->set('skirts', 0);
|
||||
|
||||
21
t/print.t
21
t/print.t
@ -1,4 +1,4 @@
|
||||
use Test::More tests => 1;
|
||||
use Test::More tests => 2;
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
@ -9,12 +9,25 @@ BEGIN {
|
||||
|
||||
use List::Util qw(first);
|
||||
use Slic3r;
|
||||
use Slic3r::Geometry qw(epsilon unscale X Y);
|
||||
use Slic3r::Test;
|
||||
|
||||
{
|
||||
my $print = Slic3r::Test::init_print('20mm_cube', rotation => 45);
|
||||
ok !(first { $_ < 0 } map @$_, map @{$_->vertices}, grep $_, map @{$_->meshes}, @{$print->objects}),
|
||||
"object is still in positive coordinate space even after rotation";
|
||||
my $config = Slic3r::Config->new_from_defaults;
|
||||
$config->set('print_center', [100,100]);
|
||||
my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
|
||||
my @extrusion_points = ();
|
||||
Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
|
||||
my ($self, $cmd, $args, $info) = @_;
|
||||
|
||||
if ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
|
||||
push @extrusion_points, my $point = Slic3r::Point->new_scale($args->{X}, $args->{Y});
|
||||
}
|
||||
});
|
||||
my $bb = Slic3r::Geometry::BoundingBox->new_from_points(\@extrusion_points);
|
||||
my $center = $bb->center_2D;
|
||||
ok abs(unscale($center->[X]) - $config->print_center->[X]) < epsilon, 'print is centered around print_center (X)';
|
||||
ok abs(unscale($center->[Y]) - $config->print_center->[Y]) < epsilon, 'print is centered around print_center (Y)';
|
||||
}
|
||||
|
||||
__END__
|
||||
|
||||
@ -191,10 +191,8 @@ TriangleMesh::slice(const std::vector<double> &z, std::vector<Polygons> &layers)
|
||||
FUTURE: parallelize slice_facet() and make_loops()
|
||||
*/
|
||||
|
||||
if (!this->repaired) this->repair();
|
||||
|
||||
// build a table to map a facet_idx to its three edge indices
|
||||
if (this->stl.v_shared == NULL) stl_generate_shared_vertices(&(this->stl));
|
||||
this->require_shared_vertices();
|
||||
typedef std::pair<int,int> t_edge;
|
||||
typedef std::vector<t_edge> t_edges; // edge_idx => a_id,b_id
|
||||
typedef std::map<t_edge,int> t_edges_map; // a_id,b_id => edge_idx
|
||||
@ -607,7 +605,7 @@ TriangleMesh::horizontal_projection(ExPolygons &retval) const
|
||||
void
|
||||
TriangleMesh::convex_hull(Polygon* hull)
|
||||
{
|
||||
if (this->stl.v_shared == NULL) stl_generate_shared_vertices(&(this->stl));
|
||||
this->require_shared_vertices();
|
||||
Points pp;
|
||||
pp.reserve(this->stl.stats.shared_vertices);
|
||||
for (int i = 0; i < this->stl.stats.shared_vertices; i++) {
|
||||
@ -617,6 +615,13 @@ TriangleMesh::convex_hull(Polygon* hull)
|
||||
Slic3r::Geometry::convex_hull(pp, hull);
|
||||
}
|
||||
|
||||
void
|
||||
TriangleMesh::require_shared_vertices()
|
||||
{
|
||||
if (!this->repaired) this->repair();
|
||||
if (this->stl.v_shared == NULL) stl_generate_shared_vertices(&(this->stl));
|
||||
}
|
||||
|
||||
#ifdef SLIC3RXS
|
||||
SV*
|
||||
TriangleMesh::to_SV() {
|
||||
|
||||
@ -41,6 +41,9 @@ class TriangleMesh
|
||||
SV* to_SV();
|
||||
void ReadFromPerl(SV* vertices, SV* facets);
|
||||
#endif
|
||||
|
||||
private:
|
||||
void require_shared_vertices();
|
||||
};
|
||||
|
||||
enum FacetEdgeType { feNone, feTop, feBottom };
|
||||
|
||||
Loading…
Reference in New Issue
Block a user