sample_list.hpp

#pragma once
 
#include "../_cexports/c_sample_database.h"
 
#include "../global.hpp"
#include "../image.hpp"
#include "../string.hpp"
#include "../point_2d.hpp"
 
#include <utility>
#include <memory>
#include <vector>
#include <ctime>
#include <chrono>
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
namespace SampleDatabase
{
 
namespace Private
{
// Helpers to validate new/changed labels
size_t GetFloatRegressionDimension (CExports::TSIL hSil)
{
  auto labelType = CVB_CALL_CAPI (SilGetLabelType(hSil));
  size_t dim = 0;
  CVB_CALL_CAPI_CHECKED (SilGetFloatVectorLabelDim(labelType, dim));
  return dim;
}
 
inline void ValidateLabel (CExports::TSIL /*hSil*/, const String &label)
{
  if (label.empty ())
  {
    throw std::invalid_argument ("empty string is not a valid label");
  }
}
 
inline void ValidateLabel (CExports::TSIL hSil, const std::vector<float> &label)
{
  if (label.size () != GetFloatRegressionDimension (hSil))
  {
    throw std::invalid_argument ("invalid dimension of the float vector label");
  }
}
 
// Helper to relabel a string label
inline void Relabel (CExports::TSIL hSil, int index, const String &label)
{
  ValidateLabel (hSil, label);
 
  CVB_CALL_CAPI_CHECKED(SilChangeStringLabelTyped(hSil, index, label.c_str()));
}
 
// Helper to relabel a float label
inline void Relabel (CExports::TSIL hSil, int index, const std::vector<float> &label)
{
  ValidateLabel (hSil, label);
 
  /* Note: need to cast-away const of "label" parameter to match the C-API, the function does not modify it. */
  CVB_CALL_CAPI_CHECKED(SilChangeVectorLabel(hSil, index, const_cast<float*>(label.data()), label.size())); // NOLINT(cppcoreguidelines-pro-type-const-cast)
}
 
// Generic label transformation callback
template<typename TLabelOut, typename TLabelIn>
using LabelTransform = std::function<TLabelOut (const TLabelIn &labelIn)>;
} /* namespace Private */
 
 
template <class TLabelInformation>
class LabelInfoCollection
{
public:
  explicit LabelInfoCollection (const SharedReleaseObjectGuard &sguardSil)
    : shandleSil_(sguardSil)
  {}
 
  LabelInfoCollection (const LabelInfoCollection& other) = delete;
  LabelInfoCollection& operator= (const LabelInfoCollection& other) = delete;
  LabelInfoCollection(LabelInfoCollection&& other) = delete;
  LabelInfoCollection& operator= (LabelInfoCollection && other) = delete;
 
  virtual ~LabelInfoCollection () = default;
 
public:
  using LabelType = typename TLabelInformation::LabelType;
 
 
  int Count () const
  {
    return CVB_CALL_CAPI(SilGetNumLabelEntries(shandleSil_.Handle()));
  }
 
 
  std::unique_ptr<TLabelInformation> ReadInfo (int index) const
  {
    return GetInfo (index);
  }
 
 
  std::vector<std::shared_ptr<TLabelInformation>> ReadInfos () const
  {
    auto count = Count ();
    std::vector<std::shared_ptr<TLabelInformation>> info;
    for (decltype(count) i = 0; i < count; ++i)
    {
      info.push_back (ReadInfo (i));
    }
 
    return info;
  }
 
 
  void RemoveAt (int index)
  {
    CVB_CALL_CAPI_CHECKED(SilDeleteLabel(shandleSil_.Handle(), index));
  }
 
 
  void Remove (const LabelType & label)
  {
    auto index = LabelToIndex(label);
    if (index < 0)
    {
      throw std::invalid_argument ("cannot remove class because it is not part of the sample database");
    }
 
    RemoveAt(index);
  }
 
 
  void Clear ()
  {
    while (Count () > 0)
    {
      RemoveAt (0);
    }
  }
 
 
  void MergeClasses (int fromIndex, int toIndex)
  {
    if (fromIndex == toIndex)
    {
      return;
    }
    Private::Relabel (shandleSil_.Handle (), fromIndex, ReadInfo (toIndex)->Label());
  }
 
 
  void MergeClasses (const LabelType & fromLabel, const LabelType & toLabel)
  {
    auto fromIndex = LabelToIndex (fromLabel);
    auto toIndex = LabelToIndex (toLabel);
    if (fromIndex < 0 || toIndex < 0)
    {
      throw std::invalid_argument ("cannot classes, at least one is not part of the collection");
    }
 
    MergeClasses (fromIndex, toIndex);
  }
 
 
protected:
  virtual std::unique_ptr<TLabelInformation> GetInfo (int index) const = 0;
 
