1.2024.11.17: fix #47: dewarping: 3 slider for correct model

Author: zvezdochiot

src/acceleration/opencl/tests/TestDewarp.cpp

@@ -82,7 +82,9 @@ BOOST_AUTO_TEST_CASE(test_argb)
     CylindricalSurfaceDewarper const distortion_model(
         std::vector<QPointF> {QPointF(200, -50), QPointF(1050, 200)},
         std::vector<QPointF> {QPointF(-50, 800), QPointF(800, 1050)},
-        1.5, 1.5
+        1.5,
+        1.5,
+        1.5
     );
 
 #if LOG_PERFORMANCE

src/dewarping/CylindricalSurfaceDewarper.cpp

@@ -16,23 +16,24 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "CylindricalSurfaceDewarper.h"
-#include "ToLineProjector.h"
-#include "NumericTraits.h"
-#include "ToVec.h"
-#include "ToPoint.h"
-#include "../foundation/MultipleTargetsSupport.h"
+#include <cmath>
+#include <cassert>
+#include <stdexcept>
+#include <string>
+#include <boost/foreach.hpp>
 #include <Eigen/Core>
 #include <Eigen/QR>
 #include <QLineF>
 #include <QtGlobal>
 #include <QDebug>
 #include <boost/foreach.hpp>
 #include <algorithm>
