2011-09-01 23:06:28 +04:00
|
|
|
package Slic3r;
|
|
|
|
|
2012-01-18 23:04:18 +04:00
|
|
|
# Copyright holder: Alessandro Ranellucci
|
|
|
|
# This application is licensed under the GNU Affero General Public License, version 3
|
|
|
|
|
2011-09-01 23:06:28 +04:00
|
|
|
use strict;
|
|
|
|
use warnings;
|
2012-01-22 16:56:15 +04:00
|
|
|
require v5.10;
|
2011-09-01 23:06:28 +04:00
|
|
|
|
2014-05-03 00:20:20 +04:00
|
|
|
our $VERSION = "1.1.3-dev";
|
2011-11-14 01:57:58 +04:00
|
|
|
|
2011-09-05 15:33:09 +04:00
|
|
|
our $debug = 0;
|
|
|
|
sub debugf {
|
|
|
|
printf @_ if $debug;
|
|
|
|
}
|
|
|
|
|
2012-05-19 22:25:59 +04:00
|
|
|
# load threads before Moo as required by it
|
2012-05-21 21:16:42 +04:00
|
|
|
our $have_threads;
|
2012-05-21 20:44:31 +04:00
|
|
|
BEGIN {
|
|
|
|
use Config;
|
2013-02-27 14:08:08 +04:00
|
|
|
$have_threads = $Config{useithreads} && eval "use threads; use threads::shared; use Thread::Queue; 1";
|
2013-07-24 12:06:02 +04:00
|
|
|
|
|
|
|
### temporarily disable threads if using the broken Moo version
|
|
|
|
use Moo;
|
|
|
|
$have_threads = 0 if $Moo::VERSION == 1.003000;
|
2012-05-21 20:44:31 +04:00
|
|
|
}
|
2012-05-19 22:25:59 +04:00
|
|
|
|
2012-09-11 18:02:26 +04:00
|
|
|
warn "Running Slic3r under Perl >= 5.16 is not supported nor recommended\n"
|
|
|
|
if $^V >= v5.16;
|
|
|
|
|
2012-05-29 16:19:14 +04:00
|
|
|
use FindBin;
|
|
|
|
our $var = "$FindBin::Bin/var";
|
|
|
|
|
2013-01-13 13:18:34 +04:00
|
|
|
use Encode;
|
|
|
|
use Encode::Locale;
|
2013-09-12 13:09:03 +04:00
|
|
|
use Moo 1.003001;
|
2013-01-13 13:18:34 +04:00
|
|
|
|
2013-07-14 15:05:55 +04:00
|
|
|
use Slic3r::XS; # import all symbols (constants etc.) before they get parsed
|
2011-10-03 13:55:32 +04:00
|
|
|
use Slic3r::Config;
|
2011-10-15 13:36:05 +04:00
|
|
|
use Slic3r::ExPolygon;
|
2011-09-26 13:42:08 +04:00
|
|
|
use Slic3r::Extruder;
|
2011-09-26 01:15:45 +04:00
|
|
|
use Slic3r::ExtrusionLoop;
|
2011-09-04 14:04:01 +04:00
|
|
|
use Slic3r::ExtrusionPath;
|
2011-09-26 12:52:58 +04:00
|
|
|
use Slic3r::ExtrusionPath::Collection;
|
2011-09-05 14:21:27 +04:00
|
|
|
use Slic3r::Fill;
|
2012-06-06 20:05:03 +04:00
|
|
|
use Slic3r::Flow;
|
2012-02-25 20:35:25 +04:00
|
|
|
use Slic3r::Format::AMF;
|
2012-05-20 13:40:37 +04:00
|
|
|
use Slic3r::Format::OBJ;
|
2012-02-25 20:35:25 +04:00
|
|
|
use Slic3r::Format::STL;
|
2012-06-28 16:44:54 +04:00
|
|
|
use Slic3r::GCode;
|
2013-08-28 21:50:16 +04:00
|
|
|
use Slic3r::GCode::ArcFitting;
|
2013-04-04 03:17:44 +04:00
|
|
|
use Slic3r::GCode::CoolingBuffer;
|
2013-05-18 18:57:44 +04:00
|
|
|
use Slic3r::GCode::Layer;
|
2012-08-23 17:42:58 +04:00
|
|
|
use Slic3r::GCode::MotionPlanner;
|
2014-03-17 03:39:07 +04:00
|
|
|
use Slic3r::GCode::PlaceholderParser;
|
2013-05-13 22:14:33 +04:00
|
|
|
use Slic3r::GCode::Reader;
|
2013-05-13 22:15:45 +04:00
|
|
|
use Slic3r::GCode::SpiralVase;
|
2013-08-28 18:51:58 +04:00
|
|
|
use Slic3r::GCode::VibrationLimit;
|
2011-12-07 22:33:59 +04:00
|
|
|
use Slic3r::Geometry qw(PI);
|
2013-06-08 01:16:02 +04:00
|
|
|
use Slic3r::Geometry::Clipper;
|
2011-09-01 23:06:28 +04:00
|
|
|
use Slic3r::Layer;
|
2014-04-08 01:18:11 +04:00
|
|
|
use Slic3r::Layer::BridgeDetector;
|
2012-09-23 04:52:31 +04:00
|
|
|
use Slic3r::Layer::Region;
|
2011-09-01 23:06:28 +04:00
|
|
|
use Slic3r::Line;
|
2012-08-29 18:49:38 +04:00
|
|
|
use Slic3r::Model;
|
2011-09-01 23:06:28 +04:00
|
|
|
use Slic3r::Point;
|
2011-10-15 13:36:05 +04:00
|
|
|
use Slic3r::Polygon;
|
2011-09-01 23:06:28 +04:00
|
|
|
use Slic3r::Polyline;
|
|
|
|
use Slic3r::Print;
|
2012-04-29 14:51:20 +04:00
|
|
|
use Slic3r::Print::Object;
|
2012-09-23 04:52:31 +04:00
|
|
|
use Slic3r::Print::Region;
|
2014-01-02 20:54:18 +04:00
|
|
|
use Slic3r::Print::Simple;
|
2013-09-18 01:27:57 +04:00
|
|
|
use Slic3r::Print::SupportMaterial;
|
2011-09-01 23:06:28 +04:00
|
|
|
use Slic3r::Surface;
|
2011-11-27 14:40:03 +04:00
|
|
|
use Slic3r::TriangleMesh;
|
2013-04-27 22:55:43 +04:00
|
|
|
our $build = eval "use Slic3r::Build; 1";
|
2011-09-01 23:06:28 +04:00
|
|
|
|
2012-07-27 23:13:03 +04:00
|
|
|
use constant SCALING_FACTOR => 0.000001;
|
2012-11-18 20:38:08 +04:00
|
|
|
use constant RESOLUTION => 0.0125;
|
|
|
|
use constant SCALED_RESOLUTION => RESOLUTION / SCALING_FACTOR;
|
2012-07-27 23:13:03 +04:00
|
|
|
use constant SMALL_PERIMETER_LENGTH => (6.5 / SCALING_FACTOR) * 2 * PI;
|
2014-01-03 23:02:00 +04:00
|
|
|
use constant LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER => 0.15;
|
2013-03-17 03:57:58 +04:00
|
|
|
use constant INFILL_OVERLAP_OVER_SPACING => 0.45;
|
2013-08-13 11:45:33 +04:00
|
|
|
use constant EXTERNAL_INFILL_MARGIN => 3;
|
2014-04-15 03:41:40 +04:00
|
|
|
use constant INSET_OVERLAP_TOLERANCE => 0.2;
|
2012-07-27 23:13:03 +04:00
|
|
|
|
2012-04-09 14:29:47 +04:00
|
|
|
sub parallelize {
|
|
|
|
my %params = @_;
|
|
|
|
|
2013-12-24 14:29:31 +04:00
|
|
|
if (!$params{disable} && $Slic3r::have_threads && $params{threads} > 1) {
|
2012-09-22 21:04:36 +04:00
|
|
|
my @items = (ref $params{items} eq 'CODE') ? $params{items}->() : @{$params{items}};
|
2012-04-09 14:29:47 +04:00
|
|
|
my $q = Thread::Queue->new;
|
2013-12-24 14:29:31 +04:00
|
|
|
$q->enqueue(@items, (map undef, 1..$params{threads}));
|
2012-04-09 14:29:47 +04:00
|
|
|
|
2013-07-07 20:43:04 +04:00
|
|
|
my $thread_cb = sub {
|
2013-11-12 15:09:33 +04:00
|
|
|
$params{thread_cb}->($q);
|
2013-07-11 18:17:36 +04:00
|
|
|
Slic3r::thread_cleanup();
|
2013-11-12 15:09:33 +04:00
|
|
|
|
|
|
|
# This explicit exit avoids an untrappable
|
|
|
|
# "Attempt to free unreferenced scalar" error
|
|
|
|
# triggered on Ubuntu 12.04 32-bit when we're running
|
|
|
|
# from the Wx plater and
|
|
|
|
# we're reusing the same plater object more than once.
|
|
|
|
# The downside to using this exit is that we can't return
|
|
|
|
# any value to the main thread but we're not doing that
|
|
|
|
# anymore anyway.
|
|
|
|
# collect_cb is completely useless now
|
|
|
|
# and should be removed from the codebase.
|
|
|
|
threads->exit;
|
2013-07-07 20:43:04 +04:00
|
|
|
};
|
2013-09-18 01:14:49 +04:00
|
|
|
$params{collect_cb} ||= sub {};
|
2013-07-07 20:43:04 +04:00
|
|
|
|
2013-05-19 19:34:33 +04:00
|
|
|
@_ = ();
|
2013-12-24 14:29:31 +04:00
|
|
|
foreach my $th (map threads->create($thread_cb), 1..$params{threads}) {
|
2012-04-09 14:29:47 +04:00
|
|
|
$params{collect_cb}->($th->join);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$params{no_threads_cb}->();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-11 18:17:36 +04:00
|
|
|
# call this at the very end of each thread (except the main one)
|
|
|
|
# so that it does not try to free existing objects.
|
|
|
|
# at that stage, existing objects are only those that we
|
|
|
|
# inherited at the thread creation (thus shared) and those
|
|
|
|
# that we are returning: destruction will be handled by the
|
|
|
|
# main thread in both cases.
|
2013-09-18 01:14:49 +04:00
|
|
|
# reminder: do not destroy inherited objects in other threads,
|
|
|
|
# as the main thread will still try to destroy them when they
|
|
|
|
# go out of scope; in other words, if you're undef()'ing an
|
|
|
|
# object in a thread, make sure the main thread still holds a
|
|
|
|
# reference so that it won't be destroyed in thread.
|
2013-07-11 18:17:36 +04:00
|
|
|
sub thread_cleanup {
|
|
|
|
# prevent destruction of shared objects
|
|
|
|
no warnings 'redefine';
|
2013-12-22 03:39:03 +04:00
|
|
|
*Slic3r::Config::DESTROY = sub {};
|
2014-01-02 13:44:54 +04:00
|
|
|
*Slic3r::Config::Full::DESTROY = sub {};
|
2013-12-22 03:39:03 +04:00
|
|
|
*Slic3r::Config::Print::DESTROY = sub {};
|
2014-01-02 13:44:54 +04:00
|
|
|
*Slic3r::Config::PrintObject::DESTROY = sub {};
|
|
|
|
*Slic3r::Config::PrintRegion::DESTROY = sub {};
|
2013-07-16 11:49:34 +04:00
|
|
|
*Slic3r::ExPolygon::DESTROY = sub {};
|
2013-07-14 02:38:01 +04:00
|
|
|
*Slic3r::ExPolygon::Collection::DESTROY = sub {};
|
2014-04-08 03:42:29 +04:00
|
|
|
*Slic3r::Extruder::DESTROY = sub {};
|
2013-07-16 11:49:34 +04:00
|
|
|
*Slic3r::ExtrusionLoop::DESTROY = sub {};
|
|
|
|
*Slic3r::ExtrusionPath::DESTROY = sub {};
|
2013-07-19 00:29:12 +04:00
|
|
|
*Slic3r::ExtrusionPath::Collection::DESTROY = sub {};
|
2014-01-14 23:11:08 +04:00
|
|
|
*Slic3r::Flow::DESTROY = sub {};
|
|
|
|
*Slic3r::Geometry::BoundingBox::DESTROY = sub {};
|
|
|
|
*Slic3r::Geometry::BoundingBoxf3::DESTROY = sub {};
|
2013-07-16 11:49:34 +04:00
|
|
|
*Slic3r::Line::DESTROY = sub {};
|
2014-04-30 03:04:49 +04:00
|
|
|
*Slic3r::Model::DESTROY = sub {};
|
|
|
|
*Slic3r::Model::Object::DESTROY = sub {};
|
2013-07-16 11:49:34 +04:00
|
|
|
*Slic3r::Point::DESTROY = sub {};
|
2014-04-29 00:02:34 +04:00
|
|
|
*Slic3r::Pointf::DESTROY = sub {};
|
2014-01-14 23:11:08 +04:00
|
|
|
*Slic3r::Pointf3::DESTROY = sub {};
|
2013-07-16 11:49:34 +04:00
|
|
|
*Slic3r::Polygon::DESTROY = sub {};
|
|
|
|
*Slic3r::Polyline::DESTROY = sub {};
|
2013-09-12 13:09:03 +04:00
|
|
|
*Slic3r::Polyline::Collection::DESTROY = sub {};
|
2013-12-20 04:36:42 +04:00
|
|
|
*Slic3r::Print::State::DESTROY = sub {};
|
2013-07-16 11:49:34 +04:00
|
|
|
*Slic3r::Surface::DESTROY = sub {};
|
|
|
|
*Slic3r::Surface::Collection::DESTROY = sub {};
|
2013-09-12 13:09:03 +04:00
|
|
|
*Slic3r::TriangleMesh::DESTROY = sub {};
|
2013-09-19 18:00:47 +04:00
|
|
|
return undef; # this prevents a "Scalars leaked" warning
|
2013-07-11 18:17:36 +04:00
|
|
|
}
|
|
|
|
|
2013-02-22 21:40:00 +04:00
|
|
|
sub encode_path {
|
|
|
|
my ($filename) = @_;
|
|
|
|
return encode('locale_fs', $filename);
|
|
|
|
}
|
|
|
|
|
2013-01-13 13:18:34 +04:00
|
|
|
sub open {
|
|
|
|
my ($fh, $mode, $filename) = @_;
|
2013-02-22 21:40:00 +04:00
|
|
|
return CORE::open $$fh, $mode, encode_path($filename);
|
2013-01-13 13:18:34 +04:00
|
|
|
}
|
|
|
|
|
2013-12-13 15:18:30 +04:00
|
|
|
# this package declaration prevents an ugly fatal warning to be emitted when
|
|
|
|
# spawning a new thread
|
|
|
|
package GLUquadricObjPtr;
|
|
|
|
|
2011-09-01 23:06:28 +04:00
|
|
|
1;
|