  int LabelToIndex (const LabelType &label) const
  {
    auto count = Count ();
    for (int i = 0; i < count; ++i)
    {
      if (ReadInfo(i)->Label() == label)
      {
        return i;
      }
    }
    return -1;
  }
 
protected:
  SharedReleaseObjectGuard shandleSil_; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
}; /* class LabelInfoCollection */
 
 
template <class TData>
class SampleCollection
{
public:
  explicit SampleCollection (const SharedReleaseObjectGuard &sguardSil)
    : shandleSil_(sguardSil)
  {}
 
  SampleCollection (const SampleCollection& other) = delete;
  SampleCollection& operator= (const SampleCollection& other) = delete;
  SampleCollection(SampleCollection&& other) = delete;
  SampleCollection& operator= (SampleCollection && other) = delete;
  virtual ~SampleCollection () = default;
 
public:
 
  int Count () const
  {
    auto label = CVB_CALL_CAPI(SilGetLabel (shandleSil_.Handle(), GetLabelIndex()));
    return CVB_CALL_CAPI(SilGetNumDataReferences(label));
  }
 
 
  TData ReadData (int index) const
  {
    auto data = CVB_CALL_CAPI(SilGetDataByLabel (shandleSil_.Handle(), GetLabelIndex(), index));
    return GetData (data);
  }
 
 
  TData RemoveAt (int index)
  {
    TData retval = ReadData (index);
    CVB_CALL_CAPI_CHECKED(SilDeleteDataByLabel(shandleSil_.Handle(), GetLabelIndex(), index));
    return retval;
  }
 
protected:
  std::shared_ptr<Image> GetImage (CExports::TSILDATA dataHandle) const
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void* & resimg)
    {
      CVB_CALL_CAPI_CHECKED(SilGetImageData (dataHandle, resimg));
      return CVB_CALL_CAPI(ShareObject (resimg));
    });
  }
 
  int GetLabelIndex () const
  {
    return 0;
  }
 
  virtual TData GetData (CExports::TSILDATA dataHandle) const = 0;
 
private:
  SharedReleaseObjectGuard shandleSil_;
}; /* class SampleCollection */
 
 
typedef std::function<String (const String &labelIn)> LabelTransformStringToString;
 
 
typedef std::function<std::vector<float> (const String &labelIn)> LabelTransformStringToVector;
 
 
typedef std::function<std::vector<float> (const std::vector<float> &labelIn)> LabelTransformVectorToVector;
 
 
typedef std::function<String (const std::vector<float> &labelIn)> LabelTransformVectorToString;
 
 
typedef std::function<std::unique_ptr<Image> (const Image &imgIn)> DataTransformImageToImage;
 
 
class SampleList
{
 
public:
 
  SampleList(const SampleList& other) = delete;
  SampleList& operator=(const SampleList& other) = delete;
  SampleList(SampleList&& other)  = delete;
  SampleList& operator=(SampleList&& other) = delete;
  virtual ~SampleList() = default;
 
protected:
  explicit SampleList (ReleaseObjectGuard&& guardSil, const String &fileName = String())
    : shandleSil_(std::move(guardSil)),
      fileName_ (fileName)
  {}
 
 
  
 
  // Helper to load a sample list from file
  static ReleaseObjectGuard LoadInternal (const String & fileName, CExports::TSilLabelType expectedLabelType)
  {
    CExports::TSIL sil = nullptr;
 
    CVB_CALL_CAPI_CHECKED (SilLoadTyped (fileName.c_str(), sil));
    ReleaseObjectGuard silGuard (sil);
 
    auto dataType = CVB_CALL_CAPI (SilGetDataTypeEnum(silGuard.Handle()));
    auto labelType = CVB_CALL_CAPI (SilGetLabelTypeEnum(silGuard.Handle()));
    if (dataType != CExports::SDT_ImageData)
    {
      throw std::invalid_argument ("the loaded SIL file does not contain image data type");
    }
    if (labelType != expectedLabelType)
    {
      throw std::invalid_argument ("the loaded SIL file does not contain expected label type");
    }
 
    return silGuard;
  }
 
public:
 
