CURA-13250 chamfered tree base

CMakeLists.txt

@@ -18,8 +18,9 @@ option(ENABLE_MORE_COMPILER_OPTIMIZATION_FLAGS "Enable more optimization flags"
 option(USE_SYSTEM_LIBS "Use the system libraries if available" OFF)
 option(OLDER_APPLE_CLANG "Apple Clang <= 13 used" OFF)
 option(ENABLE_THREADING "Enable threading support" ON)
+option(ENABLE_CURAVIZ "Build with CuraViz toolbox" ON)
 
-if (${ENABLE_ARCUS} OR ${ENABLE_PLUGINS})
+if (${ENABLE_ARCUS} OR ${ENABLE_PLUGINS} OR ${ENABLE_CURAVIZ})
     find_package(protobuf REQUIRED)
 endif ()
 
@@ -38,6 +39,11 @@ if (${ENABLE_ARCUS})
     protobuf_generate_cpp(engine_PB_SRCS engine_PB_HEADERS Cura.proto)
 endif ()
 
+message(STATUS "Building with CuraViz: ${ENABLE_CURAVIZ}")
+if (${ENABLE_CURAVIZ})
+    find_package(curaviz_grpc_definitions REQUIRED)
+endif ()
+
 ### Compiling CuraEngine ###
 # First compile all of CuraEngine as library.
 
@@ -157,6 +163,7 @@ set(engine_SRCS # Except main.cpp.
         src/utils/AABB3D.cpp
         src/utils/channel.cpp
         src/utils/Segment3LL.cpp
+        src/utils/CuraViz.cpp
         src/utils/Date.cpp
         src/utils/ExtrusionJunction.cpp
         src/utils/ExtrusionLine.cpp
@@ -193,6 +200,7 @@ set(engine_SRCS # Except main.cpp.
         src/utils/scoring/RandomScoringCriterion.cpp
         src/utils/scoring/TextureScoringCriterion.cpp
 
+        src/geometry/ClosedLinesSet.cpp
         src/geometry/OpenLinesSet.cpp
         src/geometry/Point2LL.cpp
         src/geometry/Point3LL.cpp
@@ -228,6 +236,7 @@ target_compile_definitions(_CuraEngine
         PUBLIC
         $<$<BOOL:${ENABLE_ARCUS}>:ARCUS>
         $<$<BOOL:${ENABLE_PLUGINS}>:ENABLE_PLUGINS>
+        $<$<BOOL:${ENABLE_CURAVIZ}>:ENABLE_CURAVIZ>
         $<$<AND:$<BOOL:${ENABLE_PLUGINS}>,$<BOOL:${ENABLE_REMOTE_PLUGINS}>>:ENABLE_REMOTE_PLUGINS>
         $<$<BOOL:${OLDER_APPLE_CLANG}>:OLDER_APPLE_CLANG>
         CURA_ENGINE_VERSION=\"${CURA_ENGINE_VERSION}\"
@@ -290,6 +299,7 @@ target_link_libraries(_CuraEngine
         $<$<NOT:$<BOOL:${EMSCRIPTEN}>>:onetbb::onetbb>
         $<$<TARGET_EXISTS:semver::semver>:semver::semver>
         $<$<TARGET_EXISTS:curaengine_grpc_definitions::curaengine_grpc_definitions>:curaengine_grpc_definitions::curaengine_grpc_definitions>
+        $<$<TARGET_EXISTS:curaviz_grpc_definitions::curaviz_grpc_definitions>:curaviz_grpc_definitions::curaviz_grpc_definitions>
         $<$<TARGET_EXISTS:asio-grpc::asio-grpc>:asio-grpc::asio-grpc>
         $<$<TARGET_EXISTS:grpc::grpc>:grpc::grpc>
         $<$<TARGET_EXISTS:protobuf::libprotobuf>:protobuf::libprotobuf>

conandata.yml

@@ -12,3 +12,5 @@ requirements_plugins:
   - "curaengine_grpc_definitions/0.4.1"
 requirements_cura_resources:
   - "cura_resources/5.14.0-alpha.0@ultimaker/testing"
+requirements_curaviz:
+  - "curaviz_grpc_definitions/1.0.0"

conanfile.py

@@ -33,6 +33,7 @@ class CuraEngineConan(ConanFile):
         "enable_plugins": [True, False],
         "enable_remote_plugins": [True, False],
         "with_cura_resources": [True, False],
+        "with_curaviz": [True, False],
     }
     default_options = {
         "enable_arcus": True,
@@ -41,6 +42,7 @@ class CuraEngineConan(ConanFile):
         "enable_plugins": True,
         "enable_remote_plugins": False,
         "with_cura_resources": False,
+        "with_curaviz": False
     }
 
     @property
@@ -89,7 +91,7 @@ def config_options(self):
     def configure(self):
         super().configure()
 
-        if self.options.enable_arcus or self.options.enable_plugins:
+        if self.options.enable_arcus or self.options.enable_plugins or self.options.with_curaviz:
             self.options["protobuf"].shared = False
         if self.options.enable_arcus:
             self.options["arcus"].shared = True
@@ -140,6 +142,9 @@ def requirements(self):
         if self.options.with_cura_resources:
             for req in self.conan_data["requirements_cura_resources"]:
                 self.requires(req)
+        if self.options.with_curaviz:
+            for req in self.conan_data["requirements_curaviz"]:
+                self.requires(req)
         self.requires("clipper/6.4.2@ultimaker/stable")
         self.requires("boost/1.88.0")
         self.requires("rapidjson/cci.20230929")
@@ -171,6 +176,7 @@ def generate(self):
             tc.variables["ENABLE_REMOTE_PLUGINS"] = self.options.enable_remote_plugins
         else:
             tc.variables["ENABLE_PLUGINS"] = self.options.enable_plugins
+        tc.variables["ENABLE_CURAVIZ"] = self.options.with_curaviz
         self.setup_cmake_toolchain_sentry(tc)
         tc.generate()
 

include/FffGcodeWriter.h

@@ -222,12 +222,14 @@ class FffGcodeWriter : public NoCopy
      * calling it for multiple layers results in the skirt/brim being printed on multiple layers.
      *
      * \param storage where the slice data is stored.
-     * \param gcodeLayer The initial planning of the g-code of the layer.
+     * \param gcode_layer The initial planning of the g-code of the layer.
      * \param extruder_nr The extruder train for which to process the skirt or
      * brim.
      * \param layer_nr The index of the layer to write the gcode of.
      */
-    void processSkirtBrim(const SliceDataStorage& storage, LayerPlan& gcodeLayer, unsigned int extruder_nr, LayerIndex layer_nr) const;
+    void processSkirtBrim(const SliceDataStorage& storage, LayerPlan& gcode_layer, const unsigned int extruder_nr, const LayerIndex layer_nr) const;
+
+    static void processSupportBrim(const SliceDataStorage& storage, LayerPlan& gcode_layer, const unsigned int extruder_nr, const LayerIndex layer_nr);
 
     /*!
      * Adds the ooze shield to the layer plan \p gcodeLayer.

include/SkirtBrim.h

@@ -220,6 +220,10 @@ class SkirtBrim
      */
     std::vector<Shape> generateAllowedAreas(const std::vector<Outline>& starting_outlines) const;
 
+    void generateSupportInsideBrim(const Settings& settings, const Shape& support_outline, const size_t width, const size_t line_width);
+
+    void generateSupportOutsideBrim(const Shape& support_outline, const size_t width, const size_t line_width, const Shape exclusion_area);
+
 public:
     /*!
      * Generate the brim which is printed from the outlines of the support inward.

include/SupportInfillPart.h

@@ -4,6 +4,7 @@
 #ifndef SUPPORT_INFILL_PART_H
 #define SUPPORT_INFILL_PART_H
 
+#include <optional>
 #include <vector>
 
 #include "geometry/Polygon.h"
@@ -23,10 +24,11 @@ namespace cura
  * Because support is handled as a whole in the engine, that is, we have a global support areas instead of support areas for each mesh.
  * With this data structure, we can keep track of which gradual support infill areas belongs to which support area, so we can print them together.
  */
-class SupportInfillPart
+struct SupportInfillPart
 {
-public:
     SingleShape outline_; //!< The outline of the support infill area
+    std::optional<Shape> base_outside_contour_; //!< Outline contour including the outer base
+    std::optional<Shape> base_inside_contour_; //!< If an inside base is generated, contains the inner contour
     AABB outline_boundary_box_; //!< The boundary box for the infill area
     coord_t support_line_width_; //!< The support line width
     int inset_count_to_generate_; //!< The number of insets need to be generated from the outline. This is not the actual insets that will be generated.
@@ -42,12 +44,6 @@ class SupportInfillPart
     const Shape& getInfillArea() const;
 };
 
-inline const Shape& SupportInfillPart::getInfillArea() const
-{
-    // if there is no wall, we use the original outline as the infill area
-    return outline_;
-}
-
 } // namespace cura
 
 #endif // SUPPORT_INFILL_PART_H

include/WallToolPathGenerator.h

@@ -0,0 +1,18 @@
+// Copyright (c) 2023 UltiMaker
+// CuraEngine is released under the terms of the AGPLv3 or higher
+
+#ifndef CURAENGINE_WALLTOOLPATHGENERATOR_H
+#define CURAENGINE_WALLTOOLPATHGENERATOR_H
+
+namespace cura
+{
+
+enum class WallToolPathGenerator
+{
+    Arachne, // Use arachne to generate smart extrusion tool paths with variable line width
+    NaiveInset // Use a naive implementation to generate tool paths with constant line width
+};
+
+}
+
+#endif

include/WallToolPaths.h

@@ -4,6 +4,7 @@
 #ifndef CURAENGINE_WALLTOOLPATHS_H
 #define CURAENGINE_WALLTOOLPATHS_H
 
+#include "WallToolPathGenerator.h"
 #include "geometry/Polygon.h"
 #include "settings/Settings.h"
 #include "utils/ExtrusionLine.h"
@@ -29,7 +30,8 @@ class WallToolPaths
         const coord_t wall_0_inset,
         const Settings& settings,
         const int layer_idx,
-        SectionType section_type);
+        SectionType section_type,
+        WallToolPathGenerator generator = WallToolPathGenerator::Arachne);
 
     /*!
      * A class that creates the toolpaths given an outline, nominal bead width and maximum amount of walls
@@ -118,6 +120,11 @@ class WallToolPaths
      */
     static void simplifyToolPaths(std::vector<VariableWidthLines>& toolpaths, const Settings& settings);
 
+private:
+    void generateArachne();
+
+    void generateNaiveInset();
+
 private:
     const Shape& outline_; //<! A reference to the outline polygon that is the designated area
     coord_t bead_width_0_; //<! The nominal or first extrusion line width with which libArachne generates its walls
@@ -144,6 +151,7 @@ class WallToolPaths
     const Settings& settings_;
     int layer_idx_;
     SectionType section_type_;
+    const WallToolPathGenerator generator_{ WallToolPathGenerator::Arachne };
 };
 } // namespace cura
 

