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; } }
 
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::ProjectionValue;
using Edge::Projection;
using Edge::ProjectionPtr;
 
using Edge::FindFirstEdge;
using Edge::FindEdgePair;
using Edge::FindAllEdges;
using Edge::FindBestEdge;
using Edge::WriteProjection;
 
using Edge::Projection;
using Edge::ProjectionPtr;
 
 
 
} /* namespace Foundation */
CVB_END_INLINE_NS
} /* namespace Cvb */