  void * Handle() const noexcept
  {
    return shandleSil_.Handle();
  }
 
 
  String FileName() const
  {
    return fileName_;
  }
 
 
  String Comment() const
  {
    size_t bufferSize = 0;
    CVB_CALL_CAPI_CHECKED (SilGetCommentTyped(Handle(), static_cast<Char*>(nullptr), bufferSize));
    std::vector<Char> comment (bufferSize);
    CVB_CALL_CAPI_CHECKED (SilGetCommentTyped(Handle(), comment.data(), bufferSize));
    return String (comment.begin(), comment.end());
  }
 
 
  void SetComment(String comment)
  {
    CVB_CALL_CAPI_CHECKED (SilSetCommentTyped (Handle(), comment.c_str()));
  }
 
 
  std::chrono::system_clock::time_point CreationDate() const
  {
    CExports::CV_SYSTEMTIME st = { 0 };
    CVB_CALL_CAPI_CHECKED (SilGetCreationDate(Handle(), st));
    std::tm tm = {};
    tm.tm_sec = st.wSecond;
    tm.tm_min = st.wMinute;
    tm.tm_hour = st.wHour;
    tm.tm_mday = st.wDay;
    tm.tm_mon = st.wMonth - 1;
    tm.tm_year = st.wYear - 1900;
    tm.tm_isdst = -1;
 
    return std::chrono::system_clock::from_time_t (std::mktime (&tm));
  }
 
 
  std::chrono::system_clock::time_point ModificationDate() const
  {
    CExports::CV_SYSTEMTIME st = { 0 };
    CVB_CALL_CAPI_CHECKED (SilGetModificationDate(Handle(), st));
    std::tm tm = {};
    tm.tm_sec = st.wSecond;
    tm.tm_min = st.wMinute;
    tm.tm_hour = st.wHour;
    tm.tm_mday = st.wDay;
    tm.tm_mon = st.wMonth - 1;
    tm.tm_year = st.wYear - 1900;
    tm.tm_isdst = -1;
 
    return std::chrono::system_clock::from_time_t (std::mktime (&tm));
  }
 
 
  int NumClasses() const
  {
    size_t numClasses = 0, dummy1 = 0, dummy2 = 0;
    double dummy3 = std::numeric_limits<double>::quiet_NaN();
    CVB_CALL_CAPI_CHECKED(SilGetStatistics(Handle(), numClasses, dummy1, dummy2, dummy3));
    return static_cast<int>(numClasses);
  }
 
 
  int NumSamples() const
  {
    return static_cast<int>(CVB_CALL_CAPI(SilGetNumDataEntries(Handle())));
  }
 
 
  int MinSampleCount() const
  {
    size_t minCount = 0, dummy1 = 0, dummy2 = 0;
    double dummy3 = std::numeric_limits<double>::quiet_NaN();
    CVB_CALL_CAPI_CHECKED(SilGetStatistics(Handle(), dummy1, minCount, dummy2, dummy3));
    return static_cast<int>(minCount);
  }
 
 
  int MaxSampleCount() const
  {
    size_t maxCount = 0, dummy1 = 0, dummy2 = 0;
    double dummy3 = std::numeric_limits<double>::quiet_NaN();
    CVB_CALL_CAPI_CHECKED(SilGetStatistics(Handle(), dummy1, dummy2, maxCount, dummy3));
    return static_cast<int>(maxCount);
  }
 
 
  double AverageSampleCount() const
  {
    size_t dummy1 = 0, dummy2 = 0, dummy3 = 0;
    double avgCount = std::numeric_limits<double>::quiet_NaN();
    CVB_CALL_CAPI_CHECKED(SilGetStatistics(Handle(), dummy1, dummy2, dummy3, avgCount));
    return avgCount;
  }
 
 
  void Save (const String & fileName) const
  {
    CVB_CALL_CAPI_CHECKED (SilStoreTyped (Handle(), fileName.c_str()));
    fileName_ = fileName;
  }
 
protected:
  // Sample image list transformation workers
  template <class TOut>
  std::unique_ptr<TOut> TransformData (DataTransformImageToImage cbk) const
  {
    CExports::TSIL sil = nullptr;
 
    CVB_CALL_CAPI_CHECKED (SilTransformDataList (Handle (), NativeDataTransformCallback, &cbk, sil));
    ReleaseObjectGuard silGuard (sil);
 
    return TOut::FromHandle (std::move (silGuard));
  }
 