-#include <cmath>
-#include <cassert>
-#include <stdexcept>
-#include <string>
+#include "CylindricalSurfaceDewarper.h"
+#include "ToLineProjector.h"
+#include "NumericTraits.h"
+#include "ToVec.h"
+#include "ToPoint.h"
+#include "../foundation/MultipleTargetsSupport.h"
 
 /*
 Naming conventions:
@@ -95,11 +96,13 @@ CylindricalSurfaceDewarper::CylindricalSurfaceDewarper(
     std::vector<QPointF> const& img_directrix1,
     std::vector<QPointF> const& img_directrix2,
     double depth_perception,
-    double curve_correct)
+    double curve_correct,
+    double curve_angle)
     :   m_pln2img(calcPlnToImgHomography(img_directrix1, img_directrix2)),
       m_img2pln(m_pln2img.inv()),
       m_depthPerception(depth_perception),
       m_curveCorrect(curve_correct),
+      m_curveAngle(curve_angle),
       m_plnStraightLineY(
           calcPlnStraightLineY(img_directrix1, img_directrix2, m_pln2img, m_img2pln)
       ),
@@ -115,6 +118,10 @@ 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_y2 = -lin_y1;
+    double const lin_y = lin_y1 + (lin_y2 - lin_y1) * pln_x;
+
     Vector2d const pln_top_pt(pln_x, 0);
     Vector2d const pln_bottom_pt(pln_x, 1);
     QPointF const img_top_pt(toPoint(m_pln2img(pln_top_pt)));
@@ -135,7 +142,7 @@ CylindricalSurfaceDewarper::mapGeneratrix(double crv_x, State& state) const
     double const img_directrix12fd_proj = img_directrix12f_proj - pln_straight_line_y;
     //double const curve_coef = 1.0 + 0.5 * (m_curveCorrect - 2.0);
     double const curve_coef = (m_curveCorrect < 2.0) ? (1.0 / (3.0 - m_curveCorrect)) : (m_curveCorrect - 1.0);
-    double const img_directrix12fds_proj = img_directrix12fd_proj * curve_coef;
+    double const img_directrix12fds_proj = img_directrix12fd_proj * curve_coef + lin_y;
     double const img_directrix12fs_proj = img_directrix12fds_proj + pln_straight_line_y;
     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));
@@ -163,6 +170,10 @@ 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_y2 = -lin_y1;
+    double const lin_y = lin_y1 + (lin_y2 - lin_y1) * pln_x;
+
     Vector2d const pln_top_pt(pln_x, 0);
     Vector2d const pln_bottom_pt(pln_x, 1);
     QPointF const img_top_pt(toPoint(m_pln2img(pln_top_pt)));
@@ -183,7 +194,7 @@ CylindricalSurfaceDewarper::mapToDewarpedSpace(QPointF const& img_pt, State& sta
     double const img_directrix12fd_proj = img_directrix12f_proj - pln_straight_line_y;
     //double const curve_coef = 1.0 + 0.5 * (m_curveCorrect - 2.0);
     double const curve_coef = (m_curveCorrect < 2.0) ? (1.0 / (3.0 - m_curveCorrect)) : (m_curveCorrect - 1.0);
-    double const img_directrix12fds_proj = img_directrix12fd_proj * curve_coef;
+    double const img_directrix12fds_proj = img_directrix12fd_proj * curve_coef + lin_y;
     double const img_directrix12fs_proj = img_directrix12fds_proj + pln_straight_line_y;
     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));
@@ -384,7 +395,7 @@ CylindricalSurfaceDewarper::CoupledPolylinesIterator::CoupledPolylinesIterator(
     std::vector<QPointF> const& img_directrix2,
     HomographicTransform<2, double> const& pln2img,
     HomographicTransform<2, double> const& img2pln)
-    :   m_seq1It(img_directrix1.begin()),
+    : m_seq1It(img_directrix1.begin()),
       m_seq2It(img_directrix2.begin()),
       m_seq1End(img_directrix1.end()),
       m_seq2End(img_directrix2.end()),

src/dewarping/CylindricalSurfaceDewarper.h

@@ -70,7 +70,8 @@ class DEWARPING_EXPORT CylindricalSurfaceDewarper
         std::vector<QPointF> const& img_directrix1,
         std::vector<QPointF> const& img_directrix2,
         double depth_perception,
-        double curve_correct);
+        double curve_correct,
+        double curve_angle);
 
     /**
      * \brief Returns the arc length of a directrix, assuming its
@@ -131,6 +132,7 @@ class DEWARPING_EXPORT CylindricalSurfaceDewarper
     HomographicTransform<2, double> m_img2pln;
     double m_depthPerception;
     double m_curveCorrect;
+    double m_curveAngle;
     double m_plnStraightLineY;
     double m_directrixArcLength;
     ArcLengthMapper m_arcLengthMapper;

src/dewarping/DewarpingImageTransform.cpp

@@ -16,13 +16,16 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "DewarpingImageTransform.h"
-#include "RoundingHasher.h"
-#include "ToVec.h"
-#include "ToLineProjector.h"
-#include "LineBoundedByPolygon.h"
-#include "imageproc/AffineImageTransform.h"
-#include "imageproc/AffineTransformedImage.h"
+#include <algorithm>
+#include <iterator>
+#include <utility>
+#include <memory>
+#include <limits>
+#include <cmath>
+#include <cassert>
+#include <map>
+#include <boost/optional.hpp>
+#include <boost/range/adaptor/reversed.hpp>
 #include <Eigen/Core>
 #include <Eigen/LU>
 #include <QImage>
@@ -36,16 +39,13 @@
 #include <QTransform>
 #include <QColor>
 #include <QString>
-#include <boost/optional.hpp>
-#include <boost/range/adaptor/reversed.hpp>
-#include <algorithm>
-#include <iterator>
-#include <utility>
-#include <memory>
-#include <limits>
-#include <cmath>
-#include <cassert>
-#include <map>
+#include "DewarpingImageTransform.h"
+#include "RoundingHasher.h"
+#include "ToVec.h"
+#include "ToLineProjector.h"
+#include "LineBoundedByPolygon.h"
+#include "imageproc/AffineImageTransform.h"
+#include "imageproc/AffineTransformedImage.h"
 
 using namespace Eigen;
 using namespace imageproc;
@@ -116,17 +116,19 @@ DewarpingImageTransform::DewarpingImageTransform(
     std::vector<QPointF> const& top_curve,
     std::vector<QPointF> const& bottom_curve,
     DepthPerception const& depth_perception,
-    DepthPerception const& curve_correct)
-    :   m_origSize(orig_size)
-    ,   m_topPolyline(top_curve)
-    ,   m_bottomPolyline(bottom_curve)
-    ,   m_depthPerception(depth_perception)
-    ,   m_curveCorrect(curve_correct)
-    ,   m_dewarper(top_curve, bottom_curve, depth_perception.value(), curve_correct.value())
-    ,   m_intrinsicScaleX(1.0)
-    ,   m_intrinsicScaleY(1.0)
-    ,   m_userScaleX(1.0)
-    ,   m_userScaleY(1.0)
+    DepthPerception const& curve_correct,
+    DepthPerception const& curve_angle)
+    : m_origSize(orig_size)
+    , m_topPolyline(top_curve)
+    , m_bottomPolyline(bottom_curve)
+    , 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_intrinsicScaleX(1.0)
+    , m_intrinsicScaleY(1.0)
+    , m_userScaleX(1.0)
+    , m_userScaleY(1.0)
 {
     // These two lines don't depend on each other and therefore can go in any order.
     m_origCropArea = constrainCropArea(orig_crop_area);

src/dewarping/DewarpingImageTransform.h

@@ -59,7 +59,8 @@ class DEWARPING_EXPORT DewarpingImageTransform : public imageproc::AbstractImage
         std::vector<QPointF> const& top_curve,
         std::vector<QPointF> const& bottom_curve,
         DepthPerception const& depth_perception,
-        DepthPerception const& curve_correct);
+        DepthPerception const& curve_correct,
+        DepthPerception const& curve_angle);
 
     virtual ~DewarpingImageTransform();
 
@@ -118,6 +119,7 @@ class DEWARPING_EXPORT DewarpingImageTransform : public imageproc::AbstractImage
     std::vector<QPointF> m_bottomPolyline;
     DepthPerception m_depthPerception;
     DepthPerception m_curveCorrect;
+    DepthPerception m_curveAngle;
     CylindricalSurfaceDewarper m_dewarper;
 
     /**

src/dewarping/DistortionModel.cpp

@@ -35,8 +35,8 @@ DistortionModel::DistortionModel()
 }
 
 DistortionModel::DistortionModel(QDomElement const& el)
-    :	m_topCurve(el.namedItem("top-curve").toElement()),
-      m_bottomCurve(el.namedItem("bottom-curve").toElement())
+    : m_topCurve(el.namedItem("top-curve").toElement())
+    , m_bottomCurve(el.namedItem("bottom-curve").toElement())
 {
 }
 

src/dewarping/DistortionModelBuilder.cpp

@@ -16,6 +16,21 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm>
+#include <exception>
+#include <iterator>
+#include <limits>
+#include <cmath>
+#include <cassert>
+#include <boost/foreach.hpp>
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/random/uniform_int_distribution.hpp>
+#include <QTransform>
+#include <QImage>
+#include <QPainter>
+#include <QPen>
+#include <QColor>
+#include <QDebug>
 #include "DistortionModelBuilder.h"
 #include "DistortionModel.h"
 #include "CylindricalSurfaceDewarper.h"
@@ -27,21 +42,6 @@
 #include "VecNT.h"
 #include "ToVec.h"
 #include "../foundation/MultipleTargetsSupport.h"
-#include <QTransform>
-#include <QImage>
-#include <QPainter>
-#include <QPen>
-#include <QColor>
-#include <QDebug>
-#include <boost/foreach.hpp>
-#include <boost/random/mersenne_twister.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-#include <algorithm>
-#include <exception>
-#include <iterator>
-#include <limits>
-#include <cmath>
-#include <cassert>
 
 using namespace imageproc;
 
@@ -55,8 +55,10 @@ struct DistortionModelBuilder::TracedCurve
     XSpline extendedSpline;
     double order; // Lesser values correspond to upper curves.
 
-    TracedCurve(std::vector<QPointF> const& trimmed_polyline,
-                XSpline const& extended_spline, double ord)
+    TracedCurve(
+        std::vector<QPointF> const& trimmed_polyline,
+        XSpline const& extended_spline,
+        double ord)
         : trimmedPolyline(trimmed_polyline),
           extendedPolyline(extended_spline.toPolyline()),
           extendedSpline(extended_spline), order(ord) {}
@@ -116,7 +118,7 @@ class DistortionModelBuilder::BadCurve : public std::exception
 
 
 DistortionModelBuilder::DistortionModelBuilder(Vec2d const& down_direction)
-    :   m_downDirection(down_direction),
+    : m_downDirection(down_direction),
       m_rightDirection(down_direction[1], -down_direction[0])
 {
     assert(down_direction.squaredNorm() > 0);
@@ -212,11 +214,10 @@ DistortionModelBuilder::tryBuildModel(DebugImages* dbg, QImage const* dbg_backgr
 
     ransac.buildAndAssessModel(&ordered_curves.front(), &ordered_curves.back());
 
-/*
     // (Tulon)
     // First let's try to combine each of the 5 top-most lines
     // with each of the 3 bottom-most ones.
-    int const exhaustive_search_threshold = 5;
+    int const exhaustive_search_threshold = 16; // 5 <- 16 -- zvezdochiot
     for (int i = 0; i < std::min<int>(exhaustive_search_threshold, num_curves); ++i)
     {
         for (int j = std::max<int>(0, num_curves - exhaustive_search_threshold); j < num_curves; ++j)
@@ -247,8 +248,8 @@ DistortionModelBuilder::tryBuildModel(DebugImages* dbg, QImage const* dbg_backgr
             ransac.buildAndAssessModel(&ordered_curves[i], &ordered_curves[j]);
         }
     }
-*/
 
