### VDSInfo Command-Line Usage and Examples

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/tools/VDSInfo/README

Demonstrates the basic usage of the VDSInfo command-line tool, including how to specify connection strings, persistent IDs, and various options to extract different types of information from a VDS. It shows examples of retrieving descriptors and metadata.

```bash
VDSInfo [OPTION...] <url>

$ VDSInfo.exe s3://openvds-test --persistentID 7068247E9CA6EA05 --channels --axis --layout

$ VDSInfo.exe s3://openvds-test --persistentID 7068247E9CA6EA05 --channels

$ VDSInfo.exe s3://openvds-test --persistentID 7068247E9CA6EA05 --metadatakeys

$ VDSInfo.exe s3://openvds-test/7068247E9CA6EA05 --metadatakeys

$ VDSInfo.exe s3://openvds-test/7068247E9CA6EA05 --metadata-name TextHeader

$ VDSInfo.exe s3://openvds-test/7068247E9CA6EA05 --metadata-name TextHeader -e -w 80
```

--------------------------------

### S3 Connection Example

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/connection

An example demonstrating how to set up a connection to an S3 backend using a URL and a connection string. This includes specifying the S3 bucket and path in the URL, and the region in the connection string.

```python
url = "s3://my_bucket/somepath"
connection = "Region=eu-north-1"
```

--------------------------------

### SEGYExport Example Usage

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/tools/SEGYExport/README

An example demonstrating how to use the SEGYExport tool to export VDS data to a SEG-Y file. This example utilizes the --url and --persistentID options to specify the VDS source and provides a local path for the output SEG-Y file.

```bash
SEGYExport --url s3://openvds-test --persistentID 7068247E9CA6EA05 D:\Datasets\Australia\shakespeare3d_pstm_Time_export.segy
```

--------------------------------

### VDSCopy Example: Cloud to Cloud Copy

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/tools/VDSCopy/README

Demonstrates copying a VDS dataset from one S3 bucket location to another within the same bucket using VDSCopy. This example utilizes the default compression and dimension group settings.

```bash
$ VDSCopy.exe s3://openvds-test/volve s3://openvds-test/volve_backup

```

--------------------------------

### VDSCopy Example: Copy with Zip Compression

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/tools/VDSCopy/README

This example demonstrates copying a local VDS file to an S3 bucket while explicitly setting the compression method to 'Zip'. This can help manage storage space and transfer times.

```bash
$ VDSCopy.exe --compression-method Zip local_file.vds s3://openvds-test/volve

```

--------------------------------

### Get IJK Annotation Start Point (C++)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/IJKCoordinateTransformer_8h_source

Returns the constant reference to the DoubleVector3 representing the starting annotation point in IJK coordinates. This defines the origin of the annotated region.

```cpp
const DoubleVector3& IJKAnnotationStart() const
{
  return m_IJKAnnotationStart;
}
```

--------------------------------

### Create OpenVDS with Options and Descriptors (Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/python-api

Creates a new VDS handle using provided OpenOptions, layout, axis, channel descriptors, and metadata. This is a primary method for VDS initialization.

```python
openvds.core.VDS openvds.core.VDS.create(options: openvds.core.OpenOptions, layoutDescriptor: OpenVDS::VolumeDataLayoutDescriptor, axisDescriptors: list[OpenVDS::VolumeDataAxisDescriptor], channelDescriptors: list[OpenVDS::VolumeDataChannelDescriptor], metadata: OpenVDS::MetadataReadAccess)
```

--------------------------------

### OpenOptions Constructor and Members (C++)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/file/OpenVDS_8h

Defines the OpenOptions structure, used to configure options for opening VDS files. It includes members for connection type, wavelet adaptive mode and its related tolerance and ratio, request thread count, and log level. Constructors are provided for default and parameterized initialization.

```cpp
inline virtual ~OpenOptions() {}

public:
ConnectionType connectionType;
WaveletAdaptiveMode waveletAdaptiveMode;
float waveletAdaptiveTolerance;
float waveletAdaptiveRatio;
int requestThreadCount;
LogLevel logLevel;

inline OpenOptions(ConnectionType connectionType) {}
inline OpenOptions(ConnectionType connectionType, WaveletAdaptiveMode waveletAdaptiveMode, float waveletAdaptiveTolerance, float waveletAdaptiveRatio, LogLevel logLevel) {}
```

--------------------------------

### Get Dimension Min Value in C++

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/python-api

Retrieves the minimum coordinate value along a specified dimension. This indicates the starting coordinate of the data along that dimension.

```cpp
float minCoord = volumeDataLayout.getDimensionMin(dimensionIndex);
```

--------------------------------

### Transform Inline Coordinate to Index (C++)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Calculates the middle inline number of a VDS dataset and converts it into a sample index using the VolumeDataLayout. This demonstrates how to interact with axis descriptors to get coordinate and sample index information. Requires a valid VolumeDataLayout object.

