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
};
 
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, height, dimension;
  CExports::cvbdatatype_t type;
  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, top, width, height, originX, originY;
    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:
  ImageCollection (const SharedReleaseObjectGuard &sguardSil)
    : SampleCollection<std::shared_ptr<Image>> (sguardSil)
  {}
 
  ImageCollection (const ImageCollection&) = default;
  ImageCollection& operator= (const ImageCollection&) = default;
 
  virtual ~ImageCollection ()
  {}
 
protected:
  std::shared_ptr<Image> GetData (CExports::TSILDATA dataHandle) const override
  {
    return GetImage (dataHandle);
  }
}; /* class ImageCollection */
 
namespace Private
{
 
template <class TLabel>
class ImageLabelInfo
{
public:
  ImageLabelInfo (const SharedReleaseObjectGuard &sguardSil, const TLabel &label)
    : label_(label), samples_(sguardSil)
  {}
 
  ImageLabelInfo (const ImageLabelInfo&) = default;
  ImageLabelInfo& operator= (const ImageLabelInfo&) = default;
 
  ~ImageLabelInfo () {};
 
public:
  using LabelType = TLabel;
 
  ImageCollection Samples() const
  {
    return samples_;
  }
 
  TLabel Label() const
  {
    return label_;
  }
 
private:
  TLabel label_;
  ImageCollection samples_;
}; /* class ImageLabelInfo */
 
} /* namespace Private */
 
 
class SampleImageList : public SampleList
{
protected:
  SampleImageList (ReleaseObjectGuard&& guardSil, const String &fileName = String())
    : SampleList (std::move(guardSil), fileName)
  {}
 
  SampleImageList (SampleImageList&&) noexcept = default;
 
  SampleImageList& operator=(SampleImageList&&) noexcept = default;
 
  virtual ~SampleImageList () = default;
 
public:
 
  class Fringes Fringes() const
  {
    auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
    CExports::cvbdim_t left, top, right, bottom;
    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));
  }
 
 
  Size2D<int> FeatureWindowSize() const
  {
    auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
    CExports::cvbdim_t left, top, width, height, originX, originY;
    CVB_CALL_CAPI_CHECKED(SilGetFeatureWindow(datatype, left, top, width, height, originX, originY));
 
    return Size2D<int>(static_cast<int>(width), static_cast<int>(height));
  }
 
 
  Point2D<int> FeatureWindowLocation() const
  {
    auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
    CExports::cvbdim_t left, top, width, height, originX, originY;
    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> FeatureWindowOrigin() const
  {
    auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
    CExports::cvbdim_t left, top, width, height, originX, originY;
    CVB_CALL_CAPI_CHECKED(SilGetFeatureWindow(datatype, left, top, width, height, originX, originY));
 
    return Point2D<int>(static_cast<int>(originX), static_cast<int>(originY));
  }
 
 
  Size2D<int> ImageSize() const
  {
    auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
    CExports::cvbdim_t width, height, dimension;
    CExports::cvbdatatype_t type;
    CVB_CALL_CAPI_CHECKED(SilGetImageDataGeometry(datatype, width, height, dimension, type));
 
    return Size2D<int>(static_cast<int>(width), static_cast<int>(height));
  }
 
 
  int ImageDimension() const
  {
    auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
    CExports::cvbdim_t width, height, dimension;
    CExports::cvbdatatype_t type;
    CVB_CALL_CAPI_CHECKED(SilGetImageDataGeometry(datatype, width, height, dimension, type));
 
    return static_cast<int>(dimension);
  }
 
 
  DataType ImageDataType() const
  {
    auto datatype = CVB_CALL_CAPI(SilGetDataType(Handle()));
 
    CExports::cvbdim_t width, height, dimension;
    CExports::cvbdatatype_t type;
    CVB_CALL_CAPI_CHECKED(SilGetImageDataGeometry(datatype, width, height, dimension, type));
 
    return DataType::FromNativeDescriptor (type);
  }
 
 
  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()));
  }
 
 
  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;
  }
 
 
  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));
    });
  }
}; /* class SampleImageList */
 
using SampleImageListPtr = std::shared_ptr<SampleImageList>;
 
 
} /* namespace SampleDatabase */
CVB_END_INLINE_NS
} /* namespace Cvb */