decl_regression_sil.hpp

#pragma once
 
#include "../../_cexports/c_sample_database.h"
 
#include "../../global.hpp"
#include "../../image.hpp"
#include "../sample_image_list.hpp"
#include "../sample_list_image_data_type.hpp"
 
#include <memory>
#include <utility>
#include <vector>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace SampleDatabase
  {


    class ImageRegressionLabelInfo
    {
    public:
      ImageRegressionLabelInfo(const SharedReleaseObjectGuard &sguardSil, const std::vector<float> &label)
          : shandleSil_(sguardSil)
          , labelInfo_(sguardSil, label)
      {
      }
 
      ImageRegressionLabelInfo(const ImageRegressionLabelInfo &other)            = delete;
      ImageRegressionLabelInfo &operator=(const ImageRegressionLabelInfo &other) = delete;
      ImageRegressionLabelInfo(ImageRegressionLabelInfo &&other)                 = delete;
      ImageRegressionLabelInfo &operator=(ImageRegressionLabelInfo &&other)      = delete;
      virtual ~ImageRegressionLabelInfo()                                        = default;
 
    public:
      using LabelType = std::vector<float>;


      ImageCollectionPtr Samples()
      {
        return labelInfo_.Samples();
      }
      ImageCollectionPtr Samples() {…}


      int Index() const
      {
        return 0;
      }
      int Index() const {…}


      std::vector<float> Label() const
      {
        return labelInfo_.Label();
      }
      std::vector<float> Label() const {…}


      void Add(const Image &srcImage, Point2D<int> extractionLocation,
               SampleExtractionMode mode = SampleExtractionMode::TopLeftCorner)
      {
        Private::AddSample(shandleSil_.Handle(), Label(), srcImage, extractionLocation, mode);
      }
      void Add(const Image &srcImage, Point2D<int> extractionLocation, {…}


      void Relabel(const std::vector<float> &label)
      {
        Private::Relabel(shandleSil_.Handle(), Index(), label);
      }
      void Relabel(const std::vector<float> &label) {…}
 
    private:
      SharedReleaseObjectGuard shandleSil_;
      Private::ImageLabelInfo<std::vector<float>> labelInfo_;
    }; /* class ImageRegressionLabelInfo */
    class ImageRegressionLabelInfo {…};

    using ImageRegressionLabelInfoPtr = std::shared_ptr<ImageRegressionLabelInfo>;


    class ImageRegressionInfoCollection : public LabelInfoCollection<ImageRegressionLabelInfo>
    {
    public:
      explicit ImageRegressionInfoCollection(const SharedReleaseObjectGuard &sguardSil)
          : LabelInfoCollection<ImageRegressionLabelInfo>(sguardSil)
      {
      }
 
    public:

      void Add(const std::vector<float> &label, const Image &srcImage, Point2D<int> extractionLocation,
               SampleExtractionMode mode = SampleExtractionMode::TopLeftCorner)
      {
        Private::AddSample(shandleSil_.Handle(), label, srcImage, extractionLocation, mode);
      }
      void Add(const std::vector<float> &label, const Image &srcImage, Point2D<int> extractionLocation, {…}


      bool HasValue(const std::vector<float> &label)
      {
        auto count = Count();
        for (int i = 0; i < count; ++i)
        {
          if (ReadInfo(i)->Label() == label)
          {
            return true;
          }
        }
        return false;
      }
      bool HasValue(const std::vector<float> &label) {…}
 
    protected:
      std::unique_ptr<ImageRegressionLabelInfo> GetInfo(int index) const override
      {
        auto labelType = CVB_CALL_CAPI(SilGetLabelType(shandleSil_.Handle()));
        size_t dim     = 0;
        CVB_CALL_CAPI_CHECKED(SilGetFloatVectorLabelDim(labelType, dim));
        auto label = CVB_CALL_CAPI(SilGetLabel(shandleSil_.Handle(), index));
        std::vector<float> floatLabel(dim);
        CVB_CALL_CAPI_CHECKED(SilGetFloatVectorLabel(label, floatLabel.data(), dim));
        return std::make_unique<ImageRegressionLabelInfo>(shandleSil_, floatLabel);
      }
 
    }; /* class ImageRegressionInfoCollection */
    class ImageRegressionInfoCollection : public LabelInfoCollection<ImageRegressionLabelInfo> {…};

    using ImageRegressionInfoCollectionPtr = std::shared_ptr<ImageRegressionInfoCollection>;
 
    // forward declaration
    class SampleClassificationImageList;


    class SampleRegressionImageList : public SampleImageList
    {
    private:
      explicit SampleRegressionImageList(ReleaseObjectGuard &&guardSil, const String &fileName = String())
          : SampleImageList(std::move(guardSil), fileName)
          , regressionDimension_(static_cast<int>(Private::GetFloatRegressionDimension(Handle())))
          , values_(std::make_shared<ImageRegressionInfoCollection>(shandleSil_))
      {
      }
 
    public:

      SampleRegressionImageList(const SampleListImageDataType &imageDataType, int regressionDimension)
          : SampleRegressionImageList(CreateInternal(imageDataType, regressionDimension))
      {
      }
      SampleRegressionImageList(const SampleListImageDataType &imageDataType, int regressionDimension) {…}


      explicit SampleRegressionImageList(const String &fileName)
          : SampleRegressionImageList(ReleaseObjectGuard(LoadInternal(fileName, CExports::SLT_Float)), fileName)
      {
      }
      explicit SampleRegressionImageList(const String &fileName) {…}
 
    private:
      // Helper to create the instance (from data type)
      static ReleaseObjectGuard CreateInternal(const SampleListImageDataType &imageDataType, int regressionDimension)
      {
        if ((regressionDimension <= 0) || (regressionDimension > RegressionDimensionMax))
        {
          throw std::out_of_range("regression dimension value must be within <1, 16>");
        }
        ReleaseObjectGuard lblType(CVB_CALL_CAPI(SilCreateLabelTypeFloatVector(regressionDimension)));
        ReleaseObjectGuard sil(CVB_CALL_CAPI(SilCreate(lblType.Handle(), imageDataType.Handle())));
        return sil;
      }
 
    public:
      static constexpr int RegressionDimensionMax = 16;


      static std::unique_ptr<SampleRegressionImageList> FromHandle(ReleaseObjectGuard &&guard,
                                                                   const String &fileName = String())
      {
        if (!guard.Handle())
        {
          throw std::invalid_argument("invalid regression image list native handle");
        }
        return std::unique_ptr<SampleRegressionImageList>(new SampleRegressionImageList(std::move(guard), fileName));
      }
      static std::unique_ptr<SampleRegressionImageList> FromHandle(ReleaseObjectGuard &&guard, {…}


      int RegressionDimension() const noexcept
      {
        return regressionDimension_;
      }
      int RegressionDimension() const noexcept {…}


      ImageRegressionInfoCollectionPtr Values()
      {
        return values_;
      }
      ImageRegressionInfoCollectionPtr Values() {…}


      std::unique_ptr<SampleRegressionImageList> Transform(DataTransformImageToImage transformCallback) const
      {
        return TransformData<SampleRegressionImageList>(transformCallback);
      }
      std::unique_ptr<SampleRegressionImageList> Transform(DataTransformImageToImage transformCallback) const {…}


      std::unique_ptr<SampleRegressionImageList> Transform(LabelTransformVectorToVector transformCallback) const
      {
        return TransformLabels<SampleRegressionImageList>(transformCallback);
      }
      std::unique_ptr<SampleRegressionImageList> Transform(LabelTransformVectorToVector transformCallback) const {…}


      std::unique_ptr<SampleClassificationImageList> Transform(LabelTransformVectorToString transformCallback) const;


      std::unique_ptr<ImageRegressionLabelInfo> GetValueForSample(int sampleIndex)
      {
        auto dataHandle = CVB_CALL_CAPI(SilGetData(Handle(), sampleIndex));
        auto labelRef   = CVB_CALL_CAPI(SilGetLabelReference(dataHandle, 0));
        auto labelIndex = CVB_CALL_CAPI(SilGetLabelIndex(Handle(), labelRef));
        return Values()->ReadInfo(labelIndex);
      }
      std::unique_ptr<ImageRegressionLabelInfo> GetValueForSample(int sampleIndex) {…}
 
    private:
      int regressionDimension_;
      ImageRegressionInfoCollectionPtr values_;
    }; /* class SampleRegressionImageList */
    class SampleRegressionImageList : public SampleImageList {…};

    using SampleRegressionImageListPtr = std::shared_ptr<SampleRegressionImageList>;
 
  } /* namespace SampleDatabase */
  CVB_END_INLINE_NS
} /* namespace Cvb */