|
|
@@ -1,922 +0,0 @@
|
|
|
-# DLP Projector screen for the SLA (stereolitography) print process
|
|
|
-
|
|
|
-package Slic3r::GUI::Projector;
|
|
|
-use strict;
|
|
|
-use warnings;
|
|
|
-use Wx qw(:dialog :id :misc :sizer :systemsettings :bitmap :button :icon wxTheApp);
|
|
|
-use Wx::Event qw(EVT_BUTTON EVT_TEXT_ENTER EVT_SPINCTRL EVT_SLIDER);
|
|
|
-use base qw(Wx::Dialog Class::Accessor);
|
|
|
-use utf8;
|
|
|
-
|
|
|
-__PACKAGE__->mk_accessors(qw(config config2 screen controller _optgroups));
|
|
|
-
|
|
|
-sub new {
|
|
|
- my ($class, $parent) = @_;
|
|
|
- my $self = $class->SUPER::new($parent, -1, "Projector for DLP", wxDefaultPosition, wxDefaultSize);
|
|
|
- $self->config2({
|
|
|
- display => 0,
|
|
|
- show_bed => 1,
|
|
|
- invert_y => 0,
|
|
|
- zoom => 100,
|
|
|
- exposure_time => 2,
|
|
|
- bottom_exposure_time => 7,
|
|
|
- settle_time => 1.5,
|
|
|
- bottom_layers => 3,
|
|
|
- z_lift => 5,
|
|
|
- z_lift_speed => 8,
|
|
|
- offset => [0,0],
|
|
|
- });
|
|
|
-
|
|
|
- my $ini = eval { Slic3r::Config->read_ini("$Slic3r::GUI::datadir/DLP.ini") };
|
|
|
- if ($ini) {
|
|
|
- foreach my $opt_id (keys %{$ini->{_}}) {
|
|
|
- my $value = $ini->{_}{$opt_id};
|
|
|
- if ($opt_id eq 'offset') {
|
|
|
- $value = [ split /,/, $value ];
|
|
|
- }
|
|
|
- $self->config2->{$opt_id} = $value;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- my $sizer = Wx::BoxSizer->new(wxVERTICAL);
|
|
|
-
|
|
|
- $self->config(Slic3r::Config->new_from_defaults(
|
|
|
- qw(serial_port serial_speed bed_shape start_gcode end_gcode z_offset)
|
|
|
- ));
|
|
|
- $self->config->apply(wxTheApp->{mainframe}->config);
|
|
|
-
|
|
|
- my @optgroups = ();
|
|
|
- {
|
|
|
- push @optgroups, my $optgroup = Slic3r::GUI::ConfigOptionsGroup->new(
|
|
|
- parent => $self,
|
|
|
- title => 'USB/Serial connection',
|
|
|
- config => $self->config,
|
|
|
- label_width => 200,
|
|
|
- );
|
|
|
- $sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10);
|
|
|
-
|
|
|
- {
|
|
|
- my $line = Slic3r::GUI::OptionsGroup::Line->new(
|
|
|
- label => 'Serial port',
|
|
|
- );
|
|
|
- my $serial_port = $optgroup->get_option('serial_port');
|
|
|
- $serial_port->side_widget(sub {
|
|
|
- my ($parent) = @_;
|
|
|
-
|
|
|
- my $btn = Wx::BitmapButton->new($self, -1, Wx::Bitmap->new($Slic3r::var->("arrow_rotate_clockwise.png"), wxBITMAP_TYPE_PNG),
|
|
|
- wxDefaultPosition, wxDefaultSize, &Wx::wxBORDER_NONE);
|
|
|
- $btn->SetToolTipString("Rescan serial ports")
|
|
|
- if $btn->can('SetToolTipString');
|
|
|
- EVT_BUTTON($self, $btn, sub {
|
|
|
- $optgroup->get_field('serial_port')->set_values([ wxTheApp->scan_serial_ports ]);
|
|
|
- });
|
|
|
-
|
|
|
- return $btn;
|
|
|
- });
|
|
|
- my $serial_test = sub {
|
|
|
- my ($parent) = @_;
|
|
|
-
|
|
|
- my $btn = $self->{serial_test_btn} = Wx::Button->new($parent, -1,
|
|
|
- "Test", wxDefaultPosition, wxDefaultSize, wxBU_LEFT | wxBU_EXACTFIT);
|
|
|
- $btn->SetFont($Slic3r::GUI::small_font);
|
|
|
- if ($Slic3r::GUI::have_button_icons) {
|
|
|
- $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("wrench.png"), wxBITMAP_TYPE_PNG));
|
|
|
- }
|
|
|
-
|
|
|
- EVT_BUTTON($self, $btn, sub {
|
|
|
- my $sender = Slic3r::GCode::Sender->new;
|
|
|
- my $res = $sender->connect(
|
|
|
- $self->{config}->serial_port,
|
|
|
- $self->{config}->serial_speed,
|
|
|
- );
|
|
|
- if ($res && $sender->wait_connected) {
|
|
|
- Slic3r::GUI::show_info($self, "Connection to printer works correctly.", "Success!");
|
|
|
- } else {
|
|
|
- Slic3r::GUI::show_error($self, "Connection failed.");
|
|
|
- }
|
|
|
- });
|
|
|
- return $btn;
|
|
|
- };
|
|
|
- $line->append_option($serial_port);
|
|
|
- $line->append_option($optgroup->get_option('serial_speed'));
|
|
|
- $line->append_widget($serial_test);
|
|
|
- $optgroup->append_line($line);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- push @optgroups, my $optgroup = Slic3r::GUI::ConfigOptionsGroup->new(
|
|
|
- parent => $self,
|
|
|
- title => 'G-code',
|
|
|
- config => $self->config,
|
|
|
- label_width => 200,
|
|
|
- );
|
|
|
- $sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10);
|
|
|
-
|
|
|
- {
|
|
|
- my $option = $optgroup->get_option('start_gcode');
|
|
|
- $option->height(50);
|
|
|
- $option->full_width(1);
|
|
|
- $optgroup->append_single_option_line($option);
|
|
|
- }
|
|
|
- {
|
|
|
- my $option = $optgroup->get_option('end_gcode');
|
|
|
- $option->height(50);
|
|
|
- $option->full_width(1);
|
|
|
- $optgroup->append_single_option_line($option);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- my $on_change = sub {
|
|
|
- my ($opt_id, $value) = @_;
|
|
|
-
|
|
|
- $self->config2->{$opt_id} = $value;
|
|
|
- $self->screen->reposition;
|
|
|
- $self->show_print_time;
|
|
|
-
|
|
|
- my $serialized = {};
|
|
|
- foreach my $opt_id (keys %{$self->config2}) {
|
|
|
- my $value = $self->config2->{$opt_id};
|
|
|
- if (ref($value) eq 'ARRAY') {
|
|
|
- $value = join ',', @$value;
|
|
|
- }
|
|
|
- $serialized->{$opt_id} = $value;
|
|
|
- }
|
|
|
- Slic3r::Config->write_ini(
|
|
|
- "$Slic3r::GUI::datadir/DLP.ini",
|
|
|
- { _ => $serialized });
|
|
|
- };
|
|
|
-
|
|
|
- {
|
|
|
- push @optgroups, my $optgroup = Slic3r::GUI::OptionsGroup->new(
|
|
|
- parent => $self,
|
|
|
- title => 'Projection',
|
|
|
- on_change => $on_change,
|
|
|
- label_width => 200,
|
|
|
- );
|
|
|
- $sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10);
|
|
|
-
|
|
|
- {
|
|
|
- my $line = Slic3r::GUI::OptionsGroup::Line->new(
|
|
|
- label => 'Display',
|
|
|
- );
|
|
|
-
|
|
|
- my @displays = 0 .. (Wx::Display::GetCount()-1);
|
|
|
- $line->append_option(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'display',
|
|
|
- type => 'select',
|
|
|
- label => 'Display',
|
|
|
- tooltip => '',
|
|
|
- labels => [@displays],
|
|
|
- values => [@displays],
|
|
|
- default => $self->config2->{display},
|
|
|
- ));
|
|
|
- $line->append_option(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'zoom',
|
|
|
- type => 'percent',
|
|
|
- label => 'Zoom %',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{zoom},
|
|
|
- min => 0.1,
|
|
|
- max => 100,
|
|
|
- ));
|
|
|
- $line->append_option(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'offset',
|
|
|
- type => 'point',
|
|
|
- label => 'Offset',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{offset},
|
|
|
- ));
|
|
|
- $line->append_option(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'invert_y',
|
|
|
- type => 'bool',
|
|
|
- label => 'Invert Y',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{invert_y},
|
|
|
- ));
|
|
|
- $optgroup->append_line($line);
|
|
|
- }
|
|
|
-
|
|
|
- $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'show_bed',
|
|
|
- type => 'bool',
|
|
|
- label => 'Show bed',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{show_bed},
|
|
|
- ));
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- push @optgroups, my $optgroup = Slic3r::GUI::OptionsGroup->new(
|
|
|
- parent => $self,
|
|
|
- title => 'Print',
|
|
|
- on_change => $on_change,
|
|
|
- label_width => 200,
|
|
|
- );
|
|
|
- $sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10);
|
|
|
-
|
|
|
- {
|
|
|
- my $line = Slic3r::GUI::OptionsGroup::Line->new(
|
|
|
- label => 'Time (seconds)',
|
|
|
- );
|
|
|
- $line->append_option(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'bottom_exposure_time',
|
|
|
- type => 'f',
|
|
|
- label => 'Bottom exposure',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{bottom_exposure_time},
|
|
|
- ));
|
|
|
- $line->append_option(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'exposure_time',
|
|
|
- type => 'f',
|
|
|
- label => 'Exposure',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{exposure_time},
|
|
|
- ));
|
|
|
- $line->append_option(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'settle_time',
|
|
|
- type => 'f',
|
|
|
- label => 'Settle',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{settle_time},
|
|
|
- ));
|
|
|
- $optgroup->append_line($line);
|
|
|
- }
|
|
|
-
|
|
|
- $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'bottom_layers',
|
|
|
- type => 'i',
|
|
|
- label => 'Bottom layers',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{bottom_layers},
|
|
|
- ));
|
|
|
-
|
|
|
- {
|
|
|
- my $line = Slic3r::GUI::OptionsGroup::Line->new(
|
|
|
- label => 'Z Lift',
|
|
|
- );
|
|
|
- $line->append_option(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'z_lift',
|
|
|
- type => 'f',
|
|
|
- label => 'Distance',
|
|
|
- sidetext => 'mm',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{z_lift},
|
|
|
- ));
|
|
|
- $line->append_option(Slic3r::GUI::OptionsGroup::Option->new(
|
|
|
- opt_id => 'z_lift_speed',
|
|
|
- type => 'f',
|
|
|
- label => 'Speed',
|
|
|
- sidetext => 'mm/s',
|
|
|
- tooltip => '',
|
|
|
- default => $self->config2->{z_lift_speed},
|
|
|
- ));
|
|
|
- $optgroup->append_line($line);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $self->_optgroups([@optgroups]);
|
|
|
-
|
|
|
- {
|
|
|
- my $sizer1 = Wx::BoxSizer->new(wxHORIZONTAL);
|
|
|
- $sizer->Add($sizer1, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10);
|
|
|
-
|
|
|
- {
|
|
|
- my $btn = $self->{btn_manual_control} = Wx::Button->new($self, -1, 'Manual Control', wxDefaultPosition, wxDefaultSize);
|
|
|
- if ($Slic3r::GUI::have_button_icons) {
|
|
|
- $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("cog.png"), wxBITMAP_TYPE_PNG));
|
|
|
- }
|
|
|
- $sizer1->Add($btn, 0);
|
|
|
- EVT_BUTTON($self, $btn, sub {
|
|
|
- my $sender = Slic3r::GCode::Sender->new;
|
|
|
- my $res = $sender->connect(
|
|
|
- $self->config->serial_port,
|
|
|
- $self->config->serial_speed,
|
|
|
- );
|
|
|
- if (!$res || !$sender->wait_connected) {
|
|
|
- Slic3r::GUI::show_error(undef, "Connection failed. Check serial port and speed.");
|
|
|
- return;
|
|
|
- }
|
|
|
- my $dlg = Slic3r::GUI::Controller::ManualControlDialog->new
|
|
|
- ($self, $self->config, $sender);
|
|
|
- $dlg->ShowModal;
|
|
|
- $sender->disconnect;
|
|
|
- });
|
|
|
-
|
|
|
-
|
|
|
- }
|
|
|
- {
|
|
|
- my $btn = $self->{btn_print} = Wx::Button->new($self, -1, 'Print', wxDefaultPosition, wxDefaultSize);
|
|
|
- if ($Slic3r::GUI::have_button_icons) {
|
|
|
- $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("control_play.png"), wxBITMAP_TYPE_PNG));
|
|
|
- }
|
|
|
- $sizer1->Add($btn, 0);
|
|
|
- EVT_BUTTON($self, $btn, sub {
|
|
|
- $self->controller->start_print;
|
|
|
- $self->_update_buttons;
|
|
|
- $self->_set_status('');
|
|
|
- });
|
|
|
- }
|
|
|
- {
|
|
|
- my $btn = $self->{btn_stop} = Wx::Button->new($self, -1, 'Stop/Black', wxDefaultPosition, wxDefaultSize);
|
|
|
- if ($Slic3r::GUI::have_button_icons) {
|
|
|
- $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("control_stop.png"), wxBITMAP_TYPE_PNG));
|
|
|
- }
|
|
|
- $sizer1->Add($btn, 0);
|
|
|
- EVT_BUTTON($self, $btn, sub {
|
|
|
- $self->controller->stop_print;
|
|
|
- $self->_update_buttons;
|
|
|
- $self->_set_status('');
|
|
|
- });
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- {
|
|
|
- my $text = Wx::StaticText->new($self, -1, "Layer:", wxDefaultPosition, wxDefaultSize);
|
|
|
- $text->SetFont($Slic3r::GUI::small_font);
|
|
|
- $sizer1->Add($text, 0, wxEXPAND | wxLEFT, 10);
|
|
|
- }
|
|
|
- {
|
|
|
- my $spin = $self->{layers_spinctrl} = Wx::SpinCtrl->new($self, -1, 0, wxDefaultPosition, [60,-1],
|
|
|
- 0, 0, 300, 0);
|
|
|
- $sizer1->Add($spin, 0);
|
|
|
- EVT_SPINCTRL($self, $spin, sub {
|
|
|
- my $value = $spin->GetValue;
|
|
|
- $self->{layers_slider}->SetValue($value);
|
|
|
- $self->controller->project_layer($value);
|
|
|
- $self->_update_buttons;
|
|
|
- });
|
|
|
- }
|
|
|
- {
|
|
|
- my $slider = $self->{layers_slider} = Wx::Slider->new(
|
|
|
- $self, -1,
|
|
|
- 0, # default
|
|
|
- 0, # min
|
|
|
- 300, # max
|
|
|
- wxDefaultPosition,
|
|
|
- wxDefaultSize,
|
|
|
- );
|
|
|
- $sizer1->Add($slider, 1);
|
|
|
- EVT_SLIDER($self, $slider, sub {
|
|
|
- my $value = $slider->GetValue;
|
|
|
- $self->{layers_spinctrl}->SetValue($value);
|
|
|
- $self->controller->project_layer($value);
|
|
|
- $self->_update_buttons;
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- my $sizer2 = Wx::BoxSizer->new(wxHORIZONTAL);
|
|
|
- $sizer->Add($sizer2, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10);
|
|
|
-
|
|
|
- {
|
|
|
- $self->{status_text} = Wx::StaticText->new($self, -1, "", wxDefaultPosition, wxDefaultSize);
|
|
|
- $self->{status_text}->SetFont($Slic3r::GUI::small_font);
|
|
|
- $sizer2->Add($self->{status_text}, 1 | wxEXPAND);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- my $buttons = $self->CreateStdDialogButtonSizer(wxOK);
|
|
|
- EVT_BUTTON($self, wxID_CLOSE, sub {
|
|
|
- $self->_close;
|
|
|
- });
|
|
|
- $sizer->Add($buttons, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10);
|
|
|
- }
|
|
|
-
|
|
|
- $self->SetSizer($sizer);
|
|
|
- $sizer->SetSizeHints($self);
|
|
|
-
|
|
|
- # reuse existing screen if any
|
|
|
- if ($Slic3r::GUI::DLP_projection_screen) {
|
|
|
- $self->screen($Slic3r::GUI::DLP_projection_screen);
|
|
|
- $self->screen->config($self->config);
|
|
|
- $self->screen->config2($self->config2);
|
|
|
- } else {
|
|
|
- $self->screen(Slic3r::GUI::Projector::Screen->new($parent, $self->config, $self->config2));
|
|
|
- $Slic3r::GUI::DLP_projection_screen = $self->screen;
|
|
|
- }
|
|
|
- $self->screen->reposition;
|
|
|
- $self->screen->Show;
|
|
|
- wxTheApp->{mainframe}->Hide;
|
|
|
-
|
|
|
- # initialize controller
|
|
|
- $self->controller(Slic3r::GUI::Projector::Controller->new(
|
|
|
- config => $self->config,
|
|
|
- config2 => $self->config2,
|
|
|
- screen => $self->screen,
|
|
|
- on_project_layer => sub {
|
|
|
- my ($layer_num) = @_;
|
|
|
-
|
|
|
- $self->{layers_spinctrl}->SetValue($layer_num);
|
|
|
- $self->{layers_slider}->SetValue($layer_num);
|
|
|
-
|
|
|
- my $duration = $self->controller->remaining_print_time;
|
|
|
- $self->_set_status(sprintf "Printing layer %d/%d (z = %.2f); %d minutes and %d seconds left",
|
|
|
- $layer_num, $self->controller->layer_count,
|
|
|
- $self->controller->current_layer_height,
|
|
|
- int($duration/60), ($duration - int($duration/60)*60)); # % truncates to integer
|
|
|
- },
|
|
|
- on_print_completed => sub {
|
|
|
- $self->_update_buttons;
|
|
|
- $self->_set_status('');
|
|
|
- Wx::Bell();
|
|
|
- },
|
|
|
- ));
|
|
|
- {
|
|
|
- my $max = $self->controller->layer_count-1;
|
|
|
- $self->{layers_spinctrl}->SetRange(0, $max);
|
|
|
- $self->{layers_slider}->SetRange(0, $max);
|
|
|
- }
|
|
|
-
|
|
|
- $self->_update_buttons;
|
|
|
- $self->show_print_time;
|
|
|
-
|
|
|
- return $self;
|
|
|
-}
|
|
|
-
|
|
|
-sub _update_buttons {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- my $is_printing = $self->controller->is_printing;
|
|
|
- my $is_projecting = $self->controller->is_projecting;
|
|
|
- $self->{btn_manual_control}->Show(!$is_printing);
|
|
|
- $self->{btn_print}->Show(!$is_printing && !$is_projecting);
|
|
|
- $self->{btn_stop}->Show($is_printing || $is_projecting);
|
|
|
- $self->{layers_spinctrl}->Enable(!$is_printing);
|
|
|
- $self->{layers_slider}->Enable(!$is_printing);
|
|
|
- if ($is_printing) {
|
|
|
- $_->disable for @{$self->_optgroups};
|
|
|
- } else {
|
|
|
- $_->enable for @{$self->_optgroups};
|
|
|
- }
|
|
|
- $self->Layout;
|
|
|
-}
|
|
|
-
|
|
|
-sub _set_status {
|
|
|
- my ($self, $status) = @_;
|
|
|
- $self->{status_text}->SetLabel($status // '');
|
|
|
- $self->{status_text}->Wrap($self->{status_text}->GetSize->GetWidth);
|
|
|
- $self->{status_text}->Refresh;
|
|
|
- $self->Layout;
|
|
|
-}
|
|
|
-
|
|
|
-sub show_print_time {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
-
|
|
|
- my $duration = $self->controller->print_time;
|
|
|
- $self->_set_status(sprintf "Estimated print time: %d minutes and %d seconds",
|
|
|
- int($duration/60), ($duration - int($duration/60)*60)); # % truncates to integer
|
|
|
-}
|
|
|
-
|
|
|
-sub _close {
|
|
|
- my $self = shift;
|
|
|
-
|
|
|
- # if projection screen is not on the same display as our dialog,
|
|
|
- # ask the user whether they want to keep it open
|
|
|
- my $keep_screen = 0;
|
|
|
- my $display_area = Wx::Display->new($self->config2->{display})->GetGeometry;
|
|
|
- if (!$display_area->Contains($self->GetScreenPosition)) {
|
|
|
- my $res = Wx::MessageDialog->new($self, "Do you want to keep the black screen open?", 'Black screen', wxYES_NO | wxYES_DEFAULT | wxICON_QUESTION)->ShowModal;
|
|
|
- $keep_screen = ($res == wxID_YES);
|
|
|
- }
|
|
|
-
|
|
|
- if ($keep_screen) {
|
|
|
- $self->screen->config(undef);
|
|
|
- $self->screen->config2(undef);
|
|
|
- $self->screen->Refresh;
|
|
|
- } else {
|
|
|
- $self->screen->Destroy;
|
|
|
- $self->screen(undef);
|
|
|
- $Slic3r::GUI::DLP_projection_screen = undef;
|
|
|
- }
|
|
|
- wxTheApp->{mainframe}->Show;
|
|
|
-
|
|
|
- my $printer_tab = wxTheApp->{mainframe}{options_tabs}{printer};
|
|
|
- $printer_tab->load_config($self->config);
|
|
|
-
|
|
|
- $self->EndModal(wxID_OK);
|
|
|
-}
|
|
|
-
|
|
|
-package Slic3r::GUI::Projector::Controller;
|
|
|
-use Moo;
|
|
|
-use Wx qw(wxTheApp :id :timer);
|
|
|
-use Wx::Event qw(EVT_TIMER);
|
|
|
-use Slic3r::Print::State ':steps';
|
|
|
-use Time::HiRes qw(gettimeofday tv_interval);
|
|
|
-
|
|
|
-has 'config' => (is => 'ro', required => 1);
|
|
|
-has 'config2' => (is => 'ro', required => 1);
|
|
|
-has 'screen' => (is => 'ro', required => 1);
|
|
|
-has 'on_project_layer' => (is => 'rw');
|
|
|
-has 'on_print_completed' => (is => 'rw');
|
|
|
-has 'sender' => (is => 'rw');
|
|
|
-has 'timer' => (is => 'rw');
|
|
|
-has 'is_printing' => (is => 'rw', default => sub { 0 });
|
|
|
-has '_print' => (is => 'rw');
|
|
|
-has '_layers' => (is => 'rw');
|
|
|
-has '_heights' => (is => 'rw');
|
|
|
-has '_layer_num' => (is => 'rw');
|
|
|
-has '_timer_cb' => (is => 'rw');
|
|
|
-
|
|
|
-sub BUILD {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- Slic3r::GUI::disable_screensaver();
|
|
|
-
|
|
|
- $self->set_print(wxTheApp->{mainframe}->{plater}->{print});
|
|
|
-
|
|
|
- # projection timer
|
|
|
- my $timer_id = &Wx::NewId();
|
|
|
- $self->timer(Wx::Timer->new($self->screen, $timer_id));
|
|
|
- EVT_TIMER($self->screen, $timer_id, sub {
|
|
|
- my $cb = $self->_timer_cb;
|
|
|
- $self->_timer_cb(undef);
|
|
|
- $cb->();
|
|
|
- });
|
|
|
-}
|
|
|
-
|
|
|
-sub delay {
|
|
|
- my ($self, $wait, $cb) = @_;
|
|
|
-
|
|
|
- $self->_timer_cb($cb);
|
|
|
- $self->timer->Start($wait * 1000, wxTIMER_ONE_SHOT);
|
|
|
-}
|
|
|
-
|
|
|
-sub set_print {
|
|
|
- my ($self, $print) = @_;
|
|
|
-
|
|
|
- # make sure layers were sliced
|
|
|
- {
|
|
|
- my $progress_dialog;
|
|
|
- foreach my $object (@{$print->objects}) {
|
|
|
- next if $object->step_done(STEP_SLICE);
|
|
|
- $progress_dialog //= Wx::ProgressDialog->new('Slicing…', "Processing layers…", 100, undef, 0);
|
|
|
- $progress_dialog->Pulse;
|
|
|
- $object->slice;
|
|
|
- }
|
|
|
- $progress_dialog->Destroy if $progress_dialog;
|
|
|
- }
|
|
|
-
|
|
|
- $self->_print($print);
|
|
|
-
|
|
|
- # sort layers by Z
|
|
|
- my %layers = ();
|
|
|
- foreach my $layer (map { @{$_->layers}, @{$_->support_layers} } @{$print->objects}) {
|
|
|
- my $height = $layer->print_z;
|
|
|
- $layers{$height} //= [];
|
|
|
- push @{$layers{$height}}, $layer;
|
|
|
- }
|
|
|
- $self->_layers({ %layers });
|
|
|
- $self->_heights([ sort { $a <=> $b } keys %layers ]);
|
|
|
-}
|
|
|
-
|
|
|
-sub layer_count {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- return scalar @{$self->_heights};
|
|
|
-}
|
|
|
-
|
|
|
-sub current_layer_height {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- return $self->_heights->[$self->_layer_num];
|
|
|
-}
|
|
|
-
|
|
|
-sub start_print {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- {
|
|
|
- $self->sender(Slic3r::GCode::Sender->new);
|
|
|
- my $res = $self->sender->connect(
|
|
|
- $self->config->serial_port,
|
|
|
- $self->config->serial_speed,
|
|
|
- );
|
|
|
- if (!$res || !$self->sender->wait_connected) {
|
|
|
- Slic3r::GUI::show_error(undef, "Connection failed. Check serial port and speed.");
|
|
|
- return;
|
|
|
- }
|
|
|
- Slic3r::debugf "connected to " . $self->config->serial_port . "\n";
|
|
|
-
|
|
|
- # send custom start G-code
|
|
|
- $self->sender->send($_, 1) for grep !/^;/, split /\n/, $self->config->start_gcode;
|
|
|
- }
|
|
|
-
|
|
|
- $self->is_printing(1);
|
|
|
-
|
|
|
- # TODO: block until the G1 command has been performed
|
|
|
- # we could do this with M400 + M115 but maybe it's not portable
|
|
|
- $self->delay(5, sub {
|
|
|
- # start with black
|
|
|
- Slic3r::debugf "starting black projection\n";
|
|
|
- $self->_layer_num(-1);
|
|
|
- $self->screen->project_layers(undef);
|
|
|
- $self->delay($self->config2->{settle_time}, sub {
|
|
|
- $self->project_next_layer;
|
|
|
- });
|
|
|
- });
|
|
|
-}
|
|
|
-
|
|
|
-sub stop_print {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- if ($self->sender) {
|
|
|
- $self->sender->disconnect;
|
|
|
- }
|
|
|
-
|
|
|
- $self->is_printing(0);
|
|
|
- $self->timer->Stop;
|
|
|
- $self->_timer_cb(undef);
|
|
|
- $self->screen->project_layers(undef);
|
|
|
-}
|
|
|
-
|
|
|
-sub print_completed {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- # send custom end G-code
|
|
|
- if ($self->sender) {
|
|
|
- $self->sender->send($_, 1) for grep !/^;/, split /\n/, $self->config->end_gcode;
|
|
|
- }
|
|
|
-
|
|
|
- # call this before the on_print_completed callback otherwise buttons
|
|
|
- # won't be updated correctly
|
|
|
- $self->stop_print;
|
|
|
-
|
|
|
- $self->on_print_completed->()
|
|
|
- if $self->is_printing && $self->on_print_completed;
|
|
|
-}
|
|
|
-
|
|
|
-sub is_projecting {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- return defined $self->screen->layers;
|
|
|
-}
|
|
|
-
|
|
|
-sub project_layer {
|
|
|
- my ($self, $layer_num) = @_;
|
|
|
-
|
|
|
- if (!defined $layer_num || $layer_num >= $self->layer_count) {
|
|
|
- $self->screen->project_layers(undef);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- my @layers = @{ $self->_layers->{ $self->_heights->[$layer_num] } };
|
|
|
- $self->screen->project_layers([ @layers ]);
|
|
|
-}
|
|
|
-
|
|
|
-sub project_next_layer {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- $self->_layer_num($self->_layer_num + 1);
|
|
|
- Slic3r::debugf "projecting layer %d\n", $self->_layer_num;
|
|
|
- if ($self->_layer_num >= $self->layer_count) {
|
|
|
- $self->print_completed;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- $self->on_project_layer->($self->_layer_num) if $self->on_project_layer;
|
|
|
-
|
|
|
- if ($self->sender) {
|
|
|
- my $z = $self->current_layer_height + $self->config->z_offset;
|
|
|
- my $F = $self->config2->{z_lift_speed} * 60;
|
|
|
- if ($self->config2->{z_lift} != 0) {
|
|
|
- $self->sender->send(sprintf("G1 Z%.5f F%d", $z + $self->config2->{z_lift}, $F), 1);
|
|
|
- }
|
|
|
- $self->sender->send(sprintf("G1 Z%.5f F%d", $z, $F), 1);
|
|
|
- }
|
|
|
-
|
|
|
- # TODO: we should block until G1 commands have been performed, see note below
|
|
|
- $self->delay($self->config2->{settle_time}, sub {
|
|
|
- $self->project_layer($self->_layer_num);
|
|
|
-
|
|
|
- # get exposure time
|
|
|
- my $time = $self->config2->{exposure_time};
|
|
|
- if ($self->_layer_num < $self->config2->{bottom_layers}) {
|
|
|
- $time = $self->config2->{bottom_exposure_time};
|
|
|
- }
|
|
|
-
|
|
|
- $self->delay($time, sub {
|
|
|
- $self->screen->project_layers(undef);
|
|
|
- $self->project_next_layer;
|
|
|
- });
|
|
|
- });
|
|
|
-}
|
|
|
-
|
|
|
-sub remaining_print_time {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- my $remaining_layers = @{$self->_heights} - $self->_layer_num;
|
|
|
- my $remaining_bottom_layers = $self->_layer_num >= $self->config2->{bottom_layers}
|
|
|
- ? 0
|
|
|
- : $self->config2->{bottom_layers} - $self->_layer_num;
|
|
|
-
|
|
|
- return $remaining_bottom_layers * $self->config2->{bottom_exposure_time}
|
|
|
- + ($remaining_layers - $remaining_bottom_layers) * $self->config2->{exposure_time}
|
|
|
- + $remaining_layers * $self->config2->{settle_time};
|
|
|
-}
|
|
|
-
|
|
|
-sub print_time {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- return $self->config2->{bottom_layers} * $self->config2->{bottom_exposure_time}
|
|
|
- + (@{$self->_heights} - $self->config2->{bottom_layers}) * $self->config2->{exposure_time}
|
|
|
- + @{$self->_heights} * $self->config2->{settle_time};
|
|
|
-}
|
|
|
-
|
|
|
-sub DESTROY {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- $self->timer->Stop if $self->timer;
|
|
|
- $self->sender->disconnect if $self->sender;
|
|
|
- Slic3r::GUI::enable_screensaver();
|
|
|
-}
|
|
|
-
|
|
|
-package Slic3r::GUI::Projector::Screen;
|
|
|
-use Wx qw(:dialog :id :misc :sizer :colour :pen :brush :font wxBG_STYLE_CUSTOM);
|
|
|
-use Wx::Event qw(EVT_PAINT EVT_SIZE);
|
|
|
-use base qw(Wx::Dialog Class::Accessor);
|
|
|
-
|
|
|
-use List::Util qw(min);
|
|
|
-use Slic3r::Geometry qw(X Y unscale scale);
|
|
|
-use Slic3r::Geometry::Clipper qw(intersection_pl);
|
|
|
-
|
|
|
-__PACKAGE__->mk_accessors(qw(config config2 scaling_factor bed_origin layers));
|
|
|
-
|
|
|
-sub new {
|
|
|
- my ($class, $parent, $config, $config2) = @_;
|
|
|
- my $self = $class->SUPER::new($parent, -1, "Projector", wxDefaultPosition, wxDefaultSize, 0);
|
|
|
-
|
|
|
- $self->config($config);
|
|
|
- $self->config2($config2);
|
|
|
- $self->SetBackgroundStyle(wxBG_STYLE_CUSTOM);
|
|
|
- EVT_SIZE($self, \&_resize);
|
|
|
- EVT_PAINT($self, \&_repaint);
|
|
|
- $self->_resize;
|
|
|
-
|
|
|
- return $self;
|
|
|
-}
|
|
|
-
|
|
|
-sub reposition {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- my $display = Wx::Display->new($self->config2->{display});
|
|
|
- my $area = $display->GetGeometry;
|
|
|
- $self->Move($area->GetPosition);
|
|
|
- # ShowFullScreen doesn't use the right screen
|
|
|
- #$self->ShowFullScreen($self->config2->{fullscreen});
|
|
|
- $self->SetSize($area->GetSize);
|
|
|
- $self->_resize;
|
|
|
- $self->Refresh;
|
|
|
-}
|
|
|
-
|
|
|
-sub _resize {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- return if !$self->config;
|
|
|
- my ($cw, $ch) = $self->GetSizeWH;
|
|
|
-
|
|
|
- # get bed shape polygon
|
|
|
- my $bed_polygon = Slic3r::Polygon->new_scale(@{$self->config->bed_shape});
|
|
|
- my $bb = $bed_polygon->bounding_box;
|
|
|
- my $size = $bb->size;
|
|
|
- my $center = $bb->center;
|
|
|
-
|
|
|
- # calculate the scaling factor needed for constraining print bed area inside preview
|
|
|
- # scaling_factor is expressed in pixel / mm
|
|
|
- $self->scaling_factor(min($cw / unscale($size->x), $ch / unscale($size->y))); #)
|
|
|
-
|
|
|
- # apply zoom to scaling factor
|
|
|
- if ($self->config2->{zoom} != 0) {
|
|
|
- # TODO: make sure min and max in the option config are enforced
|
|
|
- $self->scaling_factor($self->scaling_factor * ($self->config2->{zoom}/100));
|
|
|
- }
|
|
|
-
|
|
|
- # calculate the displacement needed for centering bed on screen
|
|
|
- $self->bed_origin([
|
|
|
- $cw/2 - (unscale($center->x) - $self->config2->{offset}->[X]) * $self->scaling_factor,
|
|
|
- $ch/2 - (unscale($center->y) - $self->config2->{offset}->[Y]) * $self->scaling_factor, #))
|
|
|
- ]);
|
|
|
-
|
|
|
- $self->Refresh;
|
|
|
-}
|
|
|
-
|
|
|
-sub project_layers {
|
|
|
- my ($self, $layers) = @_;
|
|
|
-
|
|
|
- $self->layers($layers);
|
|
|
- $self->Refresh;
|
|
|
-}
|
|
|
-
|
|
|
-sub _repaint {
|
|
|
- my ($self) = @_;
|
|
|
-
|
|
|
- my $dc = Wx::AutoBufferedPaintDC->new($self);
|
|
|
- my ($cw, $ch) = $self->GetSizeWH;
|
|
|
- return if $cw == 0; # when canvas is not rendered yet, size is 0,0
|
|
|
-
|
|
|
- $dc->SetPen(Wx::Pen->new(wxBLACK, 1, wxSOLID));
|
|
|
- $dc->SetBrush(Wx::Brush->new(wxBLACK, wxSOLID));
|
|
|
- $dc->DrawRectangle(0, 0, $cw, $ch);
|
|
|
-
|
|
|
- return if !$self->config;
|
|
|
-
|
|
|
- # turn size into max visible coordinates
|
|
|
- # TODO: or should we use ClientArea?
|
|
|
- $cw--;
|
|
|
- $ch--;
|
|
|
-
|
|
|
- # draw bed
|
|
|
- if ($self->config2->{show_bed}) {
|
|
|
- $dc->SetPen(Wx::Pen->new(wxRED, 2, wxSOLID));
|
|
|
- $dc->SetBrush(Wx::Brush->new(wxWHITE, wxTRANSPARENT));
|
|
|
-
|
|
|
- # draw contour
|
|
|
- my $bed_polygon = Slic3r::Polygon->new_scale(@{$self->config->bed_shape});
|
|
|
- $dc->DrawPolygon($self->scaled_points_to_pixel($bed_polygon), 0, 0);
|
|
|
-
|
|
|
- # draw grid
|
|
|
- $dc->SetPen(Wx::Pen->new(wxRED, 1, wxSOLID));
|
|
|
- {
|
|
|
- my $bb = $bed_polygon->bounding_box;
|
|
|
- my $step = scale 10; # 1cm grid
|
|
|
- my @polylines = ();
|
|
|
- for (my $x = $bb->x_min - ($bb->x_min % $step) + $step; $x < $bb->x_max; $x += $step) {
|
|
|
- push @polylines, Slic3r::Polyline->new([$x, $bb->y_min], [$x, $bb->y_max]);
|
|
|
- }
|
|
|
- for (my $y = $bb->y_min - ($bb->y_min % $step) + $step; $y < $bb->y_max; $y += $step) {
|
|
|
- push @polylines, Slic3r::Polyline->new([$bb->x_min, $y], [$bb->x_max, $y]);
|
|
|
- }
|
|
|
- $dc->DrawLine(map @$_, @$_)
|
|
|
- for map $self->scaled_points_to_pixel([ @$_[0,-1] ]),
|
|
|
- @{intersection_pl(\@polylines, [$bed_polygon])};
|
|
|
- }
|
|
|
-
|
|
|
- # draw axes orientation
|
|
|
- $dc->SetPen(Wx::Pen->new(wxWHITE, 4, wxSOLID));
|
|
|
- {
|
|
|
- foreach my $endpoint ([10, 0], [0, 10]) {
|
|
|
- $dc->DrawLine(
|
|
|
- map @{$self->unscaled_point_to_pixel($_)}, [0,0], $endpoint
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- $dc->SetTextForeground(wxWHITE);
|
|
|
- $dc->SetFont(Wx::Font->new(20, wxDEFAULT, wxNORMAL, wxNORMAL));
|
|
|
- $dc->DrawText("X", @{$self->unscaled_point_to_pixel([10, -2])});
|
|
|
- $dc->DrawText("Y", @{$self->unscaled_point_to_pixel([-2, 10])});
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return if !defined $self->layers;
|
|
|
-
|
|
|
- # get layers at this height
|
|
|
- # draw layers
|
|
|
- $dc->SetPen(Wx::Pen->new(wxWHITE, 1, wxSOLID));
|
|
|
- foreach my $layer (@{$self->layers}) {
|
|
|
- my @polygons = sort { $a->contains_point($b->first_point) ? -1 : 1 } map @$_, @{ $layer->slices };
|
|
|
- foreach my $copy (@{$layer->object->_shifted_copies}) {
|
|
|
- foreach my $polygon (@polygons) {
|
|
|
- $polygon = $polygon->clone;
|
|
|
- $polygon->translate(@$copy);
|
|
|
-
|
|
|
- if ($polygon->is_counter_clockwise) {
|
|
|
- $dc->SetBrush(Wx::Brush->new(wxWHITE, wxSOLID));
|
|
|
- } else {
|
|
|
- $dc->SetBrush(Wx::Brush->new(wxBLACK, wxSOLID));
|
|
|
- }
|
|
|
- $dc->DrawPolygon($self->scaled_points_to_pixel($polygon->pp), 0, 0);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-# convert a model coordinate into a pixel coordinate
|
|
|
-sub unscaled_point_to_pixel {
|
|
|
- my ($self, $point) = @_;
|
|
|
-
|
|
|
- my $zero = $self->bed_origin;
|
|
|
- my $p = [
|
|
|
- $point->[X] * $self->scaling_factor + $zero->[X],
|
|
|
- $point->[Y] * $self->scaling_factor + $zero->[Y],
|
|
|
- ];
|
|
|
-
|
|
|
- if (!$self->config2->{invert_y}) {
|
|
|
- my $ch = $self->GetSize->GetHeight;
|
|
|
- $p->[Y] = $ch - $p->[Y];
|
|
|
- }
|
|
|
-
|
|
|
- return $p;
|
|
|
-}
|
|
|
-
|
|
|
-sub scaled_points_to_pixel {
|
|
|
- my ($self, $points) = @_;
|
|
|
-
|
|
|
- return [
|
|
|
- map $self->unscaled_point_to_pixel($_),
|
|
|
- map Slic3r::Pointf->new_unscale(@$_),
|
|
|
- @$points
|
|
|
- ];
|
|
|
-}
|
|
|
-
|
|
|
-1;
|
bubnikv
