A simple version of adaptive cubic support, for testing purposes

src/libslic3r/Fill/FillAdaptive.hpp

@@ -48,6 +48,12 @@ class FillAdaptive : public Fill
 public:
     virtual ~FillAdaptive() {}
 
+    static void insert_octant(
+        FillAdaptive_Internal::Cube *                             i_cube,
+        FillAdaptive_Internal::Cube *                             current,
+        int                                                       depth,
+        const std::vector<FillAdaptive_Internal::CubeProperties> &cubes_properties);
+
 protected:
     virtual Fill* clone() const { return new FillAdaptive(*this); };
 	virtual void _fill_surface_single(

src/libslic3r/PrintObject.cpp

@@ -11,6 +11,7 @@
 #include "Utils.hpp"
 #include "AABBTreeIndirect.hpp"
 #include "Fill/FillAdaptive.hpp"
+#include "Format/STL.hpp"
 
 #include <utility>
 #include <boost/log/trivial.hpp>
@@ -432,6 +433,8 @@ void PrintObject::generate_support_material()
     }
 }
 
+#define ADAPTIVE_SUPPORT_SIMPLE
+
 std::unique_ptr<FillAdaptive_Internal::Octree> PrintObject::prepare_adaptive_infill_data()
 {
     auto [adaptive_line_spacing, support_line_spacing] = adaptive_fill_line_spacing(*this);
@@ -445,6 +448,41 @@ std::unique_ptr<FillAdaptive_Internal::Octree> PrintObject::prepare_adaptive_inf
     // Center of the first cube in octree
     Vec3d mesh_origin = mesh.bounding_box().center();
 
+#ifdef ADAPTIVE_SUPPORT_SIMPLE
+    if (mesh.its.vertices.empty())
+    {
+        mesh.require_shared_vertices();
+    }
+
+    Vec3f vertical(0, 0, 1);
+
+    indexed_triangle_set its_set;
+    its_set.vertices = mesh.its.vertices;
+
+    // Filter out non overhanging faces
+    for (size_t i = 0; i < mesh.its.indices.size(); ++i) {
+        stl_triangle_vertex_indices vertex_idx = mesh.its.indices[i];
+
+        auto its_calculate_normal = [](const stl_triangle_vertex_indices &index, const std::vector<stl_vertex> &vertices) {
+            stl_normal normal = (vertices[index.y()] - vertices[index.x()]).cross(vertices[index.z()] - vertices[index.x()]);
+            return normal;
+        };
+
+        stl_normal normal = its_calculate_normal(vertex_idx, mesh.its.vertices);
+        stl_normalize_vector(normal);
+
+        if(normal.dot(vertical) >= 0.707) {
+            its_set.indices.push_back(vertex_idx);
+        }
+    }
+
+    mesh = TriangleMesh(its_set);
+
+#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
+    Slic3r::store_stl(debug_out_path("overhangs.stl").c_str(), &mesh, false);
+#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
+#endif /* ADAPTIVE_SUPPORT_SIMPLE */
+
     Vec3d rotation = Vec3d((5.0 * M_PI) / 4.0, Geometry::deg2rad(215.264), M_PI / 6.0);
     Transform3d rotation_matrix = Geometry::assemble_transform(Vec3d::Zero(), rotation, Vec3d::Ones(), Vec3d::Ones()).inverse();