OpenVDB: nanovdb::io Namespace Reference

OpenVDB 11.0.0

Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions
nanovdb::io Namespace Reference

## Namespaces
namespace | Internal
| Internal functions for compressed read/write of a NanoVDB GridHandle into a stream.

## Classes
struct | FileGridMetaData
| This class defines the meta data stored for each grid in a segment. More...
struct | FileHeader
| Data encoded at the head of each segment of a file or stream. More...
struct | FileMetaData
struct | Segment
| This class defines all the data stored in segment of a file. More...

## Typedefs
using | fileSize_t = uint64_t

## Enumerations
enum class | Codec : uint16_t { NONE = 0 , ZIP = 1 , BLOSC = 2 , END = 3 }
| Define compression codecs. More...

## Functions
const char * | toStr (Codec codec)
template<typename StreamT >
void | writeUncompressedGrid (StreamT &os, const GridData *gridData, bool raw=false)
| This is a standalone alternative to io::writeGrid(...,Codec::NONE) defined in util/IO.h Unlike the latter this function has no dependencies at all, not even NanoVDB.h, so it also works if client code only includes PNanoVDB.h!
template<typename GridHandleT , template< typename... > class VecT>
void | writeUncompressedGrids (const char *fileName, const VecT< GridHandleT > &handles, bool raw=false)
| write multiple NanoVDB grids to a single file, without compression.
template<typename GridHandleT , typename StreamT , template< typename... > class VecT>
VecT< GridHandleT > | readUncompressedGrids (StreamT &is, const typename GridHandleT::BufferType &pool=typename GridHandleT::BufferType())
| read all uncompressed grids from a stream and return their handles.
template<typename GridHandleT , template< typename... > class VecT>
VecT< GridHandleT > | readUncompressedGrids (const char *fileName, const typename GridHandleT::BufferType &buffer=typename GridHandleT::BufferType())
| Read a multiple un-compressed NanoVDB grids from a file and return them as a vector.
template<typename BufferT >
void | writeGrid (const std::string &fileName, const GridHandle< BufferT > &handle, io::Codec codec=io::Codec::NONE, int verbose=0)
| Write a single grid to file (over-writing existing content of the file)
template<typename BufferT = HostBuffer, template< typename... > class VecT = std::vector>
void | writeGrids (const std::string &fileName, const VecT< GridHandle< BufferT > > &handles, Codec codec=Codec::NONE, int verbose=0)
| Write multiple grids to file (over-writing existing content of the file)
template<typename BufferT = HostBuffer>
GridHandle< BufferT > | readGrid (const std::string &fileName, int n=0, int verbose=0, const BufferT &buffer=BufferT())
| Read and return one or all grids from a file into a single GridHandle.
template<typename BufferT = HostBuffer>
GridHandle< BufferT > | readGrid (const std::string &fileName, const std::string &gridName, int verbose=0, const BufferT &buffer=BufferT())
| Read and return the first grid with a specific name from a file.
template<typename BufferT = HostBuffer, template< typename... > class VecT = std::vector>
VecT< GridHandle< BufferT > > | readGrids (const std::string &fileName, int verbose=0, const BufferT &buffer=BufferT())
| Read all the grids in the file and return them as a vector of multiple GridHandles, each containing all grids encoded in the same segment of the file (i.e. they where written together)
uint64_t | stringHash (const char *cstr)
| Standard hash function to use on strings; std::hash may vary by platform/implementation and is know to produce frequent collisions.
uint64_t | stringHash (const std::string &str)
| Return a uint64_t hash key of a std::string.
uint64_t | reverseEndianness (uint64_t val)
| Return a uint64_t with its bytes reversed so we can check for endianness.
bool | hasGrid (const std::string &fileName, const std::string &gridName)
| Return true if the file contains a grid with the specified name.
bool | hasGrid (std::istream &is, const std::string &gridName)
| Return true if the stream contains a grid with the specified name.
std::vector< FileGridMetaData > | readGridMetaData (const std::string &fileName)
| Reads and returns a vector of meta data for all the grids found in the specified file.
std::vector< FileGridMetaData > | readGridMetaData (std::istream &is)
| Reads and returns a vector of meta data for all the grids found in the specified stream.
template<typename BufferT >
void | writeGrid (std::ostream &os, const GridHandle< BufferT > &handle, Codec codec)
template<typename BufferT = HostBuffer, template< typename... > class VecT = std::vector>
void | writeGrids (std::ostream &os, const VecT< GridHandle< BufferT > > &handles, Codec codec=Codec::NONE)
template<typename BufferT >
GridHandle< BufferT > | readGrid (std::istream &is, int n, const BufferT &pool)
template<typename BufferT >
GridHandle< BufferT > | readGrid (std::istream &is, const std::string &gridName, const BufferT &pool)
| Read a specific grid from an input stream given the name of the grid.
template<typename BufferT = HostBuffer, template< typename... > class VecT = std::vector>
VecT< GridHandle< BufferT > > | readGrids (std::istream &is, const BufferT &pool=BufferT())

