3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Implemented Slic3r::ExtrusionLoop

Browse source
This commit is contained in:
Alessandro Ranellucci 2013-07-15 16:21:09 +02:00
parent c9749ca3b3
commit d0701cdcd4
10 changed files with 145 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

50
lib/Slic3r/ExtrusionLoop.pm
View file

@ -1,38 +1,20 @@
package Slic3r::ExtrusionLoop;
use Moo;
use strict;
use warnings;
use Slic3r::Geometry qw(same_point);
# the underlying Slic3r::Polygon objects holds the geometry
has 'polygon' => (
is => 'rw',
required => 1,
handles => [qw(is_printable nearest_point_index_to reverse)],
);
has 'flow_spacing' => (is => 'rw', required => 1);
# see EXTR_ROLE_* constants in ExtrusionPath.pm
has 'role' => (is => 'rw', required => 1);
use constant PACK_FMT => 'fca*';
sub polygon { $_[0] }
# class or object method
sub pack {
my $self = shift;
my %args = @_;
if (ref $self) {
%args = map { $_ => $self->$_ } qw(flow_spacing role polygon);
return $self;
} else {
return $self->new(@_);
}
my $o = \ pack PACK_FMT,
$args{flow_spacing} || -1,
$args{role} // (die "Missing mandatory attribute 'role'"), #/
$args{polygon}->serialize;
bless $o, 'Slic3r::ExtrusionLoop::Packed';
return $o;
}
# no-op
@ -42,9 +24,10 @@ sub split_at_index {
my $self = shift;
return Slic3r::ExtrusionPath->new(
polyline => $self->polygon->split_at_index(@_),
polyline => $self->as_polygon->split_at_index(@_),
role => $self->role,
flow_spacing => $self->flow_spacing,
height => $self->height,
);
}
@ -52,9 +35,10 @@ sub split_at {
my $self = shift;
return Slic3r::ExtrusionPath->new(
polyline => $self->polygon->split_at(@_),
polyline => $self->as_polygon->split_at(@_),
role => $self->role,
flow_spacing => $self->flow_spacing,
height => $self->height,
);
}
@ -68,18 +52,4 @@ sub first_point {
return $self->polygon->[0];
}
package Slic3r::ExtrusionLoop::Packed;
sub unpack {
my $self = shift;
my ($flow_spacing, $role, $polygon_s)
= unpack Slic3r::ExtrusionLoop::PACK_FMT, $$self;
return Slic3r::ExtrusionLoop->new(
flow_spacing => ($flow_spacing == -1) ? undef : $flow_spacing,
role => $role,
polygon => Slic3r::Polygon->deserialize($polygon_s),
);
}
1;

12
lib/Slic3r/GCode.pm
View file

