search_predictor.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "../value_range.hpp"
#include "../angle.hpp"
#include "predictor_base.hpp"
#include "search_result.hpp"
 
#include <vector>
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
namespace Polimago
{
 
enum class InvarianceType
{
  None = 0,
  Translation = CExports::TI_Translations,
  RotationScaleTranslation = CExports::TI_RotScaleTrans,
  AffineGroup = CExports::TI_AffineGroup
};
 
// forward declaration
namespace Training { class SearchPredictorFactory; }
 
 
class SearchPredictor : public PredictorBase
{
private:
  // Internal helper constructor version
  SearchPredictor (ReleaseObjectGuard&& guard)
    : PredictorBase (std::move (guard))
  {
    CVB_CALL_CAPI (PMGetSearchClfTrainParams (Handle (), trainingParameters_, searchTrainingParameters_));
    maxNumResults_ = maxNumResultsDefault_;
    InitResultBuffer ();
  }
 
  void InitResultBuffer()
  {
    pbuffer_.assign (MaxNumResults (), CExports::TSearchResult ());
  }
 
  // Helper to load a saved predictor from file
  static CExports::TSCLF LoadInternal (const String & fileName)
  {
    CExports::TSCLF predictor = nullptr;
 
    CVB_CALL_CAPI_CHECKED (PMOpenSearchClfTyped(fileName.c_str(), predictor));
    return predictor;
  }
 
  void SaveFunction (const String &fileName) const override
  {
    CVB_CALL_CAPI_CHECKED (PMSaveSearchClfTyped(fileName.c_str(), Handle()));
  }
 
  std::string ObjectName () const override
  {
    return thisObjectName_;
  }
 
public:
 
  SearchPredictor (const String & fileName)
    : SearchPredictor (ReleaseObjectGuard(LoadInternal (fileName)))
  {
    fileName_ = fileName;
  }
 
  SearchPredictor (SearchPredictor&&) noexcept = default;
 
  SearchPredictor& operator=(SearchPredictor&&) noexcept = default;
 
  virtual ~SearchPredictor ()
  {}
 
 
  static std::unique_ptr<SearchPredictor> FromHandle (ReleaseObjectGuard&& guard)
  {
    if (!guard.Handle ())
    {
      throw std::invalid_argument ("invalid search predictor native handle");
    }
    return std::unique_ptr<SearchPredictor>(new SearchPredictor(std::move(guard)));
  }
 
 
  static std::unique_ptr<SearchPredictor> Load (const String & fileName)
  {
    return std::unique_ptr<SearchPredictor>(new SearchPredictor(fileName));
  }
 
 
  int MaxNumResults() const noexcept
  {
    return maxNumResults_;
  }
 
 
  void SetMaxNumResults(int maxNumResults)
  {
    if (maxNumResults == maxNumResults_)
    {
      return;
    }
    if (maxNumResults < 1)
    {
      throw std::invalid_argument ("max num results value must be >0");
    }
    maxNumResults_ = maxNumResults;
    InitResultBuffer();
  }
 
 
  int SampleSize() const noexcept
  {
    return searchTrainingParameters_.SampleSize;
  }
 
 
  double ExtractionRadius() const noexcept
  {
    return searchTrainingParameters_.InvarianceParams.XYRadius;
  }
 
 
  ValueRange<Angle> RotationRange() const noexcept
  {
    return ValueRange<Angle>(Angle::FromRadians(searchTrainingParameters_.InvarianceParams.MinAngle),
                             Angle::FromRadians(searchTrainingParameters_.InvarianceParams.MaxAngle));
  }
 
 
  ValueRange<double> ScaleRange() const noexcept
  {
    return ValueRange<double>(searchTrainingParameters_.InvarianceParams.MinScaleMinL, searchTrainingParameters_.InvarianceParams.MaxScaleMaxL);
  }
 
 
  InvarianceType Invariances() const noexcept
  {
    return static_cast<InvarianceType>(searchTrainingParameters_.InvarianceParams.InvarianceType);
  }
 
 
  int NumClassificationSteps() const noexcept
  {
    return searchTrainingParameters_.NumClfs;
  }
 
 
  int FeatureResolutionStep1And2() const noexcept
  {
    return searchTrainingParameters_.Resolution12;
  }
 
 
  int FeatureResolutionRest() const noexcept
  {
    return searchTrainingParameters_.ResolutionRest;
  }
 
 
  std::vector<SearchResult> GridSearch (const Image & img, Rect<int> aoi, double gridStep, double threshold, double locality, int &numCalls)
  {
    VerifyCompatibility(img);
 
    CExports::cvbval_t numCallsOut = 0;
    auto resultCount = CVB_CALL_CAPI (PMGridSearch(Handle(), img.Handle(), aoi.Left(), aoi.Top(), aoi.Right(), aoi.Bottom(), gridStep, threshold, locality, maxNumResults_, &pbuffer_[0], numCallsOut));
    numCalls = static_cast<int>(numCallsOut);
 
    std::vector<SearchResult> retval;
    for (decltype(resultCount) i = 0; i < resultCount; ++i)
    {
      retval.push_back (SearchResult (pbuffer_[i], Handle ()));
    }
    return retval;
  }
 
 
  std::vector<SearchResult> GridSearch (const Image & img, Rect<int> aoi, double gridStep, double threshold, double locality)
  {
    int numCalls;
    return GridSearch (img, aoi, gridStep, threshold, locality, numCalls);
  }
 
 
  bool Inspect (const Image & img, SearchResult &res, int &searchDepth)
  {
    VerifyCompatibility(img);
    CExports::TSearchResult tmpRes = res.resInternal_;
    CExports::cvbval_t tmpDepth = searchDepth;
 
    auto retval = CVB_CALL_CAPI(PMInspect(Handle(), img.Handle(), tmpRes, tmpDepth));
    if (retval)
    {
      res = SearchResult (tmpRes, Handle());
      searchDepth = static_cast<int>(tmpDepth);
    }
    return retval != 0;
  }
 
 
  bool Inspect (const Image & img, SearchResult &res, int &searchDepth, std::vector<SearchResult> &trace)
  {
    VerifyCompatibility(img);
    CExports::TSearchResult tmpRes = res.resInternal_;
    CExports::cvbval_t tmpDepth = searchDepth;
    CExports::TDiagnostics diag = {};
 
    auto retval = CVB_CALL_CAPI(PMInspectD(Handle(), img.Handle(), tmpRes, tmpDepth, diag));
    if (retval)
    {
      res = SearchResult (tmpRes, Handle());
      searchDepth = static_cast<int>(tmpDepth);
    }
 
    trace.clear ();
    for (int i = 0; i < searchDepth; ++i)
    {
      trace.push_back (SearchResult (diag[i], Handle ()));
    }
 
    return retval != 0;
  }
 
 
  std::unique_ptr<Image> SearchResultToImage (const Image & sourceImage, SearchResult res)
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void* & resimg)
    {
      return CVB_CALL_CAPI(PMSearchResultToImage(Handle(), sourceImage.Handle(), res.resInternal_.G, resimg));
    });
  }
 
  friend Training::SearchPredictorFactory;
 
private:
  static const int maxNumResultsDefault_ = 4096;
  const std::string thisObjectName_ = "Polimago Search Predictor";
  CExports::TTrainSearchParams searchTrainingParameters_;
  CExports::cvbval_t maxNumResults_;
  std::vector<CExports::TSearchResult> pbuffer_;
};
 
using SearchPredictorPtr = std::shared_ptr<SearchPredictor>;
 
 
 
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */