refactor center line calculation

rursprung · rursprung · commit b2df3a76dd55 · 2024-05-21T14:44:24.000+02:00
this is now stored in the result for easier access (will also be re-used
in subsequent step, this way we don't need to calculate it several
times).
diff --git a/include/banana-lib/lib.hpp b/include/banana-lib/lib.hpp
@@ -14,6 +14,8 @@ namespace banana {
     typedef std::vector<cv::Point> Contour;
     /// List of multiple contours.
     typedef std::vector<Contour> Contours;
+    /// The coefficients a0, a1 and a2 of the two-dimensional polynomial $y = a0 + a1 * x + a2 * x^2$.
+    typedef std::tuple<double, double, double> Polynomial2DCoefficients;
 
     /**
      * All errors which may occur during analysis of the image.
@@ -51,17 +53,29 @@ namespace banana {
      * The analysis results for a banana which has been found in the image.
      */
     struct AnalysisResult {
+        struct CenterLine {
+            /**
+             * The coefficients a0, a1 and a2 of the two-dimensional polynomial describing the center line of the banana.
+             * Important: note that this is given along the primary axis of the banana and not in relation to the x-axis of the image.
+             *
+             * The center line is defined approximately by the method $y = a0 + a1 * x + a2 * x^2$.
+             */
+            Polynomial2DCoefficients coefficients;
+
+            /**
+             * The points along the center line inside of the banana contour (rotated, banana coordinate system).
+             */
+            std::vector<cv::Point2d> points_in_banana_coordsys;
+        };
+
         /// Contour of the banana in the image.
         Contour contour;
-        /**
-         * The coefficients a0, a1 and a2 of the two-dimensional polynomial describing the center line of the banana.
-         * Important: note that this is given along the primary axis of the banana and not in relation to the x-axis of the image.
-         *
-         * The center line is defined approximately by the method $y = a0 + a1 * x + a2 * x^2$.
-         */
-        std::tuple<double, double, double> center_line_coefficients;
+
+        CenterLine center_line;
+
         /// The rotation angle of the banana, as seen from the x-axis. Given in radians.
         double rotation_angle;
+
         /// The estimated center of the banana shape. Note that this might actually lie outside of the banana itself due to the curvature!
         cv::Point estimated_center;
     };
@@ -154,12 +168,22 @@ namespace banana {
          * Calculate the coefficients of the two-dimensional polynomial describing the center line.
          * Important: note that this is given along the primary axis of the banana and not in relation to the x-axis of the image.
          *
-         * @param banana_contour the contour of the banana to be analysed
+         * @param rotated_banana_contour the contour of the banana to be analysed - already rotated so that the x-axis is along the primary axis of the banana.
          * @param pca_result the result from the PCA analysis
          * @return the coefficients of the two-dimensional polynomial describing the center line of the banana.
          */
         [[nodiscard]]
-        auto GetBananaCenterLineCoefficients(Contour const& banana_contour, PCAResult const& pca_result) const -> std::expected<std::tuple<double, double, double>, AnalysisError>;
+        auto GetBananaCenterLineCoefficients(Contour const& rotated_banana_contour) const -> std::expected<Polynomial2DCoefficients, AnalysisError>;
+
+        /**
+         * Calculate the center line of the banana in the coordinate system of the banana (x-axis along the primary axis of the banana).
+         *
+         * @param rotated_banana_contour the contour of the banana to be analysed - already rotated so that the x-axis is along the primary axis of the banana.
+         * @param coefficients the coefficients of the two-dimensional polynomial describing the center line of the banana
+         * @return a consecutive list of points with 1px spacing on the x-axis along the whole x-axis of the banana, describing the center line.
+         */
+        [[nodiscard]]
+        auto GetBananaCenterLine(Contour const& rotated_banana_contour, Polynomial2DCoefficients const& coefficients) const -> std::vector<cv::Point2d>;
 
         /**
          * Rotate a contour by the defined angle around the specified point.
@@ -194,9 +218,10 @@ namespace banana {
         auto AnalyzeBanana(cv::Mat const& image, Contour const& banana_contour) const -> std::expected<AnalysisResult, AnalysisError>;
 
         /**
-         * Plot the center line of the banana - as defined by the coefficients & contour - onto the provided draw target.
+         * Plot the center line of the banana onto the provided draw target.
          *
          * @param draw_target the image being annotated.
+         * @param center_line the center line along the whole x-axis of the banana in the coordinate system of the x-axis
          * @param result the analysis result for the banana to be drawn.
          */
         void PlotCenterLine(cv::Mat& draw_target, AnalysisResult const& result) const;
diff --git a/src/lib.cpp b/src/lib.cpp
@@ -40,7 +40,7 @@ namespace banana {
     std::ostream& operator << (std::ostream& o, AnnotatedAnalysisResult const& analysis_result) {
         o << "found " << analysis_result.banana.size() << " banana(s) in the picture" << std::endl;
         for (auto const& [n, banana] : std::ranges::enumerate_view(analysis_result.banana)) {
-            auto const& [coeff_0, coeff_1, coeff_2] = banana.center_line_coefficients;
+            auto const& [coeff_0, coeff_1, coeff_2] = banana.center_line.coefficients;
             o << "  Banana #" << n << ":" << std::endl;
             o << "    " << std::format("y = {} + {} * x + {} * x^2", coeff_0, coeff_1, coeff_2) << std::endl;
             o << "    Rotation = " << (banana.rotation_angle * 180 / std::numbers::pi) << " degrees" << std::endl;
@@ -129,15 +129,31 @@ namespace banana {
         return contours;
     }
 
-    auto Analyzer::GetBananaCenterLineCoefficients(Contour const& banana_contour, PCAResult const& pca_result) const -> std::expected<std::tuple<double, double, double>, AnalysisError> {
-        // rotate the contour so that it's horizontal
-        auto const rotated_contour = this->RotateContour(banana_contour, pca_result.center, pca_result.angle);
-
+    auto Analyzer::GetBananaCenterLineCoefficients(Contour const& rotated_banana_contour) const -> std::expected<Polynomial2DCoefficients, AnalysisError> {
         auto const to_std_pair_fn = [](auto const& p) -> std::pair<double, double> { return {p.x, p.y}; };
-        auto const coeffs = polyfit::Fit2DPolynomial(rotated_contour | std::views::transform(to_std_pair_fn));
+        auto const coeffs = polyfit::Fit2DPolynomial(rotated_banana_contour | std::views::transform(to_std_pair_fn));
         return coeffs.transform_error([](auto const& _) -> auto {return AnalysisError::kPolynomialCalcFailure;});
     }
 
+    auto Analyzer::GetBananaCenterLine(Contour const& rotated_banana_contour, Polynomial2DCoefficients const& coefficients) const -> std::vector<cv::Point2d> {
+        // note that the coefficients for the center line are given in relation to the bananas main axis.
+        // accordingly we have to rotate the resulting line to plot it over the banana in the image.
+
+        auto const& [coeff_0, coeff_1, coeff_2] = coefficients;
+
+        auto const minmax_x = std::ranges::minmax(rotated_banana_contour | std::views::transform(&cv::Point::x));
+
+        /// Calculate a Point2d for the [x,y] coords based on the provided polynomial and x-values.
+        auto const calc_xy = [&coeff_0, &coeff_1, &coeff_2](auto const&& x) -> cv::Point2d {
+            auto const y = coeff_0 + coeff_1 * x + coeff_2 * x * x;
+            return {static_cast<double>(x), y};
+        };
+
+        return std::views::iota(minmax_x.min, minmax_x.max)
+                   | std::views::transform(calc_xy)
+                   | std::ranges::to<std::vector>();
+    }
+
     auto Analyzer::RotateContour(Contour const& contour, cv::Point const& center, double const angle) const -> Contour {
         auto const rotation_matrix = cv::getRotationMatrix2D(center, angle * 180 / std::numbers::pi, 1);
         Contour rotated_contour{contour.size()};
@@ -181,42 +197,33 @@ namespace banana {
 
     auto Analyzer::AnalyzeBanana(cv::Mat const& image, Contour const& banana_contour) const -> std::expected<AnalysisResult, AnalysisError> {
         auto const pca = this->GetPCA(banana_contour);
-        auto const coeffs = this->GetBananaCenterLineCoefficients(banana_contour, pca);
+
+        // rotate the contour so that it's horizontal
+        auto const rotated_contour = this->RotateContour(banana_contour, pca.center, pca.angle);
+
+        auto const coeffs = this->GetBananaCenterLineCoefficients(rotated_contour);
         if (!coeffs) {
             return std::unexpected{coeffs.error()};
         }
 
+        auto const center_line_points_in_banana_coordsys = this->GetBananaCenterLine(rotated_contour, *coeffs);
+
         return AnalysisResult{
                 .contour = banana_contour,
-                .center_line_coefficients = *coeffs,
+                .center_line{
+                    .coefficients = *coeffs,
+                    .points_in_banana_coordsys = center_line_points_in_banana_coordsys,
+                 },
                 .rotation_angle = pca.angle,
                 .estimated_center = pca.center,
         };
     }
 
     void Analyzer::PlotCenterLine(cv::Mat& draw_target, AnalysisResult const& result) const {
-        // note that the coefficients for the center line are given in relation to the bananas main axis.
-        // accordingly we have to rotate the resulting line to plot it over the banana in the image.
-
-        // rotate the contour so that it's horizontal (needed to calculate the x-axis points for plotting in the coordinate system of the banana).
-        auto const rotated_contour = this->RotateContour(result.contour, result.estimated_center, result.rotation_angle);
-
-        auto const& [coeff_0, coeff_1, coeff_2] = result.center_line_coefficients;
-
-        auto const minmax_x = std::ranges::minmax(rotated_contour | std::views::transform(&cv::Point::x));
-
-        /// Calculate a Point2d for the [x,y] coords based on the provided polynomial and x-values.
-        auto const calc_xy = [&coeff_0, &coeff_1, &coeff_2](auto const&& x) -> cv::Point2d {
-            auto const y = coeff_0 + coeff_1 * x + coeff_2 * x * x;
-            return {static_cast<double>(x), y};
-        };
-        auto const to_point2i = [](auto const&& p) -> cv::Point {return {static_cast<int>(p.x), static_cast<int>(p.y)};};
-
-        auto const line_extension_length = 50; ///< amount of pixels by which the line should be extended on either side
-        auto const start = std::max(minmax_x.min - line_extension_length, 0);
-        auto const end = std::min(minmax_x.max + line_extension_length, draw_target.cols);
-        auto const center_line_points = std::views::iota(start, end) | std::views::transform(calc_xy);
-        auto const center_line_points2i = center_line_points | std::views::transform(to_point2i) | std::ranges::to<std::vector>();
+        auto const to_point2i = [](auto const& p) -> cv::Point {return {static_cast<int>(p.x), static_cast<int>(p.y)};};
+        auto const center_line_points2i = result.center_line.points_in_banana_coordsys
+                                                                     | std::views::transform(to_point2i)
+                                                                     | std::ranges::to<std::vector>();
 
         // rotate the center line back so that it fits on the image
         auto const rotated_center_line = this->RotateContour(center_line_points2i, result.estimated_center, -result.rotation_angle);
diff --git a/test/banana-lib-test.cpp b/test/banana-lib-test.cpp
@@ -51,7 +51,7 @@ TEST(BananaContourFinderTestSuite, FindTwoBananas) {
 
 TEST(CenterLineCoefficientsTestSuite, SingleBanana00) {
     GET_RESULT("resources/test-images/banana-00.jpg", 1);
-    ASSERT_COEFFS_NEAR(2536.0389294, -1.8237497, 0.0005237, result.banana.front().center_line_coefficients);
+    ASSERT_COEFFS_NEAR(2482.2342194, -1.8133667, 0.0005347, result.banana.front().center_line.coefficients);
 }
 
 TEST(PCATestSuite, SingleBanana00) {
diff --git a/test/polyfit-test-util.hpp b/test/polyfit-test-util.hpp
@@ -3,9 +3,10 @@
 
 #define ASSERT_COEFFS_NEAR(coeff_expected_0, coeff_expected_1, coeff_expected_2, coeffs) \
     do {                                                                                 \
-        ASSERT_NEAR(coeff_expected_0, std::get<0>(coeffs), 1e-6);                        \
-        ASSERT_NEAR(coeff_expected_1, std::get<1>(coeffs), 1e-6);                        \
-        ASSERT_NEAR(coeff_expected_2, std::get<2>(coeffs), 1e-6);                        \
+        auto const& [coeff_0, coeff_1, coeff_2] = coeffs;                                \
+        ASSERT_NEAR(coeff_expected_0, coeff_0, 1e-6);                                    \
+        ASSERT_NEAR(coeff_expected_1, coeff_1, 1e-6);                                    \
+        ASSERT_NEAR(coeff_expected_2, coeff_2, 1e-6);                                    \
     } while (false)
 
 #endif //BANANA_PROJECT_POLYFIT_TEST_UTIL_HPP

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ TEST(BananaContourFinderTestSuite, FindTwoBananas) {`
`51`	`51`
`52`	`52`	`TEST(CenterLineCoefficientsTestSuite, SingleBanana00) {`
`53`	`53`	`GET_RESULT("resources/test-images/banana-00.jpg", 1);`
`54`		`- ASSERT_COEFFS_NEAR(2536.0389294, -1.8237497, 0.0005237, result.banana.front().center_line_coefficients);`
	`54`	`+ ASSERT_COEFFS_NEAR(2482.2342194, -1.8133667, 0.0005347, result.banana.front().center_line.coefficients);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`TEST(PCATestSuite, SingleBanana00) {`