Completely replaced the homebrew Pointf3 class with Eigen Vec3d.

Replaced the unscale macro with a template, implemented templates
for unscaling Eigen vectors.

29 files changed, 184 insertions, 228 deletions

diff --git a/xs/src/libslic3r/BoundingBox.cpp b/xs/src/libslic3r/BoundingBox.cpp
index 68136b916..81a748f8f 100644
--- a/xs/src/libslic3r/BoundingBox.cpp
+++ b/xs/src/libslic3r/BoundingBox.cpp
@@ -9,7 +9,7 @@ namespace Slic3r {
 template BoundingBoxBase<Point>::BoundingBoxBase(const std::vector<Point> &points);
 template BoundingBoxBase<Pointf>::BoundingBoxBase(const std::vector<Pointf> &points);
 
-template BoundingBox3Base<Pointf3>::BoundingBox3Base(const std::vector<Pointf3> &points);
+template BoundingBox3Base<Vec3d>::BoundingBox3Base(const std::vector<Vec3d> &points);
 
 BoundingBox::BoundingBox(const Lines &lines)
 {
@@ -22,8 +22,7 @@ BoundingBox::BoundingBox(const Lines &lines)
     *this = BoundingBox(points);
 }
 
-void
-BoundingBox::polygon(Polygon* polygon) const
+void BoundingBox::polygon(Polygon* polygon) const
 {
     polygon->points.clear();
     polygon->points.resize(4);
@@ -37,8 +36,7 @@ BoundingBox::polygon(Polygon* polygon) const
     polygon->points[3](1) = this->max(1);
 }
 
-Polygon
-BoundingBox::polygon() const
+Polygon BoundingBox::polygon() const
 {
     Polygon p;
     this->polygon(&p);
@@ -73,18 +71,17 @@ BoundingBoxBase<PointClass>::scale(double factor)
 }
 template void BoundingBoxBase<Point>::scale(double factor);
 template void BoundingBoxBase<Pointf>::scale(double factor);
-template void BoundingBoxBase<Pointf3>::scale(double factor);
+template void BoundingBoxBase<Vec3d>::scale(double factor);
 
 template <class PointClass> void
 BoundingBoxBase<PointClass>::merge(const PointClass &point)
 {
     if (this->defined) {
-        this->min(0) = std::min(point(0), this->min(0));
-        this->min(1) = std::min(point(1), this->min(1));
-        this->max(0) = std::max(point(0), this->max(0));
-        this->max(1) = std::max(point(1), this->max(1));
+        this->min = this->min.cwiseMin(point);
+        this->max = this->max.cwiseMax(point);
     } else {
-        this->min = this->max = point;
+        this->min = point;
+        this->max = point;
         this->defined = true;
     }
 }
@@ -105,10 +102,8 @@ BoundingBoxBase<PointClass>::merge(const BoundingBoxBase<PointClass> &bb)
     assert(bb.defined || bb.min(0) >= bb.max(0) || bb.min(1) >= bb.max(1));
     if (bb.defined) {
         if (this->defined) {
-            this->min(0) = std::min(bb.min(0), this->min(0));
-            this->min(1) = std::min(bb.min(1), this->min(1));
-            this->max(0) = std::max(bb.max(0), this->max(0));
-            this->max(1) = std::max(bb.max(1), this->max(1));
+            this->min = this->min.cwiseMin(bb.min);
+            this->max = this->max.cwiseMax(bb.max);
         } else {
             this->min = bb.min;
             this->max = bb.max;
@@ -123,19 +118,22 @@ template <class PointClass> void
 BoundingBox3Base<PointClass>::merge(const PointClass &point)
 {
     if (this->defined) {
-        this->min(2) = std::min(point(2), this->min(2));
-        this->max(2) = std::max(point(2), this->max(2));
+        this->min = this->min.cwiseMin(point);
+        this->max = this->max.cwiseMax(point);
+    } else {
+        this->min = point;
+        this->max = point;
+        this->defined = true;
     }
-    BoundingBoxBase<PointClass>::merge(point);
 }
-template void BoundingBox3Base<Pointf3>::merge(const Pointf3 &point);
+template void BoundingBox3Base<Vec3d>::merge(const Vec3d &point);
 
 template <class PointClass> void
 BoundingBox3Base<PointClass>::merge(const std::vector<PointClass> &points)
 {
     this->merge(BoundingBox3Base(points));
 }
-template void BoundingBox3Base<Pointf3>::merge(const Pointf3s &points);
+template void BoundingBox3Base<Vec3d>::merge(const Pointf3s &points);
 
 template <class PointClass> void
 BoundingBox3Base<PointClass>::merge(const BoundingBox3Base<PointClass> &bb)
@@ -143,13 +141,16 @@ BoundingBox3Base<PointClass>::merge(const BoundingBox3Base<PointClass> &bb)
     assert(bb.defined || bb.min(0) >= bb.max(0) || bb.min(1) >= bb.max(1) || bb.min(2) >= bb.max(2));
     if (bb.defined) {
         if (this->defined) {
-            this->min(2) = std::min(bb.min(2), this->min(2));
-            this->max(2) = std::max(bb.max(2), this->max(2));
+            this->min = this->min.cwiseMin(bb.min);
+            this->max = this->max.cwiseMax(bb.max);
+        } else {
+            this->min = bb.min;
+            this->max = bb.max;
+            this->defined = true;
         }
-        BoundingBoxBase<PointClass>::merge(bb);
     }
 }
-template void BoundingBox3Base<Pointf3>::merge(const BoundingBox3Base<Pointf3> &bb);
+template void BoundingBox3Base<Vec3d>::merge(const BoundingBox3Base<Vec3d> &bb);
 
 template <class PointClass> PointClass
 BoundingBoxBase<PointClass>::size() const
@@ -164,7 +165,7 @@ BoundingBox3Base<PointClass>::size() const
 {
     return PointClass(this->max(0) - this->min(0), this->max(1) - this->min(1), this->max(2) - this->min(2));
 }
-template Pointf3 BoundingBox3Base<Pointf3>::size() const;
+template Vec3d BoundingBox3Base<Vec3d>::size() const;
 
 template <class PointClass> double BoundingBoxBase<PointClass>::radius() const
 {
@@ -183,7 +184,7 @@ template <class PointClass> double BoundingBox3Base<PointClass>::radius() const
     double z = this->max(2) - this->min(2);
     return 0.5 * sqrt(x*x+y*y+z*z);
 }
-template double BoundingBox3Base<Pointf3>::radius() const;
+template double BoundingBox3Base<Vec3d>::radius() const;
 
 template <class PointClass> void
 BoundingBoxBase<PointClass>::offset(coordf_t delta)
@@ -202,15 +203,12 @@ BoundingBox3Base<PointClass>::offset(coordf_t delta)
     this->min -= v;
     this->max += v;
 }
-template void BoundingBox3Base<Pointf3>::offset(coordf_t delta);
+template void BoundingBox3Base<Vec3d>::offset(coordf_t delta);
 
 template <class PointClass> PointClass
 BoundingBoxBase<PointClass>::center() const
 {
-    return PointClass(
-        (this->max(0) + this->min(0))/2,
-        (this->max(1) + this->min(1))/2
-    );
+    return (this->min + this->max) / 2;
 }
 template Point BoundingBoxBase<Point>::center() const;
 template Pointf BoundingBoxBase<Pointf>::center() const;
@@ -218,13 +216,9 @@ template Pointf BoundingBoxBase<Pointf>::center() const;
 template <class PointClass> PointClass
 BoundingBox3Base<PointClass>::center() const
 {
-    return PointClass(
-        (this->max(0) + this->min(0))/2,
-        (this->max(1) + this->min(1))/2,
-        (this->max(2) + this->min(2))/2
-    );
+    return (this->min + this->max) / 2;
 }
-template Pointf3 BoundingBox3Base<Pointf3>::center() const;
+template Vec3d BoundingBox3Base<Vec3d>::center() const;
 
 template <class PointClass> coordf_t
 BoundingBox3Base<PointClass>::max_size() const
@@ -232,7 +226,7 @@ BoundingBox3Base<PointClass>::max_size() const
     PointClass s = size();
     return std::max(s(0), std::max(s(1), s(2)));
 }
-template coordf_t BoundingBox3Base<Pointf3>::max_size() const;
+template coordf_t BoundingBox3Base<Vec3d>::max_size() const;
 
 // Align a coordinate to a grid. The coordinate may be negative,
 // the aligned value will never be bigger than the original one.
@@ -287,7 +281,7 @@ BoundingBoxf3 BoundingBoxf3::transformed(const Transform3f& matrix) const
         max_z = std::max(max_z, transf_vertices(2, i));
     }
 
-    return BoundingBoxf3(Pointf3((coordf_t)min_x, (coordf_t)min_y, (coordf_t)min_z), Pointf3((coordf_t)max_x, (coordf_t)max_y, (coordf_t)max_z));
+    return BoundingBoxf3(Vec3d((coordf_t)min_x, (coordf_t)min_y, (coordf_t)min_z), Vec3d((coordf_t)max_x, (coordf_t)max_y, (coordf_t)max_z));
 }
 
 }
