Namespace OpenVDS

namespace OpenVDS

Typedefs

typedef VDSCoordinateTransformerBase<2> VDSCoordinateTransformer2D

typedef VDSCoordinateTransformerBase<3> VDSCoordinateTransformer3D

typedef VDSCoordinateTransformerBase<4> VDSCoordinateTransformer4D

typedef VDSCoordinateTransformerBase<5> VDSCoordinateTransformer5D

typedef VDSCoordinateTransformerBase<6> VDSCoordinateTransformer6D

typedef VDSError Error

typedef void (*LogCallback)(LogLevel level, const char *message, size_t messageSize, void *userHandle)

using IntMatrix2x2 = Matrix<int, 2>

using IntMatrix3x3 = Matrix<int, 3>

using IntMatrix4x4 = Matrix<int, 4>

using FloatMatrix2x2 = Matrix<float, 2>

using FloatMatrix3x3 = Matrix<float, 3>

using FloatMatrix4x4 = Matrix<float, 4>

using DoubleMatrix2x2 = Matrix<double, 2>

using DoubleMatrix3x3 = Matrix<double, 3>

using DoubleMatrix4x4 = Matrix<double, 4>

template<size_t N> using IntMatrix = Matrix<int, N>

template<size_t N> using FloatMatrix = Matrix<float, N>

template<size_t N> using DoubleMatrix = Matrix<double, N>

typedef struct VDS *VDSHandle

using IntRange = Range<int>

using FloatRange = Range<float>

using DoubleRange = Range<double>

using IntVector2 = Vector<int, 2>

using IntVector3 = Vector<int, 3>

using IntVector4 = Vector<int, 4>

using FloatVector2 = Vector<float, 2>

using FloatVector3 = Vector<float, 3>

using FloatVector4 = Vector<float, 4>

using DoubleVector2 = Vector<double, 2>

using DoubleVector3 = Vector<double, 3>

using DoubleVector4 = Vector<double, 4>

template<size_t N> using IntVector = Vector<int, N>

template<size_t N> using FloatVector = Vector<float, N>

template<size_t N> using DoubleVector = Vector<double, N>

using VolumeData2DInterpolatingAccessorR64 = VolumeDataReadAccessor<FloatVector2, double>

using VolumeData2DInterpolatingAccessorR32 = VolumeDataReadAccessor<FloatVector2, float>

using VolumeData2DReadAccessorR64 = VolumeDataReadAccessor<IntVector2, double>

using VolumeData2DReadAccessorU64 = VolumeDataReadAccessor<IntVector2, uint64_t>

using VolumeData2DReadAccessorR32 = VolumeDataReadAccessor<IntVector2, float>

using VolumeData2DReadAccessorU32 = VolumeDataReadAccessor<IntVector2, uint32_t>

using VolumeData2DReadAccessorU16 = VolumeDataReadAccessor<IntVector2, uint16_t>

using VolumeData2DReadAccessorU8 = VolumeDataReadAccessor<IntVector2, uint8_t>

using VolumeData2DReadAccessor1Bit = VolumeDataReadAccessor<IntVector2, bool>

using VolumeData2DReadWriteAccessorR64 = VolumeDataReadWriteAccessor<IntVector2, double>

using VolumeData2DReadWriteAccessorU64 = VolumeDataReadWriteAccessor<IntVector2, uint64_t>

using VolumeData2DReadWriteAccessorR32 = VolumeDataReadWriteAccessor<IntVector2, float>

using VolumeData2DReadWriteAccessorU32 = VolumeDataReadWriteAccessor<IntVector2, uint32_t>

using VolumeData2DReadWriteAccessorU16 = VolumeDataReadWriteAccessor<IntVector2, uint16_t>

using VolumeData2DReadWriteAccessorU8 = VolumeDataReadWriteAccessor<IntVector2, uint8_t>

using VolumeData2DReadWriteAccessor1Bit = VolumeDataReadWriteAccessor<IntVector2, bool>

using VolumeData3DInterpolatingAccessorR64 = VolumeDataReadAccessor<FloatVector3, double>

using VolumeData3DInterpolatingAccessorR32 = VolumeDataReadAccessor<FloatVector3, float>

using VolumeData3DReadAccessorR64 = VolumeDataReadAccessor<IntVector3, double>

using VolumeData3DReadAccessorU64 = VolumeDataReadAccessor<IntVector3, uint64_t>

using VolumeData3DReadAccessorR32 = VolumeDataReadAccessor<IntVector3, float>

using VolumeData3DReadAccessorU32 = VolumeDataReadAccessor<IntVector3, uint32_t>

using VolumeData3DReadAccessorU16 = VolumeDataReadAccessor<IntVector3, uint16_t>

using VolumeData3DReadAccessorU8 = VolumeDataReadAccessor<IntVector3, uint8_t>

using VolumeData3DReadAccessor1Bit = VolumeDataReadAccessor<IntVector3, bool>

using VolumeData3DReadWriteAccessorR64 = VolumeDataReadWriteAccessor<IntVector3, double>

using VolumeData3DReadWriteAccessorU64 = VolumeDataReadWriteAccessor<IntVector3, uint64_t>

using VolumeData3DReadWriteAccessorR32 = VolumeDataReadWriteAccessor<IntVector3, float>

using VolumeData3DReadWriteAccessorU32 = VolumeDataReadWriteAccessor<IntVector3, uint32_t>

using VolumeData3DReadWriteAccessorU16 = VolumeDataReadWriteAccessor<IntVector3, uint16_t>

using VolumeData3DReadWriteAccessorU8 = VolumeDataReadWriteAccessor<IntVector3, uint8_t>

using VolumeData3DReadWriteAccessor1Bit = VolumeDataReadWriteAccessor<IntVector3, bool>

using VolumeData4DInterpolatingAccessorR64 = VolumeDataReadAccessor<FloatVector4, double>

using VolumeData4DInterpolatingAccessorR32 = VolumeDataReadAccessor<FloatVector4, float>

using VolumeData4DReadAccessorR64 = VolumeDataReadAccessor<IntVector4, double>

using VolumeData4DReadAccessorU64 = VolumeDataReadAccessor<IntVector4, uint64_t>

using VolumeData4DReadAccessorR32 = VolumeDataReadAccessor<IntVector4, float>

using VolumeData4DReadAccessorU32 = VolumeDataReadAccessor<IntVector4, uint32_t>

using VolumeData4DReadAccessorU16 = VolumeDataReadAccessor<IntVector4, uint16_t>

using VolumeData4DReadAccessorU8 = VolumeDataReadAccessor<IntVector4, uint8_t>

using VolumeData4DReadAccessor1Bit = VolumeDataReadAccessor<IntVector4, bool>

using VolumeData4DReadWriteAccessorR64 = VolumeDataReadWriteAccessor<IntVector4, double>

using VolumeData4DReadWriteAccessorU64 = VolumeDataReadWriteAccessor<IntVector4, uint64_t>

using VolumeData4DReadWriteAccessorR32 = VolumeDataReadWriteAccessor<IntVector4, float>

using VolumeData4DReadWriteAccessorU32 = VolumeDataReadWriteAccessor<IntVector4, uint32_t>

using VolumeData4DReadWriteAccessorU16 = VolumeDataReadWriteAccessor<IntVector4, uint16_t>

using VolumeData4DReadWriteAccessorU8 = VolumeDataReadWriteAccessor<IntVector4, uint8_t>

using VolumeData4DReadWriteAccessor1Bit = VolumeDataReadWriteAccessor<IntVector4, bool>

using VolumeDataRequest1Bit = VolumeDataRequest_t<uint8_t>

using VolumeDataRequestByte = VolumeDataRequest_t<uint8_t>

using VolumeDataRequestUShort = VolumeDataRequest_t<uint16_t>

using VolumeDataRequestUInt = VolumeDataRequest_t<uint32_t>

using VolumeDataRequestULong = VolumeDataRequest_t<uint64_t>

using VolumeDataRequestFloat = VolumeDataRequest_t<float>

using VolumeDataRequestDouble = VolumeDataRequest_t<double>

using VolumeIndexer2D = VolumeIndexerBase<2>

using VolumeIndexer3D = VolumeIndexerBase<3>

using VolumeIndexer4D = VolumeIndexerBase<4>

using VolumeIndexer5D = VolumeIndexerBase<5>

using VolumeIndexer6D = VolumeIndexerBase<6>

Enums

enum class LogLevel

Values:

enumerator None

enumerator Error

enumerator Warning

enumerator Info

enumerator Trace

enum class MetadataType

Values:

enumerator Int

enumerator IntVector2

enumerator IntVector3

enumerator IntVector4

enumerator Float

enumerator FloatVector2

enumerator FloatVector3

enumerator FloatVector4

enumerator Double

enumerator DoubleVector2

enumerator DoubleVector3

enumerator DoubleVector4

enumerator String

enumerator BLOB

enum class WaveletAdaptiveMode

Values:

enumerator BestQuality: The best quality available data is loaded (this is the only setting which will load lossless data).

enumerator Tolerance: An adaptive level closest to the global compression tolerance is selected when loading wavelet compressed data.

enumerator Ratio: An adaptive level closest to the global compression ratio is selected when loading wavelet compressed data.

enum class VolumeDataFormat

Volume data format.

Values:

enumerator Format_Any: Volume data can be in any format.

enumerator Format_1Bit: Volume data is in packed 1-bit format.

enumerator Format_U8: Volume data is in unsigned 8 bit.

enumerator Format_U16: Volume data is in unsigned 16 bit.

enumerator Format_R32: Volume data is in 32 bit float.

enumerator Format_U32: Volume data is in unsigned 32 bit.

enumerator Format_R64: Volume data is in 64 bit double.

enumerator Format_U64: Volume data is in unsigned 64 bit.

enum class VolumeDataComponents

Volume data components.

Values:

enumerator Components_1: Volume data is scalar.

enumerator Components_2: Volume data has 2-components.

enumerator Components_4: Volume data has 4-components.

enum class InterpolationMethod

Interpolation method used for sampling.

Values:

enumerator Nearest: Snap to the closest sample.

enumerator Linear: Linear interpolation.

enumerator Cubic: Cubic interpolation.

enumerator Angular: Angular interpolation (same as linear but wraps around the value range)

enumerator Triangular: Triangular interpolation used to interpolate heightmap data.

enum DimensionsND

2D or 3D dimension group

Values:

enumerator Dimensions_012

enumerator Dimensions_013

enumerator Dimensions_014

enumerator Dimensions_015

enumerator Dimensions_023

enumerator Dimensions_024

enumerator Dimensions_025

enumerator Dimensions_034

enumerator Dimensions_035

enumerator Dimensions_045

enumerator Dimensions_123

enumerator Dimensions_124

enumerator Dimensions_125

enumerator Dimensions_134

enumerator Dimensions_135

enumerator Dimensions_145

enumerator Dimensions_234

enumerator Dimensions_235

enumerator Dimensions_245

enumerator Dimensions_345

enumerator Dimensions_01

enumerator Dimensions_02

enumerator Dimensions_03

enumerator Dimensions_04

enumerator Dimensions_05

enumerator Dimensions_12

enumerator Dimensions_13

enumerator Dimensions_14

enumerator Dimensions_15

enumerator Dimensions_23

enumerator Dimensions_24

enumerator Dimensions_25

enumerator Dimensions_34

enumerator Dimensions_35

enumerator Dimensions_45

enum class VolumeDataMapping

Mapping volume data channels.

Values:

enumerator Direct: Each voxel in the volume has a value.

enumerator PerTrace: Each line of voxels along dimension 0 in the volume has a number of values specifed by the MappedValueCount of the VolumeDataChannelDescriptor.

enum class CompressionMethod

Values:

enumerator None: No compression is applied; data is stored ‘as is’.

enumerator Wavelet: Voxel values are compressed using a lossy wavelet compression algorithm. This usually produces excellent results for continuous data, but is not applicable when dealing with discrete values.

enumerator RLE: Voxel values are compressed using run-length encoding which is a fast, lossless algorithm. This gives good results when the same value is often repeated for adjacent voxels, for example classification data.

enumerator Zip: Voxel values are compressed using zip (zlib) which is a slower, lossless algorithm that gives fairly good compression for all types of data.

enumerator WaveletNormalizeBlock: This method is experimental and no guarantee is made that decompression for data compressed in this format will be supported in future versions. Voxel values are compressed using a lossy wavelet compression algorithm. Also the threshold takes into account the absolute average of each block. This is good for data that varies a lot in signal strength. This usually produces excellent results for continuous data, but is not applicable when dealing with discrete values.

enumerator WaveletLossless: Voxel values are compressed using a losslees wavelet compression algorithm. This usually produces excellent results for continuous data, but is not applicable when dealing with discrete values.

enumerator WaveletNormalizeBlockLossless: This method is experimental and no guarantee is made that decompression for data compressed in this format will be supported in future versions. Voxel values are compressed using a lossless wavelet compression algorithm. Also the threshold takes into account the absolute average of each block. This is good for data that varies a lot in signal strength. This usually produces excellent results for continuous data, but is not applicable when dealing with discrete values.

enum class VDSProduceStatus

Values:

enumerator Normal

enumerator Remapped

enumerator Unavailable

Functions

inline void fastInvert(M4 &m)

inline OpenOptions *CreateOpenOptions(std::string url, std::string connectionString, Error &error)

Create an OpenOptions struct from a url and connection string.

Parameters:

url – The url scheme specific to each cloud provider Available schemes are s3:// azure://
connectionString – The cloud provider specific connection string Specifies additional arguments for the cloud provider
error – If an error occured, the error code and message will be written to this output parameter

Returns:

This function news a OpenOptions struct that has to be deleted by the caller. This is a helper function to allow applications modify the OpenOption before passing it to Open. Use the Open and Create functions with url and string instead if this is not needed.

inline bool IsSupportedProtocol(std::string url)

Verifies that the url is a supported protocol.

Returns:: Returnes true if the protocol specifier of the url is recognised by OpenVDS, otherwise returns false

inline VDSHandle Open(std::string url, std::string connectionString, Error &error)

Open an existing VDS.

Parameters:

url – The url scheme specific to each cloud provider Available schemes are s3:// azure://
connectionString – The cloud provider specific connection string Specifies additional arguments for the cloud provider
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle OpenWithAdaptiveCompressionTolerance(std::string url, std::string connectionString, float waveletAdaptiveTolerance, Error &error)

Open an existing VDS with adaptive compression tolerance.

Parameters:

url – The url scheme specific to each cloud provider Available schemes are s3:// azure://
connectionString – The cloud provider specific connection string Specifies additional arguments for the cloud provider
waveletAdaptiveTolerance – Wavelet adaptive tolerance. This will try to read the dataset as-if it was compressed with the given tolerance even if it was compressed with a lower tolerance or lossless.
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle OpenWithAdaptiveCompressionRatio(std::string url, std::string connectionString, float waveletAdaptiveRatio, Error &error)

Open an existing VDS with adaptive compression ratio.

Parameters:

url – The url scheme specific to each cloud provider Available schemes are s3:// azure://
connectionString – The cloud provider specific connection string Specifies additional arguments for the cloud provider
waveletAdaptiveRatio – Wavelet adaptive ratio. This will try to read the dataset as-if it was compressed with the given ratio even if it was compressed with a lower ratio or lossless. A compression ratio of 5.0 corresponds to compressed data which is 20% of the original.
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Open(std::string url, Error &error)

Open an existing VDS. This is a simple wrapper that uses an empty connectionString.

Parameters:

url – The url scheme specific to each cloud provider Available schemes are s3:// azure://
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Open(const OpenOptions &options, Error &error)

Open an existing VDS.

Parameters:

options – The options for the connection
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Open(IOManager *ioManager, Error &error)

Open an existing VDS.

Parameters:

ioManager – The IOManager for the connection, it will be deleted automatically when the VDS handle is closed
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Open(IOManager *ioManager, LogLevel logLevel, Error &error)

Open an existing VDS.

Parameters:

ioManager – The IOManager for the connection, it will be deleted automatically when the VDS handle is closed
logLevel – The logging threshold
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline bool IsCompressionMethodSupported(CompressionMethod compressionMethod)

Check if a compression method is supported. Not all compression methods might be supported when creating VDSs, and this method checks if a particular compression methods is supported by this implementation.

Parameters:: compressionMethod – The compression method to check
Returns:: True if the compression method is supported when creating VDSs with this implementation.

inline VDSHandle Create(std::string url, std::string connectionString, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, CompressionMethod compressionMethod, float compressionTolerance, Error &error)

Create a new VDS.

Parameters:

url – The url scheme specific to each cloud provider Available schemes are s3:// azure://
connectionString – The cloud provider specific connection string Specifies additional arguments for the cloud provider
compressionMethod – The overall compression method to be used for the VDS. The channel descriptors can have additional options to control how a channel is compressed.
compressionTolerance – This property specifies the compression tolerance [1..255] when using the wavelet compression method. This value is the maximum deviation from the original data value when the data is converted to 8-bit using the value range. A value of 1 means the maximum allowable loss is the same as quantizing to 8-bit (but the average loss will be much much lower than quantizing to 8-bit). It is not a good idea to directly relate the tolerance to the quality of the compressed data, as the average loss will in general be an order of magnitude lower than the allowable loss.
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Create(std::string url, std::string connectionString, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, Error &error)

Create a new VDS.

Parameters:

url – The url scheme specific to each cloud provider Available schemes are s3:// azure://
connectionString – The cloud provider specific connection string Specifies additional arguments for the cloud provider
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Create(std::string url, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, CompressionMethod compressionMethod, float compressionTolerance, Error &error)

Create a new VDS. This is a simple wrapper that uses an empty connectionString.

Parameters:

url – The url scheme specific to each cloud provider Available schemes are s3:// azure://
compressionMethod – The overall compression method to be used for the VDS. The channel descriptors can have additional options to control how a channel is compressed.
compressionTolerance – This property specifies the compression tolerance [1..255] when using the wavelet compression method. This value is the maximum deviation from the original data value when the data is converted to 8-bit using the value range. A value of 1 means the maximum allowable loss is the same as quantizing to 8-bit (but the average loss will be much much lower than quantizing to 8-bit). It is not a good idea to directly relate the tolerance to the quality of the compressed data, as the average loss will in general be an order of magnitude lower than the allowable loss.
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Create(std::string url, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, Error &error)

Create a new VDS. This is a simple wrapper that uses an empty connectionString.

Parameters:

url – The url scheme specific to each cloud provider Available schemes are s3:// azure://
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Create(const OpenOptions &options, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, CompressionMethod compressionMethod, float compressionTolerance, Error &error)

Create a new VDS.

Parameters:

options – The options for the connection
compressionMethod – The overall compression method to be used for the VDS. The channel descriptors can have additional options to control how a channel is compressed.
compressionTolerance – This property specifies the compression tolerance [1..255] when using the wavelet compression method. This value is the maximum deviation from the original data value when the data is converted to 8-bit using the value range. A value of 1 means the maximum allowable loss is the same as quantizing to 8-bit (but the average loss will be much much lower than quantizing to 8-bit). It is not a good idea to directly relate the tolerance to the quality of the compressed data, as the average loss will in general be an order of magnitude lower than the allowable loss.
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Create(const OpenOptions &options, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, Error &error)

Create a new VDS.

Parameters:

options – The options for the connection
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Create(IOManager *ioManager, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, CompressionMethod compressionMethod, float compressionTolerance, Error &error)

Create a new VDS.

Parameters:

ioManager – The IOManager for the connection, it will be deleted automatically when the VDS handle is closed
compressionMethod – The overall compression method to be used for the VDS. The channel descriptors can have additional options to control how a channel is compressed.
compressionTolerance – This property specifies the compression tolerance [1..255] when using the wavelet compression method. This value is the maximum deviation from the original data value when the data is converted to 8-bit using the value range. A value of 1 means the maximum allowable loss is the same as quantizing to 8-bit (but the average loss will be much much lower than quantizing to 8-bit). It is not a good idea to directly relate the tolerance to the quality of the compressed data, as the average loss will in general be an order of magnitude lower than the allowable loss.
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Create(IOManager *ioManager, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, CompressionMethod compressionMethod, float compressionTolerance, LogLevel logLevel, Error &error)

Create a new VDS.

Parameters:

ioManager – The IOManager for the connection, it will be deleted automatically when the VDS handle is closed
compressionMethod – The overall compression method to be used for the VDS. The channel descriptors can have additional options to control how a channel is compressed.
compressionTolerance – This property specifies the compression tolerance [1..255] when using the wavelet compression method. This value is the maximum deviation from the original data value when the data is converted to 8-bit using the value range. A value of 1 means the maximum allowable loss is the same as quantizing to 8-bit (but the average loss will be much much lower than quantizing to 8-bit). It is not a good idea to directly relate the tolerance to the quality of the compressed data, as the average loss will in general be an order of magnitude lower than the allowable loss.
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Create(IOManager *ioManager, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, Error &error)

Create a new VDS.

Parameters:

ioManager – The IOManager for the connection, it will be deleted automatically when the VDS handle is closed
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VDSHandle Create(IOManager *ioManager, VolumeDataLayoutDescriptor const &layoutDescriptor, std::vector<VolumeDataAxisDescriptor> axisDescriptors, std::vector<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, LogLevel logLevel, Error &error)

Create a new VDS.

Parameters:

ioManager – The IOManager for the connection, it will be deleted automatically when the VDS handle is closed
error – If an error occured, the error code and message will be written to this output parameter

Returns:

The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

inline VolumeDataLayout *GetLayout(VDSHandle handle)

Get the VolumeDataLayout for a VDS.

Parameters:: handle – The handle of the VDS
Returns:: The VolumeDataLayout of the VDS

inline IVolumeDataAccessManager *GetAccessManagerInterface(VDSHandle handle)

Get the VolumeDataAccessManagerInterface for a VDS.

Parameters:: handle – The handle of the VDS
Returns:: The VolumeDataAccessManagerInterface of the VDS

inline VolumeDataAccessManager GetAccessManager(VDSHandle handle)

Get the VolumeDataAccessManager for a VDS.

Parameters:: handle – The handle of the VDS
Returns:: The VolumeDataAccessManager of the VDS