```cpp
const int sampleDimension = 0, crosslineDimension = 1, inlineDimension = 2;
OpenVDS::VolumeDataAxisDescriptor inlineAxisDescriptor = layout->GetAxisDescriptor(inlineDimension);
int inlineNumber = int((inlineAxisDescriptor.GetCoordinateMin() + inlineAxisDescriptor.GetCoordinateMax()) / 2);
int inlineIndex = inlineAxisDescriptor.CoordinateToSampleIndex((float)inlineNumber);
```

--------------------------------

### Create OpenVDS with IOManager and Compression Options (Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/python-api

Creates a new VDS handle using an IOManager, layout, axis, channel descriptors, metadata, and compression method with tolerance. This overload simplifies VDS creation when detailed error reporting is not immediately needed.

```python
openvds.core.VDS openvds.core.VDS.create(ioManager: openvds.core.IOManager, layoutDescriptor: OpenVDS::VolumeDataLayoutDescriptor, axisDescriptors: list[OpenVDS::VolumeDataAxisDescriptor], channelDescriptors: list[OpenVDS::VolumeDataChannelDescriptor], metadata: OpenVDS::MetadataReadAccess, compressionMethod: OpenVDS::CompressionMethod, compressionTolerance: float)
```

--------------------------------

### Get Dimension Minimum Coordinate

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/namespace/namespaceOpenVDS

Retrieves the minimum coordinate value along a specified dimension. This defines the starting point of the dimension's range.

```C++
virtual float GetDimensionMin(int dimension) const = 0
```

--------------------------------

### Get Volume Data Axis Descriptor Coordinate Min in C++

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/python-api

Retrieves the minimum coordinate value for an axis descriptor. This property is part of the VolumeDataAxisDescriptor class and indicates the start of the axis's range.

```cpp
float minCoord = axisDescriptor._coordinateMin;
```

--------------------------------

### Create OpenVDS with IOManager and Compression Details (Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/python-api

Creates a new VDS handle using an IOManager, layout, axis, channel descriptors, metadata, and specific compression settings. It also includes an error output parameter.

```python
openvds.core.VDS openvds.core.VDS.create(ioManager: openvds.core.IOManager, layoutDescriptor: OpenVDS::VolumeDataLayoutDescriptor, axisDescriptors: list[OpenVDS::VolumeDataAxisDescriptor], channelDescriptors: list[OpenVDS::VolumeDataChannelDescriptor], metadata: OpenVDS::MetadataReadAccess, compressionMethod: OpenVDS::CompressionMethod, compressionTolerance: float, error: OpenVDS::VDSError)
```

--------------------------------

### Wait for Asynchronous Data Request Completion (C++, Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Waits for an asynchronous data request to complete. This is crucial for ensuring that the data in the buffer is ready to be accessed after the request has been made.

```cpp
bool success = request->WaitForCompletion();
```

```python
success = request.waitForCompletion()
```

--------------------------------

### OpenOptions Class

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/file/OpenVDS_8h

Provides options for opening and configuring VDS (Volume Data Store) files, including settings for connection type, wavelet compression, and logging.

```APIDOC
## OpenOptions Class

### Description
Manages configuration options for opening and interacting with VDS files. This includes settings related to connection parameters, wavelet compression behavior, and logging levels.

### Public Members

- **connectionType** (ConnectionType) - Specifies the type of connection to be used for the VDS.

- **waveletAdaptiveMode** (WaveletAdaptiveMode) - Controls how wavelet adaptive compression determines the data loading level. Options include using global or local tolerance, or a specific ratio.
  - *Description*: 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.

- **waveletAdaptiveTolerance** (float) - Tolerance value used for wavelet adaptive compression when the `waveletAdaptiveMode` is set to `Tolerance`.
  - *Description*: Wavelet adaptive tolerance, this setting will be used whenever the WavletAdaptiveMode is set to Tolerance.

- **waveletAdaptiveRatio** (float) - Ratio value used for wavelet adaptive compression when the `waveletAdaptiveMode` is set to `Ratio`. A compression ratio of 5.0 corresponds to compressed data which is 20% of the original.
  - *Description*: Wavelet adaptive ratio, this setting will be used whenever the WaveletAdaptiveMode is set to Ratio. A compression ratio of 5.0 corresponds to compressed data which is 20% of the original.

- **requestThreadCount** (int) - The number of threads to be used for processing requests.
  - *Description*: Number of threads used to process requests.

- **logLevel** (LogLevel) - Sets the level for OpenVDS logging handlers.
  - *Description*: Property to adjust the OpenVDSLogging handlers level.
```

--------------------------------

### Get Bit Mask for Voxel Index (C++)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/namespace/namespaceOpenVDS

Obtains the bit mask for a voxel index, used in conjunction with BitDataIndex functions for 1-bit data manipulation. An example shows its usage with `VoxelIndexToBitDataIndex`.

```C++
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
}
```

--------------------------------

### Create OpenVDS with IOManager, Compression, and Log Level (Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/python-api

Creates a new VDS handle using an IOManager, layout, axis, channel descriptors, metadata, compression method, tolerance, and a specified log level. This overload provides fine-grained control over logging during VDS creation.

```python
openvds.core.VDS openvds.core.VDS.create(ioManager: openvds.core.IOManager, layoutDescriptor: OpenVDS::VolumeDataLayoutDescriptor, axisDescriptors: list[OpenVDS::VolumeDataAxisDescriptor], channelDescriptors: list[OpenVDS::VolumeDataChannelDescriptor], metadata: OpenVDS::MetadataReadAccess, compressionMethod: OpenVDS::CompressionMethod, compressionTolerance: float, logLevel: OpenVDS::LogLevel)
```

--------------------------------

### Get Trace Vertical Offsets Metadata

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/classOpenVDS_1_1KnownMetadata

Retrieves an array of doubles representing the vertical offset for each trace from the start of the Time/Depth/Sample dimension. This is used for precise vertical positioning.

```C++
static MetadataKey TraceVerticalOffsets ();
```

--------------------------------

### Create VDS (with Options and Compression)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/python-api

Creates a new VDS instance using connection options, layout, axis, channel, metadata, compression method, and tolerance.

```APIDOC
## POST /vds/create

### Description
Creates a new VDS instance using connection options, layout descriptor, axis descriptors, channel descriptors, metadata, compression method, and compression tolerance.

### Method
POST

### Endpoint
/vds/create

### Parameters
#### Query Parameters
- **options** (openvds.core.OpenOptions) - Required - The options for the connection.
- **compressionMethod** (OpenVDS::CompressionMethod) - Required - The overall compression method to be used for the VDS.
- **compressionTolerance** (float) - Optional - The compression tolerance [1..255] for wavelet compression.

#### Request Body
- **layoutDescriptor** (OpenVDS::VolumeDataLayoutDescriptor) - Required - Describes the layout of the volume data.
- **axisDescriptors** (list[OpenVDS::VolumeDataAxisDescriptor]) - Required - A list of descriptors for the volume data axes.
- **channelDescriptors** (list[OpenVDS::VolumeDataChannelDescriptor]) - Required - A list of descriptors for the volume data channels.
- **metadata** (OpenVDS::MetadataReadAccess) - Required - Access to read metadata.
- **error** (OpenVDS::VDSError) - Optional - Output parameter for error information.

### Response
#### Success Response (200)
- **vdsHandle** (openvds.core.VDS) - A handle to the created VDS instance.

#### Response Example
{
  "vdsHandle": "<VDS_HANDLE_OBJECT>"
}
```

--------------------------------

### Get Axis Coordinate Minimum - OpenVDS VolumeDataAxisDescriptor

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/VolumeDataAxisDescriptor_8h_source

Retrieves the coordinate value of the first sample along an axis within a VolumeDataAxisDescriptor. This is useful for understanding the starting point of the data along that dimension.

```cpp
float GetCoordinateMin() const;
// Get the coordinate of the first sample of this axis.
```

--------------------------------

### Request Data Subset with Automatic Buffer (C++, Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Requests a subset of volume data where OpenVDS automatically allocates the buffer. Retrieving the data from the request object will block until completion or throw an exception, simplifying buffer management.

```cpp
auto request = accessManager.RequestVolumeSubset<float>(OpenVDS::Dimensions_012, 0, 0, voxelMin, voxelMax);
std::vector<float> data = std::move(request->Data());
```

```python
request = manager.requestVolumeSubset(dimensionsND = openvds.DimensionsND.Dimensions_012, min = voxelMin, max = voxelMax, lod = 0, channel = 0)
data = request.data.reshape(layout.getDimensionNumSamples(crosslineDimension), layout.getDimensionNumSamples(sampleDimension))
```

--------------------------------

### Create VDS (with Options, without Compression)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/python-api

Creates a new VDS instance using connection options, layout, axis, channel, metadata, and error handling.

```APIDOC
## POST /vds/create

### Description
Creates a new VDS instance using connection options, layout descriptor, axis descriptors, channel descriptors, and metadata. This version does not specify compression settings.

### Method
POST

### Endpoint
/vds/create

### Parameters
#### Query Parameters
- **options** (openvds.core.OpenOptions) - Required - The options for the connection.

#### Request Body
- **layoutDescriptor** (OpenVDS::VolumeDataLayoutDescriptor) - Required - Describes the layout of the volume data.
- **axisDescriptors** (list[OpenVDS::VolumeDataAxisDescriptor]) - Required - A list of descriptors for the volume data axes.
- **channelDescriptors** (list[OpenVDS::VolumeDataChannelDescriptor]) - Required - A list of descriptors for the volume data channels.
- **metadata** (OpenVDS::MetadataReadAccess) - Required - Access to read metadata.
- **error** (OpenVDS::VDSError) - Optional - Output parameter for error information.

### Response
#### Success Response (200)
- **vdsHandle** (openvds.core.VDS) - A handle to the created VDS instance.

#### Response Example
{
  "vdsHandle": "<VDS_HANDLE_OBJECT>"
}
```