diff --git a/xs/src/libslic3r/BoundingBox.hpp b/xs/src/libslic3r/BoundingBox.hpp
index d09658774..7a0287860 100644
--- a/xs/src/libslic3r/BoundingBox.hpp
+++ b/xs/src/libslic3r/BoundingBox.hpp
@@ -7,11 +7,6 @@
 
 namespace Slic3r {
 
-typedef Point   Size;
-typedef Point3  Size3;
-typedef Pointf  Sizef;
-typedef Pointf3 Sizef3;
-
 template <class PointClass>
 class BoundingBoxBase
 {
@@ -20,7 +15,7 @@ public:
     PointClass max;
     bool defined;
     
-    BoundingBoxBase() : defined(false) {};
+    BoundingBoxBase() : defined(false), min(PointClass::Zero()), max(PointClass::Zero()) {}
     BoundingBoxBase(const PointClass &pmin, const PointClass &pmax) : 
         min(pmin), max(pmax), defined(pmin(0) < pmax(0) && pmin(1) < pmax(1)) {}
     BoundingBoxBase(const std::vector<PointClass>& points)
@@ -29,14 +24,11 @@ public:
             CONFESS("Empty point set supplied to BoundingBoxBase constructor");
 
         typename std::vector<PointClass>::const_iterator it = points.begin();
-        this->min(0) = this->max(0) = (*it)(0);
-        this->min(1) = this->max(1) = (*it)(1);
-        for (++it; it != points.end(); ++it)
-        {
-            this->min(0) = std::min((*it)(0), this->min(0));
-            this->min(1) = std::min((*it)(1), this->min(1));
-            this->max(0) = std::max((*it)(0), this->max(0));
-            this->max(1) = std::max((*it)(1), this->max(1));
+        this->min = *it;
+        this->max = *it;
+        for (++ it; it != points.end(); ++ it) {
+            this->min = this->min.cwiseMin(*it);
+            this->max = this->max.cwiseMax(*it);
         }
         this->defined = (this->min(0) < this->max(0)) && (this->min(1) < this->max(1));
     }
@@ -71,19 +63,17 @@ public:
         BoundingBoxBase<PointClass>(pmin, pmax) 
         { if (pmin(2) >= pmax(2)) BoundingBoxBase<PointClass>::defined = false; }
     BoundingBox3Base(const std::vector<PointClass>& points)
-        : BoundingBoxBase<PointClass>(points)
     {
         if (points.empty())
             CONFESS("Empty point set supplied to BoundingBox3Base constructor");
-
         typename std::vector<PointClass>::const_iterator it = points.begin();
-        this->min(2) = this->max(2) = (*it)(2);
-        for (++it; it != points.end(); ++it)
-        {
-            this->min(2) = std::min((*it)(2), this->min(2));
-            this->max(2) = std::max((*it)(2), this->max(2));
+        this->min = *it;
+        this->max = *it;
+        for (++ it; it != points.end(); ++ it) {
+            this->min = this->min.cwiseMin(*it);
+            this->max = this->max.cwiseMax(*it);
         }
-        this->defined &= (this->min(2) < this->max(2));
+        this->defined = (this->min(0) < this->max(0)) && (this->min(1) < this->max(1)) && (this->min(2) < this->max(2));
     }
     void merge(const PointClass &point);
     void merge(const std::vector<PointClass> &points);
@@ -91,7 +81,7 @@ public:
     PointClass size() const;
     double radius() const;
     void translate(coordf_t x, coordf_t y, coordf_t z) { assert(this->defined); PointClass v(x, y, z); this->min += v; this->max += v; }
-    void translate(const Pointf3 &v) { this->min += v; this->max += v; }
+    void translate(const Vec3d &v) { this->min += v; this->max += v; }
     void offset(coordf_t delta);
     PointClass center() const;
     coordf_t max_size() const;
@@ -146,12 +136,12 @@ public:
     BoundingBoxf(const std::vector<Pointf> &points) : BoundingBoxBase<Pointf>(points) {};
 };
 
-class BoundingBoxf3 : public BoundingBox3Base<Pointf3> 
+class BoundingBoxf3 : public BoundingBox3Base<Vec3d> 
 {
 public:
-    BoundingBoxf3() : BoundingBox3Base<Pointf3>() {};
-    BoundingBoxf3(const Pointf3 &pmin, const Pointf3 &pmax) : BoundingBox3Base<Pointf3>(pmin, pmax) {};
-    BoundingBoxf3(const std::vector<Pointf3> &points) : BoundingBox3Base<Pointf3>(points) {};
+    BoundingBoxf3() : BoundingBox3Base<Vec3d>() {};
+    BoundingBoxf3(const Vec3d &pmin, const Vec3d &pmax) : BoundingBox3Base<Vec3d>(pmin, pmax) {};
+    BoundingBoxf3(const std::vector<Vec3d> &points) : BoundingBox3Base<Vec3d>(points) {};
 
     BoundingBoxf3 transformed(const Transform3f& matrix) const;
 };
diff --git a/xs/src/libslic3r/ExtrusionEntity.hpp b/xs/src/libslic3r/ExtrusionEntity.hpp
index 15363e8ed..90675c04a 100644
--- a/xs/src/libslic3r/ExtrusionEntity.hpp
+++ b/xs/src/libslic3r/ExtrusionEntity.hpp
@@ -149,7 +149,7 @@ public:
     // Minimum volumetric velocity of this extrusion entity. Used by the constant nozzle pressure algorithm.
     double min_mm3_per_mm() const { return this->mm3_per_mm; }
     Polyline as_polyline() const { return this->polyline; }
-    virtual double total_volume() const { return mm3_per_mm * unscale(length()); }
+    virtual double total_volume() const { return mm3_per_mm * unscale<double>(length()); }
 
 private:
     void _inflate_collection(const Polylines &polylines, ExtrusionEntityCollection* collection) const;
diff --git a/xs/src/libslic3r/Fill/FillConcentric.cpp b/xs/src/libslic3r/Fill/FillConcentric.cpp
index d0f9510cc..8a3a7ea89 100644
--- a/xs/src/libslic3r/Fill/FillConcentric.cpp
+++ b/xs/src/libslic3r/Fill/FillConcentric.cpp
@@ -21,7 +21,7 @@ void FillConcentric::_fill_surface_single(
     
     if (params.density > 0.9999f && !params.dont_adjust) {
         distance = this->_adjust_solid_spacing(bounding_box.size()(0), distance);
-        this->spacing = unscale(distance);
+        this->spacing = unscale<double>(distance);
     }
 
     Polygons loops = (Polygons)expolygon;
diff --git a/xs/src/libslic3r/Fill/FillGyroid.cpp b/xs/src/libslic3r/Fill/FillGyroid.cpp
index 003893649..bbaebc5f9 100644
--- a/xs/src/libslic3r/Fill/FillGyroid.cpp
+++ b/xs/src/libslic3r/Fill/FillGyroid.cpp
@@ -71,10 +71,10 @@ static std::vector<Pointf> make_one_period(double width, double scaleFactor, dou
     for (unsigned int i=1;i<points.size()-1;++i) {
         auto& lp = points[i-1]; // left point
         auto& tp = points[i];   // this point
+        Vec2d lrv = tp - lp;
         auto& rp = points[i+1]; // right point
         // calculate distance of the point to the line:
-        double dist_mm = unscale(scaleFactor * std::abs( (rp(1) - lp(1))*tp(0) + (lp(0) - rp(0))*tp(1) + (rp(0)*lp(1) - rp(1)*lp(0)) ) / std::hypot((rp(1) - lp(1)),(lp(0) - rp(0))));
-
+        double dist_mm = unscale<double>(scaleFactor) * std::abs(cross2(rp, lp) - cross2(rp - lp, tp)) / lrv.norm();
         if (dist_mm > tolerance) {                               // if the difference from straight line is more than this
             double x = 0.5f * (points[i-1](0) + points[i](0));
             points.emplace_back(Pointf(x, f(x, z_sin, z_cos, vertical, flip)));
diff --git a/xs/src/libslic3r/Fill/FillRectilinear.cpp b/xs/src/libslic3r/Fill/FillRectilinear.cpp
index 2209d219e..205eb1b66 100644
--- a/xs/src/libslic3r/Fill/FillRectilinear.cpp
+++ b/xs/src/libslic3r/Fill/FillRectilinear.cpp
@@ -27,7 +27,7 @@ void FillRectilinear::_fill_surface_single(
     // define flow spacing according to requested density
     if (params.density > 0.9999f && !params.dont_adjust) {
         this->_line_spacing = this->_adjust_solid_spacing(bounding_box.size()(0), this->_line_spacing);
-        this->spacing = unscale(this->_line_spacing);
+        this->spacing = unscale<double>(this->_line_spacing);
     } else {
         // extend bounding box so that our pattern will be aligned with other layers
         // Transform the reference point to the rotated coordinate system.
diff --git a/xs/src/libslic3r/Fill/FillRectilinear2.cpp b/xs/src/libslic3r/Fill/FillRectilinear2.cpp
index f18ab0f62..65440d0ef 100644
--- a/xs/src/libslic3r/Fill/FillRectilinear2.cpp
+++ b/xs/src/libslic3r/Fill/FillRectilinear2.cpp
@@ -792,7 +792,7 @@ bool FillRectilinear2::fill_surface_by_lines(const Surface *surface, const FillP
     // define flow spacing according to requested density
     if (params.full_infill() && !params.dont_adjust) {
         line_spacing = this->_adjust_solid_spacing(bounding_box.size()(0), line_spacing);
-        this->spacing = unscale(line_spacing);
+        this->spacing = unscale<double>(line_spacing);
     } else {
         // extend bounding box so that our pattern will be aligned with other layers
         // Transform the reference point to the rotated coordinate system.
diff --git a/xs/src/libslic3r/Fill/FillRectilinear3.cpp b/xs/src/libslic3r/Fill/FillRectilinear3.cpp
index d80bbfe6e..72c8b1ec5 100644
--- a/xs/src/libslic3r/Fill/FillRectilinear3.cpp
+++ b/xs/src/libslic3r/Fill/FillRectilinear3.cpp
@@ -391,7 +391,7 @@ static bool prepare_infill_hatching_segments(
         // Full infill, adjust the line spacing to fit an integer number of lines.
         out.line_spacing = Fill::_adjust_solid_spacing(bounding_box.size()(0), line_spacing);
         // Report back the adjusted line spacing.
-        fill_dir_params.spacing = float(unscale(line_spacing));
+        fill_dir_params.spacing = unscale<double>(line_spacing);
     } else {
         // Extend bounding box so that our pattern will be aligned with the other layers.
         // Transform the reference point to the rotated coordinate system.
diff --git a/xs/src/libslic3r/GCode.cpp b/xs/src/libslic3r/GCode.cpp
index 419299135..2f911440a 100644
--- a/xs/src/libslic3r/GCode.cpp
+++ b/xs/src/libslic3r/GCode.cpp
@@ -64,7 +64,7 @@ std::string OozePrevention::pre_toolchange(GCode &gcodegen)
     // move to the nearest standby point
     if (!this->standby_points.empty()) {
         // get current position in print coordinates
-        Pointf3 writer_pos = gcodegen.writer().get_position();
+        Vec3d writer_pos = gcodegen.writer().get_position();
         Point pos = Point::new_scale(writer_pos(0), writer_pos(1));
         
         // find standby point
@@ -74,7 +74,7 @@ std::string OozePrevention::pre_toolchange(GCode &gcodegen)
         /*  We don't call gcodegen.travel_to() because we don't need retraction (it was already
             triggered by the caller) nor avoid_crossing_perimeters and also because the coordinates
             of the destination point must not be transformed by origin nor current extruder offset.  */
-        gcode += gcodegen.writer().travel_to_xy(Pointf::new_unscale(standby_point), 
+        gcode += gcodegen.writer().travel_to_xy(unscale(standby_point), 
             "move to standby position");
     }
     
@@ -831,7 +831,7 @@ void GCode::_do_export(Print &print, FILE *file, GCodePreviewData *preview_data)
                     final_extruder_id   = tool_ordering.last_extruder();
                     assert(final_extruder_id != (unsigned int)-1);
                 }
-                this->set_origin(unscale(copy(0)), unscale(copy(1)));
+                this->set_origin(unscale(copy));
                 if (finished_objects > 0) {
                     // Move to the origin position for the copy we're going to print.
                     // This happens before Z goes down to layer 0 again, so that no collision happens hopefully.
@@ -1547,7 +1547,7 @@ void GCode::process_layer(
                     if (m_last_obj_copy != this_object_copy)
                         m_avoid_crossing_perimeters.use_external_mp_once = true;
                     m_last_obj_copy = this_object_copy;
-                    this->set_origin(unscale(copy(0)), unscale(copy(1)));
+                    this->set_origin(unscale(copy));
                     if (object_by_extruder.support != nullptr && !print_wipe_extrusions) {
                         m_layer = layers[layer_id].support_layer;
                         gcode += this->extrude_support(
@@ -2621,9 +2621,7 @@ std::string GCode::set_extruder(unsigned int extruder_id)
 Pointf GCode::point_to_gcode(const Point &point) const
 {
     Pointf extruder_offset = EXTRUDER_CONFIG(extruder_offset);
-    return Pointf(
-        unscale(point(0)) + m_origin(0) - extruder_offset(0),
-        unscale(point(1)) + m_origin(1) - extruder_offset(1));
+    return unscale(point) + m_origin - extruder_offset;
 }
 
 // convert a model-space scaled point into G-code coordinates
@@ -2635,7 +2633,6 @@ Point GCode::gcode_to_point(const Pointf &point) const
         scale_(point(1) - m_origin(1) + extruder_offset(1)));
 }
 
-
 // Goes through by_region std::vector and returns reference to a subvector of entities, that are to be printed
 // during infill/perimeter wiping, or normally (depends on wiping_entities parameter)
 // Returns a reference to member to avoid copying.
diff --git a/xs/src/libslic3r/GCode/Analyzer.cpp b/xs/src/libslic3r/GCode/Analyzer.cpp
index 44e6e9acb..ce9a9ac8e 100644
--- a/xs/src/libslic3r/GCode/Analyzer.cpp
+++ b/xs/src/libslic3r/GCode/Analyzer.cpp
@@ -14,7 +14,7 @@ static const float MMMIN_TO_MMSEC = 1.0f / 60.0f;
 static const float INCHES_TO_MM = 25.4f;
 static const float DEFAULT_FEEDRATE = 0.0f;
 static const unsigned int DEFAULT_EXTRUDER_ID = 0;
-static const Slic3r::Pointf3 DEFAULT_START_POSITION = Slic3r::Pointf3(0.0f, 0.0f, 0.0f);
+static const Slic3r::Vec3d DEFAULT_START_POSITION = Slic3r::Vec3d(0.0f, 0.0f, 0.0f);
 static const float DEFAULT_START_EXTRUSION = 0.0f;
 
 namespace Slic3r {
@@ -71,7 +71,7 @@ bool GCodeAnalyzer::Metadata::operator != (const GCodeAnalyzer::Metadata& other)
     return false;
 }
 
-GCodeAnalyzer::GCodeMove::GCodeMove(GCodeMove::EType type, ExtrusionRole extrusion_role, unsigned int extruder_id, double mm3_per_mm, float width, float height, float feedrate, const Pointf3& start_position, const Pointf3& end_position, float delta_extruder)
+GCodeAnalyzer::GCodeMove::GCodeMove(GCodeMove::EType type, ExtrusionRole extrusion_role, unsigned int extruder_id, double mm3_per_mm, float width, float height, float feedrate, const Vec3d& start_position, const Vec3d& end_position, float delta_extruder)
     : type(type)
     , data(extrusion_role, extruder_id, mm3_per_mm, width, height, feedrate)
     , start_position(start_position)
@@ -80,7 +80,7 @@ GCodeAnalyzer::GCodeMove::GCodeMove(GCodeMove::EType type, ExtrusionRole extrusi
 {
 }
 
-GCodeAnalyzer::GCodeMove::GCodeMove(GCodeMove::EType type, const GCodeAnalyzer::Metadata& data, const Pointf3& start_position, const Pointf3& end_position, float delta_extruder)
+GCodeAnalyzer::GCodeMove::GCodeMove(GCodeMove::EType type, const GCodeAnalyzer::Metadata& data, const Vec3d& start_position, const Vec3d& end_position, float delta_extruder)
     : type(type)
     , data(data)
     , start_position(start_position)
@@ -587,12 +587,12 @@ void GCodeAnalyzer::_reset_axes_position()
     ::memset((void*)m_state.position, 0, Num_Axis * sizeof(float));
 }
 
-void GCodeAnalyzer::_set_start_position(const Pointf3& position)
+void GCodeAnalyzer::_set_start_position(const Vec3d& position)
 {
     m_state.start_position = position;
 }
 
-const Pointf3& GCodeAnalyzer::_get_start_position() const
+const Vec3d& GCodeAnalyzer::_get_start_position() const
 {
     return m_state.start_position;
 }
@@ -612,9 +612,9 @@ float GCodeAnalyzer::_get_delta_extrusion() const
     return _get_axis_position(E) - m_state.start_extrusion;
 }
 
-Pointf3 GCodeAnalyzer::_get_end_position() const
+Vec3d GCodeAnalyzer::_get_end_position() const
 {
-    return Pointf3(m_state.position[X], m_state.position[Y], m_state.position[Z]);
+    return Vec3d(m_state.position[X], m_state.position[Y], m_state.position[Z]);
 }
 
 void GCodeAnalyzer::_store_move(GCodeAnalyzer::GCodeMove::EType type)
@@ -673,7 +673,7 @@ void GCodeAnalyzer::_calc_gcode_preview_extrusion_layers(GCodePreviewData& previ
     Metadata data;
     float z = FLT_MAX;
     Polyline polyline;
-    Pointf3 position(FLT_MAX, FLT_MAX, FLT_MAX);
+    Vec3d position(FLT_MAX, FLT_MAX, FLT_MAX);
     float volumetric_rate = FLT_MAX;
     GCodePreviewData::Range height_range;
     GCodePreviewData::Range width_range;
@@ -742,7 +742,7 @@ void GCodeAnalyzer::_calc_gcode_preview_travel(GCodePreviewData& preview_data)
         return;
 
     Polyline3 polyline;
-    Pointf3 position(FLT_MAX, FLT_MAX, FLT_MAX);
+    Vec3d position(FLT_MAX, FLT_MAX, FLT_MAX);
     GCodePreviewData::Travel::EType type = GCodePreviewData::Travel::Num_Types;
     GCodePreviewData::Travel::Polyline::EDirection direction = GCodePreviewData::Travel::Polyline::Num_Directions;
     float feedrate = FLT_MAX;
diff --git a/xs/src/libslic3r/GCode/Analyzer.hpp b/xs/src/libslic3r/GCode/Analyzer.hpp
index 03dbab338..27a49b869 100644
--- a/xs/src/libslic3r/GCode/Analyzer.hpp
+++ b/xs/src/libslic3r/GCode/Analyzer.hpp
@@ -75,12 +75,12 @@ public:
 
         EType type;
         Metadata data;
-        Pointf3 start_position;
-        Pointf3 end_position;
+        Vec3d start_position;
+        Vec3d end_position;
         float delta_extruder;
 
-        GCodeMove(EType type, ExtrusionRole extrusion_role, unsigned int extruder_id, double mm3_per_mm, float width, float height, float feedrate, const Pointf3& start_position, const Pointf3& end_position, float delta_extruder);
-        GCodeMove(EType type, const Metadata& data, const Pointf3& start_position, const Pointf3& end_position, float delta_extruder);
+        GCodeMove(EType type, ExtrusionRole extrusion_role, unsigned int extruder_id, double mm3_per_mm, float width, float height, float feedrate, const Vec3d& start_position, const Vec3d& end_position, float delta_extruder);
+        GCodeMove(EType type, const Metadata& data, const Vec3d& start_position, const Vec3d& end_position, float delta_extruder);
     };
 
     typedef std::vector<GCodeMove> GCodeMovesList;
@@ -93,7 +93,7 @@ private:
         EPositioningType global_positioning_type;
         EPositioningType e_local_positioning_type;
         Metadata data;
-        Pointf3 start_position;
+        Vec3d start_position = Vec3d::Zero();
         float start_extrusion;
         float position[Num_Axis];
     };
@@ -206,15 +206,15 @@ private:
     // Sets axes position to zero
     void _reset_axes_position();
 
-    void _set_start_position(const Pointf3& position);
-    const Pointf3& _get_start_position() const;
+    void _set_start_position(const Vec3d& position);
+    const Vec3d& _get_start_position() const;
 
     void _set_start_extrusion(float extrusion);
     float _get_start_extrusion() const;
     float _get_delta_extrusion() const;
 
     // Returns current xyz position (from m_state.position[])
-    Pointf3 _get_end_position() const;
+    Vec3d _get_end_position() const;
 
     // Adds a new move with the given data
     void _store_move(GCodeMove::EType type);
diff --git a/xs/src/libslic3r/GCode/CoolingBuffer.cpp b/xs/src/libslic3r/GCode/CoolingBuffer.cpp
index 0f361b250..40ccc7b09 100644
--- a/xs/src/libslic3r/GCode/CoolingBuffer.cpp
+++ b/xs/src/libslic3r/GCode/CoolingBuffer.cpp
@@ -23,7 +23,7 @@ CoolingBuffer::CoolingBuffer(GCode &gcodegen) : m_gcodegen(gcodegen), m_current_
 void CoolingBuffer::reset()
 {
     m_current_pos.assign(5, 0.f);
-    Pointf3 pos = m_gcodegen.writer().get_position();
+    Vec3d pos = m_gcodegen.writer().get_position();
     m_current_pos[0] = float(pos(0));
     m_current_pos[1] = float(pos(1));
     m_current_pos[2] = float(pos(2));
diff --git a/xs/src/libslic3r/GCode/PrintExtents.cpp b/xs/src/libslic3r/GCode/PrintExtents.cpp
index e1d4e257f..a1cd0cde9 100644
--- a/xs/src/libslic3r/GCode/PrintExtents.cpp
+++ b/xs/src/libslic3r/GCode/PrintExtents.cpp
@@ -32,8 +32,8 @@ static inline BoundingBoxf extrusionentity_extents(const ExtrusionPath &extrusio
     BoundingBox bbox = extrusion_polyline_extents(extrusion_path.polyline, scale_(0.5 * extrusion_path.width));
     BoundingBoxf bboxf;
     if (! empty(bbox)) {
-        bboxf.min = Pointf::new_unscale(bbox.min);
-        bboxf.max = Pointf::new_unscale(bbox.max);
+        bboxf.min = unscale(bbox.min);
+        bboxf.max = unscale(bbox.max);
 		bboxf.defined = true;
     }
     return bboxf;
@@ -46,8 +46,8 @@ static inline BoundingBoxf extrusionentity_extents(const ExtrusionLoop &extrusio
         bbox.merge(extrusion_polyline_extents(extrusion_path.polyline, scale_(0.5 * extrusion_path.width)));
     BoundingBoxf bboxf;
     if (! empty(bbox)) {
-        bboxf.min = Pointf::new_unscale(bbox.min);
-        bboxf.max = Pointf::new_unscale(bbox.max);
+        bboxf.min = unscale(bbox.min);
+        bboxf.max = unscale(bbox.max);
 		bboxf.defined = true;
 	}
     return bboxf;
@@ -60,8 +60,8 @@ static inline BoundingBoxf extrusionentity_extents(const ExtrusionMultiPath &ext
         bbox.merge(extrusion_polyline_extents(extrusion_path.polyline, scale_(0.5 * extrusion_path.width)));
     BoundingBoxf bboxf;
     if (! empty(bbox)) {
-        bboxf.min = Pointf::new_unscale(bbox.min);
-        bboxf.max = Pointf::new_unscale(bbox.max);
+        bboxf.min = unscale(bbox.min);
+        bboxf.max = unscale(bbox.max);
 		bboxf.defined = true;
 	}
     return bboxf;
@@ -123,7 +123,7 @@ BoundingBoxf get_print_object_extrusions_extents(const PrintObject &print_object
                 bbox_this.merge(extrusionentity_extents(extrusion_entity));
         for (const Point &offset : print_object._shifted_copies) {
             BoundingBoxf bbox_translated(bbox_this);
-            bbox_translated.translate(Pointf::new_unscale(offset));
+            bbox_translated.translate(unscale(offset));
             bbox.merge(bbox_translated);
         }
     }
diff --git a/xs/src/libslic3r/GCodeWriter.cpp b/xs/src/libslic3r/GCodeWriter.cpp
index cefbdad2e..5352e9502 100644
--- a/xs/src/libslic3r/GCodeWriter.cpp
+++ b/xs/src/libslic3r/GCodeWriter.cpp
@@ -290,7 +290,7 @@ std::string GCodeWriter::travel_to_xy(const Pointf &point, const std::string &co
     return gcode.str();
 }
 
-std::string GCodeWriter::travel_to_xyz(const Pointf3 &point, const std::string &comment)
+std::string GCodeWriter::travel_to_xyz(const Vec3d &point, const std::string &comment)
 {
     /*  If target Z is lower than current Z but higher than nominal Z we
         don't perform the Z move but we only move in the XY plane and
@@ -299,7 +299,7 @@ std::string GCodeWriter::travel_to_xyz(const Pointf3 &point, const std::string &
     if (!this->will_move_z(point(2))) {
         double nominal_z = m_pos(2) - m_lifted;
         m_lifted = m_lifted - (point(2) - nominal_z);
-        return this->travel_to_xy(point.xy());
+        return this->travel_to_xy(to_2d(point));
     }
     
     /*  In all the other cases, we perform an actual XYZ move and cancel
@@ -373,7 +373,7 @@ std::string GCodeWriter::extrude_to_xy(const Pointf &point, double dE, const std
     return gcode.str();
 }
 
-std::string GCodeWriter::extrude_to_xyz(const Pointf3 &point, double dE, const std::string &comment)
+std::string GCodeWriter::extrude_to_xyz(const Vec3d &point, double dE, const std::string &comment)
 {
     m_pos = point;
     m_lifted = 0;
diff --git a/xs/src/libslic3r/GCodeWriter.hpp b/xs/src/libslic3r/GCodeWriter.hpp
index f706b8768..d02bbfe60 100644
--- a/xs/src/libslic3r/GCodeWriter.hpp
+++ b/xs/src/libslic3r/GCodeWriter.hpp
@@ -56,17 +56,17 @@ public:
     std::string toolchange(unsigned int extruder_id);
     std::string set_speed(double F, const std::string &comment = std::string(), const std::string &cooling_marker = std::string()) const;
     std::string travel_to_xy(const Pointf &point, const std::string &comment = std::string());
-    std::string travel_to_xyz(const Pointf3 &point, const std::string &comment = std::string());
+    std::string travel_to_xyz(const Vec3d &point, const std::string &comment = std::string());
     std::string travel_to_z(double z, const std::string &comment = std::string());
     bool        will_move_z(double z) const;
     std::string extrude_to_xy(const Pointf &point, double dE, const std::string &comment = std::string());
-    std::string extrude_to_xyz(const Pointf3 &point, double dE, const std::string &comment = std::string());
+    std::string extrude_to_xyz(const Vec3d &point, double dE, const std::string &comment = std::string());
     std::string retract(bool before_wipe = false);
     std::string retract_for_toolchange(bool before_wipe = false);
     std::string unretract();
     std::string lift();
     std::string unlift();
-    Pointf3     get_position() const { return m_pos; }
+    Vec3d       get_position() const { return m_pos; }
 
 private:
     std::vector<Extruder>    m_extruders;
@@ -81,7 +81,7 @@ private:
     unsigned int    m_last_bed_temperature;
     bool            m_last_bed_temperature_reached;
     double          m_lifted;
-    Pointf3         m_pos;
+    Vec3d           m_pos = Vec3d::Zero();
 
     std::string _travel_to_z(double z, const std::string &comment);
     std::string _retract(double length, double restart_extra, const std::string &comment);
diff --git a/xs/src/libslic3r/Line.cpp b/xs/src/libslic3r/Line.cpp
index 93e888efa..a29e4ce4e 100644
--- a/xs/src/libslic3r/Line.cpp
+++ b/xs/src/libslic3r/Line.cpp
@@ -97,11 +97,11 @@ bool Line::intersection(const Line &l2, Point *intersection) const
     return false;  // not intersecting
 }
 
-Pointf3 Linef3::intersect_plane(double z) const
+Vec3d Linef3::intersect_plane(double z) const
 {
     auto   v = (this->b - this->a).cast<double>();
     double t = (z - this->a(2)) / v(2);
-    return Pointf3(this->a(0) + v(0) * t, this->a(1) + v(1) * t, z);
+    return Vec3d(this->a(0) + v(0) * t, this->a(1) + v(1) * t, z);
 }
 
 }
diff --git a/xs/src/libslic3r/Line.hpp b/xs/src/libslic3r/Line.hpp
index 39c2e1ff1..39a7c2223 100644
--- a/xs/src/libslic3r/Line.hpp
+++ b/xs/src/libslic3r/Line.hpp
@@ -81,13 +81,13 @@ public:
 class Linef3
 {
 public:
-    Linef3() {}
-    explicit Linef3(Pointf3 _a, Pointf3 _b): a(_a), b(_b) {}
-    Pointf3 intersect_plane(double z) const;
+    Linef3() : a(0., 0., 0.), b(0., 0., 0.) {}
+    explicit Linef3(Vec3d _a, Vec3d _b): a(_a), b(_b) {}
+    Vec3d   intersect_plane(double z) const;
     void    scale(double factor) { this->a *= factor; this->b *= factor; }
 
-    Pointf3 a;
-    Pointf3 b;
+    Vec3d a;
+    Vec3d b;
 };
 
 } // namespace Slic3r
diff --git a/xs/src/libslic3r/Model.cpp b/xs/src/libslic3r/Model.cpp
index c5b8ad8df..cc59b6558 100644
--- a/xs/src/libslic3r/Model.cpp
+++ b/xs/src/libslic3r/Model.cpp
@@ -251,7 +251,7 @@ void Model::center_instances_around_point(const Pointf &point)
         for (size_t i = 0; i < o->instances.size(); ++ i)
             bb.merge(o->instance_bounding_box(i, false));
 
-    Pointf shift = point - 0.5 * bb.size().xy() - bb.min.xy();
+    Pointf shift = point - 0.5 * to_2d(bb.size()) - to_2d(bb.min);
     for (ModelObject *o : this->objects) {
         for (ModelInstance *i : o->instances)
             i->offset += shift;
@@ -309,8 +309,8 @@ bool Model::arrange_objects(coordf_t dist, const BoundingBoxf* bb)
         for (size_t i = 0; i < o->instances.size(); ++ i) {
             // an accurate snug bounding box around the transformed mesh.
             BoundingBoxf3 bbox(o->instance_bounding_box(i, true));
-            instance_sizes.push_back(bbox.size().xy());
-            instance_centers.push_back(bbox.center().xy());
+            instance_sizes.emplace_back(to_2d(bbox.size()));
+            instance_centers.emplace_back(to_2d(bbox.center()));
         }
 
     Pointfs positions;
@@ -332,7 +332,7 @@ bool Model::arrange_objects(coordf_t dist, const BoundingBoxf* bb)
 // Duplicate the entire model preserving instance relative positions.
 void Model::duplicate(size_t copies_num, coordf_t dist, const BoundingBoxf* bb)
 {
-    Pointfs model_sizes(copies_num-1, this->bounding_box().size().xy());
+    Pointfs model_sizes(copies_num-1, to_2d(this->bounding_box().size()));
     Pointfs positions;
     if (! _arrange(model_sizes, dist, bb, positions))
         CONFESS("Cannot duplicate part as the resulting objects would not fit on the print bed.\n");
@@ -375,7 +375,7 @@ void Model::duplicate_objects_grid(size_t x, size_t y, coordf_t dist)
     ModelObject* object = this->objects.front();
     object->clear_instances();
 
-    Sizef3 size = object->bounding_box().size();
+    Vec3d size = object->bounding_box().size();
 
     for (size_t x_copy = 1; x_copy <= x; ++x_copy) {
         for (size_t y_copy = 1; y_copy <= y; ++y_copy) {
@@ -642,7 +642,7 @@ BoundingBoxf3 ModelObject::tight_bounding_box(bool include_modifiers) const
                     {
                         // original point
                         const stl_vertex& v = facet.vertex[i];
-                        Pointf3 p((double)v.x, (double)v.y, (double)v.z);
+                        Vec3d p((double)v.x, (double)v.y, (double)v.z);
 
                         // scale
                         p(0) *= inst->scaling_factor;
@@ -727,10 +727,10 @@ void ModelObject::center_around_origin()
 			bb.merge(v->mesh.bounding_box());
     
     // first align to origin on XYZ
-    Vectorf3 vector(-bb.min(0), -bb.min(1), -bb.min(2));
+    Vec3d vector(-bb.min(0), -bb.min(1), -bb.min(2));
     
     // then center it on XY
-    Sizef3 size = bb.size();
+    Vec3d size = bb.size();
     vector(0) -= size(0)/2;
     vector(1) -= size(1)/2;
     
@@ -741,7 +741,7 @@ void ModelObject::center_around_origin()
         for (ModelInstance *i : this->instances) {
             // apply rotation and scaling to vector as well before translating instance,
             // in order to leave final position unaltered
-            Vectorf v = - vector.xy();
+            Vectorf v = - to_2d(vector);
             v.rotate(i->rotation);
             i->offset += v * i->scaling_factor;
         }
@@ -757,12 +757,12 @@ void ModelObject::translate(coordf_t x, coordf_t y, coordf_t z)
         m_bounding_box.translate(x, y, z);
 }
 
-void ModelObject::scale(const Pointf3 &versor)
+void ModelObject::scale(const Vec3d &versor)
 {
     for (ModelVolume *v : this->volumes)
         v->mesh.scale(versor);
     // reset origin translation since it doesn't make sense anymore
-    this->origin_translation = Pointf3(0,0,0);
+    this->origin_translation = Vec3d(0,0,0);
     this->invalidate_bounding_box();
 }
 
@@ -784,7 +784,7 @@ void ModelObject::rotate(float angle, const Axis &axis)
         }
     }
 
-    this->origin_translation = Pointf3(0, 0, 0);
+    this->origin_translation = Vec3d(0, 0, 0);
     this->invalidate_bounding_box();
 }
 
@@ -798,7 +798,7 @@ void ModelObject::transform(const float* matrix3x4)
         v->mesh.transform(matrix3x4);
     }
 
-    origin_translation = Pointf3(0.0, 0.0, 0.0);
+    origin_translation = Vec3d(0.0, 0.0, 0.0);
     invalidate_bounding_box();
 }
 
@@ -806,7 +806,7 @@ void ModelObject::mirror(const Axis &axis)
 {
     for (ModelVolume *v : this->volumes)
         v->mesh.mirror(axis);
-    this->origin_translation = Pointf3(0,0,0);
+    this->origin_translation = Vec3d(0,0,0);
     this->invalidate_bounding_box();
 }
 
@@ -929,7 +929,7 @@ void ModelObject::check_instances_print_volume_state(const BoundingBoxf3& print_
                     {
                         // original point
                         const stl_vertex& v = facet.vertex[i];
-                        Pointf3 p((double)v.x, (double)v.y, (double)v.z);
+                        Vec3d p((double)v.x, (double)v.y, (double)v.z);
 
                         // scale
                         p(0) *= inst->scaling_factor;
@@ -970,7 +970,7 @@ void ModelObject::print_info() const
     TriangleMesh mesh = this->raw_mesh();
     mesh.check_topology();
     BoundingBoxf3 bb = mesh.bounding_box();
-    Sizef3 size = bb.size();
+    Vec3d size = bb.size();
     cout << "size_x = " << size(0) << endl;
     cout << "size_y = " << size(1) << endl;
     cout << "size_z = " << size(2) << endl;
@@ -1082,30 +1082,20 @@ BoundingBoxf3 ModelInstance::transform_mesh_bounding_box(const TriangleMesh* mes
     for (int i = 0; i < mesh->stl.stats.number_of_facets; ++ i) {
         const stl_facet &facet = mesh->stl.facet_start[i];
         for (int j = 0; j < 3; ++ j) {
-            stl_vertex v = facet.vertex[j];
-            double xold = v.x;
-            double yold = v.y;
-            v.x = float(c * xold - s * yold);
-            v.y = float(s * xold + c * yold);
-            bbox.merge(Pointf3(v.x, v.y, v.z));
+            const stl_vertex &v = facet.vertex[j];
+			bbox.merge(Vec3d(c * v.x - s * v.y, s * v.x + c * v.y, v.z));
         }
     }
     if (! empty(bbox)) {
         // Scale the bounding box uniformly.
         if (std::abs(this->scaling_factor - 1.) > EPSILON) {
-            bbox.min(0) *= float(this->scaling_factor);
-            bbox.min(1) *= float(this->scaling_factor);
-            bbox.min(2) *= float(this->scaling_factor);
-            bbox.max(0) *= float(this->scaling_factor);
-            bbox.max(1) *= float(this->scaling_factor);
-            bbox.max(2) *= float(this->scaling_factor);
+            bbox.min *= this->scaling_factor;
+			bbox.max *= this->scaling_factor;
         }
         // Translate the bounding box.
         if (! dont_translate) {
-            bbox.min(0) += float(this->offset(0));
-            bbox.min(1) += float(this->offset(1));
-            bbox.max(0) += float(this->offset(0));
-            bbox.max(1) += float(this->offset(1));
+            Eigen::Map<Vec2d>(bbox.min.data()) += this->offset;
+            Eigen::Map<Vec2d>(bbox.max.data()) += this->offset;
         }
     }
     return bbox;
diff --git a/xs/src/libslic3r/Model.hpp b/xs/src/libslic3r/Model.hpp
index 8dcfff024..dfe391b0e 100644
--- a/xs/src/libslic3r/Model.hpp
+++ b/xs/src/libslic3r/Model.hpp
@@ -84,7 +84,7 @@ public:
         center_around_origin() method. Callers might want to apply the same translation
         to new volumes before adding them to this object in order to preserve alignment
         when user expects that. */
-    Pointf3                 origin_translation;
+    Vec3d                   origin_translation;
     
     Model* get_model() const { return m_model; };
     
@@ -120,9 +120,9 @@ public:
     // A snug bounding box around the transformed non-modifier object volumes.
     BoundingBoxf3 instance_bounding_box(size_t instance_idx, bool dont_translate = false) const;
     void center_around_origin();
-    void translate(const Vectorf3 &vector) { this->translate(vector(0), vector(1), vector(2)); }
+    void translate(const Vec3d &vector) { this->translate(vector(0), vector(1), vector(2)); }
     void translate(coordf_t x, coordf_t y, coordf_t z);
-    void scale(const Pointf3 &versor);
+    void scale(const Vec3d &versor);
     void rotate(float angle, const Axis &axis);
     void transform(const float* matrix3x4);
     void mirror(const Axis &axis);
@@ -138,7 +138,7 @@ public:
     void print_info() const;
     
 private:        
-    ModelObject(Model *model) : layer_height_profile_valid(false), m_model(model), m_bounding_box_valid(false) {}
+    ModelObject(Model *model) : layer_height_profile_valid(false), m_model(model), origin_translation(Vec3d::Zero()), m_bounding_box_valid(false) {}
     ModelObject(Model *model, const ModelObject &other, bool copy_volumes = true);
     ModelObject& operator= (ModelObject other);
     void swap(ModelObject &other);
diff --git a/xs/src/libslic3r/PerimeterGenerator.cpp b/xs/src/libslic3r/PerimeterGenerator.cpp
index 8e7b33cc8..de8aeeb2a 100644
--- a/xs/src/libslic3r/PerimeterGenerator.cpp
+++ b/xs/src/libslic3r/PerimeterGenerator.cpp
@@ -243,7 +243,7 @@ void PerimeterGenerator::process()
                 perimeter_spacing / 2;
         // only apply infill overlap if we actually have one perimeter
         if (inset > 0)
-            inset -= scale_(this->config->get_abs_value("infill_overlap", unscale(inset + solid_infill_spacing / 2)));
+            inset -= scale_(this->config->get_abs_value("infill_overlap", unscale<double>(inset + solid_infill_spacing / 2)));
         // simplify infill contours according to resolution
         Polygons pp;
         for (ExPolygon &ex : last)
@@ -420,7 +420,7 @@ static inline ExtrusionPaths thick_polyline_to_extrusion_paths(const ThickPolyli
             path.polyline.append(line.b);
             // Convert from spacing to extrusion width based on the extrusion model
             // of a square extrusion ended with semi circles.
-            flow.width = unscale(w) + flow.height * (1. - 0.25 * PI);
+            flow.width = unscale<float>(w) + flow.height * (1. - 0.25 * PI);
             #ifdef SLIC3R_DEBUG
             printf("  filling %f gap\n", flow.width);
             #endif
diff --git a/xs/src/libslic3r/Point.hpp b/xs/src/libslic3r/Point.hpp
index 311951175..e189e22ee 100644
--- a/xs/src/libslic3r/Point.hpp
+++ b/xs/src/libslic3r/Point.hpp
@@ -18,17 +18,9 @@ class MultiPoint;
 class Point;
 class Point3;
 class Pointf;
-class Pointf3;
 typedef Point                       Vector;
 typedef Point3                      Vector3;
 typedef Pointf                      Vectorf;
-typedef Pointf3                     Vectorf3;
-typedef std::vector<Point>          Points;
-typedef std::vector<Point*>         PointPtrs;
-typedef std::vector<const Point*>   PointConstPtrs;
-typedef std::vector<Point3>         Points3;
-typedef std::vector<Pointf>         Pointfs;
-typedef std::vector<Pointf3>        Pointf3s;
 
 // Eigen types, to replace the Slic3r's own types in the future.
 // Vector types with a fixed point coordinate base type.
@@ -43,6 +35,13 @@ typedef Eigen::Matrix<float,    3, 1, Eigen::DontAlign> Vec3f;
 typedef Eigen::Matrix<double,   2, 1, Eigen::DontAlign> Vec2d;
 typedef Eigen::Matrix<double,   3, 1, Eigen::DontAlign> Vec3d;
 
+typedef std::vector<Point>                              Points;
+typedef std::vector<Point*>                             PointPtrs;
+typedef std::vector<const Point*>                       PointConstPtrs;
+typedef std::vector<Point3>                             Points3;
+typedef std::vector<Pointf>                             Pointfs;
+typedef std::vector<Vec3d>                              Pointf3s;
+
 typedef Eigen::Transform<float,  2, Eigen::Affine, Eigen::DontAlign> Transform2f;
 typedef Eigen::Transform<double, 2, Eigen::Affine, Eigen::DontAlign> Transform2d;
 typedef Eigen::Transform<float,  3, Eigen::Affine, Eigen::DontAlign> Transform3f;
@@ -53,6 +52,18 @@ inline coord_t cross2(const Vec2crd &v1, const Vec2crd &v2) { return v1(0) * v2(
 inline float   cross2(const Vec2f   &v1, const Vec2f   &v2) { return v1(0) * v2(1) - v1(1) * v2(0); }
 inline double  cross2(const Vec2d   &v1, const Vec2d   &v2) { return v1(0) * v2(1) - v1(1) * v2(0); }
 
+inline Vec2crd to_2d(const Vec3crd &pt3) { return Vec2crd(pt3(0), pt3(1)); }
+inline Vec2i64 to_2d(const Vec3i64 &pt3) { return Vec2i64(pt3(0), pt3(1)); }
+inline Vec2f   to_2d(const Vec3f   &pt3) { return Vec2f  (pt3(0), pt3(1)); }
+inline Vec2d   to_2d(const Vec3d   &pt3) { return Vec2d  (pt3(0), pt3(1)); }
+
+inline Vec2d   unscale(coord_t x, coord_t y) { return Vec2d(unscale<double>(x), unscale<double>(y)); }
+inline Vec2d   unscale(const Vec2crd &pt) { return Vec2d(unscale<double>(pt(0)), unscale<double>(pt(1))); }
+inline Vec2d   unscale(const Vec2d   &pt) { return Vec2d(unscale<double>(pt(0)), unscale<double>(pt(1))); }
+inline Vec3d   unscale(coord_t x, coord_t y, coord_t z) { return Vec3d(unscale<double>(x), unscale<double>(y), unscale<double>(z)); }
+inline Vec3d   unscale(const Vec3crd &pt) { return Vec3d(unscale<double>(pt(0)), unscale<double>(pt(1)), unscale<double>(pt(2))); }
+inline Vec3d   unscale(const Vec3d   &pt) { return Vec3d(unscale<double>(pt(0)), unscale<double>(pt(1)), unscale<double>(pt(2))); }
+
 inline std::string to_string(const Vec2crd &pt) { return std::string("[") + std::to_string(pt(0)) + ", " + std::to_string(pt(1)) + "]"; }
 inline std::string to_string(const Vec2d   &pt) { return std::string("[") + std::to_string(pt(0)) + ", " + std::to_string(pt(1)) + "]"; }
 inline std::string to_string(const Vec3crd &pt) { return std::string("[") + std::to_string(pt(0)) + ", " + std::to_string(pt(1)) + ", " + std::to_string(pt(2)) + "]"; }
@@ -229,8 +240,6 @@ public:
         this->Vec3crd::operator=(other);
         return *this;
     }
-
-    Point xy() const { return Point((*this)(0), (*this)(1)); }
 };
 
 std::ostream& operator<<(std::ostream &stm, const Pointf &pointf);
@@ -245,8 +254,6 @@ public:
     // This constructor allows you to construct Pointf from Eigen expressions
     template<typename OtherDerived>
     Pointf(const Eigen::MatrixBase<OtherDerived> &other) : Vec2d(other) {}
-    static Pointf new_unscale(coord_t x, coord_t y) { return Pointf(unscale(x), unscale(y)); }
-    static Pointf new_unscale(const Point &p) { return Pointf(unscale(p(0)), unscale(p(1))); }
 
     // This method allows you to assign Eigen expressions to MyVectorType
     template<typename OtherDerived>
@@ -262,30 +269,6 @@ public:
     bool operator< (const Pointf& rhs) const { return (*this)(0) < rhs(0) || ((*this)(0) == rhs(0) && (*this)(1) < rhs(1)); }
 };
 
-class Pointf3 : public Vec3d
-{
-public:
-    typedef coordf_t coord_type;
-
-    explicit Pointf3() { (*this)(0) = (*this)(1) = (*this)(2) = 0.; }
-    explicit Pointf3(coordf_t x, coordf_t y, coordf_t z) { (*this)(0) = x; (*this)(1) = y; (*this)(2) = z; }
-    // This constructor allows you to construct Pointf from Eigen expressions
-    template<typename OtherDerived>
-    Pointf3(const Eigen::MatrixBase<OtherDerived> &other) : Vec3d(other) {}
-    static Pointf3 new_unscale(coord_t x, coord_t y, coord_t z) { return Pointf3(unscale(x), unscale(y), unscale(z)); }
-    static Pointf3 new_unscale(const Point3& p) { return Pointf3(unscale(p(0)), unscale(p(1)), unscale(p(2))); }
-
-    // This method allows you to assign Eigen expressions to MyVectorType
-    template<typename OtherDerived>
-    Pointf3& operator=(const Eigen::MatrixBase<OtherDerived> &other)
-    {
-        this->Vec3d::operator=(other);
-        return *this;
-    }
-
-    Pointf xy() const { return Pointf((*this)(0), (*this)(1)); }
-};
-
 } // namespace Slic3r
 
 // start Boost
diff --git a/xs/src/libslic3r/Print.cpp b/xs/src/libslic3r/Print.cpp
index 82dee9049..230201cc1 100644
--- a/xs/src/libslic3r/Print.cpp
+++ b/xs/src/libslic3r/Print.cpp
@@ -536,7 +536,7 @@ bool Print::has_skirt() const
 std::string Print::validate() const
 {
     BoundingBox bed_box_2D = get_extents(Polygon::new_scale(config.bed_shape.values));
-    BoundingBoxf3 print_volume(Pointf3(unscale(bed_box_2D.min(0)), unscale(bed_box_2D.min(1)), 0.0), Pointf3(unscale(bed_box_2D.max(0)), unscale(bed_box_2D.max(1)), config.max_print_height));
+	BoundingBoxf3 print_volume(unscale(bed_box_2D.min(0), bed_box_2D.min(1), 0.0), unscale(bed_box_2D.max(0), bed_box_2D.max(1), scale_(config.max_print_height)));
     // Allow the objects to protrude below the print bed, only the part of the object above the print bed will be sliced.
     print_volume.min(2) = -1e10;
     unsigned int printable_count = 0;
@@ -724,7 +724,7 @@ BoundingBox Print::bounding_box() const
     for (const PrintObject *object : this->objects)
         for (Point copy : object->_shifted_copies) {
             bb.merge(copy);
-            copy += object->size.xy();
+            copy += to_2d(object->size);
             bb.merge(copy);
         }
     return bb;
@@ -967,7 +967,7 @@ void Print::_make_skirt()
         this->skirt.append(eloop);
         if (this->config.min_skirt_length.value > 0) {
             // The skirt length is limited. Sum the total amount of filament length extruded, in mm.
-            extruded_length[extruder_idx] += unscale(loop.length()) * extruders_e_per_mm[extruder_idx];
+            extruded_length[extruder_idx] += unscale<double>(loop.length()) * extruders_e_per_mm[extruder_idx];
             if (extruded_length[extruder_idx] < this->config.min_skirt_length.value) {
                 // Not extruded enough yet with the current extruder. Add another loop.
                 if (i == 1)
diff --git a/xs/src/libslic3r/Print.hpp b/xs/src/libslic3r/Print.hpp
index 36e6784cd..734b04e3f 100644
--- a/xs/src/libslic3r/Print.hpp
+++ b/xs/src/libslic3r/Print.hpp
@@ -144,7 +144,7 @@ public:
     bool set_copies(const Points &points);
     bool reload_model_instances();
     // since the object is aligned to origin, bounding box coincides with size
-    BoundingBox bounding_box() const { return BoundingBox(Point(0,0), this->size.xy()); }
+    BoundingBox bounding_box() const { return BoundingBox(Point(0,0), to_2d(this->size)); }
 
     // adds region_id, too, if necessary
     void add_region_volume(unsigned int region_id, int volume_id) {
diff --git a/xs/src/libslic3r/PrintObject.cpp b/xs/src/libslic3r/PrintObject.cpp
index 8df711196..10ebcb18e 100644
--- a/xs/src/libslic3r/PrintObject.cpp
+++ b/xs/src/libslic3r/PrintObject.cpp
@@ -50,7 +50,7 @@ PrintObject::PrintObject(Print* print, ModelObject* model_object, const Bounding
         // (copies are expressed in G-code coordinates and this translation is not publicly exposed).
         this->_copies_shift = Point::new_scale(modobj_bbox.min(0), modobj_bbox.min(1));
         // Scale the object size and store it
-        Pointf3 size = modobj_bbox.size();
+        Vec3d size = modobj_bbox.size();
         this->size = Point3::new_scale(size(0), size(1), size(2));
     }
     
@@ -1121,7 +1121,7 @@ SlicingParameters PrintObject::slicing_parameters() const
 {
     return SlicingParameters::create_from_config(
         this->print()->config, this->config, 
-        unscale(this->size(2)), this->print()->object_extruders());
+        unscale<double>(this->size(2)), this->print()->object_extruders());
 }
 
 bool PrintObject::update_layer_height_profile(std::vector<coordf_t> &layer_height_profile) const
@@ -1335,7 +1335,7 @@ std::vector<ExPolygons> PrintObject::_slice_region(size_t region_id, const std::
                 // consider the first one
                 this->model_object()->instances.front()->transform_mesh(&mesh, true);
                 // align mesh to Z = 0 (it should be already aligned actually) and apply XY shift
-                mesh.translate(- float(unscale(this->_copies_shift(0))), - float(unscale(this->_copies_shift(1))), -float(this->model_object()->bounding_box().min(2)));
+                mesh.translate(- unscale<float>(this->_copies_shift(0)), - unscale<float>(this->_copies_shift(1)), - float(this->model_object()->bounding_box().min(2)));
                 // perform actual slicing
                 TriangleMeshSlicer mslicer(&mesh);
                 mslicer.slice(z, &layers);
diff --git a/xs/src/libslic3r/SVG.cpp b/xs/src/libslic3r/SVG.cpp
index d3a0eed36..2113acc43 100644
--- a/xs/src/libslic3r/SVG.cpp
+++ b/xs/src/libslic3r/SVG.cpp
@@ -3,7 +3,7 @@
 
 #include <boost/nowide/cstdio.hpp>
 
-#define COORD(x) ((float)unscale((x))*10)
+#define COORD(x) (unscale<float>((x))*10)
 
 namespace Slic3r {
 
diff --git a/xs/src/libslic3r/Slicing.cpp b/xs/src/libslic3r/Slicing.cpp
index d745a803c..bebff6c43 100644
--- a/xs/src/libslic3r/Slicing.cpp
+++ b/xs/src/libslic3r/Slicing.cpp
@@ -607,7 +607,7 @@ int generate_layer_height_texture(
             // Intensity profile to visualize the layers.
             coordf_t intensity = cos(M_PI * 0.7 * (mid - z) / h);
             // Color mapping from layer height to RGB.
-            Pointf3 color(
+            Vec3d color(
                 intensity * lerp(coordf_t(color1(0)), coordf_t(color2(0)), t), 
                 intensity * lerp(coordf_t(color1(1)), coordf_t(color2(1)), t),
                 intensity * lerp(coordf_t(color1(2)), coordf_t(color2(2)), t));
@@ -639,7 +639,7 @@ int generate_layer_height_texture(
                 const Point3 &color1 = palette_raw[idx1];
                 const Point3 &color2 = palette_raw[idx2];
                 // Color mapping from layer height to RGB.
-                Pointf3 color(
+                Vec3d color(
                     lerp(coordf_t(color1(0)), coordf_t(color2(0)), t), 
                     lerp(coordf_t(color1(1)), coordf_t(color2(1)), t),
                     lerp(coordf_t(color1(2)), coordf_t(color2(2)), t));
diff --git a/xs/src/libslic3r/TriangleMesh.cpp b/xs/src/libslic3r/TriangleMesh.cpp
index 30ef637e5..ff226ad9e 100644
--- a/xs/src/libslic3r/TriangleMesh.cpp
+++ b/xs/src/libslic3r/TriangleMesh.cpp
@@ -52,17 +52,17 @@ TriangleMesh::TriangleMesh(const Pointf3s &points, const std::vector<Point3>& fa
     for (int i = 0; i < stl.stats.number_of_facets; i++) {
         stl_facet facet;
 
-        const Pointf3& ref_f1 = points[facets[i](0)];
+        const Vec3d& ref_f1 = points[facets[i](0)];
         facet.vertex[0].x = ref_f1(0);
         facet.vertex[0].y = ref_f1(1);
         facet.vertex[0].z = ref_f1(2);
 
-        const Pointf3& ref_f2 = points[facets[i](1)];
+        const Vec3d& ref_f2 = points[facets[i](1)];
         facet.vertex[1].x = ref_f2(0);
         facet.vertex[1].y = ref_f2(1);
         facet.vertex[1].z = ref_f2(2);
 
-        const Pointf3& ref_f3 = points[facets[i](2)];
+        const Vec3d& ref_f3 = points[facets[i](2)];
         facet.vertex[2].x = ref_f3(0);
         facet.vertex[2].y = ref_f3(1);
         facet.vertex[2].z = ref_f3(2);
@@ -300,7 +300,7 @@ void TriangleMesh::scale(float factor)
     stl_invalidate_shared_vertices(&this->stl);
 }
 
-void TriangleMesh::scale(const Pointf3 &versor)
+void TriangleMesh::scale(const Vec3d &versor)
 {
     float fversor[3];
     fversor[0] = versor(0);
@@ -1493,8 +1493,8 @@ void TriangleMeshSlicer::cut(float z, TriangleMesh* upper, TriangleMesh* lower)
             facet.normal.y = 0;
             facet.normal.z = -1;
             for (size_t i = 0; i <= 2; ++i) {
-                facet.vertex[i].x = unscale(p.points[i](0));
-                facet.vertex[i].y = unscale(p.points[i](1));
+                facet.vertex[i].x = unscale<float>(p.points[i](0));
+                facet.vertex[i].y = unscale<float>(p.points[i](1));
                 facet.vertex[i].z = z;
             }
             stl_add_facet(&upper->stl, &facet);
@@ -1519,8 +1519,8 @@ void TriangleMeshSlicer::cut(float z, TriangleMesh* upper, TriangleMesh* lower)
             facet.normal.y = 0;
             facet.normal.z = 1;
             for (size_t i = 0; i <= 2; ++i) {
-                facet.vertex[i].x = unscale(polygon->points[i](0));
-                facet.vertex[i].y = unscale(polygon->points[i](1));
+                facet.vertex[i].x = unscale<float>(polygon->points[i](0));
+                facet.vertex[i].y = unscale<float>(polygon->points[i](1));
                 facet.vertex[i].z = z;
             }
             stl_add_facet(&lower->stl, &facet);
@@ -1534,10 +1534,10 @@ void TriangleMeshSlicer::cut(float z, TriangleMesh* upper, TriangleMesh* lower)
 
 // Generate the vertex list for a cube solid of arbitrary size in X/Y/Z.
 TriangleMesh make_cube(double x, double y, double z) {
-    Pointf3 pv[8] = { 
-        Pointf3(x, y, 0), Pointf3(x, 0, 0), Pointf3(0, 0, 0), 
-        Pointf3(0, y, 0), Pointf3(x, y, z), Pointf3(0, y, z), 
-        Pointf3(0, 0, z), Pointf3(x, 0, z) 
+    Vec3d pv[8] = { 
+        Vec3d(x, y, 0), Vec3d(x, 0, 0), Vec3d(0, 0, 0), 
+        Vec3d(0, y, 0), Vec3d(x, y, z), Vec3d(0, y, z), 
+        Vec3d(0, 0, z), Vec3d(x, 0, z) 
     };
     Point3 fv[12] = { 
         Point3(0, 1, 2), Point3(0, 2, 3), Point3(4, 5, 6), 
@@ -1561,8 +1561,8 @@ TriangleMesh make_cylinder(double r, double h, double fa) {
     std::vector<Point3> facets;
 
     // 2 special vertices, top and bottom center, rest are relative to this
-    vertices.emplace_back(Pointf3(0.0, 0.0, 0.0));
-    vertices.emplace_back(Pointf3(0.0, 0.0, h));
+    vertices.emplace_back(Vec3d(0.0, 0.0, 0.0));
+    vertices.emplace_back(Vec3d(0.0, 0.0, h));
 
     // adjust via rounding to get an even multiple for any provided angle.
     double angle = (2*PI / floor(2*PI / fa));
@@ -1572,13 +1572,13 @@ TriangleMesh make_cylinder(double r, double h, double fa) {
     // top and bottom.
     // Special case: Last line shares 2 vertices with the first line.
     unsigned id = vertices.size() - 1;
-    vertices.emplace_back(Pointf3(sin(0) * r , cos(0) * r, 0));
-    vertices.emplace_back(Pointf3(sin(0) * r , cos(0) * r, h));
+    vertices.emplace_back(Vec3d(sin(0) * r , cos(0) * r, 0));
+    vertices.emplace_back(Vec3d(sin(0) * r , cos(0) * r, h));
     for (double i = 0; i < 2*PI; i+=angle) {
         Pointf p(0, r);
         p.rotate(i);
-        vertices.emplace_back(Pointf3(p(0), p(1), 0.));
-        vertices.emplace_back(Pointf3(p(0), p(1), h));
+        vertices.emplace_back(Vec3d(p(0), p(1), 0.));
+        vertices.emplace_back(Vec3d(p(0), p(1), h));
         id = vertices.size() - 1;
         facets.emplace_back(Point3( 0, id - 1, id - 3)); // top
         facets.emplace_back(Point3(id,      1, id - 2)); // bottom
@@ -1619,7 +1619,7 @@ TriangleMesh make_sphere(double rho, double fa) {
 
     // special case: first ring connects to 0,0,0
     // insert and form facets.
-    vertices.emplace_back(Pointf3(0.0, 0.0, -rho));
+    vertices.emplace_back(Vec3d(0.0, 0.0, -rho));
     size_t id = vertices.size();
     for (size_t i = 0; i < ring.size(); i++) {
         // Fixed scaling 
@@ -1628,7 +1628,7 @@ TriangleMesh make_sphere(double rho, double fa) {
         const double r = sqrt(abs(rho*rho - z*z));
         Pointf b(0, r);
         b.rotate(ring[i]);
-        vertices.emplace_back(Pointf3(b(0), b(1), z));
+        vertices.emplace_back(Vec3d(b(0), b(1), z));
         facets.emplace_back((i == 0) ? Point3(1, 0, ring.size()) : Point3(id, 0, id - 1));
         ++ id;
     }
@@ -1641,7 +1641,7 @@ TriangleMesh make_sphere(double rho, double fa) {
         for (size_t i = 0; i < ring.size(); i++) {
             Pointf b(0, r);
             b.rotate(ring[i]); 
-            vertices.emplace_back(Pointf3(b(0), b(1), z));
+            vertices.emplace_back(Vec3d(b(0), b(1), z));
             if (i == 0) {
                 // wrap around
                 facets.emplace_back(Point3(id + ring.size() - 1 , id, id - 1)); 
@@ -1657,7 +1657,7 @@ TriangleMesh make_sphere(double rho, double fa) {
 
     // special case: last ring connects to 0,0,rho*2.0
     // only form facets.
-    vertices.emplace_back(Pointf3(0.0, 0.0, rho));
+    vertices.emplace_back(Vec3d(0.0, 0.0, rho));
     for (size_t i = 0; i < ring.size(); i++) {
         if (i == 0) {
             // third vertex is on the other side of the ring.
diff --git a/xs/src/libslic3r/TriangleMesh.hpp b/xs/src/libslic3r/TriangleMesh.hpp
index c700784a5..b04d09f32 100644
--- a/xs/src/libslic3r/TriangleMesh.hpp
+++ b/xs/src/libslic3r/TriangleMesh.hpp
@@ -37,7 +37,7 @@ public:
     bool is_manifold() const;
     void WriteOBJFile(char* output_file);
     void scale(float factor);
-    void scale(const Pointf3 &versor);
+    void scale(const Vec3d &versor);
     void translate(float x, float y, float z);
     void rotate(float angle, const Axis &axis);
     void rotate_x(float angle);
diff --git a/xs/src/libslic3r/libslic3r.h b/xs/src/libslic3r/libslic3r.h
index 862ce2e51..6fea64cd1 100644
--- a/xs/src/libslic3r/libslic3r.h
+++ b/xs/src/libslic3r/libslic3r.h
@@ -45,7 +45,6 @@ typedef double  coordf_t;
 //FIXME Better to use an inline function with an explicit return type.
 //inline coord_t scale_(coordf_t v) { return coord_t(floor(v / SCALING_FACTOR + 0.5f)); }
 #define scale_(val) ((val) / SCALING_FACTOR)
-#define unscale(val) ((val) * SCALING_FACTOR)
 #define SCALED_EPSILON scale_(EPSILON)
 /* Implementation of CONFESS("foo"): */
 #ifdef _MSC_VER
@@ -102,6 +101,9 @@ inline std::string debug_out_path(const char *name, ...)
 
 namespace Slic3r {
 
+template<typename T, typename Q>
+inline T unscale(Q v) { return T(v) * T(SCALING_FACTOR); }
+
 enum Axis { X=0, Y, Z, E, F, NUM_AXES };
 
 template <class T>