OpenVDB 12.1.0

Loading...
Searching...
No Matches
VolumeRayIntersector< GridT, NodeLevel, RayT > Class Template Reference

This class provides the public API for intersecting a ray with a generic (e.g. density) volume. More...

`#include <openvdb/tools/RayIntersector.h>`

## Public Types
using | GridType = GridT
using | RayType = RayT
using | RealType = typename RayT::RealType
using | RootType = typename GridT::TreeType::RootNodeType
using | TreeT = tree::Tree<typename RootType::template ValueConverter<bool>::Type>

## Public Member Functions
| VolumeRayIntersector (const GridT &grid, int dilationCount=0)
| Grid constructor.
| VolumeRayIntersector (const GridT &grid, const math::CoordBBox &bbox)
| Grid and BBox constructor.
| VolumeRayIntersector (const VolumeRayIntersector &other)
| Shallow copy constructor.
| ~VolumeRayIntersector ()
| Destructor.
bool | setIndexRay (const RayT &iRay)
| Return `false` if the index ray misses the bbox of the grid.
bool | setWorldRay (const RayT &wRay)
| Return `false` if the world ray misses the bbox of the grid.
RayT::TimeSpan | march ()
bool | march (RealType &t0, RealType &t1)
| Return `true` if the ray intersects active values, i.e. either active voxels or tiles. Only when a hit is detected are t0 and t1 updated with the corresponding entry and exit times along the INDEX ray!
template<typename ListType>
void | hits (ListType &list)
| Generates a list of hits along the ray.
Vec3R | getIndexPos (RealType time) const
| Return the floating-point index position along the current index ray at the specified time.
Vec3R | getWorldPos (RealType time) const
| Return the floating-point world position along the current index ray at the specified time.
RealType | getWorldTime (RealType time) const
const GridT & | grid () const
| Return a const reference to the input grid.
const TreeT & | tree () const
| Return a const reference to the (potentially dilated) bool tree used to accelerate the ray marching.
const math::CoordBBox & | bbox () const
| Return a const reference to the BBOX of the grid.
void | print (std::ostream &os=std::cout, int verboseLevel=1)
| Print bbox, statistics, memory usage and other information.

## Detailed Description

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>
class openvdb::v12_1::tools::VolumeRayIntersector< GridT, NodeLevel, RayT >

This class provides the public API for intersecting a ray with a generic (e.g. density) volume.

Internally it performs the actual hierarchical tree node traversal.

Warning
  Use the (default) copy-constructor to make sure each computational thread has their own instance of this class. This is important since it contains a ValueAccessor that is not thread-safe and a CoordBBox of the active voxels that should not be re-computed for each thread. However copying is very efficient.

Example:
  // Create an instance for the master thread
  VolumeRayIntersector inter(grid);
  // For each additional thread use the copy constructor. This
  // amortizes the overhead of computing the bbox of the active voxels!
  VolumeRayIntersector inter2(inter);
  // Before each ray-traversal set the index ray.
  iter.setIndexRay(ray);
  // or world ray
  iter.setWorldRay(ray);
  // Now you can begin the ray-marching using consecutive calls to VolumeRayIntersector::march
  double t0=0, t1=0;// note the entry and exit times are with respect to the INDEX ray
  while ( inter.march(t0, t1) ) {
  // perform line-integration between t0 and t1
  }}
  openvdb::v12_1::tools::VolumeRayIntersector::grid
  const GridT & grid() const
  Return a const reference to the input grid.
  Definition RayIntersector.h:446
  openvdb::v12_1::tools::VolumeRayIntersector::VolumeRayIntersector
  VolumeRayIntersector(const GridT &grid, int dilationCount=0)
  Grid constructor.
  Definition RayIntersector.h:297

## Member Typedef Documentation

## ◆ GridType

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

using GridType = GridT

## ◆ RayType

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

using RayType = RayT

## ◆ RealType

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

using RealType = typename RayT::RealType

## ◆ RootType

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

using RootType = typename GridT::TreeType::RootNodeType

## ◆ TreeT

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

using TreeT = tree::Tree<typename RootType::template ValueConverter<bool>::Type>

## Constructor & Destructor Documentation

## ◆ VolumeRayIntersector() [1/3]

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

VolumeRayIntersector | ( | const GridT & | grid,
|  | int | dilationCount = 0 )
| inline

Grid constructor.

Parameters

  grid | Generic grid to intersect rays against.
  dilationCount | The number of voxel dilations performed on (a boolean copy of) the input grid. This allows the intersector to account for the size of interpolation kernels in client code.

Exceptions

  RuntimeError | if the voxels of the grid are not uniform or the grid is empty.