--------------------------------

### OpenVDS OpenOptions Constructors

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/structOpenVDS_1_1AzureOpenOptions-members

Documentation for the constructors available for the OpenVDS::OpenOptions class, allowing for different initialization configurations.

```APIDOC
## Constructors for OpenVDS::OpenOptions

### Description
Constructors for initializing OpenVDS::OpenOptions with various parameters.

### Methods
#### Constructor 1
- **OpenOptions**(ConnectionType connectionType)
  - Initializes OpenOptions with a specified connection type.

#### Constructor 2
- **OpenOptions**(ConnectionType connectionType, WaveletAdaptiveMode waveletAdaptiveMode, float waveletAdaptiveTolerance, float waveletAdaptiveRatio, LogLevel logLevel)
  - Initializes OpenOptions with detailed connection, wavelet, and logging configurations.
```

--------------------------------

### Access Volume Data Manager and Layout (C++)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Retrieves the VolumeDataAccessManager and VolumeDataLayout from an opened VDSHandle. The access manager is used for data requests, and the layout provides information about the VDS structure. This code follows successful VDS opening.

```cpp
OpenVDS::VolumeDataAccessManager accessManager = OpenVDS::GetAccessManager(handle);
OpenVDS::VolumeDataLayout const *layout = accessManager.GetVolumeDataLayout();
```

--------------------------------

### Get Trace Vertical Offsets Metadata Key

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/class/classOpenVDS_1_1KnownMetadata

Retrieves the metadata key for trace vertical offsets. This key provides an array of doubles representing the offset for each trace from the vertical start position in the VDS's Time/Depth/Sample dimension.

```cpp
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.
```

--------------------------------

### OpenVDS AzurePresignedOpenOptions Constructor and Attributes (C++)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/structOpenVDS_1_1AzurePresignedOpenOptions

Demonstrates the constructor for AzurePresignedOpenOptions, which takes a base URL and URL suffix. It also lists the public attributes: baseUrl, urlSuffix, and inherited options like connectionType, waveletAdaptiveMode, waveletAdaptiveTolerance, waveletAdaptiveRatio, requestThreadCount, and logLevel.

```C++
#include <OpenVDS.h>

// Constructor for AzurePresignedOpenOptions
AzurePresignedOpenOptions::AzurePresignedOpenOptions(const std::string &baseUrl, const std::string &urlSuffix);

// Public Attributes
std::string baseUrl;
std::string urlSuffix;

// Inherited from OpenVDS::OpenOptions
ConnectionType connectionType;
WaveletAdaptiveMode waveletAdaptiveMode;
float waveletAdaptiveTolerance;
float waveletAdaptiveRatio;
int requestThreadCount;
LogLevel logLevel;
```

--------------------------------

### HttpOpenOptions Constructor

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/structOpenVDS_1_1HttpOpenOptions

Constructor for HttpOpenOptions which allows opening a VDS using a plain HTTP URL. This IO backend does not support uploading data. Query parameters in the URL will be appended to sub-URLs.

```cpp
inline OpenVDS::HttpOpenOptions::HttpOpenOptions(std::string const & _url_) : url(_url_) {}

```

--------------------------------

### Request Data Subset with Manual Buffer (C++, Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Requests a subset of volume data, specifying the buffer to store it in and its size. The data is automatically converted to the buffer's type. This method requires manual buffer allocation and size calculation.

```cpp
std::vector<float> buffer(layout->GetDimensionNumSamples(sampleDimension) * layout->GetDimensionNumSamples(crosslineDimension));

auto request = accessManager.RequestVolumeSubset(buffer.data(), buffer.size() * sizeof(float), OpenVDS::Dimensions_012, 0, 0, voxelMin, voxelMax);
```

```python
buffer = np.empty((layout.getDimensionNumSamples(crosslineDimension), layout.getDimensionNumSamples(sampleDimension)))
request = manager.requestVolumeSubset(data_out = buffer, dimensionsND = openvds.DimensionsND.Dimensions_012, min = voxelMin, max = voxelMax, lod = 0, channel = 0)
```

--------------------------------

### Define Voxel Region for Data Request (C++, Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Sets up the minimum and maximum voxel coordinates for a specific data region within the VDS. This involves defining dimensions like sample, crossline, and inline to specify the exact slice to be read.

