algorithm.hpp

#pragma once
 
#include <exception>
#include <memory>
#include <new>
#include <stdexcept>
 
#include "_cexports/c_img.h"
 
#include "global.hpp"
#include "image.hpp"
#include "image_plane.hpp"
 
#include "utilities/system_info.hpp"
 
namespace Cvb
{

  CVB_BEGIN_INLINE_NS


  inline std::unique_ptr<Image> AffineTransform(const Image &image, AffineMatrix2D affineMatrix, Area2D area)
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(
          CreateAreaAffineTransformedImage(image.Handle(), *reinterpret_cast<CExports::TCoordinateMap *>(&affineMatrix),
                                           *reinterpret_cast<CExports::TArea *>(&area), img));
    });
  }
  inline std::unique_ptr<Image> AffineTransform(const Image &image, AffineMatrix2D affineMatrix, Area2D area) {…}


  inline std::unique_ptr<Image> AffineTransform(const Image &image, AffineMatrix2D affineMatrix)
  {
    return AffineTransform(image, affineMatrix,
                           Area2D(static_cast<Rect<double>>(image.Bounds()), AffineMatrix2D::Identity()));
  }
  inline std::unique_ptr<Image> AffineTransform(const Image &image, AffineMatrix2D affineMatrix) {…}


  inline std::unique_ptr<Image> LinearTransform(const Image &image, Matrix2D matrix)
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(
          CreateMatrixTransformedImageEx(image.Handle(), *reinterpret_cast<CExports::TMatrix *>(&matrix), img));
    });
  }
  inline std::unique_ptr<Image> LinearTransform(const Image &image, Matrix2D matrix) {…}


  inline std::unique_ptr<Image> MapTo8Bit(const Image &image,
                                          PlaneNormalization planeNormalization = PlaneNormalization::Identical)
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(MapTo8Bit(
          image.Handle(),
          static_cast<CExports::cvbbool_t>(planeNormalization == PlaneNormalization::Identical ? (true) : false), img));
    });
  }
  inline std::unique_ptr<Image> MapTo8Bit(const Image &image, {…}


  inline std::unique_ptr<Image> NormalizeMinMax(const Image &image, double targetMin, double targetMax)
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(
          CreateNormalizedImage(image.Handle(), CExports::Normalize_MinMax, targetMin, targetMax, img));
    });
  }
  inline std::unique_ptr<Image> NormalizeMinMax(const Image &image, double targetMin, double targetMax) {…}


  inline std::unique_ptr<Image> NormalizeMeanVariance(const Image &image, double targetMean, double targetVariance)
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(
          CreateNormalizedImage(image.Handle(), CExports::Normalize_MeanVariance, targetMean, targetVariance, img));
    });
  }
  inline std::unique_ptr<Image> NormalizeMeanVariance(const Image &image, double targetMean, double targetVariance) {…}


  inline std::unique_ptr<Image> PolarTransform(const Image &image, Point2D<double> center, double innerRadius,
                                               double outerRadius, Angle startAngle, Angle totalAngle)
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(CreatePolarImageEx(image.Handle(), center.X(), center.Y(), startAngle.Deg(),
                                              totalAngle.Deg(), std::min(innerRadius, outerRadius),
                                              std::max(innerRadius, outerRadius), img));
    });
  }
  inline std::unique_ptr<Image> PolarTransform(const Image &image, Point2D<double> center, double innerRadius, {…}


  inline std::unique_ptr<Image> PolarTransform(const Image &image, Point2D<double> center, double innerRadius,
                                               double outerRadius)
  {
    return PolarTransform(image, center, innerRadius, outerRadius, Angle::FromDegrees(0.0), Angle::FromDegrees(360.0));
  }
  inline std::unique_ptr<Image> PolarTransform(const Image &image, Point2D<double> center, double innerRadius, {…}


  inline std::unique_ptr<Image> InversePolarTransform(const Image &image, Angle startAngle, double innerRadius)
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(CreateInversePolarImage(image.Handle(), startAngle.Deg(), innerRadius, img));
    });
  }
  inline std::unique_ptr<Image> InversePolarTransform(const Image &image, Angle startAngle, double innerRadius) {…}


  inline void InversePolarTransformToDst(const Image &imageSrc, Point2D<double> center, Angle startAngle,
                                         double innerRadius, Image &imageDst)
  {
    if (CVB_CALL_CAPI(InversePolarTransform(imageSrc.Handle(), center.X(), center.Y(), startAngle.Deg(), innerRadius,
                                            imageDst.Handle())))
      Utilities::SystemInfo::ThrowLastError();
    imageDst.RaisePixelContentChanged();
  }
  inline void InversePolarTransformToDst(const Image &imageSrc, Point2D<double> center, Angle startAngle, {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb