regression.hpp

#pragma once
 
#if defined _WIN32
 
#  include "../_cexports/c_foundation.h"
 
#  include "../global.hpp"
#  include "../exception.hpp"
#  include "../circle.hpp"
#  include "../ellipse.hpp"
#  include "../line_2d.hpp"
#  include "../_detail/detail_pixel_list.hpp"
#  include "../point_2d.hpp"
#  include "../angle.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Foundation
  {


    namespace Regression
    {

      template <class RANGE>
      inline typename TypedRange<Circle, Point2D<double>, RANGE>::type CircleRegression(const RANGE &points)
      {
        auto pixelList = Internal::PixelList::FromPoints(points);
 
        double x, y, radius;
        CVB_CALL_CAPI_CHECKED(CalculateCircleRegression(pixelList->Handle(), x, y, radius));
        return Circle(Point2D<double>(x, y), radius);
      }
      inline typename TypedRange<Circle, Point2D<double>, RANGE>::type CircleRegression(const RANGE &points) {…}


      template <class RANGE>
      inline typename TypedRange<Ellipse, Point2D<double>, RANGE>::type EllipseRegression(const RANGE &points)
      {
        auto pixelList = Internal::PixelList::FromPoints(points);
 
        double x, y, radiusA, radiusB, rot;
        CVB_CALL_CAPI_CHECKED(CalculateEllipseRegression(pixelList->Handle(), x, y, radiusA, radiusB, rot));
        return Ellipse(Point2D<double>(x, y), radiusA, radiusB, Angle::FromDegrees(rot));
      }
      inline typename TypedRange<Ellipse, Point2D<double>, RANGE>::type EllipseRegression(const RANGE &points) {…}


      template <class RANGE>
      inline typename TypedRange<Line2D, Point2D<double>, RANGE>::type LineRegression(const RANGE &points)
      {
        auto pixelList = Internal::PixelList::FromPoints(points);
 
        auto hLine = CVB_CALL_CAPI(CreateLine2DByRegression(pixelList->Handle()));
        ReleaseObjectGuard hLineHolder(hLine);
 
        double distance;
        CVB_CALL_CAPI_CHECKED(GetLine2DOriginDistance(hLine, distance));
        CExports::VECTOR2D hVector;
        CVB_CALL_CAPI_CHECKED(GetLine2DNormalVector(hLine, hVector));
        ReleaseObjectGuard hVectorHolder(hVector);
 
        double vectX, vectY;
        CVB_CALL_CAPI_CHECKED(GetVector2DCartesian(hVector, vectX, vectY));
 
        return Line2D(Point2D<double>(vectX, vectY), distance);
      }
      inline typename TypedRange<Line2D, Point2D<double>, RANGE>::type LineRegression(const RANGE &points) {…}
 
    } /* namespace Regression */
    namespace Regression {…}
 
    using Regression::CircleRegression;
    using Regression::EllipseRegression;
    using Regression::LineRegression;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */
 
#endif