```cpp
int voxelMin[OpenVDS::Dimensionality_Max] = { 0, 0, 0, 0, 0, 0};
int voxelMax[OpenVDS::Dimensionality_Max] = { 1, 1, 1, 1, 1, 1};

voxelMin[sampleDimension] = 0;
voxelMax[sampleDimension] = layout->GetDimensionNumSamples(sampleDimension);
voxelMin[crosslineDimension] = 0;
voxelMax[crosslineDimension] = layout->GetDimensionNumSamples(crosslineDimension);
voxelMin[inlineDimension] = inlineIndex;
voxelMax[inlineDimension] = inlineIndex + 1;
```

```python
voxelMin = (0, 0, inlineIndex)
voxelMax = (layout.getDimensionNumSamples(sampleDimension), layout.getDimensionNumSamples(crosslineDimension), inlineIndex + 1)
```

--------------------------------

### HttpOpenOptions Constructor and Parameters

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/structOpenVDS_1_1HttpOpenOptions

Details the constructor for HttpOpenOptions and its associated public attributes for configuring HTTP-based VDS access.

```APIDOC
## HttpOpenOptions

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

### Method
Constructor

### Endpoint
N/A (Class Constructor)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Constructor
`HttpOpenOptions(std::string const &url)`

### Public Attributes
- **url** (std::string) - The base URL for accessing the VDS.

### Inherited Attributes from OpenVDS::OpenOptions
- **connectionType** (ConnectionType) - Specifies the type of connection.
- **waveletAdaptiveMode** (WaveletAdaptiveMode) - Controls how wavelet adaptive compression determines data levels. Options include global or local tolerance, or ratio.
- **waveletAdaptiveTolerance** (float) - The tolerance value used when `waveletAdaptiveMode` is set to `Tolerance`.
- **waveletAdaptiveRatio** (float) - The ratio value used when `waveletAdaptiveMode` is set to `Ratio`. A ratio of 5.0 implies compressed data is 20% of the original size.
- **requestThreadCount** (int) - The number of threads to use for processing requests.
- **logLevel** (LogLevel) - Adjusts the level for OpenVDS logging handlers.

### Request Example
```cpp
#include <OpenVDS.h>

// Example usage of the constructor
OpenVDS::HttpOpenOptions httpOptions("http://example.com/vds/data.vds");

// Setting other options (inherited)
httpOptions.requestThreadCount = 4;
httpOptions.waveletAdaptiveMode = OpenVDS::WaveletAdaptiveMode.Tolerance;
httpOptions.waveletAdaptiveTolerance = 0.5f;
```

### Response
#### Success Response (Constructor)
N/A (Constructor does not return a value directly)

#### Response Example
N/A
```

--------------------------------

### OpenVDS Create (Options)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/cpp-important-types-and-functions

Creates a new VDS using provided OpenOptions, layout descriptors, axis descriptors, channel descriptors, metadata, compression method, and compression tolerance.

```APIDOC
## OpenVDS Create (Options)

### Description
Creates a new VDS using provided OpenOptions, layout descriptors, axis descriptors, channel descriptors, metadata, compression method, and compression tolerance.

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

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **options** (OpenOptions) - The options for the connection
- **layoutDescriptor** (VolumeDataLayoutDescriptor) - Descriptor for the volume data layout.
- **axisDescriptors** (array of VolumeDataAxisDescriptor) - Descriptors for the data axes.
- **channelDescriptors** (array of VolumeDataChannelDescriptor) - Descriptors for the data channels.
- **metadata** (MetadataReadAccess) - Read access to metadata.
- **compressionMethod** (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** (float) - 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** (Error) - If an error occurred, the error code and message will be written to this output parameter

### Request Example
```json
{
  "options": { ... },
  "layoutDescriptor": { ... },
  "axisDescriptors": [ { ... } ],
  "channelDescriptors": [ { ... } ],
  "metadata": { ... },
  "compressionMethod": "WAVELET",
  "compressionTolerance": 0.2,
  "error": null
}
```

### Response
#### Success Response (200)
- **VDSHandle** - The VDS handle that can be used to get the VolumeDataLayout and the VolumeDataAccessManager

#### Response Example
```json
{
  "VDSHandle": { ... }
}
```
```

--------------------------------

### Access Volume Data Manager and Layout (Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Retrieves the VolumeDataAccessManager and VolumeDataLayout from an opened VDS object. The manager is used for data operations, and the layout contains structural details of the VDS. This code assumes a VDS object `vds` has been successfully opened.

```python
manager = openvds.getAccessManager(vds)
layout = manager.volumeDataLayout
```

--------------------------------

### DMSOpenOptions Constructor with API Key and Callback (C++)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/structOpenVDS_1_1DMSOpenOptions

This constructor for DMSOpenOptions facilitates opening a dataset using a service discovery URL, API key, dataset path, and a custom authentication provider callback. It includes options for handling single file datasets, specifying a legal tag, and configuring an HTTP proxy.

```cpp
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()
)
```

--------------------------------

### Open VDS Connection and Handle Initialization (C++)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Initializes URL and connection strings, then opens a VDS using the provided credentials and retrieves a VDSHandle. Error handling is included to report issues during the opening process. This function requires OpenVDS library.

