3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-10-30 20:21:12 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

New --perimeters-extrusion-width and --infill-extrusion-width options. #302

Browse source
This commit is contained in:
Alessandro Ranellucci 2012-06-06 18:05:03 +02:00
parent 8a031fe501
commit 82dd3c7a3e
17 changed files with 150 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

69
lib/Slic3r/Config.pm
View file

@ -204,10 +204,20 @@ our $Options = {
type => 'f',
},
'first_layer_extrusion_width' => {
label => 'First layer extrusion width (mm or %; leave zero to use default)',
label => 'First layer extrusion width (mm or % or 0 for default)',
cli => 'first-layer-extrusion-width=s',
type => 'f',
},
'perimeters_extrusion_width' => {
label => 'Perimeters extrusion width (mm or % or 0 for default)',
cli => 'perimeters-extrusion-width=s',
type => 'f',
},
'infill_extrusion_width' => {
label => 'Infill extrusion width (mm or % or 0 for default)',
cli => 'infill-extrusion-width=s',
type => 'f',
},
'bridge_flow_ratio' => {
label => 'Bridge flow ratio',
cli => 'bridge-flow-ratio=f',
@ -596,16 +606,13 @@ sub validate {
if $Slic3r::_first_layer_height > $Slic3r::nozzle_diameter;
# calculate flow
($Slic3r::flow_width, $Slic3r::min_flow_spacing, $Slic3r::flow_spacing) = calculate_flow($Slic3r::extrusion_width);
Slic3r::debugf "Flow width = $Slic3r::flow_width\n";
Slic3r::debugf "Flow spacing = $Slic3r::flow_spacing\n";
Slic3r::debugf "Min flow spacing = $Slic3r::min_flow_spacing\n";
# calculate first layer flow
($Slic3r::first_layer_flow_width, $Slic3r::first_layer_min_flow_spacing, $Slic3r::first_layer_flow_spacing) = calculate_flow($Slic3r::first_layer_extrusion_width || $Slic3r::extrusion_width);
Slic3r::debugf "First Layer Flow width = $Slic3r::first_layer_flow_width\n";
Slic3r::debugf "First Layer Flow spacing = $Slic3r::first_layer_flow_spacing\n";
Slic3r::debugf "First Layer Min flow spacing = $Slic3r::first_layer_min_flow_spacing\n";
$Slic3r::flow->calculate($Slic3r::extrusion_width);
$Slic3r::first_layer_flow->calculate($Slic3r::first_layer_extrusion_width)
if $Slic3r::first_layer_extrusion_width;
$Slic3r::perimeters_flow->calculate($Slic3r::perimeters_extrusion_width || $Slic3r::extrusion_width);
$Slic3r::infill_flow->calculate($Slic3r::infill_extrusion_width || $Slic3r::extrusion_width);
Slic3r::debugf "Default flow width = %s, spacing = %s, min_spacing = %d\n",
$Slic3r::flow->width, $Slic3r::flow->spacing, $Slic3r::flow->min_spacing;
# --perimeters
die "Invalid value for --perimeters\n"
@ -723,44 +730,4 @@ sub replace_options {
return $string;
}
sub calculate_flow {
my ($extrusion_width) = @_;
my ($flow_width, $min_flow_spacing, $flow_spacing);
if ($extrusion_width) {
$flow_width = $extrusion_width =~ /^(\d+(?:\.\d+)?)%$/
? ($Slic3r::layer_height * $1 / 100)
: $extrusion_width;
} else {
# here we calculate a sane default by matching the flow speed (at the nozzle)
# and the feed rate
my $volume = ($Slic3r::nozzle_diameter**2) * PI/4;
my $shape_threshold = $Slic3r::nozzle_diameter * $Slic3r::layer_height
+ ($Slic3r::layer_height**2) * PI/4;
if ($volume >= $shape_threshold) {
# rectangle with semicircles at the ends
$flow_width = (($Slic3r::nozzle_diameter**2) * PI + ($Slic3r::layer_height**2) * (4 - PI)) / (4 * $Slic3r::layer_height);
} else {
# rectangle with squished semicircles at the ends
$flow_width = $Slic3r::nozzle_diameter * ($Slic3r::nozzle_diameter/$Slic3r::layer_height - 4/PI + 1);
}
my $min_flow_width = $Slic3r::nozzle_diameter * 1.05;
my $max_flow_width = $Slic3r::nozzle_diameter * 1.4;
$flow_width = $max_flow_width if $flow_width > $max_flow_width;
$flow_width = $min_flow_width if $flow_width < $min_flow_width;
}
if ($flow_width >= ($Slic3r::nozzle_diameter + $Slic3r::layer_height)) {
# rectangle with semicircles at the ends
$min_flow_spacing = $flow_width - $Slic3r::layer_height * (1 - PI/4);
} else {
# rectangle with shrunk semicircles at the ends
$min_flow_spacing = $flow_width * (1 - PI/4) + $Slic3r::nozzle_diameter * PI/4;
}
$flow_spacing = $flow_width - $Slic3r::overlap_factor * ($flow_width - $min_flow_spacing);
return ($flow_width, $min_flow_spacing, $flow_spacing);
}
1;

8
lib/Slic3r/Extruder.pm
View file

@ -102,7 +102,7 @@ sub extrude_loop {
# clip the path to avoid the extruder to get exactly on the first point of the loop;
# if polyline was shorter than the clipping distance we'd get a null polyline, so
# we discard it in that case
$extrusion_path->clip_end(scale($self->layer->flow_width || $Slic3r::flow_width) * 0.15);
$extrusion_path->clip_end(scale($self->layer ? $self->layer->flow->width : $Slic3r::flow->width) * 0.15);
return '' if !@{$extrusion_path->polyline};
# extrude along the path
@ -129,7 +129,7 @@ sub extrude_path {
{
my $distance_from_last_pos = $self->last_pos->distance_to($path->points->[0]) * $Slic3r::scaling_factor;
my $distance_threshold = $Slic3r::retract_before_travel;
$distance_threshold = 2 * ($self->layer->flow_width || $Slic3r::flow_width) / $Slic3r::fill_density * sqrt(2)
$distance_threshold = 2 * ($self->layer ? $self->layer->flow->width : $Slic3r::flow->width) / $Slic3r::fill_density * sqrt(2)
if $Slic3r::fill_density > 0 && $description =~ /fill/;
if ($distance_from_last_pos >= $distance_threshold) {
@ -145,9 +145,9 @@ sub extrude_path {
$gcode .= $self->unretract if $self->retracted;
# calculate extrusion length per distance unit
my $s = $path->flow_spacing || $self->layer->flow_spacing || $Slic3r::flow_spacing;
my $s = $path->flow_spacing || $self->layer ? $self->layer->flow->spacing : $Slic3r::flow->spacing;
my $h = $path->depth_layers * $self->layer->height;
my $w = ($s - $Slic3r::min_flow_spacing * $Slic3r::overlap_factor) / (1 - $Slic3r::overlap_factor);
my $w = ($s - ($self->layer ? $self->layer->flow->min_spacing : $Slic3r::flow->min_spacing) * $Slic3r::overlap_factor) / (1 - $Slic3r::overlap_factor);
my $area;
if ($path->role == EXTR_ROLE_BRIDGE) {

4
lib/Slic3r/Fill.pm
View file

@ -99,7 +99,7 @@ sub make_fill {
# add spacing between adjacent surfaces
{
my $distance = scale $layer->flow_spacing / 2;
my $distance = scale $layer->flow->spacing / 2;
my @offsets = ();
foreach my $surface (@surfaces) {
my $expolygon = $surface->expolygon;
@ -137,7 +137,7 @@ sub make_fill {
SURFACE: foreach my $surface (@surfaces) {
my $filler = $Slic3r::fill_pattern;
my $density = $Slic3r::fill_density;
my $flow_spacing = $layer->flow_spacing;
my $flow_spacing = $layer->flow->spacing;
my $is_bridge = $layer->id > 0 && $surface->surface_type == S_TYPE_BOTTOM;
my $is_solid = (grep { $surface->surface_type == $_ } S_TYPE_TOP, S_TYPE_BOTTOM, S_TYPE_INTERNALSOLID) ? 1 : 0;

2
lib/Slic3r/Fill/Concentric.pm
View file

@ -64,7 +64,7 @@ sub fill_surface {
$path->deserialize;
# clip the path to avoid the extruder to get exactly on the first point of the loop
$path->clip_end(scale($self->layer->flow_width || $Slic3r::flow_width) * 0.15);
$path->clip_end(scale($self->layer ? $self->layer->flow->width : $Slic3r::flow->width) * 0.15);
push @paths, $path->points if @{$path->points};
}

2
lib/Slic3r/Fill/Honeycomb.pm
View file

@ -21,7 +21,7 @@ sub fill_surface {
# infill math
my $min_spacing = scale $params{flow_spacing};
my $distance = $min_spacing / $params{density};
my $overlap_distance = scale($self->layer->flow_width || $Slic3r::flow_width) * 0.4;
my $overlap_distance = scale($self->layer ? $self->layer->flow->width : $Slic3r::flow->width) * 0.4;
my $cache_id = sprintf "d%s_s%s_a%s",
$params{density}, $params{flow_spacing}, $rotate_vector->[0][0];

2
lib/Slic3r/Fill/Rectilinear.pm
View file

@ -32,7 +32,7 @@ sub fill_surface {
$flow_spacing = unscale $distance_between_lines;
}
my $overlap_distance = scale($self->layer->flow_width || $Slic3r::flow_width) * 0.4;
my $overlap_distance = scale($self->layer ? $self->layer->flow->width : $Slic3r::flow->width) * 0.4;
my $x = $bounding_box->[X1];
my $is_line_pattern = $self->isa('Slic3r::Fill::Line');

53
lib/Slic3r/Flow.pm Normal file
View file

@ -0,0 +1,53 @@
package Slic3r::Flow;
use Moo;
use Slic3r::Geometry qw(PI);
has 'width' => (is => 'rw');
has 'min_spacing' => (is => 'rw');
has 'spacing' => (is => 'rw');
sub calculate {
my $self = shift;
my ($extrusion_width) = @_;
my ($flow_width, $min_flow_spacing, $flow_spacing);
if ($extrusion_width) {
$flow_width = $extrusion_width =~ /^(\d+(?:\.\d+)?)%$/
? ($Slic3r::layer_height * $1 / 100)
: $extrusion_width;
} else {
# here we calculate a sane default by matching the flow speed (at the nozzle)
# and the feed rate
my $volume = ($Slic3r::nozzle_diameter**2) * PI/4;
my $shape_threshold = $Slic3r::nozzle_diameter * $Slic3r::layer_height
+ ($Slic3r::layer_height**2) * PI/4;
if ($volume >= $shape_threshold) {
# rectangle with semicircles at the ends
$flow_width = (($Slic3r::nozzle_diameter**2) * PI + ($Slic3r::layer_height**2) * (4 - PI)) / (4 * $Slic3r::layer_height);
} else {
# rectangle with squished semicircles at the ends
$flow_width = $Slic3r::nozzle_diameter * ($Slic3r::nozzle_diameter/$Slic3r::layer_height - 4/PI + 1);
}
my $min_flow_width = $Slic3r::nozzle_diameter * 1.05;
my $max_flow_width = $Slic3r::nozzle_diameter * 1.4;
$flow_width = $max_flow_width if $flow_width > $max_flow_width;
$flow_width = $min_flow_width if $flow_width < $min_flow_width;
}
if ($flow_width >= ($Slic3r::nozzle_diameter + $Slic3r::layer_height)) {
# rectangle with semicircles at the ends
$min_flow_spacing = $flow_width - $Slic3r::layer_height * (1 - PI/4);
} else {
# rectangle with shrunk semicircles at the ends
$min_flow_spacing = $flow_width * (1 - PI/4) + $Slic3r::nozzle_diameter * PI/4;
}
$flow_spacing = $flow_width - $Slic3r::overlap_factor * ($flow_width - $min_flow_spacing);
$self->width($flow_width);
$self->min_spacing($min_flow_spacing);
$self->spacing($flow_spacing);
}
1;

2
lib/Slic3r/GUI/SkeinPanel.pm
View file

@ -70,7 +70,7 @@ sub new {
},
extrusion => {
title => 'Extrusion',
options => [qw(extrusion_width first_layer_extrusion_width bridge_flow_ratio)],
options => [qw(extrusion_width first_layer_extrusion_width perimeters_extrusion_width infill_extrusion_width bridge_flow_ratio)],
},
output => {
title => 'Output',

2
lib/Slic3r/Geometry.pm
View file

@ -890,7 +890,7 @@ sub arrange {
# margin needed for the skirt
my $skirt_margin;
if ($Slic3r::skirts > 0) {
$skirt_margin = ($Slic3r::flow_spacing * $Slic3r::skirts + $Slic3r::skirt_distance) * 2;
$skirt_margin = ($Slic3r::flow->spacing * $Slic3r::skirts + $Slic3r::skirt_distance) * 2;
} else {
$skirt_margin = 0;
}

46
lib/Slic3r/Layer.pm
View file

@ -19,8 +19,9 @@ has 'slicing_errors' => (is => 'rw');
has 'slice_z' => (is => 'lazy');
has 'print_z' => (is => 'lazy');
has 'height' => (is => 'lazy');
has 'flow_spacing' => (is => 'lazy');
has 'flow_width' => (is => 'lazy');
has 'flow' => (is => 'lazy');
has 'perimeters_flow' => (is => 'lazy');
has 'infill_flow' => (is => 'lazy');
# collection of spare segments generated by slicing the original geometry;
# these need to be merged in continuos (closed) polylines
@ -101,14 +102,25 @@ sub _build_height {
return $self->id == 0 ? $Slic3r::_first_layer_height : $Slic3r::layer_height;
}
sub _build_flow_spacing {
sub _build_flow {
my $self = shift;
return $self->id == 0 ? $Slic3r::first_layer_flow_spacing : $Slic3r::flow_spacing;
return $self->id == 0 && $Slic3r::first_layer_flow
? $Slic3r::first_layer_flow
: $Slic3r::flow;
}
sub _build_flow_width {
sub _build_perimeters_flow {
my $self = shift;
return $self->id == 0 ? $Slic3r::first_layer_flow_width : $Slic3r::flow_width;
return $self->id == 0 && $Slic3r::first_layer_flow
? $Slic3r::first_layer_flow
: $Slic3r::perimeters_flow;
}
sub _build_infill_flow {
my $self = shift;
return $self->id == 0 && $Slic3r::first_layer_flow
? $Slic3r::first_layer_flow
: $Slic3r::infill_flow;
}
sub add_line {
@ -139,7 +151,7 @@ sub make_surfaces {
# the contours must be offsetted by half extrusion width inwards
{
my $distance = scale $self->flow_width / 2;
my $distance = scale $self->perimeters_flow->width / 2;
my @surfaces = @{$self->slices};
@{$self->slices} = ();
foreach my $surface (@surfaces) {
@ -158,12 +170,12 @@ sub make_surfaces {
);
if (@$diff) {
my $area_threshold = scale($self->flow_spacing) ** 2;
my $area_threshold = scale($self->perimeters_flow->spacing) ** 2;
@$diff = grep $_->area > ($area_threshold), @$diff;
push @{$self->thin_walls},
grep $_,
map $_->medial_axis(scale $self->flow_width),
map $_->medial_axis(scale $self->perimeters_flow->width),
@$diff;
Slic3r::debugf " %d thin walls detected\n", scalar(@{$self->thin_walls}) if @{$self->thin_walls};
@ -213,8 +225,8 @@ sub make_perimeters {
next unless $circumference <= $Slic3r::small_perimeter_length;
# revert the compensation done in make_surfaces() and get the actual radius
# of the hole
my $radius = ($circumference / PI / 2) - scale $self->flow_spacing/2;
my $new_radius = (scale($self->flow_width) + sqrt((scale($self->flow_width)**2) + (4*($radius**2)))) / 2;
my $radius = ($circumference / PI / 2) - scale $self->perimeters_flow->spacing/2;
my $new_radius = (scale($self->perimeters_flow->width) + sqrt((scale($self->perimeters_flow->width)**2) + (4*($radius**2)))) / 2;
# holes are always turned to contours, so reverse point order before and after
$hole->reverse;
my @offsetted = $hole->offset(+ ($new_radius - $radius));
@ -233,7 +245,7 @@ sub make_perimeters {
push @{ $perimeters[-1] }, [@last_offsets];
# offset distance for inner loops
$distance = scale $self->flow_spacing;
$distance = scale $self->perimeters_flow->spacing;
}
# create one more offset to be used as boundary for fill
@ -249,7 +261,7 @@ sub make_perimeters {
);
push @{ $self->thin_fills },
grep $_,
map $_->medial_axis(scale $self->flow_width),
map $_->medial_axis(scale $self->perimeters_flow->width),
@$small_gaps if 0;
}
}
@ -321,7 +333,7 @@ sub add_perimeter {
my $self = shift;
my ($polygon, $role) = @_;
return unless $polygon->is_printable($self->flow_width);
return unless $polygon->is_printable($self->perimeters_flow->width);
push @{ $self->perimeters }, Slic3r::ExtrusionLoop->new(
polygon => $polygon,
role => (abs($polygon->length) <= $Slic3r::small_perimeter_length) ? EXTR_ROLE_SMALLPERIMETER : ($role // EXTR_ROLE_PERIMETER), #/
@ -336,7 +348,7 @@ sub prepare_fill_surfaces {
# merge too small internal surfaces with their surrounding tops
# (if they're too small, they can be treated as solid)
{
my $min_area = ((7 * $self->flow_spacing / $Slic3r::scaling_factor)**2) * PI;
my $min_area = ((7 * $self->infill_flow->spacing / $Slic3r::scaling_factor)**2) * PI;
my $small_internal = [
grep { $_->expolygon->contour->area <= $min_area }
grep { $_->surface_type == S_TYPE_INTERNAL }
@ -369,7 +381,7 @@ sub prepare_fill_surfaces {
sub remove_small_surfaces {
my $self = shift;
my $distance = scale $self->flow_spacing / 2;
my $distance = scale $self->infill_flow->spacing / 2;
my @surfaces = @{$self->fill_surfaces};
@{$self->fill_surfaces} = ();
@ -429,7 +441,7 @@ sub process_bridges {
# offset the contour and intersect it with the internal surfaces to discover
# which of them has contact with our bridge
my @supporting_surfaces = ();
my ($contour_offset) = $expolygon->contour->offset(scale $self->flow_spacing * sqrt(2));
my ($contour_offset) = $expolygon->contour->offset(scale $self->flow->spacing * sqrt(2));
foreach my $internal_surface (@internal_surfaces) {
my $intersection = intersection_ex([$contour_offset], [$internal_surface->p]);
if (@$intersection) {

2
lib/Slic3r/Polygon.pm
View file

@ -114,7 +114,7 @@ sub is_printable {
# detect them and we would be discarding them.
my $p = $self->clone;
$p->make_counter_clockwise;
return $p->offset(scale($flow_width || $Slic3r::flow_width) / 2) ? 1 : 0;
return $p->offset(scale($flow_width || $Slic3r::flow->width) / 2) ? 1 : 0;
}
sub is_valid {

8
lib/Slic3r/Print.pm
View file

@ -410,7 +410,7 @@ sub make_skirt {
# draw outlines from outside to inside
my @skirt = ();
for (my $i = $Slic3r::skirts - 1; $i >= 0; $i--) {
my $distance = scale ($Slic3r::skirt_distance + ($Slic3r::flow_spacing * $i));
my $distance = scale ($Slic3r::skirt_distance + ($Slic3r::flow->spacing * $i));
my $outline = offset([$convex_hull], $distance, $Slic3r::scaling_factor * 100, JT_ROUND);
push @skirt, Slic3r::ExtrusionLoop->new(
polygon => Slic3r::Polygon->new(@{$outline->[0]}),
@ -440,9 +440,9 @@ sub write_gcode {
extrusion_multiplier perimeter_speed infill_speed travel_speed scale)) {
printf $fh "; %s = %s\n", $_, Slic3r::Config->get($_);
}
printf $fh "; single wall width = %.2fmm\n", $Slic3r::flow_width;
printf $fh "; first layer single wall width = %.2fmm\n", $Slic3r::first_layer_flow_width
if $Slic3r::first_layer_flow_width != $Slic3r::flow_width;
printf $fh "; single wall width = %.2fmm\n", $Slic3r::flow->width;
printf $fh "; first layer single wall width = %.2fmm\n", $Slic3r::first_layer_flow->width
if $Slic3r::first_layer_flow;
print $fh "\n";
# set up our extruder object

28
lib/Slic3r/Print/Object.pm
View file

@ -174,13 +174,13 @@ sub make_perimeters {
my $layer = $self->layers->[$layer_id];
my $upper_layer = $self->layers->[$layer_id+1];
my $overlap = $layer->flow_spacing; # one perimeter
my $overlap = $layer->perimeters_flow->spacing; # one perimeter
# compute polygons representing the thickness of the first external perimeter of
# the upper layer slices
my $upper = diff_ex(
[ map @$_, map $_->expolygon->offset_ex(+ 0.5 * scale $layer->flow_spacing), @{$upper_layer->slices} ],
[ map @$_, map $_->expolygon->offset_ex(- scale($overlap) + (0.5 * scale $layer->flow_spacing)), @{$upper_layer->slices} ],
[ map @$_, map $_->expolygon->offset_ex(+ 0.5 * scale $layer->perimeters_flow->spacing), @{$upper_layer->slices} ],
[ map @$_, map $_->expolygon->offset_ex(- scale($overlap) + (0.5 * scale $layer->perimeters_flow->spacing)), @{$upper_layer->slices} ],
);
next if !@$upper;
@ -189,10 +189,10 @@ sub make_perimeters {
my $ignore = [];
{
my $diff = diff_ex(
[ map @$_, map $_->expolygon->offset_ex(- ($Slic3r::perimeters-0.5) * scale $layer->flow_spacing), @{$layer->slices} ],
[ map @$_, map $_->expolygon->offset_ex(- ($Slic3r::perimeters-0.5) * scale $layer->perimeters_flow->spacing), @{$layer->slices} ],
[ map @{$_->expolygon}, @{$upper_layer->slices} ],
);
$ignore = [ map @$_, map $_->offset_ex(scale $layer->flow_spacing), @$diff ];
$ignore = [ map @$_, map $_->offset_ex(scale $layer->perimeters_flow->spacing), @$diff ];
}
foreach my $slice (@{$layer->slices}) {
@ -202,9 +202,9 @@ sub make_perimeters {
# of our slice
my $hypothetical_perimeter;
{
my $outer = [ map @$_, $slice->expolygon->offset_ex(- ($hypothetical_perimeter_num-1.5) * scale $layer->flow_spacing) ];
my $outer = [ map @$_, $slice->expolygon->offset_ex(- ($hypothetical_perimeter_num-1.5) * scale $layer->perimeters_flow->spacing) ];
last CYCLE if !@$outer;
my $inner = [ map @$_, $slice->expolygon->offset_ex(- ($hypothetical_perimeter_num-0.5) * scale $layer->flow_spacing) ];
my $inner = [ map @$_, $slice->expolygon->offset_ex(- ($hypothetical_perimeter_num-0.5) * scale $layer->perimeters_flow->spacing) ];
last CYCLE if !@$inner;
$hypothetical_perimeter = diff_ex($outer, $inner);
}
@ -236,7 +236,7 @@ sub detect_surfaces_type {
[ map { ref $_ eq 'ARRAY' ? $_ : ref $_ eq 'Slic3r::ExPolygon' ? @$_ : $_->p } @$clip_surfaces ],
1,
);
return grep $_->contour->is_printable($layer->flow_width),
return grep $_->contour->is_printable($layer->flow->width),
map Slic3r::Surface->new(expolygon => $_, surface_type => $result_type),
@$expolygons;
};
@ -310,14 +310,14 @@ sub discover_horizontal_shells {
Slic3r::debugf "==> DISCOVERING HORIZONTAL SHELLS\n";
my $area_threshold = scale($Slic3r::flow_spacing) ** 2;
my $area_threshold = scale($Slic3r::flow->spacing) ** 2;
for (my $i = 0; $i < $self->layer_count; $i++) {
my $layer = $self->layers->[$i];
foreach my $type (S_TYPE_TOP, S_TYPE_BOTTOM) {
# find surfaces of current type for current layer
# and offset them to take perimeters into account
my @surfaces = map $_->offset($Slic3r::perimeters * scale $layer->flow_width),
my @surfaces = map $_->offset($Slic3r::perimeters * scale $layer->perimeters_flow->width),
grep $_->surface_type == $type, @{$layer->fill_surfaces} or next;
my $surfaces_p = [ map $_->p, @surfaces ];
Slic3r::debugf "Layer %d has %d surfaces of type '%s'\n",
@ -396,7 +396,7 @@ sub infill_every_layers {
my $self = shift;
return unless $Slic3r::infill_every_layers > 1 && $Slic3r::fill_density > 0;
my $area_threshold = scale($Slic3r::flow_spacing) ** 2;
my $area_threshold = scale($Slic3r::flow->spacing) ** 2;
# start from bottom, skip first layer
for (my $i = 1; $i < $self->layer_count; $i++) {
@ -512,13 +512,13 @@ sub generate_support_material {
# those parts. a visibility check algorithm is needed.
# @a = @{diff_ex(
# [ map $_->p, grep $_->surface_type == S_TYPE_BOTTOM, @{$layer->slices} ],
# [ map @$_, map $_->expolygon->offset_ex(scale $layer->flow_spacing * $Slic3r::perimeters),
# [ map @$_, map $_->expolygon->offset_ex(scale $layer->flow->spacing * $Slic3r::perimeters),
# grep $_->surface_type == S_TYPE_BOTTOM && defined $_->bridge_angle,
# @{$layer->fill_surfaces} ],
# )};
@a = map $_->expolygon->clone, grep $_->surface_type == S_TYPE_BOTTOM, @{$layer->slices};
$_->simplify(scale $layer->flow_spacing * 3) for @a;
$_->simplify(scale $layer->flow->spacing * 3) for @a;
push @unsupported_expolygons, @a;
}
}
@ -541,7 +541,7 @@ sub generate_support_material {
#bridge_angle => $Slic3r::fill_angle + 45 + $angle,
),
density => 0.20,
flow_spacing => $Slic3r::flow_spacing,
flow_spacing => $Slic3r::flow->spacing,
);
my $params = shift @paths;