training_set.hpp

#pragma once
 
#include "../_cexports/c_minos.h"
 
#include "../global.hpp"
#include "../image.hpp"
#include "../matrix_2d.hpp"
#include "../point_2d.hpp"
#include "../rect.hpp"
#include "../area_2d.hpp"
 
#include "search_result.hpp"
 
#include <vector>
#include <climits>
#include <utility>
#include <memory>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Minos
  {
    class TrainingSet;
  }
 
  template <>
  inline HandleGuard<Minos::TrainingSet>::HandleGuard(void *handle) noexcept
      : HandleGuard<Minos::TrainingSet>(handle, [](void *h) { CVB_CALL_CAPI(ReleaseObject(h)); })
  {
  }

  namespace Minos
  {
 
    // forward declarations
    class ImageInfo;
    class ModelInfo;


    class InstanceInfo
    {
      friend class InstanceInfoCollectionGeneric;
      friend class ImageInstanceInfoCollection;
      struct PrivateTag
      {
      };
 
    public:
      InstanceInfo(const InstanceInfo &other)            = delete;
      InstanceInfo &operator=(const InstanceInfo &other) = delete;
      InstanceInfo(InstanceInfo &&other)                 = delete;
      InstanceInfo &operator=(InstanceInfo &&other)      = delete;
      virtual ~InstanceInfo()                            = default;
 
      InstanceInfo(const SharedHandleGuard<TrainingSet> &sguardTrSet, CExports::MTSINSTANCE nativeHandle, PrivateTag)
          : sguardTrSet_(sguardTrSet)
          , nativeHandle_(nativeHandle)
      {
      }


      int Index() const
      {
        return static_cast<int>(CVB_CALL_CAPI(InstanceIndex(Handle())));
      }
      int Index() const {…}


      std::unique_ptr<class Image> Image() const
      {
        return Internal::DoHandleCallObjectOut<class Image>(CVB_CALL_CAPI(CreateImageFromInstance(Handle())));
      }
      std::unique_ptr<class Image> Image() const {…}


#if 0
  double GetCorrelation () const
  {
  }
#endif


      std::unique_ptr<ImageInfo> SourceImage() const;


      Point2D<double> Location() const
      {
        double dX = CVB_CALL_CAPI(InstanceX(Handle()));
        double dY = CVB_CALL_CAPI(InstanceY(Handle()));
        return Point2D<double>(dX, dY);
      }
      Point2D<double> Location() const {…}


      std::unique_ptr<ModelInfo> Model() const;


      void *Handle() const noexcept
      {
        return nativeHandle_;
      }
      void *Handle() const noexcept {…}
 
    private:
      SharedHandleGuard<TrainingSet> sguardTrSet_;
      CExports::MTSINSTANCE nativeHandle_;
    }; /* class InstanceInfo */
    class InstanceInfo {…};


    inline bool operator==(const InstanceInfo &lhs, const InstanceInfo &rhs) noexcept
    {
      return (lhs.Handle() == rhs.Handle());
    }
    inline bool operator==(const InstanceInfo &lhs, const InstanceInfo &rhs) noexcept {…}


    inline bool operator!=(const InstanceInfo &lhs, const InstanceInfo &rhs) noexcept
    {
      return (!(lhs == rhs));
    }
    inline bool operator!=(const InstanceInfo &lhs, const InstanceInfo &rhs) noexcept {…}
 
    namespace Private
    {
      template <class T>
      auto ReadInfos(const T &collection) -> std::vector<decltype(collection.ReadInfo(0))>
      {
        auto count = collection.Count();
        std::vector<decltype(collection.ReadInfo(0))> info;
        for (decltype(count) i = 0; i < count; ++i)
        {
          info.push_back(collection.ReadInfo(i));
        }
 
        return info;
      }
 
      template <class Tcol, class Tobj>
      int IndexOf(const Tcol &collection, const Tobj &obj)
      {
        auto count = collection.Count();
        for (decltype(count) i = 0; i < count; ++i)
        {
          auto readInfo = collection.ReadInfo(i);
          if (*readInfo == obj)
          {
            return i;
          }
        }
        return -1;
      }
    } /* namespace Private */


    class InstanceInfoCollectionGeneric
    {
    public:
      explicit InstanceInfoCollectionGeneric(const SharedHandleGuard<TrainingSet> &sguard)
          : shandle_(sguard)
      {
      }
 
      InstanceInfoCollectionGeneric(const InstanceInfoCollectionGeneric &other)            = delete;
      InstanceInfoCollectionGeneric &operator=(const InstanceInfoCollectionGeneric &other) = delete;
      InstanceInfoCollectionGeneric(InstanceInfoCollectionGeneric &&other)                 = delete;
      InstanceInfoCollectionGeneric &operator=(InstanceInfoCollectionGeneric &&other)      = delete;
      virtual ~InstanceInfoCollectionGeneric()                                             = default;


      int Count() const
      {
        return GetCount();
      }
      int Count() const {…}


      std::unique_ptr<InstanceInfo> ReadInfo(int index) const
      {
        auto instHandle = GetInstanceNativeHandle(index);
        if (instHandle == nullptr)
        {
          Utilities::SystemInfo::ThrowLastError();
        }
        return std::make_unique<InstanceInfo>(shandle_, instHandle, InstanceInfo::PrivateTag{});
      }
      std::unique_ptr<InstanceInfo> ReadInfo(int index) const {…}


      std::vector<std::unique_ptr<InstanceInfo>> ReadInfos() const
      {
        return Private::ReadInfos(*this);
      }
      std::vector<std::unique_ptr<InstanceInfo>> ReadInfos() const {…}


      int IndexOf(const InstanceInfo &obj) const
      {
        return Private::IndexOf(*this, obj);
      }
      int IndexOf(const InstanceInfo &obj) const {…}


      bool Remove(const InstanceInfo &instance)
      {
        auto count = Count();
        for (decltype(count) i = 0; i < count; ++i)
        {
          if (*ReadInfo(i) == instance)
          {
            CVB_CALL_CAPI_CHECKED(RemoveMTSInstance(instance.Handle()));
            return true;
          }
        }
        return false;
      }
      bool Remove(const InstanceInfo &instance) {…}


      bool RemoveAt(int index)
      {
        return Remove(*ReadInfo(index));
      }
      bool RemoveAt(int index) {…}
 
    protected:
      virtual int GetCount() const                                           = 0;
      virtual CExports::MTSINSTANCE GetInstanceNativeHandle(int index) const = 0;
 
    protected:
      SharedHandleGuard<TrainingSet> shandle_;  // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
    }; /* class InstanceInfoCollectionGeneric */
    class InstanceInfoCollectionGeneric {…};


    class InstanceInfoCollection : public InstanceInfoCollectionGeneric
    {
    public:
      explicit InstanceInfoCollection(const SharedHandleGuard<TrainingSet> &sguard)
          : InstanceInfoCollectionGeneric(sguard)
          , collectionParent_(sguard.Handle())
      {
      }
 
    protected:
      int GetCount() const override
      {
        return static_cast<int>(CVB_CALL_CAPI(NumMTSInstances(collectionParent_)));
      }
 
      CExports::MTSINSTANCE GetInstanceNativeHandle(int index) const override
      {
        return CVB_CALL_CAPI(MTSInstance(collectionParent_, index));
      }
 
    private:
      CExports::MTSINSTANCE collectionParent_;
    }; /* class InstanceInfoCollection */
    class InstanceInfoCollection : public InstanceInfoCollectionGeneric {…};


    class ImageInstanceInfoCollection : public InstanceInfoCollectionGeneric
    {
    public:
      ImageInstanceInfoCollection(const SharedHandleGuard<TrainingSet> &sguard, CExports::MTSIMAGE collectionParent)
          : InstanceInfoCollectionGeneric(sguard)
          , collectionParent_(collectionParent)
      {
      }


      std::unique_ptr<InstanceInfo> Add(const String &name, bool askForce, Point2D<double> location)
      {
        double dX                      = location.X();
        double dY                      = location.Y();
        CExports::MTSINSTANCE instance = nullptr;
        CVB_CALL_CAPI_CHECKED(NewMTSInstanceTyped(collectionParent_, name.c_str(), askForce, dX, dY, instance));
        if (instance == nullptr)
        {
          throw std::runtime_error("failed to add sample to the class");
        }
        return std::make_unique<InstanceInfo>(shandle_, instance, InstanceInfo::PrivateTag{});
      }
      std::unique_ptr<InstanceInfo> Add(const String &name, bool askForce, Point2D<double> location) {…}
 
    protected:
      int GetCount() const override
      {
        return static_cast<int>(CVB_CALL_CAPI(NumMTSImageInstances(collectionParent_)));
      }
 
      CExports::MTSINSTANCE GetInstanceNativeHandle(int index) const override
      {
        return CVB_CALL_CAPI(MTSImageInstance(collectionParent_, index));
      }
 
    private:
      CExports::MTSIMAGE collectionParent_;
    }; /* class ImageInstanceInfoCollection */
    class ImageInstanceInfoCollection : public InstanceInfoCollectionGeneric {…};


    class ModelInstanceInfoCollection : public InstanceInfoCollectionGeneric
    {
    public:
      ModelInstanceInfoCollection(const SharedHandleGuard<TrainingSet> &sguard, CExports::MTSMODEL collectionParent)
          : InstanceInfoCollectionGeneric(sguard)
          , collectionParent_(collectionParent)
      {
      }
 
    protected:
      int GetCount() const override
      {
        return static_cast<int>(CVB_CALL_CAPI(NumMTSModelInstances(collectionParent_)));
      }
 
      CExports::MTSINSTANCE GetInstanceNativeHandle(int index) const override
      {
        return CVB_CALL_CAPI(MTSModelInstance(collectionParent_, index));
      }
 
    private:
      CExports::MTSMODEL collectionParent_;
    }; /* class ModelInstanceInfoCollection */
    class ModelInstanceInfoCollection : public InstanceInfoCollectionGeneric {…};


    class ImageInfo
    {
      friend class InstanceInfo;
      friend class ImageInfoCollection;
 
      struct PrivateTag
      {
      };
 
    public:
      ImageInfo(const ImageInfo &other)            = delete;
      ImageInfo &operator=(const ImageInfo &other) = delete;
      ImageInfo(ImageInfo &&other)                 = delete;
      ImageInfo &operator=(ImageInfo &&other)      = delete;
      virtual ~ImageInfo()                         = default;
 
      ImageInfo(const SharedHandleGuard<TrainingSet> &sguardTrSet, int index, PrivateTag)
          : sguardTrSet_(sguardTrSet)
          , nativeHandle_(CVB_CALL_CAPI(MTSImage(sguardTrSet.Handle(), index)))
          , instances_(sguardTrSet_, nativeHandle_)
      {
        if (nativeHandle_ == nullptr)
        {
          Utilities::SystemInfo::ThrowLastError();
        }
      }
 
    public:

      int Index() const
      {
        return static_cast<int>(CVB_CALL_CAPI(MTSImageIndex(Handle())));
      }
      int Index() const {…}


      std::unique_ptr<class Image> Image() const
      {
        return Internal::DoBoolCallObjectOut<class Image>([&](void *&resimg) {
          resimg = CVB_CALL_CAPI(GetImageFromImage(Handle()));
          return CVB_CALL_CAPI(ShareObject(resimg));
        });
      }
      std::unique_ptr<class Image> Image() const {…}


      void TransformImageAndInstances(Matrix2D matrix)
      {
        /* Note: the binary compatibility between Matrix and TMatrix is guaranteed, therefore the cast below is legal.
         */
        CVB_CALL_CAPI_CHECKED(TransformMTSImage(Handle(), reinterpret_cast<const CExports::TMatrix &>(matrix)));
      }
      void TransformImageAndInstances(Matrix2D matrix) {…}


      std::vector<SearchResult> CheckConsistency(double threshold, double density = 1.0)
      {
        CExports::RESULTS hSearchResults = nullptr;
        CVB_CALL_CAPI_CHECKED(
            MTSImageCheck(Handle(), threshold, static_cast<int>(density * 1000.0), nullptr, nullptr, hSearchResults));
        ReleaseObjectGuard hSearchResHolder(hSearchResults);
        return Private::SearchResultsToArray(hSearchResults);
      }
      std::vector<SearchResult> CheckConsistency(double threshold, double density = 1.0) {…}


      ImageInstanceInfoCollection &Instances()
      {
        return instances_;
      }
      ImageInstanceInfoCollection &Instances() {…}


      void *Handle() const noexcept
      {
        return nativeHandle_;
      }
      void *Handle() const noexcept {…}
 
    private:
      SharedHandleGuard<TrainingSet> sguardTrSet_;
      CExports::MTSIMAGE nativeHandle_;
      ImageInstanceInfoCollection instances_;
    }; /* class ImageInfo*/
    class ImageInfo {…};


    inline bool operator==(const ImageInfo &lhs, const ImageInfo &rhs) noexcept
    {
      return (lhs.Handle() == rhs.Handle());
    }
    inline bool operator==(const ImageInfo &lhs, const ImageInfo &rhs) noexcept {…}


    inline bool operator!=(const ImageInfo &lhs, const ImageInfo &rhs) noexcept
    {
      return (!(lhs == rhs));
    }
    inline bool operator!=(const ImageInfo &lhs, const ImageInfo &rhs) noexcept {…}
 
    std::unique_ptr<ImageInfo> InstanceInfo::SourceImage() const
    {
      auto imageIndex = CVB_CALL_CAPI(GetImageFromInstance(Handle()));
      return std::make_unique<ImageInfo>(sguardTrSet_, CVB_CALL_CAPI(MTSImageIndex(imageIndex)),
                                         ImageInfo::PrivateTag{});
    }
    std::unique_ptr<ImageInfo> InstanceInfo::SourceImage() const {…}


    class ImageInfoCollection
    {
    public:
      explicit ImageInfoCollection(const SharedHandleGuard<TrainingSet> &sguard)
          : shandle_(sguard)
      {
      }
 
      ImageInfoCollection(const ImageInfoCollection &other)            = delete;
      ImageInfoCollection &operator=(const ImageInfoCollection &other) = delete;
      ImageInfoCollection(ImageInfoCollection &&other)                 = delete;
      ImageInfoCollection &operator=(ImageInfoCollection &&other)      = delete;
      virtual ~ImageInfoCollection()                                   = default;


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


      std::unique_ptr<ImageInfo> ReadInfo(int index) const
      {
        return std::make_unique<ImageInfo>(shandle_, index, ImageInfo::PrivateTag{});
      }
      std::unique_ptr<ImageInfo> ReadInfo(int index) const {…}


      std::vector<std::unique_ptr<ImageInfo>> ReadInfos() const
      {
        return Private::ReadInfos(*this);
      }
      std::vector<std::unique_ptr<ImageInfo>> ReadInfos() const {…}


      int IndexOf(const ImageInfo &obj) const
      {
        return Private::IndexOf(*this, obj);
      }
      int IndexOf(const ImageInfo &obj) const {…}


      void Add(const ImagePlane &plane)
      {
        auto h = CVB_CALL_CAPI(NewMTSImageIndex(shandle_.Handle(), plane.Parent().Handle(), plane.Plane()));
        if (h == nullptr)
        {
          Utilities::SystemInfo::ThrowLastError();
        }
      }
      void Add(const ImagePlane &plane) {…}


      bool Remove(const ImageInfo &image)
      {
        auto count = Count();
        for (decltype(count) i = 0; i < count; ++i)
        {
          if (*ReadInfo(i) == image)
          {
            CVB_CALL_CAPI_CHECKED(RemoveMTSImage(image.Handle()));
            return true;
          }
        }
        return false;
      }
      bool Remove(const ImageInfo &image) {…}


      bool RemoveAt(int index)
      {
        return Remove(*ReadInfo(index));
      }
      bool RemoveAt(int index) {…}
 
    private:
      SharedHandleGuard<TrainingSet> shandle_;
    }; /* class ImageInfoCollection */
    class ImageInfoCollection {…};


    class ModelInfo
    {
      friend class InstanceInfo;
      friend class ModelInfoCollection;
      struct PrivateTag
      {
      };
 
    public:
      ModelInfo(const ModelInfo &other)            = delete;
      ModelInfo &operator=(const ModelInfo &other) = delete;
      ModelInfo(ModelInfo &&other)                 = delete;
      ModelInfo &operator=(ModelInfo &&other)      = delete;
      virtual ~ModelInfo()                         = default;
 
      ModelInfo(const SharedHandleGuard<TrainingSet> &sguardTrSet, int index, PrivateTag)
          : sguardTrSet_(sguardTrSet)
          , nativeHandle_(CVB_CALL_CAPI(MTSModel(sguardTrSet.Handle(), index)))
          , instances_(sguardTrSet_, nativeHandle_)
      {
        if (nativeHandle_ == nullptr)
        {
          Utilities::SystemInfo::ThrowLastError();
        }
      }
 
    public:

      int Index() const
      {
        return static_cast<int>(CVB_CALL_CAPI(MTSModelIndex(Handle())));
      }
      int Index() const {…}


      std::unique_ptr<class Image> Image() const
      {
        return Internal::DoBoolCallObjectOut<class Image>([&](void *&resimg) {
          resimg = CVB_CALL_CAPI(GetImageFromModel(Handle()));
          return CVB_CALL_CAPI(ShareObject(resimg));
        });
      }
      std::unique_ptr<class Image> Image() const {…}


      String Name() const
      {
        const Char *name = nullptr;
        CVB_CALL_CAPI(GetModelNameTyped(Handle(), name));
        return (name != nullptr) ? String(name) : String();
      }
      String Name() const {…}


      void SetName(const String &name)
      {
        CVB_CALL_CAPI_CHECKED(SetModelNameTyped(Handle(), name.c_str()));
      }
      void SetName(const String &name) {…}


      Point2D<double> AdvanceVector() const
      {
        double advX = std::numeric_limits<double>::quiet_NaN(), advY = std::numeric_limits<double>::quiet_NaN();
        CVB_CALL_CAPI_CHECKED(GetModelAdvance(Handle(), advX, advY));
        return Point2D<double>(advX, advY);
      }
      Point2D<double> AdvanceVector() const {…}


      void SetAdvanceVector(Point2D<double> advanceVector)
      {
        CVB_CALL_CAPI_CHECKED(SetModelAdvance(Handle(), advanceVector.X(), advanceVector.Y()));
      }
      void SetAdvanceVector(Point2D<double> advanceVector) {…}


      Rect<int> FeatureWindow() const
      {
        /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the cast below is legal. */
        Area2D featureWindowNative;
        CVB_CALL_CAPI_CHECKED(GetFeatureWindow(Handle(), reinterpret_cast<CExports::TArea &>(featureWindowNative)));
        return Round(Rect<double>(featureWindowNative.P0().X(), featureWindowNative.P0().Y(),
                                  featureWindowNative.P1().X(), featureWindowNative.P2().Y()));
      }
      Rect<int> FeatureWindow() const {…}


      void SetFeatureWindow(Rect<int> featureWindow)
      {
        /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the cast below is legal. */
        auto featureWindowNative = Area2D(static_cast<Rect<double>>(featureWindow));
        CVB_CALL_CAPI_CHECKED(SetFeatureWindow(Handle(), reinterpret_cast<CExports::TArea &>(featureWindowNative)));
      }
      void SetFeatureWindow(Rect<int> featureWindow) {…}


      Point2D<double> Origin() const
      {
        return Image()->CoordinateSystem().Translation();
      }
      Point2D<double> Origin() const {…}


      void SetOrigin(Point2D<double> origin)
      {
        auto cs                     = Image()->CoordinateSystem();
        cs.Translation()            = origin;
        Image()->CoordinateSystem() = cs;
        CVB_CALL_CAPI_CHECKED(TranslateModelOrigin(Handle()));
      }
      void SetOrigin(Point2D<double> origin) {…}


      const ModelInstanceInfoCollection &Instances() const
      {
        return instances_;
      }
      const ModelInstanceInfoCollection &Instances() const {…}


      std::vector<SearchResult> CheckConsistency(const ImageInfo &trainingSetImage, double threshold,
                                                 double density = 1.0)
      {
        CExports::RESULTS hSearchResults = nullptr;
        CVB_CALL_CAPI_CHECKED(MTSModelImageCheck(Handle(), trainingSetImage.Handle(), threshold,
                                                 static_cast<int>(density * 1000.0), nullptr, nullptr, hSearchResults));
        ReleaseObjectGuard hSearchResHolder(hSearchResults);
        return Private::SearchResultsToArray(hSearchResults);
      }
      std::vector<SearchResult> CheckConsistency(const ImageInfo &trainingSetImage, double threshold, {…}


      std::vector<SearchResult> CheckConsistency(double threshold, double density = 1.0)
      {
        CExports::RESULTS hSearchResults = nullptr;
        CVB_CALL_CAPI_CHECKED(
            MTSModelCheck(Handle(), threshold, static_cast<int>(density * 1000.0), nullptr, nullptr, hSearchResults));
        ReleaseObjectGuard hSearchResHolder(hSearchResults);
        return Private::SearchResultsToArray(hSearchResults);
      }
      std::vector<SearchResult> CheckConsistency(double threshold, double density = 1.0) {…}


      Rect<int> GetMaxFeatureWindow() const
      {
        int left = INT_MAX, top = INT_MAX, right = INT_MAX, bottom = INT_MAX;
 
        for (auto &&i : instances_.ReadInfos())
        {
          auto loc_x = static_cast<int>(std::lround(i->Location().X()));
          if (loc_x < left)
          {
            left = loc_x;
          }
          auto loc_y = static_cast<int>(std::lround(i->Location().Y()));
          if (loc_y < top)
          {
            top = loc_y;
          }
          auto srcimg_w = i->SourceImage()->Image()->Width();
          if (srcimg_w - loc_x < right)
          {
            right = srcimg_w - loc_x - 1;
          }
          auto srcimg_h = i->SourceImage()->Image()->Height();
          if (srcimg_h - loc_y < bottom)
          {
            bottom = srcimg_h - loc_y - 1;
          }
        }
        left = -left;
        top  = -top;
 
        return Rect<int>(left, top, right, bottom);
      }
      Rect<int> GetMaxFeatureWindow() const {…}


      Rect<int> GetExtractableArea(const ImageInfo &image) const
      {
        int left   = -FeatureWindow().Left();
        int top    = -FeatureWindow().Top();
        int right  = image.Image()->Width() - FeatureWindow().Right() - 1;
        int bottom = image.Image()->Height() - FeatureWindow().Bottom() - 1;
        return Rect<int>(left, top, right, bottom);
      }
      Rect<int> GetExtractableArea(const ImageInfo &image) const {…}


      void *Handle() const noexcept
      {
        return nativeHandle_;
      }
      void *Handle() const noexcept {…}
 
    private:
      SharedHandleGuard<TrainingSet> sguardTrSet_;
      CExports::MTSMODEL nativeHandle_;
      ModelInstanceInfoCollection instances_;
    }; /* class ModelInfo */
    class ModelInfo {…};


    inline bool operator==(const ModelInfo &lhs, const ModelInfo &rhs) noexcept
    {
      return (lhs.Handle() == rhs.Handle());
    }
    inline bool operator==(const ModelInfo &lhs, const ModelInfo &rhs) noexcept {…}


    inline bool operator!=(const ModelInfo &lhs, const ModelInfo &rhs) noexcept
    {
      return (!(lhs == rhs));
    }
    inline bool operator!=(const ModelInfo &lhs, const ModelInfo &rhs) noexcept {…}
 
    std::unique_ptr<ModelInfo> InstanceInfo::Model() const
    {
      auto modelIndex = CVB_CALL_CAPI(GetModelFromInstance(nativeHandle_));
      return std::make_unique<ModelInfo>(sguardTrSet_, CVB_CALL_CAPI(MTSModelIndex(modelIndex)),
                                         ModelInfo::PrivateTag{});
    }
    std::unique_ptr<ModelInfo> InstanceInfo::Model() const {…}


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


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


      std::unique_ptr<ModelInfo> ReadInfo(int index) const
      {
        return std::make_unique<ModelInfo>(shandle_, index, ModelInfo::PrivateTag{});
      }
      std::unique_ptr<ModelInfo> ReadInfo(int index) const {…}


      std::vector<std::unique_ptr<ModelInfo>> ReadInfos() const
      {
        return Private::ReadInfos(*this);
      }
      std::vector<std::unique_ptr<ModelInfo>> ReadInfos() const {…}


      int IndexOf(const ModelInfo &obj) const
      {
        return Private::IndexOf(*this, obj);
      }
      int IndexOf(const ModelInfo &obj) const {…}


      bool Contains(const String &name)
      {
        auto count = Count();
        for (decltype(count) i = 0; i < count; ++i)
        {
          if (ReadInfo(i)->Name() == name)
          {
            return true;
          }
        }
        return false;
      }
      bool Contains(const String &name) {…}


      void Add(const ImageInfo &image, const String &name, Point2D<double> location, Rect<int> featureWindow)
      {
        /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the cast below is legal. */
        auto featureWindowNative = Area2D(static_cast<Rect<double>>(featureWindow));
        auto instance = CVB_CALL_CAPI(NewMTSModelTyped(image.Handle(), name.c_str(), location.X(), location.Y(),
                                                       reinterpret_cast<CExports::TArea &>(featureWindowNative)));
        if (instance == nullptr)
        {
          Utilities::SystemInfo::ThrowLastError();
        }
      }
      void Add(const ImageInfo &image, const String &name, Point2D<double> location, Rect<int> featureWindow) {…}


      bool Remove(const ModelInfo &model)
      {
        auto count = Count();
        for (decltype(count) i = 0; i < count; ++i)
        {
          if (*ReadInfo(i) == model)
          {
            CVB_CALL_CAPI_CHECKED(RemoveMTSModel(model.Handle()));
            return true;
          }
        }
        return false;
      }
      bool Remove(const ModelInfo &model) {…}


      bool RemoveAt(int index)
      {
        return Remove(*ReadInfo(index));
      }
      bool RemoveAt(int index) {…}


      void SetGlobalAdvanceVector(Point2D<double> vec)
      {
        CVB_CALL_CAPI_CHECKED(SetMTSGlobalAdvance(shandle_.Handle(), true, vec.X(), vec.Y()));
      }
      void SetGlobalAdvanceVector(Point2D<double> vec) {…}
 
    private:
      SharedHandleGuard<TrainingSet> shandle_;
    }; /* class ModelInfoCollection */
    class ModelInfoCollection {…};


    class TrainingSet
    {
    private:
      // Internal helper constructor version
      explicit TrainingSet(HandleGuard<TrainingSet> &&guard, const String &srcFileName = String())
          : shandle_(std::move(guard))
          , fileName_(srcFileName)
          , instances_(shandle_)
          , images_(shandle_)
          , models_(shandle_)
      {
      }
 
      // Helper to create an empty training set
      static CExports::MTS CreateInternal()
      {
        CExports::MTS mts = CVB_CALL_CAPI(CreateMTS(3, 0.6));
        if (mts == nullptr)
        {
          Utilities::SystemInfo::ThrowLastError();
        }
        return mts;
      }
 
      // Helper to load a training set from file
      static CExports::MTS LoadInternal(const String &fileName)
      {
        CExports::MTS mts = nullptr;
 
        CVB_CALL_CAPI_CHECKED(LoadMTSFileTyped(fileName.c_str(), mts));
        return mts;
      }
 
    public:

      TrainingSet()
          : TrainingSet(HandleGuard<TrainingSet>(CreateInternal()))
      {
      }
      TrainingSet() {…}


      explicit TrainingSet(const String &fileName)
          : TrainingSet(HandleGuard<TrainingSet>(LoadInternal(fileName)), fileName)
      {
      }
      explicit TrainingSet(const String &fileName) {…}
 
      TrainingSet(const TrainingSet &other)            = delete;
      TrainingSet &operator=(const TrainingSet &other) = delete;
      TrainingSet(TrainingSet &&other)                 = delete;
      TrainingSet &operator=(TrainingSet &&other)      = delete;
      ~TrainingSet()                                   = default;
 
    public:

      static std::unique_ptr<TrainingSet> Load(const String &fileName)
      {
        return std::make_unique<TrainingSet>(fileName);
      }
      static std::unique_ptr<TrainingSet> Load(const String &fileName) {…}


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


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


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


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


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


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


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


      std::vector<SearchResult> CheckConsistency(double threshold, double density = 1.0)
      {
        CExports::RESULTS hSearchResults = nullptr;
        CVB_CALL_CAPI_CHECKED(MTSConsistencyCheck(Handle(), threshold, static_cast<int>(density * 1000.0), nullptr,
                                                  nullptr, hSearchResults));
        ReleaseObjectGuard hSearchResHolder(hSearchResults);
        return Private::SearchResultsToArray(hSearchResults);
      }
      std::vector<SearchResult> CheckConsistency(double threshold, double density = 1.0) {…}


      int ClassCount() const
      {
        return static_cast<int>(CVB_CALL_CAPI(NumMTSClasses(Handle())));
      }
      int ClassCount() const {…}


      InstanceInfoCollection &Instances()
      {
        return instances_;
      }
      InstanceInfoCollection &Instances() {…}


      int InstancesTotal() const
      {
        return instances_.Count();
      }
      int InstancesTotal() const {…}


      ImageInfoCollection &Images()
      {
        return images_;
      }
      ImageInfoCollection &Images() {…}


      ModelInfoCollection &Models()
      {
        return models_;
      }
      ModelInfoCollection &Models() {…}


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


      bool IsModified() const
      {
        CExports::cvbbool_t retval = false;
        CVB_CALL_CAPI_CHECKED(GetMTSModified(Handle(), retval));
        return retval != 0;
      }
      bool IsModified() const {…}


      void SetIsModified(bool isModified)
      {
        CVB_CALL_CAPI_CHECKED(SetMTSModified(Handle(), isModified));
      }
      void SetIsModified(bool isModified) {…}


      Rect<int> Extent() const
      {
        CExports::cvbdim_t left = 0, top = 0, right = 0, bottom = 0;
        CVB_CALL_CAPI_CHECKED(GetMTSExtent(Handle(), left, top, right, bottom));
        return Rect<int>(static_cast<int>(left), static_cast<int>(top), static_cast<int>(right),
                         static_cast<int>(bottom));
      }
      Rect<int> Extent() const {…}


      Rect<int> LastFeatureWindow() const
      {
        Area2D area;
        /* Note: the binary compatibility between Area2D and TArea is guaranteed, therefore the cast below is legal. */
        CVB_CALL_CAPI_CHECKED(GetMTSLastFeatureWnd(Handle(), reinterpret_cast<CExports::TArea &>(area)));
        return Round(Rect<double>(area.P0().X(), area.P0().Y(), area.P1().X(), area.P2().Y()));
      }
      Rect<int> LastFeatureWindow() const {…}


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


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


      double ExpectationRadius() const
      {
        double expectationRadius    = std::numeric_limits<double>::quiet_NaN(),
               correlationThreshold = std::numeric_limits<double>::quiet_NaN();
        CVB_CALL_CAPI_CHECKED(GetMTSCorelParams(Handle(), expectationRadius, correlationThreshold));
        return expectationRadius;
      }
      double ExpectationRadius() const {…}


      void SetExpectationRadius(double expectationRadius)
      {
        CVB_CALL_CAPI_CHECKED(SetMTSCorelParams(Handle(), expectationRadius, CorrelationThreshold()));
      }
      void SetExpectationRadius(double expectationRadius) {…}


      double CorrelationThreshold() const
      {
        double expectationRadius    = std::numeric_limits<double>::quiet_NaN(),
               correlationThreshold = std::numeric_limits<double>::quiet_NaN();
        CVB_CALL_CAPI_CHECKED(GetMTSCorelParams(Handle(), expectationRadius, correlationThreshold));
        return correlationThreshold;
      }
      double CorrelationThreshold() const {…}


      void SetCorrelationThreshold(double correlationThreshold)
      {
        CVB_CALL_CAPI_CHECKED(SetMTSCorelParams(Handle(), ExpectationRadius(), correlationThreshold));
      }
      void SetCorrelationThreshold(double correlationThreshold) {…}
 
    private:
      SharedHandleGuard<TrainingSet> shandle_;
      mutable String fileName_;
      InstanceInfoCollection instances_;
      ImageInfoCollection images_;
      ModelInfoCollection models_;
    }; /* class TrainingSet */
    class TrainingSet {…};

    using TrainingSetPtr = std::shared_ptr<TrainingSet>;
 
  } /* namespace Minos */
  CVB_END_INLINE_NS
} /* namespace Cvb */