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

src/libnest2d/tests/test.cpp

@@ -10,10 +10,6 @@
 #include "boost/multiprecision/integer.hpp"
 #include "boost/rational.hpp"
 
-//#include "../tools/Int128.hpp"
-
-//#include "gte/Mathematics/GteMinimumAreaBox2.h"
-
 //#include "../tools/libnfpglue.hpp"
 //#include "../tools/nfp_svgnest_glue.hpp"
 
@@ -183,7 +179,7 @@ TEST(GeometryAlgorithms, Distance) {
     
     Segment seg(p1, p3);
     
-//    ASSERT_DOUBLE_EQ(pointlike::distance(p2, seg), 7.0710678118654755);
+    //    ASSERT_DOUBLE_EQ(pointlike::distance(p2, seg), 7.0710678118654755);
     
     auto result = pointlike::horizontalDistance(p2, seg);
     
@@ -396,7 +392,7 @@ TEST(GeometryAlgorithms, ArrangeRectanglesLoose)
 {
     using namespace libnest2d;
     
-//    std::vector<Rectangle> rects = { {40, 40}, {10, 10}, {20, 20} };
+    //    std::vector<Rectangle> rects = { {40, 40}, {10, 10}, {20, 20} };
     std::vector<Rectangle> rects = {
         {80, 80},
         {60, 90},
@@ -454,14 +450,14 @@ void exportSVG(std::vector<std::reference_wrapper<Item>>& result, const Bin& bin
     std::string loc = "out";
     
     static std::string svg_header =
-R"raw(<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+        R"raw(<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
 <svg height="500" width="500" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
 )raw";
     
     int i = idx;
     auto r = result;
-//    for(auto r : result) {
+    //    for(auto r : result) {
     std::fstream out(loc + std::to_string(i) + ".svg", std::fstream::out);
     if(out.is_open()) {
         out << svg_header;
@@ -487,8 +483,8 @@ R"raw(<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
     }
     out.close();
     
-//        i++;
+    //        i++;
-//    }
+    //    }
 }
 }
 
@@ -556,11 +552,12 @@ TEST(GeometryAlgorithms, NestTest) {
     
     ASSERT_LE(result.size(), 2);
     
-    int partsum = std::accumulate(result.begin(),
+    size_t partsum = std::accumulate(result.begin(),
                                      result.end(),
-                                  0,
+                                     size_t(0),
                                      [](int s,
-                                     const decltype(result)::value_type &bin) {
+                                        const decltype(
+                                            result)::value_type &bin) {
                                          return s += bin.size();
                                      });
     
@@ -728,7 +725,7 @@ std::vector<ItemPair> nfp_testdata = {
     }
 };
 
-std::vector<ItemPair> nfp_concave_testdata = {
+    std::vector<ItemPair> nfp_concave_testdata = {
         { // ItemPair
          {
              {
@@ -935,67 +932,39 @@ template<class T> struct BoostGCD {
 };
 
 using Unit = int64_t;
-using Ratio = boost::rational<boost::multiprecision::int128_t>;// Rational<boost::multiprecision::int256_t>;
+using Ratio = boost::rational<boost::multiprecision::int128_t>;
-
-//double gteMinAreaBox(const PolygonImpl& p) {    
-    
-//    using GteCoord = ClipperLib::cInt;
-//    using GtePoint = gte::Vector2<GteCoord>;
- 
-//    gte::MinimumAreaBox2<GteCoord, Ratio> mb;
-    
-//    std::vector<GtePoint> points; 
-//    points.reserve(p.Contour.size());
-    
-//    for(auto& pt : p.Contour) points.emplace_back(GtePoint{GteCoord(pt.X), GteCoord(pt.Y)});
-    
-//    mb(int(points.size()), points.data(), 0, nullptr, true);
-    
-//    auto min_area = double(mb.GetArea());
-    
-//    return min_area;
-//}
 
 }
 
 TEST(RotatingCalipers, MinAreaBBCClk) {
-//    PolygonImpl poly({{-50, 30}, {-50, -50}, {50, -50}, {50, 50}, {-40, 50}});
-    
-//    PolygonImpl poly({{-50, 0}, {50, 0}, {0, 100}});
-    
     auto u = [](ClipperLib::cInt n) { return n*1000000; };
     PolygonImpl poly({ {u(0), u(0)}, {u(4), u(1)}, {u(2), u(4)}});
     
-    
     long double arearef = refMinAreaBox(poly);
     long double area = minAreaBoundingBox<PolygonImpl, Unit, Ratio>(poly).area();
-//    double gtearea = gteMinAreaBox(poly);
     
     ASSERT_LE(std::abs(area - arearef), 500e6 );
-//    ASSERT_LE(std::abs(gtearea - arearef), 500 );
-//    ASSERT_DOUBLE_EQ(gtearea, arearef);
 }
 
 TEST(RotatingCalipers, AllPrusaMinBB) {
-    size_t idx = 0;
+    //    /size_t idx = 0;
     long double err_epsilon = 500e6l;
     
     for(ClipperLib::Path rinput : PRINTER_PART_POLYGONS) {
-//        ClipperLib::Path rinput = PRINTER_PART_POLYGONS[idx];
+        //        ClipperLib::Path rinput = PRINTER_PART_POLYGONS[idx];
-//        rinput.pop_back();
+        //        rinput.pop_back();
-//        std::reverse(rinput.begin(), rinput.end());
+        //        std::reverse(rinput.begin(), rinput.end());
         
-//        PolygonImpl poly(removeCollinearPoints<PathImpl, PointImpl, Unit>(rinput, 1000000));
+        //        PolygonImpl poly(removeCollinearPoints<PathImpl, PointImpl, Unit>(rinput, 1000000));
         PolygonImpl poly(rinput);
         
         long double arearef = refMinAreaBox(poly);
         auto bb = minAreaBoundingBox<PathImpl, Unit, Ratio>(rinput);
         long double area = cast<long double>(bb.area());
-//        double area = gteMinAreaBox(poly);
         
         bool succ = std::abs(arearef - area) < err_epsilon;
-        std::cout << idx++ << " " << (succ? "ok" : "failed") << " ref: " 
+        //        std::cout << idx++ << " " << (succ? "ok" : "failed") << " ref: " 
-                  << arearef << " actual: " << area << std::endl;
+//                  << arearef << " actual: " << area << std::endl;
         
         ASSERT_TRUE(succ);
     }
@@ -1006,15 +975,14 @@ TEST(RotatingCalipers, AllPrusaMinBB) {
         
         PolygonImpl poly(removeCollinearPoints<PathImpl, PointImpl, Unit>(rinput, 1000000));
         
-        
         long double arearef = refMinAreaBox(poly);
         auto bb = minAreaBoundingBox<PolygonImpl, Unit, Ratio>(poly);
         long double area = cast<long double>(bb.area());
-//        double area = gteMinAreaBox(poly);
+        
         
         bool succ = std::abs(arearef - area) < err_epsilon;
-        std::cout << idx++ << " " << (succ? "ok" : "failed") << " ref: " 
+        //        std::cout << idx++ << " " << (succ? "ok" : "failed") << " ref: " 
-                  << arearef << " actual: " << area << std::endl;
+//                  << arearef << " actual: " << area << std::endl;
         
         ASSERT_TRUE(succ);
     }

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,37 +71,40 @@ 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);
 
-    m_right = box.right_extent();
+    m_right  = libnest2d::cast<long double>(box.right_extent());
-    m_bottom = box.bottom_extent();
+    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);
 
-    m_right = box.right_extent();
+    m_right  = libnest2d::cast<long double>(box.right_extent());
-    m_bottom = box.bottom_extent();
+    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);
 
-    m_right = box.right_extent();
+    m_right  = libnest2d::cast<long double>(box.right_extent());
-    m_bottom = box.bottom_extent();
+    m_bottom = libnest2d::cast<long double>(box.bottom_extent());
     m_axis   = box.axis();
 }
 
@@ -109,18 +112,20 @@ double MinAreaBoundigBox::angle_to_X() const
 {
     double ret = std::atan2(m_axis.y(), m_axis.x());
     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
@@ -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
@@ -696,15 +696,13 @@ void SLAPrint::process()
 
         double  lhd  = m_objects.front()->m_config.layer_height.getFloat();
         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  maxZ = bb3d.max(Z);
         auto    minZf = float(minZ);
-
+        coord_t minZs = scaled(minZ);
-        auto minZs = scaled(minZ);
+        coord_t maxZs = scaled(maxZ);
-        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];