ImageViewFactory.h

#pragma once
 
#include <iolink/IOLinkAPI.h>
#include <iolink/MemoryLayout.h>
#include <iolink/storage/RandomAccess.h>
#include <iolink/view/ImageView.h>
#include <iolink/view/MultiImageView.h>
 
#include <memory>
 
namespace iolink
{
 
class IOLINK_API ImageViewFactory
{
public:
  ImageViewFactory() = delete;
  ImageViewFactory(const ImageViewFactory& other) = delete;            // copy constructor
  ImageViewFactory(ImageViewFactory&& other) = delete;                 // move constructor
  ImageViewFactory& operator=(const ImageViewFactory& other) = delete; // copy assignment
  ImageViewFactory& operator=(ImageViewFactory&& other) = delete;      // move assignment
 
  // ==================== //
  // Creating Image Views //
  // ==================== //
 
  static std::shared_ptr<ImageView> allocate(const VectorXu64& shape,
                                             DataType type,
                                             std::shared_ptr<ImageProperties> properties,
                                             std::shared_ptr<MetadataNode> metadata);
 
  static std::shared_ptr<ImageView> allocate(const VectorXu64& shape, DataType type);
 
  static std::shared_ptr<ImageView> copyInMemory(std::shared_ptr<ImageView> image);
 
  static std::shared_ptr<ImageView> createOnDisk(const std::string& dirPath,
                                                 const VectorXu64& shape,
                                                 DataType type,
                                                 std::shared_ptr<ImageProperties> properties,
                                                 std::shared_ptr<MetadataNode> metadata);
 
  static std::shared_ptr<ImageView> createOnDisk(const std::string& dirPath, const VectorXu64& shape, DataType type);
 
  static std::shared_ptr<ImageView> createOnDisk(const VectorXu64& shape,
                                                 DataType type,
                                                 std::shared_ptr<ImageProperties> properties,
                                                 std::shared_ptr<MetadataNode> metadata);
 
  static std::shared_ptr<ImageView> createOnDisk(const VectorXu64& shape, DataType type);
 
  static std::shared_ptr<ImageView> copyOnDisk(std::shared_ptr<ImageView> image);
 
  static std::shared_ptr<ImageView> copyOnDisk(std::shared_ptr<ImageView> image, const std::string& dirPath);
 
  static std::shared_ptr<ImageView> fromBuffer(const VectorXu64& shape,
                                               DataType type,
                                               void* buffer,
                                               size_t bufferSize,
                                               std::shared_ptr<ImageProperties> properties,
                                               const std::shared_ptr<MetadataNode> metadata);
 
  static std::shared_ptr<ImageView> fromBuffer(const VectorXu64& shape, DataType type, void* buffer, size_t bufferSize);
 
  static std::shared_ptr<ImageView> fromRandomAccess(std::shared_ptr<RandomAccess> accessor,
                                                     MemoryLayout layout,
                                                     const VectorXu64& shape,
                                                     const DataType type,
                                                     std::shared_ptr<ImageProperties> properties,
                                                     const std::shared_ptr<const MetadataNode> metadata);
 
  static std::shared_ptr<ImageView> fromRandomAccess(std::shared_ptr<RandomAccess> accessor,
                                                     MemoryLayout layout,
                                                     const VectorXu64& shape,
                                                     const DataType type);
 
  static std::shared_ptr<ImageView> fromRandomAccess(std::shared_ptr<RandomAccess> accessor,
                                                     const VectorXu64& shape,
                                                     const DataType type,
                                                     std::shared_ptr<ImageProperties> properties,
                                                     std::shared_ptr<const MetadataNode> metadata);
 
  static std::shared_ptr<ImageView> fromRandomAccess(std::shared_ptr<RandomAccess> accessor,
                                                     const VectorXu64& shape,
                                                     const DataType type);
 
  static std::shared_ptr<ImageView> fromImageView(std::shared_ptr<ImageView> view,
                                                  std::shared_ptr<const ImageProperties> properties,
                                                  std::shared_ptr<const MetadataNode> metadata);
 
  static std::shared_ptr<ImageView> uniform(const VectorXu64& shape,
                                            DataType type,
                                            void* value,
                                            std::shared_ptr<ImageProperties> properties,
                                            std::shared_ptr<const MetadataNode> metadata);
 
  static std::shared_ptr<ImageView> uniform(const VectorXu64& shape, DataType type, void* value);
 
  // ==================== //
  // Adapting Image Views //
  // ==================== //
 
  static std::shared_ptr<ImageView> adaptDynamicRange(std::shared_ptr<ImageView> view,
                                                      DataType type,
                                                      const Vector2d& inputRange,
                                                      const Vector2d& outputRange);
 
  static std::shared_ptr<ImageView> adaptDataType(std::shared_ptr<ImageView> view, DataType type);
 
  static std::shared_ptr<ImageView> extractChannel(std::shared_ptr<ImageView> view, size_t idxChannel);
 
  static std::shared_ptr<ImageView> extractRegion(std::shared_ptr<ImageView> view, const RegionXu64& region);
 
  static std::shared_ptr<ImageView> extractAdjustedRegion(std::shared_ptr<ImageView> view, const RegionXu64& region);
 
  static std::shared_ptr<ImageView> stack(std::shared_ptr<MultiImageView> view, ImageDimension newDimension);
 
  static std::shared_ptr<ImageView> stack(std::shared_ptr<MultiImageView> view);
 
  static std::shared_ptr<ImageView> stack(std::shared_ptr<MultiImageView> view,
                                          ImageDimension newDimension,
                                          size_t threadCount);
 
  static std::shared_ptr<ImageView> assembleChannels(std::shared_ptr<ImageView> image);
 
  static std::shared_ptr<ImageView> disassembleChannels(std::shared_ptr<ImageView> image);
 
  static std::shared_ptr<ImageView> interlace(std::shared_ptr<MultiImageView> multiView,
                                              ImageInterpretation newInterpretation,
                                              bool hasAlpha);
 
  static std::shared_ptr<ImageView> interlace(std::shared_ptr<MultiImageView> multiView);
 
  static std::shared_ptr<ImageView> reinterpret(std::shared_ptr<ImageView> image, ImageType newImageType);
 
  static std::shared_ptr<ImageView> reinterpretAxes(std::shared_ptr<ImageView> image,
                                                    std::initializer_list<ImageDimension> dimensionsList);
 
  static std::shared_ptr<ImageView> reinterpretAxes(std::shared_ptr<ImageView> image,
                                                    const ImageDimension* dimensionsList,
                                                    size_t count);
 
  static std::shared_ptr<ImageView> subSample(std::shared_ptr<ImageView> image, size_t step);
 
  static std::shared_ptr<ImageView> flip(std::shared_ptr<ImageView> image, ImageDimension dimension);
 
  static std::shared_ptr<ImageView> flip(std::shared_ptr<ImageView> image, size_t dimensionIndex);
 
  static std::shared_ptr<ImageView> makeThreadSafe(std::shared_ptr<ImageView> image);
};
 
} // end namespace iolink