Make an order in using scale and unscale, remove some warnings.

src/libslic3r/MTUtils.hpp

@@ -7,6 +7,9 @@
 #include <utility>    // for std::forward
 #include <algorithm>
 
+#include "libslic3r.h"
+#include "Point.hpp"
+
 namespace Slic3r {
 
 /// Handy little spin mutex for the cached meshes.
@@ -248,6 +251,94 @@ template<class X, class Y> inline X ceil_i(X x, Y y)
     return (x % y) ? x / y + 1 : x / y;
 }
 
+// A shorter C++14 style form of the enable_if metafunction
+template<bool B, class T>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+// /////////////////////////////////////////////////////////////////////////////
+// Type safe conversions to and from scaled and unscaled coordinates
+// /////////////////////////////////////////////////////////////////////////////
+
+// A meta-predicate which is true for integers wider than or equal to coord_t
+template<class I> struct is_scaled_coord
+{
+    static const SLIC3R_CONSTEXPR bool value =
+        std::is_integral<I>::value &&
+        std::numeric_limits<I>::digits >=
+            std::numeric_limits<coord_t>::digits;
+};
+
+// Meta predicates for floating, 'scaled coord' and generic arithmetic types
+template<class T>
+using FloatingOnly = enable_if_t<std::is_floating_point<T>::value, T>;
+
+template<class T>
+using ScaledCoordOnly = enable_if_t<is_scaled_coord<T>::value, T>;
+
+template<class T>
+using ArithmeticOnly = enable_if_t<std::is_arithmetic<T>::value, T>;
+
+// A shorter form for a generic Eigen vector which is widely used in PrusaSlicer 
+template<class T, int N>
+using EigenVec = Eigen::Matrix<T, N, 1, Eigen::DontAlign>;
+
+// Semantics are the following:
+// Upscaling (scaled()): only from floating point types (or Vec) to either
+//                       floating point or integer 'scaled coord' coordinates.
+// Downscaling (unscaled()): from arithmetic types (or Vec) to either
+//                           floating point only
+
+// Conversion definition from unscaled to floating point scaled
+template<class Tout,
+         class Tin,
+         class = FloatingOnly<Tin>,
+         class = FloatingOnly<Tout>>
+inline SLIC3R_CONSTEXPR Tout scaled(const Tin &v) SLIC3R_NOEXCEPT
+{
+    return static_cast<Tout>(v / static_cast<Tout>(SCALING_FACTOR));
+}
+
+// Conversion definition from unscaled to integer 'scaled coord'.
+// TODO: is the rounding necessary ? Here it is to show that it can be different
+// but it does not have to be. Using std::round means loosing noexcept and
+// constexpr modifiers
+template<class Tout = coord_t, class Tin, class = FloatingOnly<Tin>>
+inline SLIC3R_CONSTEXPR ScaledCoordOnly<Tout> scaled(const Tin &v) SLIC3R_NOEXCEPT
+{
+    //return static_cast<Tout>(std::round(v / SCALING_FACTOR));
+    return static_cast<Tout>(v / static_cast<Tout>(SCALING_FACTOR));
+}
+
+// Conversion for Eigen vectors (N dimensional points)
+template<class Tout = coord_t, class Tin, int N, class = FloatingOnly<Tin>>
+inline EigenVec<ArithmeticOnly<Tout>, N> scaled(const EigenVec<Tin, N> &v)
+{
+    return v.template cast<Tout>() / SCALING_FACTOR;
+}
+
+// Conversion from arithmetic scaled type to floating point unscaled
+template<class Tout = double,
+         class Tin,
+         class = ArithmeticOnly<Tin>,
+         class = FloatingOnly<Tout>>
+inline SLIC3R_CONSTEXPR Tout unscaled(const Tin &v) SLIC3R_NOEXCEPT
+{
+    return static_cast<Tout>(v * static_cast<Tout>(SCALING_FACTOR));
+}
+
+// Unscaling for Eigen vectors. Input base type can be arithmetic, output base
+// type can only be floating point.
+template<class Tout = double,
+         class Tin,
+         int N,
+         class = ArithmeticOnly<Tin>,
+         class = FloatingOnly<Tout>>
+inline SLIC3R_CONSTEXPR EigenVec<Tout, N> unscaled(
+    const EigenVec<Tin, N> &v) SLIC3R_NOEXCEPT
+{
+    return v.template cast<Tout>() * SCALING_FACTOR;
+}
+
 } // namespace Slic3r
 
 #endif // MTUTILS_HPP

