WIP: Reworked slicing

1) Slicing code moved to TriangleMeshSlicer.cpp,hpp from TriangleMesh.cpp,hpp
2) Refactored to use as little as possible of admesh.

src/libslic3r/TriangleMeshSlicer.hpp

@@ -0,0 +1,141 @@
+#ifndef slic3r_TriangleMeshSlicer_hpp_
+#define slic3r_TriangleMeshSlicer_hpp_
+
+#include "libslic3r.h"
+#include <admesh/stl.h>
+#include <functional>
+#include <vector>
+#include <boost/thread.hpp>
+#include "BoundingBox.hpp"
+#include "Line.hpp"
+#include "Point.hpp"
+#include "Polygon.hpp"
+#include "ExPolygon.hpp"
+
+namespace Slic3r {
+
+class TriangleMesh;
+
+enum class SlicingMode : uint32_t {
+    // Regular slicing, maintain all contours and their orientation.
+    Regular,
+    // Maintain all contours, orient all contours CCW, therefore all holes are being closed.
+    Positive,
+    // Orient all contours CCW and keep only the contour with the largest area.
+    // This mode is useful for slicing complex objects in vase mode.
+    PositiveLargestContour,
+};
+
+struct MeshSlicingParams
+{
+    SlicingMode   mode { SlicingMode::Regular };
+    // For vase mode: below this layer a different slicing mode will be used to produce a single contour.
+    // 0 = ignore.
+    size_t        slicing_mode_normal_below_layer { 0 };
+    // Mode to apply below slicing_mode_normal_below_layer. Ignored if slicing_mode_nromal_below_layer == 0.
+    SlicingMode   mode_below { SlicingMode::Regular };
+};
+
+struct MeshSlicingParamsExtended : public MeshSlicingParams
+{
+    // Morphological closing operation when creating output expolygons.
+    float         closing_radius { 0 };
+    // Positive offset applied when creating output expolygons.
+    float         extra_offset { 0 };
+    // Resolution for contour simplification.
+    // 0 = don't simplify.
+    double        resolution { 0 };
+    // Transformation of the object owning the ModelVolume.
+//    Transform3d         object_trafo;
+};
+
+class TriangleMeshSlicer
+{
+public:
+    using throw_on_cancel_callback_type = std::function<void()>;
+    TriangleMeshSlicer() = default;
+    TriangleMeshSlicer(const TriangleMesh *mesh) { this->init(mesh, []{}); }
+    TriangleMeshSlicer(const indexed_triangle_set *its) { this->init(its, []{}); }
+    void init(const TriangleMesh *mesh, throw_on_cancel_callback_type throw_on_cancel);
+    void init(const indexed_triangle_set *its, throw_on_cancel_callback_type);
+
+    void slice(
+        const std::vector<float>         &z,
+        const MeshSlicingParams          &params,
+        std::vector<Polygons>           *layers,
+        throw_on_cancel_callback_type    throw_on_cancel = []{}) const;
+
+    void slice(
+        // Where to slice.
+        const std::vector<float>         &z,
+        const MeshSlicingParamsExtended  &params,
+        std::vector<ExPolygons>         *layers,
+        throw_on_cancel_callback_type    throw_on_cancel = []{}) const;
+
+    void cut(float z, indexed_triangle_set *upper, indexed_triangle_set *lower) const;
+    void cut(float z, TriangleMesh* upper, TriangleMesh* lower) const;
+
+    void set_up_direction(const Vec3f& up);
+
+private:
+    const indexed_triangle_set *m_its { nullptr };
+//    const TriangleMesh      *mesh { nullptr };
+    // Map from a facet to an edge index.
+    std::vector<int>         facets_edges;
+    // Scaled copy of this->mesh->stl.v_shared
+    std::vector<stl_vertex>  v_scaled_shared;
+    // Quaternion that will be used to rotate every facet before the slicing
+    Eigen::Quaternion<float, Eigen::DontAlign> m_quaternion;
+    // Whether or not the above quaterion should be used
+    bool                     m_use_quaternion = false;
+};
+
+inline void slice_mesh(
+    const TriangleMesh                               &mesh,
+    const std::vector<float>                         &z,
+    std::vector<Polygons>                            &layers,
+    TriangleMeshSlicer::throw_on_cancel_callback_type thr = []{})
+{
+    if (! mesh.empty()) {
+        TriangleMeshSlicer slicer(&mesh);
+        slicer.slice(z, MeshSlicingParams{}, &layers, thr);
+    }
+}
+
+inline void slice_mesh(
+    const TriangleMesh                               &mesh,
+    const std::vector<float>                         &z,
+    const MeshSlicingParamsExtended                  &params,
+    std::vector<ExPolygons>                          &layers,
+    TriangleMeshSlicer::throw_on_cancel_callback_type thr = []{})
+{
+    if (! mesh.empty()) {
+        TriangleMeshSlicer slicer(&mesh);
+        slicer.slice(z, params, &layers, thr);
+    }
+}
+
+inline void slice_mesh(
+    const TriangleMesh                               &mesh,
+    const std::vector<float>                         &z,
+    float                                             closing_radius,
+    std::vector<ExPolygons>                          &layers,
+    TriangleMeshSlicer::throw_on_cancel_callback_type thr = []{})
+{
+    MeshSlicingParamsExtended params;
+    params.closing_radius = closing_radius;
+    slice_mesh(mesh, z, params, layers);
+}
+
+inline void slice_mesh(
+    const TriangleMesh                               &mesh,
+    const std::vector<float>                         &z,
+    std::vector<ExPolygons>                          &layers,
+    TriangleMeshSlicer::throw_on_cancel_callback_type thr = []{})
+{
+    slice_mesh(mesh, z, MeshSlicingParamsExtended{}, layers);
+}
+
+}
+
+#endif // slic3r_TriangleMeshSlicer_hpp_