## Typedef Documentation

## ◆ fileSize_t

using fileSize_t = uint64_t

We fix a specific size for counting bytes in files so that they are saved the same regardless of machine precision. (Note there are still little/bigendian issues, however)

## Enumeration Type Documentation

## ◆ Codec

enum class Codec : uint16_t
| strong

Define compression codecs.

Note
  NONE is the default, ZIP is slow but compact and BLOSC offers a great balance.

Exceptions

  NanoVDB | optionally supports ZIP and BLOSC compression and will throw an exception if its support is required but missing.

Enumerator
NONE |
ZIP |
BLOSC |
END |

## Function Documentation

## ◆ hasGrid() [1/2]

bool hasGrid | ( | const std::string & | fileName,
|  | const std::string & | gridName
| ) |  |
| inline

Return true if the file contains a grid with the specified name.

## ◆ hasGrid() [2/2]

bool hasGrid | ( | std::istream & | is,
|  | const std::string & | gridName
| ) |  |
| inline

Return true if the stream contains a grid with the specified name.

## ◆ readGrid() [1/4]

template<typename BufferT = HostBuffer>

GridHandle< BufferT > readGrid | ( | const std::string & | fileName,
|  | const std::string & | gridName,
|  | int | verbose = `0`,
|  | const BufferT & | buffer = `BufferT()`
| ) |  |

Read and return the first grid with a specific name from a file.

Read the first grid with a specific name.

Template Parameters

  BufferT | Type of buffer used memory allocation

Parameters

  fileName | string name of file to be read from
  gridName | string name of the grid to be read
  verbose | specify verbosity level. Default value of zero means quiet.
  buffer | optional buffer used for memory allocation

Returns
  return a single GridHandle containing the grid with the specific name

Exceptions

  will | throw a std::runtime_error if the file does not contain a grid with the specific name

## ◆ readGrid() [2/4]

template<typename BufferT = HostBuffer>

GridHandle< BufferT > readGrid | ( | const std::string & | fileName,
|  | int | n = `0`,
|  | int | verbose = `0`,
|  | const BufferT & | buffer = `BufferT()`
| ) |  |

Read and return one or all grids from a file into a single GridHandle.

Read the n'th grid.

Template Parameters

  BufferT | Type of buffer used memory allocation

Parameters

  fileName | string name of file to be read from
  n | zero-based signed index of the grid to be read. The default value of 0 means read only first grid. A negative value of n means read all grids in the file.
  verbose | specify verbosity level. Default value of zero means quiet.
  buffer | optional buffer used for memory allocation

Returns
  return a single GridHandle with one or all grids found in the file

Exceptions

  will | throw a std::runtime_error if the file does not contain a grid with index n

## ◆ readGrid() [3/4]

template<typename BufferT >

GridHandle< BufferT > readGrid | ( | std::istream & | is,
|  | const std::string & | gridName,
|  | const BufferT & | pool
| ) |  |

Read a specific grid from an input stream given the name of the grid.

Template Parameters

  BufferT | Buffer type used for allocation

Parameters

  is | input stream from which to read the grid
  gridName | string name of the (first) grid to be returned
  pool | optional memory pool from which to allocate the grid buffer

Returns
  Return the first grid in the input stream with a specific name

Exceptions

  std::runtime_error | with no grid exists with the specified name

## ◆ readGrid() [4/4]

template<typename BufferT >

GridHandle< BufferT > readGrid | ( | std::istream & | is,
|  | int | n,
|  | const BufferT & | pool
| ) |  |

## ◆ readGridMetaData() [1/2]

std::vector< FileGridMetaData > readGridMetaData | ( | const std::string & | fileName | ) |
| inline

Reads and returns a vector of meta data for all the grids found in the specified file.

## ◆ readGridMetaData() [2/2]

std::vector< FileGridMetaData > readGridMetaData | ( | std::istream & | is | ) |
| inline

Reads and returns a vector of meta data for all the grids found in the specified stream.

## ◆ readGrids() [1/2]

template<typename BufferT = HostBuffer, template< typename... > class VecT = std::vector>

VecT< GridHandle< BufferT > > readGrids | ( | const std::string & | fileName,
|  | int | verbose = `0`,
|  | const BufferT & | buffer = `BufferT()`
| ) |  |

Read all the grids in the file and return them as a vector of multiple GridHandles, each containing all grids encoded in the same segment of the file (i.e. they where written together)

Read all the grids.

Template Parameters

  BufferT | Type of buffer used memory allocation

