Code refactored to allow for multiple infill types

lib/Slic3r.pm

@@ -53,6 +53,7 @@ our $flow_width;
 # print options
 our $perimeter_offsets  = 3;
 our $solid_layers       = 3;
+our $fill_type          = 'rectilinear';
 our $fill_density       = 0.4;  # 1 = 100%
 our $fill_angle         = 0;
 our $temperature        = 200;

lib/Slic3r/Fill.pm

@@ -1,6 +1,60 @@
 package Slic3r::Fill;
 use Moo;
 
+use Slic3r::Fill::Base;
 use Slic3r::Fill::Rectilinear;
 
+has 'print'     => (is => 'ro', required => 1);
+has 'fillers'   => (is => 'rw', default => sub { {} });
+
+our %FillTypes = (
+    rectilinear => 'Slic3r::Fill::Rectilinear',
+);
+
+sub BUILD {
+    my $self = shift;
+    $self->fillers->{$_} ||= $FillTypes{$_}->new(print => $self->print)
+        for ('rectilinear', $Slic3r::fill_type);
+}
+
+sub make_fill {
+    my $self = shift;
+    my ($layer) = @_;
+    
+    my $max_print_dimension = $self->print->max_length * sqrt(2);
+    for (values %{$self->fillers}) {
+        $_->layer($layer);
+        $_->max_print_dimension($max_print_dimension);
+    }
+    
+    printf "Filling layer %d:\n", $layer->id;
+    foreach my $surface_collection (@{ $layer->fill_surfaces }) {
+        my @path_collection = ();
+        
+        SURFACE: foreach my $surface (@{ $surface_collection->surfaces }) {
+            Slic3r::debugf " Processing surface %s:\n", $surface->id;
+            
+            my $filler = $Slic3r::fill_type;
+            my $density = $Slic3r::fill_density;
+            next SURFACE unless $density > 0;
+            
+            # force 100% density and rectilinear fill for external surfaces
+            if ($surface->surface_type ne 'internal') {
+                $density = 1;
+                $filler = 'rectilinear';
+            }
+            
+            push @path_collection, $self->fillers->{$filler}->fill_surface($surface,
+                density => $density,
+            );
+        }
+        
+        # save into layer
+        push @{ $layer->fills }, Slic3r::ExtrusionPath::Collection->new(
+            paths => [ map Slic3r::ExtrusionPath->cast([ @$_ ]), @path_collection ],
+        );
+        $layer->fills->[-1]->cleanup;
+    }
+}
+
 1;

lib/Slic3r/Fill/Base.pm

@@ -0,0 +1,56 @@
+package Slic3r::Fill::Base;
+use Moo;
+
+use XXX;
+
+has 'layer'               => (is => 'rw');
+has 'max_print_dimension' => (is => 'rw');
+
+use constant PI => 4 * atan2(1, 1);
+
+sub infill_direction {
+    my $self = shift;
+    my ($polygons) = @_;
+    
+    # set infill angle
+    my (@rotate, @shift);
+    $rotate[0] = Slic3r::Geometry::deg2rad($Slic3r::fill_angle);
+    $rotate[1] = [ $self->max_print_dimension / 2, $self->max_print_dimension / 2 ];
+    @shift = @{$rotate[1]};
+    
+    # alternate fill direction
+    if ($self->layer->id % 2) {
+        $rotate[0] = Slic3r::Geometry::deg2rad($Slic3r::fill_angle) + PI/2;
+    }
+    
+    # TODO: here we should implement an "infill in direction of bridges" option
+    
+    @shift = @{ +(Slic3r::Geometry::rotate_points(@rotate, \@shift))[0] };
+    return [\@rotate, \@shift];
+}
+
+sub rotate_points {
+    my $self = shift;
+    my ($polygons, $rotate_vector) = @_;
+    my @rotate = @{$rotate_vector->[0]};
+    my @shift  = @{$rotate_vector->[1]};
+    
+    # rotate surface as needed
+    @$polygons = map [ Slic3r::Geometry::move_points(\@shift, @$_) ],
+        map [ Slic3r::Geometry::rotate_points(@rotate, @$_) ], @$polygons if $rotate[0];
+    
+}
+
+sub rotate_points_back {
+    my $self = shift;
+    my ($paths, $rotate_vector) = @_;
+    my @rotate = @{$rotate_vector->[0]};
+    my @shift  = @{$rotate_vector->[1]};
+    
+    if ($rotate[0]) {
+        @$paths = map [ Slic3r::Geometry::rotate_points(-$rotate[0], $rotate[1], @$_) ], 
+            map [ Slic3r::Geometry::move_points([map -$_, @shift], @$_) ], @$paths;
+    }
+}
+
+1;

