undistortion.hpp

#pragma once
 
#include "_cexports/c_core_2d.h"
#include "_cexports/c_img.h"
#include "global.hpp"
#include "image.hpp"
#include "point_2d.hpp"
#include "size_2d.hpp"
#include "core_2d.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  class UndistPointFilter;
 
  template <>
  inline HandleGuard<UndistPointFilter>::HandleGuard(void *handle) noexcept
      : HandleGuard<UndistPointFilter>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  class UndistImageFilter;
 
  template <>
  inline HandleGuard<UndistImageFilter>::HandleGuard(void *handle) noexcept
      : HandleGuard<UndistImageFilter>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }

  class UndistPointFilter final
  {
  public:

    static std::unique_ptr<UndistPointFilter> Create(const Cvb::String &calibrationData)
    {
      const std::string ascii_data = Cvb::Internal::CastToAscii(calibrationData);
      return Internal::DoResCallObjectOut<UndistPointFilter>(
          [&](void *&handle) { return CVB_CALL_CAPI(CVC2DCreateUndistortionPointFilter(ascii_data.c_str(), handle)); });
    }
 
    static std::unique_ptr<UndistPointFilter> FromHandle(HandleGuard<UndistPointFilter> &&guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      return std::make_unique<UndistPointFilter>(std::move(guard));
    }
 
    explicit UndistPointFilter(HandleGuard<UndistPointFilter> &&guard) noexcept
        : handle_(std::move(guard))
    {
    }
 
    UndistPointFilter(const UndistPointFilter &other)            = delete;
    UndistPointFilter &operator=(const UndistPointFilter &other) = delete;
    UndistPointFilter(UndistPointFilter &&other)                 = delete;
    UndistPointFilter &operator=(UndistPointFilter &&other)      = delete;
 
    ~UndistPointFilter() = default;
 
    void *Handle() const noexcept
    {
      return handle_.Handle();
    }


    std::vector<Point2D<double>> Undistort(const std::vector<Point2D<double>> &distortedPoints)
    {
      // Convert Point2D to CVIPointD
      std::vector<Cvb::CExports::CVIPointD> distorted_points_CVI;
      for (const auto &c : distortedPoints)
      {
        Cvb::CExports::CVIPointD pt;
        pt.X = c.X();
        pt.Y = c.Y();
        distorted_points_CVI.push_back(pt);
      }
 
      const int N = static_cast<int>(distortedPoints.size());
      std::vector<Cvb::CExports::CVIPointD> undistorted_points_CVI(N);
      CVB_CALL_CAPI_CHECKED(
          CVC2DUndistortionPointFilterRun(Handle(), distorted_points_CVI.data(), N, undistorted_points_CVI.data()));
 
      // Convert CVIPointD to Point2D
      std::vector<Point2D<double>> undistorted_points;
      for (const auto &c : undistorted_points_CVI)
        undistorted_points.push_back(Point2D<double>(c.X, c.Y));
 
      return undistorted_points;
    }
 
  private:
    HandleGuard<UndistPointFilter> handle_;
  };

  class UndistImageFilter final
  {
  public:

    static std::unique_ptr<UndistImageFilter>
    Create(const Cvb::String &calibrationData, const Size2D<int> &imageSize, bool crop,
           UndistInterpolationMode interpolationMode = UndistInterpolationMode::Bilinear)
    {
      Cvb::CExports::cvbdim_t outwidth, outheight;
      const std::string ascii_data = Cvb::Internal::CastToAscii(calibrationData);
 
      auto res = Internal::DoResCallObjectOut<UndistImageFilter>([&](void *&handle) {
        return CVB_CALL_CAPI(CVC2DCreateUndistortionFilter(
            ascii_data.c_str(), imageSize.Width(), imageSize.Height(), crop,
            static_cast<Cvb::CExports::CVC2DInterpolationMode>(interpolationMode), handle, outwidth, outheight));
      });
 
      res->outSize_ = Size2D<int>(outwidth, outheight);
 
      return res;
    }
 
    static std::unique_ptr<UndistImageFilter> FromHandle(HandleGuard<UndistImageFilter> &&guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      return std::make_unique<UndistImageFilter>(std::move(guard));
    }
 
    explicit UndistImageFilter(HandleGuard<UndistImageFilter> &&guard) noexcept
        : handle_(std::move(guard))
    {
    }
 
    UndistImageFilter(const UndistImageFilter &other)            = delete;
    UndistImageFilter &operator=(const UndistImageFilter &other) = delete;
    UndistImageFilter(UndistImageFilter &&other)                 = delete;
    UndistImageFilter &operator=(UndistImageFilter &&other)      = delete;
 
    ~UndistImageFilter() = default;
 
    void *Handle() const noexcept
    {
      return handle_.Handle();
    }


    const Size2D<int> &OutSize() const
    {
      return outSize_;
    }


    std::unique_ptr<Image> Undistort(const Image &image) const
    {
      if (!image.PlaneDataTypesIdentical())
        throw std::runtime_error("plane data types must be identical");
 
      auto imageOut =
          Image::Create(outSize_.Width(), outSize_.Height(), image.PlanesCount(), image.Plane(0).DataType());
      Undistort(image, *imageOut);
      return imageOut;
    }


    void Undistort(const Image &imageIn, Image &imageOut) const
    {
      auto outHandle = imageOut.Handle();
      CVB_CALL_CAPI_CHECKED(CVC2DUndistortionFilterRun(
          Handle(), static_cast<Cvb::CExports::CVC2DUndistThreads>(Cvb::CExports::CVC2DUndistThreadsSingle),
          imageIn.Handle(), outHandle));
    }
 
  private:
    HandleGuard<UndistImageFilter> handle_;
    Size2D<int> outSize_;
  };
 
  CVB_END_INLINE_NS
}  // namespace Cvb