OpenVDB Version History
=======================

Version 13.0.0 - November 3, 2025

      This version introduces ABI changes relative to older major releases,
      so to preserve ABI compatibility it might be necessary to define the
      macro OPENVDB_ABI_VERSION_NUMBER=N, where, for example, N is 11 for
      Houdini 20.5 and 12 for Houdini 21.0.

      Support for reading .vdb files written prior to VDB 1.0 has been removed.
      To read older .vdb files, please use VDB 12.x or older and re-write them,
      so that they use the newer file format and can be read in VDB 13+.

  Highlights:
  - OpenVDB now includes in-memory support for Half Grids and the file format
    has been extended to add I/O serialization for half grids. More work is
    planned on adapting algorithms when using Half Grids for better performance
    and improved precision.
  - NanoVDB is no longer limited to static applications, such as rendering, but
    can increasingly be applied to problems that involve dynamic topology, such
    as level set tracking, grid building, morphology operations and merging of
    grids. This is due to the fact that we keep adding more and more tools to
    NanoVDB that facilitates tree modification. However, unlike OpenVDB, these
    operations generate new NanoVDB grids (as oppose to in-palace modifications
    in OpenVDB), yet are typically much faster since they are performed on the
    GPU. Many of these exciting new features are the foundation of fVDB.

  OpenVDB:
    New features:
    - Added native registration of HalfGrid type.
    - Added customization of the output transformation attribute for
      points::pca(). Can be output as a quaternion or as a combined affine
      transform with the scale/stretch ommitted.
    - Added support for input quaternions attributes and affine
      transformations (that include scale) in points::rasterizeSdf() for
      ellipsoidal rasterizations.

    API Changes:
    - Added LeafBuffer::storage() for direct const access to the raw data
      buffer when using the bool LeafNode.
    - Removed Grid::evalMinMax(), use tools::minMax for superior threaded
      performance.
    - Removed points::rasterize() that took a custom filter and interrupter.
    - Removed LeafNode<bool, ...>() TopologyCopy constructor in favor of using
      explicit mask/buffer constructors.
    - Removed ValueAccessor NodeT0, NodeT1, NodeT2 aliases, use NodeTypeAtLevel
      instead.
    - Add InternalNode::setValueMaskUnsafe() to write a value mask directly.
    - LegacyFrustum and RootNodeMask have been removed. These classes were only
      used for reading old .vdb files, which is no longer supported.
    - io::writeCompressedValues() now takes a const ValueT* source buffer for
      improved const-correctness.

    Bug Fixes:
    - Fix a bug in the LevelSetRayIntersector class where two of the methods
      were incorrectly adjusting the time even when an intersection was not
      found.
    - Fixed an assertion in math::Quat where a vector length check was using
      too small a tolerance.
    - Fixed a bug in the unit tests where detecting if assertions were enabled
      was using NDEBUG rather than OpenVDB assertions.

    Build:
    - Removed the unnecessary USE_NUMPY build option for the OpenVDB Python
      module. All functions which take numpy arrays are now always generated
      (numpy is not required at compile time for this support).
    - Bumped minimum supported CMake version to 3.24, and new future minimum
      to 4.0.0.
    - Bumped minimum supported OpenEXR and Imath versions to 3.2, and new
      future minimum to 3.3.
    - Bumped minimum supported Boost version to 1.82, and new future minimum
      to 1.85.
    - Bumped minimum supported Python version to 3.11
    - Bumped minimum supported Log4cplus version to 2.0
    - Bumped minimum supported Houdini version to 20.5
    - Bumped minimum supported GLFW version to 3.3
    - Bumped future minimum for TBB to 2021 (oneapi).
    - Bumped future minimum for nanobind to 2.5.0.

  OpenVDB AX:
    New:
    - Added support for LLVM 21.

  NanoVDB:
    Highlights:
    - NanoVDB is no longer limited to static applications, such as rendering,
      but can increasingly be applied to problems that involve dynamic
      topology, such as level set tracking, grid building, morphology
      operations and merging of grids. This is due to the fact that we keep
      adding more and more tools to NanoVDB that facilitates tree modification.
      However, unlike OpenVDB, these operations generate new NanoVDB grids (as
      oppose to in-palace modifications in OpenVDB), yet are typically much
      faster since they are performed on the GPU. Many of these exciting new
      features are the foundation of fVDB.

    New features:
    - Added nanovdb/tools/cuda/DilateGrid.cuh, which performs topology dilation
      on the GPU.
    - Added nanovdb/tools/cuda/MergeGrids.cuh, which merges the topology of two
      grids on the GPU.
    - Added nanovdb/tools/cuda/CoarsenGrid.cuh, which performs topological
      coarsening of grids on the GPU.
    - Added nanovdb/tools/cuda/RefineGrid.cuh, which performs topological
      refinement of grids on the GPU.
    - Added nanovdb/tools/cuda/PruneGrid.cuh, which prunes the topology of a
      grid using a sidecar mask on the GPU.
    - Added nanovdb/util/cuda/Injection.cuh, which facilitates sidecar data
      copying - on the GPU - in the overlap of two grids with different
      topology.
    - Added Mat classes and other math types to NanoVDB.
    - Major rewrite of nanovdb::NanoToOpenVDB, which now allows
      nanovdb::IndexGrids and blind (or sidecar) data to be converted into an
      openvdb grid.
    - Added support for LevelSet, FogVolume, and Staggered grid semantics.
      Added toGridClass and toSemantic to map Grid Blind data semantic to Grid
      class and vice versa.

    Improvements:
    - Improvements to mGPU grid building and introduction of a separate test
      executable for mGPU tests
    - Added stand-alone function nanovdb::writeUncompressedGrid that allows
      nanovdb::IndexGrids and blind (or sidecar) data to be written directly to
      a stream.
    - nanovdb_print now (optionally) prints the blind data count per grid.
    - Extended nanovdb::GridBlindDataSemantic with nanovdb::GridClass types to
      support conversion between IndexGrid and regular grids.
    - Improvements and bugfixes to PNanoVDB.

    API Changes:
    - Removed nanovdb::ValueIndexMask and nanovdb::ValueOnIndexMask since they
      are no longer used by fVDB (or elsewhere).
    - NanoVDB version is now 32.9.0, so the ABI of the grid is preserved but
      not the API. However, the API changes are very minor!

    Bug Fixes:
    - Several fixes for compiler warnings.
    - Fixed error in nanovdb/io/IO.h related to missing throws.

  Houdini:
  - Remove support for openvdb_houdini::Interrupter, use
    openvdb_houdini::HoudiniInterrupter instead.
  - Remove input-stealing via duplicateSourceStealable(), SideFX have since
    introduced verbification and compiled SOPs to provide zero-copy node
    evaluation.


Version 12.1.1 - September 30, 2025

  OpenVDB AX:
    Fixes:
    - Fixed an issue which was causing host specific optimization passes to be
      omitted when using LLVM 16 and higher.

  Houdini:
    - Fixed a compilation issue with the OpenVDB Activate SOP with Houdini 21
    [Reported by @callen128]


Version 12.1.0 - August 8, 2025

  OpenVDB:
    New features:
    - New level set constructor tools::createLevelSetCapsule creates a grid
      containing a narrow-band level set representation of a capsule (tube
      with constant radius and sphere caps).
    - New level set constructor tools::createLevelSetTaperedCapsule creates a
      grid containing a narrow-band level set representation of a tapered
      capsule (tube with sphere caps and different radii at both ends, or
      equivalently the convex hull of two spheres with possibly different
      centers and radii).
    - New level set constructor tools::createLevelSetTubeComplex creates a grid
      containing a narrow-band level set representation of a tube complex (a
      collection of capsules or tapered capsules defined by endpoint coordinates
      and segment indices).
    - New level set constructor tools::createLevelSetDilatedMesh creates a grid
      containing a narrow-band level set representation of a dilated surface
      mesh (dilated by a radius in all directions).
    - New class tools::ConvexVoxelizer, used by the above methods, which can be
      inherited to implement a convex level set constructor.
    - Introduced anisotropic surfacing tools in points/PointRasterizeSDF.h and
      principal component analysis (PCA) methods in points/PrincipalComponentAnalysis.h.
      The latter tool analyses point neighborhoods and computes affine
      transformations representing elliptical distributions. The prior tool
      takes rotational and stretch point attributes (optionally computed from
      the prior PCA methods) and generates anisotropic surfaces.

    Improvements:
    - Significantly improved the performance of all LeafNode ValueIterators,
      up to 5x on some platforms and up to 10x when delay loading is enabled.
      Construction of a ValueIterator from a leaf node now requests the leaf
      buffers ahead of iteration to avoid potentially expensive API calls.
    - Improved the performance of PointRasterizeSDF.h tools with larger radii
      with better bound computation approximations.
    - Significant performance improvement to delay loaded files - the warning
      logic which checks the underlying mapped file for the last modified time
      has been removed, resulting in performance gains upwards of 10x when
      loading in node data buffers. Note that the check that was removed is
      entirely redundant on Windows and would only print a warning on other
      system.
      [Contributed by jjtParadox]
    - Added OPENVDB_HAS_INVOKABLE_MEMBER_FUNCTION and OPENVDB_HAS_MEMBER_FUNCTION
      macros to help determine the presence and compatibility of interface
      member functions at compile time.
    - Added OPENVDB_ASSUME macros to mimic builtin assume and C++23 assume
      attributes.
    - Improved read and write of PLY files with vdb_tool so they support Vec3d
      and 64 bit attributes. Changed vdb_tool version number from 10.6.1 to
      10.7.0.

    API Changes:
    - Mat3 and Mat4 functions have been marked [[nodiscard]] where it may be
      confusing if they are operating in place or returning a result, in
      particular tranpose, invert, adjoint, and timesDiagonal.
    - Re-worked the API in PointRasterizeSDF.h with the addition of anisotropic
      surfacing kernels. The new API exposes more concise free functions which
      take structs of parameters. The old API remains supported but is
      deprecated.
    - Deprecated providing a filter or interrupter as arguments to
      points::rasterize. These can instead be implemented on user transfer
      schemes.
    - Transfer schemes provided to points::rasterize can now optionally
      implement a rasterizePoints callback that takes a range of points per
      voxel.

    Fixes:
    - Fixed a bug in points::rasterizeSpheres and points::rasterizeSmoothSpheres
      which could cause sections of the generated surface to incorrectly be
      marked as negative interior values.
    - Fixed a bug in points::rasterizeSmoothSpheres which could result in
      incomplete surface reconstruction with significantly larger search
      distances.
    - Fixed some precision issues in various Matrix methods.
    - Fixed bugs in vdb_tool that prevented build with newer namespaces in
      nanovdb.

  OpenVDB AX:
    Improvements:
    - Added support for LLVM versions greater than 15. Upgraded CI to test with
      LLVM versions 16, 17, 18, 19 and 20.
    - As of this release, LLVM 15 is the minimum required version for OpenVDB
      AX. Note that there is an issue with LLVM 17 symbols which makes it
      incompatible with the OpenVDB Python plugin. AS such, LLVM version 18 and
      greater are the recommended LLVM versions to use, with LLVM 18 being the
      new future minimum version.
    - Significant performance improvement to the compilation of AX kernels when
      using LLVM 18 and greater.
    - Significant backend refactoring to AX IR generation to support newer
      versions of LLVM. In particular, parts of the codegen::Function and
      codegen::FunctionBuilder API require new usage from LLVM 16 due to
      the LLVM opaque pointer changes. If you're not using the OpenVDB AX
      Function codegen API then no client changes should be necessary.
    - Migrated OpenVDB AX unit tests from cppunit to gtest
      [Contributed by Tim Straubinger]

    Fixes:
    - Fixed a case of undefined behaviour when explicitly casting variables to
      the same type as their storage type e.g:
        double a; double b = double(a);
    - Fixed an AX compiler error which would produce invalid IR when using 64bit
      integer variables for matrix array offsetting e.g:
        int64 a = 0; mat4f b = 1; float c = b[a,a];

  NanoVDB:
    - Added nanovdb::openToIndexVDB, which can convert an OpenVDB grid into a
      NanoVDB IndexGrid.
    - Added new options "--index" and "--onIndex" to the command-line tool
      nanovdb_convert so it can produce IndexGrids.
    - Fixed memory leak in DeviceBuffer.
    - Added constructor for DeviceBuffer from an existing HostBuffer.
    - Added VoxelBlockManager, an acceleration structure for sequential access
      and stencil ops over active voxels.
    - Added helper functions for kernel launches with shared memory.
    - Added support for CUDA 13.0.
    - Fix warnings and compilation errors for GCC and Clang.
    - Fixed inconsistent usage of util::cuda::mallocAsync/freeAsync that
      affected vGPUs.
    - Added support for custom memory resources in PointsToGrid.
    - Fixed race condition in split/mergeGridHandles.
    - Fixed offset bug in nanovdb::tools::cuda::IndexToGrid related to non-POD
      build types.
      [Contributed by Andreas Henne]

  Houdini:
    - Define OP_InputIdx and OP_OutputIdx for Houdini 21.0 compatibility
    - Add Houdini 21 style camera interface to support LOP cameras
    - Include env flag for avoiding stream writing (was backported to 19.5)


Version 12.0.1 - April 3, 2025

  OpenVDB:
    New features:
    - Added read and write support for OFF (Object File Format) files to
      vdb_tool

    Build:
    - Fixed a build issue with vdb_render on Windows with newer versions of
      glew not including glu.h by default
    - Fixed issues with newer versions of clang refusing to accept older
      ::template syntax

  NanoVDB:
    New features:
    - Added support for multiple GPUs to DeviceBuffer
    - Added a UnifiedBuffer class that wraps CUDA unified memory
    - Added example for multiGPU sparse convolution
    - Added CUDA utility functions for device queries
    - Added functions to independently stop and compute the elapsed time for
      timer classes

    Improvements:
    - Replaced CUB's CachingDeviceAllocator with the default asynchronous
      stream ordered allocator in PointsToGrid for improved performance

    Bug fix:
    - Map is now properly transposed when converting NanoVDB to OpenVDB.
    - Fixed ostream specializations being hidden within the nanovdb namespace
    - Fixed a call to a non-existent method in GridBuild.h


Version 12.0.0 - October 31, 2024

      OpenVDB is now licensed under the Apache 2.0 license, instead of the MPL 2.0 license.

      This version introduces ABI changes relative to older major releases,
      so to preserve ABI compatibility it might be necessary to define the
      macro OPENVDB_ABI_VERSION_NUMBER=N, where, for example, N is 10 for
      Houdini 20.0 and 11 for Houdini 20.5.

      GCC 9 is no longer supported.

  OpenVDB:
    New features:
    - Added fillet() method in tools::LevelSetFilter to round off concave edges
      to create smoother transition between surfaces.

    Improvements:
    - Added openvdb::assertAbort to replace cassert and a
      OPENVDB_ENABLE_ASSERTS cmake argument/compile define to toggle
      assertions in OpenVDB code, independantly of NDEBUG. Asserts are
      no longer enabled by default in when NDEBUG is absent (e.g.
      Debug builds).
    - Removed last traces of Boost when OPENVDB_USE_DELAYED_LOADING is OFF
      [Reported by Brian McKinnon]
    - RootNode code cleanup to eliminate redundant key conversion and
      to create map values in-place.
    - Add RootNode::deleteChildOrTile() to delete a child or tile of
      the root node.
    - ValueAccessors are now defined and created in the Tree class
      instead of in the Grid class so that custom Tree implementations
      may define and create their own ValueAccessors if desired.
    - Added support for PDAL to vdb_tool [Contributed by Tom Matterson]
    - LeafManager and NodeManager now use Index64 for leaf counts internally.
    - Added RootNode::probeChild() const.
    - Added RootNode::probeChild() and RootNode::probeConstChild().
    - Added RootNode::probe() and RootNode::probeConst() to query key presence,
      child node, value and active state.
    - Added InternalNode::probeChild() const.
    - Added InternalNode::probeChild() and probeChildConst() with coord access
      and optionally value and active state.
    - Added InternalNode::probeChild() and probeChildConst() with index access
      and optionally value and active state.
    - Added InternalNode::isValueOff(), LeafNode::isValueOff(),
      LeafNodeBool::isValueOff(), LeafNodeMask::isValueOff().
    - Added LeafNodeMask::probeValue(Index,val), LeafNodeBool::probeValue(Index,val).
    - Added RootNode::getValueUnsafe(), RootNode::getChildUnsafe(),
      RootNode::getConstChildUnsafe().
    - Added InternalNode::getValueUnsafe(), InternalNode::getChildUnsafe(),
      InternalNode::getConstChildUnsafe().
    - Added InternalNode::setActiveStateUnsafe(), InternalNode::setValueOnlyUnsafe(),
      InternalNode::setValueOnUnsafe(), InternalNode::setValueOffUnsafe().
    - Added InternalNode::setChildUnsafe(), InternalNode::resetChildUnsafe(),
      InternalNode::stealChildUnsafe(), InternalNode::deleteChildUnsafe().
    - For LeafNode, LeafNodeBool and LeafNodeMask - added
      LeafNode::getValueUnsafe(), LeafNode::setActiveStateunsafe(),
      LeafNode::setValueOnlyUnsafe(), LeafNode::setValueOnUnsafe(),
      LeafNode::setValueOffUnsafe().

    ABI changes:
    - Tree::leafCount(), Tree::unallocatedLeafCount(),
      Tree::nonLeafCount() and Tree::nodeCount() now use Index64 in their
      return types instead of Index32.

    API Changes:
    - RootNode::tileCount(), RootNode::activeTileCount() and
      RootNode::inactiveTileCount() are now public.
    - RootNode::hasKey() and RootNode::coordToKey() are now public.
    - RootNode::leafCount(), RootNode::nonLeafCount() and RootNode::nodeCount()
      now use Index64 instead of Index32. The Index32 variant is deprecated.
    - InternalNode::leafCount(), InternalNode::nonLeafCount() and
      InternalNode::nodeCount() now use Index64 instead of Index32. The Index32
      variant is deprecated.
    - LeafNode::leafCount() and LeafNode::nonLeafCount() now use Index64 instead
      of Index32. The Index32 variant is deprecated.

    Bug Fixes:
    - Fix potential crash reading corrupt .vdb files with invalid
      blosc or zip chunks.
      [Fix thanks to Matthias Ueberheide]
    - Fix a bug in RootNode::setOrigin() where the origin was updated
      before the error was thrown potentially leaving the root in an
      invalid state.
    - Fixed a thread sanitizer issue which could cause undefined
      behaviour in VolumeToSpheres::fillWithSpheres
      [Reported by Jérémie Dumas]
    - Fixed an occurance of undefined behaviour in tools::activate
      (though this would typically not have manifested with any
      unintended behaviour)

  NanoVDB:
    Bug fix:
    - nanovdb::readGrids works with raw grid buffer.

    Improvements:
    - Restructure files location and namespace to be more align with
      OpenVDB. The namespaces touched by the restructuring are: io,
      cuda, util, tools, and math.
    - Add two scripts updateFiles.sh and updateFiles.py to update the
      files using NanoVDB. The script updateFiles.py works on both
      Windows and Linux.  For a more complete list of changes, see API
      Changes (details).

    - cuda::PointsToGrid supports target density.
    - Add support for NanoVDB Grid of type UInt8.
    - Add ability to use externally managed CUDA buffer.
    - Add create methods for CudaDeviceBuffer and exceptions.
    - Improve GridValidator logic, e.g. include check for grid count.
    - Add operator > and >= for class Coord according to lexicographical order.
    - Add toCodec to convert string to Codec enumeration type.
    - Add nanovdb::strlen<GridType>().
    - Add strncpy util.
    - Add NANOVDB_DISABLE_SYNC_CUDA_MALLOC that maps cudaMallocAsync
      and cudaFreeAsync to cudaMalloc and cudaFree respectively.
    - Add guard to UINT64_C.
    - Remove use of cudaMallocAsync in PointsToGrid.cuh.
    - Align PNanoVDB blind metadata to NanoVDB.

    API Changes:
    - Change mapToGridType to toGridType.
    - Change mapToMagic to toMagic.
    - Change CpuTimer.h to Timer.h.

    API Changes (details):
    - These APIs are now under the math namespace: Ray, DDA, HDDA,
      Vec3, Vec4, BBox, ZeroCrossing, TreeMarcher, PointTreeMarcher,
      BoxStencil, CurvatureStencil, GradStencil, WenoStencil, AlignUp,
      Min, Max, Abs, Clamp, Sqrt, Sign, Maximum, Delta, RoundDown, pi,
      isApproxZero, Round, createSampler, SampleFromVoxels.

    - These APIs are now under the tools namespace: createNanoGrid,
      StatsMode, createLevelSetSphere, createFogVolumeSphere,
      createFogVolumeSphere, createFogVolumeSphere,
      createFogVolumeTorus, createLevelSetBox, CreateNanoGrid,
      updateGridStats, evalChecksum, validateChecksum, checkGrid,
      Extrema.
    - These APIs are now under the util namespace: is_floating_point,
      findLowestOn, findHighestOn, Range, streq, strcpy, strcat,
      empty, Split, invoke, forEach, reduce, prefixSum, is_same,
      is_specialization, PtrAdd, PtrDiff.

    - Move nanovdb::build to nanovdb::tools::build.
    - Rename nanovdb::BBoxR to nanovdb::Vec3dBBox.
    - Rename nanovdb::BBox<nanovdb::Vec3d> to nanovdb::Vec3dBbox.
    - Move nanovdb::cudaCreateNodeManager to nanovdb::cuda::createNodeManager.
    - Move and rename nanovdb::cudaVoxelsToGrid to nanovdb::cuda::voxelsToGrid.
    - Move and rename nanovdb::cudaPointsToGrid to nanovdb::cuda::pointsToGrid.
    - Move nanovdb::DitherLUT to nanovdb::math::DitherLUT.
    - Move and rename nanovdb::PackedRGBA8 to nanovdb::math::Rgba8.
    - Move nanovdb::Rgba8 to nanovdb::math::Rgba8.
    - Move and rename nanovdb::CpuTimer to nanovdb::util::Timer.
    - Move nanovdb::GpuTimer to nanovdb::util::cuda::Timer.
    - Move and rename nanovdb::CountOn to nanovdb::util::countOn.

    - Move util/GridHandle.h to GridHandle.h.
    - Move util/BuildGrid.h to tools/GridBuilder.h.
    - Move util/GridBuilder.h to tools/GridBuilder.h.
    - Move util/IO.h to io/IO.h.
    - Move util/CSampleFromVoxels.h to math/CSampleFromVoxels.h.
    - Move util/DitherLUT.h to math/DitherLUT.h.
    - Move util/HDDA.h to math/HDDA.h.
    - Move util/Ray.h to math/Ray.h.
    - Move util/SampleFromVoxels.h to math/SampleFromVoxels.h.
    - Move util/Stencils.h to nanovdb/math/Stencils.h.
    - Move util/CreateNanoGrid.h to tools/CreateNanoGrid.h.
    - Move and rename util/Primitives.h to tools/CreatePrimitives.h.
    - Move util/GridChecksum.h to tools/GridChecksum.h.
    - Move util/GridStats.h to tools/GridStats.h.
    - Move util/GridChecksum.h to tools/GridChecksum.h.
    - Move util/GridValidator.h to tools/GridValidator.h.
    - Move util/NanoToOpenVDB.h to tools/NanoToOpenVDB.h.
    - Move util/cuda/CudaGridChecksum.cuh to tools/cuda/CudaGridChecksum.cuh.
    - Move util/cuda/CudaGridStats.cuh to tools/cuda/CudaGridStats.cuh.
    - Move util/cuda/CudaGridValidator.cuh to tools/cuda/CudaGridValidator.cuh.
    - Move util/cuda/CudaIndexToGrid.cuh to tools/cuda/CudaIndexToGrid.cuh.
    - Move and rename util/cuda/CudaPointsToGrid.cuh to tools/cuda/PointsToGrid.cuh.
    - Move util/cuda/CudaSignedFloodFill.cuh to tools/cuda/CudaSignedFloodFill.cuh.
    - Move and rename util/cuda/CudaDeviceBuffer.h to cuda/DeviceBuffer.h.
    - Move and rename util/cuda/CudaGridHandle.cuh to cuda/GridHandle.cuh.
    - Move and rename util/cuda/CudaUtils.h to util/cuda/Util.h.
    - Move and consolidate util/cuda/GpuTimer.h to util/cuda/Timer.h.

  Houdini:
    - When OPENVDB_ENABLE_RPATH is ON, the location of
      libopenvdb_houdini is now added to the rpath of all Houdini
      dsos.

  Python:
    - OpenVDB Python bindings are now implemented using nanobind
      instead of pybind11
    - The OpenVDB Python module has been changed from pyopenvdb to openvdb
    - Added Python bindings for NanoVDB

  Build:
    - Fixed an issue with OpenVDB AX's CMake on Windows where the
      static and shared library targets would have the same name
      [Reported by Nicholas Yue]
    - USE_EXPLICIT_INSTANTIATION is now disabled on Windows by default
      due to OOM linker issues.
    - Jemalloc is now the preferred allocator of choice on all
      platforms when CONCURRENT_MALLOC is set to Auto.
    - Fixed an issue with the Blosc CMake FindPackage for the OpenVDB
      Windows static library.


