Finished porting LayerRegion to C++

lib/Slic3r.pm

@@ -54,7 +54,6 @@ use Slic3r::GCode::VibrationLimit;
 use Slic3r::Geometry qw(PI);
 use Slic3r::Geometry::Clipper;
 use Slic3r::Layer;
-use Slic3r::Layer::Region;
 use Slic3r::Line;
 use Slic3r::Model;
 use Slic3r::Point;
@@ -77,7 +76,6 @@ use constant RESOLUTION             => 0.0125;
 use constant SCALED_RESOLUTION      => RESOLUTION / SCALING_FACTOR;
 use constant LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER => 0.15;
 use constant INFILL_OVERLAP_OVER_SPACING  => 0.3;
-use constant EXTERNAL_INFILL_MARGIN => 3;
 
 # keep track of threads we created
 my @my_threads = ();

lib/Slic3r/Fill.pm

@@ -48,9 +48,9 @@ sub make_fill {
     my $self = shift;
     my ($layerm) = @_;
 
-    Slic3r::debugf "Filling layer %d:\n", $layerm->id;
+    Slic3r::debugf "Filling layer %d:\n", $layerm->layer->id;
 
-    my $fill_density            = $layerm->config->fill_density;
+    my $fill_density            = $layerm->region->config->fill_density;
     my $infill_flow             = $layerm->flow(FLOW_ROLE_INFILL);
     my $solid_infill_flow       = $layerm->flow(FLOW_ROLE_SOLID_INFILL);
     my $top_solid_infill_flow   = $layerm->flow(FLOW_ROLE_TOP_SOLID_INFILL);
@@ -74,13 +74,13 @@ sub make_fill {
             for (my $i = 0; $i <= $#groups; $i++) {
                 # we can only merge solid non-bridge surfaces, so discard
                 # non-solid surfaces
-                if ($groups[$i][0]->is_solid && (!$groups[$i][0]->is_bridge || $layerm->id == 0)) {
+                if ($groups[$i][0]->is_solid && (!$groups[$i][0]->is_bridge || $layerm->layer->id == 0)) {
                     $is_solid[$i] = 1;
                     $fw[$i] = ($groups[$i][0]->surface_type == S_TYPE_TOP)
                         ? $top_solid_infill_flow->width
                         : $solid_infill_flow->width;
                     $pattern[$i] = $groups[$i][0]->is_external
-                        ? $layerm->config->external_fill_pattern
+                        ? $layerm->region->config->external_fill_pattern
                         : 'rectilinear';
                 } else {
                     $is_solid[$i]   = 0;
@@ -179,19 +179,19 @@ sub make_fill {
     my @fills = ();
     SURFACE: foreach my $surface (@surfaces) {
         next if $surface->surface_type == S_TYPE_INTERNALVOID;
-        my $filler          = $layerm->config->fill_pattern;
+        my $filler          = $layerm->region->config->fill_pattern;
         my $density         = $fill_density;
         my $role = ($surface->surface_type == S_TYPE_TOP) ? FLOW_ROLE_TOP_SOLID_INFILL
             : $surface->is_solid ? FLOW_ROLE_SOLID_INFILL
             : FLOW_ROLE_INFILL;
-        my $is_bridge       = $layerm->id > 0 && $surface->is_bridge;
+        my $is_bridge       = $layerm->layer->id > 0 && $surface->is_bridge;
         my $is_solid        = $surface->is_solid;
 
         if ($surface->is_solid) {
             $density = 100;
             $filler = 'rectilinear';
             if ($surface->is_external && !$is_bridge) {
-                $filler = $layerm->config->external_fill_pattern;
+                $filler = $layerm->region->config->external_fill_pattern;
             }
         } else {
             next SURFACE unless $density > 0;
@@ -201,14 +201,14 @@ sub make_fill {
         my $f = $self->filler($filler);
 
         # calculate the actual flow we'll be using for this infill
-        my $h = $surface->thickness == -1 ? $layerm->height : $surface->thickness;
+        my $h = $surface->thickness == -1 ? $layerm->layer->height : $surface->thickness;
         my $flow = $layerm->region->flow(
             $role,
             $h,
             $is_bridge || $f->use_bridge_flow,
-            $layerm->id == 0,
+            $layerm->layer->id == 0,
             -1,
-            $layerm->object,
+            $layerm->layer->object,
         );
 
         # calculate flow spacing for infill pattern generation
@@ -220,21 +220,21 @@ sub make_fill {
             # layer height
             my $internal_flow = $layerm->region->flow(
                 FLOW_ROLE_INFILL,
-                $layerm->object->config->layer_height,  # TODO: handle infill_every_layers?
+                $layerm->layer->object->config->layer_height,  # TODO: handle infill_every_layers?
                 0,  # no bridge
                 0,  # no first layer
                 -1, # auto width
-                $layerm->object,
+                $layerm->layer->object,
             );
             $f->spacing($internal_flow->spacing);
             $using_internal_flow = 1;
         } else {
             $f->spacing($flow->spacing);
         }
 
-        $f->layer_id($layerm->id);
-        $f->z($layerm->print_z);
-        $f->angle(deg2rad($layerm->config->fill_angle));
+        $f->layer_id($layerm->layer->id);
+        $f->z($layerm->layer->print_z);
+        $f->angle(deg2rad($layerm->region->config->fill_angle));
         $f->loop_clipping(scale($flow->nozzle_diameter) * &Slic3r::LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER);
 
         # apply half spacing using this flow's own spacing and generate infill

lib/Slic3r/Layer.pm

@@ -41,24 +41,25 @@ sub make_perimeters {
 
     for my $region_id (0..$#{$self->regions}) {
         next if $done{$region_id};
-        my $layerm = $self->regions->[$region_id];
+        my $layerm = $self->get_region($region_id);
+        my $config = $layerm->region->config;
         $done{$region_id} = 1;
 
         # find compatible regions
         my @layerms = ($layerm);
         for my $i (($region_id+1)..$#{$self->regions}) {
-            my $config = $self->regions->[$i]->config;
-            my $layerm_config = $layerm->config;
+            my $other_layerm = $self->get_region($i);
+            my $other_config = $other_layerm->region->config;
 
-            if ($config->perimeter_extruder == $layerm_config->perimeter_extruder
-                && $config->perimeters == $layerm_config->perimeters
-                && $config->perimeter_speed == $layerm_config->perimeter_speed
-                && $config->gap_fill_speed == $layerm_config->gap_fill_speed
-                && $config->overhangs == $layerm_config->overhangs
-                && $config->perimeter_extrusion_width == $layerm_config->perimeter_extrusion_width
-                && $config->thin_walls == $layerm_config->thin_walls
-                && $config->external_perimeters_first == $layerm_config->external_perimeters_first) {
-                push @layerms, $self->regions->[$i];
+            if ($config->perimeter_extruder             == $other_config->perimeter_extruder
+                && $config->perimeters                  == $other_config->perimeters
+                && $config->perimeter_speed             == $other_config->perimeter_speed
+                && $config->gap_fill_speed              == $other_config->gap_fill_speed
+                && $config->overhangs                   == $other_config->overhangs
+                && $config->perimeter_extrusion_width   == $other_config->perimeter_extrusion_width
+                && $config->thin_walls                  == $other_config->thin_walls
+                && $config->external_perimeters_first   == $other_config->external_perimeters_first) {
+                push @layerms, $other_layerm;
                 $done{$i} = 1;
             }
         }

lib/Slic3r/Print/GCode.pm

@@ -357,7 +357,7 @@ sub process_layer {
         $self->_spiral_vase->enable(
             ($layer->id > 0 || $self->print->config->brim_width == 0)
                 && ($layer->id >= $self->print->config->skirt_height && !$self->print->has_infinite_skirt)
-                && !defined(first { $_->config->bottom_solid_layers > $layer->id } @{$layer->regions})
+                && !defined(first { $_->region->config->bottom_solid_layers > $layer->id } @{$layer->regions})
                 && !defined(first { $_->perimeters->items_count > 1 } @{$layer->regions})
                 && !defined(first { $_->fills->items_count > 0 } @{$layer->regions})
         );

lib/Slic3r/Print/Object.pm

@@ -830,17 +830,6 @@ sub clip_fill_surfaces {
     }
 }
 
-sub process_external_surfaces {
-    my ($self) = @_;
-
-    for my $region_id (0 .. ($self->print->region_count-1)) {
-        $self->get_layer(0)->regions->[$region_id]->process_external_surfaces(undef);
-        for my $i (1 .. ($self->layer_count - 1)) {
-            $self->get_layer($i)->regions->[$region_id]->process_external_surfaces($self->get_layer($i-1));
-        }
-    }
-}
-
 sub discover_horizontal_shells {
     my $self = shift;
 
@@ -850,8 +839,8 @@ sub discover_horizontal_shells {
         for (my $i = 0; $i < $self->layer_count; $i++) {
             my $layerm = $self->get_layer($i)->regions->[$region_id];
 
-            if ($layerm->config->solid_infill_every_layers && $layerm->config->fill_density > 0
-                && ($i % $layerm->config->solid_infill_every_layers) == 0) {
+            if ($layerm->region->config->solid_infill_every_layers && $layerm->region->config->fill_density > 0
+                && ($i % $layerm->region->config->solid_infill_every_layers) == 0) {
                 $_->surface_type(S_TYPE_INTERNALSOLID) for @{$layerm->fill_surfaces->filter_by_type(S_TYPE_INTERNAL)};
             }
 
@@ -873,8 +862,8 @@ sub discover_horizontal_shells {
                 Slic3r::debugf "Layer %d has %s surfaces\n", $i, ($type == S_TYPE_TOP) ? 'top' : 'bottom';
 
                 my $solid_layers = ($type == S_TYPE_TOP)
-                    ? $layerm->config->top_solid_layers
-                    : $layerm->config->bottom_solid_layers;
+                    ? $layerm->region->config->top_solid_layers
+                    : $layerm->region->config->bottom_solid_layers;
                 NEIGHBOR: for (my $n = ($type == S_TYPE_TOP) ? $i-1 : $i+1; 
                         abs($n - $i) <= $solid_layers-1; 
                         ($type == S_TYPE_TOP) ? $n-- : $n++) {
@@ -902,7 +891,7 @@ sub discover_horizontal_shells {
                     );
                     next EXTERNAL if !@$new_internal_solid;
 
-                    if ($layerm->config->fill_density == 0) {
+                    if ($layerm->region->config->fill_density == 0) {
                         # if we're printing a hollow object we discard any solid shell thinner
                         # than a perimeter width, since it's probably just crossing a sloping wall
                         # and it's not wanted in a hollow print even if it would make sense when
@@ -1100,12 +1089,12 @@ sub combine_infill {
                         )};
 
                     # apply surfaces back with adjusted depth to the uppermost layer
-                    if ($layerm->id == $self->get_layer($layer_idx)->id) {
+                    if ($layerm->layer->id == $self->get_layer($layer_idx)->id) {
                         push @new_this_type,
                             map Slic3r::Surface->new(
                                 expolygon        => $_,
                                 surface_type     => $type,
-                                thickness        => sum(map $_->height, @layerms),
+                                thickness        => sum(map $_->layer->height, @layerms),
                                 thickness_layers => scalar(@layerms),
                             ),
                             @$intersection;

lib/Slic3r/Print/SupportMaterial.pm

@@ -235,7 +235,7 @@ sub contact_area {
                         # just remove bridged areas
                         $diff = diff(
                             $diff,
-                            [ map @$_, @{$layerm->bridged} ],
+                            $layerm->bridged,
                             1,
                         );
                     }
@@ -267,7 +267,7 @@ sub contact_area {
             # get the average nozzle diameter used on this layer
             my @nozzle_diameters = map $self->print_config->get_at('nozzle_diameter', $_),
                 map { $_->config->perimeter_extruder-1, $_->config->infill_extruder-1, $_->config->solid_infill_extruder-1 }
-                @{$layer->regions};
+                map $_->region, @{$layer->regions};
             my $nozzle_diameter = sum(@nozzle_diameters)/@nozzle_diameters;
 
             my $contact_z = $layer->print_z - $self->contact_distance($layer->height, $nozzle_diameter);