inline MetadataWriteAccess *GetMetadataWriteAccessInterface(VDSHandle handle)

Get the MetadataWriteAccess interface for a VDS.

Parameters:: handle – The handle of the VDS
Returns:: The MetadataWriteAccess interface of the VDS

inline CompressionMethod GetCompressionMethod(VDSHandle handle)

Get the primary CompressionMethod for a VDS.

Parameters:: handle – The handle of the VDS
Returns:: The CompressionMethod used for the VDS

inline float GetCompressionTolerance(VDSHandle handle)

Get the primary compression tolerance used for a VDS.

Parameters:: handle – The handle of the VDS
Returns:: The compression tolerance used for the VDS

inline int64_t GetWaveletCompressedSize(VDSHandle handle)

Get the total wavelet compressed size (including lossless data) of the primary layer (first dimension group, channel 0, LOD 0) of a wavelet compressed dataset.

Parameters:: handle – The handle of the VDS
Returns:: The total wavelet compressed size (including lossless data) of the primary layer (first dimension group, channel 0, LOD 0)

inline int64_t GetWaveletUncompressedSize(VDSHandle handle)

Get the uncompressed size (not counting empty/constant value blocks) of the primary layer (first dimension group, channel 0, LOD 0) of a wavelet compressed dataset.

Parameters:: handle – The handle of the VDS
Returns:: The uncompressed size (not counting empty/constant value blocks) of the primary layer (first dimension group, channel 0, LOD 0)

inline std::vector<WaveletAdaptiveLevel> GetWaveletAdaptiveLevels(VDSHandle handle)

Get a list of the available wavelet adaptive levels for the VDS.

Parameters:: handle – The handle of the VDS
Returns:: The list of available wavelet adaptive levels

inline void Close(VDSHandle handle, bool flush = true)

Close a VDS and free up all associated resources. If an error occurs, an exception will be thrown.

Parameters:: handle – The handle of the VDS

inline void Close(VDSHandle handle, Error &error, bool flush = true)

Close a VDS and free up all associated resources.

Parameters:

handle – The handle of the VDS
error – If an error occured, the error code and message will be written to this output parameter

inline void RetryableClose(VDSHandle handle, bool flush = true)

Close a VDS and free up all associated resources if the close succeeds. If an error occurs, an exception will be thrown.

Parameters:: handle – The handle of the VDS

inline void RetryableClose(VDSHandle handle, Error &error, bool flush = true)

Close a VDS and free up all associated resources if the close succeeds.

Parameters:

handle – The handle of the VDS
error – If an error occured, the error code and message will be written to this output parameter

inline GlobalState *GetGlobalState()

Get the GlobalState interface.

Returns:: A pointer to the GlobalState interface

inline const char *GetOpenVDSName()

Get the name of the OpenVDS implementation.

Returns:: A null terminated string

inline const char *GetOpenVDSVersion()

Get the version for the OpenVDS implementation.

Returns:: A version string

inline const char *GetOpenVDSRevision()

Get revision of the OpenVDS build.

Returns:: A revision string

OpenVDSInterface &GetOpenVDSInterface(const char *version)

void SetOpenVDSInterface(OpenVDSInterface &openVDSInterface)

template<typename T> T rangeSize(const Range<T> &r)

template<typename T1, typename T2> inline std::enable_if<std::is_same<T1, bool>::value && !std::is_same<T2, bool>::value, T1>::type ConvertValue(T2 value)

template<typename T1, typename T2> inline std::enable_if<std::is_same<T2, bool>::value, T1>::type ConvertValue(T2 value)

template<typename T1, typename T2> inline std::enable_if<std::numeric_limits<T1>::is_integer && !std::is_same<T1, bool>::value && std::numeric_limits<T2>::is_integer && !std::is_same<T2, bool>::value, T1>::type ConvertValue(T2 value)

template<typename T1, typename T2> inline std::enable_if<std::numeric_limits<T1>::is_integer && !std::is_same<T1, bool>::value && !std::numeric_limits<T2>::is_integer, T1>::type ConvertValue(T2 value)

template<typename T1, typename T2> inline std::enable_if<!std::numeric_limits<T1>::is_integer && !std::is_same<T2, bool>::value, T1>::type ConvertValue(T2 value)

template<typename T> inline T ConvertNoValue(float noValue)

template<> inline bool ConvertNoValue<bool>(float)

template<> inline uint8_t ConvertNoValue<uint8_t>(float)

template<> inline uint16_t ConvertNoValue<uint16_t>(float)

template<typename T> inline T ConvertNoValue(double noValue)

template<> inline bool ConvertNoValue<bool>(double)

template<> inline uint8_t ConvertNoValue<uint8_t>(double)

template<> inline uint16_t ConvertNoValue<uint16_t>(double)

static inline int QuantizeValueWithReciprocalScale(float value, float offset, float reciprocalScale, int buckets)

template<typename T, size_t N> static inline bool operator==(const Vector<T, N> &a, const Vector<T, N> &b)

template<typename T, size_t N> bool operator!=(const Vector<T, N> &a, const Vector<T, N> &b)

inline constexpr int operator+(int n, VolumeDataComponents components)

inline constexpr int operator+(VolumeDataComponents components, int n)

inline int &operator+=(int &n, VolumeDataComponents components)

inline constexpr int operator-(int n, VolumeDataComponents components)

inline constexpr int operator-(VolumeDataComponents components, int n)

inline int &operator-=(int &n, VolumeDataComponents components)

inline constexpr int operator*(int n, VolumeDataComponents components)

inline constexpr int operator*(VolumeDataComponents components, int n)

inline int &operator*=(int &n, VolumeDataComponents components)

inline constexpr int operator/(int n, VolumeDataComponents components)

inline constexpr int operator/(VolumeDataComponents components, int n)

inline int &operator/=(int &n, VolumeDataComponents components)

inline constexpr bool operator==(int n, VolumeDataComponents components)

inline constexpr bool operator==(VolumeDataComponents components, int n)

inline constexpr bool operator!=(int n, VolumeDataComponents components)

inline constexpr bool operator!=(VolumeDataComponents components, int n)

inline constexpr bool operator<(int n, VolumeDataComponents components)

inline constexpr bool operator<(VolumeDataComponents components, int n)

inline constexpr bool operator<=(int n, VolumeDataComponents components)

inline constexpr bool operator<=(VolumeDataComponents components, int n)

inline constexpr bool operator>(int n, VolumeDataComponents components)

inline constexpr bool operator>(VolumeDataComponents components, int n)

inline constexpr bool operator>=(int n, VolumeDataComponents components)

inline constexpr bool operator>=(VolumeDataComponents components, int n)

inline bool CompressionMethod_IsWavelet(CompressionMethod compressionMethod)

inline int GetLODSize(int voxelMin, int voxelMax, int LOD, bool includePartialUpperVoxel = true)

Get the number of voxels at a particular LOD from a voxel range (ranges are exclusive).

Parameters:

voxelMin – The minimum voxel index of the range.
voxelMax – The maximum voxel index of the range (ranges are exclusive, so the range does not include voxelMax).
includePartialUpperVoxel – This controls the rounding. Usually you want the size of the range to be all voxels in the range, but when we are copying from multiple adjacent ranges we only want to round up for the last one.
LOD – The LOD level for which the size is requested.

Returns:

The number of voxels at the given LOD, at LOD 0 the result is voxelMax - voxelMin.

template<typename T> inline T ReadElement(const T *buffer, size_t element)

Read element from buffer. This function has a template specialisation for bool making it suitable to read single bits from a buffer with packed bits.

Parameters:

buffer – Buffer to read from
element – The element index to read from buffer

Returns:

Element at position “element” is returned.

template<> inline bool ReadElement<bool>(const bool *buffer, size_t element)

template<typename T> inline void WriteElement(T *buffer, size_t element, T value)

Write element into buffer. This function has a template specialisation for bool making it suitable to write single bits into a buffer with packed bits.

Parameters:

buffer – Buffer to write to
element – The element index in the buffer to write to
value – Value to write

template<> inline void WriteElement(bool *buffer, size_t element, bool value)

template<typename T> inline int PitchScale()

Template function to get the scalar for the pitch value (which is in bytes for 1-bit data) used to scale the pitch to get the number of elements.

Returns:: The scale factor for the pitch for the given type

template<> inline int PitchScale<bool>()

inline bool VolumeDataHash_IsDefined(uint64_t volumeDataHash): Determine whether the given volume data hash is defined.

inline bool VolumeDataHash_IsNoValue(uint64_t volumeDataHash): Determine whether the given volume data hash is the no-data-value.

inline bool VolumeDataHash_IsConstant(uint64_t volumeDataHash): Determine whether the given volume data hash is constant.

inline VolumeDataChannelDescriptor::Flags operator|(VolumeDataChannelDescriptor::Flags lhs, VolumeDataChannelDescriptor::Flags rhs)

inline VolumeDataLayoutDescriptor::Options operator|(VolumeDataLayoutDescriptor::Options lhs, VolumeDataLayoutDescriptor::Options rhs)

Variables

constexpr int Dimensionality_Max = 6

struct AWSOpenOptions : public OpenVDS::OpenOptions

#include <OpenVDS.h>

Options for opening a VDS in AWS.

Public Functions

inline AWSOpenOptions()

inline AWSOpenOptions(std::string const &bucket, std::string const &key, std::string const &region = std::string(), std::string const &endpointOverride = std::string(), int connectionTimeoutMs = 3000, int requestTimeoutMs = 6000, bool disableInitApi = false)

AWSOpenOptions constructor.

Parameters:

bucket – The bucket of the VDS
key – The key prefix of the VDS
region – The region of the bucket of the VDS
endpointOverride – This parameter allows to override the endpoint url
connectionTimeoutMs – This parameter allows to override the time a connection can spend on connecting to AWS
requestTimeoutMs – This paramter allows to override the time a request can take

Public Members

std::string bucket

std::string key

std::string region

std::string endpointOverride

std::string accessKeyId

std::string secretKey

std::string sessionToken

std::string expiration

int connectionTimeoutMs

int requestTimeoutMs

bool disableInitApi

struct AzureOpenOptions : public OpenVDS::OpenOptions

#include <OpenVDS.h>

Options for opening a VDS in Azure.

Public Functions

inline AzureOpenOptions()

inline AzureOpenOptions(std::string const &connectionString, std::string const &container, std::string const &blob)

AzureOpenOptions constructor.

Parameters:

connectionString – The connectionString for the VDS
container – The container of the VDS
blob – The blob prefix of the VDS

inline AzureOpenOptions(std::string const &connectionString, std::string const &container, std::string const &blob, int parallelism_factor, int max_execution_time)

AzureOpenOptions constructor.

Parameters:

connectionString – The connectionString for the VDS
container – The container of the VDS
blob – The blob prefix of the VDS
parallelism_factor – The parallelism factor setting for the Azure Blob Storage library
max_execution_time – The max execution time setting for the Azure Blob Storage library

Public Members

std::string connectionString

std::string accountName

std::string bearerToken

std::string container

std::string blob

int parallelism_factor = 4

int max_execution_time = 100000

Public Static Functions

static inline AzureOpenOptions AzureOpenOptionsBearer(std::string const &accountName, std::string const &bearerToken, std::string const &container, std::string const &blob)

AzureOpenOptions factory function for bearer token based authentication.

Parameters:

bearerToken – The bearer token
container – The container of the VDS
blob – The blob prefix of the VDS

Returns:

A valid AzureOpenOptions

struct AzurePresignedOpenOptions : public OpenVDS::OpenOptions

#include <OpenVDS.h>

Options for opening a VDS with presigned Azure url.

Public Functions

inline AzurePresignedOpenOptions()

inline AzurePresignedOpenOptions(const std::string &baseUrl, const std::string &urlSuffix)

AzurePresignedOpenOptions constructor.

Parameters:

baseUrl – The base url for the VDS
urlSuffix – The suffix of the presigned url

Public Members

std::string baseUrl

std::string urlSuffix

struct DMSOpenOptions : public OpenVDS::OpenOptions

Public Functions

inline DMSOpenOptions()

inline DMSOpenOptions(std::string const &sdAuthorityUrl, std::string const &sdApiKey, std::string const &sdToken, std::string const &datasetPath, std::string const &authTokenUrl = std::string(), std::string const &refreshToken = std::string(), std::string const &clientId = std::string(), std::string const &clientSecret = std::string(), std::string const &scopes = std::string(), bool useFileNameForSingleFileDatasets = false, std::string const &legalTag = std::string(), std::string const &httpProxy = std::string())

inline DMSOpenOptions(std::string const &sdAuthorityUrl, std::string const &sdApiKey, std::string const &datasetPath, std::string (*authProviderCallback)(const void*), const void *authProviderCallbackData, bool useFileNameForSingleFileDatasets = false, std::string const &legalTag = std::string(), std::string const &httpProxy = std::string())

Public Members

std::string sdAuthorityUrl

std::string sdApiKey

std::string sdToken

std::string datasetPath

std::string authTokenUrl

std::string refreshToken

std::string clientId

std::string clientSecret

std::string scopes

bool useFileNameForSingleFileDatasets

std::string (*authProviderCallback)(const void*)

const void *authProviderCallbackData

std::string legalTag

std::string httpProxy

class Exception : public std::exception

Subclassed by OpenVDS::MessageBufferException< 16384 >, OpenVDS::MessageBufferException< 512 >, OpenVDS::MessageBufferException< BUFFERSIZE >

Public Functions

inline const char *what() const noexcept override

virtual const char *GetErrorMessage() const noexcept = 0

class FatalException : public OpenVDS::MessageBufferException<16384>

Public Functions

inline FatalException(const char *errorMessage)

inline FatalException(const FatalException &other)

inline FatalException &operator=(const FatalException &other)

inline virtual const char *GetErrorMessage() const noexcept override

class GlobalState

#include <GlobalState.h>

Object that contains global runtime data.

Public Functions

virtual uint64_t GetBytesDownloaded(OpenOptions::ConnectionType connectionType) = 0

Get the global amount of downloaded bytes from a cloud vendor.

Parameters:: connectionType – The counter to be retireved.
Returns:: Global number of bytes downloaded from the connection. This does not include any http header data.

virtual uint64_t GetChunksDownloaded(OpenOptions::ConnectionType connectionType) = 0

Get the global count of downloaded chunks.

Parameters:: connectionType – The counter to be retireved.
Returns:: Number of chunks downloaded.

virtual uint64_t GetBytesDecompressed(OpenOptions::ConnectionType connectionType) = 0

Get the global amount of decompressed bytes. This amount might be smaller than the amount of downloaded bytes because of a small header pr chunk. It can also be larger for non compressed data sets since chunks can be cached.

Parameters:: connectionType –
Returns:: Amount of decompressed bytes served the process.

virtual uint64_t GetChunksDecompressed(OpenOptions::ConnectionType connectionType) = 0

Get the global count of decompressed chunks.

Parameters:: connectionType – The counter to be retireved.
Returns:: Number of chunks decompressed.

virtual void SetLogCallback(LogCallback callback, void *userHandle) = 0

Set the log callback used to receive log messages from OpenVDS. It is safe to set the LogCallback before any other OpenVDS function is called.

Parameters:

callback – The function pointer to the callback.
userHandle – This is the pointer that will be passed into the callback functions userHandle parameter.

virtual void SetDefaultLogCallback() = 0: Set the default LogCallback This function sets the default logging interface that will print trace and info to stdout. It will print Warning and Error to the stderr file stream.

class GoogleCredentialsJson

#include <OpenVDS.h>

Credentials for opening a VDS in Google Cloud Storage by the string containing json with credentials Using OAuth.

Public Functions

inline explicit GoogleCredentialsJson(std::string const &json)

GoogleCredentialsJson constructor.

Parameters:: json – The string containing json with credentials

inline explicit GoogleCredentialsJson(std::string &&json) noexcept

class GoogleCredentialsPath

#include <OpenVDS.h>

Credentials for opening a VDS in Google Cloud Storage by path to the service account json file Using OAuth.

Public Functions

inline explicit GoogleCredentialsPath(std::string const &path)

GoogleCredentialsPath constructor.

Parameters:: path – The path to the service account json file

inline explicit GoogleCredentialsPath(std::string &&path) noexcept

class GoogleCredentialsSignedUrl

#include <OpenVDS.h>

Credentials for opening a VDS in Google Cloud Storage by using the default credentials Using signed URL mechanism.

Public Functions

inline explicit GoogleCredentialsSignedUrl(std::string const &region)

GoogleCredentialsSignedUrl constructor.

Parameters:: region – The string containing the region required for signature generation

inline explicit GoogleCredentialsSignedUrl(std::string &&region) noexcept

class GoogleCredentialsSignedUrlJson

#include <OpenVDS.h>

Credentials for opening a VDS in Google Cloud Storage by the string containing json with credentials Using signed URL mechanism.

Public Functions

inline explicit GoogleCredentialsSignedUrlJson(std::string const &region, std::string const &json)

GoogleCredentialsSignedUrlJson constructor.

Parameters:

region – The string containing the region required for signature generation
json – The string containing json with credentials

inline explicit GoogleCredentialsSignedUrlJson(std::string &&region, std::string const &json)

inline explicit GoogleCredentialsSignedUrlJson(std::string const &region, std::string &&json)

inline explicit GoogleCredentialsSignedUrlJson(std::string &&region, std::string &&json) noexcept

class GoogleCredentialsSignedUrlPath

#include <OpenVDS.h>

Credentials for opening a VDS in Google Cloud Storage by path to the service account json file Using signed URL mechanism.

Public Functions

inline explicit GoogleCredentialsSignedUrlPath(std::string const &region, std::string const &path)

GoogleCredentialsSignedUrlPath constructor.

Parameters:

region – The string containing the region required for signature generation
path – The path to the service account json file

inline explicit GoogleCredentialsSignedUrlPath(std::string &&region, std::string const &path)

inline explicit GoogleCredentialsSignedUrlPath(std::string const &region, std::string &&path)

inline explicit GoogleCredentialsSignedUrlPath(std::string &&region, std::string &&path) noexcept

class GoogleCredentialsToken

#include <OpenVDS.h>

Credentials for opening a VDS in Google Cloud Storage by using the string containing an access token Using OAuth.

Public Functions

inline explicit GoogleCredentialsToken(std::string const &token)

GoogleCredentialsToken constructor.

Parameters:: token – The string containing an access token

inline explicit GoogleCredentialsToken(std::string &&token) noexcept

struct GoogleOpenOptions : public OpenVDS::OpenOptions

#include <OpenVDS.h>

Options for opening a VDS in Google Cloud Storage.

Public Types

enum class CredentialsType : CredentialsIntType

Values:

enumerator Default

enumerator AccessToken

enumerator Path

enumerator Json

enumerator SignedUrl

enumerator SignedUrlPath

enumerator SignedUrlJson

using CredentialsIntType = unsigned int

Public Functions

inline GoogleOpenOptions()

inline GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix)

GoogleOpenOptions constructor.

Parameters:

bucket – The bucket of the VDS
pathPrefix – The prefix of the VDS
credentials – Google Cloud Storage access credentials

inline GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix, GoogleCredentialsToken const &credentials)

inline GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix, GoogleCredentialsPath const &credentials)

inline GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix, GoogleCredentialsJson const &credentials)

inline GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix, GoogleCredentialsSignedUrl const &credentials)

inline GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix, GoogleCredentialsSignedUrlPath const &credentials)

inline GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix, GoogleCredentialsSignedUrlJson const &credentials)

inline bool SetSignedUrl()

Public Members

CredentialsType credentialsType = CredentialsType::Default

std::string bucket

std::string pathPrefix

std::string credentials

std::string storageClass

std::string region

template<class T> class HeapBasedValueRangeEstimator

Public Functions

inline HeapBasedValueRangeEstimator(float percentile, uint64_t sampleCount)

template<typename InputIt, typename IsNan> inline void UpdateValueRange(InputIt first, InputIt last, IsNan isNan)

template<typename InputIt> inline void UpdateValueRange(InputIt first, InputIt last)

inline void GetValueRange(float &valueRangeMin, float &valueRangeMax)

inline int NaNCount() const

struct HttpOpenOptions : public OpenVDS::OpenOptions

#include <OpenVDS.h>

Options for opening a VDS with a plain HTTP url. If there are query parameters in then they will be appended to the different sub urls. The resulting IO backend will not support uploading data.

Public Functions

inline HttpOpenOptions()

inline HttpOpenOptions(std::string const &url)

HttpOpenOptions constructor.

Parameters:: url – The http base url of the VDS

Public Members

std::string url

class IHasVolumeDataAccess

Public Functions

virtual IVolumeDataAccessManager *GetVolumeDataAccessManager() = 0

struct IJKCoordinateTransformer

#include <IJKCoordinateTransformer.h>

IJKCoordinateTransformer may be used to transform between the following three-dimensional index and coordinate systems of a volume:

IJK Index - a 3D index into the volume based on IJK dimensions. Dimensions I and J are usually horizontal directions, whereas K is usually the vertical direction. Transforms are provided to/from integer IJK indexes and also floating-point IJK positions.

World Coordinate - a world position, related to IJK through the IJK grid definition provided on construction.

Annotation Coordinate - a coordinate position based on the annotation axes of the volume (inline, crossline, depth, time, etc.). The order of annotation coordinate values correspond to the volume axes for each IJK dimension. That is, the annotation coordinate X value specifies the coordinate for the annotation axis corresponding to the I direction, and so on. When used with a VDS, annotation coordinates are based on the VDS axis descriptors.

Voxel Index - a 3D index into the volume based on volume data dimesions, where dimension 0 is the data dimension that changes the fastest, dimension 1 is the data dimension that changes second fastest, etc. Transforms are provided to/from integer voxel indexes and also floating-point voxel positions. When used with a VDS, voxel index 0 refers to dimension 0, ranging from 0 to Dimension0Size - 1, and so on. The relationship between IJK dimensions and voxel dimensions is controlled by the IJK dimension map provided at construction. If the dimension map is (0, 1, 2), the IJK dimensions are the same as voxel dimensions. However, it is often the case that the dimension map is not (0, 1, 2), and so IJK dimensions are not the same as voxel dimensions, especially when used with a VDS. When used with a VDS, the dimension map is often set to (2, 1, 0), meaning that IJK corresponds to voxel dimensions (2, 1, 0). However, this is not a strict rule, and the dimension map will generally be defined based on the VDS axis descriptors. If a particular VDS axis is given the name “I”, “J”, or “K”, that axis index will be considered as dimension I, J, or K. This is not very common. If a particular VDS axis is given the name “Inline”, it will be considered as dimension I. If a particular VDS axis is given the name “Crossline”, it will be considered as dimension J. If a particular VDS axis is given the name “Time”, “Depth”, or “Sample”, it will be considered as dimension K.

