Move structures to their own files and convert to classes

CURA-12361

Author: wawanbreton

CMakeLists.txt

@@ -43,7 +43,6 @@ endif ()
 
 set(engine_SRCS # Except main.cpp.
         src/Application.cpp
-        src/bridge.cpp
         src/ConicalOverhang.cpp
         src/ExtruderPlan.cpp
         src/ExtruderTrain.cpp
@@ -99,6 +98,12 @@ set(engine_SRCS # Except main.cpp.
         src/BeadingStrategy/WideningBeadingStrategy.cpp
         src/BeadingStrategy/OuterWallInsetBeadingStrategy.cpp
 
+        src/bridge/bridge.cpp
+        src/bridge/ExpansionRange.cpp
+        src/bridge/SegmentOverlappingData.cpp
+        src/bridge/TransformedSegment.cpp
+        src/bridge/TransformedShape.cpp
+
         src/communication/ArcusCommunication.cpp
         src/communication/ArcusCommunicationPrivate.cpp
         src/communication/CommandLine.cpp

doc/bridging_skin_support.svg

@@ -0,0 +1,139 @@
+// Copyright (c) 2025 Ultimaker B.V.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
+
+#ifndef BRIDGE_EXPANSIONRANGE_H
+#define BRIDGE_EXPANSIONRANGE_H
+
+#include <optional>
+
+#include "bridge/TransformedSegment.h"
+
+namespace cura
+{
+
+struct SegmentOverlapping;
+
+/*! Helper structure containing a vertical range that has been projected (or not) for a segment */
+class ExpansionRange
+{
+public:
+    /*!
+     * Constructs a range that has been projected to an infill line
+     * @param segment The actual projected segment, cropped to the range
+     * @param supporting_segment The infill line which is supporting this segment
+     */
+    ExpansionRange(const TransformedSegment& segment, const TransformedSegment* supporting_segment)
+        : data_{ .segment = segment }
+        , supporting_segment_(supporting_segment)
+        , is_projected_(true)
+    {
+    }
+
+    /*!
+     * Constructs a range that has not been projected
+     * @param min_y The range bottom Y coordinate
+     * @param max_y The range maximum Y coordinate
+     * @param expanded_segment The segment being expanded
+     */
+    ExpansionRange(const coord_t min_y, const coord_t max_y, const TransformedSegment* expanded_segment)
+        : data_{ .range = { .min_y = min_y, .max_y = max_y } }
+        , supporting_segment_(expanded_segment)
+        , is_projected_(false)
+    {
+    }
+
+    coord_t minY() const
+    {
+        return is_projected_ ? data_.segment.minY() : data_.range.min_y;
+    }
+
+    coord_t maxY() const
+    {
+        return is_projected_ ? data_.segment.maxY() : data_.range.max_y;
+    }
+
+    /*!
+     * Calculate the horizontal overlapping between this range and an other segment, given the expand direction. Overlapping means that the new segment is on the right (or left)
+     * of the actual segment on a horizontal band formed by the segment top and bottom
+     * @param other The other segment that may be overlapping
+     * @param expand_direction The expand direction, 1 means expand to the right, -1 expand to the left
+     * @return The overlapping details if the segment actually overlap, or nullopt if it doesn't
+     */
+    std::optional<SegmentOverlapping> calculateOverlapping(const TransformedSegment& other, const int8_t expand_direction) const;
+
+    /*! Move the range maximum Y coordinate down, actually cropping it */
+    void cropTop(const coord_t new_max_y)
+    {
+        if (is_projected_)
+        {
+            data_.segment.cropTop(new_max_y);
+        }
+        else
+        {
+            data_.range.max_y = new_max_y;
+        }
+    }
+
+    /*! Move the segment minimum Y coordinate up, actually cropping it */
+    void cropBottom(const coord_t new_min_y)
+    {
+        if (is_projected_)
+        {
+            data_.segment.cropBottom(new_min_y);
+        }
+        else
+        {
+            data_.range.min_y = new_min_y;
+        }
+    }
+
+    /*! Indicates if the range is still valid, e.g. doesn't have a (almost) null height */
+    bool isValid() const
+    {
+        return fuzzy_not_equal(maxY(), minY());
+    }
+
+    void setProjectedEnd(const Point2LL& end)
+    {
+        data_.segment.setEnd(end);
+    }
+
+    const TransformedSegment* getSupportingSegment() const
+    {
+        return supporting_segment_;
+    }
+
+    bool isProjected() const
+    {
+        return is_projected_;
+    }
+
+    const TransformedSegment& getProjectedSegment() const
+    {
+        return data_.segment;
+    }
+
+private:
+    union
+    {
+        // The segment that has been projected
+        TransformedSegment segment;
+        // The range that has not been projected
+        struct
+        {
+            coord_t min_y;
+            coord_t max_y;
+        } range;
+    } data_;
+
+    // The supporting segment that this range is based upon, or the segment being expanded if it has not been projected
+    const TransformedSegment* supporting_segment_;
+
+    // True if this range has been projected to a supported infill line, in which case you can use data.segment. Otherwise the range has not been projected and only contains
+    // its Y range in data.range.
+    bool is_projected_;
+};
+
+} // namespace cura
+
+#endif

include/bridge/ExpansionRange.h

@@ -0,0 +1,21 @@
+// Copyright (c) 2025 Ultimaker B.V.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
+
+#ifndef BRIDGE_SEGMENTOVERLAPPING_H
+#define BRIDGE_SEGMENTOVERLAPPING_H
+
+#include "bridge/SegmentOverlappingType.h"
+#include "bridge/TransformedSegment.h"
+
+namespace cura
+{
+
+struct SegmentOverlapping
+{
+    SegmentOverlappingType type;
+    TransformedSegment other_overlapping_part;
+};
+
+} // namespace cura
+
+#endif

include/bridge/SegmentOverlapping.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2025 Ultimaker B.V.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
+
+#ifndef BRIDGE_SEGMENTOVERLAPPINGDATA_H
+#define BRIDGE_SEGMENTOVERLAPPINGDATA_H
+
+#include "geometry/Point2LL.h"
+#include "utils/Coord_t.h"
+
+namespace cura
+{
+
+class TransformedSegment;
+
+/*! Helper structure that calculate the basic coordinates data to be used to perform segments overlapping calculation */
+struct SegmentOverlappingData
+{
+    coord_t y_min;
+    coord_t y_max;
+    coord_t this_x_min;
+    coord_t this_x_max;
+    coord_t other_x_min;
+    coord_t other_x_max;
+
+    /*!
+     * Builds the basic segment overlapping data
+     * @param this_min_y The minimum Y coordinate of the original segment
+     * @param this_max_y The maximum Y coordinate of the original segment
+     * @param other_min_y The minimum Y coordinate of the tested segment
+     * @param other_max_y The maximum Y coordinate of the tested segment
+     * @param this_start The actual start position of the original segment, which may be null
+     * @param this_end The actual end position of the original segment, which may be null
+     * @param other_start The actual start position of the tested segment
+     * @param other_end The actual end position of the tested segment
+     */
+    SegmentOverlappingData(
+        const coord_t this_min_y,
+        const coord_t this_max_y,
+        const coord_t other_min_y,
+        const coord_t other_max_y,
+        const Point2LL* this_start,
+        const Point2LL* this_end,
+        const Point2LL& other_start,
+        const Point2LL& other_end);
+
+    /*! Make the cropped segment that is actually overlapping over the original segment, which may be part of all of the initial segment */
+    TransformedSegment makeOtherOverlappingPart() const;
+};
+
+} // namespace cura
+
+#endif

include/bridge/SegmentOverlappingData.h

@@ -0,0 +1,21 @@
+// Copyright (c) 2025 Ultimaker B.V.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
+
+#ifndef BRIDGE_SEGMENTOVERLAPPINGTYPE_H
+#define BRIDGE_SEGMENTOVERLAPPINGTYPE_H
+
+namespace cura
+{
+
+/*! Enumeration containing the overlapping type of two segments in the bridging projection direction */
+enum class SegmentOverlappingType
+{
+    Full, // The segment fully overlaps with the base segment
+    Bottom, // The segment overlaps with the base segment only on its bottom part
+    Top, // The segment overlaps with the base segment only on its top part
+    Middle, // The segment overlaps with the base segment somewhere in the middle, but not top neither bottom
+};
+
+} // namespace cura
+
+#endif

include/bridge/SegmentOverlappingType.h

@@ -0,0 +1,94 @@
+// Copyright (c) 2025 Ultimaker B.V.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
+
+#ifndef BRIDGE_TRANSFORMEDSEGMENT_H
+#define BRIDGE_TRANSFORMEDSEGMENT_H
+
+#include <optional>
+
+#include "geometry/Point2LL.h"
+
+namespace cura
+{
+
+enum class SegmentOverlappingType;
+struct SegmentOverlapping;
+class PointMatrix;
+
+/*! Base structure tha represents a segment that has been transformed in the space where the bridging lines are horizontal */
+class TransformedSegment
+{
+public:
+    TransformedSegment() = default;
+
+    TransformedSegment(const Point2LL& transformed_start, const Point2LL& transformed_end)
+        : start_(transformed_start)
+        , end_(transformed_end)
+    {
+        updateMinMax();
+    }
+
+    TransformedSegment(const Point2LL& start, const Point2LL& end, const PointMatrix& matrix);
+
+    void setStart(const Point2LL& transformed_start)
+    {
+        start_ = transformed_start;
+        updateMinMax();
+    }
+
+    void setEnd(const Point2LL& transformed_end)
+    {
+        end_ = transformed_end;
+        updateMinMax();
+    }
+
+    void updateMinMax();
+
+    coord_t minY() const
+    {
+        return min_y_;
+    }
+
+    coord_t maxY() const
+    {
+        return max_y_;
+    }
+
+    const Point2LL& getStart() const
+    {
+        return start_;
+    }
+
+    const Point2LL& getEnd() const
+    {
+        return end_;
+    }
+
+    /*!
+     * Calculate the horizontal overlapping between this segment and an other segment, given the expand direction. Overlapping means that the new segment is on the right (or left)
+     * of the actual segment on a horizontal band formed by the segment top and bottom
+     * @param other The other segment that may be overlapping
+     * @param expand_direction The expand direction, 1 means expand to the right, -1 expand to the left
+     * @return The overlapping details if the segment actually overlap, or nullopt if it doesn't
+     */
+    std::optional<SegmentOverlapping> calculateOverlapping(const TransformedSegment& other, const int8_t expand_direction) const;
+
+    /*! Move the segment maximum Y coordinate down, actually cropping it */
+    void cropTop(const coord_t new_max_y);
+
+    /*! Move the segment minimum Y coordinate up, actually cropping it */
+    void cropBottom(const coord_t new_min_y);
+
+    /*! Calculate an overlapping type, given whether the segments overlap on the top, bottom or both. Only in case there is no segment intersection. */
+    static SegmentOverlappingType makeNonIntersectingOverlapping(const bool overlap_top, const bool overlap_bottom);
+
+private:
+    Point2LL start_;
+    Point2LL end_;
+    coord_t min_y_{ 0 };
+    coord_t max_y_{ 0 };
+};
+
+} // namespace cura
+
+#endif