From 948b43fe0d820c4f1b97443c28a55803c81c8724 Mon Sep 17 00:00:00 2001 From: Alessandro Ranellucci Date: Mon, 29 Jul 2013 11:05:04 +0200 Subject: [PATCH] Don't try to align rectilinear infill if solid, otherwise there will be a gap at one side --- lib/Slic3r/ExPolygon.pm | 8 ++++ lib/Slic3r/Fill.pm | 1 - lib/Slic3r/Fill/Rectilinear.pm | 87 +++++++++++++++------------------- t/fill.t | 27 ++++++++++- 4 files changed, 73 insertions(+), 50 deletions(-) diff --git a/lib/Slic3r/ExPolygon.pm b/lib/Slic3r/ExPolygon.pm index 610751a62..bd5ed4e3f 100644 --- a/lib/Slic3r/ExPolygon.pm +++ b/lib/Slic3r/ExPolygon.pm @@ -173,6 +173,14 @@ sub translate { $self; } +sub align_to_origin { + my $self = shift; + + my $bb = $self->bounding_box; + $self->translate(-$bb->x_min, -$bb->y_min); + $self; +} + sub rotate { my $self = shift; $_->rotate(@_) for @$self; diff --git a/lib/Slic3r/Fill.pm b/lib/Slic3r/Fill.pm index 5270c7250..143dc905b 100644 --- a/lib/Slic3r/Fill.pm +++ b/lib/Slic3r/Fill.pm @@ -165,7 +165,6 @@ sub make_fill { $surface, density => $density, flow_spacing => $flow_spacing, - dont_adjust => $is_bridge, ); } my $params = shift @paths; diff --git a/lib/Slic3r/Fill/Rectilinear.pm b/lib/Slic3r/Fill/Rectilinear.pm index 08bbee21f..c58b3871a 100644 --- a/lib/Slic3r/Fill/Rectilinear.pm +++ b/lib/Slic3r/Fill/Rectilinear.pm @@ -5,7 +5,7 @@ extends 'Slic3r::Fill::Base'; has 'cache' => (is => 'rw', default => sub {{}}); -use Slic3r::Geometry qw(A B X Y scale unscale scaled_epsilon); +use Slic3r::Geometry qw(A B X Y MIN scale unscale scaled_epsilon); sub fill_surface { my $self = shift; @@ -16,72 +16,63 @@ sub fill_surface { my $rotate_vector = $self->infill_direction($surface); $self->rotate_points($expolygon, $rotate_vector); - my ($expolygon_off) = $expolygon->offset_ex(scale $params{flow_spacing}/2); - return {} if !$expolygon_off; # skip some very small polygons (which shouldn't arrive here) + my $flow_spacing = $params{flow_spacing}; + my $min_spacing = scale $params{flow_spacing}; + my $line_spacing = $min_spacing / $params{density}; + my $line_oscillation = $line_spacing - $min_spacing; + my $is_line_pattern = $self->isa('Slic3r::Fill::Line'); + my $bounding_box = $expolygon->bounding_box; - my $flow_spacing = $params{flow_spacing}; - my $min_spacing = scale $params{flow_spacing}; - my $distance_between_lines = $min_spacing / $params{density}; - my $line_oscillation = $distance_between_lines - $min_spacing; - my $is_line_pattern = $self->isa('Slic3r::Fill::Line'); + # define flow spacing according to requested density + if ($params{density} == 1 && !$params{dont_adjust}) { + $line_spacing = $self->adjust_solid_spacing( + width => $bounding_box->size->[X], + distance => $line_spacing, + ); + $flow_spacing = unscale $line_spacing; + } else { + # extend bounding box so that our pattern will be aligned with other layers + # $bounding_box->[X1] and [Y1] represent the displacement between new bounding box offset and old one + $bounding_box->extents->[X][MIN] -= $bounding_box->x_min; + $bounding_box->extents->[Y][MIN] -= $bounding_box->y_min; + } - my $cache_id = sprintf "d%s_s%.2f_a%.2f", - $params{density}, $params{flow_spacing}, $rotate_vector->[0][0]; - - if (!$self->cache->{$cache_id}) { - # compute bounding box - my $bounding_box; - { - my $bb_polygon = $self->bounding_box->polygon; - $bb_polygon->scale(sqrt 2); - $self->rotate_points($bb_polygon, $rotate_vector); - $bounding_box = $bb_polygon->bounding_box; + # generate the basic pattern + my $i = 0; + my $x = $bounding_box->x_min; + my $x_max = $bounding_box->x_max + scaled_epsilon; + my @vertical_lines = (); + while ($x <= $x_max) { + my $vertical_line = Slic3r::Line->new([$x, $bounding_box->y_max], [$x, $bounding_box->y_min]); + if ($is_line_pattern && $i % 2) { + $vertical_line->[A][X] += $line_oscillation; + $vertical_line->[B][X] -= $line_oscillation; } - - # define flow spacing according to requested density - if ($params{density} == 1 && !$params{dont_adjust}) { - $distance_between_lines = $self->adjust_solid_spacing( - width => $bounding_box->size->[X], - distance => $distance_between_lines, - ); - $flow_spacing = unscale $distance_between_lines; - } - - # generate the basic pattern - my $x = $bounding_box->x_min; - my @vertical_lines = (); - for (my $i = 0; $x <= $bounding_box->x_max + scaled_epsilon; $i++) { - my $vertical_line = Slic3r::Line->new([$x, $bounding_box->y_max], [$x, $bounding_box->y_min]); - if ($is_line_pattern && $i % 2) { - $vertical_line->[A][X] += $line_oscillation; - $vertical_line->[B][X] -= $line_oscillation; - } - push @vertical_lines, $vertical_line; - $x += $distance_between_lines; - } - - $self->cache->{$cache_id} = [@vertical_lines]; + push @vertical_lines, $vertical_line; + $i++; + $x += $line_spacing; } # clip paths against a slightly offsetted expolygon, so that the first and last paths # are kept even if the expolygon has vertical sides - my @paths = @{ Boost::Geometry::Utils::polygon_multi_linestring_intersection( - +($expolygon->offset_ex(scaled_epsilon))[0], # TODO: we should use all the resulting expolygons and clip the linestrings to a multipolygon object - [ @{ $self->cache->{$cache_id} } ], + my @paths = @{ Boost::Geometry::Utils::multi_polygon_multi_linestring_intersection( + [ $expolygon->offset_ex(scaled_epsilon) ], + [ @vertical_lines ], ) }; # connect lines unless ($params{dont_connect}) { + my ($expolygon_off) = $expolygon->offset_ex(scale $params{flow_spacing}/2); my $collection = Slic3r::Polyline::Collection->new( polylines => [ map Slic3r::Polyline->new(@$_), @paths ], ); @paths = (); my $tolerance = 10 * scaled_epsilon; - my $diagonal_distance = $distance_between_lines * 2; + my $diagonal_distance = $line_spacing * 2; my $can_connect = $is_line_pattern ? sub { - ($_[X] >= ($distance_between_lines - $line_oscillation) - $tolerance) && ($_[X] <= ($distance_between_lines + $line_oscillation) + $tolerance) + ($_[X] >= ($line_spacing - $line_oscillation) - $tolerance) && ($_[X] <= ($line_spacing + $line_oscillation) + $tolerance) && $_[Y] <= $diagonal_distance } : sub { $_[X] <= $diagonal_distance && $_[Y] <= $diagonal_distance }; diff --git a/t/fill.t b/t/fill.t index 28c2509bd..9c7cbabe9 100644 --- a/t/fill.t +++ b/t/fill.t @@ -2,7 +2,7 @@ use Test::More; use strict; use warnings; -plan tests => 10; +plan tests => 11; BEGIN { use FindBin; @@ -11,6 +11,7 @@ BEGIN { use Slic3r; use Slic3r::Geometry qw(scale X Y); +use Slic3r::Geometry::Clipper qw(diff_ex); use Slic3r::Surface qw(:types); use Slic3r::Test; @@ -48,6 +49,30 @@ sub scale_points (@) { map [scale $_->[X], scale $_->[Y]], @_ } } } +{ + my $expolygon = Slic3r::ExPolygon->new([ + [6883102, 9598327.01296997], + [6883102, 20327272.01297], + [3116896, 20327272.01297], + [3116896, 9598327.01296997], + ]); + $expolygon->align_to_origin; + my $filler = Slic3r::Fill::Rectilinear->new( + bounding_box => $expolygon->bounding_box, + angle => 0, + ); + my $surface = Slic3r::Surface->new( + surface_type => S_TYPE_BOTTOM, + expolygon => $expolygon, + ); + my ($params, @paths) = $filler->fill_surface($surface, flow_spacing => 0.55, density => 1); + + # check whether any part was left uncovered + my @grown_paths = map Slic3r::Polyline->new(@$_)->grow(scale $params->{flow_spacing}/2), @paths; + my $uncovered = diff_ex([ @$expolygon ], [ @grown_paths ]); + is scalar(@$uncovered), 0, 'solid surface is fully filled'; +} + { my $collection = Slic3r::Polyline::Collection->new(polylines => [ Slic3r::Polyline->new([0,15], [0,18], [0,20]),