```cpp
std::string url = TEST_URL;
std::string connectionString = TEST_CONNECTION;

OpenVDS::Error error;
OpenVDS::VDSHandle handle = OpenVDS::Open(url, connectionString, error);

if(error.code != 0)
{
  std::cerr << "Could not open VDS: " << error.string << std::endl;
  exit(1);
}
```

--------------------------------

### Open VDS Connection and Handle Initialization (Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Initializes URL and connection strings, then opens a VDS using the provided credentials within a context manager. It demonstrates basic error handling for connection issues. This function requires the 'openvds' Python package.

```python
url = TEST_URL
connectionString = TEST_CONNECTION

try:
    with openvds.open(url, connectionString) as vds:
        .
        .
        .
except RuntimeError as error:
    print(f"Could not open VDS: {error}")
```

--------------------------------

### AzurePresignedOpenOptions Constructor

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/namespace/namespaceOpenVDS

Constructor for AzurePresignedOpenOptions. Initializes VDS opening options with a base URL and a suffix for presigned URLs.

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

--------------------------------

### OpenVDS GoogleOpenOptions Constructors

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/structOpenVDS_1_1GoogleOpenOptions-members

These constructors are used to initialize OpenVDS::GoogleOpenOptions objects, which configure access to data stored in Google Cloud. They allow specification of the bucket, path prefix, and different methods for providing credentials such as tokens or paths.

```cpp
inline OpenVDS::GoogleOpenOptions()
inline OpenVDS::GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix)
inline OpenVDS::GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix, OpenVDS::GoogleCredentialsToken const &credentials)
inline OpenVDS::GoogleOpenOptions(std::string const &bucket, std::string const &pathPrefix, OpenVDS::GoogleCredentialsPath const &credentials)
```

--------------------------------

### Transform Inline Coordinate to Index (Python)

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/getting-started

Determines the middle inline number within the VDS and converts it to a sample index using the VolumeDataLayout. This illustrates accessing axis descriptors to obtain coordinate ranges and perform coordinate-to-index transformations. Requires a valid VolumeDataLayout object.

```python
sampleDimension, crosslineDimension, inlineDimension = (0, 1, 2)
inlineAxis = layout.getAxisDescriptor(inlineDimension)
inlineNumber = (inlineAxis.coordinateMin + inlineAxis.coordinateMax) // 2
inlineIndex = inlineAxis.coordinateToSampleIndex(inlineNumber)
```

--------------------------------

### Open with Options

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/namespace/namespaceOpenVDS

Opens an existing VDS using specified options.

```APIDOC
## POST /vds/openWithOptions

### Description
Opens an existing VDS using specified options.

### Method
POST

### Endpoint
/vds/openWithOptions

### Parameters
#### Request Body
- **options** (object) - Required - The options for the connection.
  - **url** (string) - Required - The URL scheme specific to each cloud provider.
  - **connectionString** (string) - Optional - The cloud provider specific connection string.
  - ... (other options as defined by OpenOptions)
- **error** (object) - Output parameter - If an error occurred, this will contain the error code and message.

### Request Example
```json
{
  "options": {
    "url": "azure://your-container/your-vds.vds",
    "connectionString": "<your-connection-string>",
    "someOtherOption": "value"
  }
}
```

### Response
#### Success Response (200)
- **vdsHandle** (object) - A handle to the VDS that can be used to get the VolumeDataLayout and VolumeDataAccessManager.

#### Response Example
```json
{
  "vdsHandle": {
    "handleId": "<generated-handle-id>"
  }
}
```
```

--------------------------------

### C++ VDSFileOpenOptions Constructor Examples

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/struct/structOpenVDS_1_1VDSFileOpenOptions

Demonstrates the usage of constructors for the OpenVDS::VDSFileOpenOptions struct in C++. The default constructor initializes options, while the parameterized constructor takes a file name.

```c++
inline VDSFileOpenOptions() {}

inline VDSFileOpenOptions(const std::string &fileName) {
    this->fileName = fileName;
}
```

--------------------------------

### VolumeDataLayout JSON Object Example

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/vds/specification/Examples

An example of a VolumeDataLayout JSON object, detailing axis descriptors, channel descriptors, layout descriptor, and metadata. This structure is fundamental for defining seismic data organization within the VDS.

