classifier.hpp

#pragma once
 
#include "../_cexports/c_minos.h"
 
#include "../global.hpp"
#include "../rect.hpp"
#include "../string.hpp"
#include "../point_2d.hpp"
#include "../matrix_2d.hpp"
#include "../image.hpp"
 
#include "learn_parameters.hpp"
#include "search_result.hpp"
 
#include <sstream>
#include <iomanip>
#include <ctime>
#include <chrono>
#include <vector>
#include <memory>
#include <utility>
#include <cstdint>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Minos
  {
    class Classifier;
  }
  namespace Minos {…}
 
  template <>
  inline HandleGuard<Minos::Classifier>::HandleGuard(void *handle) noexcept
      : HandleGuard<Minos::Classifier>(handle, [](void *h) { CVB_CALL_CAPI(ReleaseObject(h)); })
  {
  }


  namespace Minos
  {

    enum class QualityFeedback
    {
      Unnormalized = CExports::Quality_Unnormalized,
      Normalized = CExports::Quality_ReturnCorrelation
    };
    enum class QualityFeedback {…};

    enum class SearchMode
    {
      FindFirst,
      FindBest,
      FindBestSubPixel
    };
    enum class SearchMode {…};

    enum class ReadMode
    {
      ReturnFirstPosition,
      ReturnLastPosition
    };
    enum class ReadMode {…};


    class ClassifierModelInfo
    {
    public:

      ClassifierModelInfo(const String &name, Point2D<int> advanceVector)
          : name_(name)
          , advanceVector_(advanceVector)
      {
      }
      ClassifierModelInfo(const String &name, Point2D<int> advanceVector) {…}


      String Name() const
      {
        return name_;
      }
      String Name() const {…}


      void SetName(const String &name)
      {
        name_ = name;
      }
      void SetName(const String &name) {…}


      Point2D<int> AdvanceVector() const
      {
        return advanceVector_;
      }
      Point2D<int> AdvanceVector() const {…}


      void SetAdvanceVector(Point2D<int> advanceVector)
      {
        advanceVector_ = advanceVector;
      }
      void SetAdvanceVector(Point2D<int> advanceVector) {…}
 
    private:
      String name_;
      Point2D<int> advanceVector_;
    }; /* class ClassifierModelInfo */
    class ClassifierModelInfo {…};


    inline bool operator!=(const ClassifierModelInfo &lhs, const ClassifierModelInfo &rhs) noexcept
    {
      return (lhs.Name() != rhs.Name()) || (lhs.AdvanceVector() != rhs.AdvanceVector());
    }
    inline bool operator!=(const ClassifierModelInfo &lhs, const ClassifierModelInfo &rhs) noexcept {…}


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


    class ClassifierModelInfoCollection
    {
    public:
      explicit ClassifierModelInfoCollection(const SharedHandleGuard<Classifier> &sguard)
          : shandle_(sguard)
      {
      }
 
      ClassifierModelInfoCollection(const ClassifierModelInfoCollection &other) noexcept            = default;
      ClassifierModelInfoCollection &operator=(const ClassifierModelInfoCollection &other) noexcept = default;
      ClassifierModelInfoCollection(ClassifierModelInfoCollection &&other) noexcept                 = default;
      ClassifierModelInfoCollection &operator=(ClassifierModelInfoCollection &&other) noexcept      = default;
      ~ClassifierModelInfoCollection()                                                              = default;


      int Count() const
      {
        return static_cast<int>(CVB_CALL_CAPI(NumCLFModels(shandle_.Handle())));
      }
      int Count() const {…}


      ClassifierModelInfo ReadInfo(int index) const
      {
        Char *pstr              = nullptr;
        CExports::cvbdim_t advX = 0, advY = 0;
        CVB_CALL_CAPI_CHECKED(GetCLFModelDataTyped(shandle_.Handle(), index, pstr, advX, advY));
 
        return ClassifierModelInfo(pstr != nullptr ? String(pstr) : String(),
                                   Point2D<int>(static_cast<int>(advX), static_cast<int>(advY)));
      }
      ClassifierModelInfo ReadInfo(int index) const {…}


      void WriteInfo(int index, ClassifierModelInfo model)
      {
        if (model == ReadInfo(index))
        {
          return;
        }
        CVB_CALL_CAPI_CHECKED(SetCLFModelDataTyped(shandle_.Handle(), index, model.Name().c_str(),
                                                   model.AdvanceVector().X(), model.AdvanceVector().Y()));
      }
      void WriteInfo(int index, ClassifierModelInfo model) {…}


      std::vector<ClassifierModelInfo> ReadInfo() const
      {
        auto count = Count();
        std::vector<ClassifierModelInfo> info;
        for (decltype(count) i = 0; i < count; ++i)
        {
          info.push_back(ReadInfo(i));
        }
 
        return info;
      }
      std::vector<ClassifierModelInfo> ReadInfo() const {…}
 
    private:
      SharedHandleGuard<Classifier> shandle_;
    }; /* class ClassifierModelInfoCollection */
    class ClassifierModelInfoCollection {…};


    class Classifier
    {
    private:
      // Internal helper constructor version
      explicit Classifier(HandleGuard<Classifier> &&guard, const String &srcFileName = String())
          : shandle_(std::move(guard))
          , fileName_(srcFileName)
          , models_(shandle_)
      {
        // Parse creation date (this property is immutable, so we might as well just parse it once)
        auto strDate = CVB_CALL_CAPI(CLFCreationDate(shandle_.Handle()));
        if (strDate)
        {
          std::istringstream iss(strDate);
          std::tm tm = {};
          // iss.imbue (std::locale ("en-US"));
          // iss >> std::get_time (&tm, "%m/%d/%Y %I:%M:%S %p");
          iss >> std::get_time(&tm, "%d.%m.%y %H:%M:%S");
          if (iss.fail())
          {
            creationDate_ = std::chrono::system_clock::now();
          }
          else
          {
            creationDate_ = std::chrono::system_clock::from_time_t(std::mktime(&tm));
          }
        }
        else
        {
          creationDate_ = std::chrono::system_clock::now();
        }
 
        // Determine classifier extent
        CExports::cvbdim_t left = 0, top = 0, right = 0, bottom = 0;
        CVB_CALL_CAPI_CHECKED(GetCLFExtent(shandle_.Handle(), left, top, right, bottom));
        clfExtent_ =
            Rect<int>(static_cast<int>(left), static_cast<int>(top), static_cast<int>(right), static_cast<int>(bottom));
      }
 
      // Internal helper
      static CExports::cvbval_t MaxSearch() noexcept
      {
        return 32767;
      }
 
    public:

      explicit Classifier(const String &fileName)
          : Classifier(std::move(*Load(fileName)))
      {
      }
      explicit Classifier(const String &fileName) {…}
 
      Classifier(const Classifier &other)                = delete;
      Classifier &operator=(const Classifier &other)     = delete;
      Classifier(Classifier &&other) noexcept            = default;
      Classifier &operator=(Classifier &&other) noexcept = default;
      virtual ~Classifier()                              = default;
 
    public:

      static std::unique_ptr<Classifier> Load(const String &fileName)
      {
        CExports::CLF clf = nullptr;
        CVB_CALL_CAPI_CHECKED(LoadCLFFileTyped(fileName.c_str(), clf));
        return std::unique_ptr<Classifier>(new Classifier(HandleGuard<Classifier>(clf), fileName));
      }
      static std::unique_ptr<Classifier> Load(const String &fileName) {…}


      static std::unique_ptr<Classifier> FromBuffer(const void *buffer, size_t size)
      {
        return Internal::DoBoolCallObjectOut<Classifier>([&](void *&resclas) {
          /* Note: need to cast-away const of "buffer" parameter to match the C-API, the function does not modify it. */
          return CVB_CALL_CAPI(MemoryToCLF(const_cast<void *>(buffer), static_cast<long>(size),
                                           resclas));  // NOLINT(cppcoreguidelines-pro-type-const-cast)
        });
      }
      static std::unique_ptr<Classifier> FromBuffer(const void *buffer, size_t size) {…}


      template <class RANGE>
      static typename TypedRange<std::unique_ptr<Classifier>, std::uint8_t, RANGE>::type FromBuffer(const RANGE &buffer)
      {
        auto bufferRange = MakeRangeAdapter<std::uint8_t>(buffer);
        return FromBuffer(bufferRange.Data(), bufferRange.Size());
      }
      static typename TypedRange<std::unique_ptr<Classifier>, std::uint8_t, RANGE>::type FromBuffer(const RANGE &buffer) {…}


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


      static std::unique_ptr<Classifier> FromHandle(HandleGuard<Classifier> &&guard)
      {
        if (!guard.Handle())
        {
          throw std::invalid_argument("invalid clf classifier native handle");
        }
        return std::unique_ptr<Classifier>(new Classifier(std::move(guard)));
      }
      static std::unique_ptr<Classifier> FromHandle(HandleGuard<Classifier> &&guard) {…}


      void Save(const String &fileName) const
      {
        CVB_CALL_CAPI_CHECKED(WriteCLFFileTyped(shandle_.Handle(), fileName.c_str()));
        fileName_ = fileName;
      }
      void Save(const String &fileName) const {…}


      std::vector<std::uint8_t> ToBuffer() const
      {
        auto sizeNeeded = CVB_CALL_CAPI(GetCLFSize(Handle()));
        std::vector<std::uint8_t> buffer(sizeNeeded);
        CVB_CALL_CAPI_CHECKED(CLFToMemory(shandle_.Handle(), buffer.data(), sizeNeeded));
        return buffer;
      }
      std::vector<std::uint8_t> ToBuffer() const {…}


      String FileName() const
      {
        return fileName_;
      }
      String FileName() const {…}


      ClassifierModelInfoCollection Models() const
      {
        return models_;
      }
      ClassifierModelInfoCollection Models() const {…}


      Rect<int> Extent() const noexcept
      {
        return clfExtent_;
      }
      Rect<int> Extent() const noexcept {…}


      std::chrono::system_clock::time_point CreationDate() const noexcept
      {
        return creationDate_;
      }
      std::chrono::system_clock::time_point CreationDate() const noexcept {…}


      bool IsMinos16BitClassifier() const
      {
        return CVB_CALL_CAPI(IsOldCLF(shandle_.Handle()) ? true : false);
      }
      bool IsMinos16BitClassifier() const {…}


      int ContrastTrigger() const
      {
        CExports::cvbval_t retval = 0;
        CVB_CALL_CAPI_CHECKED(GetCLFTrigger(shandle_.Handle(), retval));
        return static_cast<int>(retval);
      }
      int ContrastTrigger() const {…}


      void SetContrastTrigger(int trigger)
      {
        CVB_CALL_CAPI_CHECKED(SetCLFTrigger(shandle_.Handle(), static_cast<CExports::cvbval_t>(trigger)));
      }
      void SetContrastTrigger(int trigger) {…}


      double Threshold() const
      {
        double retval = std::numeric_limits<double>::quiet_NaN();
        CVB_CALL_CAPI_CHECKED(GetCLFThreshold(shandle_.Handle(), retval));
        return retval;
      }
      double Threshold() const {…}


      void SetThreshold(double threshold)
      {
        CVB_CALL_CAPI_CHECKED(SetCLFThreshold(shandle_.Handle(), threshold));
      }
      void SetThreshold(double threshold) {…}


      QualityFeedback QualityMeasure() const
      {
        CExports::QualityMeasureMethod retval = CExports::Quality_Unnormalized;
        CVB_CALL_CAPI_CHECKED(GetCLFQualityType(shandle_.Handle(), retval));
        return static_cast<QualityFeedback>(retval);
      }
      QualityFeedback QualityMeasure() const {…}


      void SetQualityMeasure(QualityFeedback quality)
      {
        CVB_CALL_CAPI_CHECKED(
            SetCLFQualityType(shandle_.Handle(), static_cast<CExports::QualityMeasureMethod>(quality)));
      }
      void SetQualityMeasure(QualityFeedback quality) {…}


      String TrainingSetName() const
      {
        const Char *name = nullptr;
        CVB_CALL_CAPI(CLFMTSNameTyped(shandle_.Handle(), name));
        return (name != nullptr) ? String(name) : String();
      }
      String TrainingSetName() const {…}


      class LearnParameters LearnParameters() const
      {
        CExports::TLearnControlStructure params{0};
        CVB_CALL_CAPI_CHECKED(GetCLFLCS(shandle_.Handle(), params));
        return Cvb::Minos::LearnParameters(params.Param6, params.Param5, params.Param4, params.Param3, params.Param1,
                                           params.Param2 / 1000.0);
      }
      class LearnParameters LearnParameters() const {…}


      String Comment() const
      {
        const Char *comment = nullptr;
        CVB_CALL_CAPI(CLFCommentTyped(shandle_.Handle(), comment));
        return (comment != nullptr) ? String(comment) : String();
      }
      String Comment() const {…}


      void SetComment(String comment)
      {
        CVB_CALL_CAPI_CHECKED(SetCLFCommentTyped(shandle_.Handle(), comment.c_str()));
      }
      void SetComment(String comment) {…}


      std::unique_ptr<Classifier> Transform(Matrix2D transformation)
      {
        return Internal::DoBoolCallObjectOut<Classifier>([&](void *&resclas) {
          /* Note: the binary compatibility between Matrix and TMatrix is guaranteed, therefore the cast below is legal.
           */
          return CVB_CALL_CAPI(
              CLFTransform(Handle(), reinterpret_cast<const CExports::TMatrix &>(transformation), resclas));
        });
      }
      std::unique_ptr<Classifier> Transform(Matrix2D transformation) {…}


      std::unique_ptr<Classifier> SetGlobalAdvanceVector(Point2D<int> advance)
      {
        return Internal::DoBoolCallObjectOut<Classifier>([&](void *&resclas) {
          return CVB_CALL_CAPI(CLFSetGlobalAdvance(Handle(), static_cast<CExports::cvbdim_t>(advance.X()),
                                                   static_cast<CExports::cvbdim_t>(advance.Y()), resclas));
        });
      }
      std::unique_ptr<Classifier> SetGlobalAdvanceVector(Point2D<int> advance) {…}


      String Read(const ImagePlane &plane, ReadMode mode, Area2D startAOI, Area2D ocrAOI, SearchResult &startOrStop,
                  double density = 1.0)
      {
        double quality = 0.0, xPos = 0.0, yPos = 0.0, dX = 0.0, dY = 0.0;
        Char *pstr                   = nullptr;
        CExports::cvbval_t charCount = 0;
        std::vector<Char> token(MaxSearch() + 1, 0);
 
        /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the casts below are legal.
         */
        switch (mode)
        {
          case ReadMode::ReturnFirstPosition:
            CVB_CALL_CAPI_CHECKED(ReadTokenFirstTyped(
                Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                reinterpret_cast<const CExports::TArea &>(startAOI), reinterpret_cast<const CExports::TArea &>(ocrAOI),
                MaxSearch(), quality, xPos, yPos, dX, dY, pstr, charCount, token.data()));
            break;
          case ReadMode::ReturnLastPosition:
            CVB_CALL_CAPI_CHECKED(ReadTokenTyped(
                Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                reinterpret_cast<const CExports::TArea &>(startAOI), reinterpret_cast<const CExports::TArea &>(ocrAOI),
                MaxSearch(), quality, xPos, yPos, dX, dY, pstr, charCount, token.data()));
            break;
        }
 
        startOrStop = SearchResult(pstr, quality, Point2D<double>(xPos, yPos), Point2D<double>(dX, dY));
        return String(token.data());
      }
      String Read(const ImagePlane &plane, ReadMode mode, Area2D startAOI, Area2D ocrAOI, SearchResult &startOrStop, {…}


      std::vector<SearchResult> Read(const ImagePlane &plane, Area2D startAOI, Area2D ocrAOI, double density = 1.0)
      {
        CExports::RESULTS hSearchResults = nullptr;
        CVB_CALL_CAPI_CHECKED(
            ReadCharacterList(Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                              reinterpret_cast<const CExports::TArea &>(startAOI),
                              reinterpret_cast<const CExports::TArea &>(ocrAOI), MaxSearch(), hSearchResults));
        ReleaseObjectGuard hSearchResHolder(hSearchResults);
        return Private::SearchResultsToArray(hSearchResults);
      }
      std::vector<SearchResult> Read(const ImagePlane &plane, Area2D startAOI, Area2D ocrAOI, double density = 1.0) {…}


      SearchResult Search(const ImagePlane &plane, SearchMode mode, Area2D aoi, double density = 1.0)
      {
        double quality = 0.0, xPos = 0.0, yPos = 0.0, dX = 0.0, dY = 0.0;
        Char *pstr = nullptr;
 
        /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the casts below are legal.
         */
        switch (mode)
        {
          case SearchMode::FindFirst:
            CVB_CALL_CAPI_CHECKED(
                SearchFirstTyped(Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                                 reinterpret_cast<const CExports::TArea &>(aoi), quality, xPos, yPos, dX, dY, pstr));
            break;
          case SearchMode::FindBest:
            CVB_CALL_CAPI_CHECKED(
                SearchOptimumTyped(Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                                   reinterpret_cast<const CExports::TArea &>(aoi), quality, xPos, yPos, dX, dY, pstr));
            break;
          case SearchMode::FindBestSubPixel:
            CVB_CALL_CAPI_CHECKED(SubpixelOptimumTyped(
                Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                reinterpret_cast<const CExports::TArea &>(aoi), quality, xPos, yPos, dX, dY, pstr));
            break;
        }
 
        return SearchResult((pstr != nullptr) ? String(pstr) : String(), quality, Point2D<double>(xPos, yPos),
                            Point2D<double>(dX, dY));
      }
      SearchResult Search(const ImagePlane &plane, SearchMode mode, Area2D aoi, double density = 1.0) {…}


      SearchResult Search(const ImagePlane &plane, SearchMode mode, double density = 1.0)
      {
        return Search(plane, mode, Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())), density);
      }
      SearchResult Search(const ImagePlane &plane, SearchMode mode, double density = 1.0) {…}


      std::vector<SearchResult> SearchAll(const ImagePlane &plane, int locality, Area2D aoi, double density = 1.0)
      {
        /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the cast below is legal. */
        CExports::RESULTS hSearchResults = nullptr;
        CVB_CALL_CAPI_CHECKED(
            SearchAll(Handle(), plane.Parent().Handle(), plane.Plane(), static_cast<int>(density * 1000.0),
                      reinterpret_cast<const CExports::TArea &>(aoi), locality, MaxSearch(), hSearchResults));
        ReleaseObjectGuard hSearchResHolder(hSearchResults);
        return Private::SearchResultsToArray(hSearchResults);
      }
      std::vector<SearchResult> SearchAll(const ImagePlane &plane, int locality, Area2D aoi, double density = 1.0) {…}


      std::vector<SearchResult> SearchAll(const ImagePlane &plane, int locality, double density = 1.0)
      {
        return SearchAll(plane, locality, Area2D(static_cast<Rect<double>>(plane.Parent().Bounds())), density);
      }
      std::vector<SearchResult> SearchAll(const ImagePlane &plane, int locality, double density = 1.0) {…}
 
    private:
      SharedHandleGuard<Classifier> shandle_;
      mutable String fileName_;
      Rect<int> clfExtent_;
      std::chrono::system_clock::time_point creationDate_;
      ClassifierModelInfoCollection models_;
    }; /* class Classifier */
    class Classifier {…};

    using ClassifierPtr = std::shared_ptr<Classifier>;
 
  } /* namespace Minos */
  CVB_END_INLINE_NS
} /* namespace Cvb */