Public Functions

inline IJKCoordinateTransformer()

inline IJKCoordinateTransformer(const IJKGridDefinition &ijkGridDefinition, const IntVector3 &ijkSize)

inline IJKCoordinateTransformer(const IJKGridDefinition &ijkGridDefinition, const IntVector3 &ijkSize, const IntVector3 &ijkToVoxelDimensionMap)

inline IJKCoordinateTransformer(const VDSIJKGridDefinition &vdsIJKGridDefinition, const IntVector3 &ijkSize)

inline IJKCoordinateTransformer(const IJKGridDefinition &ijkGridDefinition, const IntVector3 &ijkSize, const DoubleVector3 &ijkAnnotationStart, const DoubleVector3 &ijkAnnotationEnd)

inline IJKCoordinateTransformer(const IJKGridDefinition &ijkGridDefinition, const IntVector3 &ijkSize, const IntVector3 &ijkToVoxelDimensionMap, const DoubleVector3 &ijkAnnotationStart, const DoubleVector3 &ijkAnnotationEnd)

inline IJKCoordinateTransformer(const VDSIJKGridDefinition &vdsIJKGridDefinition, const IntVector3 &ijkSize, const DoubleVector3 &ijkAnnotationStart, const DoubleVector3 &ijkAnnotationEnd)

inline IJKCoordinateTransformer(const VolumeDataLayout *layout)

inline const IJKGridDefinition &IJKGrid() const: The IJK grid definition relating IJK coordinates to world XYZ coordinates.

inline const IntVector3 &IJKSize() const: The number of voxels in each IJK dimension.

inline const IntVector3 &IJKToVoxelDimensionMap() const: Mapping from IJK to voxel volume dimensions.

inline const DoubleMatrix4x4 &IJKToWorldTransform() const: The matrix used to transform from IJK coordinates to world coordinates.

inline const DoubleMatrix4x4 &WorldToIJKTransform() const: The matrix used to transform from world coordinates to IJK coordinates.

inline const DoubleVector3 &IJKAnnotationStart() const: The annotation start coordinates, corresponding to min IJK index (i.e. 0, 0, 0)

inline const DoubleVector3 &IJKAnnotationEnd() const: The annotation end coordinates, corresponding to max IJK index (i.e. IJKSize - (1, 1, 1))

inline bool AnnotationsDefined() const: Whether or not the annotation start/end coordinates are set, which defines the annotation coordinate system.

inline DoubleVector3 IJKPositionToWorld(const DoubleVector3 &ijkPosition) const: Transform the given IJK position to a world position.

inline DoubleVector3 IJKIndexToWorld(const IntVector3 &ijkIndex) const: Transform the given IJK index to a world position.

inline DoubleVector3 IJKPositionToAnnotation(const DoubleVector3 &ijkPosition) const: Transform the given IJK position to an annotation position.

inline DoubleVector3 IJKIndexToAnnotation(const IntVector3 &ijkIndex) const: Transform the given IJK index to an annotation position.

inline DoubleVector3 IJKPositionToVoxelPosition(const DoubleVector3 &ijkPosition) const: Transform the given IJK position to a voxel position.

inline IntVector3 IJKIndexToVoxelIndex(const IntVector3 &ijkIndex) const: Transform the given IJK index to a voxel index.

inline DoubleVector3 WorldToIJKPosition(const DoubleVector3 &worldPosition) const: Transform the given world position to a IJK position.

inline IntVector3 WorldToIJKIndex(const DoubleVector3 &worldPosition) const: Transform the given world position to a IJK index.

inline DoubleVector3 WorldToAnnotation(DoubleVector3 worldPosition) const: Transform the given world position to an annotation position.

inline DoubleVector3 WorldToVoxelPosition(const DoubleVector3 &worldPosition) const: Transform the given world position to a voxel position.

inline IntVector3 WorldToVoxelIndex(const DoubleVector3 &worldPosition) const: Transform the given world position to a voxel index.

inline DoubleVector3 AnnotationToIJKPosition(const DoubleVector3 &annotationPosition) const: Transform the given annotation position to a IJK position.

inline IntVector3 AnnotationToIJKIndex(const DoubleVector3 &annotationPosition) const: Transform the given annotation position to a IJK index.

inline DoubleVector3 AnnotationToWorld(DoubleVector3 annotationPosition) const: Transform the given annotation position to a world position.

inline DoubleVector3 AnnotationToVoxelPosition(const DoubleVector3 &annotationPosition) const: Transform the given annotation position to a voxel position.

inline IntVector3 AnnotationToVoxelIndex(const DoubleVector3 &annotationPosition) const: Transform the given annotation position to a voxel index.

inline DoubleVector3 VoxelPositionToIJKPosition(const DoubleVector3 &voxelPosition) const: Transform the given voxel position to an IJK position.

inline IntVector3 VoxelIndexToIJKIndex(const IntVector3 &voxelIndex) const: Transform the given voxel index to an IJK index.

inline DoubleVector3 VoxelPositionToWorld(const DoubleVector3 &voxelPosition) const: Transform the given voxel position to a world position.

inline DoubleVector3 VoxelIndexToWorld(const IntVector3 &voxelIndex) const: Transform the given voxel index to a world position.

inline DoubleVector3 VoxelPositionToAnnotation(const DoubleVector3 &voxelPosition) const: Transform the given voxel position to an annotation position.

inline DoubleVector3 VoxelIndexToAnnotation(const IntVector3 &voxelIndex) const: Transform the given voxel index to an annotation position.

inline bool IsIJKPositionOutOfRange(const DoubleVector3 &ijkPosition) const: Determine whether the given IJK position is out of range.

inline bool IsIJKIndexOutOfRange(const IntVector3 &ijkIndex) const: Determine whether the given IJK index is out of range.

inline bool IsVoxelPositionOutOfRange(const DoubleVector3 &voxelPosition) const: Determine whether the given voxel position is out of range.

inline bool IsVoxelIndexOutOfRange(const IntVector3 &voxelIndex) const: Determine whether the given voxel index is out of range.

inline IntVector3 ConvertIJKPositionToIndex(const DoubleVector3 &ijkPosition) const: Convert the given IJK position to IJK index. Return (-1, -1, -1) if any component is outside valid range.

inline IntVector3 ConvertVoxelPositionToIndex(const DoubleVector3 &voxelPosition) const: Convert the given voxel position to voxel index. Return (-1, -1, -1) if any component is outside valid range.

inline bool operator==(const IJKCoordinateTransformer &rhs) const: Equality operator.

inline int ErrorCodeIfIJKPositionOutOfRange(const DoubleVector3 &ijkPosition) const

inline int ErrorCodeIfVoxelPositionOutOfRange(const DoubleVector3 &voxelPosition) const

struct IJKGridDefinition

Subclassed by OpenVDS::VDSIJKGridDefinition

Public Functions

inline IJKGridDefinition()

inline IJKGridDefinition(DoubleVector3 origin, DoubleVector3 iUnitStep, DoubleVector3 jUnitStep, DoubleVector3 kUnitStep)

inline bool operator==(const IJKGridDefinition &b) const

Public Members

DoubleVector3 origin

DoubleVector3 iUnitStep

DoubleVector3 jUnitStep

DoubleVector3 kUnitStep

class IndexOutOfRangeException : public OpenVDS::MessageBufferException<512>

Public Functions

inline IndexOutOfRangeException(const char *errorMessage)

inline IndexOutOfRangeException(const IndexOutOfRangeException &other)

inline IndexOutOfRangeException &operator=(const IndexOutOfRangeException &other)

inline virtual const char *GetErrorMessage() const noexcept override

template<typename T> struct IndexRegion

Public Functions

inline IndexRegion()

inline IndexRegion(T Min, T Max)

Public Members

T Min

T Max

struct InMemoryOpenOptions : public OpenVDS::OpenOptions

#include <OpenVDS.h>

Options for opening a VDS which is stored in memory (for testing)

Public Functions

inline InMemoryOpenOptions()

inline InMemoryOpenOptions(const char *name)

inline InMemoryOpenOptions(const std::string &name)

Public Members

std::string name

template<typename T> struct InterpolatedRealType

Public Types

typedef float type

template<> struct InterpolatedRealType<double>

Public Types

typedef double type

template<> struct InterpolatedRealType<uint32_t>

Public Types

typedef double type

template<> struct InterpolatedRealType<uint64_t>

Public Types

typedef double type

class InvalidArgument : public OpenVDS::MessageBufferException<512>

Public Functions

inline InvalidArgument(const char *errorMessage, const char *parameterName)

inline InvalidArgument(const InvalidArgument &other)

inline InvalidArgument &operator=(const InvalidArgument &other)

inline virtual const char *GetErrorMessage() const noexcept override

inline const char *GetParameterName() const noexcept

class InvalidOperation : public OpenVDS::MessageBufferException<512>

Public Functions

inline InvalidOperation(const char *errorMessage)

inline InvalidOperation(const InvalidOperation &other)

inline InvalidOperation &operator=(const InvalidOperation &other)

inline virtual const char *GetErrorMessage() const noexcept override

class IVolumeDataAccessManager

Public Types

typedef void (*ErrorHandler)(Error *error, int errorCode, const char *errorMessage)

Public Functions

virtual void AddRef() = 0

virtual void Release() = 0

virtual int RefCount() const = 0

virtual VolumeDataLayout const *GetVolumeDataLayout() = 0

Get the VolumeDataLayout object for a VDS.

Returns:: The VolumeDataLayout object associated with the VDS or NULL if there is no valid VolumeDataLayout.

virtual VDSProduceStatus GetVDSProduceStatus(DimensionsND dimensionsND, int LOD, int channel) = 0

Get the produce status for the specific DimensionsND/LOD/Channel combination.

Parameters:

dimensionsND – The dimensions group we’re getting the produce status for.
LOD – The LOD level we’re getting the produce status for.
channel – The channel index we’re getting the produce status for.

Returns:

The produce status for the specific DimensionsND/LOD/Channel combination.

virtual int64_t GetVDSChunkCount(DimensionsND dimensionsND, int LOD, int channel) = 0

Get the chunk count for the specific DimensionsND/LOD/Channel combination.

Parameters:

dimensionsND – The dimensions group we’re getting the chunk count for.
LOD – The LOD level we’re getting the chunk count status for.
channel – The channel index we’re getting the chunk count status for.

Returns:

The chunk count for the specific DimensionsND/LOD/Channel combination.

virtual VolumeDataPageAccessor *CreateVolumeDataPageAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, VolumeDataPageAccessor::AccessMode accessMode, int chunkMetadataPageSize = 1024) = 0

Create a VolumeDataPageAccessor object for the VDS.

Parameters:

dimensionsND – The dimensions group that the volume data page accessor will access.
LOD – The LOD level that the volume data page accessor will access.
channel – The channel index that the volume data page accessor will access.
maxPages – The maximum number of pages that the volume data page accessor will cache.
accessMode – This specifies the access mode (ReadOnly/ReadWrite/Create) of the volume data page accessor.
chunkMetadataPageSize – The chunk metadata page size of the layer. This controls how many chunk metadata entries are written per page, and is only used when the access mode is Create. If this number is too low it will degrade performance, but in certain situations it can be advantageous to make this number a multiple of the number of chunks in some of the dimensions. Do not change this from the default (1024) unless you know exactly what you are doing.

Returns:

A VolumeDataPageAccessor object for the VDS.

virtual void DestroyVolumeDataPageAccessor(VolumeDataPageAccessor *volumeDataPageAccessor) = 0

Destroy a volume data page accessor object.

Parameters:: volumeDataPageAccessor – The VolumeDataPageAccessor object to destroy.

virtual void DestroyVolumeDataAccessor(IVolumeDataAccessor *accessor) = 0

virtual IVolumeDataAccessor *CloneVolumeDataAccessor(IVolumeDataAccessor const &accessor) = 0

