ImageView.h

#pragma once
 
#include <memory>
 
#include <iolink/DataType.h>
#include <iolink/FlagSet.h>
#include <iolink/IOLinkAPI.h>
#include <iolink/Indexer.h>
#include <iolink/RegionX.h>
#include <iolink/VectorX.h>
#include <iolink/metadata/MetadataNode.h>
#include <iolink/property/ImageProperties.h>
#include <iolink/view/View.h>
 
namespace iolink
{
 
enum class ImageCapability
{
  // Flags
  READ = 0x1,          
  WRITE = 0x2,         
  RESHAPE = 0x4,       
  MEMORY_ACCESS = 0x8, 
 
  // Combinations
  READ_WRITE = 0x3, 
};
 
extern template class IOLINK_API_IMPORT FlagSet<ImageCapability>;
 
using ImageCapabilitySet = FlagSet<ImageCapability>;
 
// Define bitwise operators for ImageCapability
IOLINK_DEFINE_ENUM_BITWISE_OPERATORS(ImageCapability)
 
 
class IOLINK_API ImageView : public View
{
 
public:
  virtual ~ImageView() = default;
 
  inline size_t dimensionCount() { return this->shape().size(); }
 
  inline bool support(ImageCapabilitySet flags) { return this->capabilities().has(flags); }
 
  virtual ImageCapabilitySet capabilities() const = 0;
 
  virtual const VectorXu64& shape() = 0;
 
  virtual DataType dataType() = 0;
 
  virtual std::shared_ptr<const ImageProperties> properties() = 0;
 
  std::string toString() const;
 
  // ==== //
  // READ //
  // ==== //
 
  virtual std::shared_ptr<const MetadataNode> metadata() const;
 
  virtual void read(const VectorXu64& index, void* dst);
 
  virtual void readRegion(const RegionXu64& region, void* dst);
 
  // ===== //
  // WRITE //
  // ===== //
 
  virtual void setProperties(std::shared_ptr<const ImageProperties> properties);
 
  virtual void setMetadata(std::shared_ptr<MetadataNode> metadata);
 
  virtual void write(const VectorXu64& index, const void* src);
 
  virtual void writeRegion(const RegionXu64& region, const void* src);
 
  // ======= //
  // RESHAPE //
  // ======= //
 
  virtual void reshape(const VectorXu64& shape, DataType dataType);
 
  // ============= //
  // MEMORY_ACCESS //
  // ============= //
 
  virtual const Indexer& indexer();
 
  virtual void* buffer();
 
  virtual const void* bufferReadOnly() const;
 
  virtual size_t bufferSize();
};
 
} // namespace iolink