calibration_line_scan.hpp

#pragma once
 
#if defined _WIN32
 
#  include "../_cexports/c_foundation.h"
#  include "cvb/foundation/transform_2d.hpp"
#  include "cvb/image_plane.hpp"
#  include "cvb/point_2d.hpp"
#  include "cvb/value_range.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {

    namespace CalibrationLineScan
    {

      enum class ScanDirection
      {

        X = CExports::CVFScanDirection::CVFSD_X,

        Y = CExports::CVFScanDirection::CVFSD_Y
      };

      enum class PreDefinedPixelSizeMode
      {
        DoNotUse,
        Use
      };


      class LineScanCalibrationConfiguration final
      {
      public:
        LineScanCalibrationConfiguration() noexcept
            : maxIterations_(50)
            , polyDegree_(3)
            , tolerance_(1e-6)
            , scanDirection_(ScanDirection::Y)
            , preDefinedPixelSizeMode_(PreDefinedPixelSizeMode::DoNotUse)
            , pixelSize_(1)
        {
        }


        LineScanCalibrationConfiguration(std::uint32_t maxIterations, std::uint32_t polyDegree, double tolerance,
                                         ScanDirection scanDirection, PreDefinedPixelSizeMode preDefinedPixelSizeMode,
                                         double pixelSize) noexcept
            : maxIterations_(maxIterations)
            , polyDegree_(polyDegree)
            , tolerance_(tolerance)
            , scanDirection_(scanDirection)
            , preDefinedPixelSizeMode_(preDefinedPixelSizeMode)
            , pixelSize_(pixelSize)
        {
        }
 
        ~LineScanCalibrationConfiguration() noexcept                                                   = default;
        LineScanCalibrationConfiguration(const LineScanCalibrationConfiguration &) noexcept            = default;
        LineScanCalibrationConfiguration(LineScanCalibrationConfiguration &&) noexcept                 = default;
        LineScanCalibrationConfiguration &operator=(const LineScanCalibrationConfiguration &) noexcept = default;
        LineScanCalibrationConfiguration &operator=(LineScanCalibrationConfiguration &&) noexcept      = default;


        std::uint32_t MaxIterations() const noexcept
        {
          return maxIterations_;
        }


        void SetMaxIterations(std::uint32_t maxIterations) noexcept
        {
          maxIterations_ = maxIterations;
        }


        std::uint32_t PolyDegree() const noexcept
        {
          return polyDegree_;
        }


        void SetPolyDegree(std::uint32_t polyDegree) noexcept
        {
          polyDegree_ = polyDegree;
        }


        double Tolerance() const noexcept
        {
          return tolerance_;
        }


        void SetTolerance(double tolerance) noexcept
        {
          tolerance_ = tolerance;
        }


        ScanDirection ScanDirection() const noexcept
        {
          return scanDirection_;
        }


        void SetScanDirection(Foundation::CalibrationLineScan::ScanDirection scanDirection) noexcept
        {
          scanDirection_ = scanDirection;
        }


        PreDefinedPixelSizeMode PreDefinedPixelSizeMode() const noexcept
        {
          return preDefinedPixelSizeMode_;
        }


        void SetPreDefinedPixelSizeMode(
            Foundation::CalibrationLineScan::PreDefinedPixelSizeMode preDefinedPixelSize) noexcept
        {
          preDefinedPixelSizeMode_ = preDefinedPixelSize;
        }


        double PixelSize() const noexcept
        {
          return pixelSize_;
        }


        void SetPixelSize(double pixelSize) noexcept
        {
          pixelSize_ = pixelSize;
        }
 
      private:
        std::uint32_t maxIterations_;
        std::uint32_t polyDegree_;
        double tolerance_;
        Foundation::CalibrationLineScan::ScanDirection scanDirection_;
        Foundation::CalibrationLineScan::PreDefinedPixelSizeMode preDefinedPixelSizeMode_;
        double pixelSize_;
      };


      inline std::pair<Point2D<double>, Point2D<double>> CalculateTwoPointsForCalibrationOfMovement(
          const ImagePlane &imagePlane, const Area2D &aoi, Foundation::Transform2D::CalibrationPatternContrast contrast,
          int minContrast, const ValueRange<double> &pointSizeRange, const ScanDirection &scanDirection)
      {
        std::pair<Point2D<double>, Point2D<double>> points;
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(CVFGet2PointsForCalibrationOfMovement(
            imagePlane.Parent().Handle(), static_cast<CExports::cvbdim_t>(imagePlane.Plane()), reinterpret_cast<const CExports::TArea&>(aoi),
            static_cast<CExports::TCalibrationPatternContrast>(contrast), minContrast,
            pointSizeRange.Min(), pointSizeRange.Max(), static_cast<CExports::CVFScanDirection>(scanDirection),
            reinterpret_cast<CExports::CVIPointD&>(points.first),
            reinterpret_cast<CExports::CVIPointD&>(points.second));
            }));
        return points;
      }
 
      class LineScanCalibrator;
      using LineScanCalibratorPtr = std::shared_ptr<LineScanCalibrator>;


      class EdgeDetectionResult final
      {
        friend std::unique_ptr<LineScanCalibrator>
        CreateLineScanCalibration(const Point2D<double> &calibrationPoint1, const Point2D<double> &calibrationPoint2,
                                  double referenceDistanceCalibrationPoints,
                                  const EdgeDetectionResult &edgeDetectionResult, double referenceWidthStripes,
                                  const LineScanCalibrationConfiguration &configuration);
 
      public:
        EdgeDetectionResult()
            : EdgeDetectionResult(std::vector<int>(), std::vector<double>(), 0, 0)
        {
        }
 
        EdgeDetectionResult(std::vector<int> &&scanLineIndices, std::vector<double> &&edgeIndices, int numProfiles,
                            int numEdgesPerProfile)
            : scanLineIndices_(std::move(scanLineIndices))
            , edgeIndices_(std::move(edgeIndices))
            , numProfiles_(numProfiles)
            , numEdgesPerProfile_(numEdgesPerProfile)
        {
        }


        std::vector<int> ScanLineIndices() const
        {
          return scanLineIndices_;
        }


        std::vector<double> EdgeIndices() const
        {
          return edgeIndices_;
        }


        int NumProfiles() const noexcept
        {
          return numProfiles_;
        }


        int NumEdgesPerProfile() const noexcept
        {
          return numEdgesPerProfile_;
        }
 
      private:
        std::vector<int> scanLineIndices_;
        std::vector<double> edgeIndices_;
        int numProfiles_;
        int numEdgesPerProfile_;
      };


      inline EdgeDetectionResult DetectEdgesOfStripeTarget(const Image &imageStripes, const Rect<int> &aoi,
                                                           int numStripes, const ScanDirection &scanDirection,
                                                           double threshold)
      {
        std::vector<int> scanLineIndices(imageStripes.Width());
        std::vector<double> edgeIndices(static_cast<size_t>(imageStripes.Width())
                                        * (static_cast<size_t>(numStripes) + 1));
        size_t numProfiles        = 0;
        size_t numEdgesPerProfile = 0;
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(
              CVFDetectEdgesOfStripeTarget(imageStripes.Handle(), static_cast<CExports::cvbdim_t>(aoi.Left()),
                                           static_cast<CExports::cvbdim_t>(aoi.Top()), static_cast<CExports::cvbdim_t>(aoi.Right()),
                                           static_cast<CExports::cvbdim_t>(aoi.Bottom()), numStripes,
                                           static_cast<CExports::CVFScanDirection>(scanDirection), threshold,
                                           scanLineIndices.data(), edgeIndices.data(), numProfiles, numEdgesPerProfile);
        }));
        return {std::move(scanLineIndices), std::move(edgeIndices), static_cast<int>(numProfiles),
                static_cast<int>(numEdgesPerProfile)};
      }


      class LineScanCalibrator final
      {
        friend std::unique_ptr<LineScanCalibrator>
        CreateLineScanCalibration(const Point2D<double> &calibrationPoint1, const Point2D<double> &calibrationPoint2,
                                  double referenceDistanceCalibrationPoints,
                                  const EdgeDetectionResult &edgeDetectionResult, double referenceWidthStripes,
                                  const LineScanCalibrationConfiguration &configuration);
 
      private:
        struct PrivateTag
        {
        };
 
      public:
        LineScanCalibrator(const NonLinearTransformationPtr &transformation, double pixelSize, double meanError,
                           double standardDeviation, PrivateTag)
            : transformation_(transformation)
            , pixelSize_(pixelSize)
            , meanError_(meanError)
            , standardDeviation_(standardDeviation)
        {
        }


        NonLinearTransformationPtr Transformation() const noexcept
        {
          return transformation_;
        }


        double PixelSize() const noexcept
        {
          return pixelSize_;
        }


        double MeanError() const noexcept
        {
          return meanError_;
        }


        double StandardDeviation() const noexcept
        {
          return standardDeviation_;
        }
 
      private:
        NonLinearTransformationPtr transformation_;
        double pixelSize_;
        double meanError_;
        double standardDeviation_;
      };


      inline std::unique_ptr<LineScanCalibrator>
      CreateLineScanCalibration(const Point2D<double> &calibrationPoint1, const Point2D<double> &calibrationPoint2,
                                double referenceDistanceCalibrationPoints,
                                const EdgeDetectionResult &edgeDetectionResult, double referenceWidthStripes,
                                const LineScanCalibrationConfiguration &configuration)
      {
        void *transformation     = nullptr;
        double pixelSize         = 0;
        double meanError         = 0;
        double standardDeviation = 0;
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(CVFCreateLineScanCalibration(*reinterpret_cast<const CExports::CVIPointD*>(&calibrationPoint1), 
            *reinterpret_cast<const CExports::CVIPointD*>(&calibrationPoint2), 
            referenceDistanceCalibrationPoints, 
            const_cast<int*>(reinterpret_cast<const int*>(edgeDetectionResult.scanLineIndices_.data())), 
            const_cast<double*>(reinterpret_cast<const double*>(edgeDetectionResult.edgeIndices_.data())), 
            edgeDetectionResult.numProfiles_, 
            edgeDetectionResult.numEdgesPerProfile_, 
            referenceWidthStripes, 
            *reinterpret_cast<const CExports::CVFLineScanCalibrationConfiguration*>(&configuration), 
            transformation, pixelSize, meanError, standardDeviation);
            }));
        return std::make_unique<LineScanCalibrator>(
            NonLinearTransformation::FromHandle(HandleGuard<NonLinearTransformation>(transformation)), pixelSize,
            meanError, standardDeviation, LineScanCalibrator::PrivateTag{});
      }
 
    }  // namespace CalibrationLineScan
 
    using CalibrationLineScan::CalculateTwoPointsForCalibrationOfMovement;
    using CalibrationLineScan::CreateLineScanCalibration;
    using CalibrationLineScan::DetectEdgesOfStripeTarget;
    using CalibrationLineScan::EdgeDetectionResult;
    using CalibrationLineScan::LineScanCalibrationConfiguration;
    using CalibrationLineScan::LineScanCalibrator;
    using CalibrationLineScan::LineScanCalibratorPtr;
    using CalibrationLineScan::PreDefinedPixelSizeMode;
    using CalibrationLineScan::ScanDirection;
 
  }  // namespace Foundation
  CVB_END_INLINE_NS
}  // namespace Cvb
 
#endif