edge.hpp

#pragma once
 
#include "../_cexports/c_edge.h"
 
#include "../global.hpp"
#include "../image.hpp"
#include "../exception.hpp"
#include "../rect.hpp"
#include "../area_2d.hpp"
 
#include <vector>
#include <string>
#include <sstream>
#include <memory>
#include <utility>
#include <algorithm>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {
    namespace Edge
    {
      class Projection;
    }
  }  // namespace Foundation
 
  template <>
  inline HandleGuard<Foundation::Edge::Projection>::HandleGuard(void *handle) noexcept
      : HandleGuard<Foundation::Edge::Projection>(handle, [](void *h) { CVB_CALL_CAPI(ReleaseProjection(h)); })
  {
  }
 
  namespace Foundation
  {


    namespace Edge
    {

      enum class EdgeSearchMode
      {

        Intensity,
        IntensitySubPixel,
        Contrast,
        ContrastSubPixel,

        SecondDerivativeSubPixel
      };

      enum class EdgeType
      {
        Ignore = CExports::POLARITY_DONT_CARE,
        Positive = CExports::POLARITY_POSITIVE,
        Negative = CExports::POLARITY_NEGATIVE
      };

      enum class ProjectionMode
      {
        Average,
        Sum
      };


      class EdgeResult
      {
      public:
        EdgeResult() noexcept
            : x_(0.0)
            , y_(0.0)
            , quality_(0.0)
            , type_(EdgeType::Ignore)
        {
        }
 
        EdgeResult(double x, double y, double quality, EdgeType type) noexcept
            : x_(x)
            , y_(y)
            , quality_(quality)
            , type_(type)
        {
        }
 
      public:

        static EdgeResult Nothing() noexcept
        {
          return EdgeResult();
        }


        double X() const noexcept
        {
          return x_;
        }


        double Y() const noexcept
        {
          return y_;
        }


        double Quality() const noexcept
        {
          return quality_;
        }


        EdgeType Type() const noexcept
        {
          return type_;
        }
 
      private:
        double x_;
        double y_;
        double quality_;
        EdgeType type_;
      };


      inline bool operator!=(const EdgeResult &lhs, const EdgeResult &rhs) noexcept
      {
        return (lhs.X() != rhs.X()) || (lhs.Y() != rhs.Y()) || (lhs.Quality() != rhs.Quality())
               || (lhs.Type() != rhs.Type());
      }


      inline bool operator==(const EdgeResult &lhs, const EdgeResult &rhs) noexcept
      {
        return (!(lhs != rhs));
      }


      struct EdgeResultPair
      {
        EdgeResult First;

        EdgeResult Second;
      };
 
      namespace Private
      {
        /* Convert an edge results collection to an edge vector. */
        inline std::vector<EdgeResult> EdgeResultsToArray(CExports::EDGERESULTS hResults, EdgeType type)
        {
          std::vector<EdgeResult> results;
 
          size_t resultCount = CVB_CALL_CAPI(EdgeResultsCount(hResults));
          for (size_t i = 0; i < resultCount; ++i)
          {
            double x = std::numeric_limits<double>::quiet_NaN(), y = std::numeric_limits<double>::quiet_NaN(),
                   q = std::numeric_limits<double>::quiet_NaN();
            CVB_CALL_CAPI_CHECKED(EdgeResult(hResults, i, x, y, q));
            results.push_back(EdgeResult(x, y, q, type));
          }
 
          return results;
        }
 
        typedef HandleGuard<void, CVB_CALL_CAPI(ReleaseEdgeResultsVoid)> ReleaseEdgeResultsGuard;
 
      } /* namespace Private */


      inline EdgeResult FindFirstEdge(const ImagePlane &plane, EdgeSearchMode mode, EdgeType type, double threshold,
                                      Area2D aoi, double density = 1.0)
      {
        if ((type == EdgeType::Ignore) && (mode != EdgeSearchMode::SecondDerivativeSubPixel))
        {
          throw std::invalid_argument("invalid combination of EdgeType and EdgeSearchMode requested");
        }
 
        CExports::TEdgeResult edgeRes = {0};
        CExports::cvbbool_t success   = false;
        switch (mode)
        {
          case EdgeSearchMode::Contrast:
            success = CVB_CALL_CAPI(CFindFirstEdge(
                plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                reinterpret_cast<CExports::TArea &>(aoi), threshold, type == EdgeType::Positive, edgeRes));
            break;
          case EdgeSearchMode::ContrastSubPixel:
            success = CVB_CALL_CAPI(CSFindFirstEdge(
                plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                reinterpret_cast<CExports::TArea &>(aoi), threshold, type == EdgeType::Positive, edgeRes));
            break;
          case EdgeSearchMode::Intensity:
            success = CVB_CALL_CAPI(TFindFirstEdge(
                plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                reinterpret_cast<CExports::TArea &>(aoi), threshold, type == EdgeType::Positive, edgeRes));
            break;
          case EdgeSearchMode::IntensitySubPixel:
            success = CVB_CALL_CAPI(TSFindFirstEdge(
                plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                reinterpret_cast<CExports::TArea &>(aoi), threshold, type == EdgeType::Positive, edgeRes));
            break;
          case EdgeSearchMode::SecondDerivativeSubPixel:
            success = CVB_CALL_CAPI(OSFindFirstEdge(plane.Parent().Handle(), plane.Plane(),
                                                    static_cast<int>(density * 1000.0),
                                                    reinterpret_cast<CExports::TArea &>(aoi), threshold,
                                                    static_cast<CExports::TEdgePolarity>(type), edgeRes));
            break;
          default:
            throw std::invalid_argument("unknown edge search mode requested");
        }
 
        if (success)
        {
          return EdgeResult(edgeRes.x, edgeRes.y, edgeRes.Quality, type);
        }
        else
        {
          return EdgeResult::Nothing();
        }
      }


      inline EdgeResult FindFirstEdge(const ImagePlane &plane, EdgeSearchMode mode, EdgeType type, double threshold,
                                      double density = 1.0)
      {
        return FindFirstEdge(plane, mode, type, threshold, Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())),
                             density);
      }


      inline EdgeResultPair FindEdgePair(const ImagePlane &plane, EdgeSearchMode mode, EdgeType type1,
                                         double threshold1, EdgeType type2, double threshold2, Area2D aoi,
                                         double density = 1.0)
      {
        if ((type1 == EdgeType::Ignore) && (mode != EdgeSearchMode::SecondDerivativeSubPixel))
        {
          throw std::invalid_argument("invalid combination of EdgeType and EdgeSearchMode requested");
        }
        if ((type2 == EdgeType::Ignore) && (mode != EdgeSearchMode::SecondDerivativeSubPixel))
        {
          throw std::invalid_argument("invalid combination of EdgeType and EdgeSearchMode requested");
        }
 
        CExports::TEdgeResult edgeRes1 = {0};
        CExports::TEdgeResult edgeRes2 = {0};
        CExports::cvbbool_t success    = false;
        switch (mode)
        {
          case EdgeSearchMode::Contrast:
            success = CVB_CALL_CAPI(
                CFindEdgePair(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                              reinterpret_cast<CExports::TArea &>(aoi), threshold1, type1 == EdgeType::Positive,
                              edgeRes1, threshold2, type2 == EdgeType::Positive, edgeRes2));
            break;
          case EdgeSearchMode::ContrastSubPixel:
            success = CVB_CALL_CAPI(
                CSFindEdgePair(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                               reinterpret_cast<CExports::TArea &>(aoi), threshold1, type1 == EdgeType::Positive,
                               edgeRes1, threshold2, type2 == EdgeType::Positive, edgeRes2));
            break;
          case EdgeSearchMode::Intensity:
            success = CVB_CALL_CAPI(
                TFindEdgePair(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                              reinterpret_cast<CExports::TArea &>(aoi), threshold1, type1 == EdgeType::Positive,
                              edgeRes1, threshold2, type2 == EdgeType::Positive, edgeRes2));
            break;
          case EdgeSearchMode::IntensitySubPixel:
            success = CVB_CALL_CAPI(
                TSFindEdgePair(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                               reinterpret_cast<CExports::TArea &>(aoi), threshold1, type1 == EdgeType::Positive,
                               edgeRes1, threshold2, type2 == EdgeType::Positive, edgeRes2));
            break;
          case EdgeSearchMode::SecondDerivativeSubPixel:
            success = CVB_CALL_CAPI(OSFindEdgePair(
                plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                reinterpret_cast<CExports::TArea &>(aoi), threshold1, static_cast<CExports::TEdgePolarity>(type1),
                edgeRes1, threshold2, static_cast<CExports::TEdgePolarity>(type2), edgeRes2));
            break;
          default:
            throw std::invalid_argument("unknown edge search mode requested");
        }
 
        if (success)
        {
          return EdgeResultPair{{edgeRes1.x, edgeRes1.y, edgeRes1.Quality, type1},
                                {edgeRes1.x, edgeRes1.y, edgeRes1.Quality, type1}};
        }
        else
        {
          return EdgeResultPair{EdgeResult::Nothing(), EdgeResult::Nothing()};
        }
      }


      inline EdgeResultPair FindEdgePair(const ImagePlane &plane, EdgeSearchMode mode, EdgeType type1,
                                         double threshold1, EdgeType type2, double threshold2, double density = 1.0)
      {
        return FindEdgePair(plane, mode, type1, threshold1, type2, threshold2,
                            Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())), density);
      }


      inline EdgeResultPair FindEdgePair(const ImagePlane &plane, EdgeSearchMode mode, EdgeType type1, EdgeType type2,
                                         double threshold, Area2D aoi, double density = 1.0)
      {
        return FindEdgePair(plane, mode, type1, threshold, type2, threshold, aoi, density);
      }


      inline EdgeResultPair FindEdgePair(const ImagePlane &plane, EdgeSearchMode mode, EdgeType type1, EdgeType type2,
                                         double threshold, double density = 1.0)
      {
        return FindEdgePair(plane, mode, type1, threshold, type2, threshold,
                            Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())), density);
      }


      inline std::vector<EdgeResult> FindAllEdges(const ImagePlane &plane, EdgeSearchMode mode, EdgeType type,
                                                  double threshold, Area2D aoi, double density = 1.0)
      {
        if ((type == EdgeType::Ignore) && (mode != EdgeSearchMode::SecondDerivativeSubPixel))
        {
          throw std::invalid_argument("invalid combination of EdgeType and EdgeSearchMode requested");
        }
 
        // second derivation is different to the rest...
        if (mode == EdgeSearchMode::SecondDerivativeSubPixel)
        {
          CExports::EDGERESULTS hEdgeResults = nullptr;
          CVB_CALL_CAPI(OSFindAllEdges(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                                       reinterpret_cast<CExports::TArea &>(aoi), threshold,
                                       static_cast<CExports::TEdgePolarity>(type), hEdgeResults));
          Private::ReleaseEdgeResultsGuard hEdgeResHolder(hEdgeResults);
          return Private::EdgeResultsToArray(hEdgeResults, type);
        }
 
        std::vector<CExports::TEdgeResult> rawResults(Round(aoi.Size()).Width());
        size_t maxEdges  = rawResults.size();
        size_t edgeCount = 0;
        switch (mode)
        {
          case EdgeSearchMode::Contrast:
            CVB_CALL_CAPI(CFindAllEdges(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                                        reinterpret_cast<CExports::TArea &>(aoi), threshold, type == EdgeType::Positive,
                                        maxEdges, rawResults.data(), edgeCount));
            break;
          case EdgeSearchMode::ContrastSubPixel:
            CVB_CALL_CAPI(CSFindAllEdges(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                                         reinterpret_cast<CExports::TArea &>(aoi), threshold,
                                         type == EdgeType::Positive, maxEdges, rawResults.data(), edgeCount));
            break;
          case EdgeSearchMode::Intensity:
            CVB_CALL_CAPI(TFindAllEdges(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                                        reinterpret_cast<CExports::TArea &>(aoi), threshold, type == EdgeType::Positive,
                                        maxEdges, rawResults.data(), edgeCount));
            break;
          case EdgeSearchMode::IntensitySubPixel:
            CVB_CALL_CAPI(TSFindAllEdges(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                                         reinterpret_cast<CExports::TArea &>(aoi), threshold,
                                         type == EdgeType::Positive, maxEdges, rawResults.data(), edgeCount));
            break;
          default:
            throw std::invalid_argument("unknown edge search mode requested");
        }
 
        std::vector<EdgeResult> fullResults(edgeCount);
        std::transform(rawResults.begin(), rawResults.begin() + edgeCount, fullResults.begin(),  // NOLINT
                       [=](CExports::TEdgeResult raw) { return EdgeResult(raw.x, raw.y, raw.Quality, type); });
        return fullResults;
      }


      inline std::vector<EdgeResult> FindAllEdges(const ImagePlane &plane, EdgeSearchMode mode, EdgeType type,
                                                  double threshold, double density = 1.0)
      {
        return FindAllEdges(plane, mode, type, threshold, Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())),
                            density);
      }


      inline EdgeResult FindBestEdge(const ImagePlane &plane, EdgeType type, Area2D aoi, double density = 1.0)
      {
        CExports::TEdgeResult edgeRes = {0};
        auto success                  = CVB_CALL_CAPI(OSFindBestEdge(
            plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
            reinterpret_cast<CExports::TArea &>(aoi), static_cast<CExports::TEdgePolarity>(type), edgeRes));
 
        if (success)
        {
          return EdgeResult(edgeRes.x, edgeRes.y, edgeRes.Quality, type);
        }
        else
        {
          return EdgeResult::Nothing();
        }
      }


      inline EdgeResult FindBestEdge(const ImagePlane &plane, EdgeType type, double density = 1.0)
      {
        return FindBestEdge(plane, type, Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())), density);
      }


      inline void WriteProjection(const ImagePlane &plane, Area2D aoi, double density = 1.0)
      {
        CVB_CALL_CAPI(WriteProjection(plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                                      reinterpret_cast<CExports::TArea &>(aoi)));
      }


      struct ProjectionValue
      {

        Point2D<double> Position;

        double Value = 0.0;
      };


      class Projection
      {
      private:
        // Internal helper constructor version
        Projection(HandleGuard<Projection> &&guard, ProjectionMode mode) noexcept
            : handle_(std::move(guard))
            , mode_(mode)
        {
        }
 
      public:

        Projection(const ImagePlane &plane, Area2D aoi, ProjectionMode mode = ProjectionMode::Sum, double density = 1.0)
            : Projection(HandleGuard<Projection>(CreateProjectionHandle(plane, aoi, mode, density)), mode)
        {
        }
 
        Projection(const Projection &other)                = delete;
        Projection &operator=(const Projection &other)     = delete;
        Projection(Projection &&other) noexcept            = default;
        Projection &operator=(Projection &&other) noexcept = default;
        ~Projection()                                      = default;


        std::vector<ProjectionValue> Values() const
        {
          if (Length() != values_.size())
          {
            std::vector<ProjectionValue> values(Length());
            Internal::DoBoolCall([&]() {
              return CVB_CALL_CAPI(
                  CopyDoubleBuffer(Handle(), reinterpret_cast<CExports::pDoubleProjection>(values.data())));
            });
            values_.swap(values);
          }
          return values_;
        }
 
      private:
        // Helper to create the projection handle.
        static CExports::PROJECTIONEX CreateProjectionHandle(const ImagePlane &plane, Area2D aoi, ProjectionMode mode,
                                                             double density)
        {
          CExports::PROJECTIONEX projection = nullptr;
          /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the cast below is legal.
           */
          switch (mode)
          {
            case ProjectionMode::Average:
              CVB_CALL_CAPI_CHECKED(GetNormProjectionEx(plane.Parent().Handle(), plane.Plane(),
                                                        static_cast<CExports::cvbdensity_t>(density * 1000.0),
                                                        reinterpret_cast<CExports::TArea &>(aoi), projection));
              break;
            case ProjectionMode::Sum:
              CVB_CALL_CAPI_CHECKED(GetProjectionEx(plane.Parent().Handle(), plane.Plane(),
                                                    static_cast<CExports::cvbdensity_t>(density * 1000.0),
                                                    reinterpret_cast<CExports::TArea &>(aoi), projection));
              break;
            default:
              throw std::invalid_argument("unknown projection mode");
          }
          return projection;
        }
 
      public:

        static std::unique_ptr<Projection> Create(const ImagePlane &plane, Area2D aoi,
                                                  ProjectionMode mode = ProjectionMode::Sum, double density = 1.0)
        {
          return std::make_unique<Projection>(plane, aoi, mode, density);
        }


        void *Handle() const noexcept
        {
          return handle_.Handle();
        }


        static std::unique_ptr<Projection> FromHandle(HandleGuard<Projection> &&guard, ProjectionMode mode)
        {
          if (!guard.Handle())
          {
            throw std::invalid_argument("invalid projection native handle");
          }
          return std::unique_ptr<Projection>(new Projection(std::move(guard), mode));
        }


        std::vector<EdgeResult> CalculateZeroCrossings()
        {
          CExports::EDGERESULTS hResults = nullptr;
          CVB_CALL_CAPI_CHECKED(ZeroCrossings(Handle(), Length(), hResults));
 
          Private::ReleaseEdgeResultsGuard hEdgeResHolder(hResults);
 
          return Private::EdgeResultsToArray(hResults, EdgeType::Ignore);
        }


        std::unique_ptr<Projection> Derive()
        {
          return Internal::DoBoolCallObjectOut<Projection>(
              [&](void *&resproj) { return CVB_CALL_CAPI(Derivation(Handle(), resproj)); }, ProjectionMode::Sum);
        }


        template <class RANGE>
        inline typename TypedRange<std::unique_ptr<Projection>, int, RANGE>::type Filter(const RANGE &kernel)
        {
          auto kernelRange = MakeRangeAdapter<int>(kernel, 1);
 
          return Internal::DoBoolCallObjectOut<Projection>(
              [&](void *&resproj) {
                return CVB_CALL_CAPI(Filter(Handle(), reinterpret_cast<CExports::cvbval_t *>(kernelRange.Data()),
                                            kernelRange.Size(), resproj));
              },
              ProjectionMode::Sum);
        }


        std::unique_ptr<Projection> ToAverageProjection()
        {
          return Internal::DoBoolCallObjectOut<Projection>(
              [&](void *&resproj) { return CVB_CALL_CAPI(Normalize(Handle(), resproj)); }, ProjectionMode::Average);
        }


        ProjectionMode Mode() const noexcept
        {
          return mode_;
        }
 
      private:
        /* The length (= number of values) of the projection. */
        size_t Length() const
        {
          size_t length = 0;
          CVB_CALL_CAPI_CHECKED(GetLength(Handle(), length));
          return length;
        }
 
      private:
        HandleGuard<Projection> handle_;
        ProjectionMode mode_;
        mutable std::vector<ProjectionValue> values_;
      }; /* class Projection */

      typedef std::shared_ptr<Projection> ProjectionPtr;
 
    } /* namespace Edge */
 
    using Edge::EdgeSearchMode;
    using Edge::EdgeType;
    using Edge::ProjectionMode;
 
    using Edge::EdgeResult;
    using Edge::EdgeResultPair;
    using Edge::Projection;
    using Edge::ProjectionPtr;
    using Edge::ProjectionValue;
 
    using Edge::FindAllEdges;
    using Edge::FindBestEdge;
    using Edge::FindEdgePair;
    using Edge::FindFirstEdge;
    using Edge::WriteProjection;
 
    using Edge::Projection;
    using Edge::ProjectionPtr;
 
  } /* namespace Foundation */
  CVB_END_INLINE_NS
} /* namespace Cvb */