curve.hpp

#pragma once
 
#if defined _WIN32
 
#  include "../_cexports/c_foundation.h"
#  include "cvb/area_2d.hpp"
#  include "cvb/line_2d.hpp"
#  include "cvb/matrix_2d.hpp"
 
#  include <algorithm>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {

    namespace Curve
    {

      inline std::vector<Point2D<double>> ResampleCurve(const std::vector<Point2D<double>> &curve,
                                                        int resampledCurveLength)
      {
        std::vector<Point2D<double>> resampledCurve(resampledCurveLength);
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(CVFResampleCurve2D(
              reinterpret_cast<const CExports::CVIPointD *>(curve.data()),
              static_cast<CExports::cvbdim_t>(curve.size()),
              static_cast<CExports::cvbdim_t>(resampledCurve.size()),
              reinterpret_cast<CExports::CVIPointD *>(resampledCurve.data()));
        }));
        return resampledCurve;
      }

      enum class PreAlignmentMode
      {
        Off,
        On
      };


      class AlignmentConfiguration
      {
      public:
        AlignmentConfiguration() noexcept
            : maxIterations_(50)
            , tolerance_(1e-6)
            , minImprovement_(1e-3)
            , correspondence_(.9)
            , preAlign_(false)
        {
        }


        AlignmentConfiguration(size_t maxIterations, double tolerance, double minImprovement, double correspondence,
                               PreAlignmentMode mode) noexcept
            : maxIterations_(maxIterations)
            , tolerance_(tolerance)
            , minImprovement_(minImprovement)
            , correspondence_(correspondence)
            , preAlign_(false)
        {
          SetMode(mode);
        }
 
        ~AlignmentConfiguration()                                         = default;
        AlignmentConfiguration(const AlignmentConfiguration &)            = default;
        AlignmentConfiguration &operator=(const AlignmentConfiguration &) = delete;
        AlignmentConfiguration(AlignmentConfiguration &&)                 = delete;
        AlignmentConfiguration &operator=(AlignmentConfiguration &&)      = default;


        size_t MaxIterations() const noexcept
        {
          return maxIterations_;
        }


        void SetMaxIterations(size_t maxIterations) noexcept
        {
          maxIterations_ = maxIterations;
        }


        double Tolerance() const noexcept
        {
          return tolerance_;
        }


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


        double MinImprovement() const noexcept
        {
          return minImprovement_;
        }


        void SetMinImprovement(double minImprovement) noexcept
        {
          minImprovement_ = minImprovement;
        }


        double Correspondence() const noexcept
        {
          return correspondence_;
        }


        void SetCorrespondence(double correspondence) noexcept
        {
          correspondence_ = correspondence;
        }


        PreAlignmentMode Mode() const noexcept
        {
          return preAlign_ ? PreAlignmentMode::On : PreAlignmentMode::Off;
        }


        void SetMode(PreAlignmentMode mode) noexcept
        {
          preAlign_ = mode == PreAlignmentMode::On ? true : false;
        }
 
      private:
        size_t maxIterations_;
        double tolerance_;
        double minImprovement_;
        double correspondence_;
        bool preAlign_;
      };


      class AlignmentResult2D
      {
      public:
        AlignmentResult2D(const AlignmentResult2D &) noexcept = default;
        AlignmentResult2D(AlignmentResult2D &&) noexcept      = default;
 
        AlignmentResult2D &operator=(const AlignmentResult2D &) = default;
        AlignmentResult2D &operator=(AlignmentResult2D &&)      = default;
 
        ~AlignmentResult2D() = default; 


        const Matrix2D &Rotation() const noexcept
        {
          return rotation_;
        }


        const Vector2D<double> &Translation() const noexcept
        {
          return translation_;
        }


        double MeanDistance() const noexcept
        {
          return meanDistance_;
        }


        size_t NumIterations() const noexcept
        {
          return numIterations_;
        }
 
      private:
        AlignmentResult2D() noexcept {};
 
        Matrix2D rotation_;
        Point2D<double> translation_;
        double meanDistance_{0};
        size_t numIterations_{0};
 
        friend AlignmentResult2D AlignCurve(const std::vector<Point2D<double>> &, const std::vector<Point2D<double>> &,
                                            const AlignmentConfiguration &);
      };


      inline AlignmentResult2D AlignCurve(const std::vector<Point2D<double>> &curve,
                                          const std::vector<Point2D<double>> &curveToBeAligned,
                                          const AlignmentConfiguration &config = AlignmentConfiguration())
      {
        AlignmentResult2D result;
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(CVFAlignCurves2D(reinterpret_cast<const CExports::CVIPointD *>(curve.data()),
                                                static_cast<CExports::cvbdim_t>(curve.size()),
                                                reinterpret_cast<const CExports::CVIPointD *>(curveToBeAligned.data()),
                                                static_cast<CExports::cvbdim_t>(curveToBeAligned.size()),
                                                reinterpret_cast<const CExports::CVFAlignmentConfiguration &>(config),
                                                reinterpret_cast<CExports::CVFAlignment2DResult &>(result)));
        });
        return result;
      }


      inline std::vector<double> CalculateSignedDifferences(const std::vector<Point2D<double>> &curve,
                                                            const std::vector<Point2D<double>> &points)
      {
        std::vector<double> differences(points.size());
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(
              CVFCalculateSignedDifferences(reinterpret_cast<const CExports::CVIPointD *>(curve.data()),
                                            static_cast<CExports::cvbdim_t>(curve.size()),
                                            reinterpret_cast<const CExports::CVIPointD *>(points.data()),
                                            static_cast<CExports::cvbdim_t>(points.size()), differences.data()));
        });
        return differences;
      }


      inline std::vector<Point2D<double>> IntersectWithLine(const std::vector<Point2D<double>> &curve,
                                                            const Line2D &line)
      {
        std::vector<Point2D<double>> intersectionPoints(curve.size());
        auto intersectionPointsCalculatedLength = intersectionPoints.size();
        auto normal                             = line.Normal();
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(CVFIntersectCurve2DWithLine(
              reinterpret_cast<const CExports::CVIPointD *>(curve.data()),
              static_cast<CExports::cvbdim_t>(curve.size()), *reinterpret_cast<const CExports::CVIPointD *>(&normal),
              line.Distance(), static_cast<CExports::cvbdim_t>(intersectionPoints.size()),
              reinterpret_cast<CExports::CVIPointD *>(intersectionPoints.data()),
              reinterpret_cast<CExports::cvbdim_t &>(intersectionPointsCalculatedLength)));
        });
        intersectionPoints.resize(intersectionPointsCalculatedLength);
        return intersectionPoints;
      }


      inline double CalculateEnclosedArea(const std::vector<Point2D<double>> &curve)
      {
        double enclosedArea = 0;
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(CVFCalculateEnclosedArea(reinterpret_cast<const CExports::CVIPointD *>(curve.data()),
                                                        static_cast<CExports::cvbdim_t>(curve.size()), &enclosedArea));
        });
        return enclosedArea;
      }


      inline Matrix2D CalculateQuadraticDifferencesToClosestPoint(const std::vector<Point2D<double>> &curve,
                                                                  const std::vector<Point2D<double>> &points)
      {
        Matrix2D distance;
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(CVFCalculateQuadraticDifferencesToClosestPoint(
              reinterpret_cast<const CExports::CVIPointD *>(curve.data()),
              static_cast<CExports::cvbdim_t>(curve.size()),
              reinterpret_cast<const CExports::CVIPointD *>(points.data()),
              static_cast<CExports::cvbdim_t>(points.size()), reinterpret_cast<double *>(&distance)));
        });
        return distance;
      }

      enum class StartSelectionMode
      {
        AsIs,
        Best
      };


      inline std::vector<Point2D<double>> MergeTwoCurves(const std::vector<Point2D<double>> &curveLHS,
                                                         const std::vector<Point2D<double>> &curveRHS,
                                                         const StartSelectionMode &mode)
      {
        std::vector<Point2D<double>> mergedCurve(curveLHS.size() + curveRHS.size());
        int mergedLength = 0;
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(CVFMerge2Curves(reinterpret_cast<const CExports::CVIPointD *>(curveLHS.data()),
                                               static_cast<CExports::cvbdim_t>(curveLHS.size()),
                                               reinterpret_cast<const CExports::CVIPointD *>(curveRHS.data()),
                                               static_cast<CExports::cvbdim_t>(curveRHS.size()),
                                               mode == StartSelectionMode::AsIs ? false : true,
                                               static_cast<CExports::cvbdim_t>(mergedCurve.size()),
                                               reinterpret_cast<CExports::CVIPointD *>(mergedCurve.data()),
                                               reinterpret_cast<CExports::cvbdim_t &>(mergedLength)));
        });
        if (mergedLength != static_cast<int>(mergedCurve.size()))
          mergedCurve.resize(mergedLength);
        return mergedCurve;
      }
    }  // namespace Curve
 
    using Curve::AlignCurve;
    using Curve::AlignmentConfiguration;
    using Curve::AlignmentResult2D;
    using Curve::CalculateEnclosedArea;
    using Curve::CalculateQuadraticDifferencesToClosestPoint;
    using Curve::CalculateSignedDifferences;
    using Curve::IntersectWithLine;
    using Curve::MergeTwoCurves;
    using Curve::PreAlignmentMode;
    using Curve::ResampleCurve;
    using Curve::StartSelectionMode;
 
  }  // namespace Foundation
  CVB_END_INLINE_NS
}  // namespace Cvb
 
#endif