include/geometry/ClosedLinesSet.h

@@ -4,18 +4,42 @@
 #ifndef GEOMETRY_CLOSED_LINES_SET_H
 #define GEOMETRY_CLOSED_LINES_SET_H
 
+#include "geometry/ClosedPolyline.h"
+#include "geometry/LinesSet.h"
+
 namespace cura
 {
 
-template<class LineType>
-class LinesSet;
-class ClosedPolyline;
+class MixedLinesSet;
 
 /*!
  * \brief Convenience definition for a container that can hold only closed polylines. This makes it
  *        explicit what the lines actually represent.
  */
-using ClosedLinesSet = LinesSet<ClosedPolyline>;
+class ClosedLinesSet : public LinesSet<ClosedPolyline>
+{
+public:
+    ClosedLinesSet() = default;
+
+    ClosedLinesSet(LinesSet<ClosedPolyline>&& other)
+        : LinesSet(std::move(other))
+    {
+    }
+
+    explicit ClosedLinesSet(const std::initializer_list<ClosedPolyline>& initializer)
+        : LinesSet(initializer)
+    {
+    }
+
+    explicit ClosedLinesSet(const ClosedPolyline& line)
+        : LinesSet(line)
+    {
+    }
+
+    [[nodiscard]] MixedLinesSet intersection(const Shape& shape) const;
+
+    [[nodiscard]] MixedLinesSet difference(const Shape& shape) const;
+};
 
 } // namespace cura
 

