222 lines
7.8 KiB
Perl
222 lines
7.8 KiB
Perl
|
package Slic3r::Fill::Rectilinear;
|
||
|
|
use Moose;
|
||
|
|
|
||
|
|
use constant epsilon => 1E-10;
|
||
|
|
use constant PI => 4 * atan2(1, 1);
|
||
|
|
use constant X1 => 0;
|
||
|
|
use constant Y1 => 1;
|
||
|
|
use constant X2 => 2;
|
||
|
|
use constant Y2 => 3;
|
||
|
|
|
||
|
|
use Math::Geometry::Planar;
|
||
|
|
use XXX;
|
||
|
|
|
||
|
|
sub make_fill {
|
||
|
|
my $self = shift;
|
||
|
|
my ($print, $layer) = @_;
|
||
|
|
printf "Filling layer %d:\n", $layer->id;
|
||
|
|
|
||
|
|
# let's alternate fill direction
|
||
|
|
my @axes = $layer->id % 2 == 0 ? (0,1) : (1,0);
|
||
|
|
printf " primary axis: %d\n", $axes[0];
|
||
|
|
|
||
|
|
foreach my $surface (@{ $layer->fill_surfaces }) {
|
||
|
|
printf " Processing surface %s:\n", $surface->id;
|
||
|
|
my $polygon = $surface->mgp_polygon;
|
||
|
|
|
||
|
|
# rotate surface as needed
|
||
|
|
if ($axes[0] == 1) {
|
||
|
|
$polygon = $polygon->rotate(PI/2)->move($print->x_length, $print->y_length);
|
||
|
|
}
|
||
|
|
|
||
|
|
# force 100% density for external surfaces
|
||
|
|
my $density = $surface->surface_type eq 'internal' ? $Slic3r::fill_density : 1;
|
||
|
|
my $distance_between_lines = $Slic3r::flow_width / $Slic3r::resolution / $density;
|
||
|
|
my $number_of_lines = ($axes[0] == 0 ? $print->x_length : $print->y_length) / $distance_between_lines;
|
||
|
|
|
||
|
|
#printf "distance_between_lines = %f\n", $distance_between_lines;
|
||
|
|
#printf "number_of_lines = %d\n", $number_of_lines;
|
||
|
|
#printf "axes = %d, %d\n", @axes;
|
||
|
|
|
||
|
|
# this arrayref will hold intersection points of the fill grid with surface segments
|
||
|
|
my $points = [ map [], 0..$number_of_lines-1 ];
|
||
|
|
foreach my $line (map $self->_lines_from_mgp_points($_), @{ $polygon->polygons }) {
|
||
|
|
|
||
|
|
# for a possible implementation of "infill in direction of bridges"
|
||
|
|
# we should rotate $line so that primary axis is in detected direction;
|
||
|
|
# then, generated extrusion paths should be rotated back to the original
|
||
|
|
# coordinate system
|
||
|
|
|
||
|
|
# find out the coordinates
|
||
|
|
my @coordinates = map @$_, @$line;
|
||
|
|
printf "Segment %d,%d - %d,%d\n", @coordinates;
|
||
|
|
|
||
|
|
# get the extents of the segment along the primary axis
|
||
|
|
my @line_c = sort ($coordinates[X1], $coordinates[X2]);
|
||
|
|
|
||
|
|
for (my $c = $line_c[0]; $c <= $line_c[1]; $c += $distance_between_lines) {
|
||
|
|
my $i = sprintf('%.0f', $c / $distance_between_lines) - 1;
|
||
|
|
|
||
|
|
# if the segment is parallel to our ray, there will be two intersection points
|
||
|
|
if ($line_c[0] == $line_c[1]) {
|
||
|
|
printf " Segment is parallel!\n";
|
||
|
|
push @{ $points->[$i] }, $coordinates[Y1], $coordinates[Y2];
|
||
|
|
printf " intersections at %f (%d) = %f, %f\n", $c, $i, $points->[$i][-2], $points->[$i][-1];
|
||
|
|
} else {
|
||
|
|
printf " Segment NOT parallel!\n";
|
||
|
|
# one point of intersection
|
||
|
|
push @{ $points->[$i] }, $coordinates[Y1] + ($coordinates[Y2] - $coordinates[Y1])
|
||
|
|
* ($c - $coordinates[X1]) / ($coordinates[X2] - $coordinates[X1]);
|
||
|
|
printf " intersection at %f (%d) = %f\n", $c, $i, $points->[$i][-1];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# sort and remove duplicates
|
||
|
|
$points = [
|
||
|
|
map {
|
||
|
|
my %h = map { sprintf("%.0f", $_) => 1 } @$_;
|
||
|
|
[ sort keys %h ];
|
||
|
|
} @$points
|
||
|
|
];
|
||
|
|
|
||
|
|
# generate extrusion paths
|
||
|
|
my (@paths, @path_points) = ();
|
||
|
|
my $direction = 0;
|
||
|
|
|
||
|
|
my $stop_path = sub {
|
||
|
|
# defensive programming
|
||
|
|
if (@path_points == 1) {
|
||
|
|
YYY \@path_points;
|
||
|
|
die "There shouldn't be only one point in the current path";
|
||
|
|
}
|
||
|
|
|
||
|
|
# if we were constructing a path, stop it
|
||
|
|
push @paths, [ @path_points ] if @path_points;
|
||
|
|
@path_points = ();
|
||
|
|
};
|
||
|
|
|
||
|
|
# loop until we have spare points
|
||
|
|
while (map @$_, @$points) {
|
||
|
|
|
||
|
|
# loop through rows
|
||
|
|
ROW: for (my $i = 0; $i < $number_of_lines; $i++) {
|
||
|
|
my $row = $points->[$i];
|
||
|
|
printf "Processing row %d...\n", $i;
|
||
|
|
if (!@$row) {
|
||
|
|
printf " no points\n";
|
||
|
|
$stop_path->();
|
||
|
|
next ROW;
|
||
|
|
}
|
||
|
|
printf " points = %s\n", join ', ', @$row;
|
||
|
|
|
||
|
|
# coordinate of current row
|
||
|
|
my $c = ($i + 1) * $distance_between_lines;
|
||
|
|
|
||
|
|
# need to start a path?
|
||
|
|
if (!@path_points) {
|
||
|
|
push @path_points, [ $c, shift @$row ];
|
||
|
|
}
|
||
|
|
|
||
|
|
my @connectable_points = $self->find_connectable_points($polygon, $path_points[-1], $c, $row);
|
||
|
|
@connectable_points = reverse @connectable_points if $direction == 1;
|
||
|
|
printf " found %d connectable points = %s\n", scalar(@connectable_points),
|
||
|
|
join ', ', @connectable_points;
|
||
|
|
|
||
|
|
if (!@connectable_points && @path_points && $path_points[-1][0] != $c) {
|
||
|
|
# no connectable in this row
|
||
|
|
$stop_path->();
|
||
|
|
}
|
||
|
|
|
||
|
|
foreach my $p (@connectable_points) {
|
||
|
|
push @path_points, [ $c, $p ];
|
||
|
|
@$row = grep $_ != $p, @$row; # remove point from row
|
||
|
|
}
|
||
|
|
|
||
|
|
# invert direction
|
||
|
|
$direction = $direction ? 0 : 1;
|
||
|
|
}
|
||
|
|
$stop_path->() if @path_points;
|
||
|
|
}
|
||
|
|
|
||
|
|
# paths must be rotated back
|
||
|
|
if ($axes[0] == 1) {
|
||
|
|
@paths = map $self->_mgp_from_points_ref($_)->move(-$print->x_length, -$print->y_length)->rotate(-PI()/2)->points, @paths;
|
||
|
|
}
|
||
|
|
|
||
|
|
# save into layer
|
||
|
|
push @{ $layer->fills }, map Slic3r::ExtrusionPath->new_from_points(@$_), @paths;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# this function will select the first contiguous block of
|
||
|
|
# points connectable to a given one
|
||
|
|
sub find_connectable_points {
|
||
|
|
my $self = shift;
|
||
|
|
my ($polygon, $point, $c, $points) = @_;
|
||
|
|
|
||
|
|
my @connectable_points = ();
|
||
|
|
foreach my $p (@$points) {
|
||
|
|
push @connectable_points, $p
|
||
|
|
if $self->can_connect($polygon, $point, [ $c, $p ]);
|
||
|
|
}
|
||
|
|
return @connectable_points;
|
||
|
|
}
|
||
|
|
|
||
|
|
# this subroutine tries to determine whether two points in a surface
|
||
|
|
# are connectable without crossing contour or holes
|
||
|
|
sub can_connect {
|
||
|
|
my $self = shift;
|
||
|
|
my ($polygon, $p1, $p2) = @_;
|
||
|
|
|
||
|
|
# there's room for optimization here
|
||
|
|
|
||
|
|
# this is not needed since we assume that $p1 and $p2 belong to $polygon
|
||
|
|
###for ($p1, $p2) {
|
||
|
|
###return 0 unless $polygon->isinside($_);
|
||
|
|
###}
|
||
|
|
|
||
|
|
# check whether the $p1-$p2 segment doesn't intersect any segment
|
||
|
|
# of the contour or of holes
|
||
|
|
foreach my $points (@{ $polygon->polygons }) {
|
||
|
|
foreach my $line ($self->_lines_from_mgp_points($points)) {
|
||
|
|
my $point = SegmentIntersection([$p1, $p2, @$line]);
|
||
|
|
if ($point && !$self->points_coincide($point, $p1) && !$self->points_coincide($point, $p2)) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
sub points_coincide {
|
||
|
|
my $self = shift;
|
||
|
|
my ($p1, $p2) = @_;
|
||
|
|
return 0 if $p2->[0] - $p1->[0] < epsilon && $p2->[1] - $p1->[1] < epsilon;
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
sub _lines_from_mgp_points {
|
||
|
|
my $self = shift;
|
||
|
|
my ($points) = @_;
|
||
|
|
|
||
|
|
my @lines = ();
|
||
|
|
my $last_point = $points->[-1];
|
||
|
|
foreach my $point (@$points) {
|
||
|
|
push @lines, [ $last_point, $point ];
|
||
|
|
$last_point = $point;
|
||
|
|
}
|
||
|
|
return @lines;
|
||
|
|
}
|
||
|
|
|
||
|
|
sub _mgp_from_points_ref {
|
||
|
|
my $self = shift;
|
||
|
|
my ($points) = @_;
|
||
|
|
my $p = Math::Geometry::Planar->new;
|
||
|
|
$p->points($points);
|
||
|
|
return $p;
|
||
|
|
}
|
||
|
|
|
||
|
|
1;
|