1.2025.01.11: dewarp: fix density thresholds

Author: zvezdochiot

src/dewarping/CylindricalSurfaceDewarper.cpp

@@ -118,7 +118,7 @@ CylindricalSurfaceDewarper::mapGeneratrix(double crv_x, State& state) const
 {
     double const pln_x = m_arcLengthMapper.arcLenToX(crv_x, state.m_arcLengthHint);
 
-    double const lin_y1 = -0.02 * (m_curveAngle - 2.0);
+    double const lin_y1 = -0.05 * (m_curveAngle - 2.0);
     double const lin_y2 = -lin_y1;
     double const lin_y = lin_y1 + (lin_y2 - lin_y1) * pln_x;
 
@@ -152,13 +152,11 @@ CylindricalSurfaceDewarper::mapGeneratrix(double crv_x, State& state) const
 
     QPointF const img_straight_line_pt(toPoint(m_pln2img(Vector2d(pln_x, img_directrix12fs_proj))));
     double const img_straight_line_proj(projector.projectionScalar(img_straight_line_pt));
-    double const img_straight_line_proj_st = pln_straight_line_frac * img_directrix12fs_proj
-                                           + (1.0 - pln_straight_line_frac) * img_straight_line_proj;
 
     boost::array<std::pair<double, double>, 3> pairs;
     pairs[0] = std::make_pair(0.0, img_directrix1_proj);
     pairs[1] = std::make_pair(1.0, img_directrix2_proj);
-    pairs[2] = std::make_pair(pln_straight_line_y, img_straight_line_proj_st);
+    pairs[2] = std::make_pair(pln_straight_line_y, img_straight_line_proj);
 
     HomographicTransform<1, double> H(threePoint1DHomography(pairs));
 
@@ -178,7 +176,7 @@ CylindricalSurfaceDewarper::mapToDewarpedSpace(QPointF const& img_pt, State& sta
     double const pln_x = m_img2pln(toVec(img_pt))[0];
     double const crv_x = m_arcLengthMapper.xToArcLen(pln_x, state.m_arcLengthHint);
 
-    double const lin_y1 = -0.02 * (m_curveAngle - 2.0);
+    double const lin_y1 = -0.05 * (m_curveAngle - 2.0);
     double const lin_y2 = -lin_y1;
     double const lin_y = lin_y1 + (lin_y2 - lin_y1) * pln_x;
 
@@ -212,13 +210,11 @@ CylindricalSurfaceDewarper::mapToDewarpedSpace(QPointF const& img_pt, State& sta
 
     QPointF const img_straight_line_pt(toPoint(m_pln2img(Vector2d(pln_x, img_directrix12fs_proj))));
     double const img_straight_line_proj(projector.projectionScalar(img_straight_line_pt));
-    double const img_straight_line_proj_st = pln_straight_line_frac * img_directrix12fs_proj
-                                           + (1.0 - pln_straight_line_frac) * img_straight_line_proj;
 
     boost::array<std::pair<double, double>, 3> pairs;
     pairs[0] = std::make_pair(img_directrix1_proj, 0.0);
     pairs[1] = std::make_pair(img_directrix2_proj, 1.0);
-    pairs[2] = std::make_pair(img_straight_line_proj_st, pln_straight_line_y);
+    pairs[2] = std::make_pair(img_straight_line_proj, pln_straight_line_y);
 
     HomographicTransform<1, double> const H(threePoint1DHomography(pairs));
 
@@ -323,7 +319,7 @@ CylindricalSurfaceDewarper::fourPoint2DHomography(
     Matrix<double, 8, 1> const h(qr.solve(b));
     Matrix3d H;
     H << h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7], 1.0;
-
+    
     return HomographicTransform<2, double>(H);
 }
 
@@ -349,7 +345,7 @@ CylindricalSurfaceDewarper::threePoint1DHomography(
     auto qr = A.colPivHouseholderQr();
     if (!qr.isInvertible())
     {
-        throw std::runtime_error("Failed to build 2D homography");
+        throw std::runtime_error("Failed to build curves homography");
     }
 
     Matrix<double, 3, 1> const h(qr.solve(b));

src/dewarping/CylindricalSurfaceDewarper.h

@@ -19,15 +19,15 @@
 #ifndef DEWARPING_CYLINDRICAL_SURFACE_DEWARPER_H_
 #define DEWARPING_CYLINDRICAL_SURFACE_DEWARPER_H_
 
-#include "dewarping_config.h"
-#include "HomographicTransform.h"
-#include "PolylineIntersector.h"
-#include "ArcLengthMapper.h"
-#include <boost/array.hpp>
 #include <vector>
 #include <utility>
 #include <QPointF>
 #include <QLineF>
+#include <boost/array.hpp>
+#include "dewarping_config.h"
+#include "HomographicTransform.h"
+#include "PolylineIntersector.h"
+#include "ArcLengthMapper.h"
 
 namespace dewarping
 {

src/dewarping/DetectVerticalBounds.cpp

@@ -16,16 +16,16 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <cmath>
+#include <utility>
+#include <cassert>
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/random/uniform_int_distribution.hpp>
 #include "DetectVerticalBounds.h"
 #include "NumericTraits.h"
 #include "ToLineProjector.h"
 #include "LineIntersectionScalar.h"
 #include "imageproc/Constants.h"
-#include <boost/random/mersenne_twister.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-#include <cmath>
-#include <utility>
-#include <cassert>
 
 using namespace imageproc;
 
@@ -42,7 +42,8 @@ enum LeftRightSide
 };
 
 QLineF findVerticalBound(std::vector<QLineF> const& chords,
-                         double const dist_threshold, LeftRightSide const side)
+                         double const dist_threshold,
+                         LeftRightSide const side)
 {
     if (chords.size() < 2)
     {
@@ -125,7 +126,8 @@ QLineF findVerticalBound(std::vector<QLineF> const& chords,
 } // anonymous namespace
 
 std::pair<QLineF, QLineF> detectVerticalBounds(
-    std::list<std::vector<QPointF>> const& curves, double const dist_threshold)
+    std::list<std::vector<QPointF>> const& curves,
+    double const dist_threshold)
 {
     std::vector<QLineF> chords;
     chords.reserve(curves.size());

src/dewarping/DewarpingImageTransform.cpp

@@ -126,7 +126,11 @@ DewarpingImageTransform::DewarpingImageTransform(
     , m_depthPerception(depth_perception)
     , m_curveCorrect(curve_correct)
     , m_curveAngle(curve_angle)
-    , m_dewarper(top_curve, bottom_curve, depth_perception.value(), curve_correct.value(), curve_angle.value())
+    , m_dewarper(top_curve,
+                 bottom_curve,
+                 depth_perception.value(),
+                 curve_correct.value(),
+                 curve_angle.value())
     , m_intrinsicScaleX(1.0)
     , m_intrinsicScaleY(1.0)
     , m_userScaleX(1.0)
@@ -147,7 +151,11 @@ DewarpingImageTransform::fingerprint() const
     RoundingHasher hash(QCryptographicHash::Sha1);
 
     hash << "DewarpingImageTransform";
-    hash << m_origSize << m_origCropArea << m_depthPerception.value() << m_curveCorrect.value() << m_curveAngle.value();
+    hash << m_origSize
+         << m_origCropArea
+         << m_depthPerception.value()
+         << m_curveCorrect.value()
+         << m_curveAngle.value();
 
     for (QPointF const& pt : m_topPolyline)
     {
@@ -200,7 +208,8 @@ DewarpingImageTransform::scale(double xscale, double yscale)
 
 AffineTransformedImage
 DewarpingImageTransform::toAffine(
-    QImage const& image, QColor const& outside_color,
+    QImage const& image,
+    QColor const& outside_color,
     std::shared_ptr<AcceleratableOperations> const& accel_ops) const
 {
     assert(!image.isNull());
@@ -261,15 +270,18 @@ DewarpingImageTransform::toAffine() const
 }
 
 QImage
-DewarpingImageTransform::materialize(QImage const& image,
-                                     QRect const& target_rect,
-                                     QColor const& outside_color,
-                                     std::shared_ptr<AcceleratableOperations> const& accel_ops) const
+DewarpingImageTransform::materialize(
+    QImage const& image,
+    QRect const& target_rect,
+    QColor const& outside_color,
+    std::shared_ptr<AcceleratableOperations> const& accel_ops) const
 {
     assert(!image.isNull());
     assert(!target_rect.isEmpty());
 
-    QRectF model_domain(0, 0, m_intrinsicScaleX * m_userScaleX, m_intrinsicScaleY * m_userScaleY);
+    QRectF model_domain(0, 0,
+        m_intrinsicScaleX * m_userScaleX,
+        m_intrinsicScaleY * m_userScaleY);
     model_domain.translate(-target_rect.topLeft());
     auto const minmax_densities = calcMinMaxDensities();
 
@@ -289,7 +301,8 @@ DewarpingImageTransform::forwardMapper() const
 {
     auto dewarper(std::make_shared<CylindricalSurfaceDewarper>(m_dewarper));
     QTransform post_transform;
-    post_transform.scale(m_intrinsicScaleX * m_userScaleX, m_intrinsicScaleY * m_userScaleY);
+    post_transform.scale(m_intrinsicScaleX * m_userScaleX,
+                         m_intrinsicScaleY * m_userScaleY);
 
     return [=](QPointF const& pt)
     {
@@ -435,7 +448,8 @@ DewarpingImageTransform::constrainCropArea(QPolygonF const& orig_crop_area) cons
     double const min_density = minmax_densities.first;
     double const max_density = minmax_densities.second;
 
-    ConstrainedCropAreaBuilder builder(orig_crop_area, min_density, max_density, m_dewarper);
+    ConstrainedCropAreaBuilder builder(orig_crop_area,
+        min_density, max_density, m_dewarper);
 
     builder.sampleCrvXRange(0.0 + 0.3, 0.0 - 0.6, -1.0);
     builder.sampleCrvXRange(1.0 - 0.3, 1.0 + 0.6, 1.0);
@@ -469,7 +483,8 @@ DewarpingImageTransform::calcMinMaxDensities() const
     auto const minmax_densities = std::minmax_element(
                                       std::begin(corner_densities), std::end(corner_densities)
                                   );
-    return std::make_pair(0.6 * *minmax_densities.first, 1.4 * *minmax_densities.second);
+/*    return std::make_pair(0.6 * *minmax_densities.first, 1.4 * *minmax_densities.second); // Tulon */
+    return std::make_pair(0.5 * *minmax_densities.first, 2.0 * *minmax_densities.second); // zvezdochiot (2025-01-11)
 }
 
 
@@ -509,7 +524,8 @@ DewarpingImageTransform::ConstrainedCropAreaBuilder::sampleCrvXRange(
     {
 
         auto segment_it = processGeneratrix(
-                              crv_x, m_dewarper.mapGeneratrix(crv_x, m_dewarpingState)
+                              crv_x,
+                              m_dewarper.mapGeneratrix(crv_x, m_dewarpingState)
                           );
         if (segment_it == m_vertSegments.end())
         {
@@ -522,7 +538,9 @@ DewarpingImageTransform::ConstrainedCropAreaBuilder::sampleCrvXRange(
             if (last_segment)
             {
                 maybeAddExtraVerticalSegments(
-                    last_segment->crv_x, last_segment->length, segment_it->first, segment_len
+                    last_segment->crv_x,
+                    last_segment->length,
+                    segment_it->first, segment_len
                 );
             }
 
@@ -653,7 +671,8 @@ DewarpingImageTransform::ConstrainedCropAreaBuilder::maybeAddExtraVerticalSegmen
 
     double const mid_crv_x = 0.5 * (segment1_crv_x + segment2_crv_x);
     auto const segment_it = processGeneratrix(
-                                mid_crv_x, m_dewarper.mapGeneratrix(mid_crv_x, m_dewarpingState)
+                                mid_crv_x,
+                                m_dewarper.mapGeneratrix(mid_crv_x, m_dewarpingState)
                             );
     if (segment_it == m_vertSegments.end())
     {

src/dewarping/DistortionModelBuilder.cpp

@@ -302,15 +302,16 @@ DistortionModelBuilder::centroid(std::vector<QPointF> const& polyline)
         return Vec2d(polyline.front());
     }
 
-    Vec2d accum(0, 0);
-    double total_weight = 0;
+    Vec2d accum(0.0, 0.0);
+    double total_weight = 0.0;
 
     for (int i = 1; i < num_points; ++i)
     {
         QLineF const segment(polyline[i - 1], polyline[i]);
         Vec2d const center(0.5 * (segment.p1() + segment.p2()));
         double const weight = segment.length();
-        accum += center * weight;
+        Vec2d const delta(center * weight);
+        accum += delta;
         total_weight += weight;
     }
 
@@ -320,7 +321,7 @@ DistortionModelBuilder::centroid(std::vector<QPointF> const& polyline)
     }
     else
     {
-        return accum / total_weight;
+        return Vec2d(accum / total_weight);
     }
 }
 
@@ -574,7 +575,7 @@ DistortionModelBuilder::visualizeTrimmedPolylines(
 
     int const width = background.width();
     int const height = background.height();
-    double const stroke_width = sqrt(double(width * width + height * height)) / 500;
+    double const stroke_width = sqrt(double(width * width + height * height)) / 500.0;
 
     // Extend / trim bounds.
     QLineF bound1(m_bound1);
@@ -603,7 +604,7 @@ DistortionModelBuilder::visualizeTrimmedPolylines(
     painter.setPen(Qt::NoPen);
     BOOST_FOREACH(TracedCurve const& curve, curves)
     {
-        QRectF rect(0, 0, stroke_width, stroke_width);
+        QRectF rect(0.0, 0.0, stroke_width, stroke_width);
         BOOST_FOREACH(QPointF const& knot, curve.trimmedPolyline)
         {
             rect.moveCenter(knot);
@@ -626,7 +627,7 @@ DistortionModelBuilder::visualizeModel(
 
     int const width = background.width();
     int const height = background.height();
-    double const stroke_width = sqrt(double(width * width + height * height)) / 500;
+    double const stroke_width = sqrt(double(width * width + height * height)) / 500.0;
 
     // Extend / trim bounds.
     QLineF bound1(m_bound1);