include/geometry/ClosedPolyline.h

@@ -10,6 +10,8 @@ namespace cura
 {
 
 class OpenPolyline;
+class MixedLinesSet;
+class Shape;
 
 /*! @brief This describes a polyline which forms a closed path.
  *  @sa https://github.com/Ultimaker/CuraEngine/wiki/Geometric-Base-Types#closedpolyline
@@ -53,7 +55,11 @@ class ClosedPolyline : public Polyline
     ClosedPolyline(const ClosedPolyline& other) = default;
 
     /*! \brief Constructor that takes ownership of the inner points list from the given polyline */
-    ClosedPolyline(ClosedPolyline&& other) = default;
+    ClosedPolyline(ClosedPolyline&& other) noexcept
+        : Polyline{ std::move(other) }
+        , explicitly_closed_(other.explicitly_closed_)
+    {
+    }
 
     /*!
      * \brief Constructor with a points initializer list, provided for convenience
@@ -99,6 +105,8 @@ class ClosedPolyline : public Polyline
     /*! @see Polyline::isValid() */
     [[nodiscard]] bool isValid() const override;
 
+    void addPath(ClipperLib::Clipper& clipper, ClipperLib::PolyType poly_typ) const override;
+
     ClosedPolyline& operator=(const ClosedPolyline& other) = default;
 
     ClosedPolyline& operator=(ClosedPolyline&& other) = default;

include/geometry/LinesSet.h

@@ -263,13 +263,6 @@ class LinesSet
      */
     void addPaths(ClipperLib::Clipper& clipper, ClipperLib::PolyType poly_typ) const;
 
-    /*!
-     * \brief Utility method to add a line to a ClipperLib::Clipper object
-     * \note This method needs to be public but you shouldn't need to use it from outside
-     */
-    template<class OtherLineLine>
-    void addPath(ClipperLib::Clipper& clipper, const OtherLineLine& line, ClipperLib::PolyType poly_typ) const;
-
     /*!
      * \brief Utility method to add all the lines to a ClipperLib::ClipperOffset object
      * \note This method needs to be public but you shouldn't need to use it from outside

include/geometry/MixedLinesSet.h

@@ -6,13 +6,13 @@
 
 #include <memory>
 
-#include "geometry/ClosedLinesSet.h"
 #include "utils/Coord_t.h"
 
 namespace cura
 {
 
 class ClosedPolyline;
+class ClosedLinesSet;
 class OpenLinesSet;
 class OpenPolyline;
 class Polygon;
@@ -22,13 +22,22 @@ class Shape;
 using PolylinePtr = std::shared_ptr<Polyline>;
 using OpenPolylinePtr = std::shared_ptr<OpenPolyline>;
 
+template<class LineType>
+class LinesSet;
+
 /*!
  * \brief Convenience definition for a container that can hold any type of polyline.
  * \sa https://github.com/Ultimaker/CuraEngine/wiki/Geometric-Base-Types#mixedlinesset
  */
 class MixedLinesSet : public std::vector<PolylinePtr>
 {
 public:
+    MixedLinesSet() = default;
+
+    MixedLinesSet(const ClosedLinesSet& lines);
+
+    MixedLinesSet(ClipperLib::PolyTree&& tree);
+
     /*!
      * \brief Computes the offset of all the polylines contained in the set. The polylines may
      *        be of different types, and polylines are polygons are treated differently.
@@ -39,9 +48,16 @@ class MixedLinesSet : public std::vector<PolylinePtr>
      */
     [[nodiscard]] Shape offset(coord_t distance, ClipperLib::JoinType join_type = ClipperLib::jtMiter, double miter_limit = 1.2) const;
 
+    MixedLinesSet intersection(const Shape& shape) const;
+
+    MixedLinesSet difference(const Shape& shape) const;
+
     /*! @brief Adds a copy of the given polyline to the set */
     void push_back(const OpenPolyline& line);
 
+    /*! @brief Adds a copy of the given polyline to the set */
+    void push_back(const ClosedPolyline& line);
+
     /*! @brief Adds a copy of the given polyline to the set */
     void push_back(const Polygon& line);
 
@@ -68,6 +84,9 @@ class MixedLinesSet : public std::vector<PolylinePtr>
     /*! @brief Adds a copy of all the polylines contained in the set */
     void push_back(OpenLinesSet&& lines_set);
 
+    /*! @brief Adds a copy of all the polylines contained in the set */
+    void push_back(const ClosedLinesSet& lines_set);
+
     /*! @brief Adds a copy of all the polylines contained in the set */
     void push_back(ClosedLinesSet&& lines_set);
 

include/geometry/OpenPolyline.h

@@ -84,6 +84,11 @@ class OpenPolyline : public Polyline
         return size() >= 2;
     }
 
+    void addPath(ClipperLib::Clipper& clipper, ClipperLib::PolyType poly_typ) const final
+    {
+        clipper.AddPath(getPoints(), poly_typ, false);
+    }
+
     OpenPolyline& operator=(OpenPolyline&& other) noexcept = default;
 
     OpenPolyline& operator=(const OpenPolyline& other) = default;