  template <class TOut, class TLabelOut, class TLabelIn>
  std::unique_ptr<TOut> TransformLabels (Private::LabelTransform<TLabelOut, TLabelIn> cbk) const
  {
    CExports::TSIL sil = nullptr;
 
    CVB_CALL_CAPI_CHECKED (SilTransformLabelList (Handle (), NativeLabelTransformCallback<TLabelOut, TLabelIn>, &cbk, sil));
    ReleaseObjectGuard silGuard (sil);
 
    return TOut::FromHandle (std::move (silGuard));
  }
 
private:
  static CExports::cvbbool_t __stdcall NativeDataTransformCallback (void* pPrivate, CExports::TSILDATA DataIn, CExports::TSILDATA& DataOut)
  {
    try
    {
      DataTransformImageToImage *cbk = reinterpret_cast<DataTransformImageToImage*> (pPrivate);
 
      auto imgIn =  Internal::DoBoolCallObjectOut<Image>([&](void* & resimg)
      {
        CVB_CALL_CAPI_CHECKED(SilGetImageData (DataIn, resimg));
        return CVB_CALL_CAPI(ShareObject (resimg));
      });
 
      auto imgOut = (*cbk) (*imgIn);
      DataOut = CVB_CALL_CAPI(SilCreateImageData(imgOut->Handle(), 0, 0, imgOut->Size().Width(), imgOut->Size().Height()));
      return true;
    }
    catch (const std::exception &)
    {
      return false;
    }
  }
 
  template <class TLabelOut, class TLabelIn>
  static CExports::cvbbool_t __stdcall NativeLabelTransformCallback (void* pPrivate, CExports::TSILLABEL LabelIn, CExports::TSILLABEL& LabelOut)
  {
    try
    {
      Private::LabelTransform<TLabelOut, TLabelIn> *cbk = reinterpret_cast<Private::LabelTransform<TLabelOut, TLabelIn>*> (pPrivate);
 
      TLabelIn objectIn;
      NativeLabelToObject (LabelIn, objectIn);
 
      auto objectOut = (*cbk) (objectIn);
      LabelOut = CreateNativeLabel (objectOut);
      return true;
    }
    catch (const std::exception &)
    {
      return false;
    }
  }
 
  static void NativeLabelToObject (CExports::TSILLABEL label, String &object)
  {
    size_t bufferSize = 0;
    CVB_CALL_CAPI_CHECKED (SilGetStringLabelTyped(label, static_cast<Char*>(nullptr), bufferSize));
    std::vector<Char> stringLabel (bufferSize);
    CVB_CALL_CAPI_CHECKED (SilGetStringLabelTyped(label, stringLabel.data(), bufferSize));
    object.assign (stringLabel.begin (), stringLabel.end ());
  }
 
  static CExports::TSILLABEL CreateNativeLabel (const String &object)
  {
    return CVB_CALL_CAPI(SilCreateStringLabelTyped(object.c_str()));
  }
 
  static void NativeLabelToObject (CExports::TSILLABEL label, std::vector<float> &object)
  {
    size_t dim = 0;
    CVB_CALL_CAPI_CHECKED (SilGetFloatVectorLabel(label, static_cast<float*>(nullptr), dim));
    object.resize (dim);
    CVB_CALL_CAPI_CHECKED (SilGetFloatVectorLabel(label, object.data(), dim));
  }
 
  static CExports::TSILLABEL CreateNativeLabel (const std::vector<float> &object)
  {
    return CVB_CALL_CAPI(SilCreateVectorLabel(object.data(), object.size()));
  }
 
protected:
  SharedReleaseObjectGuard shandleSil_; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
 
private:
  mutable String fileName_;
}; /* class SampleList */
 
using SampleListPtr = std::shared_ptr<SampleList>;
 
 
} /* namespace SampleDatabase */
CVB_END_INLINE_NS
} /* namespace Cvb */