+/*
     // Full RANCAS (zvezdochiot)
     for (int i = 0; i < (num_curves - 1); i++)
     {
@@ -257,7 +258,7 @@ DistortionModelBuilder::tryBuildModel(DebugImages* dbg, QImage const* dbg_backgr
             ransac.buildAndAssessModel(&ordered_curves[i], &ordered_curves[j]);
         }
     }
-
+*/
     if (dbg && dbg_background)
     {
         dbg->add(visualizeTrimmedPolylines(*dbg_background, ordered_curves), "trimmed_polylines");
@@ -481,7 +482,11 @@ try
 
     double const depth_perception = 2.0; // Doesn't matter much here.
     CylindricalSurfaceDewarper const dewarper(
-        top_curve->extendedPolyline, bottom_curve->extendedPolyline, depth_perception, depth_perception
+        top_curve->extendedPolyline,
+        bottom_curve->extendedPolyline,
+        depth_perception,
+        depth_perception,
+        depth_perception
     );
 
     // CylindricalSurfaceDewarper maps the curved quadrilateral to a unit
@@ -611,7 +616,8 @@ DistortionModelBuilder::visualizeTrimmedPolylines(
 
 QImage
 DistortionModelBuilder::visualizeModel(
-    QImage const& background, std::vector<TracedCurve> const& curves,
+    QImage const& background,
+    std::vector<TracedCurve> const& curves,
     RansacModel const& model) const
 {
     QImage canvas(background.convertToFormat(QImage::Format_RGB32));

src/dewarping/DistortionModelBuilder.h

@@ -116,8 +116,10 @@ class DEWARPING_EXPORT DistortionModelBuilder
     QImage visualizeTrimmedPolylines(
         QImage const& background, std::vector<TracedCurve> const& curves) const;
 
-    QImage visualizeModel(QImage const& background,
-                          std::vector<TracedCurve> const& curves, RansacModel const& model) const;
+    QImage visualizeModel(
+        QImage const& background,
+        std::vector<TracedCurve> const& curves,
+        RansacModel const& model) const;
 
     Vec2d m_downDirection;
     Vec2d m_rightDirection;

src/stages/deskew/CacheDrivenTask.cpp

@@ -43,8 +43,8 @@ namespace deskew
 CacheDrivenTask::CacheDrivenTask(
     IntrusivePtr<Settings> const& settings,
     IntrusivePtr<select_content::CacheDrivenTask> const& next_task)
-    :   m_ptrNextTask(next_task),
-        m_ptrSettings(settings)
+    : m_ptrNextTask(next_task),
+      m_ptrSettings(settings)
 {
 }
 
@@ -117,6 +117,7 @@ CacheDrivenTask::process(
                                 image_transform.origCropArea(),
                                 top_curve, bottom_curve,
                                 dewarping::DepthPerception(),
+                                dewarping::DepthPerception(),
                                 dewarping::DepthPerception()
                             );
             break;
@@ -128,7 +129,8 @@ CacheDrivenTask::process(
                                 params->dewarpingParams().distortionModel().topCurve().polyline(),
                                 params->dewarpingParams().distortionModel().bottomCurve().polyline(),
                                 params->dewarpingParams().depthPerception(),
-                                params->dewarpingParams().depthPerception()
+                                params->dewarpingParams().correctCurves(),
+                                params->dewarpingParams().correctAngle()
                             );
             break;
         }