Parameters

  fileName | string name of file to be read from
  verbose | specify verbosity level. Default value of zero means quiet.
  buffer | optional buffer used for memory allocation

Returns
  Return a vector of GridHandles each containing all grids encoded in the same segment of the file (i.e. they where written together).

## ◆ readGrids() [2/2]

template<typename BufferT = HostBuffer, template< typename... > class VecT = std::vector>

VecT< GridHandle< BufferT > > readGrids | ( | std::istream & | is,
|  | const BufferT & | pool = `BufferT()`
| ) |  |

## ◆ readUncompressedGrids() [1/2]

template<typename GridHandleT , template< typename... > class VecT>

VecT< GridHandleT > readUncompressedGrids | ( | const char * | fileName,
|  | const typename GridHandleT::BufferType & | buffer = `typename GridHandleT::BufferType()`
| ) |  |

Read a multiple un-compressed NanoVDB grids from a file and return them as a vector.

## ◆ readUncompressedGrids() [2/2]

template<typename GridHandleT , typename StreamT , template< typename... > class VecT>

VecT< GridHandleT > readUncompressedGrids | ( | StreamT & | is,
|  | const typename GridHandleT::BufferType & | pool = `typename GridHandleT::BufferType()`
| ) |  |

read all uncompressed grids from a stream and return their handles.

Exceptions

  std::invalid_argument | if stream does not contain a single uncompressed valid NanoVDB grid

StreamT class must support: "bool read(char*, size_t)" and "void skip(uint32_t)"

## ◆ reverseEndianness()

uint64_t reverseEndianness | ( | uint64_t | val | ) |
| inline

Return a uint64_t with its bytes reversed so we can check for endianness.

## ◆ stringHash() [1/2]

uint64_t stringHash | ( | const char * | cstr | ) |
| inline

Standard hash function to use on strings; std::hash may vary by platform/implementation and is know to produce frequent collisions.

## ◆ stringHash() [2/2]

uint64_t stringHash | ( | const std::string & | str | ) |
| inline

Return a uint64_t hash key of a std::string.

## ◆ toStr()

const char * toStr | ( | Codec | codec | ) |
| inline

## ◆ writeGrid() [1/2]

template<typename BufferT >

void writeGrid | ( | const std::string & | fileName,
|  | const GridHandle< BufferT > & | handle,
|  | io::Codec | codec = `io::Codec::NONE`,
|  | int | verbose = `0`
| ) |  |

Write a single grid to file (over-writing existing content of the file)

## ◆ writeGrid() [2/2]

template<typename BufferT >

void writeGrid | ( | std::ostream & | os,
|  | const GridHandle< BufferT > & | handle,
|  | Codec | codec
| ) |  |

## ◆ writeGrids() [1/2]

template<typename BufferT = HostBuffer, template< typename... > class VecT = std::vector>

void writeGrids | ( | const std::string & | fileName,
|  | const VecT< GridHandle< BufferT > > & | handles,
|  | Codec | codec = `Codec::NONE`,
|  | int | verbose = `0`
| ) |  |

Write multiple grids to file (over-writing existing content of the file)

## ◆ writeGrids() [2/2]

template<typename BufferT = HostBuffer, template< typename... > class VecT = std::vector>

void writeGrids | ( | std::ostream & | os,
|  | const VecT< GridHandle< BufferT > > & | handles,
|  | Codec | codec = `Codec::NONE`
| ) |  |

## ◆ writeUncompressedGrid()

template<typename StreamT >

void writeUncompressedGrid | ( | StreamT & | os,
|  | const GridData * | gridData,
|  | bool | raw = `false`
| ) |  |

This is a standalone alternative to io::writeGrid(...,Codec::NONE) defined in util/IO.h Unlike the latter this function has no dependencies at all, not even NanoVDB.h, so it also works if client code only includes PNanoVDB.h!

Writes a raw NanoVDB buffer, possibly with multiple grids, to a stream WITHOUT compression. It follows all the conventions in util/IO.h so the stream can be read by all existing client code of NanoVDB.

Note
  This method will always write uncompressed grids to the stream, i.e. Blosc or ZIP compression is never applied! This is a fundamental limitation and feature of this standalone function.

Exceptions

  std::invalid_argument | if buffer does not point to a valid NanoVDB grid.

Warning
  This is pretty ugly code that involves lots of pointer and bit manipulations - not for the faint of heart :)

## ◆ writeUncompressedGrids()

template<typename GridHandleT , template< typename... > class VecT>

void writeUncompressedGrids | ( | const char * | fileName,
|  | const VecT< GridHandleT > & | handles,
|  | bool | raw = `false`
| ) |  |

write multiple NanoVDB grids to a single file, without compression.

Note
  To write all grids in a single GridHandle simply use handle.write("fieNane")