@ -142,7 +142,7 @@ sub move_z {
sub extrude {
my $self = shift;
($_[0]->isa('Slic3r::ExtrusionLoop') || $_[0]->isa('Slic3r::ExtrusionLoop::Packed'))
$_[0]->isa('Slic3r::ExtrusionLoop')
? $self->extrude_loop(@_)
: $self->extrude_path(@_);
}
@ -152,14 +152,14 @@ sub extrude_loop {
my ($loop, $description) = @_;
# extrude all loops ccw
$loop = $loop->unpack if $loop->isa('Slic3r::ExtrusionLoop::Packed');
my $was_clockwise = $loop->polygon->make_counter_clockwise;
my $polygon = $loop->as_polygon;
my $was_clockwise = $polygon->make_counter_clockwise;
# find candidate starting points
# start looking for concave vertices not being overhangs
my @concave = ();
if ($Slic3r::Config->start_perimeters_at_concave_points) {
@concave = $loop->polygon->concave_points;
@concave = $polygon->concave_points;
}
my @candidates = ();
if ($Slic3r::Config->start_perimeters_at_non_overhang) {
@ -171,11 +171,11 @@ sub extrude_loop {
if (!@candidates) {
# if none, look for any non-overhang vertex
if ($Slic3r::Config->start_perimeters_at_non_overhang) {
@candidates = grep !Boost::Geometry::Utils::point_covered_by_multi_polygon($_, $self->_layer_overhangs), @{$loop->polygon};
@candidates = grep !Boost::Geometry::Utils::point_covered_by_multi_polygon($_, $self->_layer_overhangs), @{$polygon};
}
if (!@candidates) {
# if none, all points are valid candidates
@candidates = @{$loop->polygon};
@candidates = @{$polygon};
}
}
}

4
lib/Slic3r/Polygon.pm
View file

@ -10,6 +10,8 @@ use Slic3r::Geometry qw(polygon_lines polygon_remove_parallel_continuous_edges
PI X1 X2 Y1 Y2 epsilon);
use Slic3r::Geometry::Clipper qw(JT_MITER);
sub arrayref { $_[0] }
sub lines {
my $self = shift;
return polygon_lines($self);
@ -22,7 +24,7 @@ sub wkt {
sub is_counter_clockwise {
my $self = shift;
return Slic3r::Geometry::Clipper::is_counter_clockwise($self);
return Slic3r::Geometry::Clipper::is_counter_clockwise($self->arrayref);
}
sub make_counter_clockwise {

1
lib/Slic3r/Test/SectionCut.pm
View file

@ -85,7 +85,6 @@ sub _plot {
my @paths =
map { $_->polyline->translate(@$copy); $_ }
map { $_->isa('Slic3r::ExtrusionLoop') ? $_->split_at_first_point : $_ }
map { ref($_) =~ /::Packed$/ ? $_->unpack : $_ }
map { $_->isa('Slic3r::ExtrusionPath::Collection') ? @{$_->paths} : $_ }
grep defined $_,
$filter->($layer);

17
xs/lib/Slic3r/XS.pm
View file

@ -29,16 +29,15 @@ use overload
'@{}' => sub { $_[0]->arrayref };
package Slic3r::ExtrusionLoop;
use overload
'@{}' => sub { $_[0]->arrayref },
'fallback' => 1;
sub new {
my ($class, %args) = @_;
my $polygon = ref($args{polygon}) eq 'Slic3r::Polygon::XS'
? $args{polygon}
: Slic3r::Polygon::XS->new(@{$args{polygon}});
return $class->_new(
$polygon, # required
$args{polygon}, # required
$args{role}, # required
$args{height} // -1,
$args{flow_spacing} // -1,
@ -49,7 +48,7 @@ sub clone {
my ($self, %args) = @_;
return (ref $self)->_new(
$args{polygon} // $self->polygon->clone,
$args{polygon} // $self->as_polygon,
$args{role} // $self->role,
$args{height} // $self->height,
$args{flow_spacing} // $self->flow_spacing,
@ -64,12 +63,8 @@ use overload
sub new {
my ($class, %args) = @_;
my $polyline = ref($args{polyline}) eq 'Slic3r::Polyline::XS'
? $args{polyline}
: Slic3r::Polyline::XS->new(@{$args{polyline}});
return $class->_new(
$polyline, # required
$args{polyline}, # required
$args{role}, # required
$args{height} // -1,
$args{flow_spacing} // -1,

10
xs/src/Polygon.hpp
View file

@ -29,6 +29,16 @@ perl2polygon(SV* poly_sv, Polygon& poly)
}
}
void
perl2polygon_check(SV* poly_sv, Polygon& poly)
{
if (sv_isobject(poly_sv) && (SvTYPE(SvRV(poly_sv)) == SVt_PVMG)) {
poly = *(Polygon*)SvIV((SV*)SvRV( poly_sv ));
} else {
perl2polygon(poly_sv, poly);
}
}
SV*
polygon2perl(Polygon& poly) {
const unsigned int num_points = poly.points.size();

10
xs/src/Polyline.hpp
View file

@ -68,6 +68,16 @@ perl2polyline(SV* poly_sv, Polyline& poly)
}
}
void
perl2polyline_check(SV* poly_sv, Polyline& poly)
{
if (sv_isobject(poly_sv) && (SvTYPE(SvRV(poly_sv)) == SVt_PVMG)) {
poly = *(Polyline*)SvIV((SV*)SvRV( poly_sv ));
} else {
perl2polyline(poly_sv, poly);
}
}
SV*
polyline2perl(Polyline& poly) {
const unsigned int num_points = poly.points.size();

29
xs/t/08_extrusionloop.t Normal file
View file

@ -0,0 +1,29 @@
#!/usr/bin/perl
use strict;
use warnings;
use Slic3r::XS;
use Test::More tests => 4;
my $square = [
[100, 100],
[200, 100],
[200, 200],
[100, 200],
];
my $loop = Slic3r::ExtrusionLoop->new(
polygon => Slic3r::Polygon::XS->new(@$square),
role => Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER,
);
isa_ok $loop->as_polygon, 'Slic3r::Polygon::XS', 'loop polygon';
is_deeply [ @{ $loop->as_polygon } ], [ @$square ], 'polygon points roundtrip';
$loop = $loop->clone;
is $loop->role, Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, 'role';
$loop->role(Slic3r::ExtrusionPath::EXTR_ROLE_FILL);
is $loop->role, Slic3r::ExtrusionPath::EXTR_ROLE_FILL, 'modify role';
__END__

65
xs/xsp/ExtrusionLoop.xsp Normal file
View file

@ -0,0 +1,65 @@
%module{Slic3r::XS};
%{
#include <myinit.h>
#include "ExtrusionEntity.hpp"
%}
%name{Slic3r::ExtrusionLoop} class ExtrusionLoop {
~ExtrusionLoop();
SV* arrayref()
%code{% RETVAL = polygon2perl(THIS->polygon); %};
Polygon* as_polygon()
%code{% const char* CLASS = "Slic3r::Polygon::XS"; RETVAL = new Polygon(THIS->polygon); %};
void set_polygon(SV* polygon_sv)
%code{% perl2polygon_check(polygon_sv, THIS->polygon); %};
%{
ExtrusionLoop*
_new(CLASS, polygon_sv, role, height, flow_spacing)
char* CLASS;
SV* polygon_sv;
ExtrusionRole role;
double height;
double flow_spacing;
CODE:
RETVAL = new ExtrusionLoop ();
perl2polygon_check(polygon_sv, RETVAL->polygon);
RETVAL->role = role;
RETVAL->height = height;
RETVAL->flow_spacing = flow_spacing;
OUTPUT:
RETVAL
ExtrusionRole
ExtrusionLoop::role(...)
CODE:
if (items > 1) {
THIS->role = (ExtrusionRole)SvUV(ST(1));
}
RETVAL = THIS->role;
OUTPUT:
RETVAL
double
ExtrusionLoop::height(...)
CODE:
if (items > 1) {
THIS->height = (double)SvNV(ST(1));
}
RETVAL = THIS->height;
OUTPUT:
RETVAL
double
ExtrusionLoop::flow_spacing(...)
CODE:
if (items > 1) {
THIS->flow_spacing = (double)SvNV(ST(1));
}
RETVAL = THIS->flow_spacing;
OUTPUT:
RETVAL
%}
};

35
xs/xsp/ExtrusionPath.xsp
View file

@ -9,6 +9,10 @@
~ExtrusionPath();
SV* arrayref()
%code{% RETVAL = polyline2perl(THIS->polyline); %};
Polyline* as_polyline()
%code{% const char* CLASS = "Slic3r::Polyline::XS"; RETVAL = new Polyline(THIS->polyline); %};
void set_polyline(SV* polyline_sv)
%code{% perl2polyline_check(polyline_sv, THIS->polyline); %};
void pop_back()
%code{% THIS->polyline.points.pop_back(); %};
void reverse();
@ -23,36 +27,13 @@ _new(CLASS, polyline_sv, role, height, flow_spacing)
double flow_spacing;
CODE:
RETVAL = new ExtrusionPath ();
if (sv_isobject(polyline_sv) && (SvTYPE(SvRV(polyline_sv)) == SVt_PVMG)) {
RETVAL->polyline = *(Polyline*)SvIV((SV*)SvRV( polyline_sv ));
} else {
perl2polyline(polyline_sv, RETVAL->polyline);
}
perl2polyline_check(polyline_sv, RETVAL->polyline);
RETVAL->role = role;
RETVAL->height = height;
RETVAL->flow_spacing = flow_spacing;
OUTPUT:
RETVAL
Polyline*
ExtrusionPath::as_polyline()
PREINIT:
const char* CLASS = "Slic3r::Polyline::XS";
CODE:
RETVAL = new Polyline(THIS->polyline);
OUTPUT:
RETVAL
void
ExtrusionPath::set_polyline(polyline_sv)
SV* polyline_sv;
CODE:
if (sv_isobject(polyline_sv) && (SvTYPE(SvRV(polyline_sv)) == SVt_PVMG)) {
THIS->polyline = *(Polyline*)SvIV((SV*)SvRV( polyline_sv ));
} else {
perl2polyline(polyline_sv, THIS->polyline);
}
ExtrusionRole
ExtrusionPath::role(...)
CODE:
@ -88,11 +69,7 @@ ExtrusionPath::append(...)
CODE:
for (unsigned int i = 1; i < items; i++) {
Point p;
if (sv_isobject(ST(i)) && (SvTYPE(SvRV(ST(i))) == SVt_PVMG)) {
p = *(Point*)SvIV((SV*)SvRV( ST(i) ));
} else {
perl2point(ST(i), p);
}
perl2point_check(ST(i), p);
THIS->polyline.points.push_back(p);
}