Version 11.0.0 - November 1, 2023

      This version introduces ABI changes relative to older major releases,
      so to preserve ABI compatibility it might be necessary to define the
      macro OPENVDB_ABI_VERSION_NUMBER=N, where, for example, N is 9 for
      Houdini 19.5 and 10 for Houdini 20.0.

      OpenEXR 2 and Python 2 are no longer supported.

  OpenVDB:
    Improvements:
    - Removed use of boost::any in favor of std::any.
      [Contributed by Brian McKinnon]

    Bug Fixes:
    - Fix potential crash reading corrupt .vdb files with invalid
      blosc or zip chunks.
      [Contributed by Matthias Ueberheide]

  NanoVDB:
    Highlights:
    - Several new tools to generate and modify NanoVDB grids on the GPU.
    - New file format that supports streaming of raw grid buffers.

    New Features:
    - New memory efficient GridClass::IndexGrid that separates values from tree
    - 4 new GridTypes (Index, OnIndex, IndexMask, OnIndexMask) used by IndexGrid
    - Added createNanoGrid that replaces older conversion methods in GridBuilder.h,
      IndexGridBuilder.h and OpenToNanoVDB.h
    - Added cudaPointsToGrid that constructs a point device grid from a list of
      points.
    - Added cudaVoxelsToGrid that constructs a voxel device grid from a list of
      voxels.
    - Added cuda/CudaUtils.h with several cuda utility functions.
    - Added GpuTimer for timing of kernels in a specific cuda stream.
    - Added cudaIndexToGrid that converts IndexGrids into regular Grids.
    - Added cudaSignedFloodFill that performs signed-flood filling on the GPU.
    - Added cudaAddBlindData that adds blind data to an existing grid on the GPU.
    - Added cudaGridChecksum that computes checksums of device grids.
    - Added cudaGridHandle that handles grids on the GPU.
    - Added cudaNodeManager that constructs a NodeManager on the GPU.
    - Added build type Points and GridType::PointIndex for point grids.
    - Added GridType::Vec3u16 and GridType::Vec3u8 for compressed coordinates.
    - Added PrefixSum.h for concurrent computation of prefix sum on the CPU.

    API Changes:
    - Version 32.6.0 (ABI is unchanged).
    - Transition from C++11 to C++17
    - Vec3R is deprecated, please use Vec3d instead.
    - nanoToOpenVDB now takes the index of a NanoVDB in a GridHandle.
    - GridData, InternalData and LeafData are now public.
    - GridMetaData can be copied.
    - Improvements to GridBuilder.h that allows construction of grids on CPU.
    - GridHandle's move c-tor now requires the GridBuffer to contain a valid grid.
    - Moved CudaDeviceBuffer.h to cuda/CudaDeviceBuffer.h.
    - New API for acceleration of custom random-access with ValueAccessors.
    - Added BitFlags class for convenient bit-mask operations.
    - Added Vec2/3::min/maxComponentAtomic GPU methods.
    - Added BBox::expandAtomic and BBox::intersectAtomic.
    - Added Coord::expandAtomic.
    - Added Map constructors.
    - Added Mask::DenseIterator, Mask::setOnAtomic, and Mask::setOffAtomic.
    - InternalNode::ChildIterator is now const-correct.
    - Added several new NanoVDB Build Traits.
    - Syncing PNanoVDB.h with NanoVDB.h.

  Build:
  - Support for OpenEXR 2.X has been removed.
  - Better support for building with external package configurations
    with CMAKE_FIND_PACKAGE_PREFER_CONFIG=ON.

  Python:
  - Removed Python 2 support.
  [Contributed by Matthew Cong]
  - Removed explicit bindings for Math types.
  [Contributed by Matthew Cong]
  - Improved type casting for TypedMetadata.
  [Contributed by Matthew Cong]


Version 10.1.0 - October 11, 2023

  Highlights:
    - OpenVDB Python bindings are now implemented using pybind11 instead of
    Boost.Python.
    [Contributed by Matthew Cong]

  OpenVDB:
    New features:
    - Added points::replicate() for the replication of PointDataGrid points
      and attributes.

    Improvements:
    - Upgraded OpenVDBs internal half representation to IMath 3.1.6. Brings
      conversion support using F16C instructions (if enabled using -mf16c) and
      the removal of the exponent lookup table in favor of bit shifting.
    - OpenVDBs copy of Half.h is no longer built with an internal lookup table,
      but explicitly selects the non-LUT version and disables the creation of
      the LUT. This is required to avoid symbol conflicts with different
      namespaced OpenVDB builds.
    - Removed boost::uuid from Archive, instead std::random_device is used
      directly to generate UUID-like objects.
    - Moved all cases of file static/global variables which relied on non-trivial
      construction into function scopes as static locals. These would previously
      initialize themselves on start-up in a non-deterministic, compiler-dictated
      order(static-initialization-order-fiasco). This order is now defined by the
      program's execution.
    - Fixed the constants used in openvdb::math::Coord::hash() and
      nanovdb::Coord::hash() to correctly be prime numbers (note that this
      changes the result of these methods).
      [Contributed by Benedikt Mersch]
    - Updated tools::meshToVolume to take two new optional arguments to provide
      an interior test oracle and an interior testing method. These allow the
      default outside-flood-fill to be replaced if the actual sidedness can be
      known.
      [Contributed by Tomas Skrivan]
    - LevelSetRebuild now includes example code that demonstrates the intended
      use of the new meshToVolume interior testing parameters for the
      resampling of level sets, where the original grid is used as the true
      sign value. However, due to differences between polygonalization and
      trilinear interpolation, this behaviour is disabled and exists as a
      reference.
    - Introduced openvdb::TupleList to wrap std::tuple and provide interface
      interop methods with openvdb::TypeList.
    - Added OPENVDB_FORCE_INLINE, OPENVDB_LIKELY and OPENVDB_UNLIKELY macros.
    - Introduced openvdb::make_index_sequence to solve clang compilations
      issues with compiler built-in index_sequence implementations.

    API changes:
    - Significant infrastructural change to the ValueAccessor header and
      implementation. All ValueAccessor specializations have been consolidated
      into a single class which supports all possible ValueAccessor configurations
      using index_sequences. Backward compatible declarations have been provided.
      The new ValueAccessor implementation is marked as final.
    - PagedArray iterators no longer derive from std::iterator
      (but remains standard compliant).

    Bug Fixes:
    - Internal counters in tree::RangeIterator were limited to 32bit precision.
      They are now extended to size_t.
      [Reported by SpaceX]
    - Fixed a bug when compiling with -fvisibility=hidden and GCC 11 which
      would cause a crash in openvdb::initialize().
    - Fixed a bug with LeafManager which wouldn't correctly
      initialize its LeafNode array for single level Tree configurations
      i.e. RootNode<LeafNode> (bug introduced in 7.2.0).
      [Reported by @lanwatch]
    - Fixed a bug with LeafNodeBool Topology constructor with designated
      on/off values which wouldn't apply them correctly.
      [Reported by @hozhaoea]

  OpenVDB AX:
    Improvements:
    - Added support for LLVM 15.

    Bug Fixes:
    - Fixed a bug in AX on older X86 hardware which could cause a crash when
      accessing point attributes with half compression (bug introduced in 9.1.0).
    - Fixed an incorrect option in the `vdb_ax` command line tool where the default
      optimization level was set to NONE instead of O3 (issue introduced in 10.0.0).

  Houdini:
    Improvements:
    - Added Preserve Holes option to VDB From Polygons that uses the
      fast winding oracle to not collapse holes in polygonal geometry.

    Bug Fixes:
    - Fix a bug in the projection mode of the Advect Points SOP that was causing
      a segfault.

  Build:
    - Fixed a build issue where Boost was not being pulled in when
      OPENVDB_USE_DELAYED_LOADING was set to OFF.
    - Fixed a build issue with AX on 32-bit platforms.
      [Reported by Mathieu Malaterre]
    - Fixed a compilation issue with the min() and max() methods on Stencils
      in openvdb/math/Stencils.h.
      [Reported by Samuel Mauch]
    - Fixed a compilation error that would be encountered when attempting to
      enable the SSE4.2 or AVX SIMD options on non-x86 based platforms.
    - Improved support for compiling with C++20.
      [Contributed by Denys Maletskyy and Jérémie Dumas]
    - OpenVDB's CMake no longer modifies the BUILD_SHARED_LIBS variable.
      [Reported by Maksim Shabunin]
    - Fix int-in-bool-context GCC9+ warnings by switching to use constexpr if.

Version 10.0.1 - November 30, 2022

    Bug Fixes:
    - Fix uninitialized point flags in tools::VolumeToMesh which could result in
      non-deterministic results (bug introduced in 10.0.0).

    Build:
    - Fixed CXX standard requirement for VDB components in FindOpenVDB.cmake

Version 10.0.0 - October 27, 2022

      This version introduces ABI changes relative to older major releases,
      so to preserve ABI compatibility it might be necessary to define the
      macro OPENVDB_ABI_VERSION_NUMBER=N, where, for example, N is 8 for
      Houdini 19.0 and 9 for Houdini 19.5.

  Highlights:
  - Introducing OpenVDBLink, which provides a Mathematica interface to
    OpenVDB. This link ports over access to various grid containers including
    level sets, fog volumes, vector grids, integer grids, Boolean grids,
    and mask grids. Construction, modification, combinations, visualisations,
    queries, import, export, etc. can be achieved over grids too. Any
    Mathematica 3D region that's ConstantRegionQ and BoundedRegionQ can
    be represented as a level set grid, providing a more seamless integration
    with OpenVDB.
  - Introducing a new command-line tool, dubbed vdb_tool, that can combine any
    number of the high-level tools available in openvdb/tools. For
    instance, it can convert a sequence of polygon meshes and particles to
    level sets, perform a large number of operations on these level set
    surfaces and export them as adaptive polygon meshes.

  OpenVDB:
    Improvements:
    - Significantly improved the performance of all ValueAccessor methods which
      access LeafNode value buffer data. This improvement applies to any type
      which is delay load compatible (all default types except for bool and mask
      grids) and improves the performance of many OpenVDB tools.
    - Improved the performance of volumeToMesh by 10-15%.

    ABI changes:
    - ABI change to openvdb::RootNode, which now has a new member that defines
      the origin of the node. For now this origin is set to a default value of
      (0,0,0), but in the near future we will allow for offsets to improve
      access performance and reduce the memory footprints.
    - Removed deprecated virtual methods from AttributeArray.

    API changes:
    - Removed PagedArray::push_back().
    - Removed Tree visitor methods from Tree, RootNode, InternalNode and
      LeafNode classes - visit(), visit2(), visitActiveBBox().
    - Removed LeafManager::getNodes().
    - Removed tools::dilateVoxels() and tools::erodeVoxels() in favor of
      tools::dilateActiveValues() and tools::erodeActiveValues().
    - Removed tools::FindActiveValues::any() and
      tools::FindActiveValues::none().
    - StringGrid and StringTrees have been removed.

    Bug Fixes:
    - Fixed an issue with tools::topologyToLevelSet which would previously
      ignore active tiles in the input topology.
      [Reported by Tobias Rittig]
    - Fixed a bug with ValueAccessor::addLeaf and ValueAccessor::addTile which
      wouldn't add the provided leaf nodes to the underlying tree. This bug did
      NOT affect the specialized accessors which are used by the default tree
      configuration.
      [Contributed by Andrey Zakirov]
    - Fixed a bug where ValueAccessor::probeNode<NodeT> and
      ValueAccessor:probeConstNode<NodeT> would return a nullptr if the NodeT
      type was not explicitly being cached by the accessor but the node existed
      in the tree.
    - Fixed a bug on Windows where math::Abs could truncate 64bit integer values.
      [Contributed by Edward Lam]
    - Fixed an occurrence of undefined behaviour with math::floatToInt32 and
      math::doubleToInt64.
      [Reported by Vojtěch Bubník]
    - Fixed bugs in the sum merge that produced incorrect merged grids when
      deep-copying the input nodes or when non-zero background grids were being
      used.
    - Fixed a bug in FastSweeping where voxels/tiles are left with min/max float
      values.
    - Fixed a bug in math/Tuple.h that prevented compilation with VS2017.

  OpenVDB AX:
    Improvements:
    - Major updates to the command line interface of the vdb_ax binary, exposing
      more controls such as tile streaming, value iterator types and attribute
      bindings.

  OpenVDB Houdini:
    New Features:
    - Add convex hull activation for VDB Activate SOP (requires 19.5).

    Improvements:
    - Improved SDF activation to use dynamic node manager.

    Bug Fixes:
    - Fixed a bug in VDB Visualize SOP where color values that exceed
      the range wrap around instead of being clamped.

  NanoVDB:
    New Features:
    - Added nanovdb::IndexGrid that allows for arbitrary voxel values and even
      multiple channels to be associated with NanoVDB grids. They are more
      flexible and memory efficient than regular grids at a small cost of
      random-access performance. IndexGrids are constructed with the new
      nanovdb::IndexGridBuilder and accessed with the new
      nanovdb::ChannelAccessor.
    - Added iterators to all tree node classes for visiting inactive, active, or
      all values and child nodes.
    - NanoVDB.h now includes standalone implementations of reading and writing
      uncompressed nanovdb grids buffers.
    - Added Stats::getExtrema, which computes the min/max values of all voxels
      in a NanoVDB grid that intersects with a user-defined bounding-box.
    - Added nanovdb::Mask::countOn(int) which is essential to the new
      nanovdb::IndexGrid.
    - Added RootNode::probeChild and InternalNode::probeChild.

    Improvements:
    - Added a new much improved nanovdb::NodeManager, that is both faster and
      more memory efficient, and that works on both the CPU and GPU. Note, it
      uses a handle for allocation (just like nanovdb::Grid) and replaces the
      old nanovdb::LeafManager which is now deprecated.
    - NanoToOpenVDB is extended to work with grids templated on Fp4, Fp8, Fp16,
      FpN, bool and ValueMask.
    - Renamed RootNode::findTile to RootNode::probeTile and made it public.
    - Made Mask::getWord return both a const and non-const reference.
    - Improved unit-tests to use explicit 32B alignment (see alignment bug-fix
      below).
    - PNanoVDB.h (a C99 port of NanoVDB.h) has been updated.

    Bug Fixes:
    - Fixed a bug in nanovdb::HostBuffer that could produce crashes due to
      misaligned CPU memory allocations.
    - Fixed bug related to uninitialized memory in nanovdb::Grid which could
      confuse CRC32 checksum validation.
    - Fixed bugs related to the use of intrinsic functions for fast bit-counting
      in nanovdb.
    - Fixed a potential security vulnerability in NanoVDB.h related to buffer
      overflow exploits.

  Build:
  - Added OPENVDB_USE_DELAYED_LOAD flag that enables delayed loading and
    defaults to on.
  - Add a placeholder to inject the specific revision and URL used
    to build OpenVDB, useful for 3rd party build scripts to publish
    their exact versions.
  - Fixed an issue where OPENVDB_AX_DLL was not being defined on shared
    library builds of AX, resulting in symbols not being exported.
    [Reported by Ray Molenkamp]
  - Fixed an issue where setting Tbb_INCLUDE_DIR could cause CMake failures.
  - Updated FindTBB.cmake to support newer library ABI suffixing in
    TBB 2021.5.
  - Updated FindBlosc.cmake to better handle cases where blosc is built with
    external sources.
  - Resolved LLVM deprecation warnings in AX and added support for LLVM 14.
  - On Windows (MSVC), OpenVDB is now built with extra compiler options to
    ensure stricter C++ conformance: /permissive- /Zc:throwingNew /Zc:inline.
  - On Windows (MSVC), the _USE_MATH_DEFINES macro is no longer defined when
    including <openvdb/Platform.h> (or any dependent headers). If you were
    relying on this in your own project for M_PI, M_PI_2, etc. you can add
    -D_USE_MATH_DEFINES to your own project compiler options. See
    https://docs.microsoft.com/en-us/cpp/c-runtime-library/math-constants
    for more info.

Version 9.1.0 - June 9, 2022

    Bug Fixes:
    - Minor fix to move assignment operator in nanovdb/util/HostBuffer.h.
      This could potentially be a problem on Windows debug builds (unconfirmed).
    - Minor fix to range in openvdb/tools/LevelSetSphere.h. This could result
      in data races for multi-threaded execution (unconfirmed)
      [Reported by Tommy Hinks]
    - Fixed a bug with Tree::combineExtended which wouldn't propagate the
      resulting active state when a destination tile overlapped a source child node.
      [Reported by @frapit]
    - Fix unit tests failures with Blosc versions >= 1.19.0.
    - Fixed a regression in ax::run which wouldn't propagate exceptions
    - Fixed a bug where ax::ast::parse could return a partially constructed but
      invalid AST on failure
    - Fixed AX logger exit handling in ax::Compiler::compile and ax::ast::parse
    - Fixed an issue which could result in significant compilation times when
      instantiating TypeList<>::Unique<>

    New features:
    - Added support for AMD's HIP API in NanoVDB
      [Contributed by Blender Foundation]
    - Added bindings mechanism to AX to allow differing data and AX attribute
      names (@) in Point and Volume executables.
    - Added support for OpenVDB AX on Windows.
    - Added tools::memUsageIfLoaded() which returns the memory consumption of
      a deserialized VDB tree, useful if delay-loading is enabled.
    - Added points::rasterizeSpheres() and points::rasterizeSmoothSpheres()
      variants, new kernels and improved performance for OpenVDB points to
      surface rasterization.
    - Added points::rasterizeTrilinear() for OpenVDB points, fast staggered
      or colocated trilinear rasterization for scalar and vector attributes.
    - Exposed TypeList declarations in openvdb.h which denote the default set
      of types supported by OpenVDB.
    - Added points::FrustumRasterizer for efficient rasterization of OpenVDB
      points to frustum volumes with optional motion blur.

    Improvements:
    - Added a --thread [n] argument to the vdb_ax binary.
    - Added a --copy-file-metadata option to vdb_ax. This behaviour is now
      off by default.
    - Added support for multiple input files with the vdb_ax binary using -i.
      Positional arguments as input files are deprecated.
    - Added tools::minMax() which supports multithreaded evaluation of active
      minimum and maximum values. Grid::evalMinMax() has been deprecated.
    - Significant performance improvements to AX point kernels, primarily due to
      providing AX access to attribute buffers for superior code generation.
    - vdb_print now prints both the in-core memory and total memory usage for
      VDB grids.
    - Improved build support for MinGW
      [Contributed by Mehdi Chinoune]
    - Added a new foreach method to TypeList for iterating over types without
      constructing them.
    - Added TypeList::Transform declaration for transforming TypeLists into new
      types.
    - Moved Grid::apply implementation to TypeList::apply to allow for other
      polymorphic types to invoke it.
    - Minor updates to NanoVDB to remove compiler warnings.

    Build:
    - Regenerated AX grammar with Flex 2.6.4 and Bison 3.8.2.
    - Improved locating NumPy in CMake when multiple python versions are installed.
    - Fixed an issue which could report Python as missing when using CMake 3.18
      and later on some systems.
      [Reported by Sam James]
    - Changed the way boost_python and boost_numpy are located. Both components
      must match the major/minor version of python in use. This can be
      circumvented by providing Boost_PYTHON_VERSION or
      Boost_PYTHON_VERSION_MAJOR.
    - Relocated OpenVDB binaries to a new openvdb_cmd root directory.
    - FindTBB.cmake now prioritises newer TBB installations.
    - Added option to compress PDB data in MSVC debug builds.

    Houdini:
    - Added Attribute Bindings to AX SOP to allow differently named AX
      attributes (@) and target point attributes/volumes.
    - Fix race condition in OpenVDB Merge SOP that could cause crashes or
      merged VDBs to not be deleted.
    - VDB Activate SOP no longer stops at the first non-VDB primitive, but
      instead just skips such primitives.
    - Added VDB Rasterize Frustum SOP for efficient rasterization of OpenVDB
      points into frustum volumes with optional motion blur.