```json
{
  "axisDescriptors": [
    {
      "coordinateMax": 4500.0,
      "coordinateMin": 0.0,
      "name": "Sample",
      "numSamples": 1126,
      "unit": "ms"
    },
    {
      "coordinateMax": 2536.0,
      "coordinateMin": 1932.0,
      "name": "Crossline",
      "numSamples": 605,
      "unit": "unitless"
    },
    {
      "coordinateMax": 10369.0,
      "coordinateMin": 9985.0,
      "name": "Inline",
      "numSamples": 385,
      "unit": "unitless"
    }
  ],
  "channelDescriptors": [
    {
      "allowLossyCompression": true,
      "channelMapping": "Direct",
      "components": "Components_1",
      "discrete": false,
      "format": "Format_R32",
      "integerOffset": 0.0,
      "integerScale": 1.0,
      "mappedValues": 0,
      "name": "Amplitude",
      "noValue": 0.0,
      "renderable": true,
      "unit": "unitless",
      "useNoValue": false,
      "valueRange": [
        -0.07938297837972641,
        0.07938297837972641
      ]
    },
    {
      "allowLossyCompression": false,
      "channelMapping": "PerTrace",
      "components": "Components_1",
      "discrete": false,
      "format": "Format_U8",
      "integerOffset": 0.0,
      "integerScale": 1.0,
      "mappedValues": 1,
      "name": "Trace",
      "noValue": 0.0,
      "renderable": true,
      "unit": "",
      "useNoValue": false,
      "valueRange": [
        0.0,
        256.0
      ]
    },
    {
      "allowLossyCompression": false,
      "channelMapping": "PerTrace",
      "components": "Components_1",
      "discrete": false,
      "format": "Format_U8",
      "integerOffset": 0.0,
      "integerScale": 1.0,
      "mappedValues": 240,
      "name": "SEGYTraceHeader",
      "noValue": 0.0,
      "renderable": true,
      "unit": "",
      "useNoValue": false,
      "valueRange": [
        0.0,
        256.0
      ]
    }
  ],
  "layoutDescriptor": {
    "brickSize": "BrickSize_128",
    "brickSize2DMultiplier": 4,
    "create2DLODs": true,
    "forceFullResolutionDimension": false,
    "fullResolutionDimension": -1,
    "lodLevels": "LODLevels_2",
    "negativeMargin": 4,
    "positiveMargin": 4
  },
  "metadata": [
    {
      "category": "SurveyCoordinateSystem",
      "name": "CRSWkt",
      "type": "String",
      "value": "PROJCS[\"ED50 / UTM zone 31N\",..."
    },
    {
      "category": "SurveyCoordinateSystem",
      "name": "Origin",
      "type": "DoubleVector2",
      "value": [
        431953.90416783805,
        6348552.886477016
      ]
    },
    {
      "category": "SurveyCoordinateSystem",
      "name": "InlineSpacing",
      "type": "DoubleVector2",
      "value": [
        3.0251294794220853,
        12.129908201355414
      ]
    },
    {
      "category": "SurveyCoordinateSystem",
      "name": "CrosslineSpacing",
      "type": "DoubleVector2",
      "value": [
        -12.128725165562914,
        3.024834437086093
      ]
    },
    {
      "category": "",
      "name": "SEGYTextHeader",
      "type": "BLOB",
      "value": "QyAxIENMSU...CA="
    },
    {
      "category": "SurveyCoordinateSystem",
      "name": "OriginalOrigin",
      "type": "DoubleVector2",
      "value": [
        431953.90416783805,
        6348552.886477016
      ]
    },
    {
      "category": "SurveyCoordinateSystem",
      "name": "OriginalInlineSpacing",
      "type": "DoubleVector2",
      "value": [
        3.0251294794220853,
        12.129908201355414
      ]
    },
    {
      "category": "SurveyCoordinateSystem",
      "name": "OriginalCrosslineSpacing",
      "type": "DoubleVector2",
      "value": [
        -12.128725165562914,
        3.024834437086093
      ]
    },
    {
      "category": "SurveyCoordinateSystem",
      "name": "Unit",
      "type": "String",
      "value": "m"
    }
  ]
}
```

--------------------------------

### Construct OpenVDS VolumeDataChannelDescriptor in C++

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/classOpenVDS_1_1VolumeDataChannelDescriptor-members

This snippet demonstrates various ways to construct an OpenVDS::VolumeDataChannelDescriptor. Constructors are provided for different configurations, including specifying format, components, name, unit, value range, mapping, flags, mapped value count, no-value, integer scale, and integer offset. Some are static trace methods.

