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
{
public:
  InstanceInfo (const InstanceInfo&) = default;
  InstanceInfo& operator= (const InstanceInfo&) = default;

private:
  InstanceInfo (const SharedHandleGuard<TrainingSet> &sguardTrSet, CExports::MTSINSTANCE nativeHandle)
    : sguardTrSet_(sguardTrSet), nativeHandle_ (nativeHandle)
  { }
  friend class InstanceInfoCollectionGeneric;
  friend class ImageInstanceInfoCollection;

public:

  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


  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);
  }


  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)
    {
      if (collection.ReadInfo (i) == obj)
      {
        return i;
      }
    }
    return -1;
  }
} /* namespace Private */


class InstanceInfoCollectionGeneric
{
public:
  InstanceInfoCollectionGeneric (const SharedHandleGuard<TrainingSet> &sguard)
    : shandle_(sguard)
  {}

  InstanceInfoCollectionGeneric (const InstanceInfoCollectionGeneric&) = default;
  InstanceInfoCollectionGeneric& operator= (const InstanceInfoCollectionGeneric&) = default;

  virtual ~InstanceInfoCollectionGeneric() = default;


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


  InstanceInfo ReadInfo (int index) const
  {
    auto instHandle = GetInstanceNativeHandle (index);
    if (instHandle == nullptr)
    {
      Utilities::SystemInfo::ThrowLastError ();
    }
    return InstanceInfo (shandle_, instHandle);
  }


  std::vector<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_;
}; /* class InstanceInfoCollectionGeneric */


class InstanceInfoCollection : public InstanceInfoCollectionGeneric
{
public:
  InstanceInfoCollection (const SharedHandleGuard<TrainingSet> &sguard)
    : InstanceInfoCollectionGeneric(sguard),
      collectionParent_(sguard.Handle())
  {}

  InstanceInfoCollection (const InstanceInfoCollection&) = default;
  InstanceInfoCollection& operator= (const InstanceInfoCollection&) = default;

  virtual ~InstanceInfoCollection() = default;

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)
  {}

  ImageInstanceInfoCollection (const ImageInstanceInfoCollection&) = default;
  ImageInstanceInfoCollection& operator= (const ImageInstanceInfoCollection&) = default;

  virtual ~ImageInstanceInfoCollection() = default;


  InstanceInfo Add (const String &name, bool askForce, Point2D<double> location)
  {
    double dX = location.X();
    double dY = location.Y();
    CExports::MTSINSTANCE instance;
    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 InstanceInfo (shandle_, instance);
  }

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)
  {}

  ModelInstanceInfoCollection (const ModelInstanceInfoCollection&) = default;
  ModelInstanceInfoCollection& operator= (const ModelInstanceInfoCollection&) = default;

  virtual ~ModelInstanceInfoCollection() = default;

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
{
public:
  ImageInfo (const ImageInfo&) = default;
  ImageInfo& operator= (const ImageInfo&) = default;

private:
  ImageInfo (const SharedHandleGuard<TrainingSet> &sguardTrSet, int index)
    : sguardTrSet_(sguardTrSet),
      nativeHandle_ (CVB_CALL_CAPI (MTSImage(sguardTrSet.Handle(), index))),
      instances_ (sguardTrSet_, nativeHandle_)
  {
    if (nativeHandle_ == nullptr)
    {
      Utilities::SystemInfo::ThrowLastError();
    }
  }
  friend class InstanceInfo;
  friend class ImageInfoCollection;

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;
    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() const
  {
    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));
}

ImageInfo InstanceInfo::SourceImage () const
{
  auto imageIndex = CVB_CALL_CAPI(GetImageFromInstance(Handle()));
  return ImageInfo(sguardTrSet_, CVB_CALL_CAPI(MTSImageIndex(imageIndex)));
}


class ImageInfoCollection
{
public:
  ImageInfoCollection (const SharedHandleGuard<TrainingSet> &sguard)
    : shandle_(sguard)
  {}

  ImageInfoCollection (const ImageInfoCollection&) = default;
  ImageInfoCollection& operator= (const ImageInfoCollection&) = default;


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


  ImageInfo ReadInfo (int index) const
  {
    return ImageInfo (shandle_, index);
  }


  std::vector<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
{
public:
  ModelInfo (const ModelInfo&) = default;
  ModelInfo& operator= (const ModelInfo&) = default;

private:
  ModelInfo (const SharedHandleGuard<TrainingSet> &sguardTrSet, int index)
    : sguardTrSet_(sguardTrSet),
      nativeHandle_ (CVB_CALL_CAPI (MTSModel(sguardTrSet.Handle(), index))),
      instances_ (sguardTrSet_, nativeHandle_)
  {
    if (nativeHandle_ == nullptr)
    {
      Utilities::SystemInfo::ThrowLastError ();
    }
  }
  friend class InstanceInfo;
  friend class ModelInfoCollection;

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, advY;
    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()));
  }


  ModelInstanceInfoCollection Instances() const
  {
    return instances_;
  }


  std::vector<SearchResult> CheckConsistency (const ImageInfo &trainingSetImage, double threshold, double density = 1.0)
  {
    CExports::RESULTS hSearchResults;
    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;
    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 = std::lround(i.Location ().X ());
      if (loc_x < left)
      {
        left = loc_x;
      }
      auto loc_y = 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));
}

ModelInfo InstanceInfo::Model () const
{
  auto modelIndex = CVB_CALL_CAPI(GetModelFromInstance(nativeHandle_));
  return ModelInfo(sguardTrSet_, CVB_CALL_CAPI(MTSModelIndex(modelIndex)));
}


class ModelInfoCollection
{
public:
  ModelInfoCollection (const SharedHandleGuard<TrainingSet> &sguard)
    : shandle_(sguard)
  {}

  ModelInfoCollection (const ModelInfoCollection&) = default;
  ModelInfoCollection& operator= (const ModelInfoCollection&) = default;


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


  ModelInfo ReadInfo (int index) const
  {
    return ModelInfo (shandle_, index);
  }


  std::vector<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
  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(const String & fileName)
    : TrainingSet(HandleGuard<TrainingSet>(LoadInternal (fileName)), fileName)
  {
  }

  TrainingSet (TrainingSet&&) noexcept = default;

  TrainingSet& operator=(TrainingSet&&) noexcept = default;

public:

  static std::unique_ptr<TrainingSet> Load (const String & fileName)
  {
    return std::unique_ptr<TrainingSet>(new 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));
    });
  }


  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;
    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() const
  {
    return instances_;
  }


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


  ImageInfoCollection Images() const
  {
    return images_;
  }


  ModelInfoCollection Models() const
  {
    return models_;
  }


  String FileName() const
  {
    return fileName_;
  }


  bool IsModified() const
  {
    CExports::cvbbool_t retval;
    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, top, right, bottom;
    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, correlationThreshold;
    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, correlationThreshold;
    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 */