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; } }
 
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:
  // 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:
 
  NonLinearTransformation (const String & fileName)
    : NonLinearTransformation(HandleGuard<NonLinearTransformation>(LoadInternal(fileName)), PrivateTag{})
  { }
 
 
  NonLinearTransformation (NonLinearTransformation&&) noexcept = default;
 
  NonLinearTransformation& operator=(NonLinearTransformation&&) noexcept = default;
 
public:
 
  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;
 
    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::Interpolation;
using Transform2D::Axis;
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::CalibrationPatternStyle;
using Transform2D::CalibrationPatternFormat;
using Transform2D::CalibrationPatternOrientation;
 
using Transform2D::CreateCalibrationPattern;
using Transform2D::CreatePrintableCalibrationPattern;
using Transform2D::ExtractCalibrationLists;
 
using Transform2D::NonLinearTransformation;
using Transform2D::NonLinearTransformationPtr;
 
} /* namespace Foundation */
CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif