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/ParallelAccessExtension.h>
#include <iolink/view/TilingInfoExtension.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);
 
  // Shortcuts
 
  ImageInterpretation imageInterpretation();
 
  ImageType axesInterpretation();
 
  Vector3d spatialOrigin();
 
  Vector3d spatialSpacing();
 
  std::string spatialUnit();
 
  const SpatialDirections& spatialDirections();
 
  size_t bitDepth();
 
  bool hasAlpha();
 
  Vector2d valueRange();
 
  // ===== //
  // 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);
 
  // Shortcuts
 
  void setImageInterpretation(const ImageInterpretation interpretation);
 
  void setAxesInterpretation(const ImageType type);
 
  void setSpatialOrigin(const Vector3d& origin);
 
  void setSpatialSpacing(const Vector3d& spacing);
 
  void setSpatialUnit(const std::string& unit);
 
  void setSpatialDirections(const SpatialDirections& directions);
 
  void setBitDepth(size_t bitDepth);
 
  void setAlpha(bool value);
 
  void setValueRange(const Vector2d& range);
 
  // ======= //
  // 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();
 
  // ========== //
  // Extensions //
  // ========== //
 
  std::shared_ptr<TilingInfoExtension> tilingInfo();
 
  std::shared_ptr<ParallelAccessExtension> parallelAccess();
};
 
} // namespace iolink