src/libslic3r/MinAreaBoundingBox.cpp

@@ -39,7 +39,7 @@ template<> inline Slic3r::Points& contour(Slic3r::Polygon& sh) { return sh.point
 template<> inline const Slic3r::Points& contour(const Slic3r::Polygon& sh) { return sh.points; }
 
 template<> Slic3r::Points::iterator begin(Slic3r::Points& pts, const PathTag&) { return pts.begin();}
-template<> Slic3r::Points::const_iterator cbegin(const Slic3r::Points& pts, const PathTag&) { return pts.begin(); }
+template<> Slic3r::Points::const_iterator cbegin(const Slic3r::Points& pts, const PathTag&) { return pts.cbegin(); }
 template<> Slic3r::Points::iterator end(Slic3r::Points& pts, const PathTag&) { return pts.end();}
 template<> Slic3r::Points::const_iterator cend(const Slic3r::Points& pts, const PathTag&) { return pts.cend(); }
 
@@ -71,62 +71,67 @@ using Rational = boost::rational<__int128>;
 
 MinAreaBoundigBox::MinAreaBoundigBox(const Polygon &p, PolygonLevel pc)
 {
-    const Polygon& chull = pc == pcConvex ? p : libnest2d::sl::convexHull(p);
+    const Polygon &chull = pc == pcConvex ? p :
-    
+                                            libnest2d::sl::convexHull(p);
-    libnest2d::RotatedBox<Point, Unit> box = 
+
-            libnest2d::minAreaBoundingBox<Polygon, Unit, Rational>(chull);
+    libnest2d::RotatedBox<Point, Unit> box =
-    
+        libnest2d::minAreaBoundingBox<Polygon, Unit, Rational>(chull);
-    m_right = box.right_extent();
+
-    m_bottom = box.bottom_extent();
+    m_right  = libnest2d::cast<long double>(box.right_extent());
-    m_axis = box.axis();
+    m_bottom = libnest2d::cast<long double>(box.bottom_extent());
+    m_axis   = box.axis();
 }
 
 MinAreaBoundigBox::MinAreaBoundigBox(const ExPolygon &p, PolygonLevel pc)
 {
-    const ExPolygon& chull = pc == pcConvex ? p : libnest2d::sl::convexHull(p);
+    const ExPolygon &chull = pc == pcConvex ? p :
-    
+                                              libnest2d::sl::convexHull(p);
-    libnest2d::RotatedBox<Point, Unit> box = 
+
-            libnest2d::minAreaBoundingBox<ExPolygon, Unit, Rational>(chull);
+    libnest2d::RotatedBox<Point, Unit> box =
-    
+        libnest2d::minAreaBoundingBox<ExPolygon, Unit, Rational>(chull);
-    m_right = box.right_extent();
+
-    m_bottom = box.bottom_extent();
+    m_right  = libnest2d::cast<long double>(box.right_extent());
-    m_axis = box.axis();
+    m_bottom = libnest2d::cast<long double>(box.bottom_extent());
+    m_axis   = box.axis();
 }
 
 MinAreaBoundigBox::MinAreaBoundigBox(const Points &pts, PolygonLevel pc)
 {
-    const Points& chull = pc == pcConvex ? pts : libnest2d::sl::convexHull(pts);
+    const Points &chull = pc == pcConvex ? pts :
-    
+                                           libnest2d::sl::convexHull(pts);
-    libnest2d::RotatedBox<Point, Unit> box = 
+
-            libnest2d::minAreaBoundingBox<Points, Unit, Rational>(chull);
+    libnest2d::RotatedBox<Point, Unit> box =
-    
+        libnest2d::minAreaBoundingBox<Points, Unit, Rational>(chull);
-    m_right = box.right_extent();
+
-    m_bottom = box.bottom_extent();
+    m_right  = libnest2d::cast<long double>(box.right_extent());
-    m_axis = box.axis();
+    m_bottom = libnest2d::cast<long double>(box.bottom_extent());
+    m_axis   = box.axis();
 }
 
 double MinAreaBoundigBox::angle_to_X() const
 {
     double ret = std::atan2(m_axis.y(), m_axis.x());
-    auto s = std::signbit(ret);
+    auto   s   = std::signbit(ret);
-    if(s) ret += 2 * PI;
+    if (s) ret += 2 * PI;
     return -ret;
 }
 
 long double MinAreaBoundigBox::width() const
 {
-    return std::abs(m_bottom) / std::sqrt(libnest2d::pl::magnsq<Point, long double>(m_axis));
+    return std::abs(m_bottom) /
+           std::sqrt(libnest2d::pl::magnsq<Point, long double>(m_axis));
 }
 
 long double MinAreaBoundigBox::height() const
 {
-    return std::abs(m_right) / std::sqrt(libnest2d::pl::magnsq<Point, long double>(m_axis));
+    return std::abs(m_right) /
+           std::sqrt(libnest2d::pl::magnsq<Point, long double>(m_axis));
 }
 
 long double MinAreaBoundigBox::area() const
 {
     long double asq = libnest2d::pl::magnsq<Point, long double>(m_axis);
-    return m_bottom * m_right / asq;   
+    return m_bottom * m_right / asq;
 }
 
 void remove_collinear_points(Polygon &p)
@@ -138,5 +143,4 @@ void remove_collinear_points(ExPolygon &p)
 {
     p = libnest2d::removeCollinearPoints<ExPolygon>(p, Unit(0));
 }
-
+} // namespace Slic3r
-}

