sample_image_list.hpp

#pragma once
 
#include "../_cexports/c_sample_database.h"
 
#include "../global.hpp"
#include "../image.hpp"
#include "../size_2d.hpp"
#include "../point_2d.hpp"
#include "../data_type.hpp"
#include "sample_list.hpp"
#include "fringes.hpp"
 
#include <vector>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace SampleDatabase
  {

    enum class SampleExtractionMode
    {
      TopLeftCorner,
      OriginPosition
    };
    enum class SampleExtractionMode {…};
 
    namespace Private
    {
      // Set of helpers to add sample to a class
      inline ReleaseObjectGuard CreateNativeImageData(CExports::TSIL hSil, const Image &srcImage,
                                                      Point2D<int> extractionLocation)
      {
        // check compatibility
        auto datatype            = CVB_CALL_CAPI(SilGetDataType(hSil));
        CExports::cvbdim_t width = 0, height = 0, dimension = 0;
        CExports::cvbdatatype_t type = 0;
        CVB_CALL_CAPI_CHECKED(SilGetImageDataGeometry(datatype, width, height, dimension, type));
        if (srcImage.PlanesCount() != static_cast<int>(dimension) || !srcImage.PlaneDataTypesIdentical()
            || srcImage.Planes()[0].DataType() != DataType::FromNativeDescriptor(type)
            || srcImage.Width() < static_cast<int>(width) || srcImage.Height() < static_cast<int>(height))
        {
          throw std::invalid_argument("the input image is not compatible with this sample list");
        }
 
        ReleaseObjectGuard data(CVB_CALL_CAPI(
            SilCreateImageData(srcImage.Handle(), extractionLocation.X(), extractionLocation.Y(), width, height)));
        return data;
      }
 
      inline ReleaseObjectGuard CreateNativeLabel(const String &label)
      {
        ReleaseObjectGuard lbl(CVB_CALL_CAPI(SilCreateStringLabelTyped(label.c_str())));
        return lbl;
      }
 
      inline ReleaseObjectGuard CreateNativeLabel(const std::vector<float> &label)
      {
        ReleaseObjectGuard lbl(CVB_CALL_CAPI(SilCreateVectorLabel(label.data(), label.size())));
        return lbl;
      }
 
      template <typename TLabel>
      void AddSample(CExports::TSIL hSil, const TLabel &label, const Image &srcImage, Point2D<int> extractionLocation,
                     SampleExtractionMode mode = SampleExtractionMode::TopLeftCorner)
      {
        ValidateLabel(hSil, label);
 
        if (mode == SampleExtractionMode::OriginPosition)
        {
          auto datatype           = CVB_CALL_CAPI(SilGetDataType(hSil));
          CExports::cvbdim_t left = 0, top = 0, width = 0, height = 0, originX = 0, originY = 0;
          CVB_CALL_CAPI_CHECKED(SilGetFeatureWindow(datatype, left, top, width, height, originX, originY));
          Point2D<int> ftrwinOrigin(static_cast<int>(originX), static_cast<int>(originY));
 
          extractionLocation -= ftrwinOrigin;
        }
 
        ReleaseObjectGuard data(CreateNativeImageData(hSil, srcImage, extractionLocation));
        ReleaseObjectGuard lbl(CreateNativeLabel(label));
        CVB_CALL_CAPI_CHECKED(SilAddItem(hSil, data.Handle(), lbl.Handle()));
      }
    } /* namespace Private */


    class ImageCollection : public SampleCollection<std::shared_ptr<Image>>
    {
    public:
      explicit ImageCollection(const SharedReleaseObjectGuard &sguardSil)
          : SampleCollection<std::shared_ptr<Image>>(sguardSil)
      {
      }
 
    protected:
      std::shared_ptr<Image> GetData(CExports::TSILDATA dataHandle) const override
      {
        return GetImage(dataHandle);
      }
    }; /* class ImageCollection */
    class ImageCollection : public SampleCollection<std::shared_ptr<Image>> {…};

    using ImageCollectionPtr = std::shared_ptr<ImageCollection>;
 
    namespace Private
    {
 
      template <class TLabel>
      class ImageLabelInfo
      {
      public:
        ImageLabelInfo(const SharedReleaseObjectGuard &sguardSil, const TLabel &label)
            : label_(label)
            , samples_(std::make_shared<ImageCollection>(sguardSil))
        {
        }
 
        ImageLabelInfo(const ImageLabelInfo &other)            = delete;
        ImageLabelInfo &operator=(const ImageLabelInfo &other) = delete;
        ImageLabelInfo(ImageLabelInfo &&other)                 = delete;
        ImageLabelInfo &operator=(ImageLabelInfo &&other)      = delete;
        virtual ~ImageLabelInfo()                              = default;
 
      public:
        using LabelType = TLabel;
 
        ImageCollectionPtr Samples()
        {
          return samples_;
        }
 
        TLabel Label() const
        {
          return label_;
        }
 
      private:
        TLabel label_;
        ImageCollectionPtr samples_;
      }; /* class ImageLabelInfo */
 
    } /* namespace Private */


    class SampleImageList : public SampleList
    {
    protected:
      explicit SampleImageList(ReleaseObjectGuard &&guardSil, const String &fileName = String())
          : SampleList(std::move(guardSil), fileName)
      {
      }
 
    public:

      class Fringes Fringes() const
      {
        auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
        CExports::cvbdim_t left = 0, top = 0, right = 0, bottom = 0;
        CVB_CALL_CAPI_CHECKED(SilGetFringes(datatype, left, top, right, bottom));
 
        return SampleDatabase::Fringes(static_cast<int>(left), static_cast<int>(top), static_cast<int>(right),
                                       static_cast<int>(bottom));
      }
      class Fringes Fringes() const {…}


      Size2D<int> FeatureWindowSize() const
      {
        auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
        CExports::cvbdim_t left = 0, top = 0, width = 0, height = 0, originX = 0, originY = 0;
        CVB_CALL_CAPI_CHECKED(SilGetFeatureWindow(datatype, left, top, width, height, originX, originY));
 
        return Size2D<int>(static_cast<int>(width), static_cast<int>(height));
      }
      Size2D<int> FeatureWindowSize() const {…}


      Point2D<int> FeatureWindowLocation() const
      {
        auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
        CExports::cvbdim_t left = 0, top = 0, width = 0, height = 0, originX = 0, originY = 0;
        CVB_CALL_CAPI_CHECKED(SilGetFeatureWindow(datatype, left, top, width, height, originX, originY));
 
        return Point2D<int>(static_cast<int>(left), static_cast<int>(top));
      }
      Point2D<int> FeatureWindowLocation() const {…}


      Point2D<int> FeatureWindowOrigin() const
      {
        auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
        CExports::cvbdim_t left = 0, top = 0, width = 0, height = 0, originX = 0, originY = 0;
        CVB_CALL_CAPI_CHECKED(SilGetFeatureWindow(datatype, left, top, width, height, originX, originY));
 
        return Point2D<int>(static_cast<int>(originX), static_cast<int>(originY));
      }
      Point2D<int> FeatureWindowOrigin() const {…}


      Size2D<int> ImageSize() const
      {
        auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
        CExports::cvbdim_t width = 0, height = 0, dimension = 0;
        CExports::cvbdatatype_t type = 0;
        CVB_CALL_CAPI_CHECKED(SilGetImageDataGeometry(datatype, width, height, dimension, type));
 
        return Size2D<int>(static_cast<int>(width), static_cast<int>(height));
      }
      Size2D<int> ImageSize() const {…}


      int ImageDimension() const
      {
        auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
        CExports::cvbdim_t width = 0, height = 0, dimension = 0;
        CExports::cvbdatatype_t type = 0;
        CVB_CALL_CAPI_CHECKED(SilGetImageDataGeometry(datatype, width, height, dimension, type));
 
        return static_cast<int>(dimension);
      }
      int ImageDimension() const {…}


      DataType ImageDataType() const
      {
        auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
        CExports::cvbdim_t width = 0, height = 0, dimension = 0;
        CExports::cvbdatatype_t type = 0;
        CVB_CALL_CAPI_CHECKED(SilGetImageDataGeometry(datatype, width, height, dimension, type));
 
        return DataType::FromNativeDescriptor(type);
      }
      DataType ImageDataType() const {…}


      void SetFeatureWindow(Point2D<int> location, Size2D<int> size, Point2D<int> origin)
      {
        auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
        CVB_CALL_CAPI_CHECKED(SilSetFeatureWindow(datatype, location.X(), location.Y(), size.Width(), size.Height(),
                                                  origin.X(), origin.Y()));
      }
      void SetFeatureWindow(Point2D<int> location, Size2D<int> size, Point2D<int> origin) {…}


      bool IsCompatible(const Image &img) const
      {
        if (img.PlanesCount() != ImageDimension())
        {
          return false;
        }
        if (!img.PlaneDataTypesIdentical())
        {
          return false;
        }
        if (img.Planes()[0].DataType() != ImageDataType())
        {
          return false;
        }
        auto imageSize = ImageSize();
        if (img.Width() < imageSize.Width())
        {
          return false;
        }
        if (img.Height() < imageSize.Height())
        {
          return false;
        }
        return true;
      }
      bool IsCompatible(const Image &img) const {…}


      std::shared_ptr<Image> GetSampleImage(int sampleIndex) const
      {
        return Internal::DoBoolCallObjectOut<Image>([&](void *&resimg) {
          auto dataHandle = CVB_CALL_CAPI(SilGetData(Handle(), sampleIndex));
          CVB_CALL_CAPI_CHECKED(SilGetImageData(dataHandle, resimg));
          return CVB_CALL_CAPI(ShareObject(resimg));
        });
      }
      std::shared_ptr<Image> GetSampleImage(int sampleIndex) const {…}
    }; /* class SampleImageList */
    class SampleImageList : public SampleList {…};

    using SampleImageListPtr = std::shared_ptr<SampleImageList>;
 
  } /* namespace SampleDatabase */
  CVB_END_INLINE_NS
} /* namespace Cvb */