virtual IVolumeDataReadWriteAccessor<IntVector2, bool> *Create2DVolumeDataAccessor1Bit(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector2, uint8_t> *Create2DVolumeDataAccessorU8(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector2, uint16_t> *Create2DVolumeDataAccessorU16(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector2, uint32_t> *Create2DVolumeDataAccessorU32(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector2, uint64_t> *Create2DVolumeDataAccessorU64(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector2, float> *Create2DVolumeDataAccessorR32(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector2, double> *Create2DVolumeDataAccessorR64(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector3, bool> *Create3DVolumeDataAccessor1Bit(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector3, uint8_t> *Create3DVolumeDataAccessorU8(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector3, uint16_t> *Create3DVolumeDataAccessorU16(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector3, uint32_t> *Create3DVolumeDataAccessorU32(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector3, uint64_t> *Create3DVolumeDataAccessorU64(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector3, float> *Create3DVolumeDataAccessorR32(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector3, double> *Create3DVolumeDataAccessorR64(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector4, bool> *Create4DVolumeDataAccessor1Bit(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector4, uint8_t> *Create4DVolumeDataAccessorU8(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector4, uint16_t> *Create4DVolumeDataAccessorU16(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector4, uint32_t> *Create4DVolumeDataAccessorU32(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector4, uint64_t> *Create4DVolumeDataAccessorU64(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector4, float> *Create4DVolumeDataAccessorR32(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadWriteAccessor<IntVector4, double> *Create4DVolumeDataAccessorR64(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue) = 0

virtual IVolumeDataReadAccessor<FloatVector2, float> *Create2DInterpolatingVolumeDataAccessorR32(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue, InterpolationMethod interpolationMethod) = 0

virtual IVolumeDataReadAccessor<FloatVector2, double> *Create2DInterpolatingVolumeDataAccessorR64(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue, InterpolationMethod interpolationMethod) = 0

virtual IVolumeDataReadAccessor<FloatVector3, float> *Create3DInterpolatingVolumeDataAccessorR32(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue, InterpolationMethod interpolationMethod) = 0

virtual IVolumeDataReadAccessor<FloatVector3, double> *Create3DInterpolatingVolumeDataAccessorR64(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue, InterpolationMethod interpolationMethod) = 0

virtual IVolumeDataReadAccessor<FloatVector4, float> *Create4DInterpolatingVolumeDataAccessorR32(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue, InterpolationMethod interpolationMethod) = 0

virtual IVolumeDataReadAccessor<FloatVector4, double> *Create4DInterpolatingVolumeDataAccessorR64(VolumeDataPageAccessor *volumeDataPageAccessor, float replacementNoValue, InterpolationMethod interpolationMethod) = 0

virtual int64_t GetVolumeSubsetBufferSize(const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], VolumeDataFormat format, int LOD = 0, int channel = 0) = 0

Compute the buffer size (in bytes) for a volume subset request.

Parameters:

minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
format – Voxel format of the destination buffer.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.

Returns:

The buffer size needed.

virtual int64_t RequestVolumeSubset(void *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], VolumeDataFormat format, optional<float> replacementNoValue = optional<float>()) = 0

Request a subset of the input VDS.

Parameters:

buffer – Pointer to a preallocated buffer holding at least as many elements of format as indicated by minVoxelCoordinates and maxVoxelCoordinates.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
format – Voxel format of the destination buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

The RequestID which can be used to query the status of the request, cancel the request or wait for the request to complete.

virtual int64_t GetProjectedVolumeSubsetBufferSize(const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], DimensionsND projectedDimensions, VolumeDataFormat format, int LOD = 0, int channel = 0) = 0

Compute the buffer size (in bytes) for a projected volume subset request.

Parameters:

minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
projectedDimensions – The 2D dimension group that the plane in the source dimensiongroup is projected into. It must be a 2D subset of the source dimensions.
format – Voxel format of the destination buffer.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.

Returns:

The buffer size needed.

virtual int64_t RequestProjectedVolumeSubset(void *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], FloatVector4 const &voxelPlane, DimensionsND projectedDimensions, VolumeDataFormat format, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>()) = 0

Request a subset projected from an arbitrary 3D plane through the subset onto one of the sides of the subset.

Parameters:

buffer – Pointer to a preallocated buffer holding at least as many elements of format as indicated by minVoxelCoordinates and maxVoxelCoordinates for the projected dimensions.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
voxelPlane – The plane equation for the projection from the dimension source to the projected dimensions (which must be a 2D subset of the source dimensions).
projectedDimensions – The 2D dimension group that the plane in the source dimensiongroup is projected into. It must be a 2D subset of the source dimensions.
interpolationMethod – Interpolation method to use when sampling the buffer.
format – Voxel format of the destination buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

The RequestID which can be used to query the status of the request, cancel the request or wait for the request to complete.

virtual int64_t GetVolumeSamplesBufferSize(int sampleCount, int channel = 0) = 0

Compute the buffer size (in bytes) for a volume samples request.

Parameters:

sampleCount – Number of samples to request.
channel – The channel index the requested data is read from.

Returns:

The buffer size needed.

virtual int64_t RequestVolumeSamples(float *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const float (*samplePositions)[VolumeDataLayout::Dimensionality_Max], int sampleCount, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>()) = 0

Request sampling of the input VDS at the specified coordinates.

Parameters:

buffer – Pointer to a preallocated buffer holding at least sampleCount elements.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
samplePositions – Pointer to array of VolumeDataLayout::Dimensionality_Max-elements indicating the positions to sample. May be deleted once RequestVolumeSamples return, as HueSpace makes a deep copy of the data.
sampleCount – Number of samples to request.
interpolationMethod – Interpolation method to use when sampling the buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

The RequestID which can be used to query the status of the request, cancel the request or wait for the request to complete.

virtual int64_t GetVolumeTracesBufferSize(int traceCount, int traceDimension, int LOD = 0, int channel = 0) = 0

Compute the buffer size (in bytes) for a volume traces request.

Parameters:

traceCount – Number of traces to request.
traceDimension – The dimension to trace
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.

Returns:

The buffer size needed.

virtual int64_t RequestVolumeTraces(float *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const float (*tracePositions)[VolumeDataLayout::Dimensionality_Max], int traceCount, InterpolationMethod interpolationMethod, int traceDimension, optional<float> replacementNoValue = optional<float>()) = 0

Request traces from the input VDS.

Parameters:

buffer – Pointer to a preallocated buffer holding at least traceCount * number of samples in the traceDimension.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
tracePositions – Pointer to array of traceCount VolumeDataLayout::Dimensionality_Max-elements indicating the trace positions.
traceCount – Number of traces to request.
interpolationMethod – Interpolation method to use when sampling the buffer.
traceDimension – The dimension to trace
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

The RequestID which can be used to query the status of the request, cancel the request or wait for the request to complete.

virtual int64_t PrefetchVolumeChunk(DimensionsND dimensionsND, int LOD, int channel, int64_t chunkIndex) = 0

Force production of a specific volume data chunk.

Parameters:

dimensionsND – The dimensiongroup the requested chunk belongs to.
LOD – The LOD level the requested chunk belongs to.
channel – The channel index the requested chunk belongs to.
chunkIndex – The index of the chunk to prefetch.

Returns:

The RequestID which can be used to query the status of the request, cancel the request or wait for the request to complete.

virtual bool IsCompleted(int64_t requestID) = 0

Check if a request completed successfully. If the request completed, the buffer now contains valid data.

Parameters:: requestID – The RequestID to check for completion.
Returns:: Either IsCompleted, IsCanceled or WaitForCompletion will return true a single time, after that the request is taken out of the system.

virtual bool IsCanceled(int64_t requestID) = 0

Check if a request was canceled (e.g. the VDS was invalidated before the request was processed). If the request was canceled, the buffer does not contain valid data.

Parameters:: requestID – The RequestID to check for cancellation.
Returns:: Either IsCompleted, IsCanceled or WaitForCompletion will return true a single time, after that the request is taken out of the system.

virtual bool IsCanceled(int64_t requestID, ReadErrorException *error) = 0

Check if a request was canceled (e.g. the VDS was invalidated before the request was processed). If the request was canceled, the buffer does not contain valid data.

Parameters:

requestID – The RequestID to check for cancellation.
error – This out parameter will be set to the error that caused the cancellation.

Returns:

Either IsCompleted, IsCanceled or WaitForCompletion will return true a single time, after that the request is taken out of the system.

virtual bool WaitForCompletion(int64_t requestID, int millisecondsBeforeTimeout = 0) = 0

Wait for a request to complete successfully. If the request completed, the buffer now contains valid data.

Parameters:

requestID – The RequestID to wait for completion of.
millisecondsBeforeTimeout – The number of milliseconds to wait before timing out (optional). A value of 0 indicates there is no timeout and we will wait for however long it takes. Note that the request is not automatically canceled if the wait times out, you can also use this mechanism to e.g. update a progress bar while waiting. If you want to cancel the request you have to explicitly call CancelRequest() and then wait for the request to stop writing to the buffer.

Returns:

Either IsCompleted, IsCanceled or WaitForCompletion will return true a single time, after that the request is taken out of the system. Whenever WaitForCompletion returns false you need to call IsCanceled() to know if that was because of a timeout or if the request was canceled.

virtual void Cancel(int64_t requestID) = 0

Try to cancel the request. You still have to call WaitForCompletion/IsCanceled to make sure the buffer is not being written to and to take the job out of the system. It is possible that the request has completed concurrently with the call to Cancel in which case WaitForCompletion will return true.

Parameters:: requestID – The RequestID to cancel.

virtual void CancelAndWaitForCompletion(int64_t requestID) = 0

Cancel the request and wait for it to complete. This call will block until the request has completed so you can be sure the buffer is not being written to and the job is taken out of the system.

Parameters:: requestID – The RequestID to cancel.

virtual float GetCompletionFactor(int64_t requestID) = 0

Get the completion factor (between 0 and 1) of the request.

Parameters:: requestID – The RequestID to get the completion factor of.
Returns:: A factor (between 0 and 1) indicating how much of the request has been completed.

virtual void Flush(ErrorHandler errorHandler, Error *error = nullptr) = 0: Flush any pending writes and write updated layer status.

Public Static Attributes

static constexpr int Dimensionality_Max = VolumeDataLayout::Dimensionality_Max: the maximum number of dimensions a VDS can have

class IVolumeDataAccessor

Subclassed by OpenVDS::IVolumeDataAccessorWithRegions< INDEX >

Public Functions

virtual Manager &GetManager() = 0

virtual VolumeDataLayout const *GetLayout() = 0

class Manager

Public Functions

virtual void DestroyVolumeDataAccessor(IVolumeDataAccessor *accessor) = 0

virtual IVolumeDataAccessor *CloneVolumeDataAccessor(IVolumeDataAccessor const &accessor) = 0

template<typename INDEX> class IVolumeDataAccessorWithRegions : public OpenVDS::IVolumeDataAccessor, public OpenVDS::IVolumeDataRegions<INDEX>

Subclassed by OpenVDS::IVolumeDataReadAccessor< INDEX, T >

Public Functions

virtual IndexRegion<INDEX> CurrentRegion() = 0

template<typename INDEX, typename T> class IVolumeDataReadAccessor : public OpenVDS::IVolumeDataAccessorWithRegions<INDEX>

Subclassed by OpenVDS::IVolumeDataReadWriteAccessor< INDEX, T >

Public Functions

virtual T GetValue(INDEX index) = 0

template<typename INDEX, typename T> class IVolumeDataReadWriteAccessor : public OpenVDS::IVolumeDataReadAccessor<INDEX, T>

Public Functions

virtual void SetValue(INDEX index, T value) = 0

virtual void Commit() = 0

virtual void Cancel() = 0

template<typename INDEX> class IVolumeDataRegions

Subclassed by OpenVDS::IVolumeDataAccessorWithRegions< INDEX >

Public Functions

virtual int64_t RegionCount() = 0

virtual IndexRegion<INDEX> Region(int64_t region) = 0

virtual int64_t RegionFromIndex(INDEX index) = 0

class KnownAxisNames

Public Static Functions

static inline const char *Inline(): String representing the name of the axis corresponding to the inline spacing.

static inline const char *Crossline(): String representing the name of the axis corresponding to the crossline spacing.

static inline const char *Time(): String representing the name of the axis corresponding to the negative z direction.

static inline const char *Depth(): String representing the name of the axis corresponding to the negative z direction.

static inline const char *Sample(): String representing the name of the axis corresponding to the negative z direction.

static inline const char *I(): String representing the name of the axis corresponding to the I step vector (SurveyCoordinateSystemIStepVector)

static inline const char *J(): String representing the name of the axis corresponding to the J step vector (SurveyCoordinateSystemIStepVector)

static inline const char *K(): String representing the name of the axis corresponding to the K step vector (SurveyCoordinateSystemKStepVector)

static inline const char *X(): String representing the name of the axis that maps directly to the X coordinate in the XYZ coordinate system.

static inline const char *Y(): String representing the name of the axis that maps directly to the Y coordinate in the XYZ coordinate system.

static inline const char *Z(): String representing the name of the axis that maps directly to the Z coordinate in the XYZ coordinate system.

class KnownMetadata

Public Static Functions

static inline const char *CategorySurveyCoordinateSystem()

The metadata in the survey coordinate system category contains either information used to transform from an Inline/Crossline annotation system to XY (Easting, Northing) coordinates or information used to transform from an I/J/K annotation system to XYZ coordinates.

In the Inline/Crossline system, the step vector for dimension 0 (Which can be named either Time, Depth or Sample) is always negative Z direction. The origin is the position of (inline, crossline) (0, 0), the inline spacing is the (X, Y) step when the inline position increments by 1 and the crossline spacing is the (X, Y) step when the crossline position increments by 1.

In the I/J/K system, all three dimensions have 3D step vectors allowing for any affine tranform to XYZ coordinates. The IJK origin is the position of (I, J, K) (0, 0, 0), the I step vector is the (X, Y, Z) step when the I position increments by 1, the J step vector is the (X, Y, Z) step when the J position increments by 1 and the K step vector is the (X, Y, Z) step when the K position increments by 1.

It is also possible to define the X, Y, Z coordinates directly by using X/Y/Z as the axis names.

Any dimensions which have names that are not recognized or are missing the Spacing metadata will be given a unit vector perpendicular to the recognized dimensions.

static inline MetadataKey SurveyCoordinateSystemOrigin(): The XY position of the origin of the annotation (Inline/Crossline/Time) coordinate system.

static inline MetadataKey SurveyCoordinateSystemInlineSpacing(): The XY spacing between units in the Inline annotation dimension.

static inline MetadataKey SurveyCoordinateSystemCrosslineSpacing(): The XY spacing between units in the Crossline annotation dimension.

static inline MetadataKey SurveyCoordinateSystemGridPoint0(): An optional reference point in the grid, the annotation coordinates for this point are GridPoint0Inline and GridPoint0Crossline.

static inline MetadataKey SurveyCoordinateSystemGridPoint0Inline(): The inline annotation coordinate for the point defined by GridPoint0.

static inline MetadataKey SurveyCoordinateSystemGridPoint0Crossline(): The inline annotation coordinate for the point defined by GridPoint0.

static inline MetadataKey SurveyCoordinateSystemGridPoint1(): An optional reference point in the grid, the annotation coordinates for this point are GridPoint1Inline and GridPoint1Crossline.

static inline MetadataKey SurveyCoordinateSystemGridPoint1Inline(): The inline annotation coordinate for the point defined by GridPoint1.

static inline MetadataKey SurveyCoordinateSystemGridPoint1Crossline(): The inline annotation coordinate for the point defined by GridPoint1.

static inline MetadataKey SurveyCoordinateSystemGridPoint2(): An optional reference point in the grid, the annotation coordinates for this point are GridPoint2Inline and GridPoint2Crossline.

static inline MetadataKey SurveyCoordinateSystemGridPoint2Inline(): The inline annotation coordinate for the point defined by GridPoint2.

static inline MetadataKey SurveyCoordinateSystemGridPoint2Crossline(): The inline annotation coordinate for the point defined by GridPoint2.

static inline MetadataKey SurveyCoordinateSystemGridPoint3(): An optional reference point in the grid, the annotation coordinates for this point are GridPoint3Inline and GridPoint3Crossline.

static inline MetadataKey SurveyCoordinateSystemGridPoint3Inline(): The inline annotation coordinate for the point defined by GridPoint3.

static inline MetadataKey SurveyCoordinateSystemGridPoint3Crossline(): The inline annotation coordinate for the point defined by GridPoint3.

static inline MetadataKey SurveyCoordinateSystemIJKOrigin(): The XYZ position of the origin of the annotation (I/J/K) coordinate system.

static inline MetadataKey SurveyCoordinateSystemIStepVector(): The step vector corresponding to dimension named ‘I’.

static inline MetadataKey SurveyCoordinateSystemJStepVector(): The step vector corresponding to dimension named ‘J’.

static inline MetadataKey SurveyCoordinateSystemKStepVector(): The step vector corresponding to dimension named ‘K’.

static inline MetadataKey SurveyCoordinateSystemUnit(): The unit of the coordinate system.

static inline MetadataKey SurveyCoordinateSystemCRSWkt(): The well-known text representation of the coordinate reference system.

static inline const char *CategoryTraceCoordinates(): The metadata in the TraceCoordinates category is used for positioning of 2D seismic. It relates to the ‘Trace’ dimension of the VDS where the annotation coordinate is used to look up in the arrays in this category. This allows using the same positions with subsetted and interpolated or decimated data.

static inline MetadataKey TracePositions(): An array of DoubleVector2 defining the position for each trace, where (0, 0) is treated as an undefined position.

static inline MetadataKey TraceVerticalOffsets(): An array of doubles defining the offset for each trace from the vertical start position in the Time/Depth/Sample dimension of the VDS.

static inline MetadataKey EnergySourcePointNumbers(): An array of scalar int32 values defining the energy source point number for each trace.

static inline MetadataKey EnsembleNumbers(): An array of scalar int32 values defining the ensemble number for each trace.

static inline const char *CategoryWrittenRegion(): The metadata in the WrittenRegion category is used to indicate which area is written in a sparsely populated VDS. The guarantee is that values outside the written area will be NoValue if UseNoValue is true, and ValueRange.Min if UseNoValue is false.

static inline MetadataKey WrittenRegion(): An array of scalar int32 values defining the 6D min and max (NDBox) of the written region.

static inline const char *CategoryStatistics(): This metadata category has statistics generated from the values written to the VDS.

static inline MetadataKey ActualValueRange(): The actual value range of the data written to the primary channel (excluding NoValues)

static inline MetadataKey Histogram(): An array of histogram counts (int64) for each bucket of the histogram using the channel’s value range of the data written to the primary channel (excluding NoValues)

static inline const char *CategoryImportInformation(): The metadata in the ImportInformation category contains information about the initial import to VDS. That is, information about the original file (file name, last modification time etc.) and when/how it was imported. The intended use is e.g. to give a default file name for an export operation or to inform the user about whether the VDS was imported from some particular file.

static inline MetadataKey ImportInformationDisplayName(): An informative name that can be displayed to a user but is not necessarily a valid file name.

static inline MetadataKey ImportInformationInputFileName(): The original input file name. In cases where the input is not a simple file this should still be a valid file name that can be used as the default for a subsequent export operation.

static inline MetadataKey ImportInformationInputFileSize(): The total size (in bytes) of the input file(s), which is an integer stored as a double because there is no 64-bit integer metadata type.

static inline MetadataKey ImportInformationInputTimeStamp(): The last modified time of the input in ISO8601 format.

static inline MetadataKey ImportInformationImportTimeStamp(): The time in ISO8601 format when the data was imported to VDS.

static inline const char *CategorySEGY(): The metadata in the SEGY category is intended to capture information required to re-create the original SEG-Y file. It is only present if the VDS was imported from a SEG-Y file.

static inline MetadataKey SEGYTextHeader(): The original text header of the SEG-Y file.

static inline MetadataKey SEGYBinaryHeader(): The original binary header of the SEG-Y file.

static inline MetadataKey SEGYEndianness(): The endianness of the SEG-Y file (0=BigEndian)(1=LittleEndian)

static inline MetadataKey SEGYDataEndianness(): The endianness of the data samples in the SEG-Y file if different from the header endianness. This is a non-standard feature, but some SEG-Y files use it. (0=BigEndian)(1=LittleEndian)

static inline MetadataKey SEGYDataSampleFormatCode(): The data sample format code of the data samples imported from the SEG-Y file. (0=Unknown)(1=IBMFloat)(2=Int32)(3=Int16)(4=FixedPoint)(5=IEEEFloat)(6=IEEEDouble)(7=Int24)(8=Int8)(9=Int64)(10=UInt32)(11=UInt16)(12=UInt64)(15=UInt24)(16=UInt8)

static inline MetadataKey SEGYPrimaryKey(): The primary key (i.e. sort order) of the original SEG-Y file. VDSs are expected to transpose crossline-oriented seismic to use the standard (Sample, Crossline, Inline) axis triple, so in order to export the file in the original order we need to know which dimension to loop over.

class KnownUnitNames

Public Static Functions

static inline const char *Meter(): String representing the SI meter unit.

static inline const char *Millisecond(): String representing the SI milliseconds unit.

static inline const char *Foot(): String representing the foot unit.

static inline const char *USSurveyFoot(): String representing the US survey foot unit.

static inline const char *Second(): String representing the SI second unit.

static inline const char *MetersPerSecond(): String representing the meters per second unit.

static inline const char *FeetPerSecond(): String representing the feet per second unit.

static inline const char *USSurveyFeetPerSecond(): String representing the US survey feet per second unit.

static inline const char *Unitless(): String representing unitless.

struct M4

Public Members

DoubleVector4 data[4]

template<typename T, size_t SIZE> struct Matrix

Public Types

Values:

enumerator element_count

typedef T element_type

Public Functions

inline Matrix()

Public Members

Vector<T, SIZE> data[SIZE]

template<int BUFFERSIZE> class MessageBufferException : public OpenVDS::Exception

Public Types

Values:

enumerator MESSAGE_BUFFER_SIZE

class MetadataContainer : public OpenVDS::MetadataReadAccess, public OpenVDS::MetadataWriteAccess

Public Functions

MetadataContainer() = default

inline virtual bool IsMetadataIntAvailable(const char *category, const char *name) const override: Returns true if a metadata int with the given category and name is available.

inline virtual bool IsMetadataIntVector2Available(const char *category, const char *name) const override: Returns true if a metadata IntVector2 with the given category and name is available.

inline virtual bool IsMetadataIntVector3Available(const char *category, const char *name) const override: Returns true if a metadata IntVector3 with the given category and name is available.

inline virtual bool IsMetadataIntVector4Available(const char *category, const char *name) const override: Returns true if a metadata IntVector4 with the given category and name is available.

inline virtual bool IsMetadataFloatAvailable(const char *category, const char *name) const override: Returns true if a metadata float with the given category and name is available.

inline virtual bool IsMetadataFloatVector2Available(const char *category, const char *name) const override: Returns true if a metadata FloatVector2 with the given category and name is available.

inline virtual bool IsMetadataFloatVector3Available(const char *category, const char *name) const override: Returns true if a metadata FloatVector3 with the given category and name is available.

inline virtual bool IsMetadataFloatVector4Available(const char *category, const char *name) const override: Returns true if a metadata FloatVector4 with the given category and name is available.

inline virtual bool IsMetadataDoubleAvailable(const char *category, const char *name) const override: Returns true if a metadata double with the given category and name is available.

inline virtual bool IsMetadataDoubleVector2Available(const char *category, const char *name) const override: Returns true if a metadata DoubleVector2 with the given category and name is available.

inline virtual bool IsMetadataDoubleVector3Available(const char *category, const char *name) const override: Returns true if a metadata DoubleVector3 with the given category and name is available.

inline virtual bool IsMetadataDoubleVector4Available(const char *category, const char *name) const override: Returns true if a metadata DoubleVector4 with the given category and name is available.

inline virtual bool IsMetadataStringAvailable(const char *category, const char *name) const override: Returns true if a metadata string with the given category and name is available.

inline virtual bool IsMetadataBLOBAvailable(const char *category, const char *name) const override: Returns true if a metadata BLOB with the given category and name is available.

inline virtual int GetMetadataInt(const char *category, const char *name) const override: Returns the metadata int with the given category and name.

inline virtual IntVector2 GetMetadataIntVector2(const char *category, const char *name) const override: Returns the metadata IntVector2 with the given category and name.

inline virtual IntVector3 GetMetadataIntVector3(const char *category, const char *name) const override: Returns the metadata IntVector3 with the given category and name.

inline virtual IntVector4 GetMetadataIntVector4(const char *category, const char *name) const override: Returns the metadata IntVector4 with the given category and name.

inline virtual float GetMetadataFloat(const char *category, const char *name) const override: Returns the metadata float with the given category and name.

inline virtual FloatVector2 GetMetadataFloatVector2(const char *category, const char *name) const override: Returns the metadata FloatVector2 with the given category and name.

inline virtual FloatVector3 GetMetadataFloatVector3(const char *category, const char *name) const override: Returns the metadata FloatVector3 with the given category and name.

inline virtual FloatVector4 GetMetadataFloatVector4(const char *category, const char *name) const override: Returns the metadata FloatVector4 with the given category and name.

inline virtual double GetMetadataDouble(const char *category, const char *name) const override: Returns the metadata double with the given category and name.

inline virtual DoubleVector2 GetMetadataDoubleVector2(const char *category, const char *name) const override: Returns the metadata DoubleVector2 with the given category and name.

inline virtual DoubleVector3 GetMetadataDoubleVector3(const char *category, const char *name) const override: Returns the metadata DoubleVector3 with the given category and name.

inline virtual DoubleVector4 GetMetadataDoubleVector4(const char *category, const char *name) const override: Returns the metadata DoubleVector4 with the given category and name.

inline virtual const char *GetMetadataString(const char *category, const char *name) const override: Returns the metadata string with the given category and name.

inline virtual void SetMetadataInt(const char *category, const char *name, int value) override: Sets a metadata int with the given category and name to the given value.

inline virtual void SetMetadataIntVector2(const char *category, const char *name, IntVector2 value) override: Sets a metadata IntVector2 with the given category and name to the given value.

inline virtual void SetMetadataIntVector3(const char *category, const char *name, IntVector3 value) override: Sets a metadata IntVector3 with the given category and name to the given value.

inline virtual void SetMetadataIntVector4(const char *category, const char *name, IntVector4 value) override: Sets a metadata IntVector4 with the given category and name to the given value.

inline virtual void SetMetadataFloat(const char *category, const char *name, float value) override: Sets a metadata float with the given category and name to the given value.

inline virtual void SetMetadataFloatVector2(const char *category, const char *name, FloatVector2 value) override: Sets a metadata FloatVector2 with the given category and name to the given value.

inline virtual void SetMetadataFloatVector3(const char *category, const char *name, FloatVector3 value) override: Sets a metadata FloatVector3 with the given category and name to the given value.

inline virtual void SetMetadataFloatVector4(const char *category, const char *name, FloatVector4 value) override: Sets a metadata FloatVector4 with the given category and name to the given value.

inline virtual void SetMetadataDouble(const char *category, const char *name, double value) override: Sets a metadata double with the given category and name to the given value.

inline virtual void SetMetadataDoubleVector2(const char *category, const char *name, DoubleVector2 value) override: Sets a metadata DoubleVector2 with the given category and name to the given value.

inline virtual void SetMetadataDoubleVector3(const char *category, const char *name, DoubleVector3 value) override: Sets a metadata DoubleVector3 with the given category and name to the given value.

inline virtual void SetMetadataDoubleVector4(const char *category, const char *name, DoubleVector4 value) override: Sets a metadata DoubleVector4 with the given category and name to the given value.

inline virtual void SetMetadataString(const char *category, const char *name, const char *value) override: Sets a metadata string with the given category and name to the given value.

inline virtual void SetMetadataBLOB(const char *category, const char *name, const void *data, size_t size) override: Sets a metadata BLOB with the given category and name to the given value.

inline virtual void CopyMetadata(const char *category, MetadataReadAccess const *metadataReadAccess) override

Copy the metadata from another MetadataContainer

Parameters:

category – the metadata category to copy
metadataReadAccess – the MetadataReadAccess interface to copy from

inline virtual void ClearMetadata(const char *category, const char *name) override: Clear the metadata with the given category and name.

inline virtual void ClearMetadata(const char *category) override: Clear the metadata with the given category.

inline virtual void GetMetadataBLOB(const char *category, const char *name, const void **data, size_t *size) const override: Returns the metadata BLOB with the given category and name.

inline virtual MetadataKeyRange GetMetadataKeys() const override: Returns a range of metadata keys that can be iterated over using range-based ‘for’.

virtual void SetMetadataBLOB(const char *category, const char *name, const void *data, size_t size) = 0: Sets a metadata BLOB with the given category and name to the given value.

template<typename T> inline void SetMetadataBLOB(const char *category, const char *name, std::vector<T> const &value)

Parameters:: value – Sets a metadata BLOB with the given category and name to the given value

virtual void SetMetadataString(const char *category, const char *name, const char *value) = 0: Sets a metadata string with the given category and name to the given value.

inline void SetMetadataString(const char *category, const char *name, std::string const &value)

Parameters:: value – Sets a metadata string with the given category and name to the given value

virtual void GetMetadataBLOB(const char *category, const char *name, const void **data, size_t *size) const = 0: Returns the metadata BLOB with the given category and name.

template<typename T> inline void GetMetadataBLOB(const char *category, const char *name, std::vector<T> &value) const

virtual const char *GetMetadataString(const char *category, const char *name) const = 0: Returns the metadata string with the given category and name.

class MetadataKey

#include <MetadataKey.h>

A metadata key uniquely identifies a metadata item.

Public Functions

inline MetadataKey(): Default constructor.

inline MetadataKey(MetadataType type, const char *category, const char *name)

Constructor.

Parameters:

type – The type of the metadata that this key identifies. The possible types are (Int, Float, Double, {Int,Float,Double}Vector{2,3,4}, String or BLOB).
category – The category of the metadata that this key identifies. A category is a collection of related metadata items, e.g. SurveyCoordinateSystem consists of Origin, InlineSpacing, CrosslineSpacing and Unit metadata.
name – The name of the metadata that this key identifies

inline MetadataType GetType() const

Get the type of metadata that this key identifies.

Returns:: The type of the metadata that this key identifies

inline const char *GetCategory() const

Get the category of metadata that this key identifies.

Returns:: The category of the metadata that this key identifies

inline const char *GetName() const

Get the name of metadata that this key identifies.

Returns:: The name of the metadata that this key identifies

inline bool operator==(const MetadataKey &other) const

inline bool operator!=(const MetadataKey &other) const

class MetadataKeyRange

#include <MetadataKey.h>

A range of metadata keys that can be iterated over using range-based ‘for’.

Public Types

using const_iterator = const MetadataKey*

Public Functions

inline MetadataKeyRange(const_iterator begin, const_iterator end)

inline const_iterator begin() const: Returns a const iterator pointing to the first element in the MetadataKey collection.

inline const_iterator end() const: Returns a const iterator pointing to the past-the-end element in the MetadataKey collection.

class MetadataReadAccess

#include <MetadataAccess.h>

Interface for read access to Metadata.

Subclassed by OpenVDS::MetadataContainer, OpenVDS::VolumeDataLayout

Public Functions

virtual bool IsMetadataIntAvailable(const char *category, const char *name) const = 0: Returns true if a metadata int with the given category and name is available.

virtual bool IsMetadataIntVector2Available(const char *category, const char *name) const = 0: Returns true if a metadata IntVector2 with the given category and name is available.

virtual bool IsMetadataIntVector3Available(const char *category, const char *name) const = 0: Returns true if a metadata IntVector3 with the given category and name is available.

virtual bool IsMetadataIntVector4Available(const char *category, const char *name) const = 0: Returns true if a metadata IntVector4 with the given category and name is available.

virtual bool IsMetadataFloatAvailable(const char *category, const char *name) const = 0: Returns true if a metadata float with the given category and name is available.

virtual bool IsMetadataFloatVector2Available(const char *category, const char *name) const = 0: Returns true if a metadata FloatVector2 with the given category and name is available.

virtual bool IsMetadataFloatVector3Available(const char *category, const char *name) const = 0: Returns true if a metadata FloatVector3 with the given category and name is available.

virtual bool IsMetadataFloatVector4Available(const char *category, const char *name) const = 0: Returns true if a metadata FloatVector4 with the given category and name is available.

virtual bool IsMetadataDoubleAvailable(const char *category, const char *name) const = 0: Returns true if a metadata double with the given category and name is available.

virtual bool IsMetadataDoubleVector2Available(const char *category, const char *name) const = 0: Returns true if a metadata DoubleVector2 with the given category and name is available.

virtual bool IsMetadataDoubleVector3Available(const char *category, const char *name) const = 0: Returns true if a metadata DoubleVector3 with the given category and name is available.

virtual bool IsMetadataDoubleVector4Available(const char *category, const char *name) const = 0: Returns true if a metadata DoubleVector4 with the given category and name is available.

virtual bool IsMetadataStringAvailable(const char *category, const char *name) const = 0: Returns true if a metadata string with the given category and name is available.

virtual bool IsMetadataBLOBAvailable(const char *category, const char *name) const = 0: Returns true if a metadata BLOB with the given category and name is available.

virtual int GetMetadataInt(const char *category, const char *name) const = 0: Returns the metadata int with the given category and name.

virtual IntVector2 GetMetadataIntVector2(const char *category, const char *name) const = 0: Returns the metadata IntVector2 with the given category and name.

virtual IntVector3 GetMetadataIntVector3(const char *category, const char *name) const = 0: Returns the metadata IntVector3 with the given category and name.

virtual IntVector4 GetMetadataIntVector4(const char *category, const char *name) const = 0: Returns the metadata IntVector4 with the given category and name.

virtual float GetMetadataFloat(const char *category, const char *name) const = 0: Returns the metadata float with the given category and name.

virtual FloatVector2 GetMetadataFloatVector2(const char *category, const char *name) const = 0: Returns the metadata FloatVector2 with the given category and name.

virtual FloatVector3 GetMetadataFloatVector3(const char *category, const char *name) const = 0: Returns the metadata FloatVector3 with the given category and name.

virtual FloatVector4 GetMetadataFloatVector4(const char *category, const char *name) const = 0: Returns the metadata FloatVector4 with the given category and name.

virtual double GetMetadataDouble(const char *category, const char *name) const = 0: Returns the metadata double with the given category and name.

virtual DoubleVector2 GetMetadataDoubleVector2(const char *category, const char *name) const = 0: Returns the metadata DoubleVector2 with the given category and name.

virtual DoubleVector3 GetMetadataDoubleVector3(const char *category, const char *name) const = 0: Returns the metadata DoubleVector3 with the given category and name.

virtual DoubleVector4 GetMetadataDoubleVector4(const char *category, const char *name) const = 0: Returns the metadata DoubleVector4 with the given category and name.

virtual const char *GetMetadataString(const char *category, const char *name) const = 0: Returns the metadata string with the given category and name.

template<typename T> inline void GetMetadataBLOB(const char *category, const char *name, std::vector<T> &value) const

virtual MetadataKeyRange GetMetadataKeys() const = 0: Returns a range of metadata keys that can be iterated over using range-based ‘for’.

Public Members

friend PyMetadataAccess

class MetadataWriteAccess

#include <MetadataAccess.h>

Interface for write access to Metadata.

Subclassed by OpenVDS::MetadataContainer

Public Functions

virtual void SetMetadataInt(const char *category, const char *name, int value) = 0: Sets a metadata int with the given category and name to the given value.

virtual void SetMetadataIntVector2(const char *category, const char *name, IntVector2 value) = 0: Sets a metadata IntVector2 with the given category and name to the given value.

virtual void SetMetadataIntVector3(const char *category, const char *name, IntVector3 value) = 0: Sets a metadata IntVector3 with the given category and name to the given value.

virtual void SetMetadataIntVector4(const char *category, const char *name, IntVector4 value) = 0: Sets a metadata IntVector4 with the given category and name to the given value.

virtual void SetMetadataFloat(const char *category, const char *name, float value) = 0: Sets a metadata float with the given category and name to the given value.

virtual void SetMetadataFloatVector2(const char *category, const char *name, FloatVector2 value) = 0: Sets a metadata FloatVector2 with the given category and name to the given value.

virtual void SetMetadataFloatVector3(const char *category, const char *name, FloatVector3 value) = 0: Sets a metadata FloatVector3 with the given category and name to the given value.

virtual void SetMetadataFloatVector4(const char *category, const char *name, FloatVector4 value) = 0: Sets a metadata FloatVector4 with the given category and name to the given value.

virtual void SetMetadataDouble(const char *category, const char *name, double value) = 0: Sets a metadata double with the given category and name to the given value.

virtual void SetMetadataDoubleVector2(const char *category, const char *name, DoubleVector2 value) = 0: Sets a metadata DoubleVector2 with the given category and name to the given value.

virtual void SetMetadataDoubleVector3(const char *category, const char *name, DoubleVector3 value) = 0: Sets a metadata DoubleVector3 with the given category and name to the given value.

virtual void SetMetadataDoubleVector4(const char *category, const char *name, DoubleVector4 value) = 0: Sets a metadata DoubleVector4 with the given category and name to the given value.

virtual void SetMetadataString(const char *category, const char *name, const char *value) = 0: Sets a metadata string with the given category and name to the given value.

inline void SetMetadataString(const char *category, const char *name, std::string const &value)

Parameters:: value – Sets a metadata string with the given category and name to the given value

virtual void SetMetadataBLOB(const char *category, const char *name, const void *data, size_t size) = 0: Sets a metadata BLOB with the given category and name to the given value.

template<typename T> inline void SetMetadataBLOB(const char *category, const char *name, std::vector<T> const &value)

Parameters:: value – Sets a metadata BLOB with the given category and name to the given value

virtual void CopyMetadata(const char *category, MetadataReadAccess const *metadataReadAccess) = 0

Copy the metadata from another MetadataContainer

Parameters:

category – the metadata category to copy
metadataReadAccess – the MetadataReadAccess interface to copy from

virtual void ClearMetadata(const char *category, const char *name) = 0: Clear the metadata with the given category and name.

virtual void ClearMetadata(const char *category) = 0: Clear the metadata with the given category.

struct OpenOptions

Subclassed by OpenVDS::AWSOpenOptions, OpenVDS::AzureOpenOptions, OpenVDS::AzurePresignedOpenOptions, OpenVDS::DMSOpenOptions, OpenVDS::GoogleOpenOptions, OpenVDS::HttpOpenOptions, OpenVDS::InMemoryOpenOptions, OpenVDS::VDSFileOpenOptions

Public Types

enum ConnectionType

Values:

enumerator AWS

enumerator Azure

enumerator AzureSdkForCpp

enumerator AzurePresigned

enumerator GoogleStorage

enumerator DMS

enumerator Http

enumerator VDSFile

enumerator InMemory

enumerator Other

enumerator ConnectionTypeCount

Public Functions

inline virtual ~OpenOptions()

Public Members

ConnectionType connectionType

WaveletAdaptiveMode waveletAdaptiveMode: This property (only relevant when using Wavelet compression) is used to control how the wavelet adaptive compression determines which level of wavelet compressed data to load. Depending on the setting, either the global or local WaveletAdaptiveTolerance or the WaveletAdaptiveRatio can be used.

float waveletAdaptiveTolerance: Wavelet adaptive tolerance, this setting will be used whenever the WavletAdaptiveMode is set to Tolerance.

float waveletAdaptiveRatio: Wavelet adaptive ratio, this setting will be used whenever the WavletAdaptiveMode is set to Ratio. A compression ratio of 5.0 corresponds to compressed data which is 20% of the original.

int requestThreadCount: Number of threads used to process requests.

LogLevel logLevel: Property to adjust the OpenVDSLogging handlers level.

class OpenVDSInterface : public OpenVDS::OpenVDSVersioningInterface

#include <OpenVDSInterface.h>

The OpenVDS interface is used to provide a versioned entrypoint for the API with wrappers for standard types to ensure ABI compatibility.

Public Types

typedef void (*ErrorHandler)(Error *error, int errorCode, const char *errorMessage)

typedef void (*WaveletAdaptiveLevelsHandler)(std::vector<WaveletAdaptiveLevel> *waveletAdaptiveLevelsVector, float compressionTolerance, float compressionRatio, int64_t compressedSize)

Public Functions

virtual OpenOptions *CreateOpenOptions(StringWrapper url, StringWrapper connectionString, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual bool IsSupportedProtocol(StringWrapper url) = 0

virtual VDSHandle Open(StringWrapper url, StringWrapper connectionString, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual VDSHandle OpenWithAdaptiveCompressionTolerance(StringWrapper url, StringWrapper connectionString, float waveletAdaptiveTolerance, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual VDSHandle OpenWithAdaptiveCompressionRatio(StringWrapper url, StringWrapper connectionString, float waveletAdaptiveRatio, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual VDSHandle Open(const OpenOptions &options, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual VDSHandle Open(IOManager *ioManager, LogLevel logLevel, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual bool IsCompressionMethodSupported(CompressionMethod compressionMethod) = 0

virtual VDSHandle Create(StringWrapper url, StringWrapper connectionString, VolumeDataLayoutDescriptor const &layoutDescriptor, VectorWrapper<VolumeDataAxisDescriptor> axisDescriptors, VectorWrapper<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, CompressionMethod compressionMethod, float compressionTolerance, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual VDSHandle Create(const OpenOptions &options, VolumeDataLayoutDescriptor const &layoutDescriptor, VectorWrapper<VolumeDataAxisDescriptor> axisDescriptors, VectorWrapper<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, CompressionMethod compressionMethod, float compressionTolerance, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual VDSHandle Create(IOManager *ioManager, VolumeDataLayoutDescriptor const &layoutDescriptor, VectorWrapper<VolumeDataAxisDescriptor> axisDescriptors, VectorWrapper<VolumeDataChannelDescriptor> channelDescriptors, MetadataReadAccess const &metadata, CompressionMethod compressionMethod, float compressionTolerance, LogLevel logLevel, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual VolumeDataLayout *GetLayout(VDSHandle handle) = 0

virtual IVolumeDataAccessManager *GetAccessManagerInterface(VDSHandle handle) = 0

virtual MetadataWriteAccess *GetMetadataWriteAccessInterface(VDSHandle handle) = 0

virtual CompressionMethod GetCompressionMethod(VDSHandle handle) = 0

virtual float GetCompressionTolerance(VDSHandle handle) = 0

virtual void Close(VDSHandle handle, bool flush) = 0

virtual void Close(VDSHandle handle, bool flush, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual void RetryableClose(VDSHandle handle, bool flush) = 0

virtual void RetryableClose(VDSHandle handle, bool flush, ErrorHandler errorHandler, Error *error = nullptr) = 0

virtual GlobalState *GetGlobalState() = 0

virtual int64_t GetWaveletCompressedSize(VDSHandle handle) = 0

virtual int64_t GetWaveletUncompressedSize(VDSHandle handle) = 0

virtual void GetWaveletAdaptiveLevels(VDSHandle handle, WaveletAdaptiveLevelsHandler WaveletAdaptiveLevelsHandler, std::vector<WaveletAdaptiveLevel> *waveletAdaptiveLevelsVector) = 0

class OpenVDSVersioningInterface

#include <OpenVDSInterface.h>

The OpenVDS versioning interface is a stable base class for the OpenVDS global interface that can be used to check what version of the OpenVDS interface is provided.

Subclassed by OpenVDS::OpenVDSInterface

Public Functions

virtual const char *GetOpenVDSName() = 0

virtual const char *GetOpenVDSVersion() = 0

virtual void GetOpenVDSVersion(int &major, int &minor, int &patch) = 0

virtual const char *GetOpenVDSRevision() = 0

template<typename T> struct optional

Public Types

using value_type = T

Public Functions

inline optional()

inline optional(const value_type &value)

inline value_type value() const

inline value_type value_or(value_type const &value) const

inline value_type &emplace(value_type &&value)

inline bool has_value() const

inline operator bool() const

Public Members

value_type m_Value

bool m_HasValue

template<typename T, bool isUseNoValue> struct QuantizedTypesToFloatConverter

Public Functions

inline QuantizedTypesToFloatConverter()

inline QuantizedTypesToFloatConverter(float, float, bool)

inline T ConvertValue(T value) const

template<bool isUseNoValue> struct QuantizedTypesToFloatConverter<uint16_t, isUseNoValue>

Public Functions

inline QuantizedTypesToFloatConverter()

inline QuantizedTypesToFloatConverter(float integerScale, float integerOffset, bool isRangeScale)

inline float ConvertValue(uint16_t value) const

Public Members

float m_integerScale

float m_integerOffset

template<bool isUseNoValue> struct QuantizedTypesToFloatConverter<uint8_t, isUseNoValue>

Public Functions

inline QuantizedTypesToFloatConverter()

inline QuantizedTypesToFloatConverter(float integerScale, float integerOffset, bool isRangeScale)

inline float ConvertValue(uint8_t value) const

Public Members

float m_integerScale

float m_integerOffset

template<typename T1, typename T2, bool isUseNoValue> class QuantizingValueConverterWithNoValue

Public Functions

inline QuantizingValueConverterWithNoValue()

inline QuantizingValueConverterWithNoValue(float valueRangeMin, float valueRangeMax, float integerScale, float integerOffset, float noValue, float replacementNoValue)

inline QuantizingValueConverterWithNoValue(float valueRangeMin, float valueRangeMax, float integerScale, float integerOffset, double noValue, double replacementNoValue)

inline QuantizingValueConverterWithNoValue(float valueRangeMin, float valueRangeMax, float integerScale, float integerOffset, float noValue, float replacementNoValue, bool isConvertWithValueRangeOnly)

inline QuantizingValueConverterWithNoValue(float valueRangeMin, float valueRangeMax, float integerScale, float integerOffset, double noValue, double replacementNoValue, bool isConvertWithValueRangeOnly)

inline T1 ConvertValue(T2 value) const

template<typename T> struct Range

Public Functions

Range() = default

inline Range(T min, T max)

Public Members

T Min

T Max

class ReadErrorException : public OpenVDS::MessageBufferException<512>

Public Functions

inline ReadErrorException(const char *errorMessage, int errorCode)

inline ReadErrorException(const ReadErrorException &other)

inline ReadErrorException &operator=(const ReadErrorException &other)

inline virtual const char *GetErrorMessage() const noexcept override

inline int GetErrorCode() const noexcept

template<typename T1, bool isUseNoValue> struct ResultConverter

Public Static Functions

static inline float ReciprocalScale(float, float)

template<typename T2> static inline T1 ConvertValueT(T2 value, float, float)

template<bool isUseNoValue> struct ResultConverter<uint16_t, isUseNoValue>

Public Static Functions

static inline float ReciprocalScale(float valueRangeMin, float valueRangeMax)

template<typename T2> static inline uint16_t ConvertValueT(T2 value, float offset, float reciprocalScale)

template<bool isUseNoValue> struct ResultConverter<uint8_t, isUseNoValue>

Public Static Functions

static inline float ReciprocalScale(float valueRangeMin, float valueRangeMax)

template<typename T2> static inline uint8_t ConvertValueT(T2 value, float offset, float reciprocalScale)

class ScopedVDSHandle

Public Functions

inline ScopedVDSHandle()

inline ScopedVDSHandle(VDSHandle const &VDS)

inline ScopedVDSHandle(ScopedVDSHandle &&VDS)

inline ~ScopedVDSHandle()

inline void Close(): Close the VDS and free up all associated resources. If an error occurs, an exception will be thrown.

inline void Close(Error &error): Close the VDS and free up all associated resources.

inline void RetryableClose(): Close the VDS and free up all associated resources if the close succeeds. If an error occurs, an exception will be thrown.

inline void RetryableClose(Error &error): Close the VDS and free up all associated resources if the close succeeds.

inline operator VDSHandle() const

inline operator bool() const

inline ScopedVDSHandle &operator=(VDSHandle const &VDS) noexcept(true)

inline ScopedVDSHandle &operator=(ScopedVDSHandle &&VDS) noexcept(true)

struct StringWrapper

Public Functions

inline StringWrapper()

inline StringWrapper(const std::string &toWrap)

template<size_t SIZE> inline StringWrapper(const char (&toWrap)[SIZE])

Public Members

const char *data

size_t size

template<int N> struct VDSCoordinateTransformerBase

Public Functions

inline FloatVector<3> VoxelIndexToWorldCoordinates(const IntVector<N> &iVoxelIndex) const

Converts a voxel index to world coordinates using the indexer’s IJK grid definition and IJK dimension map

Parameters:: iVoxelIndex – the voxel index to convert
Returns:: the world coordinates

inline FloatVector<3> VoxelIndexToWorldCoordinates(const FloatVector<N> &rVoxelIndex) const

Converts a float voxel index to world coordinates using the indexer’s IJK grid definition and IJK dimension map

Parameters:: rVoxelIndex – the float voxel index to convert
Returns:: the world coordinates

inline IntVector<N> WorldCoordinatesToVoxelIndex(const FloatVector<3> &rWorldCoords, const int (&anVoxelMin)[Dimensionality_Max]) const

Converts world coordinates to a voxel index, rounding to the nearest integer

Parameters:

rWorldCoords – the world coordinates to convert
anVoxelMin –

Returns:

the voxel index

inline FloatVector<N> WorldCoordinatesToVoxelIndexFloat(const FloatVector<3> &rWorldCoords, const int (&anVoxelMin)[Dimensionality_Max]) const

Converts world coordinates to a float voxel index without rounding

Parameters:

rWorldCoords – the world coordinates to convert
anVoxelMin –

Returns:

the float voxel index

inline VDSCoordinateTransformerBase(const VDSIJKGridDefinition &vdsIjkGridDefinition)

Constructor

Parameters:: cIJKGridAndDImensionMap – the IJK grid definition and IJK dimension map

inline VDSCoordinateTransformerBase(): Constructor

Public Members

float ijkToWorldTransform[3][3]: Coordinate transfrom matrix.

float worldToIJKTransform[3][3]: Coordinate transform matrix.

float ijkToWorldTranslation[3]: Coordinate translation vector.

float worldToIJKTranslation[3]: Coordinate translation vector.

int ijkDimensionMap[3]: Map to determine which dimension map to I, J, and K.

struct VDSError

Public Functions

VDSError() = default

Public Members

int code = 0

std::string string

struct VDSFileOpenOptions : public OpenVDS::OpenOptions

#include <OpenVDS.h>

Options for opening a VDS file.

Public Functions

inline VDSFileOpenOptions()

inline VDSFileOpenOptions(const std::string &fileName)

VDSFileOpenOptions constructor.

Parameters:: fileName – The name of the VDS file

Public Members

std::string fileName

struct VDSIJKGridDefinition : public OpenVDS::IJKGridDefinition

Public Functions

inline VDSIJKGridDefinition()

inline VDSIJKGridDefinition(const IJKGridDefinition &ijkGridDefinition, IntVector3 dimensionMap)

inline bool operator==(const VDSIJKGridDefinition &b) const

Public Members

IntVector3 dimensionMap

template<typename T, size_t N> struct Vector

Public Functions

inline Vector()

inline T &operator[](size_t n)

inline const T &operator[](size_t n) const

Public Members

T data[N]

template<typename TYPE> struct Vector<TYPE, 2>

Public Types

Values:

enumerator element_count

typedef TYPE element_type

Public Functions

inline Vector()

inline Vector(TYPE X, TYPE Y)

inline Vector(std::tuple<TYPE, TYPE> const &t)

inline TYPE &operator[](size_t n)

inline const TYPE &operator[](size_t n) const

inline operator std::tuple<TYPE, TYPE>() const

Public Members

TYPE X

TYPE Y

TYPE data[2]

union OpenVDS::Vector< TYPE, 2 >

template<typename TYPE> struct Vector<TYPE, 3>

Public Types

Values:

enumerator element_count

typedef TYPE element_type

Public Functions

inline Vector()

inline Vector(TYPE X, TYPE Y, TYPE Z)

inline Vector(std::tuple<TYPE, TYPE, TYPE> const &t)

inline TYPE &operator[](size_t n)

inline const TYPE &operator[](size_t n) const

inline operator std::tuple<TYPE, TYPE, TYPE>() const

Public Members

TYPE X

TYPE Y

TYPE Z

TYPE data[3]

union OpenVDS::Vector< TYPE, 3 >

template<typename TYPE> struct Vector<TYPE, 4>

Public Types

Values:

enumerator element_count

typedef TYPE element_type

Public Functions

inline Vector()

inline Vector(TYPE X, TYPE Y, TYPE Z, TYPE T)

inline Vector(std::tuple<TYPE, TYPE, TYPE, TYPE> const &t)

inline TYPE &operator[](size_t n)

inline const TYPE &operator[](size_t n) const

inline operator std::tuple<TYPE, TYPE, TYPE, TYPE>() const

Public Members

TYPE X

TYPE Y

TYPE Z

TYPE T

TYPE data[4]

union OpenVDS::Vector< TYPE, 4 >

template<typename T> struct VectorWrapper

Public Functions

inline VectorWrapper()

inline VectorWrapper(const std::vector<T> &toWrap)

Public Members

const T *data

size_t size

class VolumeDataAccessManager

Public Types

typedef VolumeDataPageAccessor::AccessMode AccessMode

Public Functions

inline VolumeDataAccessManager()

inline VolumeDataAccessManager(IVolumeDataAccessManager *manager)

inline VolumeDataAccessManager(VolumeDataAccessManager const &rhs)

inline ~VolumeDataAccessManager()

inline VolumeDataAccessManager &operator=(const VolumeDataAccessManager &rhs)

inline VolumeDataLayout const *GetVolumeDataLayout()

Get the VolumeDataLayout object for a VDS.

Returns:: The VolumeDataLayout object associated with the VDS or NULL if there is no valid VolumeDataLayout.

inline VDSProduceStatus GetVDSProduceStatus(DimensionsND dimensionsND, int LOD, int channel) const

Get the produce status for the specific DimensionsND/LOD/Channel combination.

Parameters:

dimensionsND – The dimensions group we’re getting the produce status for.
LOD – The LOD level we’re getting the produce status for.
channel – The channel index we’re getting the produce status for.

Returns:

The produce status for the specific DimensionsND/LOD/Channel combination.

inline int64_t GetVDSChunkCount(DimensionsND dimensionsND, int LOD, int channel) const

Get the chunk count for the specific DimensionsND/LOD/Channel combination.

Parameters:

dimensionsND – The dimensions group we’re getting the chunk count for.
LOD – The LOD level we’re getting the chunk count status for.
channel – The channel index we’re getting the chunk count status for.

Returns:

The chunk count for the specific DimensionsND/LOD/Channel combination.

inline std::shared_ptr<VolumeDataPageAccessor> CreateVolumeDataPageAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, AccessMode accessMode, int chunkMetadataPageSize = 1024)

Create a VolumeDataPageAccessor object for the VDS.

Parameters:

dimensionsND – The dimensions group that the volume data page accessor will access.
LOD – The LOD level that the volume data page accessor will access.
channel – The channel index that the volume data page accessor will access.
maxPages – The maximum number of pages that the volume data page accessor will cache.
accessMode – This specifies the access mode (ReadOnly/ReadWrite/Create) of the volume data page accessor.
chunkMetadataPageSize – The chunk metadata page size of the layer. This controls how many chunk metadata entries are written per page, and is only used when the access mode is Create. If this number is too low it will degrade performance, but in certain situations it can be advantageous to make this number a multiple of the number of chunks in some of the dimensions. Do not change this from the default (1024) unless you know exactly what you are doing.

Returns:

A VolumeDataPageAccessor object for the VDS.

template<typename INDEX, typename T> VolumeDataReadAccessor<INDEX, T> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

template<typename INDEX, typename T> VolumeDataReadAccessor<INDEX, T> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

template<typename INDEX, typename T> VolumeDataReadWriteAccessor<INDEX, T> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

template<typename INDEX, typename T> VolumeDataReadWriteAccessor<INDEX, T> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

template<typename INDEX, typename T> VolumeDataReadAccessor<INDEX, T> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue = optional<float>())

template<typename INDEX, typename T> VolumeDataReadAccessor<INDEX, T> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DInterpolatingAccessorR64 CreateVolumeData2DInterpolatingAccessorR64(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DInterpolatingAccessorR64 CreateVolumeData2DInterpolatingAccessorR64(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DInterpolatingAccessorR32 CreateVolumeData2DInterpolatingAccessorR32(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DInterpolatingAccessorR32 CreateVolumeData2DInterpolatingAccessorR32(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessor1Bit CreateVolumeData2DReadAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessor1Bit CreateVolumeData2DReadAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorU8 CreateVolumeData2DReadAccessorU8(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorU8 CreateVolumeData2DReadAccessorU8(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorU16 CreateVolumeData2DReadAccessorU16(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorU16 CreateVolumeData2DReadAccessorU16(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorU32 CreateVolumeData2DReadAccessorU32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorU32 CreateVolumeData2DReadAccessorU32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorU64 CreateVolumeData2DReadAccessorU64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorU64 CreateVolumeData2DReadAccessorU64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorR32 CreateVolumeData2DReadAccessorR32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorR32 CreateVolumeData2DReadAccessorR32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorR64 CreateVolumeData2DReadAccessorR64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadAccessorR64 CreateVolumeData2DReadAccessorR64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessor1Bit CreateVolumeData2DReadWriteAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessor1Bit CreateVolumeData2DReadWriteAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorU8 CreateVolumeData2DReadWriteAccessorU8(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorU8 CreateVolumeData2DReadWriteAccessorU8(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorU16 CreateVolumeData2DReadWriteAccessorU16(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorU16 CreateVolumeData2DReadWriteAccessorU16(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorU32 CreateVolumeData2DReadWriteAccessorU32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorU32 CreateVolumeData2DReadWriteAccessorU32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorU64 CreateVolumeData2DReadWriteAccessorU64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorU64 CreateVolumeData2DReadWriteAccessorU64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorR32 CreateVolumeData2DReadWriteAccessorR32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorR32 CreateVolumeData2DReadWriteAccessorR32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorR64 CreateVolumeData2DReadWriteAccessorR64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData2DReadWriteAccessorR64 CreateVolumeData2DReadWriteAccessorR64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DInterpolatingAccessorR64 CreateVolumeData3DInterpolatingAccessorR64(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DInterpolatingAccessorR64 CreateVolumeData3DInterpolatingAccessorR64(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DInterpolatingAccessorR32 CreateVolumeData3DInterpolatingAccessorR32(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DInterpolatingAccessorR32 CreateVolumeData3DInterpolatingAccessorR32(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessor1Bit CreateVolumeData3DReadAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessor1Bit CreateVolumeData3DReadAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorU8 CreateVolumeData3DReadAccessorU8(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorU8 CreateVolumeData3DReadAccessorU8(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorU16 CreateVolumeData3DReadAccessorU16(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorU16 CreateVolumeData3DReadAccessorU16(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorU32 CreateVolumeData3DReadAccessorU32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorU32 CreateVolumeData3DReadAccessorU32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorU64 CreateVolumeData3DReadAccessorU64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorU64 CreateVolumeData3DReadAccessorU64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorR32 CreateVolumeData3DReadAccessorR32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorR32 CreateVolumeData3DReadAccessorR32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorR64 CreateVolumeData3DReadAccessorR64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadAccessorR64 CreateVolumeData3DReadAccessorR64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessor1Bit CreateVolumeData3DReadWriteAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessor1Bit CreateVolumeData3DReadWriteAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorU8 CreateVolumeData3DReadWriteAccessorU8(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorU8 CreateVolumeData3DReadWriteAccessorU8(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorU16 CreateVolumeData3DReadWriteAccessorU16(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorU16 CreateVolumeData3DReadWriteAccessorU16(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorU32 CreateVolumeData3DReadWriteAccessorU32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorU32 CreateVolumeData3DReadWriteAccessorU32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorU64 CreateVolumeData3DReadWriteAccessorU64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorU64 CreateVolumeData3DReadWriteAccessorU64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorR32 CreateVolumeData3DReadWriteAccessorR32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorR32 CreateVolumeData3DReadWriteAccessorR32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorR64 CreateVolumeData3DReadWriteAccessorR64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData3DReadWriteAccessorR64 CreateVolumeData3DReadWriteAccessorR64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DInterpolatingAccessorR64 CreateVolumeData4DInterpolatingAccessorR64(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DInterpolatingAccessorR64 CreateVolumeData4DInterpolatingAccessorR64(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DInterpolatingAccessorR32 CreateVolumeData4DInterpolatingAccessorR32(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DInterpolatingAccessorR32 CreateVolumeData4DInterpolatingAccessorR32(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessor1Bit CreateVolumeData4DReadAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessor1Bit CreateVolumeData4DReadAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorU8 CreateVolumeData4DReadAccessorU8(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorU8 CreateVolumeData4DReadAccessorU8(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorU16 CreateVolumeData4DReadAccessorU16(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorU16 CreateVolumeData4DReadAccessorU16(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorU32 CreateVolumeData4DReadAccessorU32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorU32 CreateVolumeData4DReadAccessorU32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorU64 CreateVolumeData4DReadAccessorU64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorU64 CreateVolumeData4DReadAccessorU64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorR32 CreateVolumeData4DReadAccessorR32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorR32 CreateVolumeData4DReadAccessorR32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorR64 CreateVolumeData4DReadAccessorR64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadAccessorR64 CreateVolumeData4DReadAccessorR64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessor1Bit CreateVolumeData4DReadWriteAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessor1Bit CreateVolumeData4DReadWriteAccessor1Bit(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorU8 CreateVolumeData4DReadWriteAccessorU8(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorU8 CreateVolumeData4DReadWriteAccessorU8(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorU16 CreateVolumeData4DReadWriteAccessorU16(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorU16 CreateVolumeData4DReadWriteAccessorU16(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorU32 CreateVolumeData4DReadWriteAccessorU32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorU32 CreateVolumeData4DReadWriteAccessorU32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorU64 CreateVolumeData4DReadWriteAccessorU64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorU64 CreateVolumeData4DReadWriteAccessorU64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorR32 CreateVolumeData4DReadWriteAccessorR32(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorR32 CreateVolumeData4DReadWriteAccessorR32(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorR64 CreateVolumeData4DReadWriteAccessorR64(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue = optional<float>())

inline VolumeData4DReadWriteAccessorR64 CreateVolumeData4DReadWriteAccessorR64(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue = optional<float>())

inline int64_t GetVolumeSubsetBufferSize(const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], VolumeDataFormat format, int LOD = 0, int channel = 0)

Compute the buffer size (in bytes) for a volume subset request.

Parameters:

minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
format – Voxel format of the destination buffer.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.

Returns:

The buffer size needed.

template<typename VALUETYPE> inline int64_t GetVolumeSubsetBufferSize(const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], int LOD = 0, int channel = 0)

inline std::shared_ptr<VolumeDataRequest> RequestVolumeSubset(void *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], VolumeDataFormat format, optional<float> replacementNoValue = optional<float>())

Request a subset of the input VDS.

Parameters:

buffer – Pointer to a preallocated buffer holding at least as many elements of format as indicated by minVoxelCoordinates and maxVoxelCoordinates.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
format – Voxel format of the destination buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline std::shared_ptr<VolumeDataRequest1Bit> RequestVolumeSubset1Bit(uint8_t *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max])

Request a subset of the input VDS.

Parameters:

buffer – Pointer to a preallocated buffer holding at least as many elements of format as indicated by minVoxelCoordinates and maxVoxelCoordinates.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

template<typename VALUETYPE> inline std::shared_ptr<VolumeDataRequest_t<VALUETYPE>> RequestVolumeSubset(VALUETYPE *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], optional<float> replacementNoValue = optional<float>())

Request a subset of the input VDS.

Parameters:

buffer – Pointer to a preallocated buffer holding at least as many elements of format as indicated by minVoxelCoordinates and maxVoxelCoordinates.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline std::shared_ptr<VolumeDataRequest> RequestVolumeSubset(DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], VolumeDataFormat format, optional<float> replacementNoValue = optional<float>())

Request a subset of the input VDS, using an automatically allocated buffer.

Parameters:

dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
format – Voxel format of the destination buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline std::shared_ptr<VolumeDataRequest1Bit> RequestVolumeSubset1Bit(DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max])

Request a subset of the input VDS, using an automatically allocated buffer.

Parameters:

dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

template<typename VALUETYPE> inline std::shared_ptr<VolumeDataRequest_t<VALUETYPE>> RequestVolumeSubset(DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], optional<float> replacementNoValue = optional<float>())

Request a subset of the input VDS, using an automatically allocated typed buffer.

Parameters:

dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline int64_t GetProjectedVolumeSubsetBufferSize(const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], DimensionsND projectedDimensions, VolumeDataFormat format, int LOD = 0, int channel = 0)

Compute the buffer size (in bytes) for a projected volume subset request.

Parameters:

minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
projectedDimensions – The 2D dimension group that the plane in the source dimensiongroup is projected into. It must be a 2D subset of the source dimensions.
format – Voxel format of the destination buffer.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.

Returns:

The buffer size needed.

template<typename VALUETYPE> inline int64_t GetProjectedVolumeSubsetBufferSize(const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], DimensionsND projectedDimensions, int LOD = 0, int channel = 0)

inline std::shared_ptr<VolumeDataRequest> RequestProjectedVolumeSubset(void *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], FloatVector4 const &voxelPlane, DimensionsND projectedDimensions, VolumeDataFormat format, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

Request a subset projected from an arbitrary 3D plane through the subset onto one of the sides of the subset.

Parameters:

buffer – Pointer to a preallocated buffer holding at least as many elements of format as indicated by minVoxelCoordinates and maxVoxelCoordinates for the projected dimensions.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
voxelPlane – The plane equation for the projection from the dimension source to the projected dimensions (which must be a 2D subset of the source dimensions).
projectedDimensions – The 2D dimension group that the plane in the source dimensiongroup is projected into. It must be a 2D subset of the source dimensions.
interpolationMethod – Interpolation method to use when sampling the buffer.
format – Voxel format of the destination buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline std::shared_ptr<VolumeDataRequest> RequestProjectedVolumeSubset(DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], FloatVector4 const &voxelPlane, DimensionsND projectedDimensions, VolumeDataFormat format, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

Request a subset projected from an arbitrary 3D plane through the subset onto one of the sides of the subset, using an automatically allocated buffer.

Parameters:

dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
voxelPlane – The plane equation for the projection from the dimension source to the projected dimensions (which must be a 2D subset of the source dimensions).
projectedDimensions – The 2D dimension group that the plane in the source dimensiongroup is projected into. It must be a 2D subset of the source dimensions.
format – Voxel format of the destination buffer.
interpolationMethod – Interpolation method to use when sampling the buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

template<typename VALUETYPE> inline std::shared_ptr<VolumeDataRequest_t<VALUETYPE>> RequestProjectedVolumeSubset(DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], FloatVector4 const &voxelPlane, DimensionsND projectedDimensions, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

Request a subset projected from an arbitrary 3D plane through the subset onto one of the sides of the subset, using an automatically allocated typed buffer.

Parameters:

dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
voxelPlane – The plane equation for the projection from the dimension source to the projected dimensions (which must be a 2D subset of the source dimensions).
projectedDimensions – The 2D dimension group that the plane in the source dimensiongroup is projected into. It must be a 2D subset of the source dimensions.
interpolationMethod – Interpolation method to use when sampling the buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

template<typename VALUETYPE> inline std::shared_ptr<VolumeDataRequest_t<VALUETYPE>> RequestProjectedVolumeSubset(void *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const int (&minVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], const int (&maxVoxelCoordinates)[VolumeDataLayout::Dimensionality_Max], FloatVector4 const &voxelPlane, DimensionsND projectedDimensions, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

Request a subset projected from an arbitrary 3D plane through the subset onto one of the sides of the subset, using an automatically allocated typed buffer.

Parameters:

buffer – Pointer to a preallocated buffer holding at least as many elements of format as indicated by minVoxelCoordinates and maxVoxelCoordinates for the projected dimensions.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
minVoxelCoordinates – The minimum voxel coordinates to request in each dimension (inclusive).
maxVoxelCoordinates – The maximum voxel coordinates to request in each dimension (exclusive).
voxelPlane – The plane equation for the projection from the dimension source to the projected dimensions (which must be a 2D subset of the source dimensions).
projectedDimensions – The 2D dimension group that the plane in the source dimensiongroup is projected into. It must be a 2D subset of the source dimensions.
interpolationMethod – Interpolation method to use when sampling the buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline int64_t GetVolumeSamplesBufferSize(int sampleCount, int channel = 0)

Compute the buffer size (in bytes) for a volume samples request.

Parameters:

sampleCount – Number of samples to request.
channel – The channel index the requested data is read from.

Returns:

The buffer size needed.

inline std::shared_ptr<VolumeDataRequestFloat> RequestVolumeSamples(float *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const float (*samplePositions)[VolumeDataLayout::Dimensionality_Max], int sampleCount, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

Request sampling of the input VDS at the specified coordinates.

Parameters:

buffer – Pointer to a preallocated buffer holding at least sampleCount elements.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
samplePositions – Pointer to array of VolumeDataLayout::Dimensionality_Max-elements indicating the positions to sample. May be deleted once RequestVolumeSamples return, as HueSpace makes a deep copy of the data.
sampleCount – Number of samples to request.
interpolationMethod – Interpolation method to use when sampling the buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline std::shared_ptr<VolumeDataRequestFloat> RequestVolumeSamples(DimensionsND dimensionsND, int LOD, int channel, const float (*samplePositions)[VolumeDataLayout::Dimensionality_Max], int sampleCount, InterpolationMethod interpolationMethod, optional<float> replacementNoValue = optional<float>())

Request sampling of the input VDS at the specified coordinates, using an automatically allocated buffer.

Parameters:

dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
samplePositions – Pointer to array of VolumeDataLayout::Dimensionality_Max-elements indicating the positions to sample. May be deleted once RequestVolumeSamples return, as HueSpace makes a deep copy of the data.
sampleCount – Number of samples to request.
interpolationMethod – Interpolation method to use when sampling the buffer.
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline int64_t GetVolumeTracesBufferSize(int traceCount, int traceDimension, int LOD = 0, int channel = 0)

Compute the buffer size (in bytes) for a volume traces request.

Parameters:

traceCount – Number of traces to request.
traceDimension – The dimension to trace
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.

Returns:

The buffer size needed.

inline std::shared_ptr<VolumeDataRequestFloat> RequestVolumeTraces(DimensionsND dimensionsND, int LOD, int channel, const float (*tracePositions)[VolumeDataLayout::Dimensionality_Max], int traceCount, InterpolationMethod interpolationMethod, int traceDimension, optional<float> replacementNoValue = optional<float>())

Request traces from the input VDS, using an automatically allocated buffer.

Parameters:

dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
tracePositions – Pointer to array of traceCount VolumeDataLayout::Dimensionality_Max-elements indicating the trace positions.
traceCount – Number of traces to request.
interpolationMethod – Interpolation method to use when sampling the buffer.
traceDimension – The dimension to trace
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline std::shared_ptr<VolumeDataRequestFloat> RequestVolumeTraces(float *buffer, int64_t bufferByteSize, DimensionsND dimensionsND, int LOD, int channel, const float (*tracePositions)[VolumeDataLayout::Dimensionality_Max], int traceCount, InterpolationMethod interpolationMethod, int traceDimension, optional<float> replacementNoValue = optional<float>())

Request traces from the input VDS.

Parameters:

buffer – Pointer to a preallocated buffer holding at least traceCount * number of samples in the traceDimension.
bufferByteSize – The size of the provided buffer, in bytes.
dimensionsND – The dimensiongroup the requested data is read from.
LOD – The LOD level the requested data is read from.
channel – The channel index the requested data is read from.
tracePositions – Pointer to array of traceCount VolumeDataLayout::Dimensionality_Max-elements indicating the trace positions.
traceCount – Number of traces to request.
interpolationMethod – Interpolation method to use when sampling the buffer.
traceDimension – The dimension to trace
replacementNoValue – If specified, this value is used to replace regions of the input VDS that has no data.

Returns:

A VolumeDataRequest instance encapsulating the request status and buffer.

inline std::shared_ptr<VolumeDataRequest> PrefetchVolumeChunk(DimensionsND dimensionsND, int LOD, int channel, int64_t chunkIndex)

Force production of a specific volume data chunk.

Parameters:

dimensionsND – The dimensiongroup the requested chunk belongs to.
LOD – The LOD level the requested chunk belongs to.
channel – The channel index the requested chunk belongs to.
chunkIndex – The index of the chunk to prefetch.

Returns:

A VolumeDataRequest instance encapsulating the request status.

inline void Flush(Error &error): Flush any pending writes and write updated layer status.

template<> inline VolumeDataReadAccessor<IntVector2, double> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, uint64_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, float> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, uint32_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, uint16_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, uint8_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, bool> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, double> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, uint64_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, float> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, uint32_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, uint16_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, uint8_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, bool> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, double> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, uint64_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, float> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, uint32_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, uint16_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, uint8_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, bool> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, double> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, uint64_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, float> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, uint32_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, uint16_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, uint8_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector2, bool> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, double> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, uint64_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, float> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, uint32_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, uint16_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, uint8_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector3, bool> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, double> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, uint64_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, float> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, uint32_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, uint16_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, uint8_t> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<IntVector4, bool> CreateVolumeDataReadAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, double> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, uint64_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, float> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, uint32_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, uint16_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, uint8_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, bool> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, double> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, uint64_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, float> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, uint32_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, uint16_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, uint8_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, bool> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, double> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, uint64_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, float> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, uint32_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, uint16_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, uint8_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, bool> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, double> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, uint64_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, float> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, uint32_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, uint16_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, uint8_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector2, bool> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, double> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, uint64_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, float> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, uint32_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, uint16_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, uint8_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector3, bool> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, double> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, uint64_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, float> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, uint32_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, uint16_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, uint8_t> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadWriteAccessor<IntVector4, bool> CreateVolumeDataReadWriteAccessor(DimensionsND dimensionsND, int LOD, int channel, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector2, double> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector2, float> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector3, double> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector3, float> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector4, double> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector4, float> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, int maxPages, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector2, double> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector2, float> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector3, double> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector3, float> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector4, double> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue)

template<> inline VolumeDataReadAccessor<FloatVector4, float> CreateInterpolatingVolumeDataAccessor(DimensionsND dimensionsND, int LOD, int channel, InterpolationMethod interpolationMethod, optional<float> replacementNoValue)

Public Static Attributes

static constexpr AccessMode AccessMode_ReadOnly = VolumeDataPageAccessor::AccessMode_ReadOnly

static constexpr AccessMode AccessMode_ReadWrite = VolumeDataPageAccessor::AccessMode_ReadWrite

static constexpr AccessMode AccessMode_Create = VolumeDataPageAccessor::AccessMode_Create

static constexpr AccessMode AccessMode_CreateWithoutLODGeneration = VolumeDataPageAccessor::AccessMode_CreateWithoutLODGeneration

static constexpr AccessMode AccessMode_ReadWriteWithoutLODGeneration = VolumeDataPageAccessor::AccessMode_ReadWriteWithoutLODGeneration

static constexpr int Dimensionality_Max = VolumeDataLayout::Dimensionality_Max: the maximum number of dimensions a VDS can have

static constexpr int maxPagesDefault = 8: the default maxPages for VolumeDataPageAccessors

class VolumeDataAxisDescriptor

#include <VolumeDataAxisDescriptor.h>

Describes the number of samples, name, unit and coordinates (annotation) of an axis (dimension) of the volume.

Public Functions

inline VolumeDataAxisDescriptor(): Default constructor.

inline VolumeDataAxisDescriptor(int numSamples, const char *name, const char *unit, float coordinateMin, float coordinateMax)

Constructor.

Parameters:

numSamples – The number of samples along this axis
name – The name of this axis
unit – The unit of the coordinates of this axis
coordinateMin – The coordinate of the first sample of this axis
coordinateMax – The coordinate of the last sample of this axis

inline int GetNumSamples() const

Get the number of samples along this axis.

Returns:: The number of samples along this axis

inline const char *GetName() const

Get the name of this axis.

Returns:: The name of this axis

inline const char *GetUnit() const

Get the unit of the coordinates of this axis.

Returns:: The unit of the coordinates of this axis

inline float GetCoordinateMin() const

Get the coordinate of the first sample of this axis.

Returns:: The coordinate of the first sample of this axis

inline float GetCoordinateMax() const

Get the coordinate of the last sample of this axis.

Returns:: The coordinate of the last sample of this axis

inline float GetCoordinateStep() const

Get the coordiante step size per sample.

Returns:: The coordiante step size per sample

inline float SampleIndexToCoordinate(int sampleIndex) const

Convert a sample index on this axis to a coordinate.

Parameters:: sampleIndex – The sample index get the coordinate of
Returns:: The coordinate of the sample index

inline int CoordinateToSampleIndex(float coordinate) const

Convert a coordinate to a sample index (rounding to the closest index)

Parameters:: coordinate – The coordinate to get the sample index of
Returns:: The sample index of the coordinate

inline float CoordinateToSamplePosition(float coordinate) const

Convert a coordinate to a sample position (to use with RequestVolumeSamples or an InterpolatingVolumeDataAccessor)

Parameters:: coordinate – The coordinate to get the sample position of
Returns:: The sample position of the coordinate

class VolumeDataChannelDescriptor

#include <VolumeDataChannelDescriptor.h>

Describes a channel of a VDS.

Public Types

enum Flags

Flags for this channel.

Values:

enumerator Default

enumerator DiscreteData: This channel contains discrete data.

enumerator NoLossyCompression: Do not allow lossy compression on this channel.

enumerator NotRenderable: This channel is not renderable.

enumerator NoLossyCompressionUseZip: Use Zip when compressing this channel.

typedef VolumeDataFormat Format

typedef VolumeDataComponents Components

Public Functions

inline VolumeDataChannelDescriptor()

inline VolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax)

The minimum constructor for a VolumeDataChannelDescriptor. This will use direct mapping, default flags, and no NoValue

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed

inline VolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, VolumeDataMapping mapping)

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed
mapping – the mapping for this channel

inline VolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, enum Flags flags)

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed
flags – the flags for this channel

inline VolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, VolumeDataMapping mapping, enum Flags flags)

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed
mapping – the mapping for this channel
flags – the flags for this channel

inline VolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, VolumeDataMapping mapping, int mappedValueCount, enum Flags flags, float integerScale, float integerOffset)

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed
mapping – the mapping for this channel
mappedValueCount – When using per trace mapping, the number of values to store per trace
flags – the flags for this channel
integerScale – the scale to use for integer types
integerOffset – the offset to use for integer types

inline VolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, float noValue)

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed
noValue – the No Value for this channel

inline VolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, float noValue, VolumeDataMapping mapping, enum Flags flags)

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed
noValue – the No Value for this channel
mapping – the mapping for this channel
flags – the flags for this channel

inline VolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, VolumeDataMapping mapping, int mappedValueCount, enum Flags flags, float noValue, float integerScale, float integerOffset)

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed
mapping – the mapping for this channel
mappedValueCount – When using per trace mapping, the number of values to store per trace
flags – the flags for this channel
noValue – the No Value for this channel
integerScale – the scale to use for integer types
integerOffset – the offset to use for integer types

inline Format GetFormat() const

inline Components GetComponents() const

inline bool IsDiscrete() const

inline bool IsRenderable() const

inline bool IsAllowLossyCompression() const

inline bool IsUseZipForLosslessCompression() const

inline const char *GetName() const

inline const char *GetUnit() const

inline const FloatRange &GetValueRange() const

inline float GetValueRangeMin() const

inline float GetValueRangeMax() const

inline VolumeDataMapping GetMapping() const

inline int GetMappedValueCount() const

inline bool IsUseNoValue() const

inline float GetNoValue() const

inline float GetIntegerScale() const

inline float GetIntegerOffset() const

inline VolumeDataChannelDescriptor::Flags GetFlags() const

Public Static Functions

static inline VolumeDataChannelDescriptor TraceMappedVolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, int mappedValueCount, enum Flags flags)

Named constructor for a trace mapped channel

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed
mappedValueCount – When using per trace mapping, the number of values to store per trace
flags – the flags for this channel

Returns:

a trace mapped descriptor

static inline VolumeDataChannelDescriptor TraceMappedVolumeDataChannelDescriptor(Format format, Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, int mappedValueCount, enum Flags flags, float noValue)

Named constructor for a trace mapped channel

Parameters:

format – the data format for this channel
components – the number of vector components (1 for scalar data) for this channel
name – the name of this channel
unit – the unit of this channel
valueRangeMin – The estimated minimum value of this channel, with outliers removed, suitable for displaying the data and used for automatic conversion between R32 and quantized U8 and U16 representations of the data
valueRangeMax – The estimated maximum value of this channel, with outliers removed
mappedValueCount – When using per trace mapping, the number of values to store per trace
flags – the flags for this channel
noValue – the No Value for this channel

Returns:

a trace mapped descriptor

Public Static Attributes

static constexpr Format Format_Any = VolumeDataFormat::Format_Any: data can be in any format

static constexpr Format Format_1Bit = VolumeDataFormat::Format_1Bit: data is in packed 1-bit format

static constexpr Format Format_U8 = VolumeDataFormat::Format_U8: data is in unsigned 8 bit

static constexpr Format Format_U16 = VolumeDataFormat::Format_U16: data is in unsigned 16 bit

static constexpr Format Format_R32 = VolumeDataFormat::Format_R32: data is in 32 bit float

static constexpr Format Format_U32 = VolumeDataFormat::Format_U32: data is in unsigned 32 bit

static constexpr Format Format_R64 = VolumeDataFormat::Format_R64: data is in 64 bit double

static constexpr Format Format_U64 = VolumeDataFormat::Format_U64: data is in unsigned 64 bit

static constexpr Components Components_1 = VolumeDataComponents::Components_1

static constexpr Components Components_2 = VolumeDataComponents::Components_2

static constexpr Components Components_4 = VolumeDataComponents::Components_4

class VolumeDataLayout : public OpenVDS::MetadataReadAccess

#include <VolumeDataLayout.h>

a class that contains axis and channel information for a VDS A layout is associated with a VDS object and contains information about axis and channels in the VDS. A VolumeDataLayout can be invalidated when the VDS is invalidated.

Public Functions

virtual uint64_t GetContentsHash() const = 0: gets the contents hash of this VDS

virtual uint64_t GetLayoutHash() const = 0: gets the hash for the layout properties including axis and channels

virtual int GetDimensionality() const = 0: gets the number of dimensions in this VDS

virtual int GetChannelCount() const = 0: gets the number of channels in this VDS

virtual bool IsChannelAvailable(const char *channelName) const = 0: Returns true of the VDS contains.

virtual int GetChannelIndex(const char *channelName) const = 0: Returns the index of a the channel with the given name.

virtual VolumeDataLayoutDescriptor GetLayoutDescriptor() const = 0: Returns the descriptor for the layout.

virtual VolumeDataChannelDescriptor GetChannelDescriptor(int channel) const = 0: Returns the descriptor for the given channel index.

virtual VolumeDataAxisDescriptor GetAxisDescriptor(int dimension) const = 0: Returns the axis descriptor for the given dimension.

virtual VolumeDataFormat GetChannelFormat(int channel) const = 0: get the format for the given channel index

virtual VolumeDataComponents GetChannelComponents(int channel) const = 0: get the vector count for the given channel index

virtual const char *GetChannelName(int channel) const = 0: get the name for the given channel index

virtual const char *GetChannelUnit(int channel) const = 0: get the unit for the given channel index

virtual float GetChannelValueRangeMin(int channel) const = 0: get the value range minimum for the given channel index

virtual float GetChannelValueRangeMax(int channel) const = 0: get the value range maximum for the given channel index

virtual bool IsChannelDiscrete(int channel) const = 0: get the discrete flag for the the given channel index

virtual bool IsChannelRenderable(int channel) const = 0: get the renderable flag for the given channel index

virtual bool IsChannelAllowingLossyCompression(int channel) const = 0: get the allow lossy compression flag for the given channel index

virtual bool IsChannelUseZipForLosslessCompression(int channel) const = 0: get the use Zip when compressing flag for the given channel index

virtual VolumeDataMapping GetChannelMapping(int channel) const = 0: get the mapping for the given channel index

virtual int GetDimensionNumSamples(int dimension) const = 0: get the number of samples for the given dimension

virtual const char *GetDimensionName(int dimension) const = 0: get the name for the given dimension

virtual const char *GetDimensionUnit(int dimension) const = 0: get the unit for the given dimension

virtual float GetDimensionMin(int dimension) const = 0: get the coordinate minimum for the given dimension

virtual float GetDimensionMax(int dimension) const = 0: get the coordinate maximum for the given dimension

virtual VDSIJKGridDefinition GetVDSIJKGridDefinitionFromMetadata() const = 0: get the VDSIJKGridDefinition from the metadata in this VDS

virtual bool IsChannelUseNoValue(int channel) const = 0: Returns true if the given channel index uses No Value.

virtual float GetChannelNoValue(int channel) const = 0: gets the No Value for the given channel index

virtual float GetChannelIntegerScale(int channel) const = 0: Returns the integer scale for the given channel index.

virtual float GetChannelIntegerOffset(int channel) const = 0: Returns the integer offset for the given channel index.

Public Static Attributes

static constexpr int Dimensionality_Max = 6: the maximum number of dimensions a VDS can have

class VolumeDataLayoutDescriptor

Public Types

enum BrickSize

Values:

enumerator BrickSize_32

enumerator BrickSize_64

enumerator BrickSize_128

enumerator BrickSize_256

enumerator BrickSize_512

enumerator BrickSize_1024

enumerator BrickSize_2048

enumerator BrickSize_4096

enum LODLevels

Values:

enumerator LODLevels_None

enumerator LODLevels_1

enumerator LODLevels_2

enumerator LODLevels_3

enumerator LODLevels_4

enumerator LODLevels_5

enumerator LODLevels_6

enumerator LODLevels_7

enumerator LODLevels_8

enumerator LODLevels_9

enumerator LODLevels_10

enumerator LODLevels_11

enumerator LODLevels_12

enum Options

Values:

enumerator Options_None

enumerator Options_Create2DLODs

enumerator Options_ForceFullResolutionDimension

Public Functions

inline VolumeDataLayoutDescriptor()

inline VolumeDataLayoutDescriptor(BrickSize brickSize, int negativeMargin, int positiveMargin, int brickSize2DMultiplier, LODLevels lodLevels, Options options, int fullResolutionDimension = 0)

inline bool IsValid() const

inline BrickSize GetBrickSize() const

inline int GetNegativeMargin() const

inline int GetPositiveMargin() const

inline int GetBrickSizeMultiplier2D() const

inline LODLevels GetLODLevels() const

inline bool IsCreate2DLODs() const

inline bool IsForceFullResolutionDimension() const

inline VolumeDataLayoutDescriptor::Options GetOptions() const

inline int GetFullResolutionDimension() const

class VolumeDataPage

Public Functions

virtual VolumeDataPageAccessor &GetVolumeDataPageAccessor() const = 0

virtual void GetMinMax(int (&min)[Dimensionality_Max], int (&max)[Dimensionality_Max]) const = 0

virtual void GetMinMaxExcludingMargin(int (&minExcludingMargin)[Dimensionality_Max], int (&maxExcludingMargin)[Dimensionality_Max]) const = 0

virtual ReadErrorException GetError() const = 0

virtual const void *GetBuffer(int (&size)[Dimensionality_Max], int (&pitch)[Dimensionality_Max]) = 0

inline const void *GetBuffer(int (&pitch)[Dimensionality_Max])

virtual void *GetWritableBuffer(int (&size)[Dimensionality_Max], int (&pitch)[Dimensionality_Max]) = 0

inline void *GetWritableBuffer(int (&pitch)[Dimensionality_Max])

virtual void UpdateWrittenRegion(const int (&writtenMin)[Dimensionality_Max], const int (&writtenMax)[Dimensionality_Max]) = 0

virtual void Release() = 0

class VolumeDataPageAccessor

Public Types

enum AccessMode

Values:

enumerator AccessMode_ReadOnly: The volume data page accessor will only be used for reading.

enumerator AccessMode_ReadWrite: The volume data page accessor will be used for reading and writing (can only be used with LOD 0, the other LODs will be automatically updated)

enumerator AccessMode_Create: The volume data page accessor will be used to write new data, overwriting any existing data (can only be used with LOD 0, the other LODs will be automatically created)

enumerator AccessMode_CreateWithoutLODGeneration: The volume data page accessor will be used to write new data, overwriting any existing data (each LOD has to be created separately)

enumerator AccessMode_ReadWriteWithoutLODGeneration: The volume data page accessor will be used used for reading and writing (each LOD has to be created separately)

Public Functions

virtual VolumeDataLayout const *GetLayout() const = 0

virtual int GetLOD() const = 0

virtual int GetChannelIndex() const = 0

virtual VolumeDataChannelDescriptor GetChannelDescriptor() const = 0

virtual void GetNumSamples(int (&numSamples)[Dimensionality_Max]) const = 0

virtual int64_t GetChunkCount() const = 0

virtual void GetChunkMinMax(int64_t chunk, int (&min)[Dimensionality_Max], int (&max)[Dimensionality_Max]) const = 0

virtual void GetChunkMinMaxExcludingMargin(int64_t chunk, int (&minExcludingMargin)[Dimensionality_Max], int (&maxExcludingMargin)[Dimensionality_Max]) const = 0

virtual uint64_t GetChunkVolumeDataHash(int64_t chunkIndex) const = 0

Get the volume data hash for the given chunk index. The value returned may be tested using the methods VolumeDataHash_IsDefined, VolumeDataHash_IsNoValue, and VolumeDataHash_IsConstant defined in VolumeData.h.

Parameters:: chunkIndex – The chunk index to get the volume data hash for.
Returns:: The volume data hash for the chunk.

virtual int64_t GetChunkIndex(const int (&position)[Dimensionality_Max]) const = 0

virtual int64_t GetMappedChunkIndex(int64_t primaryChannelChunkIndex) const = 0

Get the chunk index for this VolumeDataPageAccessor corresponding to the given chunk index in the primary channel. Because some channels can have mappings (e.g. one value per trace), the number of chunks can be less than in the primary channel and we need to have a mapping to figure out the chunk index in each channel that is produced together.

Parameters:: primaryChannelChunkIndex – The index of the chunk in the primary channel (channel 0) that we want to map to a chunk index for this VolumeDataPageAccessor.
Returns:: The chunk index for this VolumeDataPageAccessor corresponding to the given chunk index in the primary channel.

virtual int64_t GetPrimaryChannelChunkIndex(int64_t chunkIndex) const = 0

Get the primary channel chunk index corresponding to the given chunk index of this VolumeDataPageAccessor. In order to avoid creating duplicates requests when a channel is mapped, we need to know which primary channel chunk index is representative of a particular mapped chunk index.

Parameters:: chunkIndex – The chunk index for this VolumeDataPageAccessor that we want the representative primary channel chunk index of.
Returns:: The primary channel chunk index corresponding to the given chunk index for this VolumeDataPageAccessor.

virtual int64_t GetSuperChunkCount() const = 0

Get the number of super-chunks for this VolumeDataPageAccessor. Each super-chunk is an overlapping block of chunks from the remap source of this VolumeDataPageAccessor and the chunks in this VolumeDataPageAccessor. In order to produce the chunks as efficiently as possible (if there are more chunks than super-chunks), any code that iterates over all the chunks of a page accessor should iterate over the super-chunks and then over the chunks within each super-chunk.

Returns:: The number of super-chunks for this VolumeDataPageAccessor.

inline std::vector<int64_t> GetChunkIndicesInSuperChunk(int64_t superChunkIndex) const

Get the list of chunks in the given super-chunk. Each super-chunk is an overlapping block of chunks from the remap source of this VolumeDataPageAccessor and the chunks in this VolumeDataPageAccessor. In order to produce the chunks as efficiently as possible (if there are more chunks than super-chunks), any code that iterates over all the chunks of a page accessor should iterate over the super-chunks and then over the chunks within each super-chunk.

Parameters:: superChunkIndex – The super-chunk index for this VolumeDataPageAccessor that we want the list of chunks in.
Returns:: The list of chunks in the super-chunk

virtual int AddReference() = 0

virtual int RemoveReference() = 0

virtual int GetMaxPages() = 0

virtual void SetMaxPages(int maxPages) = 0

virtual VolumeDataPage *CreatePage(int64_t chunkIndex) = 0

virtual void CopyPage(int64_t chunkIndex, VolumeDataPageAccessor const &source) = 0

Copy a page of data from another VolumeDataPageAccessor with a compatible layout. This method is not blocking so if you want to access the copied data you need to call ReadPage which will block until the copy is done and return the copied data.

Parameters:

chunkIndex – The chunk index to copy
source – The VolumeDataPageAccessor to copy data from

virtual VolumeDataPage *ReadPage(int64_t chunkIndex) = 0

virtual VolumeDataPage *ReadPageAtPosition(const int (&position)[Dimensionality_Max]) = 0

virtual void Commit() = 0

template<typename INDEX, typename T> class VolumeDataReadAccessor

#include <VolumeDataAccess.h>

A class that provides random read access to the voxel values of a VDS.

Subclassed by OpenVDS::VolumeDataReadWriteAccessor< INDEX, T >

Public Functions

inline VolumeDataLayout const *GetLayout() const

inline int64_t RegionCount() const

inline IndexRegion<INDEX> Region(int64_t region) const

inline int64_t RegionFromIndex(INDEX index)

inline IndexRegion<INDEX> CurrentRegion() const

inline T GetValue(INDEX index) const

inline VolumeDataReadAccessor()

inline VolumeDataReadAccessor(IVolumeDataReadAccessor<INDEX, T> *accessor)

inline VolumeDataReadAccessor(VolumeDataReadAccessor const &readAccessor)

inline ~VolumeDataReadAccessor()

template<typename INDEX, typename T> class VolumeDataReadWriteAccessor : public OpenVDS::VolumeDataReadAccessor<INDEX, T>

#include <VolumeDataAccess.h>

A class that provides random read/write access to the voxel values of a VDS.

Public Functions

inline void SetValue(INDEX index, T value)

inline void Commit()

inline void Cancel()

inline VolumeDataReadWriteAccessor()

inline VolumeDataReadWriteAccessor(IVolumeDataReadWriteAccessor<INDEX, T> *accessor)

inline VolumeDataReadWriteAccessor(VolumeDataReadWriteAccessor const &readWriteAccessor)

class VolumeDataRequest

#include <VolumeDataAccessManager.h>

A VolumeDataRequest encapsulates an asynchronous request for volume data from a VDS object instance.

When created by a VolumeDataAccessManager a VolumeDataRequest will be active. The request remains active until either IsCompleted(), IsCanceled() or WaitForCompletion() returns true.

It is supported to access a VolumeDataRequest from a different thread than where it was created, but concurrent access to the same instance from multiple threads can result in race conditions.

Subclassed by OpenVDS::VolumeDataRequest_t< VALUETYPE >

Public Functions

inline VolumeDataRequest()

inline VolumeDataRequest(IVolumeDataAccessManager *manager)

inline VolumeDataRequest(IVolumeDataAccessManager *manager, void *buffer, int64_t bufferByteSize, VolumeDataFormat bufferDataType)

inline VolumeDataRequest(IVolumeDataAccessManager *manager, int64_t bufferByteSize, VolumeDataFormat bufferDataType)

inline virtual ~VolumeDataRequest(): Destructor will automatically cancel the request if it is still active.

inline void ValidateRequest(): Check if the request object is valid. Throws an InvalidOperation exception if the request object is not valid.

inline int64_t RequestID() const

Get the ID of the request.

Returns:: The ID of the request.

inline bool IsCompleted()

Check if the request completed successfully. If the request completed, the buffer now contains valid data.

Returns:: The request is active until either IsCompleted, IsCanceled or WaitForCompletion returns true.

inline bool IsCanceled()

Check if the request was canceled (e.g. the VDS was invalidated before the request was processed). If the request was canceled, the buffer does not contain valid data.

Returns:: The request is active until either IsCompleted, IsCanceled or WaitForCompletion returns true.

inline bool WaitForCompletion(int millisecondsBeforeTimeout = 0)

Wait for the VolumeDataRequest to complete successfully. If the request completed, the buffer now contains valid data.

Parameters:: millisecondsBeforeTimeout – The number of milliseconds to wait before timing out (optional). A value of 0 indicates there is no timeout and we will wait for however long it takes. Note that the request is not automatically canceled if the wait times out, you can also use this mechanism to e.g. update a progress bar while waiting. If you want to cancel the request you have to explicitly call CancelRequest() and then wait for the request to stop writing to the buffer.
Returns:: The request is active until either IsCompleted, IsCanceled or WaitForCompletion returns true. Whenever WaitForCompletion returns false you need to call IsCanceled() to know if that was because of a timeout or if the request was canceled.

inline void Cancel(): Try to cancel the request. You still have to call WaitForCompletion/IsCanceled to make sure the buffer is not being written to and to take the job out of the system. It is possible that the request has completed concurrently with the call to Cancel in which case WaitForCompletion will return true.

inline void CancelAndWaitForCompletion(): Cancel the request and wait for it to complete. This call will block until the request has completed so you can be sure the buffer is not being written to and the job is taken out of the system.

inline int GetErrorCode()

Get the error code of a request that has been cancelled.

Returns:: The error code. If the error code is positive, it corresponds to the enum values in Hue::HueSpaceLib::ErrorCode. Compute plugins may set their own negative error code, which causes the return value of this method to be a plain int value that does not correspond to one of the enum values.

inline std::string GetErrorMessage()

Get the error string of a request that has been cancelled.

Returns:: The error string.

inline float GetCompletionFactor()

Get the completion factor (between 0 and 1) of the request.

Returns:: A factor (between 0 and 1) indicating how much of the request has been completed.

inline void *Buffer() const

Get the pointer to the buffer the request is writing to.

Returns:: The pointer to the buffer the request is writing to.

inline int64_t BufferByteSize() const

Get the size of the buffer the request is writing to.

Returns:: The size of the buffer the request is writing to.

inline VolumeDataFormat BufferDataType() const

Get the volume data format of the buffer the request is writing to.

Returns:: The volume data format of the buffer the request is writing to.

template<> struct RequestFormat<double>

Public Static Attributes

static constexpr VolumeDataFormat format = VolumeDataFormat::Format_R64

template<> struct RequestFormat<float>

Public Static Attributes

static constexpr VolumeDataFormat format = VolumeDataFormat::Format_R32

template<> struct RequestFormat<uint16_t>

Public Static Attributes

static constexpr VolumeDataFormat format = VolumeDataFormat::Format_U16

template<> struct RequestFormat<uint32_t>

Public Static Attributes

static constexpr VolumeDataFormat format = VolumeDataFormat::Format_U32

template<> struct RequestFormat<uint64_t>

Public Static Attributes

static constexpr VolumeDataFormat format = VolumeDataFormat::Format_U64

template<> struct RequestFormat<uint8_t>

Public Static Attributes

static constexpr VolumeDataFormat format = VolumeDataFormat::Format_U8

template<typename VALUETYPE> class VolumeDataRequest_t : public OpenVDS::VolumeDataRequest

Public Types

using element_t = VALUETYPE

Public Functions

inline virtual ~VolumeDataRequest_t() override

inline virtual std::vector<VALUETYPE> &Data()

template<int N> struct VolumeIndexerBase : public OpenVDS::VolumeIndexerData 

Public Functions

inline int GetDataBlockNumSamples(int iDimension) const

Gets the number of samples for a dimension in the DataBlock

Parameters:: iDimension – the DataBlock dimension
Returns:: the number of samples in the dimension

inline int GetLocalChunkNumSamples(int iDimension) const

Get the number of samples for a dimension in the volume

Parameters:: iDimension – the volume dimension
Returns:: the number of samples in the dimension

inline IntVector<N> LocalIndexToVoxelIndex(const IntVector<N> &iLocalIndex) const

Converts a local index to a voxel index

Parameters:: iLocalIndex – the local index to convert
Returns:: the voxel index

inline FloatVector<N> LocalIndexToVoxelIndexFloat(const FloatVector<N> &iLocalIndex) const

Converts a float local index to a float voxel index

Parameters:: iLocalIndex – the float local index to convert
Returns:: the float voxel index

inline IntVector<N> LocalIndexToLocalChunkIndex(const IntVector<N> &iLocalIndex) const

Converts a local index to a local chunk index

Parameters:: iLocalIndex – the local index to convert
Returns:: the local chunk index

inline IntVector<N> VoxelIndexToLocalIndex(const IntVector<N> &iVoxelIndex) const

Converts a voxel index to a local index

Parameters:: iVoxelIndex – the voxel index to convert
Returns:: the local index

inline FloatVector<N> VoxelIndexToLocalIndexFloat(const FloatVector<N> &iVoxelIndex) const

Converts a float voxel index to a float local index

Parameters:: iVoxelIndex – the float voxel index to convert
Returns:: the float local index

inline FloatVector<N> VoxelIndexToVolumeSamplerLocalIndex(const FloatVector<N> &iVoxelIndex) const

Converts a float voxel index to a volume sampler local index. The volume sampler works like OpenGL textures so the first sample starts at 0.5.

Parameters:: iVoxelIndex – the float voxel index to convert
Returns:: the float volume sampler local index

inline IntVector<N> VoxelIndexToLocalChunkIndex(const IntVector<N> &iVoxelIndex) const

Converts a voxel index to a local chunk index

Parameters:: iVoxelIndex – the voxel index to convert
Returns:: the local chunk index

inline IntVector<N> LocalChunkIndexToLocalIndex(const IntVector<N> &iLocalChunkIndex) const

Converts a local chunk index to a local index

Parameters:: iLocalChunkIndex – the local chunk index to convert
Returns:: the local index

inline IntVector<N> LocalChunkIndexToVoxelIndex(const IntVector<N> &iLocalChunkIndex) const

Converts a local chunk index to a voxel index

Parameters:: iLocalChunkIndex – the local chunk index to convert
Returns:: the local voxel index

inline int VoxelIndexToDataIndex(const IntVector<N> &iVoxelIndex) const

Converts a voxel index to a data index

Parameters:: iVoxelIndex – the voxel index to convert
Returns:: the buffer offset for the voxel index

inline int LocalIndexToDataIndex(const IntVector<N> &iLocalIndex) const

Converts a local index to a data index

Parameters:: iLocalIndex – the local index to convert
Returns:: the buffer offset for the local index

inline int LocalChunkIndexToDataIndex(const IntVector<N> &iLocalChunkIndex) const

Converts a local chunk index to a data index

Parameters:: iLocalChunkIndex – the local chunk index to convert
Returns:: the buffer offset for the local chunk index

inline int VoxelIndexToBitDataIndex(const IntVector<N> &iVoxelIndex) const

Converts a voxel index to a bit data index

Used with the BitMask functions to read and write 1Bit data

See also

BitMaskFromVoxelIndex

Parameters:: iVoxelIndex – the voxel index to convert
Returns:: the buffer offset (in number of bits) for the voxel index

inline int LocalIndexToBitDataIndex(const IntVector<N> &iLocalIndex) const

Converts a local index to a bit data index

Used with the BitMask functions to read and write 1Bit data

See also

BitMaskFromLocalIndex

Parameters:: iLocalIndex – the local index to convert
Returns:: the buffer offset (in number of bits) for the local index

inline int LocalChunkIndexToBitDataIndex(const IntVector<N> &iLocalChunkIndex) const

Converts a local chunk index to a bit data index

Used with the BitMask functions to read and write 1Bit data

See also

BitMaskFromLocalChunkIndex

Parameters:: iLocalChunkIndex – the local chunk index to convert
Returns:: the buffer offset (in number of bits) for the local chunk index

inline unsigned char BitMaskFromLocalIndex(const IntVector<N> &iLocalIndex) const

Gets the bit mask for a local index

Used with the BitDataIndex functions to read and write 1Bit data

Common usage:

bool bit = buffer[LocalIndexToBitDataIndex(iLocalIndex) / 8] & BitMaskFromLocalIndex(iLocalIndex) != 0;

See also

LocalIndexToBitDataIndex

Parameters:: iLocalIndex – the local index to compute the mask from
Returns:: the bit mask for the local index

inline unsigned char BitMaskFromVoxelIndex(const IntVector<N> &iVoxelIndex) const

Gets the bit mask for a voxel index

Used with the BitDataIndex functions to read and write 1Bit data

Common usage:

bool bit = buffer[VoxelIndexToBitDataIndex(iVoxelIndex) / 8] & BitMaskFromVoxelIndex(iVoxelIndex) != 0;

See also

VoxelIndexToBitDataIndex

Parameters:: iVoxelIndex – the voxel index to compute the mask from
Returns:: the bit mask for the voxel index

inline unsigned char BitMaskFromLocalChunkIndex(const IntVector<N> &iLocalChunkIndex) const

Gets the bit mask for a local chunk index

Used with the BitDataIndex functions to read and write 1Bit data

Common usage:

bool bit = buffer[LocalChunkIndexToBitDataIndex(iLocalChunkIndex) / 8] & BitMaskFromLocalChunkIndex(iLocalChunkIndex) != 0;

See also

LocalChunkIndexToBitDataIndex

Parameters:: iLocalChunkIndex – the local index to compute the mask from
Returns:: the bit mask for the local chunk index

inline bool BitValueFromLocalIndex(const unsigned char *data, const IntVector<N> &iLocalIndex) const

Convenience function for reading the bit value from a 1Bit DataBlock buffer at a local index

See also

LocalIndexToBitDataIndex

See also

BitMaskFromLocalIndex

Parameters:

data – the 1Bit buffer to read
iLocalIndex – the local index to read

Returns:

the binary value read

inline bool BitValueFromVoxelIndex(const unsigned char *data, const IntVector<N> &iVoxelIndex) const

Convenience function for reading the bit value from a 1Bit DataBlock buffer at a voxel index

See also

VoxelIndexToBitDataIndex

See also

BitMaskFromVoxelIndex

Parameters:

data – the 1Bit buffer to read
iVoxelIndex – the voxel index to read

Returns:

the binary value read

inline bool BitValueFromLocalChunkIndex(const unsigned char *data, const IntVector<N> &iLocalChunkIndex) const

Convenience function for reading the bit value from a 1Bit DataBlock buffer at a local chunk index

See also

LocalChunkIndexToBitDataIndex

See also

BitMaskFromLocalChunkIndex

Parameters:

data – the 1Bit buffer to read
iLocalChunkIndex – the local chunk index to read

Returns:

the binary value read

inline bool VoxelIndexInProcessArea(const IntVector<N> &iVoxelIndex) const

Checks if a voxel index is within the chunk this indexer was created with

Parameters:: iVoxelIndex – the voxel index to check
Returns:: true if the index is within this chunk, false otherwise

inline bool LocalIndexInProcessArea(const IntVector<N> &iLocalIndex) const

Checks if a local index is within the DataBlock this indexer was created with

Parameters:: iLocalIndex – the local index to check
Returns:: true if the index is within this chunk, false otherwise

inline bool LocalChunkIndexInProcessArea(const IntVector<N> &iLocalChunkIndex) const

Checks if a local chunk index is within the chunk this indexer was created with

Parameters:: iLocalChunkIndex – the local chunk index to check
Returns:: true if the index is within this chunk, false otherwise

inline float GetCoordinateStep(int iDimension) const

Gets the coordinate step for the given volume dimension at LOD 0

Parameters:: iDimension – the volume dimension
Returns:: the coordinate step at LOD 0

inline FloatVector<N> LocalIndexToCoordinate(const IntVector<N> &iLocalIndex) const

Converts a local index to coordinates

Parameters:: iLocalIndex – the local index to convert
Returns:: the coordinates

inline float VoxelIndexToCoordinate(int iVoxelIndex, int iDimension) const

Converts a voxel index for a specific volume dimension to a coordinate value

Parameters:

iVoxelIndex – the voxel index to convert
iDimension – the volume dimension

Returns:

the coordinate

inline float VoxelIndexFloatToCoordinate(float rVoxelIndex, int iDimension) const

Converts a float voxel index for a specific volume dimension to a coordinate value

Parameters:

rVoxelIndex – the voxel index to convert
iDimension – the volume dimension

Returns:

the coordinate

inline IntVector<N> CoordinateToLocalIndex(const FloatVector<N> &rCoordinate) const

Converts coordinates to a local index, rounding to the nearest integer

Parameters:: rCoordinate – the coordinates to convert
Returns:: the local index

inline FloatVector<N> CoordinateToLocalIndexFloat(const FloatVector<N> &rCoordinate) const

Converts coordinates to a float local index without rounding

Parameters:: rCoordinate – the coordinates to convert
Returns:: the float local index

inline FloatVector<N> CoordinateToVolumeSamplerLocalIndex(const FloatVector<N> &rCoordinate) const

Converts coordinates to a volume sampler local index. The volume sampler works like OpenGL textures so the first sample starts at 0.5.

Parameters:: rCoordinate – the coordinates to convert
Returns:: the float volume sampler local index

inline int CoordinateToVoxelIndex(float rCoordinate, int iDimension) const

Converts a coordinate for a specific volume dimension to a voxel index, rounding to the nearest integer

Parameters:

rCoordinate – the coordinate to convert
iDimension – the volume dimension

Returns:

the voxel index

inline float CoordinateToVoxelIndexFloat(float rCoordinate, int iDimension) const

Converts a coordinate for a specific volume dimension to a float voxel index without rounding

Parameters:

rCoordinate – the coordinate to convert
iDimension – the volume dimension

Returns:

the float voxel index

inline FloatVector<N> LocalIndexToRelativeAxisPosition(const IntVector<N> &iLocalIndex) const

Converts a local index to a relative position (between 0 and 1) along the volume axes

Parameters:: iLocalIndex – the local index to convert
Returns:: the relative position along volume axes

inline IntVector<N> RelativeAxisPositionToLocalIndex(const FloatVector<N> &rPosition) const

Converts a relative position along the volume axes to a local index

Parameters:: rPosition – the relative postion to convert
Returns:: the local index

inline float VoxelIndexToRelativeAxisPosition(int iVoxelIndex, int iDimension) const

Converts a voxel index for a specific dimension to a relative position (between 0 and 1) along a volume axis

Parameters:

iVoxelIndex – the voxel index to convert
iDimension – the volume dimension

Returns:

the relative position along the iDimension axis

inline int RelativeAxisPositionToVoxelIndex(float rPosition, int iDimension) const

Converts a relative volume axis position to a voxel index, rounding to the nears integer

Parameters:

rPosition – the axis position
iDimension – the volume dimension

Returns:

the voxel index

inline FloatVector<3> VoxelIndexToWorldCoordinates(const IntVector<N> &iVoxelIndex, const VDSCoordinateTransformerBase<N> &cVDSCoordinateTransformer) const

Converts a voxel index to world coordinates using the coordinate transformer’s IJK grid definition and IJK dimension map

Parameters:

iVoxelIndex – the voxel index to convert
cVDSCoordinateTransformer – the coordinate transformer to use

Returns:

the world coordinates

inline FloatVector<3> VoxelIndexToWorldCoordinates(const FloatVector<N> &rVoxelIndex, const VDSCoordinateTransformerBase<N> &cVDSCoordinateTransformer) const

Converts a float voxel index to world coordinates using the coordinate transformer’s IJK grid definition and IJK dimension map

Parameters:

rVoxelIndex – the float voxel index to convert
cVDSCoordinateTransformer – the coordinate transformer to use

Returns:

the world coordinates

inline IntVector<N> WorldCoordinatesToVoxelIndex(const FloatVector<3> &rWorldCoords, const VDSCoordinateTransformerBase<N> &cVDSCoordinateTransformer) const

Converts world coordinates to a voxel index, rounding to the nearest integer

Parameters:

rWorldCoords – the world coordinates to convert
cVDSCoordinateTransformer – the coordinate transformer to use

Returns:

the voxel index

inline FloatVector<N> WorldCoordinatesToVoxelIndexFloat(const FloatVector<3> &rWorldCoords, const VDSCoordinateTransformerBase<N> &cVDSCoordinateTransformer) const

Converts world coordinates to a float voxel index without rounding

Parameters:

rWorldCoords – the world coordinates to convert
cVDSCoordinateTransformer – the coordinate transformer to use

Returns:

the float voxel index

inline FloatVector<3> LocalIndexToWorldCoordinates(const IntVector<N> &iLocalIndex, const VDSCoordinateTransformerBase<N> &cVDSCoordinateTransformer) const

Converts a local index to world coordinates using the coordinate transformer’s IJK grid definition and IJK dimension map

Parameters:

iLocalIndex – the local index to convert
cVDSCoordinateTransformer – the coordinate transformer to use

Returns:

the world coordinates

inline IntVector<N> WorldCoordinatesToLocalIndex(const FloatVector<3> &rWorldCoords, const VDSCoordinateTransformerBase<N> &cVDSCoordinateTransformer) const

Converts world coordinates to a local index, rounding to the nearest integer

Parameters:

rWorldCoords – the world coordinates to convert
cVDSCoordinateTransformer – the coordinate transformer to use

Returns:

the local index

inline VolumeIndexerBase()

inline VolumeIndexerBase(const VolumeDataPage *page, int32_t channelIndex, int32_t lod, DimensionsND dimensions, const VolumeDataLayout *layout)

Public Static Functions

static inline unsigned char BitMaskFromBitDataIndex(int iBitDataIndex)

Gets the bit mask for a bit data index

Used with the BitDataIndex functions to read and write 1Bit data

Common usage:

bool bit = buffer[iBitDataIndex >> 3] &

BitMaskFromBitDataIndex(iBitDataIndex) != 0;

Parameters:: iBitDataIndex – the local index to compute the mask from
Returns:: the bit mask for the local index

static inline bool BitValueFromBitDataIndex(const unsigned char *data, int iBitDataIndex)

Convenience function for reading the bit value from a 1Bit DataBlock buffer at a local index

See also

BitMaskFromBitDataIndex

Parameters:

data – the 1Bit buffer to read
iBitDataIndex – the bit index to read

Returns:

the binary value read

static inline VolumeIndexerBase<N> CreateTempBufferIndexer(int (&anVoxelMin)[6], int (&anVoxelMax)[6], int iLOD = 0)

Creates an indexer for a temp buffer from voxel minimum and maximums.

Parameters:

anVoxelMin – voxel minimum for this indexer
anVoxelMax – voxel maximum for this indexer
iLOD – the LOD for this indexer

Returns:

the created indexer

static inline VolumeIndexerBase<N> CreateTempBufferIndexer(const VolumeIndexerBase<N> &indexer)

Create a temp buffer indexer with the same area and configuration as another indexer.

Parameters:: indexer – the indexer to copy configuration and area from
Returns:: the created indexer

static inline VolumeIndexerBase<N> CreateTempBufferIndexer(const VolumeIndexerBase<N> &indexer, int anNewVoxelMin[6], int anNewVoxelMax[6])

Create a temp buffer indexer with the same configuration as another indexer, but a new voxel min and max

Parameters:

indexer – the indexer to copy configuration from
anNewVoxelMin – the voxel minimum for the created indexer
anNewVoxleMax – the voxel maximum for the created indexer

Returns:

the created indexer

struct VolumeIndexerData

Subclassed by OpenVDS::VolumeIndexerBase< N >

Public Functions

inline VolumeIndexerData()

VolumeIndexerData(const VolumeDataPage *page, int32_t channelIndex, int32_t lod, DimensionsND dimensions, const VolumeDataLayout *layout)

Public Members

int32_t voxelMin[Dimensionality_Max]: Minimum voxel range in volume dimensions.

int32_t voxelMax[Dimensionality_Max]: Maximum voxel range in volume dimensions.

int32_t localChunkSamples[Dimensionality_Max]: Number of samples in volume dimensions.

int32_t localChunkAllocatedSize[Dimensionality_Max]: Allocated size of buffer in volume dimensions.

int32_t pitch[Dimensionality_Max]: Pitch for buffer in volume dimensions.

int32_t bitPitch[Dimensionality_Max]: Pitch for bits in volume dimensions.

int32_t dataBlockSamples[DataBlockDimensionality_Max]: Number of sample in DataBlock dimensions.

int32_t dataBlockAllocatedSize[DataBlockDimensionality_Max]: Allocated size of buffer in DataBlock dimensions.

int32_t dataBlockPitch[DataBlockDimensionality_Max]: Pitch for buffer in DataBlock dimensions.

int32_t dataBlockBitPitch[DataBlockDimensionality_Max]: Pitch for bits in DataBlock dimensions.

int32_t dimensionMap[DataBlockDimensionality_Max]: Map from DataBlock dimensions to volume dimensions.

int32_t lod: Level of Detail for data being indexed.

bool isDimensionLODDecimated[Dimensionality_Max]: Indicates if a volume dimension is decimated with the LOD or not.

float coordinateMin[Dimensionality_Max]: Minimum coordinates in volume dimensions.

float coordinateMax[Dimensionality_Max]: Maximum coordinates in volume dimensions.

int axisNumSamples[Dimensionality_Max]: Total number of samples in volume dimensions for whole volume (not just this chunk)

float valueRangeMin: The value range minimum for the volume.

float valueRangeMax: The value range maximum for the volume.

Public Static Attributes

static constexpr int DataBlockDimensionality_Max = 4

template<typename T, InterpolationMethod INTERPMETHOD, bool ISUSENOVALUE> class VolumeSampler

Public Functions

inline VolumeSampler()

inline VolumeSampler(const int (&anSize)[DataBlockDimensionality_Max], const int (&anPitch)[DataBlockDimensionality_Max], float rangeMin, float rangeMax, float integerScale, float integerOffset, float noValalue, float replacementNoValue)

Parameters:

anSize – the (at least 3D) size of the buffer to be sampled
anPitch – the (at least 3D) pitch of the buffer to be sampled
rangeMin – the value range minimum of the data to be sampled
rangemax – the value range maximum of the data to be sampled
noValalue – the no value for the data to be sampled
replacementNoValue – the value to replace any NoValues with

inline TREAL Sample3D(const T *ptBuffer, FloatVector3 localIndex) const

Sample the given buffer at the the given 3D index

The returned TREAL type is double when T is double, int32, or int64 and float for all other types

Parameters:

ptBuffer – pointer to the buffer to be samples
localIndex – the local 3D index into the buffer

Returns:

a TREAL sampled using the ::InterpolationType at the given index

inline bool IsHeightValid(T tHeight) const

inline TREAL Sample2D(const T *ptBuffer, FloatVector2 localIndex) const

Sample the given buffer at the the given 2D index

The returned TREAL type is double when T is double, int32, or int64 and float for all other types

Parameters:

ptBuffer – pointer to the buffer to be samples
localIndex – the local 2D index into the buffer

Returns:

a TREAL sampled using the ::InterpolationType at the given index

Public Static Attributes

static constexpr int DataBlockDimensionality_Max = 4

struct WaveletAdaptiveLevel

#include <OpenVDS.h>

Description of an available level of wavelet compression.

Public Functions

inline WaveletAdaptiveLevel()

inline WaveletAdaptiveLevel(float compressionTolerance, float compressionRatio, int64_t compressedSize)

Public Members

float compressionTolerance: Compression tolerance of the wavelet adaptive level.

float compressionRatio: Compression ratio (uncompressed size / compressed size) of the wavelet adaptive level.

int64_t compressedSize: Compressed size of the wavelet adaptive level.