Version 9.0.0 - October 29, 2021

      This version introduces ABI changes relative to older major releases,
      so to preserve ABI compatibility it might be necessary to define the
      macro OPENVDB_ABI_VERSION_NUMBER=N, where, for example, N is 7 for
      Houdini 18.5 and 8 for Houdini 19.0.

      Official release of NanoVDB, which for the first time offers GPU support
      for static sparse volumes in OpenVDB.

    New features:
    - Faster build times from support for explicit template instantiation,
      which is enabled by default for most of the tools.
    - Added support for OpenEXR 3 and TBB 2021.
    - Added transient data to the RootNode, InternalNode, and LeafNode.

    Improvements:
    - Added tools::countActiveLeafVoxels(), tools::countInactiveVoxels(),
      tools::countInactiveLeafVoxels() and tools::activeTiles() to perform
      multi-threaded counting. The Tree methods now use these implementations.
    - Moved from the deprecated TBB task scheduler to TBB arenas. Various
      methods now respect the TBB arena state they were invoked from.
    - Introduced a new thread/Threading.h header to consolidate calls to
      third-party threading methods.
    - Minor performance improvements to dilation calls in fast sweeping
      algorithms.
    - Added hsvtogrb() and rgbtohsv() AX helper functions for converting
      hue, saturation and value inputs to RGB values and vice-versa.
    - PointDataGrid conversion can now be performed using 32-bit float arrays.
    - Improved support for size_t grid types on systems where size_t is a
      unique type.
      [Contributed by Brecht Van Lommel]
    - Add support for dilation in one direction and extending a field in one
      direction in fast sweeping algorithms.
    - Added PNG support to vdb_render which can be enabled with during CMake
      with -DUSE_PNG=ON.
    - Explicit template instantiation has been enabled by default for most of
      the tools. This pre-compiles template instantiations into the core library
      to reduce the time spent compiling code in downstream libraries or
      applications.
    - Added a python binding for OpenVDB AX which allows you to invoke accelerated
      AX code from the python module.

    Bug Fixes:
    - Fixed a bug where ax::run() would crash if it could not parse a single
      statement.

    ABI changes:
    - Added transient data to the RootNode, InternalNode, and LeafNode.

    API changes:
    - DynamicNodeManager can now set one grain size for threading across leaf nodes
      and another for threading across non-leaf nodes.
    - StringGrid and StringTrees are deprecated.
    - The NullInterrupter is now a virtual base class to help reduce
      compile-time instantiation cost.

    Houdini:
    - Fix crash in VDB Combine in Copy B mode if the second input has
      more VDBs than the first.
    - VDB Vector Merge SOP is now VDB Vector From Scalar SOP to distinguish
      it from the VDB Merge SOP. It keeps the same internal name so this
      is merely a label change.
    - Add option to pass in OPENVDB_DSO_NAMES to CMake to configure which
      Houdini DSOs are compiled.
    - VDB Activate SOP now has an option for the expansion pattern to use
      for dilation.
    - The label for Voxels to Expand is now Expand Voxels to match Houdini.
    - Fix bug to allow VDB LOD SOPs to be chained together.
    - SOP Extrapolate supports dilation in one direction and extending a field
      in one (domain) direction.
    - The default OpenVDB ABI is now 8 for Houdini versions > 18.5.
    - VDB Visualize Tree SOP is now multi-threaded and provides slicing and
      color remapping.
    - A new HoudiniInterrupter has been added that derives from the
      NullInterrupter and the Interrupter is now deprecated. All the SOPs have
      been updated to use the new HoudiniInterrupter.
    - Add a sanitizer in SOP OpenVDB Extrapolate when expanding a narrow-band
      level-set with a dilation value of 0, which will result in no operation.

    Build:
    - Added support for TBB 2021.
    - Enabled the OPENVDB_FUTURE_DEPRECATION variable by default to warn on
      upcoming deprecations.
    - Introduced a OPENVDB_DOXYGEN_INTERNAL CMake variable which is ON by
      default and removes the majority of internal namespaces from the
      generated doxygen.
    - Improved the doxygen deprecation listings, folder layouts and fixes
      issues when using later versions of doxygen.
    - Build fixes for MinGW on Windows.
      [Contributed by Brecht Sanders]
    - Added support for OpenEXR 3.
      [Contributed by Cary Phillips]
    - Added an OPENVDB_NAMESPACE_SUFFIX CMake string option which provides
      the ability to customise the VDB namespace.
    - The Python Module now appends the base directory defined by
      Python_SITELIB to the default install path (typically dist-packages
      or site-packages).
      [Contributed by Ignacio Vizzo]
    - As of this release, VFX Reference Platform 2019 is no longer supported.
      CMake now issues deprecation warnings for 2020 VFX Reference Platform
      version dependencies.
    - Build fixes for OpenVDB AX with C++17 and greater.
    - Bumped the new blosc version future minimum to 1.17.0.
    - OpenEXR is now optional for vdb_render. It can be enabled with
      -DUSE_EXR=ON.


Version 8.2.0 - November 24, 2021

    Improvements:
    - Added tools::countActiveLeafVoxels(), tools::countInactiveVoxels(),
      tools::countInactiveLeafVoxels() and tools::activeTiles() to perform
      multi-threaded counting. The Tree methods now use these implementations.
    - Moved from the deprecated TBB task scheduler to TBB arenas. Various
      methods now respect the TBB arena state they were invoked from.
    - Introduced a new thread/Threading.h header to consolidate calls to
      third-party threading methods.
    - Minor performance improvements to dilation calls in fast sweeping
      algorithms.
    - Added hsvtogrb() and rgbtohsv() AX helper functions for converting
      hue, saturation and value inputs to RGB values and vice-versa.
    - PointDataGrid conversion can now be performed using 32-bit float arrays.
    - Improved support for size_t grid types on systems where size_t is a
      unique type.
      [Contributed by Brecht Van Lommel]
    - Minor performance improvements to dilation calls in fast sweeping
      algorithms.
    - Add support for dilation in one direction and extending a field in one
      direction in fast sweeping algorithms.

    API changes:
    - DynamicNodeManager can now set one grain size for threading across leaf nodes
      and another for threading across non-leaf nodes.

    Houdini:
    - Fix crash in VDB Combine in Copy B mode if the second input has
      more VDBs than the first.
    - VDB Vector Merge SOP is now VDB Vector From Scalar SOP to distinguish
      it from the VDB Merge SOP. It keeps the same internal name so this
      is merely a label change.
    - Add option to pass in OPENVDB_DSO_NAMES to CMake to configure which
      Houdini DSOs are compiled.
    - VDB Activate SOP now has an option for the expansion pattern to use
      for dilation.
    - The label for Voxels to Expand is now Expand Voxels to match Houdini.
    - Fix bug to allow VDB LOD SOPs to be chained together.
    - SOP Extrapolate supports dilation in one direction and extending a field
      in one (domain) direction.
    - The default OpenVDB ABI is now 8 for Houdini versions > 18.5.
    - VDB Visualize Tree SOP is now multi-threaded and provides slicing and
      color remapping.
    - Add a sanitizer in SOP OpenVDB Extrapolate when expanding a narrow-band
      level-set with a dilation value of 0, which will result in no operation.

    Build:
    - Added support for TBB 2021.
    - Enabled the OPENVDB_FUTURE_DEPRECATION variable by default to warn on
      upcoming deprecations.
    - Introduced a OPENVDB_DOXYGEN_INTERNAL CMake variable which is ON by
      default and removes the majority of internal namespaces from the
      generated doxygen.
    - Improved the doxygen deprecation listings, folder layouts and fixes
      issues when using later versions of doxygen.
    - Build fixes for MinGW on Windows.
      [Contributed by Brecht Sanders]
    - Added support for OpenEXR 3.
      [Contributed by Cary Phillips]
    - Added an OPENVDB_NAMESPACE_SUFFIX CMake string option which provides
      the ability to customise the VDB namespace.
    - The Python Module now appends the base directory defined by
      Python_SITELIB to the default install path (typically dist-packages
      or site-packages).
      [Contributed by Ignacio Vizzo]


Version 8.1.0 - June 11, 2021

      As of this release, support for grid ABI=5 has been removed.

    New features:
    - Added tools::erodeActiveValues() to match the existing
      tools::dilateActiveValues(). New erosion tools support all tile policies
      and edge/vertex neighbor patterns.
    - Added support for automatic filtering of active tiles in tools::Filter
      by setting tools::Filter::setProcessTiles. Active tiles are densified
      on demand, only when necessary.
    - Added tools::visitNodesDepthFirst and tools::DepthFirstNodeVisitor which
      visit nodes in a tree or sub-tree in single-threaded depth-first order.
    - Significant performance improvements to AX volume kernels, primarily due
      to improved vectorization. Performance scales depending on the available
      host CPU instruction set and scalability of the AX kernel. Trivial
      assignments profile upwards of 3x faster on AVX.
    - Introduced Active Tile Streaming for volumes kernels. AX can now
      dynamically expand and collapse active nodes at all levels of a VDB tree
      on demand, switching on or off by checking the spatial access pattern of
      AX programs.
    - Added tools::countActiveVoxels() for multi-threaded counting of active
      voxels, optionally by bounding box. The Tree::activeVoxelCount() method
      now uses this implementation.
    - Added tools::memUsage() for multi-threaded counting of bytes of memory
      used. The Tree::memUsage() method now uses this implementation.

    Improvements:
    - Significant performance improvements to large dilations with
      tools::dilateActiveValues(). Performance gains will improve relative to
      increases in the inputs size and dilation scheme.
    - Added an optional argument to Tree::topologyUnion() which preserves
      active tiles on the destination tree should they overlap leaf nodes
      from the source tree.
    - Reduced the time spent in the hot path of openvdb::initialize() and
      openvdb::uninitialize() by leveraging atomics with double-checked locks.
      [Contributed by Ben FrantzDale].
    - Extended tree::DynamicNodeManager to allow for use with a const tree.
    - Replace tbb::mutex with std::mutex and tbb::atomic with std::atomic as
      these have now been removed in TBB 2021.
      [Contributed by Ben FrantzDale].
    - Significant performance improvements to tools::activate and
      tools::deactivate through use of the DynamicNodeManager to parallelize
      tile processing.
    - Added degree() and radians() AX helper functions for converting radians
      to degrees and vice versa, respectively.
    - Added adjoint(), cofactor() and inverse() AX matrix functions.
    - Added sort(), argsort(), isfinite(), isinf() and isnan() AX utility and
      math functions.
    - Added Vec4 argument support to normalize() AX function.
    - Removed unused int16 AX modulo function signatures.
    - Refactored the backend AX representation of strings with SSO support and
      heap allocation.
    - Added new methods on the VolumeExecutable to control active tile
      streaming and node execution levels
    - The deletepoint() AX function is now natively supported by the
      PointExecutable
    - Added tools::SumMergeOp that uses a parallel breadth-first algorithm to
      accelerate summing grids.
    - vdb_view: Fixed a bug which wouldn't reset the camera speed on focus
    - vdb_view: Improved the drawing of PointDataGrids
    - vdb_view: Improved the exception handling of BufferObjects and added
      support for drawing an array without index values

    Bug Fixes:
    - Fix a memory leak in AttributeArray when delayed-loading is disabled.
    - Fixed a crash in OpenVDB AX when declaring arrays with non-scalar
      elements (unsupported) i.e. {"foo", 1, 2}, {1, {1,2}, 3} etc.
    - Fixed a bug in OpenVDB AX which would cause an error when multiplying a
      vec3 by a mat4.
    - In OpenVDB AX, improved the error message produced when attempting to use
      a matrix literal (i.e. {1,2,3...}) in a binary expression (this is
      invalid but would previously print out bad IR).
    - Fixed a non-deterministic failure in the TestStreamCompression unit test.
    - Use copy-by-reference for the operator in a DynamicNodeManager to fix a
      performance regression.
    - tools::deactivate now also works with a MaskTree.
    - Fixed a memory leak in the OpenVDB AX parser
    - Fixed an occurrence of undefined behavior in the OpenVDB AX visitor
    - Fixed some memory leaks in the OpenVDB and OpenVDB AX unit tests
    - Fixed a bug in AX which could cause string allocations in loops to overflow
      the stack
    - Fixed a bug where the ValueOff iterator for the AX VolumeExecutable could
      remove child branches of a VDB tree.
    - Fixed a crash in the AX Houdini SOP with an empty PointDataGrid input.
    - Fixed all cases where PointIndex and PointData aliases were used instead
      of a templated type.  [Reported by Karl Marrett]
    - Fixed a crash when calling openvdb::points::pointOffsets with an empty
      PointDataGrid input.
    - Add missing 8-bit and 16-bit attribute type registration.

    API changes:
    - Restructured the internals of Morphology.h and moved tools::activate()
      and tools::deactivate() to a new header, Activate.h.
    - Deprecated tools::dilateVoxels() and tools::erodeVoxels() in favour of
      new morphology methods.
    - The openvdb::tools::Film class no longer has a saveExr method in
      any build configuration. Sample code for saving exrs from this
      object can be found in the command line render tool.
    - Added ability to run tools::activate and tools::deactivate
      single-threaded.

    Houdini:
    - Updated the VDB Activate SOP and others to use the multi-threaded
      implementation for voxel dilation, providing a significant performance
      increase.
    - Introduced the VDB AX SOP which provides an interface for running
      OpenVDB AX code in Houdini on VDB grids.
    - Updated the VDB Smooth SOP to support the filtering of active tiles.
    - Fixed a parameter warning in VDB AX SOP.
    - Transfer Surface Attributes in Convert VDB SOP could use uninitialized
      memory.
    - VDB Activate SOP now uses the multi-threaded tools::deactivate for much
      faster performance.
    - Improved the formatting and updated the OpenVDB AX SOPs help card.
    - The AX SOP utilizes the new Active Tile Streaming feature for Volumes.
      Grids will only be densified in areas where unique values are created.
    - VDB Activate SOP dilation will affect tiles, changing its behavior
      from previous versions, but producing a more expected result.
    - VDB Activate SOP has a world space dilation option.
    - Introduced the VDB Merge SOP that merges multiple grids in parallel and
      is faster and more convenient to use than the VDB Combine SOP.
    - Fix a bug where the VDB Rebuild SDF was not preserving metadata from the
      input grid.
    - Fix a bug in VDB Resample SOP where input transform was not being used for
      voxel size and voxel scale transform modes.
    - Added Extrapolate SOP, which wraps the tools leveraging the Fast Sweeping
      algorithm (tools::dilateSdf, tools::maskSdf, tools::fogToSdf,
      tools::sdfToSdf, tools::sdfToExt, tools::fogToExt, tools::sdfToSdfAndExt,
      tools::fogToSdfAndExt).

    Build:
    - Dependency on OpenEXR's Half implementation has been removed from the
      core library by naturalizing the implementation into openvdb::math.
      This is fully bitwise compatible, but may require switching Half
      references to math::Half. The USE_IMATH_HALF build configuration can
      be used to switch back to OpenEXR based half.
    - Blosc, Log4cplus, IlmBase, OpenEXR and TBB find modules now configure
      release and debug library variants.
      [Reported by Matthew Cong]
    - Fixed an issue where FindBlosc wouldn't add zstd as a dep in non static
      builds BLOSC_USE_EXTERNAL_SOURCES.
    - Fixed Log4cplus interface language and missing interface libraries on
      Win32.
    - Removed Jemalloc and Tbbmalloc logic from the core library builds.
    - The variable CMAKE_MSVC_RUNTIME_LIBRARY is no longer set by the OpenVDB
      CMake. If CMAKE_MSVC_RUNTIME_LIBRARY is not explicitly provided, OpenVDB
      configures the static library with /MT(d) and the dynamic library
      with /MD(d).
      [Reported by Jérémie Dumas]
    - Added support for ABI=9 and a CMake option OPENVDB_USE_FUTURE_ABI_9 to
      use it without errors.
    - The value of CONCURRENT_MALLOC is now respected when building the vdb_ax
      command line binary.
    - Added an option OPENVDB_ENABLE_UNINSTALL to allow the toggling of the
      uninstall build target.
      [Contributed by Jérémie Dumas]
    - Improved the behavior of locating static zlib libraries when
      USE_STATIC_DEPENDENCIES is enabled.
    - Fixed an issue where extra hboost libraries could not be found when
      building against Houdini 18.5 on Windows.
    - Build fixes to OpenVDB AX for LLVM 12.
    - Re-introduced the OPENVDB_DEPRECATED macro with an additional option that
      takes a message.  Added support to disable deprecations throughout
      OpenVDB by defining OPENVDB_NO_DEPRECATION_WARNINGS
    - Added an optional OPENVDB_TESTS variable to easily build a subset of the
      unit tests.
    - Fixed various incorrect RPATH directory paths in CMake (introduced in
      8.0.1)
      [Contributed by Ignacio Vizzo].
    - Removed some unnecessary CMake for vdb_view
    - The Windows defines NOMINMAX and _USE_MATH_DEFINES are now provided in
      Platform.h.
    - Moved the logic from PlatformConfig.h into Platform.h.
    - The version.h header is now an auto generated header (version.h.in)
      populated by CMake.  The OpenVDB Version and ABI defines are computed
      from the installation settings.  Importantly, the value of
      OPENVDB_ABI_VERSION_NUMBER now always matches the version used at build
      time.
    - Added OPENVDB_USE_HALF, OPENVDB_USE_BLOSC and OPENVDB_USE_ZLIB as
      publicly available defines in version.h. These will be defined depending
      on the settings used to build OpenVDB.


Version 8.0.1 - February 5, 2021

    Bug fixes:
    - Fixed a bug in the new CSG intersection merge algorithm where data
      outside of the intersection region was not being removed.

    Build:
    - Fixed various incorrect RPATH directory paths in CMake
    - Dropped the minimum boost requirement back to 1.61.
    - Documentation installed by the doc target is now installed to the
      share/doc/OpenVDB prefix

    Houdini:
    - VDB Combine SOP no longer attempts to invoke SDF CSG operations on
      bool grids because unary negation is undefined on bools in the
      template expansion.

Version 8.0.0 - December 23, 2020

      This version introduces ABI changes relative to older major releases,
      so to preserve ABI compatibility it might be necessary to define the
      macro OPENVDB_ABI_VERSION_NUMBER=N, where, for example, N is 6 for
      Houdini 18.0 and 7 for Houdini 18.5.

      Official release of OpenVDB AX, a new C++ library that implements a
      domain specific JIT (just-in-time) compiled expression language,
      providing users with a new way of interacting with OpenVDB data. AX is
      tailored towards writing highly parallelizable and customizable OpenVDB
      volume and point kernel operations. See the documentation for more:
      https://www.openvdb.org/documentation/openvdbax.html

    New features:
    - Added tools::anyActiveVoxels and tools::anyActiveTiles that check
      if respectively active voxels or tiles in a tree intersect a given
      CoordBBox.
    - Added tools::activeTiles that returns a vector containing all the active
      tiles in a tree that intersects a given CoordBBox.

    Improvements:
    - Made LeafManager class non-virtual.

    Bug fixes:
    - Fixed a determinism bug in NodeManager when using non-thread-safe
      functor members.
    - Fix GridTransformer construction to use correct rotate-scale-translate
      order when recomposing matrix components.
      [Contributed by Tom Cnops].
    - OpenVDB AX: Fixed a potential code generation crash in binary, ternary
      or comma operators when errors occurred in first operand.

    ABI changes:
    - Grid::isTreeUnique() is now virtual as of ABI=8 so that it can be
      accessed from the GridBase.
    - Private method RootNode::getChildCount() has been removed as of ABI=8.
    - Mark map classes and functions as final for ABI=8 where beneficial to
      allow devirtualization optimization.
    - As of ABI 8, Vector, Matrix and Quaternion types now satisfy the Trivial
      Type requirement. Their empty constructors and copy constructors have
      been removed (and are left to the compiler to define).
    - As of ABI 8, removed an unnecessary specialization of NodeUnion and
      CopyTraits from NodeUnion.h. Replaced std::is_pod usage with
      std::is_trivially_copyable which allows more types to benefit from the
      union storage.
    - As of ABI 8, PointDataGrids use the union NodeUnion specialization,
      reducing the memory footprint of their topology by 50%.

    API changes:
    - Removed a number of deprecated point, volume and AX methods.

    Houdini:
    - VDB to Spheres SOP doesn't reset the radius when in worldspace mode.
      VDB Write likewise should not reset the compression values.

    Build:
    - As of this release, VFX Reference Platform 2018 is no longer supported.
      CMake now issues deprecation warnings for 2019 VFX Reference Platform
      version dependencies, with the exception that OpenEXR/IlmBase 2.2 is
      still supported.
    - Added a missing header include to resolve an undefined size_t build error
      on GCC10.
    - Improved the python module's linkage with the CMake 3.15 Python::Module
      target. Explicitly linking with the Development target could result in
      crashes, particularly on macOS.
      [Reported by Alexander Hagen]
    - Removed OPENVDB_DEPRECATED macro in favor of C++14 [[deprecated]]
      attribute.

Version 7.2.3 - March 16, 2021

    Bug fixes:
    - Use copy-by-reference for the operator in a DynamicNodeManager to fix a
      performance regression.

Version 7.2.2 - February 4, 2021

    Bug fixes:
    - Fixed a bug in the new CSG intersection merge algorithm where data
      outside of the intersection region was not being removed.
    - Fix GridTransformer construction to use correct rotate-scale-translate
      order when recomposing matrix components.
      [Contributed by Tom Cnops].

    Houdini:
    - VDB Combine SOP no longer attempts to invoke SDF CSG operations on
      bool grids because unary negation is undefined on bools in the
      template expansion.
    - VDB to Spheres SOP doesn't reset the radius when in worldspace mode.
      VDB Write likewise should not reset the compression values.

Version 7.2.1 - December 23, 2020

    Bug fixes:
    - Fixed a determinism bug in NodeManager when using non-thread-safe
      functor members.

    Build:
    - Added a missing header include to resolve an undefined size_t build error
      on GCC10.

Version 7.2.0 - December 9, 2020

    New features:
    - Added tree::DynamicNodeManager that lazily caches the nodes at each
      level of the tree to allow for efficient threading of topology-changing
      top-down workflows.
    - Added tools::CsgUnionOp, tools::CsgIntersectionOp and
      tools::CsgDifferenceOp that use a parallel breadth-first algorithm to
      accelerate CSG union, intersection and difference operations.
    - Added tools::TreeToMerge which provides methods to steal or deep-copy
      from a tree based on the tag dispatch class used in its construction.
    - Pre-release of OpenVDB AX, an open source C++ library that provides a
      powerful and easy way of interacting with OpenVDB volume and point data.

    Improvements:
    - util::CpuTimer now uses C++11 chrono instead of TBB.
    - Threaded the construction of LeafManager and NodeManager linear arrays.
    - tools::csgUnion, tools::csgIntersection and tools::csgDifference now use
      the new parallel breadth-first algorithms for much faster performance.
    - Extended tree::NodeManager to allow for use with a const tree.
    - Added math::Abs, math::cwiseAdd, math::cwiseLessThan and
      math::cwiseGreaterThan methods for Matrix types. Matrix grids can now be
      instantiated.

    Houdini:
    - Fixed a bug in the OpenVDB Points Convert SOP where the auto voxel
      transform was ignoring the contents of packed geometry.
    - Fixed a bug in the OpenVDB Points Convert SOP where points representing
      packed geometry were also being converted.
    - Fixed a bug where a Houdini SOP's verb would not be correctly associated
      with the corresponding node if the node's internal name was changed.
    - Fixed bug where OpenVDB Convert SOP could revert the name attribute.

    Bug fixes:
    - Fixed a bug which could cause recursive compile time instantiations of
      TypeList objects, manifesting in longer compile times.
    - Deprecated util::PagedArray::push_back due to a race condition. Instead
      use util::PagedArray::ValueBuffer::push_back which is faster and thread-safe.
    - Fixed various cases of undefined behavior in some LevelSetUtil methods
      [Reported by fkemmler]

    API changes:
    - Deprecated tree::LeafManager::getNodes. This method is no longer used when
      constructing a NodeManager from a LeafManager.
    - Deprecated Tree::visitActiveBBox, Tree::visit and Tree::visit2 methods in
      favor of using a tree::DynamicNodeManager.
    - Removed tools::CsgVisitorBase, tools::CsgVisitorUnion,
      tools::CsgVisitorIntersection and tools::CsgVisitorDifference. The CSG
      tools now use the parallel breath-first algorithms.
    - Moved openvdb::TypeList from Types.h into its own header TypeList.h

    Build:
    - Removed the Makefiles.
    - Re-organised the repository layout such that each independent library
      is able to be configured against an existing installation of OpenVDB
      without ambiguous include paths.
    - Upgraded CMake minimum version support to 3.12.
    - Removed OPENVDB_STATIC_SPECIALIZATION macro which is no longer required.
    - Fixed various compiler warnings for GCC 9.1.
    - Moved to CMake doxygen commands and removed the doxygen-config files for
      doxygen documentation.
    - Added USE_ZLIB compiler flag that enables zlib compression and defaults
      to on.
    - Added the OPENVDB_STATICLIB define to all static builds to fix builds on
      Windows which use the multithread/DLL-specific version of the CRT.
      [Reported by Tobias Rittig]
    - Core library unit tests use GoogleTest instead of CppUnit.

Version 7.1.0 - August 13, 2020

      As of this release, support for grid ABI=4 has been removed.

    New features:
    - Added a novel parallel sparse FastSweeping class that outperforms our
      existing techniques for computing signed distance fields in addition to
      supporting velocity extension.
    - Added tools::fogToSdf which converts a scalar (fog) volume into a signed
      distance field.
    - Added tools::sdfToSdf which re-normalizes a signed distance field;
    - Added tools::fogToExt which extends an arbitrary field (e.g. velocity)
      off the iso-surface of a scalar (fog) volume.
    - Added tools::sdfToExt which extends an arbitrary field (e.g. velocity)
      off the iso-surface of a signed distance field.
    - Added tools::fogToSdfAndExt which computes a signed distance and extends
      an arbitrary field (e.g. velocity) off the iso-surface of a signed
      distance field.
    - Added tools::fogToSdfAndExt which re-normalizes a signed distance and
      extends an arbitrary field (e.g. velocity) off the iso-surface of a
      signed distance field.
    - Added tools::dilateSdf which dilates a signed distance field.
    - Added tools::maskSdf which extends an existing signed distance into a
      user-defined mask.
    - Added Grid::isTreeUnique() to tell if the tree is shared with another
      grid.
    - Added PointDataLeafNode::stealAttributeSet() and
      AttributeSet::removeAttribute() for releasing ownership of attribute
      data.
    - Added AttributeSet::Descriptor::groupIndexCollision() for detecting
      group index collisions when attempting to merge two Descriptors.
    - Added RootNode::childCount(), InternalNode::childCount() and
      LeafNode::childCount() to count the number of immediate child nodes that
      exist below the current node.

    Improvements:
    - Added GroupWriteHandle::setUnsafe() for faster performance when the group
      array is known to be in-core and non-uniform.
    - Add support for default value metadata when creating AttributeArrays or
      appending to an AttributeSet.
    - Added new group inspection methods to the AttributeSet::Descriptor.
    - Introduced a StringMetaCache class for convenient string attribute
      metadata lookup and performed some minor optimizations.
    - Removed redundant floor in points::floatingPointToFixedPoint.
    - Add gitignore to repository root.
    - Removed some logic for compilers older than Visual Studio 2019.
    - Add a new Houdini ABI test binary.
    - Fixed an indexing typo in tools::Filter. [Contributed by Yuanming Hu]
    - Removed redundant null pointer checks. [Contributed by Kuba Roth]
    - Added support for vdb_view on Windows. Requires GLEW.
    - Removed support for GLFW 2.
    - vdb_view now uses OPENVDB_LOG_FATAL when catching exceptions.
    - vdb_view, vdb_print and vdb_render now use std::terminate() when catching
      an unknown exception.
    - Removed Boost::thread as a dependency of vdb_view in favour of
      std::thread.
    - Removed usage of boost/integer.hpp and boost/math/constants/constants.hpp,
      the latter in favour of new openvdb math constants for pi
    - Removed usage of boost/mpl/*.hpp methods in favour of new template
      meta-programming methods on the openvdb::TypeList struct. This now
      supports get, front, back, contains, index, unique, popback, popfront
      and range removal of types.
    - Changed the tree::NodeChain implementation to use an openvdb::TypeList
      rather than a boost::mpl::vector and updated all usage of tree::NodeChain
      accordingly.

    Bug fixes:
    - Fixed a bug where grids with no active values might return true when the
      method evalActiveVoxelBoundingBox is called. The correct behavior is to
      only return true if the grid contains any active values.
    - Fixed a sign propagation bug in tools::traceExteriorBoundaries() used by
      tools::meshToVolume(). This could cause values to not be propagated across
      node boundaries, leading to voxels incorrectly being marked as inside the
      isosurface. [Contributed by Tristan Barback]
    - Fixed a rotation order bug in tools::local_util::decompose()
      that caused it to fail to decompose some matrices.
    - Fixed a bug where math::Quat::inverse() was not marked as const.
      [Contributed by Michael Tao]
    - Fixed a bug in the unit test for util::CpuTimer on Windows by using a
      more accurate sleep implementation.
    - Fixed a bug where the requested uniform value of an AttributeArray was
      not being applied on attribute creation if the default attribute value
      was not the default value for that value type.
    - Fixed a compiler error when using C++17 by changing std::unexpected() to
      std::terminate().
      [Contributed by Mark Sisson]

    API changes:
    - Removed a number of deprecated point methods.
    - points::StringIndexType is now deprecated, use Index instead.
    - PointPartitioner::voxelOffsets() now returns a std::unique_ptr instead of
      a boost::scoped_array.
    - Renamed AttributeSet::Descriptor::nextUnusedGroupOffset() to
      AttributeSet::Descriptor::unusedGroupOffset() to allow for providing an
      optional group offset hint.

    Houdini:
    - Platonic SOP is now verbified.
    - Extend all SOP references to support VDB Points.
    - Combine SOP will not error in flatten-all mode if second has no grids.
    - Changed the label (but not the opname) of Resize Narrow Band SOP to match
      the corresponding native Houdini SOP. The new label is Activate SDF.
    - Fixed a bug by using GEO_Detail::getBBox() instead of
      GEO_Detail::computeQuickBounds() as the latter was incorrectly using the
      point of the VDB when computing bounding box. SOPs affected include Clip,
      Fill, Points Group, Rasterize Points, Read, Remove Divergence.
      [Contributed by Kuba Roth]
    - OpenVDB from Polygons SOP now always displays the vector UI, as otherwise
      it might be stuck hidden if the input hasn't cooked.
    - OpenVDB from Polygons and OpenVDB from Particles SOPs no longer require
      input geometry to have been cooked to offer a choice of attributes,
      the user may now also type in a value.

    Build:
    - Improved the CMake build for the OpenVDB Houdini library on Windows.
      [Reported by Ian Woodward]
    - Remove some logic for compilers older than Visual Studio 2019.
    - Fixed a bug in the CMake FindIlmBase/OpenEXR modules which could cause
      compilers on UNIX systems to fail to find stdlib.h if IlmBase/OpenEXR
      headers were installed to /usr/include.
    - CMake now checks the minimum supported MSVC compiler for Windows.
    - CMake now only requires a CXX compiler.
    - Improved the Windows README instructions and various MSVC warnings.
    - Remove CMake warning when using GLFW 3.2+ on Debian.
    - Various fixes to unary minus on unsigned compiler warnings.
    - The defines _CRT_NONSTDC_NO_WARNINGS and _CRT_SECURE_NO_WARNINGS are now
      enabled by default with MSVC.
    - New CMake option OPENVDB_BUILD_PYTHON_UNITTESTS to disable or enable
      the python module tests and fixed the required environment for them on
      Windows. The python interpreter is no longer required by default if the
      tests are disabled.
    - Improved the CMake user messages when locating python and numpy.
    - The python module extension is now .pyd on Windows.
    - Fixed some build issues with the Houdini plugin on Windows.
    - Standardized the library components install paths for the OpenVDB
      Houdini shared library.
    - Added a USE_PKGCONFIG option to CMake to optionally disable use of
      pkg-config. [Contributed by Kartik Shrivastava]
    - Standardized the dependency search paths in FindPackage modules using
      GNU install paths.
    - Added better library type detection of dependencies through FindPackage
      modules on UNIX.
    - Added missing TBB, OpenEXR and IlmBase defines for static builds on
      Windows through the relevant FindPackage modules.
    - Improved the logic in FindOpenVDB for static builds.
    - Fixed a compiler warning on Apple Clang 11.0 where the AttributeArray
      move constructor was being implicitly deleted despite being marked
      default.
    - Added an option BLOSC_USE_EXTERNAL_SOURCES to FindBlosc to include blosc
      dependencies as interface libraries.
    - Added a root CMake option USE_STATIC_DEPENDENCIES to force CMake to
      only locate static libraries on UNIX. On Windows, if enabled, located
      libraries are assumed to be static.
    - Added support for CMAKE_MSVC_RUNTIME_LIBRARY for compilers that target
      the MSVC ABI. Requires CMake 3.15 or greater.
    - Fixed an issue where OPENVDB_OPENEXR_STATICLIB was not being defined and
      OPENEXR_DLL was being defined when linking against static builds of
      OpenEXR/IlmBase on Windows.
    - Improved the behaviour of boost implicit linking with the
      Boost::disable_autolinking target.
    - Added support for importing pyopenvdb and openvdb_houdini through the
      FindOpenVDB CMake module
    - Removed the OPENVDB_2_ABI_COMPATIBLE and OPENVDB_3_ABI_COMPATIBLE macros.
    - Fixed a few GCC compiler warnings by adding override keywords.
      [Contributed by Edward Lam]
    - jemalloc/tbbmalloc are no longer linked into library artifacts of the
      OpenVDB CMake build. The CONCURRENT_MALLOC CMake option now only applies
      to the executables.
    - Introduced a new OpenVDB::openvdb_je interface target through the
      FindOpenVDB CMake module which adds Jemalloc as a link time dependency.
    - CMake build fix for the vdb_render binary on Windows when building
      statically and using OpenEXR 2.5

Version 7.0.0 - December 6, 2019

      Some changes in this release (see "ABI changes" below) alter
      the grid ABI so that it is incompatible with earlier versions
      of the OpenVDB library, such as the ones built into Houdini
      up to and including Houdini 18.0. To preserve ABI compatibility,
      when compiling OpenVDB or any dependent code define the macro
      OPENVDB_ABI_VERSION_NUMBER=N, where, for example, N is 5 for
      Houdini 17.0 and 17.5 and 6 for Houdini 18.0.

      As of this release, a C++14 compiler is required and the oldest
      supported Houdini version is 17.0.

    New features:
    - LevelSetMeasure can now compute multiple types of curvatures (averge and total
      Gaussian and mean curvature) as well as Euler characteristic and genus of
      level set surfaces.
    - Most stencil classes now have an intersection method that detcts the axial
      directions of zero-crossings (as oppose to the existing boolean intersection test).
    - The CurvatureStencil can now compute Gaussian and principal
      curvatures (in addition to mean curvature).
    - Added Tree::nodeCount, which counts the number and type of nodes
      in a tree very efficiently.
    - Added new RootNode::addChild() and InternalNode::addChild() methods to
      allow the insertion of child nodes directly.

    Improvements:
    - The minimum ABI for OpenVDB is now always enforced through CMake
      separately from other minimum dependency version variables.
    - Added support for CMake 3.12 compatible Xxx_ROOT variables.
    - Replaced the CMake USE_SYSTEM_LIBRARY_PATHS option with
      DISABLE_CMAKE_SEARCH_PATHS and removed the hard coded list of
      SYSTEM_LIBRARY_PATHS in favor of using CMake's default search procedure.
      SYSTEM_LIBRARY_PATHS can still be used as a global list of paths for all
      dependency searches.
    - Improvements to OpenVDB's CMake module setup order in regards to CMake
      policy, minimum version and project calls.
    - Replaced occurrences of boost::scoped_array with std::unique_ptr.
    - Added an OPENVDB_SIMD option to CMake to optionally define SSE4.2 and
      AVX compiler flags, this is switched off by default.
    - Made various small changes to improve Visual Studio compatiblity and
      deprecate some logic for compilers older than Visual Studio 2017.
    - Standardized CMake install locations using GNUInstallDirs. Importantly,
      this changes the default library installation folder from lib to lib64
      on some 64-bit systems, or to lib/multiarch-tuple on Debian
      [Contributed by David Aguilar]
    - Added SIMD intrinsics to a few common NodeMask methods.
      [Contributed by Konstantin]

    Bug fixes:
    - Fixed a bug in FindJemalloc.cmake where paths were not being handled
      correctly.
    - Fixed a Windows build issue in openvdb_render.
    - Fixed a non deterministic threading bug in tools::meshToVolume() during
      polygon voxelization which could result in different distance values.

    ABI changes:
    - OpFactory destructor is now virtual as of ABI=7
    - Added new virtual methods for copying const grids and replacing
      the metadata and/or the transform - GridBase::copyGridReplacingMetadata,
      GridBase::copyGridReplacingTransform and
      GridBase::copyGridReplacingMetadataAndTransform.
    - AttributeArray copy constructor is now thread-safe.

    API changes:
    - VolumeToMesh::pointList() and VolumeToMesh::polygonPoolList() now return
      a std::unique_ptr instead of a boost::scoped_array.
    - AttributeArray::copyUncompressed() is now deprecated.

    Python:
    - Removed the requirement of CMake 3.14 for NumPy usage.
    - Added support for Boost versions 1.65 and later when building
      the Python module with NumPy support through CMake.
    - Improved CMake Python3 support.
    - The Python Module is now disabled by default in CMake.

    Houdini:
    - Fixed a bug in the Points Convert SOP during conversion from
      Houdini geometry to OpenVDB Points, where point group information
      could end up corrupted or cause a crash with non-contiguous
      point offsets (mesh inputs).
    - Threaded the population of point group memberships during conversion
      from Houdini geometry to OpenVDB Points
    - Added logic to the Rasterize Points SOP to suppress the output of
      non-finite attribute values due to subnormal input densities.
    - Introduced a position compression option to the Scatter SOP for VDB
      Points and default to 16-bit fixed point.


Version 6.2.1 - September 30, 2019

    Bug fixes:
    - Fixed a crash that arose from an inadvertent ABI change of an I/O class
      with the 6.2.0 release.  The crash occured when attempting to write out
      a point data grid using an I/O routine from a different version of
      OpenVDB than the one with which the grid was authored and when
      one of those OpenVDB versions was 6.2.0.


Version 6.2.0 - September 18, 2019

    New features:
    - Added tools::FindActiveValues, which counts the active values
      in a tree that intersect a given bounding box.
    - Added io::DelayedLoadMetadata, which stores mask offsets and compression
      sizes on write to accelerate delayed load reading.

    Improvements:
    - LeafNode::modifyValue() and LeafNode::modifyValueAndActiveState()
      now modify voxel values in place for improved performance.
    - Added math::isInfinite() and math::isNan() to resolve Visual Studio
      compatibility issues with integer types.
    - Made minor performance improvements to moving and filtering VDB points.
    - Improved performance related to a mutex contention when appending
      multiple AttributeArrays in parallel through various point operations.
    - Significantly improved the performance of createLevelSetSphere()
      using threading.
    - Improved directory and file path lookups of some CMake commands in
      the root CMakeLists.txt
      [Reported by Daniel Elliott]
    - Improved CMake support for GLFW versions 3.1 and later.
    - FindOpenVDB.cmake now correctly propagates CXX version requirements.
    - Added CMake support for linking against Jemalloc and TBB malloc
      and enabled Jemalloc by default for Linux and non-Maya builds
      and TBB malloc for all other builds.
    - Added a USE_COLORED_OUTPUT option to CMake to display compiler output
      in color.
    - Added an OPENVDB_CODE_COVERAGE option to CMake.
    - CMake now automatically detects and configures the CXX11 ABI requirement
      for Houdini builds.
    - CMake now issues deprecation warnings for 2017 VFX Reference Platform
      version dependencies. In particular, C++11-only compilers are now
      deprecated; OpenVDB 7.0 will require a C++14-compatible compiler.

    Bug fixes:
    - Replaced std::vector with std::deque as the underlying container
      for util::PagedArray, to address a rare crash when reading
      from multiple threads while writing from another thread.
    - Fixed a bug that could cause an empty CoordBBox to report nonzero volume.
    - Fixed a bug in tools::computeScalarPotential() that could produce
      a corrupt result due to invalid memory access.
      [Reported by Edwin Braun]
    - Partially reverted tools::ClosestSurfacePoint's distance calculations
      to their pre-OpenVDB 5.0 behavior to address a bug in the
      fillWithSpheres() tool that caused generated spheres to sometimes
      extend outside the target volume.
    - CMake now correctly sets rpaths for the unit test binary.
    - Addressed a Valgrind warning by allocating the AttributeArray registry
      using a Meyers singleton.
      [Contributed by Autodesk]

    ABI changes:
    - ABI versions 3 and older are now deprecated, and support for them will be
      removed in a future release. Until then, define the macro
      OPENVDB_USE_DEPRECATED_ABI (or set the CMake OPENVDB_USE_DEPRECATED_ABI
      option to ON) to suppress deprecation messages when compiling OpenVDB or
      dependent code.

    API changes:
    - Changed points::RandomLeafFilter::LeafMap from a std::map to
      a std::unordered_map.
    - Removed the TableT template argument from util::PagedArray.
      The table type is now hardcoded to std::deque.
    - The minimum supported version of GLFW is now 3.1.

    Python:
    - CMake now always produces a .so for the Python module on Unix
      and Linux platforms.
    - Fixed a compile-time error when building the Python module for Python 3.
      [Reported by yurivict]

    Houdini:
    - OpenVDB SOPs are now displayed in an ASWF sub-menu of the VDB tab menu.
    - Added API documentation and examples.
    - Added openvdb_houdini::GEOvdbApply(), which invokes a functor
      on a VDB primitive if the resolved grid type is a member of
      a given type list.
    - Fixed a regression in the Fill SOP that caused it to modify VDBs
      in the input detail.
    - The Combine SOP no longer crashes in Copy B mode when the destination
      is not a VDB.
    - Added a houdini_utils::OpFactory::addSpareData() method
      and addOperatorSpareData() and getOperatorSpareData() functions
      to manage spare data associated with operator types.
    - Added an opsparedata HScript command and hou.NodeType.spareData()
      and hou.NodeType.spareDataDict() methods to retrieve spare data
      associated with operator types.
    - Added a pythonrc.py startup script to set the tab menu visibility
      of nodes and their native Houdini equivalents, based on an
      OPENVDB_OPHIDE_POLICY environment variable.
    - Added a houdini_utils::OpFactory::setInvisible() method to hide nodes
      from tab menus.
    - Added an OpenVDBOpFactory::setNativeName() method to pair OpenVDB nodes
      with their native Houdini equivalents.
    - Added a houdini_utils::OpPolicy::getTabSubMenuPath() method to allow
      OpPolicy subclasses to provide their own tab sub-menu path.
    - OpenVDB nodes now override OP_Operator::getVersion() to return
      a version string of the form "vdb6.2.0 houdini18.0.222".


Version 6.1.0 - May 8, 2019

      As of this release, the oldest supported Houdini version is 16.5.

    New features:
    - Added new QuatTraits, MatTraits and ValueTraits type traits to complement
      VecTraits and added an IsSpecializationOf helper metafunction.
    - Added support for Vec4s, Vec4d and Vec4i metadata.
    - Added a generic TypeList class.
    - Added GridBase::apply(), which invokes a functor on a grid
      if the resolved grid type is a member of a given type list.
    - Added util::printTime(), which outputs nicely formatted time information.
    - Added a std::hash<Coord> template specialization.
    - Added CoordBBox::moveMin() and CoordBBox::moveMax() to move a CoordBBox.

    Improvements:
    - util::CpuTimer now makes use of util::printTime() for nicer output,
      and its API has been improved.
    - Significantly improved the performance of point data grid string
      attribute generation.
    - AttributeArray::copy() and the copy assignment operator for
      AttributeArrays are now thread-safe.
    - The command-line tools (vdb_print, etc.) now include the library
      ABI version in their -version output.
    - Further improved the responsiveness of the mesh to volume converter
      to interrupt requests.
    - The CMake build system has been significantly improved to support a
      wider range of build options and use cases. This includes better
      dependency handling and status reporting, find module installation for
      external use, more robust handling of different platform configurations
      and the introduction of dependency and build documentation.

    Bug fixes:
    - Fixed a bug in tools::clip() that caused some grid metadata
      to be discarded.
    - Added a check to points::setGroup to compare the maximum index of the
      provided PointIndexTree to the size of the membership vector.
    - Fixed a race condition introduced in ABI 6 when moving points
      in point data grids, due to non-const access to an AttributArray
      triggering a copy-on-write.
    - Fixed a bug that caused the mesh to volume converter to consume
      unlimited memory when it encountered NaNs in vertex positions.
    - Fixed a rounding error bug in point conversion when using
      single-precision floating-point.
    - Addressed some type conversion issues and other issues reported by GCC 6.
    - Fixed a crash in tools::extractActiveVoxelSegmentMasks() when the first
      leaf node had no active voxels.
      [Reported by Rick Hankins]
    - Fixed a bug in tools::segmentActiveVoxels() and tools::segmentSDF() where
      inactive leaf nodes were only pruned when there was more than one segment.
    - Fixed a crash in point moving when using group filters.
    - Fixed a bug where the stride of existing attributes was being ignored
      during copy-construction of an AttributeSet.
    - Fixed a bug that caused AttributeArray equality operators to fail for
      attributes with non-constant strides.

    API changes:
    - Moved the CopyConstness metafunction from TreeIterator.h to Types.h.

    Houdini:
    - The Points Convert SOP now reports NaN Positions as warnings when
      converting from Houdini Points to VDB Points.
    - Fixed a bug where the Points Convert SOP was incorrectly ignoring
      point attributes with the same name as an existing point group.
    - The Transform SOP now supports frustum transforms by applying the
      transformation to the internal affine map.
    - Changed the labels (but not the opnames) of several SOPs to match
      the corresponding native Houdini SOPs.  The new labels are
      Morph SDF, Project Non-Divergent, Rebuild SDF, Renormalize SDF,
      Reshape SDF, Segment by Connectivity, Smooth SDF, Topology to SDF,
      and Visualize Tree.
    - Added a houdini_utils::OpPolicy::getFirstName() method to allow
      OpPolicy subclasses to provide their own first name scheme.
    - Added a houdini_utils::OpPolicy::getLabelName() method to allow
      OpPolicy subclasses to provide their own label naming scheme
      for tab menus.
    - Added type lists for sets of commonly used grid types, including
      ScalarGridTypes, Vec3GridTypes, AllGridTypes, etc.
    - The Vector Merge SOP now copies metadata from the representative
      scalar grid.
    - Deprecated SOP_NodeVDB::duplicateSourceStealable(),
      houdini_utils::getNodeChain() and houdini_utils::OP_EvalScope.

    Python:
    - Added limited support for point data grids, comprising I/O and
      metadata functionality for now.
    - Added support for Mat4s and Mat4d metadata, in the form of nested
      Python lists (e.g., [[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]]).


Version 6.0.0 - December 18, 2018

      Some changes in this release (see "ABI changes" below) alter
      the grid ABI so that it is incompatible with earlier versions
      of the OpenVDB library, such as the ones built into Houdini
      up to and including Houdini 17.  To preserve ABI compatibility,
      when compiling OpenVDB or any dependent code define the macro
      OPENVDB_ABI_VERSION_NUMBER=N, where, for example, N is 3 for
      Houdini 15, 15.5 and 16, 4 for Houdini 16.5 and 5 for Houdini 17.0

    New features:
    - Added support to the ParticlesToLevelSet tool for fast rasterization
      of particles into boolean mask grids.
    - Added convenience functions particlesToSdf(), particleTrailsToSdf(),
      particlesToMask() and particleTrailsToMask() for common particle
      rasterization use cases.
    - Added batch copying of AttributeArray values that significantly
      outperforms the older method that relied on a virtual function.

    Improvements:
    - Improved the responsiveness of the mesh to volume converter to interrupt
      requests.
    - Attempts to use a partially deserialized AttributeArray now errors.
    - Updated point deletion to use faster batch copying for ABI=6+.
    - Methods relating to in-memory Blosc compression for AttributeArrays now
      do nothing and have been marked deprecated resulting in memory savings
      for ABI=6+.

    Bug fixes:
    - Fixed various signed/unsigned casting issues to resolve compiler warnings
      when moving points in point data grids.

    ABI changes:
    - Added new virtual functions to AttributeArray.
    - Changed the order and size of member variables in AttributeArray
      and TypedAttributeArray.

    API changes:
    - Removed a number of methods that were deprecated in version 5.0.0 or
      earlier.
    - Removed the experimental ValueAccessor::newSetValue method.
    - Deprecated AttributeArray methods relating to in-memory
      Blosc compression.

    Houdini:
    - The Convert and To Polygons SOPs now correctly transfer vertex
      attributes when the output is a polygon soup.
    - Added an option to the Visualize SOP to display leaf nodes as points.
    - Renamed the Visualize SOP's "leafmode", "internalmode", "tilemode"
      and "voxelmode" parameters to "leafstyle", "internalstyle", etc.
      and converted them from ordinal to string-valued.
    - Made various improvements to viewport rendering of point data grids.
    - Added a ParmFactory::setInvisible() method to allow parameters
      to be marked as hidden.  This is useful for multi-parms,
      whose child parameters cannot be made obsolete.
    - Removed the option to use in-memory Blosc compression from the Points
      Convert SOP as this feature has now been deprecated.
    - Made various small changes for Houdini 17 compatibility.


Version 5.2.0 - August 13, 2018

    New features:
    - Added tools to advect points stored in point data grids
      through velocity fields.
      [Contributed by Dan Bailey]
    - For point data grids, voxel data can now be prefetched independently
      of position or other attributes.
      [Contributed by Dan Bailey]
    - Added tools to sample voxel values onto points stored in
      point data grids.
      [Contributed by Double Negative]

    Improvements:
    - The UniformPointScatter tool now generates points in "points per volume"
      mode even when the product of the density and the voxel volume is less
      than one, and the point count now varies continuously with the density.
    - Added a min/max sphere count argument to the fillWithSpheres() tool.
      (The previous version, now deprecated, supported only a maximum
      sphere count.)
    - Added a method to tools::LevelSetTracker to enable and disable
      trimming of voxels outside the narrow band.
      Previously, trimming was always enabled, which caused dense SDFs
      to be converted to narrow-band level sets.
    - Added state() methods to point data index filters to improve
      optimization opportunities.
      [Contributed by Dan Bailey]
    - Added active and inactive value mask point data index filters.
      [Contributed by Dan Bailey]
    - Replaced include/exclude group list parameters with filter functors
      in various point data functions.
      [Contributed by Dan Bailey]
    - Refactored and simplified the point count API.
      [Contributed by Dan Bailey]
    - Computing cumulative per-leaf point offsets is now parallelized.
      [Contributed by Dan Bailey]
    - Made various small changes for Visual Studio 2017 compatibility.
      [Contributed by Edward Lam]

    Bug fixes:
    - Fixed a bug that could cause an infinite loop when iterating over
      an empty root node.
    - Fixed namespace-related bugs in math::Tuple::isZero() and
      math::Mat::isZero() that led to compile-time errors.
    - Fixed type conversion bugs in the vector-to-vector math::rotation()
      function that made it impossible for it to return a single-precision
      rotation matrix, and modified the function to accept Vec3 arguments
      of any value type.
    - Fixed a bug in the mesh to volume converter that made it uninterruptible
      in certain cases even though an interrupter was provided.
      [Reported by Doug Epps]

    Houdini:
    - Added an option to the From Particles SOP to output an
      interior mask grid.
    - Added options to the Metadata SOP to set the grid name
      and to propagate metadata to primitive attributes and vice-versa.
    - Modified GU_PrimVDB::convertVolumesToVDBs() to set the output VDBs'
      grid names to the names of the volume primitives.
    - Added an option to the Offset Level Set, Renormalize Level Set,
      Smooth Level Set, and Resize Narrow Band SOPs to enable and disable
      trimming of voxels outside the narrow band.
      Previously, trimming was always enabled, which caused dense SDFs
      to be converted to narrow-band level sets.
    - Fixed a bug in the Resample SOP that prevented it from reading
      a reference VDB from the second input.
    - Added an option to the Scatter SOP to scatter points only on
      an isosurface of a signed distance field.
    - The Scatter SOP now generates points in Point Density mode even when
      the product of the density and the voxel volume is less than one,
      and the point count now varies continuously with the density.
    - Added a minimum sphere count option to the To Spheres SOP.
    - Added enable/disable toggles to the To Spheres SOP's minimum and maximum
      radius parameters and eliminated the world space radius parameters.
      The remaining minimum and maximum parameters, formerly the voxel space
      radii, are now used in both world unit and voxel unit modes.
    - Added transform and rotation order options to the Transform SOP.
    - Added support to the Advect Points SOP for advecting points stored
      in point data grids.
      [Contributed by Dan Bailey]
    - Added support to the Sample Points SOP for sampling onto points
      stored in point data grids.
      [Contributed by Double Negative]


Version 5.1.0 - April 10, 2018

    New features:
    - Added an option to points::deleteFromGroups() to delete the groups
      as well as the points.
      [Contributed by Nick Avramoussis]
    - Added a header_test Makefile target that checks library header files
      for dependencies on missing or indirectly included headers.
      [Contributed by Dan Bailey]
    - Added support for Mat3s and Mat3d point data typed attributes.
      [Contributed by Dan Bailey]

    Improvements:
    - Added per-test timings to vdb_test to help in identifying
      performance regressions.
    - zeroVal() now returns a zero matrix instead of an identity matrix
      for Mat4s and Mat4d, and it is now also defined (and returns
      a zero matrix) for Mat3s and Mat3d.

    Python:
    - Fixed a bug introduced in version 3.2.0 that caused boolean and integer
      values added to a grid's metadata to be stored as floating-point values.

    Houdini:
    - Added options to the Clip SOP to expand or shrink the clipping region
      and, when clipping to a camera frustum, to set the near and far
      clipping planes.
    - Added output grid naming options to the Points Convert SOP.
    - Added a Keep Original Geometry toggle to the Points Convert SOP
      and improved the efficiency of point unpacking.
      [Contributed by Dan Bailey]
    - Added an option to the Points Delete SOP to delete point groups.
      [Contributed by Nick Avramoussis]
    - Fixed a rare crash when extracting points from a point data primitive.
      [Contributed by Jeff Lait]
    - Added a SOP_NodeVDB::evalStdString() method that facilitates
      string parameter evaluation in expressions, e.g.,
      matchGroup(*gdp, evalStdString("group", time)).
    - Removed the deprecated openvdb_houdini::validateGeometry() function.
      Use convertGeometry() instead.
    - Added a SOP_NodeVDB::matchGroup() overload that eliminates the need
      to const_cast the GU_Detail.
      [Contributed by Jeff Lait]
    - Grid transforms are now more aggressively simplified, making it
      less likely to produce nonuniform voxels erroneously.
      [Contributed by Jeff Lait]
    - Fixed a bug when copying and pasting a Create SOP that could cause
      the Voxel Size toggle to change state.
    - Added a houdini_utils::OpFactory::setVerb() method to register
      compilable SOPs.
    - Made SOP_NodeVDB::cookMySop() final (that is, non-overridable)
      to facilitate the implementation of compilable SOPs.
      Override SOP_NodeVDB::cookVDBSop() instead.  (In most cases,
      it suffices to rename cookMySop to cookVDBSop.)
    - Renamed some parameters on the following SOPs to match the equivalent
      native Houdini nodes: Advect, Advect Points, Analysis, Combine, Filter,
      Fracture, From Particles, From Polygons, Morph Level Set,
      Occlusion Mask, Offset Level Set, Points Group, Resample,
      Resize Narrow Band, Smooth Level Set, Topology To Level Set,
      Vector Merge, and Visualize.
    - Added SOP_VDBCacheOptions, a convenience base class for compilable SOPs.
      [Contributed by Jeff Lait]
    - Converted most SOPs into compilable SOPs.


Version 5.0.0 - November 6, 2017

      Some changes in this release (see "ABI changes" below) alter
      the grid ABI so that it is incompatible with earlier versions
      of the OpenVDB library, such as the ones built into Houdini
      up to and including Houdini 16.  To preserve ABI compatibility,
      when compiling OpenVDB or any dependent code define the macro
      OPENVDB_ABI_VERSION_NUMBER=N, where, for example, N is 3 for
      Houdini 15, 15.5 and 16 and 4 for Houdini 16.5.

    New features:
    - Added a getLibraryAbiVersionString() function, which returns a
      string such as "5.0.0abi3".
    - Added a WeakPtr type alias for ABI compatibility.
    - Metadata fields of unregistered types are no longer discarded after
      being read from a .vdb file, and although their values are not printable,
      they can be written back to disk.
    - Added a DESTDIR_LIB_DIR Makefile variable for Linux multiarch support.
      [Contributed by Mathieu Malaterre]
    - Added tools to create potential flow fields, as described in the
      2017 SIGGRAPH OpenVDB course.
      [Contributed by Double Negative]
    - Added tools to create mask grids from point data grids and to compute
      point counts.
      [Contributed by Dan Bailey]
    - Added tools to scatter OpenVDB points randomly throughout a volume.
      [Contributed by Nick Avramoussis]

    Improvements:
    - Significantly improved the performance of point data grid group filters.
      [Contributed by Double Negative]

    Bug fixes:
    - Fixed bugs in tools::ClosestSurfacePoint's distance calculations
      that caused searches to produce incorrect results.
    - Fixed a locking issue that affected multithreaded access to
      PointDataLeafNodes when delayed loading was in effect.
      [Contributed by Dan Bailey]

    ABI changes:
    - Made tree::InternalNode's destructor non-virtual.
    - The fix for a delayed-loading race condition in the LeafBuffer class
      that was only partially rolled out in the previous release is now
      enabled on all platforms.
    - Replaced a points::AttributeArray bit flag with an atomic integer
      to address a threading issue during delayed loading.
      [Contributed by Dan Bailey]
    - Deprecated the OPENVDB_2_ABI_COMPATIBLE and OPENVDB_3_ABI_COMPATIBLE
      macros in favor of a new OPENVDB_ABI_VERSION_NUMBER macro.
      The new macro defaults to the library major version number but can be
      set at compile time to an earlier version number to disable ABI changes
      since that version.  (Older ABIs will not be supported indefinitely,
      however.)  For example, compile OpenVDB and any dependent code
      with "-DOPENVDB_ABI_VERSION_NUMBER=4" to use the 4.x ABI.

    API changes:
    - Replaced tools::ClosestSurfacePoint::initialize() with
      tools::ClosestSurfacePoint::create(), which returns a newly-allocated
      and properly initialized object.
    - Removed methods that were deprecated in version 4.0.0 or earlier,
      including io::File::readGridPartial(), points::initialize(),
      points::uninitialize() and util::PagedArray::pop_back().
    - Deprecated IllegalValueException in favor of ValueError.
    - Changed the naming scheme for the library namespace from
      openvdb::vX_Y_Z to openvdb::vX_YabiN, where X, Y, Z and N are
      the major, minor, patch and ABI version numbers, respectively.
      The abiN suffix is added only when the library is built using
      an older ABI version.

    Python:
    - Reimplemented NumPy support for Boost 1.65 compatibility.

    Houdini:
    - Fixed bugs that caused the Ray SOP's closest surface point searches
      to produce incorrect results.
    - Changed the VdbPrimCIterator::FilterFunc type from boost::function
      to std::function.
    - Changed the houdini_utils::OpPolicyPtr type from boost:shared_ptr
      to std::shared_ptr.
    - Debug-level log messages generated by OpenVDB are no longer forwarded
      to Houdini's error manager.
    - Fixed a bug in the Read SOP that made it impossible to select among
      grids of the same name in a file.
    - Added houdini_utils::ParmFactory::setAttrChoiceList(), a convenience
      method for the creation of menus of attributes.
    - Added a Potential Flow SOP.
      [Contributed by Double Negative]
    - Added point data grid support to the Scatter SOP.
      [Contributed by Nick Avramoussis]
    - Added mask and point count output options to the Points Convert SOP.
      [Contributed by Dan Bailey]


Version 4.0.2 - July 28, 2017

    New features:
    - Added tools::compActiveLeafVoxels(), which composites active
      voxel values from a source tree into a destination tree.
      It is threaded and faster than existing tools that merge trees,
      however it operates only on leaf nodes.
    - Added a vdb_test -f option that reads a list of tests to be run
      from a text file.
    - Added functions for deleting points from point data grids based on
      group membership.
      [Contributed by Double Negative]
    - Enabled display of point data grids in vdb_view.
      [Contributed by Nick Avramoussis]
    - Added a view mode indicator to vdb_view.
    - Added isFinite(), isInfinite(), isNan(), and isZero() methods
      to math::Mat and added isZero() to math::Tuple.
    - Added tools::interiorMask(), which constructs a boolean mask grid
      from the active voxels of an input grid or, if the input grid is
      a level set, from the interior voxels of the level set.
    - Added begin() and end() iterator methods (and related methods)
      to math::CoordBBox, so that it can be used in range-based for loops.
    - tools::clip() now accepts either a box, a mask grid or a camera frustum
      as the clipping region.  The latter is new in this version.

    Improvements:
    - Moved the isFinite(), isInfinite() and isNan() methods from
      math::Vec3 et al. to math::Tuple.

    Bug fixes:
    - Fixed a delayed-loading race condition that could result in crashes.
      [Reported by Dan Bailey]

      To preserve ABI compatibility, this fix is currently enabled only
      on platforms for which the alignment of a tbb::atomic<uint32_t>
      is the same as for a uint32_t.  On other platforms, warnings will
      be logged during OpenVDB initialization, and it is recommended
      to disable delayed loading in that case (for example, by defining
      the environment variable OPENVDB_DISABLE_DELAYED_LOAD).

    - Fixed a delayed-loading memory leak in the PointDataLeafNode.
      [Contributed by Double Negative]
    - Changed the random number seeding mechanism for .vdb file UUIDs
      to avoid duplicate IDs.
      [Reported by Jason Lefley]
    - Fixed an off-by-one bug in the resampler that produced grid patterns
      of missing interior voxels for scale factors greater than one.

    Houdini:
    - As of Houdini 16.0.549, houdini_utils::OpFactory can generate help cards
      for operators automatically.  New OpFactory::setDocumentation() and
      ParmFactory::setDocumentation() methods allow one to add custom
      help text in wiki markup format.
    - Added help cards for all SOPs.  Houdini 16.0.578 or later is required.
      [Contributed by Dan Bailey and SideFX]
    - The Extended Operator Info window in Houdini 16 now renders correctly
      for OpenVDB SOPs, instead of displaying a Python stack trace.
      [Contributed by Dan Bailey]
    - Added a Points Delete SOP for deleting points from point data grids
      based on group membership.
      [Contributed by Double Negative]
    - Added a Mantra VRAY procedural and a delayed load SHOP for rendering
      point data grids.  Houdini 16 is required.
      [Contributed by Double Negative]
    - Replaced the Combine SOP's "A/B Pairs" and "Flatten" toggles with
      a menu of collation options that include flattening only A grids
      and flattening groups of A grids independently.
    - Added a slider to the Remove Divergence SOP to set the error tolerance
      for the pressure solver.
    - Added value type conversion options (for VDB output) to the Convert SOP.
    - Added a Densify SOP that replaces active tiles with leaf voxels.
    - Fixed a bug in the Rasterize Points SOP that capped density values
      to one instead of to the particles' densities.
    - The Convert and To Polygons SOPs now accept grids of any type
      as surface masks, not just level set or SDF grids.
    - Added an option to the Clip SOP to clip to a camera frustum.


Version 4.0.1 - March 8, 2017

    New features:
    - Added functions to util/logging.h to simplify configuration of the
      logging system (via command-line arguments, in particular).
    - Added LeafManager::activeLeafVoxelCount(), a faster, threaded
      alternative to Tree::activeLeafVoxelCount().
    - Added a -shuffle option that causes vdb_test to run unit tests
      in random order, which can help to identify unintended dependencies
      between tests.
    - Added vdb_lod, a command-line tool to generate volume mipmaps
      for level-of-detail effects.
    - Added methods to compute the median value of active, inactive or all
      voxels in leaf nodes.

    Improvements:
    - Added a Metadata::str() specialization for StringMetadata that
      eliminates the overhead of writing to a string stream.
    - Made various minor improvements to util::PagedArray.
    - Added an install_lib build target to the Makefile.
      [Contributed by Double Negative]
    - Added documentation and Cookbook examples for OpenVDB Points.
      [Contributed by Double Negative]
    - Registration of OpenVDB Points grid and attribute types is now handled
      in openvdb::initialize(), and openvdb::points::initialize() and
      openvdb::points::uninitialize() are therefore deprecated.
    - Extended multi-pass I/O to handle a variable number of passes
      per leaf node.
      [Contributed by Double Negative]
    - Addressed a name conflict between macros in util/NodeMasks.h
      and symbols in the Eigen library.
      [Reported by Trevor Thomson]

    Bug fixes:
    - tools::fillWithSpheres() and tools::ClosestSurfacePoint now correctly
      handle isosurfaces outside the input volume's narrow band.
    - tools::MultiResGrid now supports all standard grid types, including
      BoolGrid and MaskGrid.
    - LeafNode::fill() now correctly clips the fill region to the node's
      bounding box.
    - Grid::denseFill() no longer densifies all existing active tiles,
      and it now correctly handles both active and inactive fill values.
    - Fixed a bug that caused tools::copyToDense() to only partially populate
      the output array when delayed loading was in effect.
      [Reported by Stuart Levy]
    - Fixed an issue with duplicate registration of PointDataGrid
      attribute types.
      [Reported by SideFX]
    - Fixed an uninitialized memory bug in tools::meshToVolume().
      [Reported by SideFX]
    - Fixed a thread race condition in math::QuantizedUnitVec that could
      cause it to produce incorrect results.
      [Contributed by Jeff Lait]
    - Fixed a dangling pointer bug in tools::ParticleAtlas.
      [Contributed by SideFX]
    - Grid operators (divergence, gradient, etc.) now produce correct results
      even for grids with active tile values.
    - Fixed a bug when writing an out-of-core points::AttributeArray
      that could cause corruption of the metadata associated with the array.
      [Contributed by Double Negative]

    Python:
    - Added functions getLoggingLevel(), setLoggingLevel(), and
      setProgramName(), to allow configuration of the logging system.

    Houdini:
    - Fixed a crash in the Ray SOP when the user selected an isosurface
      outside the target volume's narrow band.
    - The LOD SOP now supports all standard grid types, including
      boolean grids.
    - Added houdini_utils::ParmFactory::setGroupChoiceList(), a convenience
      method for the creation of menus of primitive groups.
    - Made various small changes for Houdini 16 compatibility.
      [Contributed by SideFX]
    - The Create SOP now supports matching the new grids' transform,
      voxel size, and topology to a reference grid.  If the topology is
      being matched, it can optionally be resampled to a different voxel size.
    - Added some support for point data grids to the Clip,
      Topology To Level Set and Visualize SOPs.
      [Contributed by Double Negative]
    - Compression is no longer enabled by default in the Points Convert SOP
      for normals and colors, because they are not guaranteed to have a
      [0, 1] range.
      [Contributed by Double Negative]
    - Added a 16-bit truncation compression option to the Points Convert SOP.
      [Contributed by Double Negative]
    - Fixed a build issue with the GR_PrimVDBPoints render hook plugin
      that could cause hython to report a DSO error.
      [Reported by Double Negative]
    - Added an install_lib build target to the Makefile.
    - Rewrote the Remove Divergence SOP to actually remove divergence from
      vector fields on collocated grids, and added support for stationary
      and moving obstacles and an option to output a pressure field.
    - The Analysis SOP now produces correct results for grids with active
      tile values.
    - Added a sparse/dense toggle to the Fill SOP.
    - Added openvdb_houdini::startLogForwarding(), stopLogForwarding()
      and isLogForwarding(), which control the forwarding of log messages
      to Houdini's error manager.  Forwarding of library warnings and
      error messages is now enabled by default for SOPs when OpenVDB
      is built with log4cplus.


Version 4.0.0 - November 15, 2016

    Highlights:
    - Incorporated Double Negative's OpenVDB Points library.
      See https://github.com/dneg/openvdb_points_dev for details.
    - Introduced some C++11 constructs.  A C++11-compatible compiler
      is now required.
    - Blosc-compressed .vdb files are now as much as 20% smaller.
    - Vector-valued grids are now constructed and destroyed much faster.

      This change and other changes in this release (see "ABI changes" below)
      alter the grid ABI so that it is incompatible with earlier versions of
      the OpenVDB library, such as the ones in Houdini 15, 15.5 and 16.
      To disable these changes and preserve ABI compatibility, define
      the macro OPENVDB_3_ABI_COMPATIBLE when compiling OpenVDB
      or any code that depends on OpenVDB.

    New features:
    - Added an option to the point scattering tools to specify how far
      each point may be displaced from the center of its host voxel or tile.
    - Added a toggle to tools::clip() to invert the clipping mask.
    - Custom leaf node implementations may now optimize their file layout
      by inheriting from io::MultiPass.  Voxel data for grids with such
      leaf nodes will be written and read in multiple passes, allowing
      blocks of related data to be stored contiguously.
      [Contributed by Double Negative]
    - Added Tree::unallocatedLeafCount(), which returns the number of leaf
      nodes with unallocated data buffers (typically due to delayed loading).

    Improvements:
    - Vector-valued grids are now constructed and destroyed much faster.
    - Changed math::Coord's data representation to facilitate C++11
      uniform initialization.
    - Delayed loading from io::Files is now faster due to the use of seeks
      instead of reads.
      [Contributed by Double Negative]
    - Made many small changes to address type conversion and other warnings
      reported by newer compilers, including Clang 3.8.
    - Improved Blosc compression ratios and write times by increasing
      the block size.
      [Contributed by Dan Bailey]

    Bug fixes:
    - Fixed a bug that caused topology operations (union, intersection
      and difference) on MaskGrids to sometimes produce incorrect results.
      (MaskGrids are used internally in a number of tools.)
    - Changed GridBase::copyGrid() and Grid::copy() to close
      const-correctness holes.
    - tools::fillWithSpheres() now returns an empty list of spheres
      instead of crashing when the user selects an isosurface that lies
      outside the bounding volume's narrow band.
    - Fixed a null pointer dereference when copying grids that were loaded
      with io::File::readGridPartial().
      [Reported by Nick Avramoussis]

    ABI changes:
    - Added a NodeUnion template specialization for non-POD value types
      that significantly expedites construction and destruction
      of vector-valued grids.
    - Changed math::Coord's internal data representation.
    - Replaced occurrences of boost::shared_ptr with std::shared_ptr.
    - Changed GridBase::copyGrid() and Grid::copy() to close
      const-correctness holes.
    - Added virtual function Tree::unallocatedLeafCount().

    API changes:
    - Introduced some C++11 constructs.  A C++11-compatible compiler
      is now required.
    - Added a parameter to the point scattering tools to control the
      displacement of each point from the center of its host voxel or tile.
      The default behavior, as before, is to allow each point to be placed
      (randomly) anywhere within its voxel or tile.
    - Renamed LeafManager::getPreFixSum() to LeafManager::getPrefixSum().
    - Made LeafNode::Buffer a top-level class and renamed it to LeafBuffer.
      [Contributed by Double Negative]
    - Deprecated io::File::readGridPartial() in favor of delayed loading.
    - tools::ClosestSurfacePoint::initialize() now returns a boolean
      indicating whether initialization was successful.
    - Dropped the CopyPolicy enum and added GridBase::copyGridWithNewTree()
      and Grid::copyWithNewTree() in order to close const-correctness holes
      that allowed newly-constructed, non-const grids to share their trees
      with existing const grids.  (Where that behavior is still required,
      use a ConstPtrCast.)

    Python:
    - Fixed a build issue with Python 3 and NumPy.
      [Contributed by Jonathan Scruggs]

    Houdini:
    - Certain changes in this release (see "ABI changes" above) alter
      the grid ABI so that it is incompatible with earlier versions of the
      OpenVDB library, such as the ones built into Houdini 15, 15.5 and 16.
      To disable these changes and preserve ABI compatibility, define
      the macro OPENVDB_3_ABI_COMPATIBLE when compiling OpenVDB
      or any code that depends on OpenVDB.
    - Introduced some C++11 constructs that are incompatible with
      versions of Houdini older than 15.0.
    - Fixed a bug in the Rasterize Points SOP that caused vector-valued
      attributes to be transferred as scalars.
      [Contributed by Double Negative]
    - Added a toggle to the Clip SOP to invert the clipping mask.
    - Added a slider to the Scatter SOP to specify how far each point
      may be displaced from the center of its host voxel or tile.


Version 3.2.0 - August 10, 2016

    Highlights:
    - New features: tool to produce and store a sequences of progressively
      lower resolution grids (mipmaps), an acceleration structure for fast
      range and nearest-neighbor searches on particles, arbitrary volume
      and level set specific segmentation tools, a new binary mask grid
      type and an efficient point to level set conversion scheme.
    - Optimizations: Faster volume to mesh conversion and threaded grid
      destruction, morphological dilation, csg operations and fracture tool.
    - New Houdini nodes: Segment, LOD and Topology To Level Set.

    New features:
    - Added tools::MultiResGrid a tool to produce and store a sequences
      of progressively lower resolution grids (mipmaps).
    - Added tools::ParticleAtlas an acceleration structure for fast range
      and nearest-neighbor searches on particles, points with radius.
    - Added tools::segmentActiveVoxels(), which operates on grids of arbitrary
      type and separates connected components of a grid's active voxels into
      distinct grids or trees.
    - Added tools::segmentSDF(), which separates disjoint signed-distance-field
      surfaces into distinct grids or trees.
    - Added tools::extractActiveVoxelSegmentMasks(), which constructs a mask
      for each connected component of a grid's active voxels.
    - Added threaded level-set CSG tools csgUnionCopy(), csgIntersectionCopy()
      and csgDifferenceCopy(), which, unlike the existing CSG tools, produce
      new grids rather than modifying their input grids.  These new tools are
      faster and use less memory than the existing tools (if only because the
      input grids never need to be deep-copied).
    - Added a threaded dilateActiveValues() tool with tile value support.
    - Added tools::PointsToMask, which activates voxels that intersect
      points from a given list.
    - Added a new MaskGrid type that uses a single bit-field to represent both
      voxel values and states for the leafnode to reduce memory usage.
    - Added tools::topologyToLevelSet(), which generates a level set from the
      implicit boundary between active and inactive voxels in an input grid
      of arbitrary type.
    - Added tools::LevelSetPlatonic a new tool that produces narrow-band
      level sets of the five Platonic solids.
    - Added tools::extractIsosurfaceMask() which masks voxels that intersect
      the implicit surface defined by the given isovalue.
    - Added tree::LeafManager::getPreFixSum() for user-managed external buffers.
    - Added tools::Dense::print().
    - Added the math::CoordBBox::Iterator class to conveniently iterate over
      coordinates covered a CoordBBox.
    - Added bit-wise operations, a component-wise constructor, and a
      getCornerPoints() method to the CoordBBox class.
    - Added a new LeafManager constructor to create the structure from an
      existing array of leafnodes.
    - Added the templated math::MinMax class to compute the extrema of
      arbitrary value types.
    - Added sparseFill and denseFill methods to the Grid, Tree and RootNode classes.

    Improvements:
    - Complete overhaul of the VolumeToMesh tool brings significant performance
      improvements and enhanced region masking, tile support and bool volume
      surfacing.
    - Improved the performance, parallel scaling and memory usage,
      of tools::LevelSetFracture and updated to use the new segmentSDF scheme.
    - Improved the performance of tools::LevelSetAdvection by up to five times.
    - Improved the performance of Tree::voxelizeActiveTiles by means of
      multithreading.
    - Improved the performance of tools::meshToVolume(), particularly for
      large narrow-band widths and for signed distance fields with dense
      interior regions.
    - Threaded the Tree destructor and the Tree::clear() method.
    - Added a parameter to tools::signedFloodFill() and to
      tools::signedFloodFillWithValues() to constrain the flood fill
      to specific levels of the tree.
    - Added active tile count to Tree::print.
    - Improved the API of tools::Dense with non-const access methods.
    - Added LeafManager::reduce and similar methods to NodeManager.
      [Contributed by Brett Tully]
    - Improved constructors of math::Mat3 and math::Mat4.
    - Added math::Mat3::cofactor().
    - Added math::Mat3::setRows, math::Mat4::setRows,
      math::Mat3::setColumns Mat3::setColumns, and
      math::Mat4::setColumns.
    - Added util::NodeMask::isConstant method for faster bit processing.
    - For better robustness, tools::Prune now uses the median of voxel values
      when replacing voxels with a tile.
    - Added a toggle to tools::PointPartitioner to select between
      cell-centered and node-centered transforms.

    Bug fixes:
    - Fixed a bug in tools::LevelSetAdvection that could cause
      non-deterministic behavior.
      [Reported by Jeff Lait]
    - Fixed a bug that allowed for unexpected implicit conversion
      between grids of different value types.
    - Fixed a bug whereby the origins of leaf nodes with value type bool
      were ignored during equality comparisons.
    - tools::GridTransformer now correctly handles affine transforms with
      shear and/or reflection.
    - Fixed a bug in tools::meshToVolume() that could produce
      incorrect distances for large narrow-band widths.
    - Fixed a bug in tools::meshToVolume() that produced different results on
      machines with different core counts.
    - Fixed a threading bug in tools::compReplace() that could cause crashes.
    - Resolved a floating-point exception in math::QuantizedUnitVec::pack()
      caused by calling the method with a zero-length vector.
      [Contributed by Rick Hankins]
    - Fixed a potential threading bug in io::Queue.
      [Contributed by Josip Sumecki]
    - Fixed a possible division-by-zero bug in openvdb/tools/LevelSetAdvect.h.
      [Contributed by Rick Hankins]
    - Corrected the outer product method to not return the transpose result.
      [Contributed by Gergely Klar]
    - Fixed a memory overallocation issue in tools::VolumeAdvect.
    - Fix bug in tools::VolumeToMesh failing to clear its state when exiting
      early.
      [Contributed by Edward Lam]
    - Fixed bug in tools::PointIndexIterator::worldSpaceSearchAndUpdate
      that resulted in missing point indices.
      [Reported by Rick Hankins]
    - Fixed Windows build issues in unit tests.
      [Contributed by Edward Lam and Steven Caron]
    - Fixed isApproxZero() so that it works correctly when tolerance is zero.
      [Reported by Joshua Olson]
    - Fixed bugs in tree::NodeUnion that could cause crashes.
    - Fixed memory leak in a tools::meshToVolume sub-tool (expandNarrowband).
      [Reported by Kévin Dietrich]
    - Fixed parameter type inconsistencies in math/Stencils.h and
      tools/RayIntersector.h.
      [Contributed by Kévin Dietrich and Nick Avramoussis]
    - Fixed a bug in the VolumeToMesh tool that produced artifacts for
      adaptive surface extraction on clipped level sets.
      [Reported by Jeff Lait]
    - Corrected empty grid background value in tools::meshToVolume().
      [Contributed by Jeff Lait]
    - Fixed a bug in tools::volumeToMesh that could produce NaNs.
      [Reported by Rick Hankins]
    - Fixed a bug in the "Advect Points SOP" that could cause a crash when
      the input grids were of incorrect type.
      [Reported by SideFX]

    API changes:
    - Deprecated math::Mat3::setBasis and math::Mat4::setBasis.
    - Renamed math::GudonovsNormSqrd to math::GodunovsNormSqrd
      [Contributed by Branislav Radjenovic]
    - Renamed ValueType to PosType in the PointArray interface.
    - Deprecated tree::Tree::addLeaf(LeafNode&) and added
      tree::Tree::addLeaf(LeafNode*).

    Python:
    - Updated the Python module for Python 3 compatibility.
    - Updated the Python module for Boost 1.60 compatibility, to address
      "no to_python (by-value) converter found" exceptions.

    Maya:
    - Fixed bugs related to data ownership, and improved error checking.
      [Contributed by Crawford Doran]
    - Updated the Read and Write DAG nodes to support file sequences
      and subframe evaluation.

    Houdini:
    - Added a Segment SOP that separates a grid's connected components
      into distinct grids.
    - Added a LOD SOP that produces a sequences of progressively lower
      resolution grids.
    - Added a Topology To Level Set SOP that generates a narrow-band
      signed distance field / level set from the interface between active
      and inactive voxels in an arbitrary grid.
    - Revamped the From Particles SOP UI and added a more efficient
      level set conversion method that supports Houdini 15 packed points.
    - Updated the Rasterize Points SOP with support for frustum transforms,
      sub region masking and orientation logic that matches the native
      Copy SOP's orientation.
    - Updated the Platonic SOP with support for all five Platonic solids.
    - Added hooks for registering SOP_NodeVDB text callbacks for different
      grid types.
      [Contributed by Nick Avramoussis]
    - The Resample and Combine SOPs now correctly handle affine transforms
      with shear and/or reflection.
    - Removed the StaggeredBoxSampler code path in SOP_OpenVDB_Advect because
      it introduces bias.
      [Contributed by Fredrik Salomonsson]
    - Fixed a bug in the Ray SOP whereby the distance attribute was created
      with the wrong data type.
      [Contributed by Nick Avramoussis]
    - The From Polygon SOP now allows the user to either specify the voxel
      count along an axis or the voxel size in world units (the only option
      in the past).


Version 3.1.0 - October 1, 2015

    Highlights:
    - New features: advection of arbitrary volumes, general-purpose
      preconditioned linear solver and Poisson solver, segmentation
      of topologically-enclosed regions of a volume, new and faster
      bitmask operators, concurrent paged array, volume diagnostics
    - Optimizations: threaded grid constructors and topology operations;
      faster mesh to volume conversion, SDF to fog volume conversion
      and grid pruning; faster, unbounded particle partitioning
    - New Houdini nodes: Advect, Diagnostics, Rasterize Points, Remap,
      Remove Divergence, Sort Points

    New features:
    - Added tools::VolumeAdvection, for sparse advection of non-level-set
      volumes.
    - Added a preconditioned conjugate gradient solver.
    - Added a Poisson solver for functions sampled on grids.
    - Added tools::extractEnclosedRegion, which detects topologically-enclosed
      (watertight) exterior regions (cavities) that can result from CSG union
      operations between level sets with concavities that are capped.
      (See the unit test TestPoissonSolver::testSolveWithSegmentDomain
      for an example in which this tool is used to identify regions of trapped
      fluid when solving for pressure in a volume of incompressible fluid.)
    - Added util::PagedArray, a concurrent, dynamic linear array data
      structure with fast O(1) value access (both random and sequential).
    - Added tools::Sampler, which provides a unified API for both staggered
      and non-staggered interpolation of various orders.
    - Added equality and inequality operators to Metadata and MetaMap.
    - Added tools::CheckLevelSet and tools::CheckFogVolume, which perform
      various tests on symmetric, narrow-band level sets and fog volumes,
      respectively, to diagnose potential issues.
    - Added support for value accessors that aren't registered with their trees.
      (Bypassing accessor registration can improve performance in rare cases
      but should be used with caution, since the accessor will be left in an
      invalid state if the tree topology is modified.)
    - Added a tree::stealNodes() method that transfers ownership of all nodes
      of a certain type and inserts them into a linear array.
    - Added a tools::createLevelSetBox() factory function for level-set grids.
    - Added tools::Dense::offsetToCoord().
    - Added LeafNode::Buffer::data(), which provides direct access to
      a leaf node's voxel value array, avoiding out-of-core overhead.
      Use with caution.
    - Added a util::NodeMask::foreach() method for efficient evaluation
      of complex bitwise operations.
    - Added a bitwise difference method to util::NodeMask.
    - Added a -version flag to vdb_print, vdb_render and vdb_view.

    Improvements:
    - Deep, conversion and topology copy Grid constructors are now threaded
      and up to five times faster.
    - Grid::topologyUnion(), Grid::topologyIntersection() and
      Grid::topologyDifference() are now much faster due to threading.
    - Significantly improved the performance, parallel scaling and memory
      usage of the tools::meshToVolume(), and implemented a more robust
      inside/outside sign classification scheme.
    - Reimplemented tools::PointPartitioner for improved performance,
      concurrency and memory usage.  The tool is now unbounded in the sense
      that points may be distributed anywhere in index space.
    - Significantly improved the performance of tools::sdfToFogVolume().
    - Significantly improved the performance of the tools::sdfInteriorMask()
      and added support for both grid and tree inputs.
    - Made various optimizations and improvements to tools::LevelSetMorphing.
    - Aggregated tools::DiscreteField and tools::EnrightField (formerly in
      tools/LevelSetAdvect.h) and tools::VelocitySampler and
      tools::VelocityIntegrator (formerly in tools/PointAdvect.h) into
      a single header, tools/VelocityFields.h.
    - Modified tools::signedFloodFill() to accept grids of any signed
      scalar value type, not just floating-point grids.
    - tools::prune() is now faster, and it employs an improved compression
      technique on trees with floating-point values.

    Bug fixes:
    - Fixed a build issue that could result in spurious "Blosc encoding
      is not supported" errors unless OPENVDB_USE_BLOSC was #defined
      when compiling client code.
    - Added NaN and inf checks to tools::PointPartitioner.
    - Fixed a vdb_view issue whereby the frame buffer size did not
      necessarily match the window size.
      [Contributed by Rafael Campos]
    - Fixed a roundoff issue in tools::LevelSetTracker that could
      result in NaNs.
    - Changed tools::CheckNormGrad to check the magnitude of the gradient
      rather than the square of the magnitude.
    - Fixed parameter type inconsistencies in math/Ray.h and
      tools/RayIntersector.h.
      [Contributed by Kévin Dietrich]
    - Fixed incorrect handling of signed values in tools::clip()
      (and the Clip SOP).

    API changes:
    - Removed the math::Hermite class since it was no longer used
      and caused build issues for some.
    - Refactored the LevelSetAdvection, LevelSetFilter, LevelSetMeasure
      and LevelSetTracker tools.
    - Extended the API of tools::Diagnose and disabled copy construction.
    - Extended and unified the API of various Samplers.
    - Added an optional template argument to the ValueAccessor class
      to allow for unregistered accessors.

    Houdini:
    - Added a Rasterize Points SOP that produces density volumes and
      transfers arbitrary point attributes using a weighted-average scheme.
      The node incorporates a VOP subnetwork for procedural modeling,
      and its accompanying creation script defines a default network
      with VEX procedures for cloud and velocity field modeling.
      (See the creation script file header for installation details.)
    - Merged the Advect Level Set SOP into a new Advect SOP that
      supports advection of arbitrary volumes, not just level sets.
    - Added a Remove Divergence SOP that eliminates divergence from a
      velocity field.
    - Added a Diagnostics SOP that can identify various problems with
      level sets, fog volumes and other grids.
    - Added a Sort Points SOP that spatially reorders a list of points
      so that points that are close together in space are also close together
      in the list.  This can improve CPU cache coherency and performance
      for random-access operations.
    - Added a Remap SOP that maps voxel values in an input range to values
      in an output range through a user-defined transfer function.
    - Added an option to the Convert SOP to activate interior voxels.
      [Contributed by SESI]
    - The To Spheres SOP can now optionally output a pscale attribute.
    - Added openvdb_houdini::SOP_NodeVDB::duplicateSourceStealable(),
      which in conjunction with the Unload flag can help to minimize
      deep copying of grids between nodes.  The Advect, Convert, Fill, Filter,
      Fracture, Noise, Offset Level Set, Prune, Remap, Remove Divergence,
      Renormalize Level Set, Resize Narrow Band, Smooth Level Set and
      Transform SOPs all have this optimization enabled, meaning that
      they can potentially steal, rather than copy, data from upstream nodes
      that have the Unload flag enabled.
      [Contributed by Double Negative]
    - Redesigned the UI of the Visualize SOP and added toggles to draw with
      or without color, to use the grid name as the attribute name for points
      with values, and to attach grid index coordinates to points.
    - Added toggles to the Filter, Rebuild Level Set, Resize Narrow Band,
      Smooth Level Set and To Spheres SOPs to specify units in either
      world space or index space.
    - Fixed an issue whereby grids generated by the Rebuild Level Set SOP
      did not always display as surfaces in the viewport.
    - The Metadata SOP now sets appropriate viewport visualization options
      when the grid class is changed.

Version 3.0.0 - January 14, 2015
    - The io::File class now supports delayed loading of .vdb files,
      meaning that memory is not allocated for voxel values until the values
      are actually accessed.  (This feature is enabled by default.)
      Until a grid has been fully loaded, its source .vdb file must not be
      modified or deleted, so for safety, io::File::open() automatically makes
      private copies of source files that are smaller than a user-specified
      limit (see io::File::setCopyMaxBytes()).  The limit can be set to zero
      to disable copying, but if it cannot be guaranteed that a file will not
      be modified, then it is best not to enable delayed loading for that file.
    - .vdb files can now optionally be compressed with the Blosc LZ4 codec.
      Blosc compresses almost as well as ZLIB, but it is much faster.
    - Added tools::PointPartitioner, a tool for fast spatial sorting
      of points stored in an external array, and tools::PointIndexGrid,
      an acceleration structure for fast range and nearest-neighbor searches.
    - Added tree::NodeManager, which linearizes a tree to facilitate
      efficient multithreading across all tree levels.
    - Added tools::prune() (and other variants), which replaces and
      outperforms Tree::prune().
    - Added tools::signedFloodFill(), which replaces and outperforms
      Tree::signedFloodFill().
    - Added tools::changeBackground (and other variants), which replaces
      and outperforms Tree::setBackground().
    - Added a fast but approximate narrow-band level set dilation method,
      a fast narrow-band level set erosion method,
      and a masked normalization method to tools::LevelSetTracker.
    - Added tools::Diagnose, which performs multithreaded diagnostics on grids
      to identify issues like values that are NaNs or out-of-range.
      It optionally generates a boolean grid of all values that fail
      user-defined tests.
    - Added optional alpha masks to tools::LevelSetMorphing.
    - Fixed an intermittent crash in tools::LevelSetMorphing.
    - Added tools::topologyToLevelSet(), which generates a level set
      from the implicit boundary between active and inactive voxels
      in an arbitrary input grid.
      [DWA internal]
    - Improved the performance of point scattering (by orders of magnitude)
      and added a DenseUniformPointScatter class as well as support for
      fractional numbers of particles per voxel.
    - Added edge-adjacent (6+12=18 neighbors) and vertex-adjacent (6+12+8=26
      neighbors) dilation algorithms to tools::Morphology::dilateVoxels().
      The default dilation pattern is still face-adjacent (6 neighbors).
    - Improved the performance and memory footprint of the ParticlesToLevelSet
      tool for large numbers (tens to hundreds of millions) of particles.
    - Added Tree::getNodes(), which allows for fast construction of
      linear arrays of tree nodes for use in multithreaded code
      such as the LeafManager or NodeManager.
    - Added math::Extrema and tools::extrema() to efficiently compute
      minimum and maximum values in a grid.
    - Added support for material color grids to all level set shaders,
      and added an option to vdb_render that allows one to specify a
      reference grid to be used for material color lookups.
    - Added openvdb::getLibraryVersionString() and
      OPENVDB_LIBRARY_VERSION_STRING.
    - Modified the mesh to volume converter to always set the grid background
      value to the exterior narrow-band width, and added finite value checks
      to narrow band parameters.
    - tools::volumeToMesh() now compiles for all grid types but throws an
      exception if the input grid does not have a scalar value type.
    - Added an io::File::readGrid() overload and readBuffers() overloads
      to the grid, tree and node classes that allow one to specify
      a bounding box against which to clip a grid while reading it.
      For large grids, clipping while reading can result in significantly
      lower memory usage than clipping after reading.
    - Added Grid::clipGrid(), which clips a grid against a world-space
      bounding box, and Grid::clip() and Tree::clip(), which clip against
      an index-space bounding box.
    - Added tools::clip(), which clips a grid either against a bounding box
      or against the active voxels of a mask grid.
    - io::File::readGridPartial() allocates the nodes of a grid's tree
      as before, but it now allocates leaf nodes without data buffers.
      (This feature is mainly for internal use; partially-read grids should be
      used with care if at all, and they should be treated as read-only.)
    - Grid names retrieved using an io::File::NameIterator now always uniquely
      identify grids; they no longer generate 'more than one grid named "x"'
      warnings when there are multiple grids of the same name in a file
      (for files written starting with this version of the OpenVDB library).
    - Fixed a bug in Tree::ValueOffIter that could cause depth-bounded
      iterators to return incorrect values.
    - Eliminated a recursive call in TreeValueIteratorBase::advance() that
      could cause crashes on systems with a limited stack size.
    - Fixed memory leaks in RootNode::topologyDifference() and
      RootNode::topologyIntersection().
    - Fixed a memory leak in io::Queue when the queue was full and
      a write task could not be added within the timeout interval.
    - Fixed a potential division by zero crash in tools::compDiv()
      with integer-valued grids.
    - Fixed kernel normalization in tools::Filter so that it is correct
      for integer-valued grids.
    - Fixed a bug in LeafNode::Buffer::getValue() whereby Visual C++
      would return a reference to a temporary.
      [Contributed by SESI]
    - Fixed a bug in tools::ParticlesToLevelSet related to attribute transfer
      when leaf nodes are produced without active values.
    - Added util/CpuTimer.h and removed the more simplistic CpuTimer
      from unittest/util.h.
    - Eliminated the use of getopt() for command-line argument parsing
      in vdb_test.
    - openvdb::initialize() now properly initializes log4cplus if it is
      enabled, eliminating "No appenders could be found" errors.
    - Fixed a bug in the QuantizedUnitVec::pack() method that caused
      quantization artifacts.
    - Added convenience class tools::AlphaMask to tools/Interpolation.h
    - Added constructors and methods to both math::RandInt and math::Rand01
      to set and reset the random seed value.
    - Added convenience methods for transforming bounding boxes to
      math::Transform.
    - vdb_view is now compatible with both GLFW 2 and GLFW 3.
    - Made many small changes to address type conversion and other warnings
      reported by newer compilers like GCC 4.8 and ICC 14.
    - Replaced the HALF_INCL_DIR and HALF_LIB_DIR Makefile variables
      with ILMBASE_INCL_DIR and ILMBASE_LIB_DIR and added ILMBASE_LIB,
      to match OpenEXR's library organization.
      [Contributed by Double Negative]
    - Eliminated most local (function-scope) static variables, because
      Visual C++ doesn't guarantee thread-safe initialization of local statics.
      [Contributed by SESI]
    - Fixed a bug in readString() related to empty strings.
      [Contributed by Fabio Piparo]
    - Fixed a bug in the tools::VolumeToMesh simplification scheme that
      was creating visual artifacts.

    API changes:
    - The addition of a GridBase::readBuffers() virtual function overload
      and the GridBase::clip(), GridBase::readNonresidentBuffers() and
      Tree::clipUnallocatedNodes() virtual functions changes the grid ABI
      so that it is incompatible with earlier versions of the OpenVDB library
      (such as the ones in Houdini 12.5 and 13).  Define the macro
      OPENVDB_2_ABI_COMPATIBLE when compiling OpenVDB to disable these changes
      and preserve ABI compatibility.
    - All shaders now have a template argument to specify the type of
      an optional material color grid, but the default type mimics
      the old, uniform color behavior.
    - Removed a deprecated io::Stream::write() overload.
    - The point counts in the UniformPointScatter and NonUniformPointScatter
      tools are now specified and returned as Index64.
    - math::RandInt has an extra template argument to specify the integer
      type.  The RandomInt typedef is unchanged.
    - io::readData(), io::HalfReader::read() and io::HalfWriter::write() now
      take a uint32_t argument indicating the type of compression instead of
      a bool indicating whether compression is enabled.
    - Removed io::Archive::isCompressionEnabled() and
      io::Archive::setCompressionEnabled() and renamed
      io::Archive::compressionFlags() and io::Archive::setCompressionFlags()
      to io::Archive::compression() and io::Archive::setCompression().
    - Internal and leaf node classes are now required to provide
      "PartialCreate" constructors that optionally bypass the allocation
      of voxel buffers.  Leaf node classes must now also provide allocate()
      and isAllocated() methods to manage the allocation of their buffers.
    - Removed pruneInactive() and pruneLevelSet() methods from the Tree
      and various node classes.  These methods have been replaced by
      the much faster pruning functions found in tools/Prune.h.
    - Removed signedFloodFill() methods from the Grid, Tree and various
      node classes.  These methods have been replaced by the much faster
      functions found in tools/SignedFloodFill.h.
    - Removed Grid::setBackground() and Tree::setBackground() (use the faster
      changeBackground() tool instead), and removed the default argument
      from RootNode::setBackground().

    Python:
    - Added grid methods convertToPolygons() and convertToQuads(),
      which convert volumes to meshes, and createLevelSetFromPolygons(),
      which converts meshes to volumes.  NumPy is required.

    Maya:
    - Added an adaptive polygonal surface extraction node.

    Houdini:
    - Added a new Resize Narrow Band SOP that can efficiently adjust the width
      of a level set's narrow band.  This allows, for example, for a level set
      to be created quickly from points or polygons with a very narrow band
      that is then quickly resized to a desired width.
    - Fixed bugs in the Smooth Level Set and Reshape Level Set SOPs that
      caused them to ignore the selected discretization scheme.
    - Added a Morph Level Set SOP.
    - Added a From Points SOP to very quickly generate a level set
      from a point cloud, ignoring any radius attribute.
      [DWA internal]
    - Added a Voxel Scale mode to the Resample SOP.
    - Improved the performance and memory footprint of the From Particles SOP
      for large numbers (tens to hundreds of millions) of particles.
    - The Scatter SOP now accepts fractional numbers of particles per voxel.
    - Improved the performance of the Scatter SOP by more than an order
      of magnitude.
    - The Clip SOP now has a toggle to choose explicitly between a mask grid
      or a bounding box as the clipping region.  As a consequence, the
      mask grid can now be unnamed.
    - Added the OpenVDB library version number to the Extended Operator
      Information for all SOPs.
    - SOPs are now linked with an rpath to the directory containing the
      OpenVDB library.
    - Like the native Houdini file SOP, the Read SOP now allows missing frames
      to be reported either as errors or as warnings.
    - The Read SOP now has an optional input for geometry, the bounding box
      of which can be used to clip grids as they are read.  For large grids,
      clipping while reading can result in significantly lower memory usage
      than clipping after reading.
    - The From Polygons and Convert SOPs now default to using the polygon soup
      mesh representation, which uses less memory.

Version 2.3.0 - April 23, 2014
    - Added tools::extractSparseTree(), which selectively extracts and
      transforms data from a dense grid to produce a sparse tree,
      and tools::extractSparseTreeWithMask(), which copies data from
      the index-space intersection of a sparse tree and a dense input grid.
    - Added copy constructors to the Grid, Tree, RootNode, InternalNode
      and LeafNode classes, and an assignment operator overload to RootNode,
      that allow the source and destination to have different value types.
    - Modified Tree::combine2() to permit combination of trees with different
      value types.
    - Added CanConvertType and RootNode::SameConfiguration metafunctions,
      which perform compile-time tests for value type and tree type
      compatibility, and a RootNode::hasCompatibleValueType() method,
      which does runtime checking.
    - Added optional support for logging using log4cplus.  See logging.h
      and the INSTALL file for details.
    - Added VolumeRayIntersector::hits(), which returns all the hit segments
      along a ray.  This is generally more efficient than repeated calls
      to VolumeRayIntersector::march().
    - Added member class Ray::TimeSpan and method Ray::valid(), and
      deprecated method Ray::test().
    - Fixed a bug in VolumeHDDA that could cause rendering artifacts
      when a ray's start time was zero.
      [Contributed by Mike Farnsworth]
    - Added tools::compositeToDense(), which composites data from a
      sparse tree into a dense array, using a sparse alpha mask.
      Over, Add, Sub, Min, Max, Mult, and Set are supported operations.
    - Added tools::transformDense(), which applies a functor to the value
      of each voxel of a dense grid within a given bounding box.
    - Improved the performance of node iterators.

    API changes:
    - Collected the digital differential analyzer code from math/Ray.h
      and tools/RayIntersector.h into a new header file, math/DDA.h.
    - Rewrote VolumeHDDA and made several changes to its API.  (VolumeHDDA
      is used internally by VolumeRayIntersector, whose API is unchanged.)
    - Tree::combine2(), RootNode::combine2(), InternalNode::combine2(),
      LeafNode::combine2() and CombineArgs all now require an additional
      template argument, which determines the type of the other tree.
    - Assignment operators for LeafManager::LeafRange::Iterator,
      BaseMaskIterator, NodeMask and RootNodeMask now return references
      to the respective objects.
    - Removed a number of methods that were deprecated in version 2.0.0
      or earlier.

    Houdini:
    - Added a Clip SOP, which does volumetric clipping.
    - Added an Occlusion Mask SOP, which generates a mask of the voxels
      inside a camera frustum that are occluded by objects in an input grid.
    - The Combine SOP now applies the optional signed flood fill only to
      level set grids, since that operation isn't meaningful for other grids.
    - The Filter SOP now processes all grid types, not just scalar grids.

Version 2.2.0 - February 20, 2014
    - Added a simple, multithreaded volume renderer, and added volume
      rendering support to the vdb_render command-line renderer.
    - Added an option to the LevelSetRayIntersector and to vdb_render
      to specify the isovalue of the level set.
    - Added methods to the LevelSetRayIntersector to return the time of
      intersection along a world or index ray and to return the level set
      isovalue.
    - Improved the performance of the VolumeRayIntersector and added
      support for voxel dilation to account for interpolation kernels.
    - Added a section to the Cookbook on interpolation using BoxSampler,
      GridSampler, DualGridSampler, et al.
    - Added a section to the Overview on grids and grid metadata.
    - Modified tools::DualGridSampler so it is more consistent with
      tools::GridSampler.
    - tools::cpt(), tools::curl(), tools::laplacian(), tools::meanCurvature()
      and tools::normalize() now output grids with appropriate vector types
      (covariant, contravariant, etc.).
    - Added tools::transformVectors(), which applies an affine transformation
      to the voxel values of a vector-valued grid in accordance with the
      grid's Vector Type and World Space/Local Space metadata setting.
    - Added tools::compDiv(), which combines grids by dividing the values
      of corresponding voxels.
    - Fixed a bug in the mean curvature computation that could produce NaNs
      in regions with constant values.
    - Added a Grid::topologyDifference() method.
    - Added exp() and sum() methods to math::Vec2, math::Vec3 and math::Vec4.
    - Improved tools::fillWithSpheres() for small volumes that are just a few
      voxels across.
    - Improved the accuracy of the mesh to volume converter.
    - Fixed a bug in the mesh to volume converter that caused incorrect sign
      classifications for narrow-band level sets.
    - Fixed a bug in NonlinearFrustumMap::applyIJT() that resulted in incorrect
      values when computing the gradient of a grid with a frustum transform.
    - Fixed a file I/O bug whereby some .vdb files could not be read correctly
      if they contained grids with more than two distinct inactive values.
    - Fixed an off-by-one bug in the numbering of unnamed grids in .vdb files.
      The first unnamed grid in a file is now retrieved using the name "[0]",
      instead of "[1]".
    - Fixed a build issue reported by Clang 3.2 in tools/GridOperators.h.
    - Fixed a memory leak in tools::Film.
    - Added library and file format version number constants to the
      Python module.
    - Improved convergence in the volume renderer.
      [Contributed by Jerry Tessendorf and Mark Matthews]
    - Made various changes for compatibility with Houdini 13 and with
      C++11 compilers.
      [Contributed by SESI]

    API changes:
    - tools::VolumeRayIntersector::march() no longer returns an int
      to distinguish tile vs. voxel hits.  Instead, it now returns false
      if no intersection is detected and true otherwise.  Also, t0 and t1
      might now correspond to the first and last hits of multiple adjacent
      leaf nodes and/or active tiles.
    - tools::DualGridSampler is no longer templated on the target grid type,
      and the value accessor is now passed as an argument.
    - The .vdb file format has changed slightly.  Tools built with older
      versions of OpenVDB should be recompiled to ensure that they can read
      files in the new format.

    Houdini:
    - Added topology union, intersection and difference operations to
      the Combine SOP.  These operations combine the active voxel topologies
      of grids that may have different value types.
    - Added a Divide operation to the Combine SOP.
    - Added support for boolean grids to the Combine, Resample, Scatter, Prune
      and Visualize SOPs.
    - The Fill SOP now accepts a vector as the fill value, and it allows
      the fill region bounds to be specified either in index space (as before),
      in world space, or using the bounds of geometry connected to an optional
      new reference input.
    - Added a toggle to the Offset Level Set SOP to specify the offset in
      either world or voxel units.
    - Added a toggle to the Transform and Resample SOPs to apply the
      transform to the voxel values of vector-valued grids, in accordance with
      those grids' Vector Type and World Space/Local Space metadata settings.
    - Added a Vector Type menu to the Vector Merge SOP.
    - Removed masking options from the Renormalize SOP (since masking is
      not supported yet).
    - Reimplemented the Vector Merge SOP for better performance and
      interruptibility and to fix a bug in the handling of tile values.

Version 2.1.0 - December 12, 2013
    - Added a small number of Maya nodes, primarily for conversion of geometry
      to and from OpenVDB volumes and for visualization of volumes.
    - Added an initial implementation of level set morphing (with improvements
      to follow soon).
    - Added tools::LevelSetMeasure, which efficiently computes the surface area,
      volume and average mean-curvature of narrow-band level sets, in both
      world and voxel units.  Those quantities are now exposed as intrinsic
      attributes on the Houdini VDB primitive and can be queried using the
      native Measure SOP.
    - tools::Dense now supports the XYZ memory layout used by Houdini and Maya
      in addition to the ZYX layout used in OpenVDB trees.
    - Improved the performance of masking in the level set filter tool and
      added inversion and scaling of the mask input, so that any scalar-valued
      volume can be used as a mask, not just volumes with a [0, 1] range.
    - Added optional masking to the non-level-set filters, to the grid
      operators (CPT, curl, divergence, gradient, Laplacian, mean curvature,
      magnitude, and normalize) and to the Analysis and Filter SOPs.
    - Added more narrow band controls to the Rebuild Level Set SOP.
    - Improved the accuracy of the level set rebuild tool.
    - Added tools::activate() and tools::deactivate(), which set the active
      states of tiles and voxels whose values are equal to or approximately
      equal to a given value, and added a Deactivate Background Voxels toggle
      to the Combine SOP.
    - Added math::BBox::applyMap() and math::BBox::applyInverseMap(), which
      allow for transformation of axis-aligned bounding boxes.
    - Added a position shader to the level set ray-tracer (primarily for
      debugging purposes).
    - Added an io::Queue class that manages a concurrent queue for
      asynchronous serialization of grids to files or streams.
    - Fixed a bug in io::Archive whereby writing unnamed, instanced grids
      (i.e., grids sharing a tree) to a file rendered the file unreadable.
    - Fixed a bug in the volume to mesh converter that caused it to generate
      invalid polygons when the zero crossing lay between active and inactive
      regions.
    - Fixed a bug in the point scatter tool (and the Scatter SOP) whereby
      the last voxel always remained empty.
    - Fixed a bug in the Read SOP that caused grids with the same name
      to be renamed with a numeric suffix (e.g., "grid[1]", "grid[2]", etc.).
    - Fixed some unit test failures on 64-bit Itanium machines.

    API changes:
    - The Filter tool is now templated on a mask grid, and threading is
      controlled using a grain size, for consistency with most of the
      other level set tools.
    - The level set filter tool is now templated on a mask grid.
    - All shaders now take a ray direction instead of a ray.

Version 2.0.0 - October 31, 2013
    - Added a Python module with functions for basic manipulation of grids
      (but no tools, yet).
    - Added ray intersector tools for efficient, hierarchical intersection
      of rays with level-set and generic volumes.
    - Added a Ray class and a hierarchical Digital Differential Analyzer
      for fast ray traversal.
    - Added a fully multithreaded level set ray tracer and camera classes
      that mimic Houdini's cameras.
    - Added a simple, command-line renderer (currently for level sets only).
    - Implemented a new meshing scheme that produces topologically robust
      two-manifold meshes and is twice as fast as the previous scheme.
    - Implemented a new, topologically robust (producing two-manifold meshes)
      level-set-based seamless fracture scheme.  The new scheme eliminates
      visible scarring seen in the previous implementation by subdividing
      internal, nonplanar quads near fracture seams.  In addition,
      fracture seam points are now tagged, allowing them to be used
      to drive pre-fracture dynamics such as local surface buckling.
    - Improved the performance of Tree::evalActiveVoxelBoundingBox() and
      Tree::activeVoxelCount(), and significantly improved the performance
      of Tree::evalLeafBoundingBox() (by about 30x).
    - Added a tool (and a Houdini SOP) that fills a volume with
      adaptively-sized overlapping or non-overlapping spheres.
    - Added a Ray SOP that can be used to perform geometry projections
      using level-set ray intersections or closest-point queries.
    - Added a tool that performs accelerated closest surface point queries
      from arbitrary points in world space to narrow-band level sets.
    - Increased the speed of masked level set filtering by 20% for
      the most common cases.
    - Added math::BoxStencil, with support for trilinear interpolation
      and gradient computation.
    - Added Tree::topologyIntersection(), which intersects a tree's active
      values with those of another tree, and Tree::topologyDifference(),
      which performs topological subtraction of one tree's active values
      from another's.  In both cases, the ValueTypes of the two trees
      need not be the same.
    - Added Tree::activeTileCount(), which returns the number of active tiles
      in a tree.
    - Added math::MinIndex() and math::MaxIndex(), which find the minimum
      and maximum components of a vector without any branching.
    - Added math::BBox::minExtent(), which returns a bounding box's
      shortest axis.
    - The default math::BBox constructor now generates an invalid bounding
      box rather than an empty bounding box positioned at the origin.
      The new behavior is consistent with math::CoordBBox.
      [Thanks to Rick Hankins for suggesting this fix.]
    - Added CoordBBox::reset(), which resets a bounding box to its initial,
      invalid state.
    - Fixed a bug in the default ScaleMap constructor that left some data
      used in the inverse uninitialized.
    - Added MapBase::applyJT(), which applies the Jacobian transpose to
      a vector (the Jacobian transpose takes a range-space vector to a
      domain-space vector, e.g., world to index), and added
      MapBase::inverseMap(), which returns a new map representing
      the inverse of the original map (except for NonlinearFrustumMap,
      which does not currently have a defined inverse map).
      Note: Houdini 12.5 uses an earlier version of OpenVDB, and maps
      created with that version lack virtual table entries for these
      new methods, so do not call these methods from Houdini 12.5.
    - Reimplemented math::RandomInt using Boost.Random instead of rand()
      (which is not thread-safe), and deprecated math::randUniform()
      and added math::Random01 to replace it.
    - Modified tools::copyFromDense() and tools::copyToDense() to allow
      for implicit type conversion (e.g., between a Dense<Int32> and a
      FloatTree) and fixed several bugs in tools::CopyFromDense.
    - Fixed bugs in math::Stats and math::Histogram that could produce
      NaNs or other incorrect behavior if certain methods were called
      on populations of size zero.
    - Renamed tolerance<T> to math::Tolerance<T> and negative<T>() to
      math::negative<T>() and removed math::toleranceValue<T>().
    - Implemented a closest point on line segment algorithm,
      math::closestPointOnSegmentToPoint().
    - Fixed meshing issues relating to masking and automatic partitioning.
    - Grid::merge() and Tree::merge() now accept an optional MergePolicy
      argument that specifies one of three new merging schemes.  (The old
      merging scheme, which is no longer available, used logic for each tree
      level that was inconsistent with the other levels and that could result
      in active tiles being replaced with nodes having only inactive values.)
    - Renamed LeafNode::coord2offset(), LeafNode::offset2coord() and
      LeafNode::offset2globalCoord() to coordToOffset(), offsetToLocalCoord()
      and offsetToGlobalCoord(), respectively, and likewise for InternalNode.
      [Thanks to Rick Hankins for suggesting this change.]
    - Replaced Tree methods setValueOnMin(), setValueOnMax() and
      setValueOnSum() with tools::setValueOnMin(), tools::setValueOnMax() and
      tools::setValueOnSum() (and a new tools::setValueOnMult()) and added
      Tree::modifyValue() and Tree::modifyValueAndActiveState(), which modify
      voxel values in place via user-supplied functors.  Similarly, replaced
      ValueAccessor::setValueOnSum() with ValueAccessor::modifyValue()
      and ValueAccessor::modifyValueAndActiveState(), and added a modifyValue()
      method to all value iterators.
    - Removed LeafNode::addValue() and LeafNode::scaleValue().
    - Added convenience classes Tree3 and Tree5 for custom tree configurations.
    - Added an option to the From Particles SOP to generate an alpha mask,
      which can be used to constrain level set filtering so as to preserve
      surface details.
    - The mesh to volume converter now handles point-degenerate polygons.
    - Fixed a bug in the Level Set Smooth, Level Set Renormalize and
      Level Set Offset SOPs that caused the group name to be ignored.
    - Fixed various OS X and Windows build issues.
      [Contributions from SESI and DD]

Version 1.2.0 - June 28, 2013
    - Level set filters now accept an optional alpha mask grid.
    - Implemented sharp feature extraction for level set surfacing.
      This enhances the quality of the output mesh and reduces aliasing
      artifacts.
    - Added masking options to the meshing tools, as well as a spatial
      multiplier for the adaptivity threshold, automatic partitioning,
      and the ability to preserve edges and corners when mesh adaptivity
      is applied.
    - The mesh to volume attribute transfer scheme now takes surface
      orientation into account, which improves accuracy in proximity to
      edges and corners.
    - Added a foreach() method to tools::LeafManager that, like
      tools::foreach(), applies a user-supplied functor to each leaf node
      in parallel.
    - Rewrote the particle to level set converter, simplifying the API,
      improving performance (especially when particles have a fixed radius),
      adding the capability to transfer arbitrary point attributes,
      and fixing a velocity trail bug.
    - Added utility methods Sign(), SignChange(), isApproxZero(), Cbrt()
      and ZeroCrossing() to math/Math.h.
    - Added a probeNode() method to the value accessor and to tree nodes
      that returns a pointer to the node that contains a given voxel.
    - Deprecated LeafNode::addValue() and LeafNode::scaleValue().
    - Doubled the speed of the mesh to volume converter (which also improves
      the performance of the fracture and level set rebuild tools) and
      improved its inside/outside voxel classification near edges and corners.
    - tools::GridSampler now accepts either a grid, a tree or a value accessor,
      and it offers faster index-based access methods and much better
      performance in cases where many instances are allocated.
    - Extended tools::Dense to make it more compatible with existing tools.
    - Fixed a crash in io::Archive whenever the library was unloaded
      from memory and then reloaded.
      [Contributed by Ollie Harding]
    - Fixed a bug in GU_PrimVDB::buildFromPrimVolume(), seen during the
      conversion from Houdini volumes to OpenVDB grids, that could cause
      signed flood fill to be applied to non-level set grids, resulting in
      active tiles with incorrect values.
    - Added a Prune SOP with several pruning schemes.

Version 1.1.1 - May 10 2013
    - Added a simple dense grid class and tools to copy data from
      dense voxel arrays into OpenVDB grids and vice-versa.
    - Starting with Houdini 12.5.396, plugins built with this version
      of OpenVDB can coexist with native Houdini OpenVDB nodes.
    - The level set fracture tool now smooths seam line edges during
      mesh extraction, eliminating staircase artifacts.
    - Significantly improved the performance of the
      util::leafTopologyIntersection() and util::leafTopologyDifference()
      utilities and added a LeafNode::topologyDifference() method.
    - Added convenience functions that provide simplified interfaces
      to the mesh to volume and volume to mesh converters.
    - Added a tools::accumulate() function that is similar to tools::foreach()
      but can be used to accumulate the results of computations over
      the values of a grid.
    - Added tools::statistics(), tools::opStatistics() and tools::histogram(),
      which efficiently compute statistics (mean, variance, etc.) and
      histograms of grid values (using math::Stats and math::Histogram).
    - Modified CoordBBox to adhere to TBB's splittable type requirements,
      so that, for example, a CoordBBox can be used as a blocked
      iteration range.
    - Added Tree::addTile(), Tree::addLeaf() and Tree::stealNode(), for
      fine control over tree construction.
    - Addressed a numerical stability issue when performing Gaussian
      filtering of level set grids.
    - Changed the return type of CoordBBox::volume() to reduce the risk
      of overflow.
    - When the input mesh is self-intersecting, the mesh to volume converter
      now produces a level set with a monotonic gradient field.
    - Fixed a threading bug in the mesh to volume converter that caused it
      to produce different results for the same input.
    - Fixed a bug in the particle to level set converter that prevented
      particles with zero velocity from being rasterized in Trail mode.
    - Added an optional input to the Create SOP into which to merge
      newly-created grids.
    - Fixed a bug in the Resample SOP that caused it to produce incorrect
      narrow-band widths when resampling level set grids.
    - Fixed a bug in the To Polygons SOP that caused intermittent crashes
      when the optional reference input was connected.
    - Fixed a bug in the Advect Level Set SOP that caused a crash
      when the velocity input was connected but empty.
    - The Scatter and Sample Point SOPs now warn instead of erroring
      when given empty grids.
    - Fixed a crash in vdb_view when stepping through multiple grids
      after changing render modes.
    - vdb_view can now render fog volumes and vector fields, and it now
      features interactively adjustable clipping planes that enable
      one to view the interior of a volume.

Version 1.1.0 - April 4 2013
    - The resampleToMatch() tool, the Resample SOP and the Combine SOP
      now use level set rebuild to correctly and safely resample level sets.
      Previously, scaling a level set would invalidate the signed distance
      field, leading to holes and other artifacts.
    - Added a mask-based topological erosion tool, and rewrote and simplified
      the dilation tool.
    - The LevelSetAdvection tool can now advect forward or backward in time.
    - Tree::pruneLevelSet() now replaces each pruned node with a tile having
      the inside or outside background value, instead of arbitrarily selecting
      one of the node's tile or voxel values.
    - When a grid is saved to a file with saveFloatAsHalf() set to true,
      the grid's background value is now also quantized to 16 bits.
      (Not quantizing the background value caused a mismatch with the values
      of background tiles.)
    - As with tools::foreach(), it is now possible to specify whether functors
      passed to tools::transformValues() should be shared across threads.
    - tree::LeafManager can now be instantiated with a const tree,
      although buffer swapping with const trees is disabled.
    - Added a Grid::signedFloodFill() overload that allows one to specify
      inside and outside values.
    - Fixed a bug in Grid::setBackground() so that now only the values of
      inactive voxels change.
    - Fixed Grid::topologyUnion() so that it actually unions tree topology,
      instead of just the active states of tiles and voxels.  The previous
      behavior broke multithreaded code that relied on input and output grids
      having compatible tree topology.
    - math::Transform now includes an isIdentity() predicate and methods
      to pre- and postmultiply by a matrix.
    - Modified the node mask classes to permit octree-like tree configurations
      (i.e., with a branching factor of two) and to use 64-bit operations
      instead of 32-bit operations.
    - Implemented a new, more efficient closest point on triangle algorithm.
    - Implemented a new vertex normal scheme in the volume to mesh
      converter, and resolved some overlapping polygon issues.
    - The volume to mesh converter now meshes not just active voxels
      but also active tiles.
    - Fixed a bug in the mesh to volume converter that caused unsigned
      distance field conversion to produce empty grids.
    - Fixed a bug in the level set fracture tool whereby the cutter overlap
      toggle was ignored.
    - Fixed an infinite loop bug in vdb_view.
    - Updated vdb_view to use the faster and less memory-intensive
      OpenVDB volume to mesh converter instead of marching cubes,
      and rewrote the shader to be OpenGL 3.2 and GLSL 1.2 compatible.
    - Given multiple input files or a file containing multiple grids,
      vdb_view now displays one grid at a time.  The left and right
      arrow keys cycle between grids.
    - The To Polygons SOP now has an option to associate the input grid's
      name with each output polygon.

Version 1.0.0 - March 14 2013
    - tools::levelSetRebuild() now throws an exception when given a
      non-scalar or non-floating-point grid.
    - The tools in tools/GridOperators.h are now interruptible, as is
      the Analysis SOP.
    - Added a leaf node iterator and a TBB-compatible range class to
      the LeafManager.
    - Modified the VolumeToMesh tool to handle surface topology issues
      around fracture seam lines.
    - Modified the Makefile to allow vdb_view to compile on OS X systems
      (provided that GLFW is available).
    - Fixed a bug in the Create SOP that resulted in "invalid parameter name"
      warnings.
    - The Combine SOP now optionally resamples the A grid into the B grid's
      index space (or vice-versa) if the A and B transforms differ.
    - The Vector Split and Vector Merge SOPs now skip inactive voxels
      by default, but they can optionally be made to include inactive voxels,
      as they did before.
    - The LevelSetFracture tool now supports custom rotations for each
      cutter instance, and the Fracture SOP now uses quaternions to generate
      uniformly-distributed random rotations.

Version 0.104.0 - February 15 2013
    - Added a tool and a SOP to rebuild a level set from any scalar volume.
    - .vdb files are now saved using a mask-based compression scheme
      that is an order of magnitude faster than ZLIB and produces comparable
      file sizes for level set and fog volume grids.  (ZLIB compression
      is still enabled by default for other classes of grids).
    - The Filter and LevelSetFilter tools now include a Gaussian filter,
      and mean (box) filtering is now 10-50x faster.
    - The isosurface meshing tool is now more robust (to level sets
      with one voxel wide narrow bands, for example).
    - Mesh to volume conversion is on average 1.5x faster and up to 5.5x
      faster for high-resolution meshes where the polygon/voxel size ratio
      is small.
    - Added createLevelSet() and createLevelSetSphere() factory functions
      for level set grids.
    - tree::ValueAccessor is now faster for trees of height 2, 3 and 4
      (the latter is the default), and it now allows one to specify,
      via a template argument, the number of node levels to be cached,
      which can also improve performance in special cases.
    - Added a toggle to tools::foreach() to specify whether or not
      the functor should be shared across threads.
    - Added Mat4s and Mat4d metadata types.
    - Added explicit pre- and postmultiplication methods to the Transform,
      Map and Mat4 classes and deprecated the old accumulation methods.
    - Modified NonlinearFrustumMap to be more compatible with Houdini's
      frustum transform.
    - Fixed a GridTransformer bug that caused it to translate the
      output grid incorrectly in some cases.
    - Fixed a bug in the tree-level LeafIterator that resulted in
      intermittent crashes in tools::dilateVoxels().
    - The Hermite data type and Hermite grids are no longer supported.
    - Added tools/GridOperators.h, which includes new, cleaner implementations
      of the Cpt, Curl, Divergence, Gradient, Laplacian, Magnitude,
      MeanCurvature and Normalize tools.
    - Interrupt support has been improved in several tools, including
      tools::ParticlesToLevelSet.
    - Simplified the API of the Stencil class and added an intersects()
      method to test for intersection with a specified isovalue.
    - Renamed voxelDimensions to voxelSize in transform classes and elsewhere.
    - Deprecated houdini_utils::ParmFactory::setChoiceList() in favor of
      houdini_utils::ParmFactory::setChoiceListItems(), which requires
      a list of token, label string pairs.
    - Made various changes for Visual C++ compatibility.
      [Contributed by SESI]
    - Fixed a bug in houdini_utils::getNodeChain() that caused the
      Offset Level Set, Smooth Level Set and Renormalize Level Set SOPs
      to ignore frame changes.
      [Contributed by SESI]
    - The From Particles SOP now provides the option to write into
      an existing grid.
    - Added a SOP to edit grid metadata.
    - The Fracture SOP now supports multiple cutter objects.
    - Added a To Polygons SOP that complements the Fracture SOP and allows
      for elimination of seam lines, generation of correct vertex normals
      and grouping of polygons when surfacing fracture fragments, using
      the original level set or mesh as a reference.

Version 0.103.1 - January 15 2013
    - tree::ValueAccessor read operations are now faster for four-level trees.
      (Preliminary benchmark tests suggest a 30-40% improvement.)
    - For vector-valued grids, tools::compMin() and tools::compMax()
      now compare vector magnitudes instead of individual components.
    - Migrated grid sampling code to a new file, Interpolation.h,
      and deprecated old files and classes.
    - Added a level-set fracture tool and a Fracture SOP.
    - Added tools::sdfInteriorMask(), which creates a mask of the
      interior region of a level set grid.
    - Fixed a bug in the mesh to volume converter that produced unexpected
      nonzero values for voxels at the intersection of two polygons,
      and another bug that produced narrow-band widths that didn't respect
      the background value when the half-band width was less than three voxels.
    - houdini_utils::ParmFactory can now correctly generate ramp multi-parms.
    - Made various changes for Visual C++ compatibility.
      [Contributed by SESI]
    - The Convert SOP can now convert between signed distance fields and
      fog volumes and from volumes to meshes.
      [Contributed by SESI]
    - For level sets, the From Mesh and From Particles SOPs now match
      the reference grid's narrow-band width.
    - The Scatter SOP can now optionally scatter points in the interior
      of a level set.

Version 0.103.0 - December 21 2012
    - The mesh to volume converter is now 60% faster at generating
      level sets with wide bands, and the From Mesh SOP is now interruptible.
    - Fixed a threading bug in the recently-added compReplace() tool
      that caused it to produce incorrect output.
    - Added a probeConstLeaf() method to the Tree, ValueAccessor and
      node classes.
    - The Houdini VDB primitive doesn't create a "name" attribute
      unnecessarily (i.e., if its grid's name is empty), but it now
      correctly allows the name to be changed to the empty string.
    - Fixed a crash in the Vector Merge SOP when fewer than three grids
      were merged.
    - The From Particles SOP now features a "maximum half-width" parameter
      to help avoid runaway computations.

Version 0.102.0 - December 13 2012
    - Added tools::compReplace(), which copies the active values of one grid
      into another, and added a "Replace A With Active B" mode to the
      Combine SOP.
    - Grid::signedFloodFill() no longer enters an infinite loop when
      filling an empty grid.
    - Fixed a bug in the particle to level set converter that sometimes
      produced level sets with holes, and fixed a bug in the SOP that
      could result in random output.
    - Fixed an issue in the frustum preview feature of the Create SOP
      whereby rendering very large frustums could cause high CPU usage.
    - Added streamline support to the constrained advection scheme
      in the Advect Points SOP.
    - Added an Advect Level Set SOP.

Version 0.101.1 - December 11 2012 (DWA internal release)
    - Partially reverted the Houdini VDB primitive's grid accessor methods
      to their pre-0.98.0 behavior.  A primitive's grid can once again
      be accessed by shared pointer, but now also by reference.
      Accessor methods for grid metadata have also been added, and the
      primitive now ensures that metadata and transforms are never shared.
    - Fixed an intermittent crash in the From Particles SOP.

Version 0.101.0 - December 6 2012 (DWA internal release)
    - Partially reverted the Grid's tree and transform accessor methods
      to their pre-0.98.0 behavior, eliminating copy-on-write but
      preserving their return-by-reference semantics.  These methods
      are now supplemented with a suite of shared pointer accessors.
    - Restructured the mesh to volume converter for a 40% speedup
      and to be more robust to non-manifold geometry, to better preserve
      sharp features, to support arbitrary tree configurations and
      to respect narrow-band limits.
    - Added a getNodeBoundingBox() method to RootNode, InternalNode
      and LeafNode that returns the index space spanned by a node.
    - Made various changes for Visual C++ compatibility.
      [Contributed by SESI]
    - Renamed the Reshape Level Set SOP to Offset Level Set.
    - Fixed a crash in the Convert SOP and added support for conversion
      of empty grids.

Version 0.100.0 - November 30 2012 (DWA internal release)
    - Greatly improved the performance of the level set to fog volume
      converter.
    - Improved the performance of the median filter and of level set
      CSG operations.
    - Reintroduced Tree::pruneLevelSet(), a specialized pruneInactive()
      for level-set grids.
    - Added utilities to the houdini_utils library to facilitate the
      collection of a chain of adjacent nodes of a particular type
      so that they can be cooked in a single step.  (For example,
      adjacent xform SOPs could be collapsed by composing their
      transformation matrices into a single matrix.)
    - Added pruning and flood-filling options to the Convert SOP.
    - Reimplemented the Filter SOP, omitting level-set-specific filters
      and adding node chaining (to reduce memory usage when applying
      several filters in sequence).
    - Added a toggle to the Read SOP to read grid metadata and
      transforms only.
    - Changed the attribute transfer scheme on the From Mesh and
      From Particles SOPs to allow for custom grid names and
      vector type metadata.

Version 0.99.0 - November 21 2012
    - Added Grid methods that return non-const Tree and Transform
      references without triggering deep copies, as well as const
      methods that return const shared pointers.
    - Added Grid methods to populate a grid's metadata with statistics
      like the active voxel count, and to retrieve that metadata.
      By default, statistics are now computed and added to grids
      whenever they are written to .vdb files.
    - Added io::File::readGridMetadata() and io::File::readAllGridMetadata()
      methods to read just the grid metadata and transforms from a .vdb file.
    - Fixed numerical precision issues in the csgUnion, csgIntersection
      and csgDifference tools, and added toggles to optionally disable
      postprocess pruning.
    - Fixed an issue in vdb_view with the ordering of GL vertex buffer calls.
      [Contributed by Bill Katz]
    - Fixed an intermittent crash in the ParticlesToLevelSet tool,
      as well as a race condition that could cause data corruption.
    - The ParticlesToLevelSet tool and From Particles SOP can now
      transfer arbitrary point attribute values from the input particles
      to output voxels.
    - Fixed a bug in the Convert SOP whereby the names of primitives
      were lost during conversion, and another bug that resulted in
      an arithmetic error when converting an empty grid.
    - Fixed a bug in the Combine SOP that caused the Operation selection
      to be lost.

Version 0.98.0 - November 16 2012
    - Tree and Transform objects (and Grid objects in the context of
      Houdini SOPs) are now passed and accessed primarily by reference
      rather than by shared pointer.  See the online documentation for
      details about this important API change.
      [Contributed by SESI]
    - Reimplemented CoordBBox to address several off-by-one bugs
      related to bounding box dimensions.
    - Fixed an off-by-one bug in Grid::evalActiveVoxelBoundingBox().
    - Introduced the LeafManager class, which will eventually replace the
      LeafArray class.  LeafManager supports dynamic buffers stored as
      a structure of arrays (SOA), unlike LeafArray, which supports only
      static buffers stored as an array of structures (AOS).
    - Improved the performance of the LevelSetFilter and LevelSetTracker
      tools by rewriting them to use the new LeafManager class.
    - Added Tree and ValueAccessor setValueOnly() methods, which change
      the value of a voxel without changing its active state, and
      Tree and ValueAccessor probeLeaf() methods that return the leaf node
      that contains a given voxel (unless the voxel is represented by a tile).
    - Added a LevelSetAdvection tool that propagates and tracks
      narrow-band level sets.
    - Introduced a new GridSampler class that supports world-space
      (or index-space) sampling of grid values.
    - Changed the interpretation of the NonlinearFrustumMap's taper
      parameter to be the ratio of the near and far plane depths.
    - Added a ParmFactory::setChoiceList() overload that accepts
      (token, label) string pairs, and a setDefault() overload that
      accepts an STL string.
    - Fixed a crash in the Combine SOP in Copy B mode.
    - Split the Level Set Filter SOP into three separate SOPs,
      Level Set Smooth, Level Set Reshape and Level Set Renormalize.
      When two or more of these nodes are connected in sequence, they interact
      to reduce memory usage: the last node in the sequence performs
      all of the operations in one step.
    - The Advect Points SOP can now output polyline streamlines
      that trace the paths of the points.
    - Added an option to the Analysis SOP to specify names for output grids.
    - Added camera-derived frustum transform support to the Create SOP.

Version 0.97.0 - October 18 2012
    - Added a narrow-band level set interface tracking tool (up to
      fifth-order in space but currently only first-order in time,
      with higher temporal orders to be added soon).
    - Added a level set filter tool to perform unrestricted surface
      smoothing (e.g., Laplacian flow), filtering (e.g., mean value)
      and morphological operations (e.g., morphological opening).
    - Added adaptivity to the level set meshing tool for faster mesh
      extraction with fewer polygons, without postprocessing.
    - Added a ValueAccessor::touchLeaf() method that creates (if necessary)
      and returns the leaf node containing a given voxel.  It can be used
      to preallocate leaf nodes over which to run parallel algorithms.
    - Fixed a bug in Grid::merge() whereby active tiles were sometimes lost.
    - Added LeafManager, which is similar to LeafArray but supports a
      dynamic buffer count and allocates buffers more efficiently.
      Useful for temporal integration (e.g., for level set propagation
      and interface tracking), LeafManager is meant to replace LeafArray,
      which will be deprecated in the next release.
    - Added a LeafNode::fill() method to efficiently populate leaf nodes
      with constant values.
    - Added a Tree::visitActiveBBox() method that applies a functor to the
      bounding boxes of all active tiles and leaf nodes and that can be used
      to improve the performance of ray intersection tests, rendering of
      bounding boxes, etc.
    - Added a Tree::voxelizeActiveTiles() method to densify active tiles.
      While convenient and fast, this can produce large dense grids,
      so use it with caution.
    - Repackaged Tree::pruneLevelSet() as a Tree::pruneOp()-compatible
      functor.  LevelSetPrune is a specialized pruneInactive() for
      level-set grids and is used in interface tracking.
    - Added a GridBase::pruneGrid() method.
    - Added a Grid:hasUniformVoxels() method.
    - Renamed tools::dilate() to tools::dilateVoxels() and improved its
      performance.  The new name reflects the fact that the current
      implementation ignores active tiles.
    - Added a tools::resampleToMatch() function that resamples an input
      grid into an output grid with a different transform such that, after
      resampling, the input and output grids coincide, but the output
      grid's transform is preserved.
    - Significantly improved the performance of depth-bounded value
      iterators (ValueOnIter, ValueAllIter, etc.) when the depth bound
      excludes leaf nodes.
    - Exposed the value buffers inside leaf nodes with LeafNode::buffer().
      This allows for very fast access (const and non-const) to voxel
      values using linear array offsets instead of (i,j,k) coordinates.
    - In openvdb_houdini/UT_VDBTools.h, added operators for use with
      processTypedGrid() that resample grids in several different ways.
    - Added a policy mechanism to houdini_utils::OpFactory that allows for
      customization of operator names, icons, and Help URLs.
    - Renamed many of the Houdini SOPs to make the names more consistent.
    - Added an Advect Points SOP.
    - Added a Level Set Filter SOP that allows for unrestricted surface
      deformations, unlike the older Filter SOP, which restricts surface
      motion to the initial narrow band.
    - Added staggered vector sampling to the Sample Points SOP.
    - Added a minimum radius threshold to the particle voxelization tool
      and SOP.
    - Merged the Composite and CSG SOPs into a single Combine SOP.
    - Added a tool and a SOP to efficiently generate narrow-band level set
      representations of spheres.
    - In the Visualize SOP, improved the performance of tree topology
      generation, which is now enabled by default.

Version 0.96.0 - September 24 2012
    - Fixed a memory corruption bug in the mesh voxelizer tool.
    - Temporarily removed the optional clipping feature from
      the level set mesher.
    - Added "Staggered Vector Field" to the list of grid classes
      in the Create SOP.

Version 0.95.0 - September 20 2012
    - Added a quad meshing tool for higher-quality level set meshing
      and updated the Visualizer SOP to use it.
    - Fixed a precision error in the mesh voxelizer and improved
      the quality of inside/outside voxel classification.
      Output grids are now also tagged as either level sets or fog volumes.
    - Modified the GridResampler to use the signed flood fill optimization
      only on grids that are tagged as level sets.
    - Added a quaternion class to the math library and a method to
      return the trace of a Mat3.
    - Fixed a bug in the ValueAccessor copy constructor that caused
      the copy to reference the original.
    - Fixed a bug in RootNode::setActiveState() that caused a crash
      when marking a (virtual) background voxel as inactive.
    - Added a Tree::pruneLevelSet() method that is similar to but faster than
      pruneInactive() for level set grids.
    - Added fast leaf node voxel access methods that index by linear offset
      (as returned by ValueIter::pos()) instead of by (i, j, k) coordinates.
    - Added a Tree::touchLeaf() method that can be used to preallocate a static
      tree topology over which to safely perform multithreaded processing.
    - Added a grain size argument to the LeafArray class for finer control
      of parallelism.
    - Modified the Makefile to make it easier to omit the doc, vdb_test
      and vdb_view targets.
    - Added utility functions (in houdini/UT_VDBUtils.h) to convert
      between Houdini and OpenVDB matrix and vector types.
      [Contributed by SESI]
    - Added accessors to GEO_PrimVDB that make it easier to directly access
      voxel data and that are used by the HScript volume expression functions
      in Houdini 12.5.
      [Contributed by SESI]
    - As of Houdini 12.1.77, the native transform SOP operates on OpenVDB
      primitives.
      [Contributed by SESI]
    - Added a Convert SOP that converts OpenVDB grids to Houdini volumes
      and vice-versa.

Version 0.94.1 - September 7 2012
    - Fixed bugs in RootNode and InternalNode setValue*() and fill() methods
      that could cause neighboring voxels to become inactive.
    - Fixed a bug in Tree::hasSameTopology() that caused false positives
      when only active states and not values differed.
    - Added a Tree::hasActiveTiles() method.
    - For better cross-platform consistency, substituted bitwise AND
      operations for right shifts in the ValueAccessor hash key computation.
    - vdb_view no longer aborts when asked to surface a vector-valued
      grid--but it still doesn't render the surface.
    - Made various changes for Visual C++ compatibility.
      [Contributed by SESI]
    - Added an option to the MeshVoxelizer SOP to convert both open and
      closed surfaces to unsigned distance fields.
    - The Filter SOP now allows multiple filters to be applied in
      user-specified order.

Version 0.94.0 - August 30 2012
    - Added a method to union just the active states of voxels from
      one grid with those of another grid of a possibly different type.
    - Fixed an incorrect scale factor in the Laplacian diffusion filter.
    - Fixed a bug in Tree::merge that could leave a tree with invalid
      value accessors.
    - Added TreeValueIteratorBase::setActiveState() and deprecated setValueOn().
    - Removed tools/FastSweeping.h.  It will be replaced with a much more
      efficient implementation in the near future.
    - ZLIB compression of .vdb files is now optional, but enabled by default.
      [Contributed by SESI]
    - Made various changes for Clang and Visual C++ compatibility.
      [Contributed by SESI]
    - The MeshVoxelizer SOP can now transfer arbitrary point and
      primitive attribute values from the input mesh to output voxels.

Version 0.93.0 - August 24 2012
    - Renamed symbols in math/Operators.h to avoid ambiguities that
      GCC 4.4 reports as errors.
    - Simplified the API for the stencil version of the
      closest-point transform operator.
    - Added logic to io::Archive::readGrid() to set the grid name metadata
      from the descriptor if the metadata doesn't already exist.
    - Added guards to prevent nesting of openvdb_houdini::Interrupter::start()
      and end() calls.


Version 0.92.0 - August 23 2012
    - Added a Laplacian diffusion filter.
    - Fixed a bug in the initialization of the sparse contour tracer
      that caused mesh-to-volume conversion to fail in certain cases.
    - Fixed a bug in the curvature stencil that caused mean curvature
      filtering to produce wrong results.
    - Increased the speed of the GridTransformer by as much as 20%
      for fog volumes.
    - Added optional pruning to the Resample SOP.
    - Modified the PointSample SOP to allow it to work with ungrouped,
      anonymous grids.
    - Fixed a crash in the LevelSetNoise SOP.

Version 0.91.0 - August 16 2012
    - tools::GridTransformer and tools::GridResampler now correctly
      (but not yet efficiently) process tiles in sparse grids.
    - Added an optional CopyPolicy argument to GridBase::copyGrid()
      and to Grid::copy() that specifies whether and how the grid's tree
      should be copied.
    - Added a GridBase::newTree() method that replaces a grid's tree with
      a new, empty tree of the correct type.
    - Fixed a crash in Tree::setValueOff() when the new value was equal to
      the background value.
    - Fixed bugs in Tree::prune() that could result in output tiles with
      incorrect active states.
    - Added librt to the link dependencies to address build failures on
      Ubuntu systems.
    - Made various small changes to the Makefile and the source code
      that should help with Mac OS X compatibility.
    - The Composite and Resample SOPs now correctly copy the input grid's
      metadata to the output grid.

Version 0.90.1 - August 7 2012
    - Fixed a bug in the BBox::getCenter() method.
    - Added missing header files to various files.
    - io::File::NameIterator::gridName() now returns a unique name of the
      form "name[1]", "name[2]", etc. if a file contains multiple grids with
      the same name.
    - Fixed a bug in the Writer SOP that caused grid names to be discarded.
    - The Resample SOP now correctly sets the background value of the
      output grid.

Version 0.90.0 - August 3 2012 (initial public release)
    - Added a basic GL viewer for OpenVDB files.
    - Greatly improved the performance of two commonly-used Tree methods,
      evalActiveVoxelBoundingBox() and memUsage().
    - Eliminated the GridMap class.  File I/O now uses STL containers
      of grid pointers instead.
    - Refactored stencil-based tools (Gradient, Laplacian, etc.) and rewrote
      some of them for generality and better performance.  Most now behave
      correctly for grids with nonlinear index-to-world transforms.
    - Added a library of index-space finite difference operators.
    - Added a "Hermite" grid type that compactly stores each voxel's upwind
      normals and can be used to convert volumes to and from polygonal meshes.
    - Added a tool (and a Houdini SOP) to scatter points randomly throughout
      a volume.

