← Back to branch summary

~ubuntu-branches/ubuntu/utopic/slic3r/utopic

« back to all changes in this revision

Viewing changes to lib/Slic3r/GCode/Layer.pm

  • Committer: Package Import Robot
  • Author(s): Chow Loong Jin
  • Date: 2014-06-17 01:27:26 UTC
  • Revision ID: package-import@ubuntu.com-20140617012726-2wrs4zdo251nr4vg
Tags: upstream-1.1.4+dfsg
Import upstream version 1.1.4+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/Slic3r/GCode/Layer.pm
 
1
package Slic3r::GCode::Layer;
 
2
use Moo;
 
3
 
 
4
use List::Util qw(first);
 
5
use Slic3r::Geometry qw(X Y unscale);
 
6
 
 
7
has 'print'                         => (is => 'ro', required => 1);
 
8
has 'gcodegen'                      => (is => 'ro', required => 1, handles => [qw(extruders)]);
 
9
has 'shift'                         => (is => 'ro', default => sub { [0,0] });
 
10
 
 
11
has 'spiralvase'                    => (is => 'lazy');
 
12
has 'vibration_limit'               => (is => 'lazy');
 
13
has 'arc_fitting'                   => (is => 'lazy');
 
14
has 'skirt_done'                    => (is => 'rw', default => sub { {} });  # print_z => 1
 
15
has 'brim_done'                     => (is => 'rw');
 
16
has 'second_layer_things_done'      => (is => 'rw');
 
17
has '_last_obj_copy'                => (is => 'rw');
 
18
 
 
19
sub _build_spiralvase {
 
20
    my $self = shift;
 
21
    
 
22
    return $self->print->config->spiral_vase
 
23
        ? Slic3r::GCode::SpiralVase->new(config => $self->print->config)
 
24
        : undef;
 
25
}
 
26
 
 
27
sub _build_vibration_limit {
 
28
    my $self = shift;
 
29
    
 
30
    return $self->print->config->vibration_limit
 
31
        ? Slic3r::GCode::VibrationLimit->new(config => $self->print->config)
 
32
        : undef;
 
33
}
 
34
 
 
35
sub _build_arc_fitting {
 
36
    my $self = shift;
 
37
    
 
38
    return $self->print->config->gcode_arcs
 
39
        ? Slic3r::GCode::ArcFitting->new(config => $self->print->config)
 
40
        : undef;
 
41
}
 