lib/Slic3r/Fill/Rectilinear.pm

@@ -1,7 +1,8 @@
 package Slic3r::Fill::Rectilinear;
 use Moo;
 
-use constant PI => 4 * atan2(1, 1);
+extends 'Slic3r::Fill::Base';
+
 use constant X1 => 0;
 use constant Y1 => 1;
 use constant X2 => 2;
@@ -11,48 +12,20 @@ use constant B => 1;
 use constant X => 0;
 use constant Y => 1;
 
-use POSIX qw(ceil);
 use XXX;
 
-sub make_fill {
+sub fill_surface {
     my $self = shift;
-    my ($print, $layer) = @_;
+    my ($surface, %params) = @_;
-    printf "Filling layer %d:\n", $layer->id;
     
-    my $max_print_dimension = $print->max_length * sqrt(2);
-    
-    my $n = 1;
-    foreach my $surface_collection (@{ $layer->fill_surfaces }) {
-        my @path_collection = ();
-        
-        SURFACE: foreach my $surface (@{ $surface_collection->surfaces }) {
-            Slic3r::debugf " Processing surface %s:\n", $surface->id;
     my $polygons = [ $surface->p ];
     
-            # set infill angle
+    # rotate polygons so that we can work with vertical lines here
-            my (@rotate, @shift);
+    my $rotate_vector = $self->infill_direction($polygons);
-            $rotate[0] = Slic3r::Geometry::deg2rad($Slic3r::fill_angle);
+    $self->rotate_points($polygons, $rotate_vector);
-            $rotate[1] = [ $max_print_dimension / 2, $max_print_dimension / 2 ];
-            @shift = @{$rotate[1]};
     
-            # alternate fill direction
+    my $distance_between_lines = $Slic3r::flow_width / $Slic3r::resolution / $params{density};
-            if ($layer->id % 2) {
+    my $number_of_lines = int(0.99999999 + $self->max_print_dimension / $distance_between_lines); # ceil
-                $rotate[0] = Slic3r::Geometry::deg2rad($Slic3r::fill_angle) + PI/2;
-            }
-            
-            # TODO: here we should implement an "infill in direction of bridges" option
-            
-            # rotate surface as needed
-            @shift = @{ +(Slic3r::Geometry::rotate_points(@rotate, \@shift))[0] };
-            @$polygons = map [ Slic3r::Geometry::move_points(\@shift, @$_) ],
-                map [ Slic3r::Geometry::rotate_points(@rotate, @$_) ], @$polygons if $rotate[0];
-            
-            # force 100% density for external surfaces
-            my $density = $surface->surface_type eq 'internal' ? $Slic3r::fill_density : 1;
-            next SURFACE unless $density > 0;
-            
-            my $distance_between_lines = $Slic3r::flow_width / $Slic3r::resolution / $density;
-            my $number_of_lines = ceil($max_print_dimension / $distance_between_lines);
 
     #printf "distance = %f\n", $distance_between_lines;
     #printf "number_of_lines = %d\n", $number_of_lines;
@@ -161,20 +134,9 @@ sub make_fill {
     }
     
     # paths must be rotated back
-            if ($rotate[0]) {
+    $self->rotate_points_back(\@paths, $rotate_vector);
-                @paths = map [ Slic3r::Geometry::rotate_points(-$rotate[0], $rotate[1], @$_) ], 
-                    map [ Slic3r::Geometry::move_points([map -$_, @shift], @$_) ], @paths;
-            }
     
-            push @path_collection, @paths;
+    return @paths;
-        }
-        
-        # save into layer
-        push @{ $layer->fills }, Slic3r::ExtrusionPath::Collection->new(
-            paths => [ map Slic3r::ExtrusionPath->cast([ @$_ ]), @path_collection ],
-        );
-        $layer->fills->[-1]->cleanup;
-    }
 }
 
 # this function will select the first contiguous block of 

lib/Slic3r/Print.pm

@@ -169,10 +169,10 @@ sub extrude_perimeters {
 sub extrude_fills {
     my $self = shift;
     
-    my $fill_extruder = Slic3r::Fill::Rectilinear->new;
+    my $fill_extruder = Slic3r::Fill->new('print' => $self);
     
     foreach my $layer (@{ $self->layers }) {
-        $fill_extruder->make_fill($self, $layer);
+        $fill_extruder->make_fill($layer);
         Slic3r::debugf "  generated %d paths: %s\n",
             scalar @{ $layer->fills },
             join '  ', map $_->id, map @{$_->paths}, @{ $layer->fills } if $Slic3r::debug;