```C++
OpenVDS::VolumeDataChannelDescriptor::VolumeDataChannelDescriptor();
OpenVDS::VolumeDataChannelDescriptor::VolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax);
OpenVDS::VolumeDataChannelDescriptor::VolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, OpenVDS::VolumeDataMapping mapping);
OpenVDS::VolumeDataChannelDescriptor::VolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, enum OpenVDS::Flags flags);
OpenVDS::VolumeDataChannelDescriptor::VolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, OpenVDS::VolumeDataMapping mapping, enum OpenVDS::Flags flags);
OpenVDS::VolumeDataChannelDescriptor::VolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, OpenVDS::VolumeDataMapping mapping, int mappedValueCount, enum OpenVDS::Flags flags, float integerScale, float integerOffset);
OpenVDS::VolumeDataChannelDescriptor::VolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, float noValue);
OpenVDS::VolumeDataChannelDescriptor::VolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, float noValue, OpenVDS::VolumeDataMapping mapping, enum OpenVDS::Flags flags);
OpenVDS::VolumeDataChannelDescriptor::VolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, OpenVDS::VolumeDataMapping mapping, int mappedValueCount, enum OpenVDS::Flags flags, float noValue, float integerScale, float integerOffset);
static OpenVDS::VolumeDataChannelDescriptor OpenVDS::VolumeDataChannelDescriptor::TraceMappedVolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, int mappedValueCount, enum OpenVDS::Flags flags);
static OpenVDS::VolumeDataChannelDescriptor OpenVDS::VolumeDataChannelDescriptor::TraceMappedVolumeDataChannelDescriptor(OpenVDS::Format format, OpenVDS::Components components, const char *name, const char *unit, float valueRangeMin, float valueRangeMax, int mappedValueCount, enum OpenVDS::Flags flags, float noValue);
```

--------------------------------

### OpenVDS Functions Starting with 'v'

Source: https://osdu.pages.opengroup.org/platform/domain-data-mgmt-services/seismic/open-vds/cppdoc/doxygen/functions_func_v

This section lists documented functions within the OpenVDS library that start with the letter 'v', detailing their purpose and return types.

```APIDOC
## Functions

### ValidateRequest()

- **Description**: Validates a request for volume data.
- **Method**: (Not specified, likely internal or part of a class)
- **Endpoint**: N/A
- **Returns**: `OpenVDS::VolumeDataRequest`

### VDSCoordinateTransformerBase()

- **Description**: Constructor for the VDSCoordinateTransformerBase class.
- **Method**: (Not specified, likely constructor)
- **Endpoint**: N/A
- **Template Parameters**: `<N>`

### VDSFileOpenOptions()

- **Description**: Constructor for VDSFileOpenOptions.
- **Method**: (Not specified, likely constructor)
- **Endpoint**: N/A

### VolumeDataAxisDescriptor()

- **Description**: Constructor for VolumeDataAxisDescriptor.
- **Method**: (Not specified, likely constructor)
- **Endpoint**: N/A

### VolumeDataChannelDescriptor()

- **Description**: Constructor for VolumeDataChannelDescriptor.
- **Method**: (Not specified, likely constructor)
- **Endpoint**: N/A

### VolumeSampler()

- **Description**: Constructor for the VolumeSampler class.
- **Method**: (Not specified, likely constructor)
- **Endpoint**: N/A
- **Template Parameters**: `<T, INTERPMETHOD, ISUSENOVALUE>`

### VoxelIndexFloatToCoordinate()

- **Description**: Converts a floating-point voxel index to a coordinate.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexInProcessArea()

- **Description**: Checks if a voxel index is within the process area.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexToAnnotation()

- **Description**: Converts a voxel index to annotation data.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Interface**: `OpenVDS::IJKCoordinateTransformer`

### VoxelIndexToBitDataIndex()

- **Description**: Converts a voxel index to a bit data index.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexToCoordinate()

- **Description**: Converts a voxel index to world coordinates.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexToDataIndex()

- **Description**: Converts a voxel index to a data index.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexToIJKIndex()

- **Description**: Converts a voxel index to an IJK index.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Interface**: `OpenVDS::IJKCoordinateTransformer`

### VoxelIndexToLocalChunkIndex()

- **Description**: Converts a voxel index to a local chunk index.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexToLocalIndex()

- **Description**: Converts a voxel index to a local index.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexToLocalIndexFloat()

- **Description**: Converts a voxel index to a floating-point local index.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexToRelativeAxisPosition()

- **Description**: Converts a voxel index to a relative axis position.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexToVolumeSamplerLocalIndex()

- **Description**: Converts a voxel index to a VolumeSampler local index.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Class**: `OpenVDS::VolumeIndexerBase< N >`

### VoxelIndexToWorld()

- **Description**: Converts a voxel index to world space.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Interface**: `OpenVDS::IJKCoordinateTransformer`

### VoxelIndexToWorldCoordinates()

- **Description**: Converts a voxel index to world coordinates.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Base Classes**: `OpenVDS::VDSCoordinateTransformerBase< N >`, `OpenVDS::VolumeIndexerBase< N >`

### VoxelPositionToAnnotation()

- **Description**: Converts a voxel position to annotation data.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Interface**: `OpenVDS::IJKCoordinateTransformer`

### VoxelPositionToIJKPosition()

- **Description**: Converts a voxel position to an IJK position.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Interface**: `OpenVDS::IJKCoordinateTransformer`

### VoxelPositionToWorld()

- **Description**: Converts a voxel position to world space.
- **Method**: (Not specified, likely part of a class)
- **Endpoint**: N/A
- **Interface**: `OpenVDS::IJKCoordinateTransformer`
```