42
 
 
43
sub process_layer {
 
44
    my $self = shift;
 
45
    my ($layer, $object_copies) = @_;
 
46
    my $gcode = "";
 
47
    
 
48
    my $object = $layer->object;
 
49
    $self->gcodegen->config->apply_object_config($object->config);
 
50
    
 
51
    # check whether we're going to apply spiralvase logic
 
52
    if (defined $self->spiralvase) {
 
53
        $self->spiralvase->enable(
 
54
            ($layer->id > 0 || $self->print->config->brim_width == 0)
 
55
                && ($layer->id >= $self->print->config->skirt_height && $self->print->config->skirt_height != -1)
 
56
                && !defined(first { $_->config->bottom_solid_layers > $layer->id } @{$layer->regions})
 
57
                && !defined(first { @{$_->perimeters} > 1 } @{$layer->regions})
 
58
                && !defined(first { @{$_->fills} > 0 } @{$layer->regions})
 
59
        );
 
60
    }
 
61
    
 
62
    # if we're going to apply spiralvase to this layer, disable loop clipping
 
63
    $self->gcodegen->enable_loop_clipping(!defined $self->spiralvase || !$self->spiralvase->enable);
 
64
    
 
65
    if (!$self->second_layer_things_done && $layer->id == 1) {
 
66
        for my $extruder_id (sort keys %{$self->extruders}) {
 
67
            my $extruder = $self->extruders->{$extruder_id};
 
68
            $gcode .= $self->gcodegen->set_temperature($extruder->temperature, 0, $extruder->id)
 
69
                if $extruder->temperature && $extruder->temperature != $extruder->first_layer_temperature;
 
70
        }
 
71
        $gcode .= $self->gcodegen->set_bed_temperature($self->print->config->bed_temperature)
 
72
            if $self->print->config->bed_temperature && $self->print->config->bed_temperature != $self->print->config->first_layer_bed_temperature;
 
73
        $self->second_layer_things_done(1);
 
74
    }
 
75
    
 
76
    # set new layer - this will change Z and force a retraction if retract_layer_change is enabled
 
77
    $gcode .= $self->gcodegen->change_layer($layer);
 
78
    $gcode .= $self->gcodegen->placeholder_parser->process($self->print->config->layer_gcode, {
 
79
        layer_num => $self->gcodegen->layer->id,
 
80
    }) . "\n" if $self->print->config->layer_gcode;
 
81
    
 
82
    # extrude skirt
 
83
    if (((values %{$self->skirt_done}) < $self->print->config->skirt_height || $self->print->config->skirt_height == -1)
 
84
        && !$self->skirt_done->{$layer->print_z}) {
 
85
        $self->gcodegen->set_shift(@{$self->shift});
 
86
        my @extruder_ids = sort keys %{$self->extruders};
 
87
        $gcode .= $self->gcodegen->set_extruder($extruder_ids[0]);
 
88
        # skip skirt if we have a large brim
 
89
        if ($layer->id < $self->print->config->skirt_height || $self->print->config->skirt_height == -1) {
 
90
            # distribute skirt loops across all extruders
 
91
            my @skirt_loops = @{$self->print->skirt};
 
92
            for my $i (0 .. $#skirt_loops) {
 
93
                # when printing layers > 0 ignore 'min_skirt_length' and 
 
94
                # just use the 'skirts' setting; also just use the current extruder
 
95
                last if ($layer->id > 0) && ($i >= $self->print->config->skirts);
 
96
                my $extruder_id = $extruder_ids[($i/@extruder_ids) % @extruder_ids];
 
97
                $gcode .= $self->gcodegen->set_extruder($extruder_id)
 
98
                    if $layer->id == 0;
 
99
                $gcode .= $self->gcodegen->extrude_loop($skirt_loops[$i], 'skirt', $object->config->support_material_speed);
 
100
            }
 
101
        }
 
102
        $self->skirt_done->{$layer->print_z} = 1;
 
103
        $self->gcodegen->straight_once(1);
 
104
    }
 
105
    
 
106
    # extrude brim
 
107
    if (!$self->brim_done) {
 
108
        $gcode .= $self->gcodegen->set_extruder($self->print->objects->[0]->config->support_material_extruder-1);
 
109
        $self->gcodegen->set_shift(@{$self->shift});
 
110
        $gcode .= $self->gcodegen->extrude_loop($_, 'brim', $object->config->support_material_speed)
 
111
            for @{$self->print->brim};
 
112
        $self->brim_done(1);
 
113
        $self->gcodegen->straight_once(1);
 
114
    }
 
115
    
 
116
    for my $copy (@$object_copies) {
 
117
        $self->gcodegen->new_object(1) if ($self->_last_obj_copy // '') ne "$copy";
 
118
        $self->_last_obj_copy("$copy");
 
119
        
 
120
        $self->gcodegen->set_shift(map $self->shift->[$_] + unscale $copy->[$_], X,Y);
 
121
        
 
122
        # extrude support material before other things because it might use a lower Z
 
123
        # and also because we avoid travelling on other things when printing it
 
124
        if ($layer->isa('Slic3r::Layer::Support')) {
 
125
            if ($layer->support_interface_fills->count > 0) {
 
126
                $gcode .= $self->gcodegen->set_extruder($object->config->support_material_interface_extruder-1);
 
127
                $gcode .= $self->gcodegen->extrude_path($_, 'support material interface', $object->config->get_abs_value('support_material_interface_speed')) 
 
128
                    for @{$layer->support_interface_fills->chained_path_from($self->gcodegen->last_pos, 0)}; 
 
129
            }
 
130
            if ($layer->support_fills->count > 0) {
 
131
                $gcode .= $self->gcodegen->set_extruder($object->config->support_material_extruder-1);
 
132
                $gcode .= $self->gcodegen->extrude_path($_, 'support material', $object->config->get_abs_value('support_material_speed')) 
 
133
                    for @{$layer->support_fills->chained_path_from($self->gcodegen->last_pos, 0)};
 
134
            }
 
135
        }
 
136
        
 
137
        # tweak region ordering to save toolchanges
 
138
        my @region_ids = 0 .. ($self->print->regions_count-1);
 
139
        if ($self->gcodegen->multiple_extruders) {
 
140
            my $last_extruder = $self->gcodegen->extruder;
 
141
            my $best_region_id = first { $self->print->regions->[$_]->config->perimeter_extruder-1 eq $last_extruder } @region_ids;
 
142
            @region_ids = ($best_region_id, grep $_ != $best_region_id, @region_ids) if $best_region_id;
 
143
        }
 
144
        
 
145
        foreach my $region_id (@region_ids) {
 
146
            my $layerm = $layer->regions->[$region_id] or next;
 
147
            my $region = $self->print->regions->[$region_id];
 
148
            $self->gcodegen->config->apply_region_config($region->config);
 
149
            
 
150
            # group extrusions by island
 
151
            my @perimeters_by_island = map [], 0..$#{$layer->slices};   # slice idx => @perimeters
 
152
            my @infill_by_island     = map [], 0..$#{$layer->slices};   # slice idx => @fills
 
153
            
 
154
            # NOTE: we assume $layer->slices was already ordered with chained_path()!
 
155
            
 
156
            PERIMETER: foreach my $perimeter (@{$layerm->perimeters}) {
 
157
                for my $i (0 .. $#{$layer->slices}-1) {
 
158
                    if ($layer->slices->[$i]->contour->contains_point($perimeter->first_point)) {
 
159
                        push @{ $perimeters_by_island[$i] }, $perimeter;
 
160
                        next PERIMETER;
 
161
                    }
 
162
                }
 
163
                push @{ $perimeters_by_island[-1] }, $perimeter; # optimization
 
164
            }
 
165
            FILL: foreach my $fill (@{$layerm->fills}) {
 
166
                for my $i (0 .. $#{$layer->slices}-1) {
 
167
                    if ($layer->slices->[$i]->contour->contains_point($fill->first_point)) {
 
168
                        push @{ $infill_by_island[$i] }, $fill;
 
169
                        next FILL;
 
170
                    }
 
171
                }
 
172
                push @{ $infill_by_island[-1] }, $fill; # optimization
 
173
            }
 
174
            
 
175
            for my $i (0 .. $#{$layer->slices}) {
 
176
                # give priority to infill if we were already using its extruder and it wouldn't
 
177
                # be good for perimeters
 
178
                if ($self->print->config->infill_first
 
179
                    || ($self->gcodegen->multiple_extruders && $region->config->infill_extruder-1 == $self->gcodegen->extruder->id && $region->config->infill_extruder != $region->config->perimeter_extruder)) {
 
180
                    $gcode .= $self->_extrude_infill($infill_by_island[$i], $region);
 
181
                    $gcode .= $self->_extrude_perimeters($perimeters_by_island[$i], $region);
 
182
                } else {
 
183
                    $gcode .= $self->_extrude_perimeters($perimeters_by_island[$i], $region);
 
184
                    $gcode .= $self->_extrude_infill($infill_by_island[$i], $region);
 
185
                }
 
186
            }
 
187
        }
 
188
    }
 
189
    
 
190
    # apply spiral vase post-processing if this layer contains suitable geometry
 
191
    # (we must feed all the G-code into the post-processor, including the first 
 
192
    # bottom non-spiral layers otherwise it will mess with positions)
 
193
    $gcode = $self->spiralvase->process_layer($gcode)
 
194
        if defined $self->spiralvase;
 
195
    
 
196
    # apply vibration limit if enabled
 
197
    $gcode = $self->vibration_limit->process($gcode)
 
198
        if $self->print->config->vibration_limit != 0;
 
199
    
 
200
    # apply arc fitting if enabled
 
201
    $gcode = $self->arc_fitting->process($gcode)
 
202
        if $self->print->config->gcode_arcs;
 
203
    
 
204
    return $gcode;
 
205
}
 
206
 
 
207
sub _extrude_perimeters {
 
208
    my $self = shift;
 
209
    my ($island_perimeters, $region) = @_;
 
210
    
 
211
    return "" if !@$island_perimeters;
 
212
    
 
213
    my $gcode = "";
 
214
    $gcode .= $self->gcodegen->set_extruder($region->config->perimeter_extruder-1);
 
215
    $gcode .= $self->gcodegen->extrude($_, 'perimeter') for @$island_perimeters;
 
216
    return $gcode;
 
217
}
 
218
 
 
219
sub _extrude_infill {
 
220
    my $self = shift;
 
221
    my ($island_fills, $region) = @_;
 
222
    
 
223
    return "" if !@$island_fills;
 
224
    
 
225
    my $gcode = "";
 
226
    $gcode .= $self->gcodegen->set_extruder($region->config->infill_extruder-1);
 
227
    for my $fill (@$island_fills) {
 
228
        if ($fill->isa('Slic3r::ExtrusionPath::Collection')) {
 
229
            $gcode .= $self->gcodegen->extrude($_, 'fill') 
 
230
                for @{$fill->chained_path_from($self->gcodegen->last_pos, 0)};
 
231
        } else {
 
232
            $gcode .= $self->gcodegen->extrude($fill, 'fill') ;
 
233
        }
 
234
    }
 
235
    return $gcode;
 
236
}
 
237
 
 
238
1;