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())));
  }
 
 
  std::unique_ptr<class Image> Image () const
  {
    return Internal::DoHandleCallObjectOut<class Image>(CVB_CALL_CAPI(CreateImageFromInstance(Handle())));
  }
 
 
#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);
  }
 
 
  std::unique_ptr<ModelInfo> Model () const;
 
 
  void * Handle() const noexcept
  {
    return nativeHandle_;
  }
 
private:
  SharedHandleGuard<TrainingSet> sguardTrSet_;
  CExports::MTSINSTANCE nativeHandle_;
}; /* 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
{
  return (!(lhs == rhs));
}
 
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 ();
  }
 
 
  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::vector<std::unique_ptr<InstanceInfo>> ReadInfos () const
  {
    return Private::ReadInfos (*this);
  }
 
 
  int IndexOf (const InstanceInfo &obj) const
  {
    return Private::IndexOf (*this, obj);
  }
 
 
  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 RemoveAt (int index)
  {
    return Remove (*ReadInfo (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 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 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{});
  }
 
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 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 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())));
  }
 
 
  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));
    });
  }
 
 
 
  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)));
  }
 
 
  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);
  }
 
 
  ImageInstanceInfoCollection& Instances()
  {
    return instances_;
  }
 
 
  void * Handle() const noexcept
  {
    return nativeHandle_;
  }
 
private:
  SharedHandleGuard<TrainingSet> sguardTrSet_;
  CExports::MTSIMAGE nativeHandle_;
  ImageInstanceInfoCollection instances_;
}; /* 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
{
  return (!(lhs == rhs));
}
 
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{});
}
 
 
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())));
  }
 
 
  std::unique_ptr<ImageInfo> ReadInfo (int index) const
  {
    return std::make_unique<ImageInfo>(shandle_, index, ImageInfo::PrivateTag{});
  }
 
 
  std::vector<std::unique_ptr<ImageInfo>> ReadInfos () const
  {
    return Private::ReadInfos (*this);
  }
 
 
  int IndexOf (const ImageInfo &obj) const
  {
    return Private::IndexOf (*this, obj);
  }
 
 
  void Add (const ImagePlane &plane)
  {
    auto h = CVB_CALL_CAPI (NewMTSImageIndex(shandle_.Handle(), plane.Parent().Handle(), plane.Plane()));
    if (h == nullptr)
    {
      Utilities::SystemInfo::ThrowLastError ();
    }
  }
 
 
  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 RemoveAt (int index)
  {
    return Remove (*ReadInfo (index));
  }
 
private:
  SharedHandleGuard<TrainingSet> shandle_;
}; /* 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())));
  }
 
 
  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));
    });
  }
 
 
  String Name() const
  {
    const Char *name = nullptr;
    CVB_CALL_CAPI (GetModelNameTyped(Handle(), name));
    return (name != nullptr) ? String (name) : String ();
  }
 
 
  void SetName(const String &name)
  {
    CVB_CALL_CAPI_CHECKED (SetModelNameTyped(Handle(), name.c_str()));
  }
 
 
  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);
  }
 
 
  void SetAdvanceVector(Point2D<double> advanceVector)
  {
    CVB_CALL_CAPI_CHECKED (SetModelAdvance (Handle(), advanceVector.X(), advanceVector.Y()));
  }
 
 
  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()));
  }
 
 
  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)));
  }
 
 
  Point2D<double> Origin() const
  {
    return Image()->CoordinateSystem().Translation();
  }
 
 
  void SetOrigin(Point2D<double> origin)
  {
    auto cs = Image()->CoordinateSystem();
    cs.Translation() = origin;
    Image()->CoordinateSystem() = cs;
    CVB_CALL_CAPI_CHECKED (TranslateModelOrigin(Handle()));
  }
 
 
  const ModelInstanceInfoCollection& Instances() const
  {
    return instances_;
  }
 
 
  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 (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);
  }
 
 
  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> 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);
  }
 
 
  void * Handle() const noexcept
  {
    return nativeHandle_;
  }
 
private:
  SharedHandleGuard<TrainingSet> sguardTrSet_;
  CExports::MTSMODEL nativeHandle_;
  ModelInstanceInfoCollection instances_;
}; /* 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
{
  return (!(lhs == rhs));
}
 
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{});
}
 
 
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())));
  }
 
 
  std::unique_ptr<ModelInfo> ReadInfo (int index) const
  {
    return std::make_unique<ModelInfo>(shandle_, index, ModelInfo::PrivateTag{});
  }
 
 
  std::vector<std::unique_ptr<ModelInfo>> ReadInfos () const
  {
    return Private::ReadInfos (*this);
  }
 
 
  int IndexOf (const ModelInfo &obj) const
  {
    return Private::IndexOf (*this, obj);
  }
 
 
  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;
  }
 
 
  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 ();
    }
  }
 
 
  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 RemoveAt (int index)
  {
    return Remove (*ReadInfo (index));
  }
 
 
  void SetGlobalAdvanceVector(Point2D<double> vec)
  {
    CVB_CALL_CAPI_CHECKED(SetMTSGlobalAdvance(shandle_.Handle(), true, vec.X(), vec.Y()));
  }
 
private:
  SharedHandleGuard<TrainingSet> shandle_;
}; /* 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 ()))
  {
  }
 
 
  explicit TrainingSet(const String & fileName)
    : TrainingSet(HandleGuard<TrainingSet>(LoadInternal (fileName)), 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> 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)
    });
  }
 
 
  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 ());
  }
 
 
  void * Handle() const noexcept
  {
    return shandle_.Handle();
  }
 
 
  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)));
  }
 
 
  void Save (const String & fileName) const
  {
    CVB_CALL_CAPI_CHECKED (WriteMTSFileTyped (Handle(), fileName.c_str()));
    fileName_ = fileName;
  }
 
 
  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::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::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);
  }
 
 
  int ClassCount() const
  {
    return static_cast<int> (CVB_CALL_CAPI (NumMTSClasses(Handle())));
  }
 
 
  InstanceInfoCollection& Instances()
  {
    return instances_;
  }
 
 
  int InstancesTotal() const
  {
    return instances_.Count();
  }
 
 
  ImageInfoCollection& Images()
  {
    return images_;
  }
 
 
  ModelInfoCollection& Models()
  {
    return models_;
  }
 
 
  String FileName() const
  {
    return fileName_;
  }
 
 
  bool IsModified() const
  {
    CExports::cvbbool_t retval = false;
    CVB_CALL_CAPI_CHECKED (GetMTSModified(Handle(), retval));
    return retval != 0;
  }
 
 
  void SetIsModified(bool isModified)
  {
    CVB_CALL_CAPI_CHECKED (SetMTSModified(Handle(), 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> 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()));
  }
 
 
  String Comment() const
  {
    const Char *comment = nullptr;
    CVB_CALL_CAPI (MTSCommentTyped(Handle(), comment));
    return (comment != nullptr) ? String (comment) : String ();
  }
 
 
  void SetComment(String comment)
  {
    CVB_CALL_CAPI_CHECKED (SetMTSCommentTyped (Handle(), comment.c_str()));
  }
 
 
  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;
  }
 
 
  void SetExpectationRadius(double expectationRadius)
  {
    CVB_CALL_CAPI_CHECKED (SetMTSCorelParams (Handle(), expectationRadius, CorrelationThreshold()));
  }
 
 
  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;
  }
 
 
  void SetCorrelationThreshold(double correlationThreshold)
  {
    CVB_CALL_CAPI_CHECKED (SetMTSCorelParams (Handle(), ExpectationRadius(), correlationThreshold));
  }
 
private:
  SharedHandleGuard<TrainingSet> shandle_;
  mutable String fileName_;
  InstanceInfoCollection instances_;
  ImageInfoCollection images_;
  ModelInfoCollection models_;
}; /* class TrainingSet */
 
using TrainingSetPtr = std::shared_ptr<TrainingSet>;
 
 
} /* namespace Minos */
CVB_END_INLINE_NS
} /* namespace Cvb */