GitHub-Proxy/Slic3r
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/slic3r/Slic3r.git synced 2025-09-24 08:43:14 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

WX::Panel layer height spline representation and control element

Browse Source
This commit is contained in:
Florens Wasserfall 2017-01-26 08:51:44 +01:00
parent 97f4301398
commit 7293f56f9b
1 changed files with 99 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

209
lib/Slic3r/GUI/Plater/SplineControl.pm
View File

@ -12,37 +12,50 @@ use base 'Wx::Panel';
sub new { sub new {
my $class = shift; my $class = shift;
my ($parent, $size) = @_; my ($parent, $size, $object) = @_;
my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, $size, wxTAB_TRAVERSAL); my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, $size, wxTAB_TRAVERSAL);
$self->{object} = $object;
# This has only effect on MacOS. On Windows and Linux/GTK, the background is painted by $self->repaint(). # This has only effect on MacOS. On Windows and Linux/GTK, the background is painted by $self->repaint().
$self->SetBackgroundColour(Wx::wxWHITE); $self->SetBackgroundColour(Wx::wxWHITE);
$self->{line_pen} = Wx::Pen->new(Wx::Colour->new(50,50,50), 1, wxSOLID); $self->{line_pen} = Wx::Pen->new(Wx::Colour->new(50,50,50), 1, wxSOLID);
$self->{original_pen} = Wx::Pen->new(Wx::Colour->new(200,200,200), 1, wxSOLID);
$self->{interactive_pen} = Wx::Pen->new(Wx::Colour->new(255,0,0), 1, wxSOLID); $self->{interactive_pen} = Wx::Pen->new(Wx::Colour->new(255,0,0), 1, wxSOLID);
$self->{resulting_pen} = Wx::Pen->new(Wx::Colour->new(0,255,0), 1, wxSOLID); $self->{resulting_pen} = Wx::Pen->new(Wx::Colour->new(50,255,50), 1, wxSOLID);
$self->{user_drawn_background} = $^O ne 'darwin'; $self->{user_drawn_background} = $^O ne 'darwin';
$self->{scaling_factor_x} = 1; $self->{scaling_factor_x} = 1;
$self->{scaling_factor_y} = 1; $self->{scaling_factor_y} = 1;
$self->{min_layer_height} = 0.1; $self->{min_layer_height} = 0.1;
$self->{max_layer_height} = 0.4; $self->{max_layer_height} = 0.4;
$self->{object_height} = 1.0; $self->{object_height} = 1.0;
$self->{layer_points} = ();
$self->{interactive_points} = ();
$self->{resulting_points} = ();
$self->{original_layers} = $object->layer_height_spline->getOriginalLayers;
$self->{original_interpolated_layers} = $object->layer_height_spline->getInterpolatedLayers;
$self->{interpolated_layers} = $object->layer_height_spline->getInterpolatedLayers; # Initialize to current values
# initialize height vector
$self->{heights} = ();
$self->{interactive_heights} = ();
my $last_z = 0;
foreach my $z (@{$self->{original_layers}}) {
push (@{$self->{heights}}, $z - $last_z);
$last_z = $z;
}
EVT_PAINT($self, \&repaint); EVT_PAINT($self, \&repaint);
EVT_ERASE_BACKGROUND($self, sub {}) if $self->{user_drawn_background}; EVT_ERASE_BACKGROUND($self, sub {}) if $self->{user_drawn_background};
EVT_MOUSE_EVENTS($self, \&mouse_event); EVT_MOUSE_EVENTS($self, \&mouse_event);
EVT_SIZE($self, sub { EVT_SIZE($self, sub {
$self->update_canvas_size; $self->_update_canvas_size;
$self->Refresh; $self->Refresh;
}); });
return $self; return $self;
} }
@ -71,14 +84,14 @@ sub repaint {
$dc->SetFont(Wx::Font->new(10, wxDEFAULT, wxNORMAL, wxNORMAL)); $dc->SetFont(Wx::Font->new(10, wxDEFAULT, wxNORMAL, wxNORMAL));
$dc->DrawLabel(sprintf('%.4g', $self->{min_layer_height}), Wx::Rect->new(0, $size[1]/2, $size[0], $size[1]/2), wxALIGN_LEFT | wxALIGN_BOTTOM); $dc->DrawLabel(sprintf('%.4g', $self->{min_layer_height}), Wx::Rect->new(0, $size[1]/2, $size[0], $size[1]/2), wxALIGN_LEFT | wxALIGN_BOTTOM);
$dc->DrawLabel(sprintf('%.4g', $self->{max_layer_height}), Wx::Rect->new(0, $size[1]/2, $size[0], $size[1]/2), wxALIGN_RIGHT | wxALIGN_BOTTOM); $dc->DrawLabel(sprintf('%.4g', $self->{max_layer_height}), Wx::Rect->new(0, $size[1]/2, $size[0], $size[1]/2), wxALIGN_RIGHT | wxALIGN_BOTTOM);
# draw interpolated (user modified) layers as lines # draw original layers as lines
my $last_z = 0.0; my $last_z = 0.0;
my @points = (); my @points = ();
foreach my $z (@{$self->{interactive_points}}) { foreach my $z (@{$self->{original_interpolated_layers}}) {
my $layer_h = $z - $last_z; my $layer_h = $z - $last_z;
$dc->SetPen($self->{interactive_pen}); $dc->SetPen($self->{original_pen});
my $pl = $self->point_to_pixel(0, $z); my $pl = $self->point_to_pixel(0, $z);
my $pr = $self->point_to_pixel($layer_h, $z); my $pr = $self->point_to_pixel($layer_h, $z);
$dc->DrawLine($pl->x, $pl->y, $pr->x, $pr->y); $dc->DrawLine($pl->x, $pl->y, $pr->x, $pr->y);
@ -86,27 +99,30 @@ sub repaint {
$last_z = $z; $last_z = $z;
} }
$dc->DrawSpline(\@points); $dc->DrawSpline(\@points);
# draw current layers as lines # # draw interactive (user modified) layers as lines
$last_z = 0.0; $last_z = 0.0;
@points = (); @points = ();
foreach my $z (@{$self->{layer_points}}) { if($self->{interactive_heights}) {
my $layer_h = $z - $last_z; foreach my $i (0..@{$self->{interactive_heights}}-1) {
$dc->SetPen($self->{line_pen}); my $z = $self->{original_layers}[$i];
my $pl = $self->point_to_pixel(0, $z); my $layer_h = $self->{interactive_heights}[$i];
my $pr = $self->point_to_pixel($layer_h, $z); $dc->SetPen($self->{interactive_pen});
$dc->DrawLine($pl->x, $pl->y, $pr->x, $pr->y); my $pl = $self->point_to_pixel(0, $z);
push (@points, $pr); my $pr = $self->point_to_pixel($layer_h, $z);
$last_z = $z; $dc->DrawLine($pl->x, $pl->y, $pr->x, $pr->y);
push (@points, $pr);
}
$dc->DrawSpline(\@points);
} }
$dc->DrawSpline(\@points);
# draw resulting layers as lines # draw resulting layers as lines
$last_z = 0.0; $last_z = 0.0;
@points = (); @points = ();
foreach my $z (@{$self->{resulting_points}}) { foreach my $z (@{$self->{interpolated_layers}}) {
my $layer_h = $z - $last_z; my $layer_h = $z - $last_z;
$dc->SetPen($self->{resulting_pen}); $dc->SetPen($self->{resulting_pen});
my $pl = $self->point_to_pixel(0, $z); my $pl = $self->point_to_pixel(0, $z);
@ -116,7 +132,20 @@ sub repaint {
$last_z = $z; $last_z = $z;
} }
$dc->DrawSpline(\@points); # $dc->DrawSpline(\@points);
# Draw current BSpline
$dc->SetPen($self->{line_pen});
@points = ();
foreach my $pixel (0..$size[1]) {
my @z = $self->pixel_to_point(Wx::Point->new(0, $pixel));
#print "z: " . $z . "\n";
my $h = $self->{object}->layer_height_spline->getLayerHeightAt($z[1]);
my $p = $self->point_to_pixel($h, $z[1]);
push (@points, $p);
#print "pixel: " . $pixel . "\n";
}
$dc->DrawLines(\@points);
$event->Skip; $event->Skip;
} }
@ -134,19 +163,26 @@ sub mouse_event {
} }
} elsif ($event->LeftUp) { } elsif ($event->LeftUp) {
if($self->{drag_start_pos}) { if($self->{drag_start_pos}) {
$self->{resulting_points} = $self->{interactive_points}; if($self->{interactive_heights}) {
$self->{heights} = $self->{interactive_heights};
$self->{interactive_heights} = ();
# update spline database
$self->{object}->layer_height_spline->updateLayerHeights($self->{heights});
$self->{interpolated_layers} = $self->{object}->layer_height_spline->getInterpolatedLayers;
}
$self->Refresh; $self->Refresh;
$self->{object}->layer_height_spline->suppressUpdate;
$self->{on_layer_update}->(@{$self->{interpolated_layers}});
} }
$self->{drag_start_pos} = undef; $self->{drag_start_pos} = undef;
} elsif ($event->Dragging) { } elsif ($event->Dragging) {
print "dragging, pos: " . $pos->x . ":" . $pos->y . "\n";
return if !$self->{drag_start_pos}; # concurrency problems return if !$self->{drag_start_pos}; # concurrency problems
my @start_pos = $self->pixel_to_point($self->{drag_start_pos}); my @start_pos = $self->pixel_to_point($self->{drag_start_pos});
my $range = abs($start_pos[1] - $obj_pos[1]); my $range = abs($start_pos[1] - $obj_pos[1]);
# compute updated interactive layer heights # compute updated interactive layer heights
$self->interactive_curve($start_pos[1], $obj_pos[0], $range); $self->_interactive_curve($start_pos[1], $obj_pos[0], $range);
$self->Refresh; $self->Refresh;
}# elsif ($event->Moving) { }# elsif ($event->Moving) {
@ -158,8 +194,29 @@ sub mouse_event {
# } # }
} }
# Set basic parameters for this control.
# min/max_layer_height are required to define the x-range, object_height is used to scale the y-range.
# Must be called if object selection changes.
sub set_size_parameters {
my ($self, $min_layer_height, $max_layer_height, $object_height) = @_;
$self->{min_layer_height} = $min_layer_height;
$self->{max_layer_height} = $max_layer_height;
$self->{object_height} = $object_height;
$self->_update_canvas_size;
$self->Refresh;
}
# Callback to notify parent element if layers have changed and reslicing should be triggered
sub on_layer_update {
my ($self, $cb) = @_;
$self->{on_layer_update} = $cb;
}
# Internal function to cache scaling factors # Internal function to cache scaling factors
sub update_canvas_size { sub _update_canvas_size {
my $self = shift; my $self = shift;
# when the canvas is not rendered yet, its GetSize() method returns 0,0 # when the canvas is not rendered yet, its GetSize() method returns 0,0
@ -174,89 +231,23 @@ sub update_canvas_size {
$self->{scaling_factor_y} = $size[1]/$self->{object_height}; $self->{scaling_factor_y} = $size[1]/$self->{object_height};
} }
# Set basic parameters for this control. sub _interactive_curve {
# min/max_layer_height are required to define the x-range, object_height is used to scale the y-range.
# Must be called if object selection changes.
sub set_size_parameters {
my ($self, $min_layer_height, $max_layer_height, $object_height) = @_;
$self->{min_layer_height} = $min_layer_height;
$self->{max_layer_height} = $max_layer_height;
$self->{object_height} = $object_height;
$self->update_canvas_size;
$self->Refresh;
}
# Set the current layer height values as basis for user manipulation
sub set_layer_points {
my ($self, @layer_points) = @_;
$self->{layer_points} = [@layer_points];
$self->{interactive_points} = [@layer_points]; # Initialize to current values
$self->{resulting_points} = [@layer_points]; # Initialize to current values
$self->Refresh;
}
sub interactive_curve {
my ($self, $mod_z, $target_layer_height, $range) = @_; my ($self, $mod_z, $target_layer_height, $range) = @_;
$self->{interactive_points} = (); # reset interactive curve $self->{interactive_heights} = (); # reset interactive curve
my $z = 0.0; # iterate over original points provided by spline
my $layer_h = $self->{resulting_points}[0]; my $last_z = 0;
my $i = 0; foreach my $i (0..@{$self->{heights}}-1 ) {
# copy points which are not going to be modified my $z = $self->{original_layers}[$i];
while(($z+$self->{resulting_points}[$i] < $mod_z-$range) && ($i < @{$self->{resulting_points}})) { my $layer_h = $self->{heights}[$i];
$layer_h = $self->{resulting_points}[$i] - $z; my $quadratic_factor = $self->_quadratic_factor($mod_z, $range, $z);
$z = $self->{resulting_points}[$i]; my $diff = $target_layer_height - $layer_h;
push (@{$self->{interactive_points}}, $z); $layer_h += $diff * $quadratic_factor;
$i +=1; push (@{$self->{interactive_heights}}, $layer_h);
} }
print "last original z: " . $z . "\n";
# interpolate next points
while($z < $self->{object_height}) {
$layer_h = $self->_interpolate_next_layer_h($z);
my $diff = $target_layer_height - $layer_h;
my $quadratic_factor = $self->_quadratic_factor($mod_z, $range, $z+$layer_h);
$layer_h += $diff * $quadratic_factor;
$z += $layer_h;
push (@{$self->{interactive_points}}, $z);
}
# remove top layer if n-1 is higher than object_height!!!
} }
sub _interpolate_next_layer_h {
my ($self, $z) = @_;
my $layer_h = $self->{resulting_points}[0];
my $array_size = @{$self->{resulting_points}};
my $i = 1;
# find current layer
while(($self->{resulting_points}[$i] <= $z) && ($array_size-1 > $i)) {
$i += 1;
}
if($i == 1) {return $layer_h}; # first layer, nothing to interpolate
$layer_h = $self->{resulting_points}[$i] - $self->{resulting_points}[$i-1];
my $tmp = $layer_h;
# interpolate
if($array_size-1 > $i) {
my $next_layer_h = $self->{resulting_points}[$i+1] - $self->{resulting_points}[$i];
$layer_h = $layer_h * ($self->{resulting_points}[$i] - $z)/$layer_h + $next_layer_h * min(1, ($z+$layer_h-$self->{resulting_points}[$i])/$next_layer_h);
}
# if(abs($layer_h - $tmp) > 0.001) {
# print "z: " . $z . "\n";
# my $layer_i = $self->{resulting_points}[$i] - $self->{resulting_points}[$i-1];
# my $layer_i1 = $self->{resulting_points}[$i+1] - $self->{resulting_points}[$i];
# print "layer i: " . $layer_i . " -> " . $self->{resulting_points}[$i] . "\n";
# print "layer i+1: " . $layer_i1 . " -> " . $self->{resulting_points}[$i+1] . "\n";
# print "layer_h_1: " . $tmp . " layer_h_2: " . $layer_h . "\n\n";
# }
return $layer_h;
}
sub _quadratic_factor { sub _quadratic_factor {
my ($self, $fixpoint, $range, $value) = @_; my ($self, $fixpoint, $range, $value) = @_;
@ -268,8 +259,6 @@ sub _quadratic_factor {
my $x = $dist/$range; # normalize my $x = $dist/$range; # normalize
my $result = 1-($x*$x); my $result = 1-($x*$x);
print "fixpoint: " . $fixpoint . " range: " . $range . " value: " . $value . " result: " . $result . "\n";
return max(0, $result); return max(0, $result);
} }