PrusaSlicer-NonPlainar/lib/Slic3r/Fill/Rectilinear.pm

package Slic3r::Fill::Rectilinear;
use Moo;

extends 'Slic3r::Fill::Base';

has 'cache'         => (is => 'rw', default => sub {{}});

use Slic3r::Geometry qw(A B X Y MIN scale unscale scaled_epsilon);
use Slic3r::Geometry::Clipper qw(intersection_pl offset);

sub fill_surface {
    my $self = shift;
    my ($surface, %params) = @_;
    
    # rotate polygons so that we can work with vertical lines here
    my $expolygon = $surface->expolygon->clone;
    my $rotate_vector = $self->infill_direction($surface);
    $self->rotate_points($expolygon, $rotate_vector);
    
    my $flow                = $params{flow} or die "No flow supplied to fill_surface()";
    my $min_spacing         = $flow->scaled_spacing;
    my $line_spacing        = $min_spacing / $params{density};
    my $line_oscillation    = $line_spacing - $min_spacing;
    my $is_line_pattern     = $self->isa('Slic3r::Fill::Line');
    my $bounding_box        = $expolygon->bounding_box;
    
    # define flow spacing according to requested density
    if ($params{density} == 1 && !$params{dont_adjust}) {
        $line_spacing = $self->adjust_solid_spacing(
            width       => $bounding_box->size->[X],
            distance    => $line_spacing,
        );
        $flow = Slic3r::Flow->new_from_spacing(
            spacing             => unscale($line_spacing),
            nozzle_diameter     => $flow->nozzle_diameter,
            layer_height        => $surface->thickness,
            bridge              => $flow->bridge,
        );
    } else {
        # extend bounding box so that our pattern will be aligned with other layers
        $bounding_box->merge_point(Slic3r::Point->new(
            $bounding_box->x_min - ($bounding_box->x_min % $line_spacing),
            $bounding_box->y_min - ($bounding_box->y_min % $line_spacing),
        ));
    }
    
    # generate the basic pattern
    my $i               = 0;
    my $x               = $bounding_box->x_min;
    my $x_max           = $bounding_box->x_max + scaled_epsilon;
    my @vertical_lines  = ();
    while ($x <= $x_max) {
        my $vertical_line = [ [$x, $bounding_box->y_max], [$x, $bounding_box->y_min] ];
        if ($is_line_pattern && $i % 2) {
            $vertical_line->[A][X] += $line_oscillation;
            $vertical_line->[B][X] -= $line_oscillation;
        }
        push @vertical_lines, Slic3r::Polyline->new(@$vertical_line);
        $i++;
        $x += $line_spacing;
    }
    
    # clip paths against a slightly larger expolygon, so that the first and last paths
    # are kept even if the expolygon has vertical sides
    # the minimum offset for preventing edge lines from being clipped is scaled_epsilon;
    # however we use a larger offset to support expolygons with slightly skewed sides and 
    # not perfectly straight
    my @polylines = @{intersection_pl(\@vertical_lines, $expolygon->offset(scale 0.02))};
    
    # connect lines
    unless ($params{dont_connect} || !@polylines) {  # prevent calling leftmost_point() on empty collections
        my ($expolygon_off) = @{$expolygon->offset_ex($min_spacing/2)};
        my $collection = Slic3r::Polyline::Collection->new(@polylines);
        @polylines = ();
        
        my $tolerance = 10 * scaled_epsilon;
        my $diagonal_distance = $line_spacing * 2;
        my $can_connect = $is_line_pattern
            ? sub {
                ($_[X] >= ($line_spacing - $line_oscillation) - $tolerance) && ($_[X] <= ($line_spacing + $line_oscillation) + $tolerance)
                    && $_[Y] <= $diagonal_distance
            }
            : sub { $_[X] <= $diagonal_distance && $_[Y] <= $diagonal_distance };
        
        foreach my $polyline (@{$collection->chained_path_from($collection->leftmost_point, 0)}) {
            if (@polylines) {
                my $first_point = $polyline->first_point;
                my $last_point = $polylines[-1]->last_point;
                my @distance = map abs($first_point->$_ - $last_point->$_), qw(x y);
                
                # TODO: we should also check that both points are on a fill_boundary to avoid 
                # connecting paths on the boundaries of internal regions
                if ($can_connect->(@distance) && $expolygon_off->contains_line(Slic3r::Line->new($last_point, $first_point))) {
                    $polylines[-1]->append_polyline($polyline);
                    next;
                }
            }
            
            # make a clone before $collection goes out of scope
            push @polylines, $polyline->clone;
        }
    }
    
    # paths must be rotated back
    $self->rotate_points_back(\@polylines, $rotate_vector);
    
    return { flow => $flow }, @polylines;
}

1;