src/libslic3r/ModelArrange.cpp

@@ -610,7 +610,7 @@ ShapeData2D projectModelFromTop(const Slic3r::Model &model,
                 
                 if(tolerance > EPSILON) {
                     Polygons pp { p };
-                    pp = p.simplify(double(scaled(tolerance)));
+                    pp = p.simplify(scaled<double>(tolerance));
                     if (!pp.empty()) p = pp.front();
                 }
                 

src/libslic3r/SLA/SLABasePool.cpp

@@ -5,6 +5,7 @@
 #include "SLABoostAdapter.hpp"
 #include "ClipperUtils.hpp"
 #include "Tesselate.hpp"
+#include "MTUtils.hpp"
 
 // For debugging:
 //#include <fstream>
@@ -203,7 +204,7 @@ void offset(ExPolygon& sh, coord_t distance) {
     }
 
     ClipperOffset offs;
-    offs.ArcTolerance = 0.01*scaled(1.0);
+    offs.ArcTolerance = scaled<double>(0.01);
     Paths result;
     offs.AddPath(ctour, jtRound, etClosedPolygon);
     offs.AddPaths(holes, jtRound, etClosedPolygon);
@@ -351,7 +352,7 @@ Contour3D round_edges(const ExPolygon& base_plate,
         double x2 = xx*xx;
         double stepy = std::sqrt(r2 - x2);
 
-        offset(ob, s*scaled(xx));
+        offset(ob, s * scaled(xx));
         wh = ceilheight_mm - radius_mm + stepy;
 
         Contour3D pwalls;
@@ -375,7 +376,7 @@ Contour3D round_edges(const ExPolygon& base_plate,
             double xx = radius_mm - i*stepx;
             double x2 = xx*xx;
             double stepy = std::sqrt(r2 - x2);
-            offset(ob, s*scaled(xx));
+            offset(ob, s * scaled(xx));
             wh = ceilheight_mm - radius_mm - stepy;
 
             Contour3D pwalls;
@@ -476,7 +477,7 @@ ExPolygons concave_hull(const ExPolygons& polys, double max_dist_mm = 50,
         double dx = x(c) - x(cc), dy = y(c) - y(cc);
         double l = std::sqrt(dx * dx + dy * dy);
         double nx = dx / l, ny = dy / l;
-        double max_dist = scaled(max_dist_mm);
+        double max_dist = scaled<double>(max_dist_mm);
 
         ExPolygon& expo = punion[idx++];
         BoundingBox querybb(expo);
@@ -492,7 +493,7 @@ ExPolygons concave_hull(const ExPolygons& polys, double max_dist_mm = 50,
         ctour.reserve(3);
         ctour.emplace_back(cc);
 
-        Point d(coord_t(scaled(1.)*nx), coord_t(scaled(1.)*ny));
+        Point d(scaled(nx), scaled(ny));
         ctour.emplace_back(c + Point( -y(d),  x(d) ));
         ctour.emplace_back(c + Point(  y(d), -x(d) ));
         offset(r, scaled(1.));
@@ -529,14 +530,14 @@ void base_plate(const TriangleMesh &mesh, ExPolygons &output, float h,
     ExPolygons tmp; tmp.reserve(count);
     for(ExPolygons& o : out)
         for(ExPolygon& e : o) {
-            auto&& exss = e.simplify(scaled(0.1));
+            auto&& exss = e.simplify(scaled<double>(0.1));
             for(ExPolygon& ep : exss) tmp.emplace_back(std::move(ep));
         }
 
     ExPolygons utmp = unify(tmp);
 
     for(auto& o : utmp) {
-        auto&& smp = o.simplify(scaled(0.1));
+        auto&& smp = o.simplify(scaled<double>(0.1));
         output.insert(output.end(), smp.begin(), smp.end());
     }
 }

src/libslic3r/SLAPrint.cpp

@@ -668,7 +668,7 @@ void SLAPrint::process()
     double ilhd = m_material_config.initial_layer_height.getFloat();
     auto   ilh  = float(ilhd);
 
-    auto ilhs = scaled(ilhd);
+    coord_t      ilhs     = scaled(ilhd);
     const size_t objcount = m_objects.size();
 
     static const unsigned min_objstatus = 0;   // where the per object operations start
@@ -694,17 +694,15 @@ void SLAPrint::process()
 
         // We need to prepare the slice index...
 
-        double lhd  = m_objects.front()->m_config.layer_height.getFloat();
+        double  lhd  = m_objects.front()->m_config.layer_height.getFloat();
-        float  lh   = float(lhd);
+        float   lh   = float(lhd);
-        auto   lhs  = scaled(lhd);
+        coord_t lhs  = scaled(lhd);
-
+        auto && bb3d = mesh.bounding_box();
-        auto &&bb3d  = mesh.bounding_box();
+        double  minZ = bb3d.min(Z) - po.get_elevation();
-        double minZ  = bb3d.min(Z) - po.get_elevation();
+        double  maxZ = bb3d.max(Z);
-        double maxZ  = bb3d.max(Z);
+        auto    minZf = float(minZ);
-        auto   minZf = float(minZ);
+        coord_t minZs = scaled(minZ);
-
+        coord_t maxZs = scaled(maxZ);
-        auto minZs = scaled(minZ);
-        auto maxZs = scaled(maxZ);
 
         po.m_slice_index.clear();
         
@@ -1013,9 +1011,6 @@ void SLAPrint::process()
         using ClipperPolygons = std::vector<ClipperPolygon>;
         namespace sl = libnest2d::shapelike;    // For algorithms
 
-        // If the raster has vertical orientation, we will flip the coordinates
-//        bool flpXY = m_printer_config.display_orientation.getInt() == SLADisplayOrientation::sladoPortrait;
-
         // Set up custom union and diff functions for clipper polygons
         auto polyunion = [] (const ClipperPolygons& subjects)
         {
@@ -1066,8 +1061,8 @@ void SLAPrint::process()
 
         const int    fade_layers_cnt    = m_default_object_config.faded_layers.getInt();// 10 // [3;20]
 
-        const double width              = scaled(m_printer_config.display_width.getFloat());
+        const auto width                = scaled<double>(m_printer_config.display_width.getFloat());
-        const double height             = scaled(m_printer_config.display_height.getFloat());
+        const auto height               = scaled<double>(m_printer_config.display_height.getFloat());
         const double display_area       = width*height;
 
         // get polygons for all instances in the object
@@ -1123,11 +1118,6 @@ void SLAPrint::process()
                     sl::translate(poly, ClipperPoint{instances[i].shift(X),
                                                      instances[i].shift(Y)});
 
-//                    if (flpXY) {
-//                        for(auto& p : poly.Contour) std::swap(p.X, p.Y);
-//                        for(auto& h : poly.Holes) for(auto& p : h) std::swap(p.X, p.Y);
-//                    }
-
                     polygons.emplace_back(std::move(poly));
                 }
             }

src/libslic3r/libslic3r.h

@@ -61,20 +61,6 @@ typedef double  coordf_t;
 #define SLIC3R_NOEXCEPT  noexcept
 #endif
 
-template<class Tf> inline SLIC3R_CONSTEXPR coord_t scaled(Tf val)
-{
-    static_assert (std::is_floating_point<Tf>::value, "Floating point only");
-    return coord_t(val / Tf(SCALING_FACTOR));
-}
-
-template<class Tf = double> inline SLIC3R_CONSTEXPR Tf unscaled(coord_t val)
-{
-    static_assert (std::is_floating_point<Tf>::value, "Floating point only");
-    return Tf(val * Tf(SCALING_FACTOR));
-}
-
-inline SLIC3R_CONSTEXPR float unscaledf(coord_t val) { return unscaled<float>(val); }
-
 inline std::string debug_out_path(const char *name, ...)
 {
 	char buffer[2048];