Make an order in using scale and unscale, remove some warnings.
This commit is contained in:
tamasmeszaros
parent
2f806dedc7
commit
14b32c4f16
@ -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>;
|
||||
|
||||
//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;
|
||||
//}
|
||||
using Ratio = boost::rational<boost::multiprecision::int128_t>;
|
||||
|
||||
}
|
||||
|
||||
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];
|
||||
// rinput.pop_back();
|
||||
// std::reverse(rinput.begin(), rinput.end());
|
||||
// ClipperLib::Path rinput = PRINTER_PART_POLYGONS[idx];
|
||||
// rinput.pop_back();
|
||||
// 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: "
|
||||
<< arearef << " actual: " << area << std::endl;
|
||||
// std::cout << idx++ << " " << (succ? "ok" : "failed") << " ref: "
|
||||
// << 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: "
|
||||
<< arearef << " actual: " << area << std::endl;
|
||||
// std::cout << idx++ << " " << (succ? "ok" : "failed") << " ref: "
|
||||
// << arearef << " actual: " << area << std::endl;
|
||||
|
||||
ASSERT_TRUE(succ);
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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_bottom = box.bottom_extent();
|
||||
m_right = libnest2d::cast<long double>(box.right_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_bottom = box.bottom_extent();
|
||||
m_right = libnest2d::cast<long double>(box.right_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_bottom = box.bottom_extent();
|
||||
m_right = libnest2d::cast<long double>(box.right_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
|
||||
|
||||
@ -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();
|
||||
}
|
||||
|
||||
|
||||
@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
@ -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);
|
||||
|
||||
auto &&bb3d = mesh.bounding_box();
|
||||
coord_t lhs = scaled(lhd);
|
||||
auto && bb3d = mesh.bounding_box();
|
||||
double minZ = bb3d.min(Z) - po.get_elevation();
|
||||
double maxZ = bb3d.max(Z);
|
||||
auto minZf = float(minZ);
|
||||
|
||||
auto minZs = scaled(minZ);
|
||||
auto maxZs = scaled(maxZ);
|
||||
coord_t minZs = scaled(minZ);
|
||||
coord_t 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 double height = scaled(m_printer_config.display_height.getFloat());
|
||||
const auto width = scaled<double>(m_printer_config.display_width.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));
|
||||
}
|
||||
}
|
||||
|
||||
@ -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];
|
||||
|
||||
Loading…
Reference in New Issue
Block a user