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,
            Foundation::CalibrationLineScan::ScanDirection scanDirection,
            Foundation::CalibrationLineScan::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;
        }
 
 
        Foundation::CalibrationLineScan::ScanDirection ScanDirection() const noexcept
        {
          return scanDirection_;
        }
 
 
        void SetScanDirection(Foundation::CalibrationLineScan::ScanDirection scanDirection) noexcept
        {
          scanDirection_ = scanDirection;
        }
 
 
        Foundation::CalibrationLineScan::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,
                                           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() = default;
 
        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 noexcept
        {
          return scanLineIndices_;
        }
 
 
        std::vector<double> EdgeIndices() const noexcept
        {
          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 Area2D &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([&]() {
          auto left   = aoi.P0().X();
          auto top    = aoi.P0().Y();
          auto right  = aoi.P3().X();
          auto bottom = aoi.P3().Y();
          return CVB_CALL_CAPI(
              CVFDetectEdgesOfStripeTarget(imageStripes.Handle(), static_cast<CExports::cvbdim_t>(left),
                                           static_cast<CExports::cvbdim_t>(top), static_cast<CExports::cvbdim_t>(right),
                                           static_cast<CExports::cvbdim_t>(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::CreateLineScanCalibration;
    using CalibrationLineScan::DetectEdgesOfStripeTarget;
    using CalibrationLineScan::EdgeDetectionResult;
    using CalibrationLineScan::CalculateTwoPointsForCalibrationOfMovement;
    using CalibrationLineScan::LineScanCalibrationConfiguration;
    using CalibrationLineScan::LineScanCalibrator;
    using CalibrationLineScan::LineScanCalibratorPtr;
    using CalibrationLineScan::PreDefinedPixelSizeMode;
    using CalibrationLineScan::ScanDirection;
 
  }  // namespace Foundation
  CVB_END_INLINE_NS
}  // namespace Cvb
 
#endif