## ◆ VolumeRayIntersector() [2/3]

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

VolumeRayIntersector | ( | const GridT & | grid,
|  | const math::CoordBBox & | bbox )
| inline

Grid and BBox constructor.

Parameters

  grid | Generic grid to intersect rays against.
  bbox | The axis-aligned bounding-box in the index space of the grid.

Warning
  It is assumed that bbox = (min, min + dim) where min denotes to the smallest grid coordinates and dim are the integer length of the bbox.

Exceptions

  RuntimeError | if the voxels of the grid are not uniform or the grid is empty.

## ◆ VolumeRayIntersector() [3/3]

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

VolumeRayIntersector | ( | const VolumeRayIntersector< GridT, NodeLevel, RayT > & | other | ) |
| inline

Shallow copy constructor.

Warning
  This copy constructor creates shallow copies of data members of the instance passed as the argument. For performance reasons we are not using shared pointers (their mutex-lock impairs multi-threading).

## ◆ ~VolumeRayIntersector()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

~VolumeRayIntersector | ( |  | ) |
| inline

Destructor.

## Member Function Documentation

## ◆ bbox()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

const math::CoordBBox & bbox | ( |  | ) | const
| inline

Return a const reference to the BBOX of the grid.

## ◆ getIndexPos()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

Vec3R getIndexPos | ( | RealType | time | ) | const
| inline

Return the floating-point index position along the current index ray at the specified time.

## ◆ getWorldPos()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

Vec3R getWorldPos | ( | RealType | time | ) | const
| inline

Return the floating-point world position along the current index ray at the specified time.

## ◆ getWorldTime()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

RealType getWorldTime | ( | RealType | time | ) | const
| inline

## ◆ grid()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

const GridT & grid | ( |  | ) | const
| inline

Return a const reference to the input grid.

## ◆ hits()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>
template<typename ListType>

void hits | ( | ListType & | list | ) |
| inline

Generates a list of hits along the ray.

Parameters

  list | List of hits represented as time spans.

Note
  ListType is a list of RayType::TimeSpan and is required to have the two methods: clear() and push_back(). Thus, it could be std::vector<typename RayType::TimeSpan> or std::deque<typename RayType::TimeSpan>.

## ◆ march() [1/2]

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

RayT::TimeSpan march | ( |  | ) |
| inline

## ◆ march() [2/2]

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

bool march | ( | RealType & | t0,
|  | RealType & | t1 )
| inline

Return `true` if the ray intersects active values, i.e. either active voxels or tiles. Only when a hit is detected are t0 and t1 updated with the corresponding entry and exit times along the INDEX ray!

Note
  Note that t0 and t1 are only resolved at the node level (e.g. a LeafNode with active voxels) as opposed to the individual active voxels.

Parameters

  t0 | If the return value > 0 this is the time of the first hit of an active tile or leaf.
  t1 | If the return value > t0 this is the time of the first hit (> t0) of an inactive tile or exit point of the BBOX for the leaf nodes.

Warning
  t0 and t1 are computed with respect to the ray represented in index space of the current grid, not world space!

## ◆ print()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

void print | ( | std::ostream & | os = std::cout,
|  | int | verboseLevel = 1 )
| inline

Print bbox, statistics, memory usage and other information.

Parameters

  os | a stream to which to write textual information
  verboseLevel | 1: print bbox only; 2: include boolean tree statistics; 3: include memory usage

## ◆ setIndexRay()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

bool setIndexRay | ( | const RayT & | iRay | ) |
| inline

Return `false` if the index ray misses the bbox of the grid.

Parameters

  iRay | Ray represented in index space.

Warning
  Call this method (or setWorldRay) before the ray traversal starts and use the return value to decide if further marching is required.

## ◆ setWorldRay()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

bool setWorldRay | ( | const RayT & | wRay | ) |
| inline

Return `false` if the world ray misses the bbox of the grid.

Parameters

  wRay | Ray represented in world space.

Warning
  Call this method (or setIndexRay) before the ray traversal starts and use the return value to decide if further marching is required.

Since hit times are computed with respect to the ray represented in index space of the current grid, it is recommended that either the client code uses getIndexPos to compute index position from hit times or alternatively keeps an instance of the index ray and instead uses setIndexRay to initialize the ray.

## ◆ tree()

template<typename GridT, int NodeLevel = GridT::TreeType::RootNodeType::ChildNodeType::LEVEL, typename RayT = math::Ray<Real>>

const TreeT & tree | ( |  | ) | const
| inline

Return a const reference to the (potentially dilated) bool tree used to accelerate the ray marching.