transform_2d.hpp

#pragma once
 
#if defined _WIN32
 
#  include "../_cexports/c_foundation.h"
 
#  include "../global.hpp"
#  include "../image.hpp"
#  include "../exception.hpp"
#  include "../size_2d.hpp"
#  include "../angle.hpp"
#  include "../matrix_2d.hpp"
#  include "../point_2d.hpp"
#  include "../rect.hpp"
#  include "../string.hpp"
#  include "../_detail/detail_pixel_list.hpp"
#  include "../area_2d.hpp"
#  include "../rect.hpp"
 
#  include <memory>
#  include <vector>
#  include <utility>
#  include <algorithm>
#  include <iterator>
#  include <functional>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {
    namespace Transform2D
    {
      class NonLinearTransformation;
    }
  }  // namespace Foundation
 
  template <>
  inline HandleGuard<Foundation::Transform2D::NonLinearTransformation>::HandleGuard(void *handle) noexcept
      : HandleGuard<Foundation::Transform2D::NonLinearTransformation>(handle,
                                                                      [](void *h) { CVB_CALL_CAPI(ReleaseObject(h)); })
  {
  }
 
  namespace Foundation
  {


    namespace Transform2D
    {

      enum class Interpolation
      {
        NearestNeighbor = CExports::IP_NearestNeighbour,
        Linear = CExports::IP_Linear,
        Cubic = CExports::IP_Cubic,
        Lanczos = CExports::IP_Lanczos,
        Supersample = CExports::IP_Supersample
      };

      enum class Axis
      {
        NoAxis = 0,
        X = 1,
        Y = 2,
        Both = 3
      };


      class PerspectiveTransformation
      {
      public:

        PerspectiveTransformation(Point2D<double> leftTop, Point2D<double> rightTop, Point2D<double> rightBottom,
                                  Point2D<double> leftBottom, Rect<int> destRect)
        {
          CVB_CALL_CAPI_CHECKED(CalcPerspectiveTransformation(
              destRect.Left(), destRect.Top(), destRect.Right(), destRect.Bottom(), leftTop.X(), leftTop.Y(),
              rightTop.X(), rightTop.Y(), rightBottom.X(), rightBottom.Y(), leftBottom.X(), leftBottom.Y(), c00_, c01_,
              c02_, c10_, c11_, c12_, c20_, c21_, c22_));
        }


        PerspectiveTransformation(Point2D<double> leftTop, Point2D<double> rightTop, Point2D<double> rightBottom,
                                  Point2D<double> leftBottom, Rect<double> destRect)
        {
          CVB_CALL_CAPI_CHECKED(CalcPerspectiveTransformationEx(
              destRect.Left(), destRect.Top(), destRect.Right(), destRect.Bottom(), leftTop.X(), leftTop.Y(),
              rightTop.X(), rightTop.Y(), rightBottom.X(), rightBottom.Y(), leftBottom.X(), leftBottom.Y(), c00_, c01_,
              c02_, c10_, c11_, c12_, c20_, c21_, c22_));
        }


        double C00() const noexcept
        {
          return c00_;
        }


        double C01() const noexcept
        {
          return c01_;
        }


        double C02() const noexcept
        {
          return c02_;
        }


        double C10() const noexcept
        {
          return c10_;
        }


        double C11() const noexcept
        {
          return c11_;
        }


        double C12() const noexcept
        {
          return c12_;
        }


        double C20() const noexcept
        {
          return c20_;
        }


        double C21() const noexcept
        {
          return c21_;
        }


        double C22() const noexcept
        {
          return c22_;
        }
 
      private:
        double c00_ = 0.0;
        double c01_ = 0.0;
        double c02_ = 0.0;
        double c10_ = 0.0;
        double c11_ = 0.0;
        double c12_ = 0.0;
        double c20_ = 0.0;
        double c21_ = 0.0;
        double c22_ = 0.0;
      };


      inline std::unique_ptr<Image> MatrixTransform(const Image &image, const Matrix2D &matrix,
                                                    Interpolation interpolation = Interpolation::Linear)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          /* Note: the binary compatibility between Matrix and TMatrix is guaranteed, therefore the cast below is legal.
           */
          return CVB_CALL_CAPI(MatrixTransformImage(image.Handle(), reinterpret_cast<const CExports::TMatrix &>(matrix),
                                                    static_cast<CExports::TInterpolationMode>(interpolation), resimg));
        });
      }


      inline std::unique_ptr<Image> Mirror(const Image &image, Axis axis)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(MirrorImage(image.Handle(), axis == Axis::X || axis == Axis::Both,
                                           axis == Axis::Y || axis == Axis::Both, resimg));
        });
      }


      inline std::unique_ptr<Image> Perspective(const Image &image, const PerspectiveTransformation &coeffs,
                                                Size2D<int> targetSize,
                                                Interpolation interpolation = Interpolation::Linear)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(PerspectiveTransformImage(
              image.Handle(), targetSize.Width(), targetSize.Height(), 0, 0, coeffs.C00(), coeffs.C01(), coeffs.C02(),
              coeffs.C10(), coeffs.C11(), coeffs.C12(), coeffs.C20(), coeffs.C21(), coeffs.C22(),
              static_cast<CExports::TInterpolationMode>(interpolation), resimg));
        });
      }


      inline std::unique_ptr<Image> Resize(const Image &image, Size2D<int> targetSize,
                                           Interpolation interpolation = Interpolation::Linear)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(ResizeImage(image.Handle(), targetSize.Width(), targetSize.Height(),
                                           static_cast<CExports::TInterpolationMode>(interpolation), resimg));
        });
      }


      inline std::unique_ptr<Image> Rotate(const Image &image, Angle angle,
                                           Interpolation interpolation = Interpolation::Linear)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(RotateImage(image.Handle(), angle.Deg(),
                                           static_cast<CExports::TInterpolationMode>(interpolation), resimg));
        });
      }


      inline std::unique_ptr<Image> Shear(const Image &image, double shearX, double shearY,
                                          Interpolation interpolation = Interpolation::Linear)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(ShearImage(image.Handle(), shearX, shearY,
                                          static_cast<CExports::TInterpolationMode>(interpolation), resimg));
        });
      }

      enum class CalibrationPatternContrast
      {
        BlackOnWhite = CExports::CPC_Black_On_White,
        WhiteOnBlack = CExports::CPC_White_On_Black
      };

      enum class CalibrationPatternStyle
      {
        UniformDots = CExports::CPS_Uniform_Dots,
        AsymmetricDots = CExports::CPS_Asymmetric_Dots
      };

      enum class CalibrationPatternFormat
      {
        A4,
        Letter
      };

      enum class CalibrationPatternOrientation
      {
        Portrait,
        Landscape
      };


      inline std::unique_ptr<Image> CreateCalibrationPattern(CalibrationPatternStyle style,
                                                             CalibrationPatternContrast contrast, int width, int height,
                                                             int numColumns, int numRows)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          return CVB_CALL_CAPI(CreateCalibrationPattern(
              width, height, numColumns, numRows, static_cast<CExports::TCalibrationPatternStyle>(style),
              static_cast<CExports::TCalibrationPatternContrast>(contrast), resimg));
        });
      }


      inline std::unique_ptr<Image>
      CreatePrintableCalibrationPattern(CalibrationPatternStyle style, CalibrationPatternContrast contrast,
                                        CalibrationPatternFormat paperSize, CalibrationPatternOrientation orientation,
                                        int numColumns, int numRows, double horizontalBorder, double verticalBorder,
                                        int dpi)
      {
        return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
          switch (paperSize)
          {
            case CalibrationPatternFormat::A4:
              return CVB_CALL_CAPI(
                  CreateCalibrationPatternA4(numColumns, numRows, horizontalBorder, verticalBorder, dpi,
                                             orientation == CalibrationPatternOrientation::Landscape,
                                             static_cast<CExports::TCalibrationPatternStyle>(style),
                                             static_cast<CExports::TCalibrationPatternContrast>(contrast), resimg));
            case CalibrationPatternFormat::Letter:
              return CVB_CALL_CAPI(
                  CreateCalibrationPatternLetter(numColumns, numRows, horizontalBorder, verticalBorder, dpi,
                                                 orientation == CalibrationPatternOrientation::Landscape,
                                                 static_cast<CExports::TCalibrationPatternStyle>(style),
                                                 static_cast<CExports::TCalibrationPatternContrast>(contrast), resimg));
            default:
              throw std::invalid_argument("unknown paper size format");
          }
        });
      }


      inline void ExtractCalibrationLists(const ImagePlane &plane, CalibrationPatternStyle style,
                                          CalibrationPatternContrast contrast, int gridSpacing, int minContrast,
                                          double maxRatio, Area2D aoi, std::vector<Point2D<double>> &originalPixels,
                                          std::vector<Point2D<double>> &transformedPixels)
      {
        CExports::PIXELLIST originalPixelList    = nullptr;
        CExports::PIXELLIST transformedPixelList = nullptr;
 
        CVB_CALL_CAPI_CHECKED(GetCalibrationLists(
            plane.Parent().Handle(), plane.Plane(), static_cast<CExports::TCalibrationPatternStyle>(style),
            static_cast<CExports::TCalibrationPatternContrast>(contrast), reinterpret_cast<CExports::TArea &>(aoi),
            gridSpacing, minContrast, maxRatio, originalPixelList, transformedPixelList));
        HandleGuard<Internal::PixelList> originalGuard(originalPixelList);
        HandleGuard<Internal::PixelList> transformedGuard(transformedPixelList);
 
        originalPixels    = Internal::PixelList::FromHandle(std::move(originalGuard))->ToPoints();
        transformedPixels = Internal::PixelList::FromHandle(std::move(transformedGuard))->ToPoints();
      }


      inline void ExtractCalibrationLists(const ImagePlane &plane, CalibrationPatternStyle style,
                                          CalibrationPatternContrast contrast, int gridSpacing, int minContrast,
                                          double maxRatio, std::vector<Point2D<double>> &originalPixels,
                                          std::vector<Point2D<double>> &transformedPixels)
      {
        ExtractCalibrationLists(plane, style, contrast, gridSpacing, minContrast, maxRatio,
                                Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())), originalPixels,
                                transformedPixels);
      }


      class NonLinearTransformation
      {
        struct PrivateTag
        {
        };
 
      public:
        ~NonLinearTransformation() = default;        
        NonLinearTransformation(const NonLinearTransformation &)            = delete;
        NonLinearTransformation &operator=(const NonLinearTransformation &) = delete;
 
 
        // Internal helper constructor version
        NonLinearTransformation(HandleGuard<NonLinearTransformation> &&guard, PrivateTag)
            : handle_(std::move(guard))
            , coefficientsTransX_()
            , coefficientsTransY_()
            , coefficientsInvTransX_()
            , coefficientsInvTransY_()
        {
          // retrieve the transformations' coefficients
          auto numCoefficients = CVB_CALL_CAPI(NLTransformNumCoefficients(handle_.Handle()));
          if (numCoefficients < 0)
          {
            Utilities::SystemInfo::ThrowLastError();
          }
 
          coefficientsTransX_.resize(numCoefficients);
          coefficientsTransY_.resize(numCoefficients);
          coefficientsInvTransX_.resize(numCoefficients);
          coefficientsInvTransY_.resize(numCoefficients);
 
          CVB_CALL_CAPI_CHECKED(NLTransformCoefficients(handle_.Handle(), coefficientsTransX_.data(),
                                                        coefficientsTransY_.data(), coefficientsInvTransX_.data(),
                                                        coefficientsInvTransY_.data()));
        }
 
      private:
        // Helper to load a saved transformation from file
        static CExports::NLTRANSFORMATION LoadInternal(const String &fileName)
        {
          CExports::NLTRANSFORMATION transformation = nullptr;
 
          CVB_CALL_CAPI_CHECKED(LoadNLTransformFileTyped(fileName.c_str(), transformation));
          return transformation;
        }
 
      public:

        explicit NonLinearTransformation(const String &fileName)
            : NonLinearTransformation(HandleGuard<NonLinearTransformation>(LoadInternal(fileName)), PrivateTag{})
        {
        }

        NonLinearTransformation(NonLinearTransformation &&) noexcept = default;

        NonLinearTransformation &operator=(NonLinearTransformation &&) noexcept = default;


        static std::unique_ptr<NonLinearTransformation> Load(const String &fileName)
        {
          return std::make_unique<NonLinearTransformation>(fileName);
        }


        void *Handle() const noexcept
        {
          return handle_.Handle();
        }


        static std::unique_ptr<NonLinearTransformation> FromHandle(HandleGuard<NonLinearTransformation> &&guard)
        {
          if (!guard.Handle())
          {
            throw std::invalid_argument("invalid non-linear transformation native handle");
          }
          return std::make_unique<NonLinearTransformation>(std::move(guard), PrivateTag{});
        }
 
        typedef std::function<bool(int stepsTotal, int stepsDone)> CreationProgress;


        template <class RANGE>
        static typename TypedRange<std::unique_ptr<NonLinearTransformation>, Point2D<double>, RANGE>::type
        FromPositionLists(const RANGE &originalPixels, const RANGE &transformedPixels, int order,
                          CreationProgress progressCallback = CreationProgress())
        {
          auto originalPixelList    = Internal::PixelList::FromPoints(originalPixels);
          auto transformedPixelList = Internal::PixelList::FromPoints(transformedPixels);
          double quality = 0;
 
          return Internal::DoResCallObjectOut<NonLinearTransformation>([&](void *&restrans) {
            return CVB_CALL_CAPI(CreateNLTransform(originalPixelList->Handle(), transformedPixelList->Handle(), order,
                                                   progressCallback ? CreationProgressCaller : nullptr,
                                                   &progressCallback, restrans, quality));
          });
        }


        static std::unique_ptr<NonLinearTransformation>
        FromCalibrationPattern(const ImagePlane &plane, CalibrationPatternStyle style,
                               CalibrationPatternContrast contrast, int gridSpacing, int minContrast, double maxRatio,
                               int order, Area2D aoi, CreationProgress progressCallback = CreationProgress())
        {
          std::vector<Point2D<double>> original, transformed;
          ExtractCalibrationLists(plane, style, contrast, gridSpacing, minContrast, maxRatio, aoi, original,
                                  transformed);
 
          return FromPositionLists(original, transformed, order, progressCallback);
        }


        static std::unique_ptr<NonLinearTransformation>
        FromCalibrationPattern(const ImagePlane &plane, CalibrationPatternStyle style,
                               CalibrationPatternContrast contrast, int gridSpacing, int minContrast, double maxRatio,
                               int order, CreationProgress progressCallback = CreationProgress())
        {
          return FromCalibrationPattern(plane, style, contrast, gridSpacing, minContrast, maxRatio, order,
                                        Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())), progressCallback);
        }


        int Order() const noexcept
        {
          return CVB_CALL_CAPI(NLTransformOrder(handle_.Handle()));
        }


        std::vector<double> CoefficientsX() const
        {
          return coefficientsTransX_;
        }


        std::vector<double> CoefficientsY() const
        {
          return coefficientsTransY_;
        }


        std::vector<double> CoefficientsXInverse() const
        {
          return coefficientsInvTransX_;
        }


        std::vector<double> CoefficientsYInverse() const
        {
          return coefficientsInvTransY_;
        }


        void Save(const String &fileName) const
        {
          CVB_CALL_CAPI_CHECKED(WriteNLTransformFileTyped(handle_.Handle(), fileName.c_str()));
        }


        std::unique_ptr<Image> Transform(const Image &image, Size2D<int> targetSize, Point2D<int> targetOffset)
        {
          return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
            return CVB_CALL_CAPI(CreateNLTransformedImage(image.Handle(), handle_.Handle(), targetSize.Width(),
                                                          targetSize.Height(), targetOffset.X(), targetOffset.Y(),
                                                          resimg));
          });
        }


        Point2D<double> Transform(Point2D<double> point)
        {
          double x = point.X(), y = point.Y();
          CVB_CALL_CAPI_CHECKED(ApplyNLTransform(handle_.Handle(), x, y));
          return Point2D<double>(x, y);
        }


        Rect<double> Transform(Rect<double> rect)
        {
          auto topLeft     = Transform(Point2D<double>(rect.Left(), rect.Top()));
          auto topRight    = Transform(Point2D<double>(rect.Right(), rect.Top()));
          auto bottomLeft  = Transform(Point2D<double>(rect.Left(), rect.Bottom()));
          auto bottomRight = Transform(Point2D<double>(rect.Right(), rect.Bottom()));
 
          return Rect<double>(std::min(topLeft.X(), std::min(topRight.X(), std::min(bottomLeft.X(), bottomRight.X()))),
                              std::min(topLeft.Y(), std::min(topRight.Y(), std::min(bottomLeft.Y(), bottomRight.Y()))),
                              std::max(topLeft.X(), std::max(topRight.X(), std::max(bottomLeft.X(), bottomRight.X()))),
                              std::max(topLeft.Y(), std::max(topRight.Y(), std::max(bottomLeft.Y(), bottomRight.Y()))));
        }


        template <class RANGE>
        typename TypedRange<std::vector<Point2D<double>>, Point2D<double>, RANGE>::type Transform(const RANGE &points)
        {
          std::vector<Point2D<double>> results;
          std::transform(std::begin(points), std::end(points), std::back_inserter(results),
                         [this](Point2D<double> p) { return Transform(p); });
 
          return results;
        }


        std::unique_ptr<Image> InverseTransform(const Image &image, Size2D<int> targetSize, Point2D<int> targetOffset)
        {
          return Internal::DoResCallObjectOut<Image>([&](void *&resimg) {
            return CVB_CALL_CAPI(CreateInverseNLTransformedImage(image.Handle(), handle_.Handle(), targetSize.Width(),
                                                                 targetSize.Height(), targetOffset.X(),
                                                                 targetOffset.Y(), resimg));
          });
        }


        Point2D<double> InverseTransform(Point2D<double> point)
        {
          double x = point.X(), y = point.Y();
          CVB_CALL_CAPI_CHECKED(ApplyInverseNLTransform(handle_.Handle(), x, y));
          return Point2D<double>(x, y);
        }


        template <class RANGE>
        typename TypedRange<std::vector<Point2D<double>>, Point2D<double>, RANGE>::type
        InverseTransform(const RANGE &points)
        {
          std::vector<Point2D<double>> results;
          std::transform(std::begin(points), std::end(points), std::back_inserter(results),
                         [this](Point2D<double> p) { return InverseTransform(p); });
 
          return results;
        }
 
      private:
        static CExports::cvbbool_t __stdcall CreationProgressCaller(void *pPrivate, CExports::cvbval_t stepsTotal,
                                                                    CExports::cvbval_t stepsDone)
        {
          CreationProgress *cbk = reinterpret_cast<CreationProgress *>(pPrivate);
          return (*cbk)(static_cast<int>(stepsTotal), static_cast<int>(stepsDone));
        }
 
      private:
        HandleGuard<NonLinearTransformation> handle_;
        std::vector<double> coefficientsTransX_;
        std::vector<double> coefficientsTransY_;
        std::vector<double> coefficientsInvTransX_;
        std::vector<double> coefficientsInvTransY_;
      }; /* class NonLinearTransformation */

      typedef std::shared_ptr<NonLinearTransformation> NonLinearTransformationPtr;
 
    } /* namespace Transform2D */
 
    using Transform2D::Axis;
    using Transform2D::Interpolation;
    using Transform2D::PerspectiveTransformation;
 
    using Transform2D::MatrixTransform;
    using Transform2D::Mirror;
    using Transform2D::Perspective;
    using Transform2D::Resize;
    using Transform2D::Rotate;
    using Transform2D::Shear;
 
    using Transform2D::CalibrationPatternContrast;
    using Transform2D::CalibrationPatternFormat;
    using Transform2D::CalibrationPatternOrientation;
    using Transform2D::CalibrationPatternStyle;
 
    using Transform2D::CreateCalibrationPattern;
    using Transform2D::CreatePrintableCalibrationPattern;
    using Transform2D::ExtractCalibrationLists;
 
    using Transform2D::NonLinearTransformation;
    using Transform2D::NonLinearTransformationPtr;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif