How to set and access Internal Node Transient Data?

[jtressle]

Hi,

Thanks for the openVDB software. It's been great to build upon.

One question is how to use the transient data values at the internal node level? What I'm trying to do is to basically attach additional data to a voxel (or node). I am able to do this via multiple grids, but I'm looking for a more memory efficient approach.

Here's an example of my code that I think is relevant. I'm basically running

openvdb::FloatGrid::Ptr grid;
std::vector<VoxelData> voxel_data;

grid = openvdb::FloatGrid::create(_settings.sdf_trunc);
grid->setName("SDF grid");
grid->setTransform(openvdb::math::Transform::createLinearTransform(_settings.voxel_size));
grid->setGridClass(openvdb::GRID_LEVEL_SET);

auto grid_acc = grid->getUnsafeAccessor();

for (const auto &pt : points) {
    //compute ray from point and origin
    openvdb::math::DDA<decltype(ray)> dda(ray);

    do {
        ...
        const auto &voxel = dda.voxel();
        ...
        const float value = ...
        grid_acc.setValue(voxel, value);

        const openvdb::Index32 index = voxel_data.size();
        voxel_data.emplace_back();

        ...
        //how to set node transientData()? 
			

    } while (dda.step());
}

Basically I tried doing a grid->probeNode and grid->probeLeaf, but I'm getting the voxel's leaf, and the transient data for that leaf.

For further clarification, if I'm able to do this correctly, I'll be able to use the transient data value:

    auto* node = grid->tree().probeNode<Int3Type>(voxel);
    if (node && node->isValueOn(voxel)) {
        const openvdb::Index32 index = node->transientData();
        
        const auto &data = voxel_data[index];
        ...
    }

Thanks!

[Idclip]

Hey @jtressle

You're basically there - if you want a specific node type within the tree hierarchy you can use probeNode with the template parameter being the node type at the desired level. You can get the exact node types from the NodeChains on the root nodes. I'm not sure what the Int3Type type is in your code, but see below for an example:

using MyTreeT = openvdb::FloatTree; // whatever tree type you have
using MyRootNodeT = MyTreeT::RootNodeType;

// Select the desired node level from the node chain, where 0 = Leaf
using DesiredNodeT1  = MyRootNodeT::NodeChainType::Get<1>;  // Leaf node parents, lowest internal node
using DesiredNodeT2 = MyRootNodeT::NodeChainType::Get<2>; // lowest internal node parents, second internal node
using TheRootNodeT = MyRootNodeT::NodeChainType::Get<3>; // in default vdb tree configs, this will be the root

...

auto* node = grid->tree().probeNode<DesiredNodeT1>(voxel); // This should now return the DesiredNodeT1 that holds the child data associated with "voxel"

[jtressle]

@Idclip thanks for the example. This helped clarify the node structure, and how to access data for each node type. I was able to save node level data using the transientData.

For additional voxel level data, I implemented a Int32 grid to store an index to a std::vector of Voxel Data. This appears to work pretty well, other than I wouldn't be able to serialize my data, or probably run multi-threaded.

//init
openvdb::Int32Grid::Ptr _indices;

_indices = openvdb::Int32Grid::create(-1);
_indices->setName("Voxel Data indices");
_indices->setTransform(openvdb::math::Transform::createLinearTransform(_settings.voxel_size));
_indices->setGridClass(openvdb::GRID_UNKNOWN);

and then when I add values:

auto indices_acc = _indices->getUnsafeAccessor();
const int index = indices_acc.getValue(voxel);

if (index >= 0) {
    const float weight = ...
    VoxelData &data = _voxel_data[index];
    const float new_weight = weight + data.weight;                    

    //update voxel data
    data.weight = new_weight;
    ... //and other data
} else {
    //update grid with new value
    const float value = ...
    grid_acc.setValue(voxel, value);
	         
    indices_acc.setValue(voxel, static_cast<openvdb::Index32>(_voxel_data.size()));
    _voxel_data.emplace_back();
}

Again, many thanks for the clarification and examples.