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


      std::unique_ptr<TLabelInformation> ReadInfo(int index) const
      {
        return GetInfo(index);
      }
      std::unique_ptr<TLabelInformation> ReadInfo(int index) const {…}


      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;
      }
      std::vector<std::shared_ptr<TLabelInformation>> ReadInfos() const {…}


      void RemoveAt(int index)
      {
        CVB_CALL_CAPI_CHECKED(SilDeleteLabel(shandleSil_.Handle(), index));
      }
      void RemoveAt(int 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 Remove(const LabelType &label) {…}


      void Clear()
      {
        while (Count() > 0)
        {
          RemoveAt(0);
        }
      }
      void Clear() {…}


      void MergeClasses(int fromIndex, int toIndex)
      {
        if (fromIndex == toIndex)
        {
          return;
        }
        Private::Relabel(shandleSil_.Handle(), fromIndex, ReadInfo(toIndex)->Label());
      }
      void MergeClasses(int fromIndex, int toIndex) {…}


      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);
      }
      void MergeClasses(const LabelType &fromLabel, const LabelType &toLabel) {…}
 
    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 */
    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));
      }
      int Count() const {…}


      TData ReadData(int index) const
      {
        auto data = CVB_CALL_CAPI(SilGetDataByLabel(shandleSil_.Handle(), GetLabelIndex(), index));
        return GetData(data);
      }
      TData ReadData(int index) const {…}


      TData RemoveAt(int index)
      {
        TData retval = ReadData(index);
        CVB_CALL_CAPI_CHECKED(SilDeleteDataByLabel(shandleSil_.Handle(), GetLabelIndex(), index));
        return retval;
      }
      TData RemoveAt(int index) {…}
 
    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 */
    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();
      }
      void *Handle() const noexcept {…}


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


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


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


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


      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));
      }
      std::chrono::system_clock::time_point ModificationDate() const {…}


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


      int NumSamples() const
      {
        return static_cast<int>(CVB_CALL_CAPI(SilGetNumDataEntries(Handle())));
      }
      int NumSamples() const {…}


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


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


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


      void Save(const String &fileName) const
      {
        CVB_CALL_CAPI_CHECKED(SilStoreTyped(Handle(), fileName.c_str()));
        fileName_ = fileName;
      }
      void Save(const String &fileName) const {…}
 
    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 */
    class SampleList {…};

    using SampleListPtr = std::shared_ptr<SampleList>;
 
  } /* namespace SampleDatabase */
  CVB_END_INLINE_NS
} /* namespace Cvb */