file_path
stringlengths 21
202
| content
stringlengths 13
1.02M
| size
int64 13
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 5.43
98.5
| max_line_length
int64 12
993
| alphanum_fraction
float64 0.27
0.91
|
|---|---|---|---|---|---|---|
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/unittest/TestPointIndexGrid.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
#include "gtest/gtest.h"
#include <openvdb/tools/PointIndexGrid.h>
#include <vector>
#include <algorithm>
#include <cmath>
#include "util.h" // for genPoints
struct TestPointIndexGrid: public ::testing::Test
{
};
////////////////////////////////////////
namespace {
class PointList
{
public:
typedef openvdb::Vec3R PosType;
PointList(const std::vector<PosType>& points)
: mPoints(&points)
{
}
size_t size() const {
return mPoints->size();
}
void getPos(size_t n, PosType& xyz) const {
xyz = (*mPoints)[n];
}
protected:
std::vector<PosType> const * const mPoints;
}; // PointList
template<typename T>
bool hasDuplicates(const std::vector<T>& items)
{
std::vector<T> vec(items);
std::sort(vec.begin(), vec.end());
size_t duplicates = 0;
for (size_t n = 1, N = vec.size(); n < N; ++n) {
if (vec[n] == vec[n-1]) ++duplicates;
}
return duplicates != 0;
}
template<typename T>
struct WeightedAverageAccumulator {
typedef T ValueType;
WeightedAverageAccumulator(T const * const array, const T radius)
: mValues(array), mInvRadius(1.0/radius), mWeightSum(0.0), mValueSum(0.0) {}
void reset() { mWeightSum = mValueSum = T(0.0); }
void operator()(const T distSqr, const size_t pointIndex) {
const T weight = T(1.0) - openvdb::math::Sqrt(distSqr) * mInvRadius;
mWeightSum += weight;
mValueSum += weight * mValues[pointIndex];
}
T result() const { return mWeightSum > T(0.0) ? mValueSum / mWeightSum : T(0.0); }
private:
T const * const mValues;
const T mInvRadius;
T mWeightSum, mValueSum;
}; // struct WeightedAverageAccumulator
} // namespace
////////////////////////////////////////
TEST_F(TestPointIndexGrid, testPointIndexGrid)
{
const float voxelSize = 0.01f;
const openvdb::math::Transform::Ptr transform =
openvdb::math::Transform::createLinearTransform(voxelSize);
// generate points
std::vector<openvdb::Vec3R> points;
unittest_util::genPoints(40000, points);
PointList pointList(points);
// construct data structure
typedef openvdb::tools::PointIndexGrid PointIndexGrid;
PointIndexGrid::Ptr pointGridPtr =
openvdb::tools::createPointIndexGrid<PointIndexGrid>(pointList, *transform);
openvdb::CoordBBox bbox;
pointGridPtr->tree().evalActiveVoxelBoundingBox(bbox);
// coord bbox search
typedef PointIndexGrid::ConstAccessor ConstAccessor;
typedef openvdb::tools::PointIndexIterator<> PointIndexIterator;
ConstAccessor acc = pointGridPtr->getConstAccessor();
PointIndexIterator it(bbox, acc);
EXPECT_TRUE(it.test());
EXPECT_EQ(points.size(), it.size());
// fractional bbox search
openvdb::BBoxd region(bbox.min().asVec3d(), bbox.max().asVec3d());
// points are bucketed in a cell-centered fashion, we need to pad the
// coordinate range to get the same search region in the fractional bbox.
region.expand(voxelSize * 0.5);
it.searchAndUpdate(region, acc, pointList, *transform);
EXPECT_TRUE(it.test());
EXPECT_EQ(points.size(), it.size());
{
std::vector<uint32_t> vec;
vec.reserve(it.size());
for (; it; ++it) {
vec.push_back(*it);
}
EXPECT_EQ(vec.size(), it.size());
EXPECT_TRUE(!hasDuplicates(vec));
}
// radial search
openvdb::Vec3d center = region.getCenter();
double radius = region.extents().x() * 0.5;
it.searchAndUpdate(center, radius, acc, pointList, *transform);
EXPECT_TRUE(it.test());
EXPECT_EQ(points.size(), it.size());
{
std::vector<uint32_t> vec;
vec.reserve(it.size());
for (; it; ++it) {
vec.push_back(*it);
}
EXPECT_EQ(vec.size(), it.size());
EXPECT_TRUE(!hasDuplicates(vec));
}
center = region.min();
it.searchAndUpdate(center, radius, acc, pointList, *transform);
EXPECT_TRUE(it.test());
{
std::vector<uint32_t> vec;
vec.reserve(it.size());
for (; it; ++it) {
vec.push_back(*it);
}
EXPECT_EQ(vec.size(), it.size());
EXPECT_TRUE(!hasDuplicates(vec));
// check that no points where missed.
std::vector<unsigned char> indexMask(points.size(), 0);
for (size_t n = 0, N = vec.size(); n < N; ++n) {
indexMask[vec[n]] = 1;
}
const double r2 = radius * radius;
openvdb::Vec3R v;
for (size_t n = 0, N = indexMask.size(); n < N; ++n) {
v = center - transform->worldToIndex(points[n]);
if (indexMask[n] == 0) {
EXPECT_TRUE(!(v.lengthSqr() < r2));
} else {
EXPECT_TRUE(v.lengthSqr() < r2);
}
}
}
// Check partitioning
EXPECT_TRUE(openvdb::tools::isValidPartition(pointList, *pointGridPtr));
points[10000].x() += 1.5; // manually modify a few points.
points[20000].x() += 1.5;
points[30000].x() += 1.5;
EXPECT_TRUE(!openvdb::tools::isValidPartition(pointList, *pointGridPtr));
PointIndexGrid::Ptr pointGrid2Ptr =
openvdb::tools::getValidPointIndexGrid<PointIndexGrid>(pointList, pointGridPtr);
EXPECT_TRUE(openvdb::tools::isValidPartition(pointList, *pointGrid2Ptr));
}
TEST_F(TestPointIndexGrid, testPointIndexFilter)
{
// generate points
const float voxelSize = 0.01f;
const size_t pointCount = 10000;
const openvdb::math::Transform::Ptr transform =
openvdb::math::Transform::createLinearTransform(voxelSize);
std::vector<openvdb::Vec3d> points;
unittest_util::genPoints(pointCount, points);
PointList pointList(points);
// construct data structure
typedef openvdb::tools::PointIndexGrid PointIndexGrid;
PointIndexGrid::Ptr pointGridPtr =
openvdb::tools::createPointIndexGrid<PointIndexGrid>(pointList, *transform);
std::vector<double> pointDensity(pointCount, 1.0);
openvdb::tools::PointIndexFilter<PointList>
filter(pointList, pointGridPtr->tree(), pointGridPtr->transform());
const double radius = 3.0 * voxelSize;
WeightedAverageAccumulator<double>
accumulator(&pointDensity.front(), radius);
double sum = 0.0;
for (size_t n = 0, N = points.size(); n < N; ++n) {
accumulator.reset();
filter.searchAndApply(points[n], radius, accumulator);
sum += accumulator.result();
}
EXPECT_NEAR(sum, double(points.size()), 1e-6);
}
TEST_F(TestPointIndexGrid, testWorldSpaceSearchAndUpdate)
{
// Create random particles in a cube.
openvdb::math::Rand01<> rnd(0);
const size_t N = 1000000;
std::vector<openvdb::Vec3d> pos;
pos.reserve(N);
// Create a box to query points.
openvdb::BBoxd wsBBox(openvdb::Vec3d(0.25), openvdb::Vec3d(0.75));
std::set<size_t> indexListA;
for (size_t i = 0; i < N; ++i) {
openvdb::Vec3d p(rnd(), rnd(), rnd());
pos.push_back(p);
if (wsBBox.isInside(p)) {
indexListA.insert(i);
}
}
// Create a point index grid
const double dx = 0.025;
openvdb::math::Transform::Ptr transform = openvdb::math::Transform::createLinearTransform(dx);
PointList pointArray(pos);
openvdb::tools::PointIndexGrid::Ptr pointIndexGrid
= openvdb::tools::createPointIndexGrid<openvdb::tools::PointIndexGrid, PointList>(pointArray, *transform);
// Search for points within the box.
openvdb::tools::PointIndexGrid::ConstAccessor acc = pointIndexGrid->getConstAccessor();
openvdb::tools::PointIndexIterator<openvdb::tools::PointIndexTree> pointIndexIter;
pointIndexIter.worldSpaceSearchAndUpdate<PointList>(wsBBox, acc, pointArray, pointIndexGrid->transform());
std::set<size_t> indexListB;
for (; pointIndexIter; ++pointIndexIter) {
indexListB.insert(*pointIndexIter);
}
EXPECT_EQ(indexListA.size(), indexListB.size());
}
| 8,097 | C++ | 25.638158 | 114 | 0.625046 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/unittest/TestTreeCombine.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
#include "gtest/gtest.h"
#include <openvdb/Types.h>
#include <openvdb/openvdb.h>
#include <openvdb/tools/Composite.h>
#include <openvdb/tools/LevelSetSphere.h>
#include <openvdb/util/CpuTimer.h>
#include "util.h" // for unittest_util::makeSphere()
#include <algorithm> // for std::max() and std::min()
#include <cmath> // for std::isnan() and std::isinf()
#include <limits> // for std::numeric_limits
#include <sstream>
#include <string>
#include <type_traits>
#define TEST_CSG_VERBOSE 0
#if TEST_CSG_VERBOSE
#include <openvdb/util/CpuTimer.h>
#include <iostream>
#endif
namespace {
using Float433Tree = openvdb::tree::Tree4<float, 4, 3, 3>::Type;
using Float433Grid = openvdb::Grid<Float433Tree>;
}
class TestTreeCombine: public ::testing::Test
{
public:
void SetUp() override { openvdb::initialize(); Float433Grid::registerGrid(); }
void TearDown() override { openvdb::uninitialize(); }
protected:
template<class TreeT, typename TreeComp, typename ValueComp>
void testComp(const TreeComp&, const ValueComp&);
template<class TreeT>
void testCompRepl();
template<typename TreeT, typename VisitorT>
typename TreeT::Ptr
visitCsg(const TreeT& a, const TreeT& b, const TreeT& ref, const VisitorT&);
};
////////////////////////////////////////
namespace {
namespace Local {
template<typename ValueT>
struct OrderDependentCombineOp {
OrderDependentCombineOp() {}
void operator()(const ValueT& a, const ValueT& b, ValueT& result) const {
result = a + ValueT(100) * b; // result is order-dependent on A and B
}
};
/// Test Tree::combine(), which takes a functor that accepts three arguments
/// (the a, b and result values).
template<typename TreeT>
void combine(TreeT& a, TreeT& b)
{
a.combine(b, OrderDependentCombineOp<typename TreeT::ValueType>());
}
/// Test Tree::combineExtended(), which takes a functor that accepts a single
/// CombineArgs argument, in which the functor can return a computed active state
/// for the output value.
template<typename TreeT>
void extendedCombine(TreeT& a, TreeT& b)
{
using ValueT = typename TreeT::ValueType;
struct ArgsOp {
static void order(openvdb::CombineArgs<ValueT>& args) {
// The result is order-dependent on A and B.
args.setResult(args.a() + ValueT(100) * args.b());
args.setResultIsActive(args.aIsActive() || args.bIsActive());
}
};
a.combineExtended(b, ArgsOp::order);
}
template<typename TreeT> void compMax(TreeT& a, TreeT& b) { openvdb::tools::compMax(a, b); }
template<typename TreeT> void compMin(TreeT& a, TreeT& b) { openvdb::tools::compMin(a, b); }
template<typename TreeT> void compSum(TreeT& a, TreeT& b) { openvdb::tools::compSum(a, b); }
template<typename TreeT> void compMul(TreeT& a, TreeT& b) { openvdb::tools::compMul(a, b); }\
template<typename TreeT> void compDiv(TreeT& a, TreeT& b) { openvdb::tools::compDiv(a, b); }\
inline float orderf(float a, float b) { return a + 100.0f * b; }
inline float maxf(float a, float b) { return std::max(a, b); }
inline float minf(float a, float b) { return std::min(a, b); }
inline float sumf(float a, float b) { return a + b; }
inline float mulf(float a, float b) { return a * b; }
inline float divf(float a, float b) { return a / b; }
inline openvdb::Vec3f orderv(const openvdb::Vec3f& a, const openvdb::Vec3f& b) { return a+100.0f*b; }
inline openvdb::Vec3f maxv(const openvdb::Vec3f& a, const openvdb::Vec3f& b) {
const float aMag = a.lengthSqr(), bMag = b.lengthSqr();
return (aMag > bMag ? a : (bMag > aMag ? b : std::max(a, b)));
}
inline openvdb::Vec3f minv(const openvdb::Vec3f& a, const openvdb::Vec3f& b) {
const float aMag = a.lengthSqr(), bMag = b.lengthSqr();
return (aMag < bMag ? a : (bMag < aMag ? b : std::min(a, b)));
}
inline openvdb::Vec3f sumv(const openvdb::Vec3f& a, const openvdb::Vec3f& b) { return a + b; }
inline openvdb::Vec3f mulv(const openvdb::Vec3f& a, const openvdb::Vec3f& b) { return a * b; }
inline openvdb::Vec3f divv(const openvdb::Vec3f& a, const openvdb::Vec3f& b) { return a / b; }
} // namespace Local
} // unnamed namespace
TEST_F(TestTreeCombine, testCombine)
{
testComp<openvdb::FloatTree>(Local::combine<openvdb::FloatTree>, Local::orderf);
testComp<openvdb::VectorTree>(Local::combine<openvdb::VectorTree>, Local::orderv);
testComp<openvdb::FloatTree>(Local::extendedCombine<openvdb::FloatTree>, Local::orderf);
testComp<openvdb::VectorTree>(Local::extendedCombine<openvdb::VectorTree>, Local::orderv);
}
TEST_F(TestTreeCombine, testCompMax)
{
testComp<openvdb::FloatTree>(Local::compMax<openvdb::FloatTree>, Local::maxf);
testComp<openvdb::VectorTree>(Local::compMax<openvdb::VectorTree>, Local::maxv);
}
TEST_F(TestTreeCombine, testCompMin)
{
testComp<openvdb::FloatTree>(Local::compMin<openvdb::FloatTree>, Local::minf);
testComp<openvdb::VectorTree>(Local::compMin<openvdb::VectorTree>, Local::minv);
}
TEST_F(TestTreeCombine, testCompSum)
{
testComp<openvdb::FloatTree>(Local::compSum<openvdb::FloatTree>, Local::sumf);
testComp<openvdb::VectorTree>(Local::compSum<openvdb::VectorTree>, Local::sumv);
}
TEST_F(TestTreeCombine, testCompProd)
{
testComp<openvdb::FloatTree>(Local::compMul<openvdb::FloatTree>, Local::mulf);
testComp<openvdb::VectorTree>(Local::compMul<openvdb::VectorTree>, Local::mulv);
}
TEST_F(TestTreeCombine, testCompDiv)
{
testComp<openvdb::FloatTree>(Local::compDiv<openvdb::FloatTree>, Local::divf);
testComp<openvdb::VectorTree>(Local::compDiv<openvdb::VectorTree>, Local::divv);
}
TEST_F(TestTreeCombine, testCompDivByZero)
{
const openvdb::Coord c0(0), c1(1), c2(2), c3(3), c4(4);
// Verify that integer-valued grids behave well w.r.t. division by zero.
{
const openvdb::Int32 inf = std::numeric_limits<openvdb::Int32>::max();
openvdb::Int32Tree a(/*background=*/1), b(0);
a.setValueOn(c0);
a.setValueOn(c1);
a.setValueOn(c2, -1);
a.setValueOn(c3, -1);
a.setValueOn(c4, 0);
b.setValueOn(c1);
b.setValueOn(c3);
openvdb::tools::compDiv(a, b);
EXPECT_EQ( inf, a.getValue(c0)); // 1 / 0
EXPECT_EQ( inf, a.getValue(c1)); // 1 / 0
EXPECT_EQ(-inf, a.getValue(c2)); // -1 / 0
EXPECT_EQ(-inf, a.getValue(c3)); // -1 / 0
EXPECT_EQ( 0, a.getValue(c4)); // 0 / 0
}
{
const openvdb::Index32 zero(0), inf = std::numeric_limits<openvdb::Index32>::max();
openvdb::UInt32Tree a(/*background=*/1), b(0);
a.setValueOn(c0);
a.setValueOn(c1);
a.setValueOn(c2, zero);
b.setValueOn(c1);
openvdb::tools::compDiv(a, b);
EXPECT_EQ( inf, a.getValue(c0)); // 1 / 0
EXPECT_EQ( inf, a.getValue(c1)); // 1 / 0
EXPECT_EQ(zero, a.getValue(c2)); // 0 / 0
}
// Verify that non-integer-valued grids don't use integer division semantics.
{
openvdb::FloatTree a(/*background=*/1.0), b(0.0);
a.setValueOn(c0);
a.setValueOn(c1);
a.setValueOn(c2, -1.0);
a.setValueOn(c3, -1.0);
a.setValueOn(c4, 0.0);
b.setValueOn(c1);
b.setValueOn(c3);
openvdb::tools::compDiv(a, b);
EXPECT_TRUE(std::isinf(a.getValue(c0))); // 1 / 0
EXPECT_TRUE(std::isinf(a.getValue(c1))); // 1 / 0
EXPECT_TRUE(std::isinf(a.getValue(c2))); // -1 / 0
EXPECT_TRUE(std::isinf(a.getValue(c3))); // -1 / 0
EXPECT_TRUE(std::isnan(a.getValue(c4))); // 0 / 0
}
}
TEST_F(TestTreeCombine, testCompReplace)
{
testCompRepl<openvdb::FloatTree>();
testCompRepl<openvdb::VectorTree>();
}
template<typename TreeT, typename TreeComp, typename ValueComp>
void
TestTreeCombine::testComp(const TreeComp& comp, const ValueComp& op)
{
using ValueT = typename TreeT::ValueType;
const ValueT
zero = openvdb::zeroVal<ValueT>(),
minusOne = zero + (-1),
minusTwo = zero + (-2),
one = zero + 1,
three = zero + 3,
four = zero + 4,
five = zero + 5;
{
TreeT aTree(/*background=*/one);
aTree.setValueOn(openvdb::Coord(0, 0, 0), three);
aTree.setValueOn(openvdb::Coord(0, 0, 1), three);
aTree.setValueOn(openvdb::Coord(0, 0, 2), aTree.background());
aTree.setValueOn(openvdb::Coord(0, 1, 2), aTree.background());
aTree.setValueOff(openvdb::Coord(1, 0, 0), three);
aTree.setValueOff(openvdb::Coord(1, 0, 1), three);
TreeT bTree(five);
bTree.setValueOn(openvdb::Coord(0, 0, 0), minusOne);
bTree.setValueOn(openvdb::Coord(0, 1, 0), four);
bTree.setValueOn(openvdb::Coord(0, 1, 2), minusTwo);
bTree.setValueOff(openvdb::Coord(1, 0, 0), minusOne);
bTree.setValueOff(openvdb::Coord(1, 1, 0), four);
// Call aTree.compMax(bTree), aTree.compSum(bTree), etc.
comp(aTree, bTree);
// a = 3 (On), b = -1 (On)
EXPECT_EQ(op(three, minusOne), aTree.getValue(openvdb::Coord(0, 0, 0)));
// a = 3 (On), b = 5 (bg)
EXPECT_EQ(op(three, five), aTree.getValue(openvdb::Coord(0, 0, 1)));
EXPECT_TRUE(aTree.isValueOn(openvdb::Coord(0, 0, 1)));
// a = 1 (On, = bg), b = 5 (bg)
EXPECT_EQ(op(one, five), aTree.getValue(openvdb::Coord(0, 0, 2)));
EXPECT_TRUE(aTree.isValueOn(openvdb::Coord(0, 0, 2)));
// a = 1 (On, = bg), b = -2 (On)
EXPECT_EQ(op(one, minusTwo), aTree.getValue(openvdb::Coord(0, 1, 2)));
EXPECT_TRUE(aTree.isValueOn(openvdb::Coord(0, 1, 2)));
// a = 1 (bg), b = 4 (On)
EXPECT_EQ(op(one, four), aTree.getValue(openvdb::Coord(0, 1, 0)));
EXPECT_TRUE(aTree.isValueOn(openvdb::Coord(0, 1, 0)));
// a = 3 (Off), b = -1 (Off)
EXPECT_EQ(op(three, minusOne), aTree.getValue(openvdb::Coord(1, 0, 0)));
EXPECT_TRUE(aTree.isValueOff(openvdb::Coord(1, 0, 0)));
// a = 3 (Off), b = 5 (bg)
EXPECT_EQ(op(three, five), aTree.getValue(openvdb::Coord(1, 0, 1)));
EXPECT_TRUE(aTree.isValueOff(openvdb::Coord(1, 0, 1)));
// a = 1 (bg), b = 4 (Off)
EXPECT_EQ(op(one, four), aTree.getValue(openvdb::Coord(1, 1, 0)));
EXPECT_TRUE(aTree.isValueOff(openvdb::Coord(1, 1, 0)));
// a = 1 (bg), b = 5 (bg)
EXPECT_EQ(op(one, five), aTree.getValue(openvdb::Coord(1000, 1, 2)));
EXPECT_TRUE(aTree.isValueOff(openvdb::Coord(1000, 1, 2)));
}
// As above, but combining the A grid into the B grid
{
TreeT aTree(/*bg=*/one);
aTree.setValueOn(openvdb::Coord(0, 0, 0), three);
aTree.setValueOn(openvdb::Coord(0, 0, 1), three);
aTree.setValueOn(openvdb::Coord(0, 0, 2), aTree.background());
aTree.setValueOn(openvdb::Coord(0, 1, 2), aTree.background());
aTree.setValueOff(openvdb::Coord(1, 0, 0), three);
aTree.setValueOff(openvdb::Coord(1, 0, 1), three);
TreeT bTree(five);
bTree.setValueOn(openvdb::Coord(0, 0, 0), minusOne);
bTree.setValueOn(openvdb::Coord(0, 1, 0), four);
bTree.setValueOn(openvdb::Coord(0, 1, 2), minusTwo);
bTree.setValueOff(openvdb::Coord(1, 0, 0), minusOne);
bTree.setValueOff(openvdb::Coord(1, 1, 0), four);
// Call bTree.compMax(aTree), bTree.compSum(aTree), etc.
comp(bTree, aTree);
// a = 3 (On), b = -1 (On)
EXPECT_EQ(op(minusOne, three), bTree.getValue(openvdb::Coord(0, 0, 0)));
// a = 3 (On), b = 5 (bg)
EXPECT_EQ(op(five, three), bTree.getValue(openvdb::Coord(0, 0, 1)));
EXPECT_TRUE(bTree.isValueOn(openvdb::Coord(0, 0, 1)));
// a = 1 (On, = bg), b = 5 (bg)
EXPECT_EQ(op(five, one), bTree.getValue(openvdb::Coord(0, 0, 2)));
EXPECT_TRUE(bTree.isValueOn(openvdb::Coord(0, 0, 2)));
// a = 1 (On, = bg), b = -2 (On)
EXPECT_EQ(op(minusTwo, one), bTree.getValue(openvdb::Coord(0, 1, 2)));
EXPECT_TRUE(bTree.isValueOn(openvdb::Coord(0, 1, 2)));
// a = 1 (bg), b = 4 (On)
EXPECT_EQ(op(four, one), bTree.getValue(openvdb::Coord(0, 1, 0)));
EXPECT_TRUE(bTree.isValueOn(openvdb::Coord(0, 1, 0)));
// a = 3 (Off), b = -1 (Off)
EXPECT_EQ(op(minusOne, three), bTree.getValue(openvdb::Coord(1, 0, 0)));
EXPECT_TRUE(bTree.isValueOff(openvdb::Coord(1, 0, 0)));
// a = 3 (Off), b = 5 (bg)
EXPECT_EQ(op(five, three), bTree.getValue(openvdb::Coord(1, 0, 1)));
EXPECT_TRUE(bTree.isValueOff(openvdb::Coord(1, 0, 1)));
// a = 1 (bg), b = 4 (Off)
EXPECT_EQ(op(four, one), bTree.getValue(openvdb::Coord(1, 1, 0)));
EXPECT_TRUE(bTree.isValueOff(openvdb::Coord(1, 1, 0)));
// a = 1 (bg), b = 5 (bg)
EXPECT_EQ(op(five, one), bTree.getValue(openvdb::Coord(1000, 1, 2)));
EXPECT_TRUE(bTree.isValueOff(openvdb::Coord(1000, 1, 2)));
}
}
////////////////////////////////////////
TEST_F(TestTreeCombine, testCombine2)
{
using openvdb::Coord;
using openvdb::Vec3d;
struct Local {
static void floatAverage(const float& a, const float& b, float& result)
{ result = 0.5f * (a + b); }
static void vec3dAverage(const Vec3d& a, const Vec3d& b, Vec3d& result)
{ result = 0.5 * (a + b); }
static void vec3dFloatMultiply(const Vec3d& a, const float& b, Vec3d& result)
{ result = a * b; }
static void vec3dBoolMultiply(const Vec3d& a, const bool& b, Vec3d& result)
{ result = a * b; }
};
const Coord c0(0, 0, 0), c1(0, 0, 1), c2(0, 1, 0), c3(1, 0, 0), c4(1000, 1, 2);
openvdb::FloatTree aFloatTree(/*bg=*/1.0), bFloatTree(5.0), outFloatTree(1.0);
aFloatTree.setValue(c0, 3.0);
aFloatTree.setValue(c1, 3.0);
bFloatTree.setValue(c0, -1.0);
bFloatTree.setValue(c2, 4.0);
outFloatTree.combine2(aFloatTree, bFloatTree, Local::floatAverage);
const float tolerance = 0.0;
// Average of set value 3 and set value -1
EXPECT_NEAR(1.0, outFloatTree.getValue(c0), tolerance);
// Average of set value 3 and bg value 5
EXPECT_NEAR(4.0, outFloatTree.getValue(c1), tolerance);
// Average of bg value 1 and set value 4
EXPECT_NEAR(2.5, outFloatTree.getValue(c2), tolerance);
// Average of bg value 1 and bg value 5
EXPECT_TRUE(outFloatTree.isValueOff(c3));
EXPECT_TRUE(outFloatTree.isValueOff(c4));
EXPECT_NEAR(3.0, outFloatTree.getValue(c3), tolerance);
EXPECT_NEAR(3.0, outFloatTree.getValue(c4), tolerance);
// As above, but combining vector grids:
const Vec3d zero(0), one(1), two(2), three(3), four(4), five(5);
openvdb::Vec3DTree aVecTree(/*bg=*/one), bVecTree(five), outVecTree(one);
aVecTree.setValue(c0, three);
aVecTree.setValue(c1, three);
bVecTree.setValue(c0, -1.0 * one);
bVecTree.setValue(c2, four);
outVecTree.combine2(aVecTree, bVecTree, Local::vec3dAverage);
// Average of set value 3 and set value -1
EXPECT_EQ(one, outVecTree.getValue(c0));
// Average of set value 3 and bg value 5
EXPECT_EQ(four, outVecTree.getValue(c1));
// Average of bg value 1 and set value 4
EXPECT_EQ(2.5 * one, outVecTree.getValue(c2));
// Average of bg value 1 and bg value 5
EXPECT_TRUE(outVecTree.isValueOff(c3));
EXPECT_TRUE(outVecTree.isValueOff(c4));
EXPECT_EQ(three, outVecTree.getValue(c3));
EXPECT_EQ(three, outVecTree.getValue(c4));
// Multiply the vector tree by the scalar tree.
{
openvdb::Vec3DTree vecTree(one);
vecTree.combine2(outVecTree, outFloatTree, Local::vec3dFloatMultiply);
// Product of set value (1, 1, 1) and set value 1
EXPECT_TRUE(vecTree.isValueOn(c0));
EXPECT_EQ(one, vecTree.getValue(c0));
// Product of set value (4, 4, 4) and set value 4
EXPECT_TRUE(vecTree.isValueOn(c1));
EXPECT_EQ(4 * 4 * one, vecTree.getValue(c1));
// Product of set value (2.5, 2.5, 2.5) and set value 2.5
EXPECT_TRUE(vecTree.isValueOn(c2));
EXPECT_EQ(2.5 * 2.5 * one, vecTree.getValue(c2));
// Product of bg value (3, 3, 3) and bg value 3
EXPECT_TRUE(vecTree.isValueOff(c3));
EXPECT_TRUE(vecTree.isValueOff(c4));
EXPECT_EQ(3 * 3 * one, vecTree.getValue(c3));
EXPECT_EQ(3 * 3 * one, vecTree.getValue(c4));
}
// Multiply the vector tree by a boolean tree.
{
openvdb::BoolTree boolTree(0);
boolTree.setValue(c0, true);
boolTree.setValue(c1, false);
boolTree.setValue(c2, true);
openvdb::Vec3DTree vecTree(one);
vecTree.combine2(outVecTree, boolTree, Local::vec3dBoolMultiply);
// Product of set value (1, 1, 1) and set value 1
EXPECT_TRUE(vecTree.isValueOn(c0));
EXPECT_EQ(one, vecTree.getValue(c0));
// Product of set value (4, 4, 4) and set value 0
EXPECT_TRUE(vecTree.isValueOn(c1));
EXPECT_EQ(zero, vecTree.getValue(c1));
// Product of set value (2.5, 2.5, 2.5) and set value 1
EXPECT_TRUE(vecTree.isValueOn(c2));
EXPECT_EQ(2.5 * one, vecTree.getValue(c2));
// Product of bg value (3, 3, 3) and bg value 0
EXPECT_TRUE(vecTree.isValueOff(c3));
EXPECT_TRUE(vecTree.isValueOff(c4));
EXPECT_EQ(zero, vecTree.getValue(c3));
EXPECT_EQ(zero, vecTree.getValue(c4));
}
// Verify that a vector tree can't be combined into a scalar tree
// (although the reverse is allowed).
{
struct Local2 {
static void f(const float& a, const Vec3d&, float& result) { result = a; }
};
openvdb::FloatTree floatTree(5.0), outTree;
openvdb::Vec3DTree vecTree(one);
EXPECT_THROW(outTree.combine2(floatTree, vecTree, Local2::f), openvdb::TypeError);
}
}
////////////////////////////////////////
TEST_F(TestTreeCombine, testBoolTree)
{
openvdb::BoolGrid::Ptr sphere = openvdb::BoolGrid::create();
unittest_util::makeSphere<openvdb::BoolGrid>(/*dim=*/openvdb::Coord(32),
/*ctr=*/openvdb::Vec3f(0),
/*radius=*/20.0, *sphere,
unittest_util::SPHERE_SPARSE_NARROW_BAND);
openvdb::BoolGrid::Ptr
aGrid = sphere->copy(),
bGrid = sphere->copy();
// CSG operations work only on level sets with a nonzero inside and outside values.
EXPECT_THROW(openvdb::tools::csgUnion(aGrid->tree(), bGrid->tree()),
openvdb::ValueError);
EXPECT_THROW(openvdb::tools::csgIntersection(aGrid->tree(), bGrid->tree()),
openvdb::ValueError);
EXPECT_THROW(openvdb::tools::csgDifference(aGrid->tree(), bGrid->tree()),
openvdb::ValueError);
openvdb::tools::compSum(aGrid->tree(), bGrid->tree());
bGrid = sphere->copy();
openvdb::tools::compMax(aGrid->tree(), bGrid->tree());
int mismatches = 0;
openvdb::BoolGrid::ConstAccessor acc = sphere->getConstAccessor();
for (openvdb::BoolGrid::ValueAllCIter it = aGrid->cbeginValueAll(); it; ++it) {
if (*it != acc.getValue(it.getCoord())) ++mismatches;
}
EXPECT_EQ(0, mismatches);
}
////////////////////////////////////////
template<typename TreeT>
void
TestTreeCombine::testCompRepl()
{
using ValueT = typename TreeT::ValueType;
const ValueT
zero = openvdb::zeroVal<ValueT>(),
minusOne = zero + (-1),
one = zero + 1,
three = zero + 3,
four = zero + 4,
five = zero + 5;
{
TreeT aTree(/*bg=*/one);
aTree.setValueOn(openvdb::Coord(0, 0, 0), three);
aTree.setValueOn(openvdb::Coord(0, 0, 1), three);
aTree.setValueOn(openvdb::Coord(0, 0, 2), aTree.background());
aTree.setValueOn(openvdb::Coord(0, 1, 2), aTree.background());
aTree.setValueOff(openvdb::Coord(1, 0, 0), three);
aTree.setValueOff(openvdb::Coord(1, 0, 1), three);
TreeT bTree(five);
bTree.setValueOn(openvdb::Coord(0, 0, 0), minusOne);
bTree.setValueOn(openvdb::Coord(0, 1, 0), four);
bTree.setValueOn(openvdb::Coord(0, 1, 2), minusOne);
bTree.setValueOff(openvdb::Coord(1, 0, 0), minusOne);
bTree.setValueOff(openvdb::Coord(1, 1, 0), four);
// Copy active voxels of bTree into aTree.
openvdb::tools::compReplace(aTree, bTree);
// a = 3 (On), b = -1 (On)
EXPECT_EQ(minusOne, aTree.getValue(openvdb::Coord(0, 0, 0)));
// a = 3 (On), b = 5 (bg)
EXPECT_EQ(three, aTree.getValue(openvdb::Coord(0, 0, 1)));
EXPECT_TRUE(aTree.isValueOn(openvdb::Coord(0, 0, 1)));
// a = 1 (On, = bg), b = 5 (bg)
EXPECT_EQ(one, aTree.getValue(openvdb::Coord(0, 0, 2)));
EXPECT_TRUE(aTree.isValueOn(openvdb::Coord(0, 0, 2)));
// a = 1 (On, = bg), b = -1 (On)
EXPECT_EQ(minusOne, aTree.getValue(openvdb::Coord(0, 1, 2)));
EXPECT_TRUE(aTree.isValueOn(openvdb::Coord(0, 1, 2)));
// a = 1 (bg), b = 4 (On)
EXPECT_EQ(four, aTree.getValue(openvdb::Coord(0, 1, 0)));
EXPECT_TRUE(aTree.isValueOn(openvdb::Coord(0, 1, 0)));
// a = 3 (Off), b = -1 (Off)
EXPECT_EQ(three, aTree.getValue(openvdb::Coord(1, 0, 0)));
EXPECT_TRUE(aTree.isValueOff(openvdb::Coord(1, 0, 0)));
// a = 3 (Off), b = 5 (bg)
EXPECT_EQ(three, aTree.getValue(openvdb::Coord(1, 0, 1)));
EXPECT_TRUE(aTree.isValueOff(openvdb::Coord(1, 0, 1)));
// a = 1 (bg), b = 4 (Off)
EXPECT_EQ(one, aTree.getValue(openvdb::Coord(1, 1, 0)));
EXPECT_TRUE(aTree.isValueOff(openvdb::Coord(1, 1, 0)));
// a = 1 (bg), b = 5 (bg)
EXPECT_EQ(one, aTree.getValue(openvdb::Coord(1000, 1, 2)));
EXPECT_TRUE(aTree.isValueOff(openvdb::Coord(1000, 1, 2)));
}
// As above, but combining the A grid into the B grid
{
TreeT aTree(/*background=*/one);
aTree.setValueOn(openvdb::Coord(0, 0, 0), three);
aTree.setValueOn(openvdb::Coord(0, 0, 1), three);
aTree.setValueOn(openvdb::Coord(0, 0, 2), aTree.background());
aTree.setValueOn(openvdb::Coord(0, 1, 2), aTree.background());
aTree.setValueOff(openvdb::Coord(1, 0, 0), three);
aTree.setValueOff(openvdb::Coord(1, 0, 1), three);
TreeT bTree(five);
bTree.setValueOn(openvdb::Coord(0, 0, 0), minusOne);
bTree.setValueOn(openvdb::Coord(0, 1, 0), four);
bTree.setValueOn(openvdb::Coord(0, 1, 2), minusOne);
bTree.setValueOff(openvdb::Coord(1, 0, 0), minusOne);
bTree.setValueOff(openvdb::Coord(1, 1, 0), four);
// Copy active voxels of aTree into bTree.
openvdb::tools::compReplace(bTree, aTree);
// a = 3 (On), b = -1 (On)
EXPECT_EQ(three, bTree.getValue(openvdb::Coord(0, 0, 0)));
// a = 3 (On), b = 5 (bg)
EXPECT_EQ(three, bTree.getValue(openvdb::Coord(0, 0, 1)));
EXPECT_TRUE(bTree.isValueOn(openvdb::Coord(0, 0, 1)));
// a = 1 (On, = bg), b = 5 (bg)
EXPECT_EQ(one, bTree.getValue(openvdb::Coord(0, 0, 2)));
EXPECT_TRUE(bTree.isValueOn(openvdb::Coord(0, 0, 2)));
// a = 1 (On, = bg), b = -1 (On)
EXPECT_EQ(one, bTree.getValue(openvdb::Coord(0, 1, 2)));
EXPECT_TRUE(bTree.isValueOn(openvdb::Coord(0, 1, 2)));
// a = 1 (bg), b = 4 (On)
EXPECT_EQ(four, bTree.getValue(openvdb::Coord(0, 1, 0)));
EXPECT_TRUE(bTree.isValueOn(openvdb::Coord(0, 1, 0)));
// a = 3 (Off), b = -1 (Off)
EXPECT_EQ(minusOne, bTree.getValue(openvdb::Coord(1, 0, 0)));
EXPECT_TRUE(bTree.isValueOff(openvdb::Coord(1, 0, 0)));
// a = 3 (Off), b = 5 (bg)
EXPECT_EQ(five, bTree.getValue(openvdb::Coord(1, 0, 1)));
EXPECT_TRUE(bTree.isValueOff(openvdb::Coord(1, 0, 1)));
// a = 1 (bg), b = 4 (Off)
EXPECT_EQ(four, bTree.getValue(openvdb::Coord(1, 1, 0)));
EXPECT_TRUE(bTree.isValueOff(openvdb::Coord(1, 1, 0)));
// a = 1 (bg), b = 5 (bg)
EXPECT_EQ(five, bTree.getValue(openvdb::Coord(1000, 1, 2)));
EXPECT_TRUE(bTree.isValueOff(openvdb::Coord(1000, 1, 2)));
}
}
////////////////////////////////////////
#ifdef DWA_OPENVDB
TEST_F(TestTreeCombine, testCsg)
{
using TreeT = openvdb::FloatTree;
using TreePtr = TreeT::Ptr;
using GridT = openvdb::Grid<TreeT>;
struct Local {
static TreePtr readFile(const std::string& fname) {
std::string filename(fname), gridName("LevelSet");
size_t space = filename.find_last_of(' ');
if (space != std::string::npos) {
gridName = filename.substr(space + 1);
filename.erase(space);
}
TreePtr tree;
openvdb::io::File file(filename);
file.open();
if (openvdb::GridBase::Ptr basePtr = file.readGrid(gridName)) {
if (GridT::Ptr gridPtr = openvdb::gridPtrCast<GridT>(basePtr)) {
tree = gridPtr->treePtr();
}
}
file.close();
return tree;
}
//static void writeFile(TreePtr tree, const std::string& filename) {
// openvdb::io::File file(filename);
// openvdb::GridPtrVec grids;
// GridT::Ptr grid = openvdb::createGrid(tree);
// grid->setName("LevelSet");
// grids.push_back(grid);
// file.write(grids);
//}
static void visitorUnion(TreeT& a, TreeT& b) { openvdb::tools::csgUnion(a, b); }
static void visitorIntersect(TreeT& a, TreeT& b) { openvdb::tools::csgIntersection(a, b); }
static void visitorDiff(TreeT& a, TreeT& b) { openvdb::tools::csgDifference(a, b); }
};
TreePtr smallTree1, smallTree2, largeTree1, largeTree2, refTree, outTree;
#if TEST_CSG_VERBOSE
openvdb::util::CpuTimer timer;
timer.start();
#endif
const std::string testDir("/work/rd/fx_tools/vdb_unittest/TestGridCombine::testCsg/");
smallTree1 = Local::readFile(testDir + "small1.vdb2 LevelSet");
EXPECT_TRUE(smallTree1.get() != nullptr);
smallTree2 = Local::readFile(testDir + "small2.vdb2 Cylinder");
EXPECT_TRUE(smallTree2.get() != nullptr);
largeTree1 = Local::readFile(testDir + "large1.vdb2 LevelSet");
EXPECT_TRUE(largeTree1.get() != nullptr);
largeTree2 = Local::readFile(testDir + "large2.vdb2 LevelSet");
EXPECT_TRUE(largeTree2.get() != nullptr);
#if TEST_CSG_VERBOSE
std::cerr << "file read: " << timer.milliseconds() << " msec\n";
#endif
#if TEST_CSG_VERBOSE
std::cerr << "\n<union>\n";
#endif
refTree = Local::readFile(testDir + "small_union.vdb2");
outTree = visitCsg(*smallTree1, *smallTree2, *refTree, Local::visitorUnion);
//Local::writeFile(outTree, "small_union_out.vdb2");
refTree = Local::readFile(testDir + "large_union.vdb2");
outTree = visitCsg(*largeTree1, *largeTree2, *refTree, Local::visitorUnion);
//Local::writeFile(outTree, "large_union_out.vdb2");
#if TEST_CSG_VERBOSE
std::cerr << "\n<intersection>\n";
#endif
refTree = Local::readFile(testDir + "small_intersection.vdb2");
outTree = visitCsg(*smallTree1, *smallTree2, *refTree, Local::visitorIntersect);
//Local::writeFile(outTree, "small_intersection_out.vdb2");
refTree = Local::readFile(testDir + "large_intersection.vdb2");
outTree = visitCsg(*largeTree1, *largeTree2, *refTree, Local::visitorIntersect);
//Local::writeFile(outTree, "large_intersection_out.vdb2");
#if TEST_CSG_VERBOSE
std::cerr << "\n<difference>\n";
#endif
refTree = Local::readFile(testDir + "small_difference.vdb2");
outTree = visitCsg(*smallTree1, *smallTree2, *refTree, Local::visitorDiff);
//Local::writeFile(outTree, "small_difference_out.vdb2");
refTree = Local::readFile(testDir + "large_difference.vdb2");
outTree = visitCsg(*largeTree1, *largeTree2, *refTree, Local::visitorDiff);
//Local::writeFile(outTree, "large_difference_out.vdb2");
}
#endif
template<typename TreeT, typename VisitorT>
typename TreeT::Ptr
TestTreeCombine::visitCsg(const TreeT& aInputTree, const TreeT& bInputTree,
const TreeT& refTree, const VisitorT& visitor)
{
using TreePtr = typename TreeT::Ptr;
#if TEST_CSG_VERBOSE
openvdb::util::CpuTimer timer;
timer.start();
#endif
TreePtr aTree(new TreeT(aInputTree));
TreeT bTree(bInputTree);
#if TEST_CSG_VERBOSE
std::cerr << "deep copy: " << timer.milliseconds() << " msec\n";
#endif
#if (TEST_CSG_VERBOSE > 1)
std::cerr << "\nA grid:\n";
aTree->print(std::cerr, /*verbose=*/3);
std::cerr << "\nB grid:\n";
bTree.print(std::cerr, /*verbose=*/3);
std::cerr << "\nExpected:\n";
refTree.print(std::cerr, /*verbose=*/3);
std::cerr << "\n";
#endif
// Compute the CSG combination of the two grids.
#if TEST_CSG_VERBOSE
timer.start();
#endif
visitor(*aTree, bTree);
#if TEST_CSG_VERBOSE
std::cerr << "combine: " << timer.milliseconds() << " msec\n";
#endif
#if (TEST_CSG_VERBOSE > 1)
std::cerr << "\nActual:\n";
aTree->print(std::cerr, /*verbose=*/3);
#endif
std::ostringstream aInfo, refInfo;
aTree->print(aInfo, /*verbose=*/2);
refTree.print(refInfo, /*verbose=*/2);
EXPECT_EQ(refInfo.str(), aInfo.str());
EXPECT_TRUE(aTree->hasSameTopology(refTree));
return aTree;
}
////////////////////////////////////////
TEST_F(TestTreeCombine, testCsgCopy)
{
const float voxelSize = 0.2f;
const float radius = 3.0f;
openvdb::Vec3f center(0.0f, 0.0f, 0.0f);
openvdb::FloatGrid::Ptr gridA =
openvdb::tools::createLevelSetSphere<openvdb::FloatGrid>(radius, center, voxelSize);
openvdb::Coord ijkA = gridA->transform().worldToIndexNodeCentered(center);
EXPECT_TRUE(gridA->tree().getValue(ijkA) < 0.0f); // center is inside
center.x() += 3.5f;
openvdb::FloatGrid::Ptr gridB =
openvdb::tools::createLevelSetSphere<openvdb::FloatGrid>(radius, center, voxelSize);
openvdb::Coord ijkB = gridA->transform().worldToIndexNodeCentered(center);
EXPECT_TRUE(gridB->tree().getValue(ijkB) < 0.0f); // center is inside
openvdb::FloatGrid::Ptr unionGrid = openvdb::tools::csgUnionCopy(*gridA, *gridB);
openvdb::FloatGrid::Ptr intersectionGrid = openvdb::tools::csgIntersectionCopy(*gridA, *gridB);
openvdb::FloatGrid::Ptr differenceGrid = openvdb::tools::csgDifferenceCopy(*gridA, *gridB);
EXPECT_TRUE(unionGrid.get() != nullptr);
EXPECT_TRUE(intersectionGrid.get() != nullptr);
EXPECT_TRUE(differenceGrid.get() != nullptr);
EXPECT_TRUE(!unionGrid->empty());
EXPECT_TRUE(!intersectionGrid->empty());
EXPECT_TRUE(!differenceGrid->empty());
// test inside / outside sign
EXPECT_TRUE(unionGrid->tree().getValue(ijkA) < 0.0f);
EXPECT_TRUE(unionGrid->tree().getValue(ijkB) < 0.0f);
EXPECT_TRUE(!(intersectionGrid->tree().getValue(ijkA) < 0.0f));
EXPECT_TRUE(!(intersectionGrid->tree().getValue(ijkB) < 0.0f));
EXPECT_TRUE(differenceGrid->tree().getValue(ijkA) < 0.0f);
EXPECT_TRUE(!(differenceGrid->tree().getValue(ijkB) < 0.0f));
}
////////////////////////////////////////
TEST_F(TestTreeCombine, testCompActiveLeafVoxels)
{
{//replace float tree (default argument)
openvdb::FloatTree srcTree(0.0f), dstTree(0.0f);
dstTree.setValue(openvdb::Coord(1,1,1), 1.0f);
srcTree.setValue(openvdb::Coord(1,1,1), 2.0f);
srcTree.setValue(openvdb::Coord(8,8,8), 3.0f);
EXPECT_EQ(1, int(dstTree.leafCount()));
EXPECT_EQ(2, int(srcTree.leafCount()));
EXPECT_EQ(1.0f, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(0.0f, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(!dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
openvdb::tools::compActiveLeafVoxels(srcTree, dstTree);
EXPECT_EQ(2, int(dstTree.leafCount()));
EXPECT_EQ(0, int(srcTree.leafCount()));
EXPECT_EQ(2.0f, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(3.0f, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
}
{//replace float tree (lambda expression)
openvdb::FloatTree srcTree(0.0f), dstTree(0.0f);
dstTree.setValue(openvdb::Coord(1,1,1), 1.0f);
srcTree.setValue(openvdb::Coord(1,1,1), 2.0f);
srcTree.setValue(openvdb::Coord(8,8,8), 3.0f);
EXPECT_EQ(1, int(dstTree.leafCount()));
EXPECT_EQ(2, int(srcTree.leafCount()));
EXPECT_EQ(1.0f, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(0.0f, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(!dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
openvdb::tools::compActiveLeafVoxels(srcTree, dstTree, [](float &d, float s){d=s;});
EXPECT_EQ(2, int(dstTree.leafCount()));
EXPECT_EQ(0, int(srcTree.leafCount()));
EXPECT_EQ(2.0f, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(3.0f, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
}
{//add float tree
openvdb::FloatTree srcTree(0.0f), dstTree(0.0f);
dstTree.setValue(openvdb::Coord(1,1,1), 1.0f);
srcTree.setValue(openvdb::Coord(1,1,1), 2.0f);
srcTree.setValue(openvdb::Coord(8,8,8), 3.0f);
EXPECT_EQ(1, int(dstTree.leafCount()));
EXPECT_EQ(2, int(srcTree.leafCount()));
EXPECT_EQ(1.0f, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(0.0f, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(!dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
openvdb::tools::compActiveLeafVoxels(srcTree, dstTree, [](float &d, float s){d+=s;});
EXPECT_EQ(2, int(dstTree.leafCount()));
EXPECT_EQ(0, int(srcTree.leafCount()));
EXPECT_EQ(3.0f, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(3.0f, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
}
{
using BufferT = openvdb::FloatTree::LeafNodeType::Buffer;
EXPECT_TRUE((std::is_same<BufferT::ValueType, BufferT::StorageType>::value));
}
{
using BufferT = openvdb::Vec3fTree::LeafNodeType::Buffer;
EXPECT_TRUE((std::is_same<BufferT::ValueType, BufferT::StorageType>::value));
}
{
using BufferT = openvdb::BoolTree::LeafNodeType::Buffer;
EXPECT_TRUE(!(std::is_same<BufferT::ValueType, BufferT::StorageType>::value));
}
{
using BufferT = openvdb::MaskTree::LeafNodeType::Buffer;
EXPECT_TRUE(!(std::is_same<BufferT::ValueType, BufferT::StorageType>::value));
}
{//replace bool tree
openvdb::BoolTree srcTree(false), dstTree(false);
dstTree.setValue(openvdb::Coord(1,1,1), true);
srcTree.setValue(openvdb::Coord(1,1,1), false);
srcTree.setValue(openvdb::Coord(8,8,8), true);
//(9,8,8) is inactive but true so it should have no effect
srcTree.setValueOnly(openvdb::Coord(9,8,8), true);
EXPECT_EQ(1, int(dstTree.leafCount()));
EXPECT_EQ(2, int(srcTree.leafCount()));
EXPECT_EQ(true, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(false, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(!dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
EXPECT_EQ(true, srcTree.getValue(openvdb::Coord(9, 8, 8)));
EXPECT_TRUE(!srcTree.isValueOn(openvdb::Coord(9, 8, 8)));
using Word = openvdb::BoolTree::LeafNodeType::Buffer::WordType;
openvdb::tools::compActiveLeafVoxels(srcTree, dstTree, [](Word &d, Word s){d=s;});
EXPECT_EQ(2, int(dstTree.leafCount()));
EXPECT_EQ(0, int(srcTree.leafCount()));
EXPECT_EQ(false, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(true, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
}
{// mask tree
openvdb::MaskTree srcTree(false), dstTree(false);
dstTree.setValueOn(openvdb::Coord(1,1,1));
srcTree.setValueOn(openvdb::Coord(1,1,1));
srcTree.setValueOn(openvdb::Coord(8,8,8));
EXPECT_EQ(1, int(dstTree.leafCount()));
EXPECT_EQ(2, int(srcTree.leafCount()));
EXPECT_EQ(true, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(false, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(!dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
openvdb::tools::compActiveLeafVoxels(srcTree, dstTree);
EXPECT_EQ(2, int(dstTree.leafCount()));
EXPECT_EQ(0, int(srcTree.leafCount()));
EXPECT_EQ(true, dstTree.getValue(openvdb::Coord(1, 1, 1)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(1, 1, 1)));
EXPECT_EQ(true, dstTree.getValue(openvdb::Coord(8, 8, 8)));
EXPECT_TRUE(dstTree.isValueOn(openvdb::Coord(8, 8, 8)));
}
}
////////////////////////////////////////
| 37,795 | C++ | 36.833834 | 101 | 0.607911 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/unittest/TestPointGroup.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
#include "gtest/gtest.h"
#include <openvdb/points/PointGroup.h>
#include <openvdb/points/PointCount.h>
#include <openvdb/points/PointConversion.h>
#include <cstdio> // for std::remove()
#include <cstdlib> // for std::getenv()
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#ifdef _MSC_VER
#include <windows.h>
#endif
using namespace openvdb;
using namespace openvdb::points;
class TestPointGroup: public ::testing::Test
{
public:
void SetUp() override { openvdb::initialize(); }
void TearDown() override { openvdb::uninitialize(); }
}; // class TestPointGroup
////////////////////////////////////////
class FirstFilter
{
public:
static bool initialized() { return true; }
static index::State state() { return index::PARTIAL; }
template <typename LeafT>
static index::State state(const LeafT&) { return index::PARTIAL; }
template <typename LeafT> void reset(const LeafT&) { }
template <typename IterT> bool valid(const IterT& iter) const
{
return *iter == 0;
}
}; // class FirstFilter
////////////////////////////////////////
namespace {
bool testStringVector(std::vector<Name>& input)
{
return input.size() == 0;
}
bool testStringVector(std::vector<Name>& input, const Name& name1)
{
if (input.size() != 1) return false;
if (input[0] != name1) return false;
return true;
}
bool testStringVector(std::vector<Name>& input, const Name& name1, const Name& name2)
{
if (input.size() != 2) return false;
if (input[0] != name1) return false;
if (input[1] != name2) return false;
return true;
}
} // namespace
TEST_F(TestPointGroup, testDescriptor)
{
// test missing groups deletion
{ // no groups, empty Descriptor
std::vector<std::string> groups;
AttributeSet::Descriptor descriptor;
deleteMissingPointGroups(groups, descriptor);
EXPECT_TRUE(testStringVector(groups));
}
{ // one group, empty Descriptor
std::vector<std::string> groups{"group1"};
AttributeSet::Descriptor descriptor;
deleteMissingPointGroups(groups, descriptor);
EXPECT_TRUE(testStringVector(groups));
}
{ // one group, Descriptor with same group
std::vector<std::string> groups{"group1"};
AttributeSet::Descriptor descriptor;
descriptor.setGroup("group1", 0);
deleteMissingPointGroups(groups, descriptor);
EXPECT_TRUE(testStringVector(groups, "group1"));
}
{ // one group, Descriptor with different group
std::vector<std::string> groups{"group1"};
AttributeSet::Descriptor descriptor;
descriptor.setGroup("group2", 0);
deleteMissingPointGroups(groups, descriptor);
EXPECT_TRUE(testStringVector(groups));
}
{ // three groups, Descriptor with three groups, one different
std::vector<std::string> groups{"group1", "group3", "group4"};
AttributeSet::Descriptor descriptor;
descriptor.setGroup("group1", 0);
descriptor.setGroup("group2", 0);
descriptor.setGroup("group4", 0);
deleteMissingPointGroups(groups, descriptor);
EXPECT_TRUE(testStringVector(groups, "group1", "group4"));
}
}
////////////////////////////////////////
TEST_F(TestPointGroup, testAppendDrop)
{
std::vector<Vec3s> positions{{1, 1, 1}, {1, 10, 1}, {10, 1, 1}, {10, 10, 1}};
const float voxelSize(1.0);
math::Transform::Ptr transform(math::Transform::createLinearTransform(voxelSize));
PointDataGrid::Ptr grid = createPointDataGrid<NullCodec, PointDataGrid>(positions, *transform);
PointDataTree& tree = grid->tree();
// check one leaf per point
EXPECT_EQ(tree.leafCount(), Index32(4));
// retrieve first and last leaf attribute sets
PointDataTree::LeafCIter leafIter = tree.cbeginLeaf();
const AttributeSet& attributeSet = leafIter->attributeSet();
++leafIter;
++leafIter;
++leafIter;
const AttributeSet& attributeSet4 = leafIter->attributeSet();
{ // throw on append or drop an empty group
EXPECT_THROW(appendGroup(tree, ""), openvdb::KeyError);
EXPECT_THROW(dropGroup(tree, ""), openvdb::KeyError);
}
{ // append a group
appendGroup(tree, "test");
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(1));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test"));
EXPECT_TRUE(attributeSet4.descriptor().hasGroup("test"));
}
{ // append a group with non-unique name (repeat the append)
appendGroup(tree, "test");
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(1));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test"));
EXPECT_TRUE(attributeSet4.descriptor().hasGroup("test"));
}
{ // append multiple groups
std::vector<Name> names{"test2", "test3"};
appendGroups(tree, names);
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(3));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test"));
EXPECT_TRUE(attributeSet4.descriptor().hasGroup("test"));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test2"));
EXPECT_TRUE(attributeSet4.descriptor().hasGroup("test2"));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test3"));
EXPECT_TRUE(attributeSet4.descriptor().hasGroup("test3"));
}
{ // append to a copy
PointDataTree tree2(tree);
appendGroup(tree2, "copy1");
EXPECT_TRUE(!attributeSet.descriptor().hasGroup("copy1"));
EXPECT_TRUE(tree2.beginLeaf()->attributeSet().descriptor().hasGroup("copy1"));
}
{ // drop a group
dropGroup(tree, "test2");
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(2));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test"));
EXPECT_TRUE(attributeSet4.descriptor().hasGroup("test"));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test3"));
EXPECT_TRUE(attributeSet4.descriptor().hasGroup("test3"));
}
{ // drop multiple groups
std::vector<Name> names{"test", "test3"};
dropGroups(tree, names);
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(0));
}
{ // drop a copy
appendGroup(tree, "copy2");
PointDataTree tree2(tree);
dropGroup(tree2, "copy2");
EXPECT_TRUE(attributeSet.descriptor().hasGroup("copy2"));
EXPECT_TRUE(!tree2.beginLeaf()->attributeSet().descriptor().hasGroup("copy2"));
dropGroup(tree, "copy2");
}
{ // set group membership
appendGroup(tree, "test");
setGroup(tree, "test", true);
GroupFilter filter("test", tree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(tree, filter), Index64(4));
setGroup(tree, "test", false);
EXPECT_EQ(pointCount(tree, filter), Index64(0));
dropGroup(tree, "test");
}
{ // drop all groups
appendGroup(tree, "test");
appendGroup(tree, "test2");
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(2));
EXPECT_EQ(attributeSet.descriptor().count(GroupAttributeArray::attributeType()), size_t(1));
dropGroups(tree);
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(0));
EXPECT_EQ(attributeSet.descriptor().count(GroupAttributeArray::attributeType()), size_t(0));
}
{ // check that newly added groups have empty group membership
// recreate the grid with 3 points in one leaf
positions = {{1, 1, 1}, {1, 2, 1}, {2, 1, 1}};
grid = createPointDataGrid<NullCodec, PointDataGrid>(positions, *transform);
PointDataTree& newTree = grid->tree();
appendGroup(newTree, "test");
// test that a completely new group (with a new group attribute)
// has empty membership
EXPECT_TRUE(newTree.cbeginLeaf());
GroupFilter filter("test", newTree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(newTree, filter), Index64(0));
// check that membership in a group that was not created with a
// new attribute array is still empty.
// we will append a second group, set its membership, then
// drop it and append a new group with the same name again
appendGroup(newTree, "test2");
PointDataTree::LeafIter leafIter2 = newTree.beginLeaf();
EXPECT_TRUE(leafIter2);
GroupWriteHandle test2Handle = leafIter2->groupWriteHandle("test2");
test2Handle.set(0, true);
test2Handle.set(2, true);
GroupFilter filter2("test2", newTree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(newTree, filter2), Index64(2));
// drop and re-add group
dropGroup(newTree, "test2");
appendGroup(newTree, "test2");
// check that group is fully cleared and does not have previously existing data
EXPECT_EQ(pointCount(newTree, filter2), Index64(0));
}
}
TEST_F(TestPointGroup, testCompact)
{
std::vector<Vec3s> positions{{1, 1, 1}};
const float voxelSize(1.0);
math::Transform::Ptr transform(math::Transform::createLinearTransform(voxelSize));
PointDataGrid::Ptr grid = createPointDataGrid<NullCodec, PointDataGrid>(positions, *transform);
PointDataTree& tree = grid->tree();
// check one leaf
EXPECT_EQ(tree.leafCount(), Index32(1));
// retrieve first and last leaf attribute sets
PointDataTree::LeafCIter leafIter = tree.cbeginLeaf();
const AttributeSet& attributeSet = leafIter->attributeSet();
std::stringstream ss;
{ // append nine groups
for (int i = 0; i < 8; i++) {
ss.str("");
ss << "test" << i;
appendGroup(tree, ss.str());
}
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(8));
EXPECT_EQ(attributeSet.descriptor().count(GroupAttributeArray::attributeType()), size_t(1));
appendGroup(tree, "test8");
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test0"));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test7"));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test8"));
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(9));
EXPECT_EQ(attributeSet.descriptor().count(GroupAttributeArray::attributeType()), size_t(2));
}
{ // drop first attribute then compact
dropGroup(tree, "test5", /*compact=*/false);
EXPECT_TRUE(!attributeSet.descriptor().hasGroup("test5"));
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(8));
EXPECT_EQ(attributeSet.descriptor().count(GroupAttributeArray::attributeType()), size_t(2));
compactGroups(tree);
EXPECT_TRUE(!attributeSet.descriptor().hasGroup("test5"));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test7"));
EXPECT_TRUE(attributeSet.descriptor().hasGroup("test8"));
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(8));
EXPECT_EQ(attributeSet.descriptor().count(GroupAttributeArray::attributeType()), size_t(1));
}
{ // append seventeen groups, drop most of them, then compact
for (int i = 0; i < 17; i++) {
ss.str("");
ss << "test" << i;
appendGroup(tree, ss.str());
}
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(17));
EXPECT_EQ(attributeSet.descriptor().count(GroupAttributeArray::attributeType()), size_t(3));
// delete all but 0, 5, 9, 15
for (int i = 0; i < 17; i++) {
if (i == 0 || i == 5 || i == 9 || i == 15) continue;
ss.str("");
ss << "test" << i;
dropGroup(tree, ss.str(), /*compact=*/false);
}
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(4));
EXPECT_EQ(attributeSet.descriptor().count(GroupAttributeArray::attributeType()), size_t(3));
// make a copy
PointDataTree tree2(tree);
// compact - should now occupy one attribute
compactGroups(tree);
EXPECT_EQ(attributeSet.descriptor().groupMap().size(), size_t(4));
EXPECT_EQ(attributeSet.descriptor().count(GroupAttributeArray::attributeType()), size_t(1));
// check descriptor has been deep copied
EXPECT_EQ(tree2.cbeginLeaf()->attributeSet().descriptor().groupMap().size(), size_t(4));
EXPECT_EQ(tree2.cbeginLeaf()->attributeSet().descriptor().count(GroupAttributeArray::attributeType()), size_t(3));
}
}
TEST_F(TestPointGroup, testSet)
{
// four points in the same leaf
std::vector<Vec3s> positions = {
{1, 1, 1},
{1, 2, 1},
{2, 1, 1},
{2, 2, 1},
{100, 100, 100},
{100, 101, 100}
};
const float voxelSize(1.0);
math::Transform::Ptr transform(math::Transform::createLinearTransform(voxelSize));
const PointAttributeVector<Vec3s> pointList(positions);
openvdb::tools::PointIndexGrid::Ptr pointIndexGrid =
openvdb::tools::createPointIndexGrid<openvdb::tools::PointIndexGrid>(pointList, *transform);
PointDataGrid::Ptr grid = createPointDataGrid<NullCodec, PointDataGrid>(*pointIndexGrid, pointList, *transform);
PointDataTree& tree = grid->tree();
appendGroup(tree, "test");
EXPECT_EQ(pointCount(tree), Index64(6));
GroupFilter filter("test", tree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(tree, filter), Index64(0));
// copy tree for descriptor sharing test
PointDataTree tree2(tree);
std::vector<short> membership{1, 0, 1, 1, 0, 1};
// test add to group
setGroup(tree, "test", true);
EXPECT_EQ(pointCount(tree, filter), Index64(6));
// test nothing is done if the index tree contains no valid indices
tools::PointIndexGrid::Ptr tmpIndexGrid = tools::PointIndexGrid::create();
setGroup(tree, tmpIndexGrid->tree(), {0,0,0,0,0,0}, "test", /*remove*/true);
EXPECT_EQ(Index64(6), pointCount(tree, filter));
// test throw on out of range index
auto indexLeaf = tmpIndexGrid->tree().touchLeaf(tree.cbeginLeaf()->origin());
indexLeaf->indices().emplace_back(membership.size());
EXPECT_THROW(setGroup(tree, tmpIndexGrid->tree(), membership, "test"), IndexError);
EXPECT_EQ(Index64(6), pointCount(tree, filter));
// test remove flag
setGroup(tree, pointIndexGrid->tree(), membership, "test", /*remove*/false);
EXPECT_EQ(Index64(6), pointCount(tree, filter));
setGroup(tree, pointIndexGrid->tree(), membership, "test", /*remove*/true);
EXPECT_EQ(Index64(4), pointCount(tree, filter));
setGroup(tree, pointIndexGrid->tree(), {0,1,0,0,1,0}, "test", /*remove*/false);
EXPECT_EQ(Index64(6), pointCount(tree, filter));
setGroup(tree, pointIndexGrid->tree(), membership, "test", /*remove*/true);
// check that descriptor remains shared
appendGroup(tree2, "copy1");
EXPECT_TRUE(!tree.cbeginLeaf()->attributeSet().descriptor().hasGroup("copy1"));
dropGroup(tree2, "copy1");
EXPECT_EQ(pointCount(tree), Index64(6));
GroupFilter filter2("test", tree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(tree, filter2), Index64(4));
{ // IO
// setup temp directory
std::string tempDir;
if (const char* dir = std::getenv("TMPDIR")) tempDir = dir;
#ifdef _MSC_VER
if (tempDir.empty()) {
char tempDirBuffer[MAX_PATH+1];
int tempDirLen = GetTempPath(MAX_PATH+1, tempDirBuffer);
EXPECT_TRUE(tempDirLen > 0 && tempDirLen <= MAX_PATH);
tempDir = tempDirBuffer;
}
#else
if (tempDir.empty()) tempDir = P_tmpdir;
#endif
std::string filename;
// write out grid to a temp file
{
filename = tempDir + "/openvdb_test_point_load";
io::File fileOut(filename);
GridCPtrVec grids{grid};
fileOut.write(grids);
}
// read test groups
{
io::File fileIn(filename);
fileIn.open();
GridPtrVecPtr grids = fileIn.getGrids();
fileIn.close();
EXPECT_EQ(grids->size(), size_t(1));
PointDataGrid::Ptr inputGrid = GridBase::grid<PointDataGrid>((*grids)[0]);
PointDataTree& treex = inputGrid->tree();
EXPECT_TRUE(treex.cbeginLeaf());
const PointDataGrid::TreeType::LeafNodeType& leaf = *treex.cbeginLeaf();
const AttributeSet::Descriptor& descriptor = leaf.attributeSet().descriptor();
EXPECT_TRUE(descriptor.hasGroup("test"));
EXPECT_EQ(descriptor.groupMap().size(), size_t(1));
EXPECT_EQ(pointCount(treex), Index64(6));
GroupFilter filter3("test", leaf.attributeSet());
EXPECT_EQ(pointCount(treex, filter3), Index64(4));
}
std::remove(filename.c_str());
}
}
TEST_F(TestPointGroup, testFilter)
{
const float voxelSize(1.0);
math::Transform::Ptr transform(math::Transform::createLinearTransform(voxelSize));
PointDataGrid::Ptr grid;
{ // four points in the same leaf
std::vector<Vec3s> positions = {
{1, 1, 1},
{1, 2, 1},
{2, 1, 1},
{2, 2, 1},
{100, 100, 100},
{100, 101, 100}
};
const PointAttributeVector<Vec3s> pointList(positions);
openvdb::tools::PointIndexGrid::Ptr pointIndexGrid =
openvdb::tools::createPointIndexGrid<openvdb::tools::PointIndexGrid>(pointList, *transform);
grid = createPointDataGrid<NullCodec, PointDataGrid>(*pointIndexGrid, pointList, *transform);
}
PointDataTree& tree = grid->tree();
{ // first point filter
appendGroup(tree, "first");
EXPECT_EQ(pointCount(tree), Index64(6));
GroupFilter filter("first", tree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(tree, filter), Index64(0));
FirstFilter filter2;
setGroupByFilter<PointDataTree, FirstFilter>(tree, "first", filter2);
auto iter = tree.cbeginLeaf();
for ( ; iter; ++iter) {
EXPECT_EQ(iter->groupPointCount("first"), Index64(1));
}
GroupFilter filter3("first", tree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(tree, filter3), Index64(2));
}
const openvdb::BBoxd bbox(openvdb::Vec3d(0, 1.5, 0), openvdb::Vec3d(101, 100.5, 101));
{ // bbox filter
appendGroup(tree, "bbox");
EXPECT_EQ(pointCount(tree), Index64(6));
GroupFilter filter("bbox", tree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(tree, filter), Index64(0));
BBoxFilter filter2(*transform, bbox);
setGroupByFilter<PointDataTree, BBoxFilter>(tree, "bbox", filter2);
GroupFilter filter3("bbox", tree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(tree, filter3), Index64(3));
}
{ // first point filter and bbox filter (intersection of the above two filters)
appendGroup(tree, "first_bbox");
EXPECT_EQ(pointCount(tree), Index64(6));
GroupFilter filter("first_bbox", tree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(tree, filter), Index64(0));
using FirstBBoxFilter = BinaryFilter<FirstFilter, BBoxFilter>;
FirstFilter firstFilter;
BBoxFilter bboxFilter(*transform, bbox);
FirstBBoxFilter filter2(firstFilter, bboxFilter);
setGroupByFilter<PointDataTree, FirstBBoxFilter>(tree, "first_bbox", filter2);
GroupFilter filter3("first_bbox", tree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(tree, filter3), Index64(1));
std::vector<Vec3f> positions;
for (auto iter = tree.cbeginLeaf(); iter; ++iter) {
GroupFilter filterx("first_bbox", iter->attributeSet());
auto filterIndexIter = iter->beginIndexOn(filterx);
auto handle = AttributeHandle<Vec3f>::create(iter->attributeArray("P"));
for ( ; filterIndexIter; ++filterIndexIter) {
const openvdb::Coord ijk = filterIndexIter.getCoord();
positions.push_back(handle->get(*filterIndexIter) + ijk.asVec3d());
}
}
EXPECT_EQ(positions.size(), size_t(1));
EXPECT_EQ(positions[0], Vec3f(100, 100, 100));
}
{ // add 1000 points in three leafs (positions aren't important)
std::vector<Vec3s> positions(1000, {1, 1, 1});
positions.insert(positions.end(), 1000, {1, 1, 9});
positions.insert(positions.end(), 1000, {9, 9, 9});
const PointAttributeVector<Vec3s> pointList(positions);
openvdb::tools::PointIndexGrid::Ptr pointIndexGrid =
openvdb::tools::createPointIndexGrid<openvdb::tools::PointIndexGrid>(pointList, *transform);
grid = createPointDataGrid<NullCodec, PointDataGrid>(*pointIndexGrid, pointList, *transform);
PointDataTree& newTree = grid->tree();
EXPECT_EQ(pointCount(newTree), Index64(3000));
// random - maximum
appendGroup(newTree, "random_maximum");
const Index64 target = 1001;
setGroupByRandomTarget(newTree, "random_maximum", target);
GroupFilter filter("random_maximum", newTree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(newTree, filter), target);
// random - percentage
appendGroup(newTree, "random_percentage");
setGroupByRandomPercentage(newTree, "random_percentage", 33.333333f);
GroupFilter filter2("random_percentage", newTree.cbeginLeaf()->attributeSet());
EXPECT_EQ(pointCount(newTree, filter2), Index64(1000));
}
}
| 22,362 | C++ | 31.935199 | 122 | 0.611752 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/unittest/TestMath.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
#include "gtest/gtest.h"
#include <openvdb/Exceptions.h>
#include <openvdb/math/Math.h>
#include <openvdb/Types.h>
#include <type_traits>
#include <vector>
class TestMath: public ::testing::Test
{
};
// This suite of tests obviously needs to be expanded!
TEST_F(TestMath, testAll)
{
using namespace openvdb;
{// Sign
EXPECT_EQ(math::Sign( 3 ), 1);
EXPECT_EQ(math::Sign(-1.0 ),-1);
EXPECT_EQ(math::Sign( 0.0f), 0);
}
{// SignChange
EXPECT_TRUE( math::SignChange( -1, 1));
EXPECT_TRUE(!math::SignChange( 0.0f, 0.5f));
EXPECT_TRUE( math::SignChange( 0.0f,-0.5f));
EXPECT_TRUE( math::SignChange(-0.1, 0.0001));
}
{// isApproxZero
EXPECT_TRUE( math::isApproxZero( 0.0f));
EXPECT_TRUE(!math::isApproxZero( 9.0e-6f));
EXPECT_TRUE(!math::isApproxZero(-9.0e-6f));
EXPECT_TRUE( math::isApproxZero( 9.0e-9f));
EXPECT_TRUE( math::isApproxZero(-9.0e-9f));
EXPECT_TRUE( math::isApproxZero( 0.01, 0.1));
}
{// Cbrt
const double a = math::Cbrt(3.0);
EXPECT_TRUE(math::isApproxEqual(a*a*a, 3.0, 1e-6));
}
{// isNegative
EXPECT_TRUE(!std::is_signed<unsigned int>::value);
EXPECT_TRUE(std::is_signed<int>::value);
EXPECT_TRUE(!std::is_signed<bool>::value);
//EXPECT_TRUE(std::is_signed<double>::value);//fails!
//EXPECT_TRUE(std::is_signed<float>::value);//fails!
EXPECT_TRUE( math::isNegative(-1.0f));
EXPECT_TRUE(!math::isNegative( 1.0f));
EXPECT_TRUE( math::isNegative(-1.0));
EXPECT_TRUE(!math::isNegative( 1.0));
EXPECT_TRUE(!math::isNegative(true));
EXPECT_TRUE(!math::isNegative(false));
EXPECT_TRUE(!math::isNegative(1u));
EXPECT_TRUE( math::isNegative(-1));
EXPECT_TRUE(!math::isNegative( 1));
}
{// zeroVal
EXPECT_EQ(zeroVal<bool>(), false);
EXPECT_EQ(zeroVal<int>(), int(0));
EXPECT_EQ(zeroVal<float>(), 0.0f);
EXPECT_EQ(zeroVal<double>(), 0.0);
EXPECT_EQ(zeroVal<Vec3i>(), Vec3i(0,0,0));
EXPECT_EQ(zeroVal<Vec3s>(), Vec3s(0,0,0));
EXPECT_EQ(zeroVal<Vec3d>(), Vec3d(0,0,0));
EXPECT_EQ(zeroVal<Quats>(), Quats::zero());
EXPECT_EQ(zeroVal<Quatd>(), Quatd::zero());
EXPECT_EQ(zeroVal<Mat3s>(), Mat3s::zero());
EXPECT_EQ(zeroVal<Mat3d>(), Mat3d::zero());
EXPECT_EQ(zeroVal<Mat4s>(), Mat4s::zero());
EXPECT_EQ(zeroVal<Mat4d>(), Mat4d::zero());
}
}
TEST_F(TestMath, testRandomInt)
{
using openvdb::math::RandomInt;
int imin = -3, imax = 11;
RandomInt rnd(/*seed=*/42, imin, imax);
// Generate a sequence of random integers and verify that they all fall
// in the interval [imin, imax].
std::vector<int> seq(100);
for (int i = 0; i < 100; ++i) {
seq[i] = rnd();
EXPECT_TRUE(seq[i] >= imin);
EXPECT_TRUE(seq[i] <= imax);
}
// Verify that generators with the same seed produce the same sequence.
rnd = RandomInt(42, imin, imax);
for (int i = 0; i < 100; ++i) {
int r = rnd();
EXPECT_EQ(seq[i], r);
}
// Verify that generators with different seeds produce different sequences.
rnd = RandomInt(101, imin, imax);
std::vector<int> newSeq(100);
for (int i = 0; i < 100; ++i) newSeq[i] = rnd();
EXPECT_TRUE(newSeq != seq);
// Temporarily change the range.
imin = -5; imax = 6;
for (int i = 0; i < 100; ++i) {
int r = rnd(imin, imax);
EXPECT_TRUE(r >= imin);
EXPECT_TRUE(r <= imax);
}
// Verify that the range change was temporary.
imin = -3; imax = 11;
for (int i = 0; i < 100; ++i) {
int r = rnd();
EXPECT_TRUE(r >= imin);
EXPECT_TRUE(r <= imax);
}
// Permanently change the range.
imin = -5; imax = 6;
rnd.setRange(imin, imax);
for (int i = 0; i < 100; ++i) {
int r = rnd();
EXPECT_TRUE(r >= imin);
EXPECT_TRUE(r <= imax);
}
// Verify that it is OK to specify imin > imax (they are automatically swapped).
imin = 5; imax = -6;
rnd.setRange(imin, imax);
rnd = RandomInt(42, imin, imax);
}
TEST_F(TestMath, testRandom01)
{
using openvdb::math::Random01;
using openvdb::math::isApproxEqual;
Random01 rnd(/*seed=*/42);
// Generate a sequence of random numbers and verify that they all fall
// in the interval [0, 1).
std::vector<Random01::ValueType> seq(100);
for (int i = 0; i < 100; ++i) {
seq[i] = rnd();
EXPECT_TRUE(seq[i] >= 0.0);
EXPECT_TRUE(seq[i] < 1.0);
}
// Verify that generators with the same seed produce the same sequence.
rnd = Random01(42);
for (int i = 0; i < 100; ++i) {
EXPECT_NEAR(seq[i], rnd(), /*tolerance=*/1.0e-6);
}
// Verify that generators with different seeds produce different sequences.
rnd = Random01(101);
bool allEqual = true;
for (int i = 0; allEqual && i < 100; ++i) {
if (!isApproxEqual(rnd(), seq[i])) allEqual = false;
}
EXPECT_TRUE(!allEqual);
}
TEST_F(TestMath, testMinMaxIndex)
{
const openvdb::Vec3R a(-1, 2, 0);
EXPECT_EQ(size_t(0), openvdb::math::MinIndex(a));
EXPECT_EQ(size_t(1), openvdb::math::MaxIndex(a));
const openvdb::Vec3R b(-1, -2, 0);
EXPECT_EQ(size_t(1), openvdb::math::MinIndex(b));
EXPECT_EQ(size_t(2), openvdb::math::MaxIndex(b));
const openvdb::Vec3R c(5, 2, 1);
EXPECT_EQ(size_t(2), openvdb::math::MinIndex(c));
EXPECT_EQ(size_t(0), openvdb::math::MaxIndex(c));
const openvdb::Vec3R d(0, 0, 1);
EXPECT_EQ(size_t(1), openvdb::math::MinIndex(d));
EXPECT_EQ(size_t(2), openvdb::math::MaxIndex(d));
const openvdb::Vec3R e(1, 0, 0);
EXPECT_EQ(size_t(2), openvdb::math::MinIndex(e));
EXPECT_EQ(size_t(0), openvdb::math::MaxIndex(e));
const openvdb::Vec3R f(0, 1, 0);
EXPECT_EQ(size_t(2), openvdb::math::MinIndex(f));
EXPECT_EQ(size_t(1), openvdb::math::MaxIndex(f));
const openvdb::Vec3R g(1, 1, 0);
EXPECT_EQ(size_t(2), openvdb::math::MinIndex(g));
EXPECT_EQ(size_t(1), openvdb::math::MaxIndex(g));
const openvdb::Vec3R h(1, 0, 1);
EXPECT_EQ(size_t(1), openvdb::math::MinIndex(h));
EXPECT_EQ(size_t(2), openvdb::math::MaxIndex(h));
const openvdb::Vec3R i(0, 1, 1);
EXPECT_EQ(size_t(0), openvdb::math::MinIndex(i));
EXPECT_EQ(size_t(2), openvdb::math::MaxIndex(i));
const openvdb::Vec3R j(1, 1, 1);
EXPECT_EQ(size_t(2), openvdb::math::MinIndex(j));
EXPECT_EQ(size_t(2), openvdb::math::MaxIndex(j));
}
| 6,711 | C++ | 31.582524 | 84 | 0.576963 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/unittest/TestParticlesToLevelSet.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
#include <vector>
#include "gtest/gtest.h"
#include <openvdb/openvdb.h>
#include <openvdb/Exceptions.h>
#include <openvdb/Types.h>
#include <openvdb/tree/LeafNode.h>
#include <openvdb/tools/LevelSetUtil.h> // for sdfInteriorMask()
#include <openvdb/tools/ParticlesToLevelSet.h>
#define ASSERT_DOUBLES_EXACTLY_EQUAL(expected, actual) \
EXPECT_NEAR((expected), (actual), /*tolerance=*/0.0);
class TestParticlesToLevelSet: public ::testing::Test
{
public:
void SetUp() override {openvdb::initialize();}
void TearDown() override {openvdb::uninitialize();}
void writeGrid(openvdb::GridBase::Ptr grid, std::string fileName) const
{
std::cout << "\nWriting \""<<fileName<<"\" to file\n";
grid->setName("TestParticlesToLevelSet");
openvdb::GridPtrVec grids;
grids.push_back(grid);
openvdb::io::File file(fileName + ".vdb");
file.write(grids);
file.close();
}
};
class MyParticleList
{
protected:
struct MyParticle {
openvdb::Vec3R p, v;
openvdb::Real r;
};
openvdb::Real mRadiusScale;
openvdb::Real mVelocityScale;
std::vector<MyParticle> mParticleList;
public:
typedef openvdb::Vec3R PosType;
MyParticleList(openvdb::Real rScale=1, openvdb::Real vScale=1)
: mRadiusScale(rScale), mVelocityScale(vScale) {}
void add(const openvdb::Vec3R &p, const openvdb::Real &r,
const openvdb::Vec3R &v=openvdb::Vec3R(0,0,0))
{
MyParticle pa;
pa.p = p;
pa.r = r;
pa.v = v;
mParticleList.push_back(pa);
}
/// @return coordinate bbox in the space of the specified transfrom
openvdb::CoordBBox getBBox(const openvdb::GridBase& grid) {
openvdb::CoordBBox bbox;
openvdb::Coord &min= bbox.min(), &max = bbox.max();
openvdb::Vec3R pos;
openvdb::Real rad, invDx = 1/grid.voxelSize()[0];
for (size_t n=0, e=this->size(); n<e; ++n) {
this->getPosRad(n, pos, rad);
const openvdb::Vec3d xyz = grid.worldToIndex(pos);
const openvdb::Real r = rad * invDx;
for (int i=0; i<3; ++i) {
min[i] = openvdb::math::Min(min[i], openvdb::math::Floor(xyz[i] - r));
max[i] = openvdb::math::Max(max[i], openvdb::math::Ceil( xyz[i] + r));
}
}
return bbox;
}
//typedef int AttributeType;
// The methods below are only required for the unit-tests
openvdb::Vec3R pos(int n) const {return mParticleList[n].p;}
openvdb::Vec3R vel(int n) const {return mVelocityScale*mParticleList[n].v;}
openvdb::Real radius(int n) const {return mRadiusScale*mParticleList[n].r;}
//////////////////////////////////////////////////////////////////////////////
/// The methods below are the only ones required by tools::ParticleToLevelSet
/// @note We return by value since the radius and velocities are modified
/// by the scaling factors! Also these methods are all assumed to
/// be thread-safe.
/// Return the total number of particles in list.
/// Always required!
size_t size() const { return mParticleList.size(); }
/// Get the world space position of n'th particle.
/// Required by ParticledToLevelSet::rasterizeSphere(*this,radius).
void getPos(size_t n, openvdb::Vec3R&pos) const { pos = mParticleList[n].p; }
void getPosRad(size_t n, openvdb::Vec3R& pos, openvdb::Real& rad) const {
pos = mParticleList[n].p;
rad = mRadiusScale*mParticleList[n].r;
}
void getPosRadVel(size_t n, openvdb::Vec3R& pos, openvdb::Real& rad, openvdb::Vec3R& vel) const {
pos = mParticleList[n].p;
rad = mRadiusScale*mParticleList[n].r;
vel = mVelocityScale*mParticleList[n].v;
}
// The method below is only required for attribute transfer
void getAtt(size_t n, openvdb::Index32& att) const { att = openvdb::Index32(n); }
};
TEST_F(TestParticlesToLevelSet, testBlindData)
{
using BlindTypeIF = openvdb::tools::p2ls_internal::BlindData<openvdb::Index, float>;
BlindTypeIF value(openvdb::Index(8), 5.2f);
EXPECT_EQ(openvdb::Index(8), value.visible());
ASSERT_DOUBLES_EXACTLY_EQUAL(5.2f, value.blind());
BlindTypeIF value2(openvdb::Index(13), 1.6f);
{ // test equality
// only visible portion needs to be equal
BlindTypeIF blind(openvdb::Index(13), 6.7f);
EXPECT_TRUE(value2 == blind);
}
{ // test addition of two blind types
BlindTypeIF blind = value + value2;
EXPECT_EQ(openvdb::Index(8+13), blind.visible());
EXPECT_EQ(0.0f, blind.blind()); // blind values are both dropped
}
{ // test addition of blind type with visible type
BlindTypeIF blind = value + 3;
EXPECT_EQ(openvdb::Index(8+3), blind.visible());
EXPECT_EQ(5.2f, blind.blind());
}
{ // test addition of blind type with type that requires casting
// note that this will generate conversion warnings if not handled properly
BlindTypeIF blind = value + 3.7;
EXPECT_EQ(openvdb::Index(8+3), blind.visible());
EXPECT_EQ(5.2f, blind.blind());
}
}
TEST_F(TestParticlesToLevelSet, testMyParticleList)
{
MyParticleList pa;
EXPECT_EQ(0, int(pa.size()));
pa.add(openvdb::Vec3R(10,10,10), 2, openvdb::Vec3R(1,0,0));
EXPECT_EQ(1, int(pa.size()));
ASSERT_DOUBLES_EXACTLY_EQUAL(10, pa.pos(0)[0]);
ASSERT_DOUBLES_EXACTLY_EQUAL(10, pa.pos(0)[1]);
ASSERT_DOUBLES_EXACTLY_EQUAL(10, pa.pos(0)[2]);
ASSERT_DOUBLES_EXACTLY_EQUAL(1 , pa.vel(0)[0]);
ASSERT_DOUBLES_EXACTLY_EQUAL(0 , pa.vel(0)[1]);
ASSERT_DOUBLES_EXACTLY_EQUAL(0 , pa.vel(0)[2]);
ASSERT_DOUBLES_EXACTLY_EQUAL(2 , pa.radius(0));
pa.add(openvdb::Vec3R(20,20,20), 3);
EXPECT_EQ(2, int(pa.size()));
ASSERT_DOUBLES_EXACTLY_EQUAL(20, pa.pos(1)[0]);
ASSERT_DOUBLES_EXACTLY_EQUAL(20, pa.pos(1)[1]);
ASSERT_DOUBLES_EXACTLY_EQUAL(20, pa.pos(1)[2]);
ASSERT_DOUBLES_EXACTLY_EQUAL(0 , pa.vel(1)[0]);
ASSERT_DOUBLES_EXACTLY_EQUAL(0 , pa.vel(1)[1]);
ASSERT_DOUBLES_EXACTLY_EQUAL(0 , pa.vel(1)[2]);
ASSERT_DOUBLES_EXACTLY_EQUAL(3 , pa.radius(1));
const float voxelSize = 0.5f, halfWidth = 4.0f;
openvdb::FloatGrid::Ptr ls = openvdb::createLevelSet<openvdb::FloatGrid>(voxelSize, halfWidth);
openvdb::CoordBBox bbox = pa.getBBox(*ls);
ASSERT_DOUBLES_EXACTLY_EQUAL((10-2)/voxelSize, bbox.min()[0]);
ASSERT_DOUBLES_EXACTLY_EQUAL((10-2)/voxelSize, bbox.min()[1]);
ASSERT_DOUBLES_EXACTLY_EQUAL((10-2)/voxelSize, bbox.min()[2]);
ASSERT_DOUBLES_EXACTLY_EQUAL((20+3)/voxelSize, bbox.max()[0]);
ASSERT_DOUBLES_EXACTLY_EQUAL((20+3)/voxelSize, bbox.max()[1]);
ASSERT_DOUBLES_EXACTLY_EQUAL((20+3)/voxelSize, bbox.max()[2]);
}
TEST_F(TestParticlesToLevelSet, testRasterizeSpheres)
{
MyParticleList pa;
pa.add(openvdb::Vec3R(10,10,10), 2);
pa.add(openvdb::Vec3R(20,20,20), 2);
// testing CSG
pa.add(openvdb::Vec3R(31.0,31,31), 5);
pa.add(openvdb::Vec3R(31.5,31,31), 5);
pa.add(openvdb::Vec3R(32.0,31,31), 5);
pa.add(openvdb::Vec3R(32.5,31,31), 5);
pa.add(openvdb::Vec3R(33.0,31,31), 5);
pa.add(openvdb::Vec3R(33.5,31,31), 5);
pa.add(openvdb::Vec3R(34.0,31,31), 5);
pa.add(openvdb::Vec3R(34.5,31,31), 5);
pa.add(openvdb::Vec3R(35.0,31,31), 5);
pa.add(openvdb::Vec3R(35.5,31,31), 5);
pa.add(openvdb::Vec3R(36.0,31,31), 5);
EXPECT_EQ(13, int(pa.size()));
const float voxelSize = 1.0f, halfWidth = 2.0f;
openvdb::FloatGrid::Ptr ls = openvdb::createLevelSet<openvdb::FloatGrid>(voxelSize, halfWidth);
openvdb::tools::ParticlesToLevelSet<openvdb::FloatGrid> raster(*ls);
raster.setGrainSize(1);//a value of zero disables threading
raster.rasterizeSpheres(pa);
raster.finalize();
//openvdb::FloatGrid::Ptr ls = raster.getSdfGrid();
//ls->tree().print(std::cout,4);
//this->writeGrid(ls, "testRasterizeSpheres");
ASSERT_DOUBLES_EXACTLY_EQUAL(halfWidth * voxelSize,
ls->tree().getValue(openvdb::Coord( 0, 0, 0)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 2, ls->tree().getValue(openvdb::Coord( 6,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 1, ls->tree().getValue(openvdb::Coord( 7,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 0, ls->tree().getValue(openvdb::Coord( 8,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-1, ls->tree().getValue(openvdb::Coord( 9,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-2, ls->tree().getValue(openvdb::Coord(10,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-1, ls->tree().getValue(openvdb::Coord(11,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 0, ls->tree().getValue(openvdb::Coord(12,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 1, ls->tree().getValue(openvdb::Coord(13,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 2, ls->tree().getValue(openvdb::Coord(14,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 2, ls->tree().getValue(openvdb::Coord(20,16,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 1, ls->tree().getValue(openvdb::Coord(20,17,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 0, ls->tree().getValue(openvdb::Coord(20,18,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-1, ls->tree().getValue(openvdb::Coord(20,19,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-2, ls->tree().getValue(openvdb::Coord(20,20,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-1, ls->tree().getValue(openvdb::Coord(20,21,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 0, ls->tree().getValue(openvdb::Coord(20,22,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 1, ls->tree().getValue(openvdb::Coord(20,23,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 2, ls->tree().getValue(openvdb::Coord(20,24,20)));
{// full but slow test of all voxels
openvdb::CoordBBox bbox = pa.getBBox(*ls);
bbox.expand(static_cast<int>(halfWidth)+1);
openvdb::Index64 count=0;
const float outside = ls->background(), inside = -outside;
const openvdb::Coord &min=bbox.min(), &max=bbox.max();
for (openvdb::Coord ijk=min; ijk[0]<max[0]; ++ijk[0]) {
for (ijk[1]=min[1]; ijk[1]<max[1]; ++ijk[1]) {
for (ijk[2]=min[2]; ijk[2]<max[2]; ++ijk[2]) {
const openvdb::Vec3d xyz = ls->indexToWorld(ijk.asVec3d());
double dist = (xyz-pa.pos(0)).length()-pa.radius(0);
for (int i = 1, s = int(pa.size()); i < s; ++i) {
dist=openvdb::math::Min(dist,(xyz-pa.pos(i)).length()-pa.radius(i));
}
const float val = ls->tree().getValue(ijk);
if (dist >= outside) {
EXPECT_NEAR(outside, val, 0.0001);
EXPECT_TRUE(ls->tree().isValueOff(ijk));
} else if( dist <= inside ) {
EXPECT_NEAR(inside, val, 0.0001);
EXPECT_TRUE(ls->tree().isValueOff(ijk));
} else {
EXPECT_NEAR( dist, val, 0.0001);
EXPECT_TRUE(ls->tree().isValueOn(ijk));
++count;
}
}
}
}
//std::cerr << "\nExpected active voxel count = " << count
// << ", actual active voxle count = "
// << ls->activeVoxelCount() << std::endl;
EXPECT_EQ(count, ls->activeVoxelCount());
}
}
TEST_F(TestParticlesToLevelSet, testRasterizeSpheresAndId)
{
MyParticleList pa(0.5f);
pa.add(openvdb::Vec3R(10,10,10), 4);
pa.add(openvdb::Vec3R(20,20,20), 4);
// testing CSG
pa.add(openvdb::Vec3R(31.0,31,31),10);
pa.add(openvdb::Vec3R(31.5,31,31),10);
pa.add(openvdb::Vec3R(32.0,31,31),10);
pa.add(openvdb::Vec3R(32.5,31,31),10);
pa.add(openvdb::Vec3R(33.0,31,31),10);
pa.add(openvdb::Vec3R(33.5,31,31),10);
pa.add(openvdb::Vec3R(34.0,31,31),10);
pa.add(openvdb::Vec3R(34.5,31,31),10);
pa.add(openvdb::Vec3R(35.0,31,31),10);
pa.add(openvdb::Vec3R(35.5,31,31),10);
pa.add(openvdb::Vec3R(36.0,31,31),10);
EXPECT_EQ(13, int(pa.size()));
typedef openvdb::tools::ParticlesToLevelSet<openvdb::FloatGrid, openvdb::Index32> RasterT;
const float voxelSize = 1.0f, halfWidth = 2.0f;
openvdb::FloatGrid::Ptr ls = openvdb::createLevelSet<openvdb::FloatGrid>(voxelSize, halfWidth);
RasterT raster(*ls);
raster.setGrainSize(1);//a value of zero disables threading
raster.rasterizeSpheres(pa);
raster.finalize();
const RasterT::AttGridType::Ptr id = raster.attributeGrid();
int minVal = std::numeric_limits<int>::max(), maxVal = -minVal;
for (RasterT::AttGridType::ValueOnCIter i=id->cbeginValueOn(); i; ++i) {
minVal = openvdb::math::Min(minVal, int(*i));
maxVal = openvdb::math::Max(maxVal, int(*i));
}
EXPECT_EQ(0 , minVal);
EXPECT_EQ(12, maxVal);
//grid.tree().print(std::cout,4);
//id->print(std::cout,4);
//this->writeGrid(ls, "testRasterizeSpheres");
ASSERT_DOUBLES_EXACTLY_EQUAL(halfWidth * voxelSize,
ls->tree().getValue(openvdb::Coord( 0, 0, 0)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 2, ls->tree().getValue(openvdb::Coord( 6,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 1, ls->tree().getValue(openvdb::Coord( 7,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 0, ls->tree().getValue(openvdb::Coord( 8,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-1, ls->tree().getValue(openvdb::Coord( 9,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-2, ls->tree().getValue(openvdb::Coord(10,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-1, ls->tree().getValue(openvdb::Coord(11,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 0, ls->tree().getValue(openvdb::Coord(12,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 1, ls->tree().getValue(openvdb::Coord(13,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 2, ls->tree().getValue(openvdb::Coord(14,10,10)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 2, ls->tree().getValue(openvdb::Coord(20,16,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 1, ls->tree().getValue(openvdb::Coord(20,17,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 0, ls->tree().getValue(openvdb::Coord(20,18,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-1, ls->tree().getValue(openvdb::Coord(20,19,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-2, ls->tree().getValue(openvdb::Coord(20,20,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL(-1, ls->tree().getValue(openvdb::Coord(20,21,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 0, ls->tree().getValue(openvdb::Coord(20,22,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 1, ls->tree().getValue(openvdb::Coord(20,23,20)));
ASSERT_DOUBLES_EXACTLY_EQUAL( 2, ls->tree().getValue(openvdb::Coord(20,24,20)));
{// full but slow test of all voxels
openvdb::CoordBBox bbox = pa.getBBox(*ls);
bbox.expand(static_cast<int>(halfWidth)+1);
openvdb::Index64 count = 0;
const float outside = ls->background(), inside = -outside;
const openvdb::Coord &min=bbox.min(), &max=bbox.max();
for (openvdb::Coord ijk=min; ijk[0]<max[0]; ++ijk[0]) {
for (ijk[1]=min[1]; ijk[1]<max[1]; ++ijk[1]) {
for (ijk[2]=min[2]; ijk[2]<max[2]; ++ijk[2]) {
const openvdb::Vec3d xyz = ls->indexToWorld(ijk.asVec3d());
double dist = (xyz-pa.pos(0)).length()-pa.radius(0);
openvdb::Index32 k =0;
for (int i = 1, s = int(pa.size()); i < s; ++i) {
double d = (xyz-pa.pos(i)).length()-pa.radius(i);
if (d<dist) {
k = openvdb::Index32(i);
dist = d;
}
}//loop over particles
const float val = ls->tree().getValue(ijk);
openvdb::Index32 m = id->tree().getValue(ijk);
if (dist >= outside) {
EXPECT_NEAR(outside, val, 0.0001);
EXPECT_TRUE(ls->tree().isValueOff(ijk));
//EXPECT_EQ(openvdb::util::INVALID_IDX, m);
EXPECT_TRUE(id->tree().isValueOff(ijk));
} else if( dist <= inside ) {
EXPECT_NEAR(inside, val, 0.0001);
EXPECT_TRUE(ls->tree().isValueOff(ijk));
//EXPECT_EQ(openvdb::util::INVALID_IDX, m);
EXPECT_TRUE(id->tree().isValueOff(ijk));
} else {
EXPECT_NEAR( dist, val, 0.0001);
EXPECT_TRUE(ls->tree().isValueOn(ijk));
EXPECT_EQ(k, m);
EXPECT_TRUE(id->tree().isValueOn(ijk));
++count;
}
}
}
}
//std::cerr << "\nExpected active voxel count = " << count
// << ", actual active voxle count = "
// << ls->activeVoxelCount() << std::endl;
EXPECT_EQ(count, ls->activeVoxelCount());
}
}
/// This is not really a conventional unit-test since the result of
/// the tests are written to a file and need to be visually verified!
TEST_F(TestParticlesToLevelSet, testRasterizeTrails)
{
const float voxelSize = 1.0f, halfWidth = 2.0f;
openvdb::FloatGrid::Ptr ls = openvdb::createLevelSet<openvdb::FloatGrid>(voxelSize, halfWidth);
MyParticleList pa(1,5);
// This particle radius = 1 < 1.5 i.e. it's below the Nyquist frequency and hence ignored
pa.add(openvdb::Vec3R( 0, 0, 0), 1, openvdb::Vec3R( 0, 1, 0));
pa.add(openvdb::Vec3R(-10,-10,-10), 2, openvdb::Vec3R( 2, 0, 0));
pa.add(openvdb::Vec3R( 10, 10, 10), 3, openvdb::Vec3R( 0, 1, 0));
pa.add(openvdb::Vec3R( 0, 0, 0), 6, openvdb::Vec3R( 0, 0,-5));
pa.add(openvdb::Vec3R( 20, 0, 0), 2, openvdb::Vec3R( 0, 0, 0));
openvdb::tools::ParticlesToLevelSet<openvdb::FloatGrid> raster(*ls);
raster.rasterizeTrails(pa, 0.75);//scale offset between two instances
//ls->tree().print(std::cout, 4);
//this->writeGrid(ls, "testRasterizeTrails");
}
TEST_F(TestParticlesToLevelSet, testRasterizeTrailsAndId)
{
MyParticleList pa(1,5);
// This particle radius = 1 < 1.5 i.e. it's below the Nyquist frequency and hence ignored
pa.add(openvdb::Vec3R( 0, 0, 0), 1, openvdb::Vec3R( 0, 1, 0));
pa.add(openvdb::Vec3R(-10,-10,-10), 2, openvdb::Vec3R( 2, 0, 0));
pa.add(openvdb::Vec3R( 10, 10, 10), 3, openvdb::Vec3R( 0, 1, 0));
pa.add(openvdb::Vec3R( 0, 0, 0), 6, openvdb::Vec3R( 0, 0,-5));
typedef openvdb::tools::ParticlesToLevelSet<openvdb::FloatGrid, openvdb::Index> RasterT;
const float voxelSize = 1.0f, halfWidth = 2.0f;
openvdb::FloatGrid::Ptr ls = openvdb::createLevelSet<openvdb::FloatGrid>(voxelSize, halfWidth);
RasterT raster(*ls);
raster.rasterizeTrails(pa, 0.75);//scale offset between two instances
raster.finalize();
const RasterT::AttGridType::Ptr id = raster.attributeGrid();
EXPECT_TRUE(!ls->empty());
EXPECT_TRUE(!id->empty());
EXPECT_EQ(ls->activeVoxelCount(),id->activeVoxelCount());
int min = std::numeric_limits<int>::max(), max = -min;
for (RasterT::AttGridType::ValueOnCIter i=id->cbeginValueOn(); i; ++i) {
min = openvdb::math::Min(min, int(*i));
max = openvdb::math::Max(max, int(*i));
}
EXPECT_EQ(1, min);//first particle is ignored because of its small rdadius!
EXPECT_EQ(3, max);
//ls->tree().print(std::cout, 4);
//this->writeGrid(ls, "testRasterizeTrails");
}
TEST_F(TestParticlesToLevelSet, testMaskOutput)
{
using namespace openvdb;
using SdfGridType = FloatGrid;
using MaskGridType = MaskGrid;
MyParticleList pa;
const Vec3R vel(10, 5, 1);
pa.add(Vec3R(84.7252, 85.7946, 84.4266), 11.8569, vel);
pa.add(Vec3R(47.9977, 81.2169, 47.7665), 5.45313, vel);
pa.add(Vec3R(87.0087, 14.0351, 95.7155), 7.36483, vel);
pa.add(Vec3R(75.8616, 53.7373, 58.202), 14.4127, vel);
pa.add(Vec3R(14.9675, 32.4141, 13.5218), 4.33101, vel);
pa.add(Vec3R(96.9809, 9.92804, 90.2349), 12.2613, vel);
pa.add(Vec3R(63.4274, 3.84254, 32.5047), 12.1566, vel);
pa.add(Vec3R(62.351, 47.4698, 41.4369), 11.637, vel);
pa.add(Vec3R(62.2846, 1.35716, 66.2527), 18.9914, vel);
pa.add(Vec3R(44.1711, 1.99877, 45.1159), 1.11429, vel);
{
// Test variable-radius particles.
// Rasterize into an SDF.
auto sdf = createLevelSet<SdfGridType>();
tools::particlesToSdf(pa, *sdf);
// Rasterize into a boolean mask.
auto mask = MaskGridType::create();
tools::particlesToMask(pa, *mask);
// Verify that the rasterized mask matches the interior of the SDF.
mask->tree().voxelizeActiveTiles();
auto interior = tools::sdfInteriorMask(*sdf);
EXPECT_TRUE(interior);
interior->tree().voxelizeActiveTiles();
EXPECT_EQ(interior->activeVoxelCount(), mask->activeVoxelCount());
interior->topologyDifference(*mask);
EXPECT_EQ(0, int(interior->activeVoxelCount()));
}
{
// Test fixed-radius particles.
auto sdf = createLevelSet<SdfGridType>();
tools::particlesToSdf(pa, *sdf, /*radius=*/10.0);
auto mask = MaskGridType::create();
tools::particlesToMask(pa, *mask, /*radius=*/10.0);
mask->tree().voxelizeActiveTiles();
auto interior = tools::sdfInteriorMask(*sdf);
EXPECT_TRUE(interior);
interior->tree().voxelizeActiveTiles();
EXPECT_EQ(interior->activeVoxelCount(), mask->activeVoxelCount());
interior->topologyDifference(*mask);
EXPECT_EQ(0, int(interior->activeVoxelCount()));
}
{
// Test particle trails.
auto sdf = createLevelSet<SdfGridType>();
tools::particleTrailsToSdf(pa, *sdf);
auto mask = MaskGridType::create();
tools::particleTrailsToMask(pa, *mask);
mask->tree().voxelizeActiveTiles();
auto interior = tools::sdfInteriorMask(*sdf);
EXPECT_TRUE(interior);
interior->tree().voxelizeActiveTiles();
EXPECT_EQ(interior->activeVoxelCount(), mask->activeVoxelCount());
interior->topologyDifference(*mask);
EXPECT_EQ(0, int(interior->activeVoxelCount()));
}
{
// Test attribute transfer.
auto sdf = createLevelSet<SdfGridType>();
tools::ParticlesToLevelSet<SdfGridType, Index32> p2sdf(*sdf);
p2sdf.rasterizeSpheres(pa);
p2sdf.finalize(/*prune=*/true);
const auto sdfAttr = p2sdf.attributeGrid();
EXPECT_TRUE(sdfAttr);
auto mask = MaskGridType::create();
tools::ParticlesToLevelSet<MaskGridType, Index32> p2mask(*mask);
p2mask.rasterizeSpheres(pa);
p2mask.finalize(/*prune=*/true);
const auto maskAttr = p2mask.attributeGrid();
EXPECT_TRUE(maskAttr);
mask->tree().voxelizeActiveTiles();
auto interior = tools::sdfInteriorMask(*sdf);
EXPECT_TRUE(interior);
interior->tree().voxelizeActiveTiles();
EXPECT_EQ(interior->activeVoxelCount(), mask->activeVoxelCount());
interior->topologyDifference(*mask);
EXPECT_EQ(0, int(interior->activeVoxelCount()));
// Verify that the mask- and SDF-generated attribute grids match.
auto sdfAcc = sdfAttr->getConstAccessor();
auto maskAcc = maskAttr->getConstAccessor();
for (auto it = interior->cbeginValueOn(); it; ++it) {
const auto& c = it.getCoord();
EXPECT_EQ(sdfAcc.getValue(c), maskAcc.getValue(c));
}
}
}
| 23,668 | C++ | 41.723827 | 102 | 0.602375 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointCount.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/PointCount.h
///
/// @author Dan Bailey
///
/// @brief Methods for counting points in VDB Point grids.
#ifndef OPENVDB_POINTS_POINT_COUNT_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_COUNT_HAS_BEEN_INCLUDED
#include <openvdb/openvdb.h>
#include "PointDataGrid.h"
#include "PointMask.h"
#include "IndexFilter.h"
#include <tbb/parallel_reduce.h>
#include <vector>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
/// @brief Count the total number of points in a PointDataTree
/// @param tree the PointDataTree in which to count the points
/// @param filter an optional index filter
/// @param inCoreOnly if true, points in out-of-core leaf nodes are not counted
/// @param threaded enable or disable threading (threading is enabled by default)
template <typename PointDataTreeT, typename FilterT = NullFilter>
inline Index64 pointCount( const PointDataTreeT& tree,
const FilterT& filter = NullFilter(),
const bool inCoreOnly = false,
const bool threaded = true);
/// @brief Populate an array of cumulative point offsets per leaf node.
/// @param pointOffsets array of offsets to be populated
/// @param tree the PointDataTree from which to populate the offsets
/// @param filter an optional index filter
/// @param inCoreOnly if true, points in out-of-core leaf nodes are ignored
/// @param threaded enable or disable threading (threading is enabled by default)
/// @return The final cumulative point offset.
template <typename PointDataTreeT, typename FilterT = NullFilter>
inline Index64 pointOffsets(std::vector<Index64>& pointOffsets,
const PointDataTreeT& tree,
const FilterT& filter = NullFilter(),
const bool inCoreOnly = false,
const bool threaded = true);
/// @brief Generate a new grid with voxel values to store the number of points per voxel
/// @param grid the PointDataGrid to use to compute the count grid
/// @param filter an optional index filter
/// @note The return type of the grid must be an integer or floating-point scalar grid.
template <typename PointDataGridT,
typename GridT = typename PointDataGridT::template ValueConverter<Int32>::Type,
typename FilterT = NullFilter>
inline typename GridT::Ptr
pointCountGrid( const PointDataGridT& grid,
const FilterT& filter = NullFilter());
/// @brief Generate a new grid that uses the supplied transform with voxel values to store the
/// number of points per voxel.
/// @param grid the PointDataGrid to use to compute the count grid
/// @param transform the transform to use to compute the count grid
/// @param filter an optional index filter
/// @note The return type of the grid must be an integer or floating-point scalar grid.
template <typename PointDataGridT,
typename GridT = typename PointDataGridT::template ValueConverter<Int32>::Type,
typename FilterT = NullFilter>
inline typename GridT::Ptr
pointCountGrid( const PointDataGridT& grid,
const openvdb::math::Transform& transform,
const FilterT& filter = NullFilter());
////////////////////////////////////////
template <typename PointDataTreeT, typename FilterT>
Index64 pointCount(const PointDataTreeT& tree,
const FilterT& filter,
const bool inCoreOnly,
const bool threaded)
{
using LeafManagerT = tree::LeafManager<const PointDataTreeT>;
using LeafRangeT = typename LeafManagerT::LeafRange;
auto countLambda =
[&filter, &inCoreOnly] (const LeafRangeT& range, Index64 sum) -> Index64 {
for (const auto& leaf : range) {
if (inCoreOnly && leaf.buffer().isOutOfCore()) continue;
auto state = filter.state(leaf);
if (state == index::ALL) {
sum += leaf.pointCount();
} else if (state != index::NONE) {
sum += iterCount(leaf.beginIndexAll(filter));
}
}
return sum;
};
LeafManagerT leafManager(tree);
if (threaded) {
return tbb::parallel_reduce(leafManager.leafRange(), Index64(0), countLambda,
[] (Index64 n, Index64 m) -> Index64 { return n + m; });
}
else {
return countLambda(leafManager.leafRange(), Index64(0));
}
}
template <typename PointDataTreeT, typename FilterT>
Index64 pointOffsets( std::vector<Index64>& pointOffsets,
const PointDataTreeT& tree,
const FilterT& filter,
const bool inCoreOnly,
const bool threaded)
{
using LeafT = typename PointDataTreeT::LeafNodeType;
using LeafManagerT = typename tree::LeafManager<const PointDataTreeT>;
// allocate and zero values in point offsets array
pointOffsets.assign(tree.leafCount(), Index64(0));
// compute total points per-leaf
LeafManagerT leafManager(tree);
leafManager.foreach(
[&pointOffsets, &filter, &inCoreOnly](const LeafT& leaf, size_t pos) {
if (inCoreOnly && leaf.buffer().isOutOfCore()) return;
auto state = filter.state(leaf);
if (state == index::ALL) {
pointOffsets[pos] = leaf.pointCount();
} else if (state != index::NONE) {
pointOffsets[pos] = iterCount(leaf.beginIndexAll(filter));
}
},
threaded);
// turn per-leaf totals into cumulative leaf totals
Index64 pointOffset(pointOffsets[0]);
for (size_t n = 1; n < pointOffsets.size(); n++) {
pointOffset += pointOffsets[n];
pointOffsets[n] = pointOffset;
}
return pointOffset;
}
template <typename PointDataGridT, typename GridT, typename FilterT>
typename GridT::Ptr
pointCountGrid( const PointDataGridT& points,
const FilterT& filter)
{
static_assert( std::is_integral<typename GridT::ValueType>::value ||
std::is_floating_point<typename GridT::ValueType>::value,
"openvdb::points::pointCountGrid must return an integer or floating-point scalar grid");
// This is safe because the PointDataGrid can only be modified by the deformer
using AdapterT = TreeAdapter<typename PointDataGridT::TreeType>;
auto& nonConstPoints = const_cast<typename AdapterT::NonConstGridType&>(points);
return point_mask_internal::convertPointsToScalar<GridT>(
nonConstPoints, filter);
}
template <typename PointDataGridT, typename GridT, typename FilterT>
typename GridT::Ptr
pointCountGrid( const PointDataGridT& points,
const openvdb::math::Transform& transform,
const FilterT& filter)
{
static_assert( std::is_integral<typename GridT::ValueType>::value ||
std::is_floating_point<typename GridT::ValueType>::value,
"openvdb::points::pointCountGrid must return an integer or floating-point scalar grid");
// This is safe because the PointDataGrid can only be modified by the deformer
using AdapterT = TreeAdapter<typename PointDataGridT::TreeType>;
auto& nonConstPoints = const_cast<typename AdapterT::NonConstGridType&>(points);
NullDeformer deformer;
return point_mask_internal::convertPointsToScalar<GridT>(
nonConstPoints, transform, filter, deformer);
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_COUNT_HAS_BEEN_INCLUDED
| 7,879 | C | 36.884615 | 96 | 0.650209 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointMask.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/PointMask.h
///
/// @author Dan Bailey
///
/// @brief Methods for extracting masks from VDB Point grids.
#ifndef OPENVDB_POINTS_POINT_MASK_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_MASK_HAS_BEEN_INCLUDED
#include <openvdb/openvdb.h>
#include <openvdb/tools/ValueTransformer.h> // valxform::SumOp
#include "PointDataGrid.h"
#include "IndexFilter.h"
#include <tbb/combinable.h>
#include <type_traits>
#include <vector>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
/// @brief Extract a Mask Grid from a Point Data Grid
/// @param grid the PointDataGrid to extract the mask from.
/// @param filter an optional index filter
/// @param threaded enable or disable threading (threading is enabled by default)
/// @note this method is only available for Bool Grids and Mask Grids
template <typename PointDataGridT,
typename MaskT = typename PointDataGridT::template ValueConverter<bool>::Type,
typename FilterT = NullFilter>
inline typename std::enable_if<std::is_same<typename MaskT::ValueType, bool>::value,
typename MaskT::Ptr>::type
convertPointsToMask(const PointDataGridT& grid,
const FilterT& filter = NullFilter(),
bool threaded = true);
/// @brief Extract a Mask Grid from a Point Data Grid using a new transform
/// @param grid the PointDataGrid to extract the mask from.
/// @param transform target transform for the mask.
/// @param filter an optional index filter
/// @param threaded enable or disable threading (threading is enabled by default)
/// @note this method is only available for Bool Grids and Mask Grids
template <typename PointDataGridT,
typename MaskT = typename PointDataGridT::template ValueConverter<bool>::Type,
typename FilterT = NullFilter>
inline typename std::enable_if<std::is_same<typename MaskT::ValueType, bool>::value,
typename MaskT::Ptr>::type
convertPointsToMask(const PointDataGridT& grid,
const openvdb::math::Transform& transform,
const FilterT& filter = NullFilter(),
bool threaded = true);
/// @brief No-op deformer (adheres to the deformer interface documented in PointMove.h)
struct NullDeformer
{
template <typename LeafT>
void reset(LeafT&, size_t /*idx*/ = 0) { }
template <typename IterT>
void apply(Vec3d&, IterT&) const { }
};
/// @brief Deformer Traits for optionally configuring deformers to be applied
/// in index-space. The default is world-space.
template <typename DeformerT>
struct DeformerTraits
{
static const bool IndexSpace = false;
};
////////////////////////////////////////
namespace point_mask_internal {
template <typename LeafT>
void voxelSum(LeafT& leaf, const Index offset, const typename LeafT::ValueType& value)
{
leaf.modifyValue(offset, tools::valxform::SumOp<typename LeafT::ValueType>(value));
}
// overload PointDataLeaf access to use setOffsetOn(), as modifyValue()
// is intentionally disabled to avoid accidental usage
template <typename T, Index Log2Dim>
void voxelSum(PointDataLeafNode<T, Log2Dim>& leaf, const Index offset,
const typename PointDataLeafNode<T, Log2Dim>::ValueType& value)
{
leaf.setOffsetOn(offset, leaf.getValue(offset) + value);
}
/// @brief Combines multiple grids into one by stealing leaf nodes and summing voxel values
/// This class is designed to work with thread local storage containers such as tbb::combinable
template<typename GridT>
struct GridCombinerOp
{
using CombinableT = typename tbb::combinable<GridT>;
using TreeT = typename GridT::TreeType;
using LeafT = typename TreeT::LeafNodeType;
using ValueType = typename TreeT::ValueType;
using SumOp = tools::valxform::SumOp<typename TreeT::ValueType>;
GridCombinerOp(GridT& grid)
: mTree(grid.tree()) {}
void operator()(const GridT& grid)
{
for (auto leaf = grid.tree().beginLeaf(); leaf; ++leaf) {
auto* newLeaf = mTree.probeLeaf(leaf->origin());
if (!newLeaf) {
// if the leaf doesn't yet exist in the new tree, steal it
auto& tree = const_cast<GridT&>(grid).tree();
mTree.addLeaf(tree.template stealNode<LeafT>(leaf->origin(),
zeroVal<ValueType>(), false));
}
else {
// otherwise increment existing values
for (auto iter = leaf->cbeginValueOn(); iter; ++iter) {
voxelSum(*newLeaf, iter.offset(), ValueType(*iter));
}
}
}
}
private:
TreeT& mTree;
}; // struct GridCombinerOp
/// @brief Compute scalar grid from PointDataGrid while evaluating the point filter
template <typename GridT, typename PointDataGridT, typename FilterT>
struct PointsToScalarOp
{
using LeafT = typename GridT::TreeType::LeafNodeType;
using ValueT = typename LeafT::ValueType;
PointsToScalarOp( const PointDataGridT& grid,
const FilterT& filter)
: mPointDataAccessor(grid.getConstAccessor())
, mFilter(filter) { }
void operator()(LeafT& leaf, size_t /*idx*/) const {
const auto* const pointLeaf =
mPointDataAccessor.probeConstLeaf(leaf.origin());
// assumes matching topology
assert(pointLeaf);
for (auto value = leaf.beginValueOn(); value; ++value) {
const Index64 count = points::iterCount(
pointLeaf->beginIndexVoxel(value.getCoord(), mFilter));
if (count > Index64(0)) {
value.setValue(ValueT(count));
} else {
// disable any empty voxels
value.setValueOn(false);
}
}
}
private:
const typename PointDataGridT::ConstAccessor mPointDataAccessor;
const FilterT& mFilter;
}; // struct PointsToScalarOp
/// @brief Compute scalar grid from PointDataGrid using a different transform
/// and while evaluating the point filter
template <typename GridT, typename PointDataGridT, typename FilterT, typename DeformerT>
struct PointsToTransformedScalarOp
{
using PointDataLeafT = typename PointDataGridT::TreeType::LeafNodeType;
using ValueT = typename GridT::TreeType::ValueType;
using HandleT = AttributeHandle<Vec3f>;
using CombinableT = typename GridCombinerOp<GridT>::CombinableT;
PointsToTransformedScalarOp(const math::Transform& targetTransform,
const math::Transform& sourceTransform,
const FilterT& filter,
const DeformerT& deformer,
CombinableT& combinable)
: mTargetTransform(targetTransform)
, mSourceTransform(sourceTransform)
, mFilter(filter)
, mDeformer(deformer)
, mCombinable(combinable) { }
void operator()(const PointDataLeafT& leaf, size_t idx) const
{
DeformerT deformer(mDeformer);
auto& grid = mCombinable.local();
auto& countTree = grid.tree();
tree::ValueAccessor<typename GridT::TreeType> accessor(countTree);
deformer.reset(leaf, idx);
auto handle = HandleT::create(leaf.constAttributeArray("P"));
for (auto iter = leaf.beginIndexOn(mFilter); iter; iter++) {
// extract index-space position
Vec3d position = handle->get(*iter) + iter.getCoord().asVec3d();
// if deformer is designed to be used in index-space, perform deformation prior
// to transforming position to world-space, otherwise perform deformation afterwards
if (DeformerTraits<DeformerT>::IndexSpace) {
deformer.template apply<decltype(iter)>(position, iter);
position = mSourceTransform.indexToWorld(position);
}
else {
position = mSourceTransform.indexToWorld(position);
deformer.template apply<decltype(iter)>(position, iter);
}
// determine coord of target grid
const Coord ijk = mTargetTransform.worldToIndexCellCentered(position);
// increment count in target voxel
auto* newLeaf = accessor.touchLeaf(ijk);
assert(newLeaf);
voxelSum(*newLeaf, newLeaf->coordToOffset(ijk), ValueT(1));
}
}
private:
const openvdb::math::Transform& mTargetTransform;
const openvdb::math::Transform& mSourceTransform;
const FilterT& mFilter;
const DeformerT& mDeformer;
CombinableT& mCombinable;
}; // struct PointsToTransformedScalarOp
template<typename GridT, typename PointDataGridT, typename FilterT>
inline typename GridT::Ptr convertPointsToScalar(
const PointDataGridT& points,
const FilterT& filter,
bool threaded = true)
{
using point_mask_internal::PointsToScalarOp;
using GridTreeT = typename GridT::TreeType;
using ValueT = typename GridTreeT::ValueType;
// copy the topology from the points grid
typename GridTreeT::Ptr tree(new GridTreeT(points.constTree(),
false, openvdb::TopologyCopy()));
typename GridT::Ptr grid = GridT::create(tree);
grid->setTransform(points.transform().copy());
// early exit if no leaves
if (points.constTree().leafCount() == 0) return grid;
// early exit if mask and no group logic
if (std::is_same<ValueT, bool>::value && filter.state() == index::ALL) return grid;
// evaluate point group filters to produce a subset of the generated mask
tree::LeafManager<GridTreeT> leafManager(*tree);
if (filter.state() == index::ALL) {
NullFilter nullFilter;
PointsToScalarOp<GridT, PointDataGridT, NullFilter> pointsToScalarOp(
points, nullFilter);
leafManager.foreach(pointsToScalarOp, threaded);
} else {
// build mask from points in parallel only where filter evaluates to true
PointsToScalarOp<GridT, PointDataGridT, FilterT> pointsToScalarOp(
points, filter);
leafManager.foreach(pointsToScalarOp, threaded);
}
return grid;
}
template<typename GridT, typename PointDataGridT, typename FilterT, typename DeformerT>
inline typename GridT::Ptr convertPointsToScalar(
PointDataGridT& points,
const openvdb::math::Transform& transform,
const FilterT& filter,
const DeformerT& deformer,
bool threaded = true)
{
using point_mask_internal::PointsToTransformedScalarOp;
using point_mask_internal::GridCombinerOp;
using CombinerOpT = GridCombinerOp<GridT>;
using CombinableT = typename GridCombinerOp<GridT>::CombinableT;
// use the simpler method if the requested transform matches the existing one
const openvdb::math::Transform& pointsTransform = points.constTransform();
if (transform == pointsTransform && std::is_same<NullDeformer, DeformerT>()) {
return convertPointsToScalar<GridT>(points, filter, threaded);
}
typename GridT::Ptr grid = GridT::create();
grid->setTransform(transform.copy());
// early exit if no leaves
if (points.constTree().leafCount() == 0) return grid;
// compute mask grids in parallel using new transform
CombinableT combiner;
tree::LeafManager<typename PointDataGridT::TreeType> leafManager(points.tree());
if (filter.state() == index::ALL) {
NullFilter nullFilter;
PointsToTransformedScalarOp<GridT, PointDataGridT, NullFilter, DeformerT> pointsToScalarOp(
transform, pointsTransform, nullFilter, deformer, combiner);
leafManager.foreach(pointsToScalarOp, threaded);
} else {
PointsToTransformedScalarOp<GridT, PointDataGridT, FilterT, DeformerT> pointsToScalarOp(
transform, pointsTransform, filter, deformer, combiner);
leafManager.foreach(pointsToScalarOp, threaded);
}
// combine the mask grids into one
CombinerOpT combineOp(*grid);
combiner.combine_each(combineOp);
return grid;
}
} // namespace point_mask_internal
////////////////////////////////////////
template<typename PointDataGridT, typename MaskT, typename FilterT>
inline typename std::enable_if<std::is_same<typename MaskT::ValueType, bool>::value,
typename MaskT::Ptr>::type
convertPointsToMask(
const PointDataGridT& points,
const FilterT& filter,
bool threaded)
{
return point_mask_internal::convertPointsToScalar<MaskT>(
points, filter, threaded);
}
template<typename PointDataGridT, typename MaskT, typename FilterT>
inline typename std::enable_if<std::is_same<typename MaskT::ValueType, bool>::value,
typename MaskT::Ptr>::type
convertPointsToMask(
const PointDataGridT& points,
const openvdb::math::Transform& transform,
const FilterT& filter,
bool threaded)
{
// This is safe because the PointDataGrid can only be modified by the deformer
using AdapterT = TreeAdapter<typename PointDataGridT::TreeType>;
auto& nonConstPoints = const_cast<typename AdapterT::NonConstGridType&>(points);
NullDeformer deformer;
return point_mask_internal::convertPointsToScalar<MaskT>(
nonConstPoints, transform, filter, deformer, threaded);
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_MASK_HAS_BEEN_INCLUDED
| 13,566 | C | 32.9175 | 99 | 0.671384 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/AttributeArray.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/AttributeArray.h
///
/// @authors Dan Bailey, Mihai Alden, Nick Avramoussis, James Bird, Khang Ngo
///
/// @brief Attribute Array storage templated on type and compression codec.
#ifndef OPENVDB_POINTS_ATTRIBUTE_ARRAY_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_ATTRIBUTE_ARRAY_HAS_BEEN_INCLUDED
#include <openvdb/Types.h>
#include <openvdb/math/QuantizedUnitVec.h>
#include <openvdb/util/Name.h>
#include <openvdb/util/logging.h>
#include <openvdb/io/io.h> // MappedFile
#include <openvdb/io/Compression.h> // COMPRESS_BLOSC
#include "IndexIterator.h"
#include "StreamCompression.h"
#include <tbb/spin_mutex.h>
#include <tbb/atomic.h>
#include <memory>
#include <mutex>
#include <string>
#include <type_traits>
class TestAttributeArray;
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
using NamePair = std::pair<Name, Name>;
namespace points {
////////////////////////////////////////
// Utility methods
template <typename IntegerT, typename FloatT>
inline IntegerT
floatingPointToFixedPoint(const FloatT s)
{
static_assert(std::is_unsigned<IntegerT>::value, "IntegerT must be unsigned");
if (FloatT(0.0) > s) return std::numeric_limits<IntegerT>::min();
else if (FloatT(1.0) <= s) return std::numeric_limits<IntegerT>::max();
return IntegerT(s * FloatT(std::numeric_limits<IntegerT>::max()));
}
template <typename FloatT, typename IntegerT>
inline FloatT
fixedPointToFloatingPoint(const IntegerT s)
{
static_assert(std::is_unsigned<IntegerT>::value, "IntegerT must be unsigned");
return FloatT(s) / FloatT((std::numeric_limits<IntegerT>::max()));
}
template <typename IntegerVectorT, typename FloatT>
inline IntegerVectorT
floatingPointToFixedPoint(const math::Vec3<FloatT>& v)
{
return IntegerVectorT(
floatingPointToFixedPoint<typename IntegerVectorT::ValueType>(v.x()),
floatingPointToFixedPoint<typename IntegerVectorT::ValueType>(v.y()),
floatingPointToFixedPoint<typename IntegerVectorT::ValueType>(v.z()));
}
template <typename FloatVectorT, typename IntegerT>
inline FloatVectorT
fixedPointToFloatingPoint(const math::Vec3<IntegerT>& v)
{
return FloatVectorT(
fixedPointToFloatingPoint<typename FloatVectorT::ValueType>(v.x()),
fixedPointToFloatingPoint<typename FloatVectorT::ValueType>(v.y()),
fixedPointToFloatingPoint<typename FloatVectorT::ValueType>(v.z()));
}
////////////////////////////////////////
/// Base class for storing attribute data
class OPENVDB_API AttributeArray
{
protected:
struct AccessorBase;
template <typename T> struct Accessor;
using AccessorBasePtr = std::shared_ptr<AccessorBase>;
public:
enum Flag {
TRANSIENT = 0x1, /// by default not written to disk
HIDDEN = 0x2, /// hidden from UIs or iterators
CONSTANTSTRIDE = 0x8, /// stride size does not vary in the array
STREAMING = 0x10, /// streaming mode collapses attributes when first accessed
PARTIALREAD = 0x20 /// data has been partially read (compressed bytes is used)
};
enum SerializationFlag {
WRITESTRIDED = 0x1, /// data is marked as strided when written
WRITEUNIFORM = 0x2, /// data is marked as uniform when written
WRITEMEMCOMPRESS = 0x4, /// data is marked as compressed in-memory when written
/// (deprecated flag as of ABI=6)
WRITEPAGED = 0x8 /// data is written out in pages
};
// Scoped Lock wrapper class that locks the AttributeArray registry mutex
class OPENVDB_API ScopedRegistryLock
{
tbb::spin_mutex::scoped_lock lock;
public:
ScopedRegistryLock();
}; // class ScopedRegistryLock
using Ptr = std::shared_ptr<AttributeArray>;
using ConstPtr = std::shared_ptr<const AttributeArray>;
using FactoryMethod = Ptr (*)(Index, Index, bool, const Metadata*);
template <typename ValueType, typename CodecType> friend class AttributeHandle;
AttributeArray(): mPageHandle() { mOutOfCore = 0; }
virtual ~AttributeArray()
{
// if this AttributeArray has been partially read, zero the compressed bytes,
// so the page handle won't attempt to clean up invalid memory
if (mFlags & PARTIALREAD) mCompressedBytes = 0;
}
#if OPENVDB_ABI_VERSION_NUMBER >= 6
AttributeArray(const AttributeArray& rhs);
AttributeArray& operator=(const AttributeArray& rhs);
#else
AttributeArray(const AttributeArray&) = default;
AttributeArray& operator=(const AttributeArray&) = default;
#endif
AttributeArray(AttributeArray&&) = delete;
AttributeArray& operator=(AttributeArray&&) = delete;
/// Return a copy of this attribute.
virtual AttributeArray::Ptr copy() const = 0;
/// Return a copy of this attribute.
#ifndef _MSC_VER
[[deprecated("In-memory compression no longer supported, use AttributeArray::copy() instead")]]
#endif
virtual AttributeArray::Ptr copyUncompressed() const = 0;
/// Return the number of elements in this array.
/// @note This does not count each data element in a strided array
virtual Index size() const = 0;
/// Return the stride of this array.
/// @note a return value of zero means a non-constant stride
virtual Index stride() const = 0;
/// Return the total number of data elements in this array.
/// @note This counts each data element in a strided array
virtual Index dataSize() const = 0;
#if OPENVDB_ABI_VERSION_NUMBER >= 6
/// Return the name of the value type of a single element in this array (e.g., "float" or "vec3d").
virtual Name valueType() const = 0;
/// Return the name of the codec used by this array (e.g., "trnc" or "fxpt").
virtual Name codecType() const = 0;
/// Return the size in bytes of the value type of a single element in this array.
/// (e.g. "float" -> 4 bytes, "vec3d" -> 24 bytes").
virtual Index valueTypeSize() const = 0;
/// Return the size in bytes of the storage type of a single element of this array.
/// @note If the Codec is a NullCodec, valueSize() == storageSize()
virtual Index storageTypeSize() const = 0;
/// Return @c true if the value type is floating point
virtual bool valueTypeIsFloatingPoint() const = 0;
/// Return @c true if the value type is a class (ie vector, matrix or quaternion return true)
virtual bool valueTypeIsClass() const = 0;
/// Return @c true if the value type is a vector
virtual bool valueTypeIsVector() const = 0;
/// Return @c true if the value type is a quaternion
virtual bool valueTypeIsQuaternion() const = 0;
/// Return @c true if the value type is a matrix
virtual bool valueTypeIsMatrix() const = 0;
#endif
/// Return the number of bytes of memory used by this attribute.
virtual size_t memUsage() const = 0;
/// Create a new attribute array of the given (registered) type, length and stride.
/// @details If @a lock is non-null, the AttributeArray registry mutex
/// has already been locked
static Ptr create(const NamePair& type, Index length, Index stride = 1,
bool constantStride = true,
const Metadata* metadata = nullptr,
const ScopedRegistryLock* lock = nullptr);
/// Return @c true if the given attribute type name is registered.
static bool isRegistered(const NamePair& type, const ScopedRegistryLock* lock = nullptr);
/// Clear the attribute type registry.
static void clearRegistry(const ScopedRegistryLock* lock = nullptr);
/// Return the name of this attribute's type.
virtual const NamePair& type() const = 0;
/// Return @c true if this attribute is of the same type as the template parameter.
template<typename AttributeArrayType>
bool isType() const { return this->type() == AttributeArrayType::attributeType(); }
/// Return @c true if this attribute has a value type the same as the template parameter
template<typename ValueType>
bool hasValueType() const { return this->type().first == typeNameAsString<ValueType>(); }
/// @brief Set value at given index @a n from @a sourceIndex of another @a sourceArray.
#if OPENVDB_ABI_VERSION_NUMBER >= 6
// Windows does not allow base classes to be easily deprecated.
#ifndef _MSC_VER
[[deprecated("From ABI 6 on, use copyValues() with source-target index pairs")]]
#endif
#endif
virtual void set(const Index n, const AttributeArray& sourceArray, const Index sourceIndex) = 0;
#if OPENVDB_ABI_VERSION_NUMBER >= 6
/// @brief Copy values into this array from a source array to a target array
/// as referenced by an iterator.
/// @details Iterators must adhere to the ForwardIterator interface described
/// in the example below:
/// @code
/// struct MyIterator
/// {
/// // returns true if the iterator is referencing valid copying indices
/// operator bool() const;
/// // increments the iterator
/// MyIterator& operator++();
/// // returns the source index that the iterator is referencing for copying
/// Index sourceIndex() const;
/// // returns the target index that the iterator is referencing for copying
/// Index targetIndex() const;
/// };
/// @endcode
/// @note It is assumed that the strided storage sizes match, the arrays are both in-core,
/// and both value types are floating-point or both integer.
/// @note It is possible to use this method to write to a uniform target array
/// if the iterator does not have non-zero target indices.
/// @note This method is not thread-safe, it must be guaranteed that this array is not
/// concurrently modified by another thread and that the source array is also not modified.
template<typename IterT>
void copyValuesUnsafe(const AttributeArray& sourceArray, const IterT& iter);
/// @brief Like copyValuesUnsafe(), but if @a compact is true, attempt to collapse this array.
/// @note This method is not thread-safe, it must be guaranteed that this array is not
/// concurrently modified by another thread and that the source array is also not modified.
template<typename IterT>
void copyValues(const AttributeArray& sourceArray, const IterT& iter, bool compact = true);
#endif
/// Return @c true if this array is stored as a single uniform value.
virtual bool isUniform() const = 0;
/// @brief If this array is uniform, replace it with an array of length size().
/// @param fill if true, assign the uniform value to each element of the array.
virtual void expand(bool fill = true) = 0;
/// Replace the existing array with a uniform zero value.
virtual void collapse() = 0;
/// Compact the existing array to become uniform if all values are identical
virtual bool compact() = 0;
// Windows does not allow base classes to be deprecated
#ifndef _MSC_VER
[[deprecated("Previously this compressed the attribute array, now it does nothing")]]
#endif
virtual bool compress() = 0;
// Windows does not allow base classes to be deprecated
#ifndef _MSC_VER
[[deprecated("Previously this uncompressed the attribute array, now it does nothing")]]
#endif
virtual bool decompress() = 0;
/// @brief Specify whether this attribute should be hidden (e.g., from UI or iterators).
/// @details This is useful if the attribute is used for blind data or as scratch space
/// for a calculation.
/// @note Attributes are not hidden by default.
void setHidden(bool state);
/// Return @c true if this attribute is hidden (e.g., from UI or iterators).
bool isHidden() const { return bool(mFlags & HIDDEN); }
/// @brief Specify whether this attribute should only exist in memory
/// and not be serialized during stream output.
/// @note Attributes are not transient by default.
void setTransient(bool state);
/// Return @c true if this attribute is not serialized during stream output.
bool isTransient() const { return bool(mFlags & TRANSIENT); }
/// @brief Specify whether this attribute is to be streamed off disk, in which
/// case, the attributes are collapsed after being first loaded leaving them
/// in a destroyed state.
/// @note This operation is not thread-safe.
void setStreaming(bool state);
/// Return @c true if this attribute is in streaming mode.
bool isStreaming() const { return bool(mFlags & STREAMING); }
/// Return @c true if this attribute has a constant stride
bool hasConstantStride() const { return bool(mFlags & CONSTANTSTRIDE); }
/// @brief Retrieve the attribute array flags
uint8_t flags() const { return mFlags; }
/// Read attribute metadata and buffers from a stream.
virtual void read(std::istream&) = 0;
/// Write attribute metadata and buffers to a stream.
/// @param outputTransient if true, write out transient attributes
virtual void write(std::ostream&, bool outputTransient) const = 0;
/// Write attribute metadata and buffers to a stream, don't write transient attributes.
virtual void write(std::ostream&) const = 0;
/// Read attribute metadata from a stream.
virtual void readMetadata(std::istream&) = 0;
/// Write attribute metadata to a stream.
/// @param outputTransient if true, write out transient attributes
/// @param paged if true, data is written out in pages
virtual void writeMetadata(std::ostream&, bool outputTransient, bool paged) const = 0;
/// Read attribute buffers from a stream.
virtual void readBuffers(std::istream&) = 0;
/// Write attribute buffers to a stream.
/// @param outputTransient if true, write out transient attributes
virtual void writeBuffers(std::ostream&, bool outputTransient) const = 0;
/// Read attribute buffers from a paged stream.
virtual void readPagedBuffers(compression::PagedInputStream&) = 0;
/// Write attribute buffers to a paged stream.
/// @param outputTransient if true, write out transient attributes
virtual void writePagedBuffers(compression::PagedOutputStream&, bool outputTransient) const = 0;
/// Ensures all data is in-core
virtual void loadData() const = 0;
#if OPENVDB_ABI_VERSION_NUMBER >= 6
/// Return @c true if all data has been loaded
virtual bool isDataLoaded() const = 0;
#endif
/// Check the compressed bytes and flags. If they are equal, perform a deeper
/// comparison check necessary on the inherited types (TypedAttributeArray)
/// Requires non operator implementation due to inheritance
bool operator==(const AttributeArray& other) const;
bool operator!=(const AttributeArray& other) const { return !this->operator==(other); }
private:
friend class ::TestAttributeArray;
/// Virtual function used by the comparison operator to perform
/// comparisons on inherited types
virtual bool isEqual(const AttributeArray& other) const = 0;
#if OPENVDB_ABI_VERSION_NUMBER >= 6
/// Virtual function to retrieve the data buffer cast to a char byte array
virtual char* dataAsByteArray() = 0;
virtual const char* dataAsByteArray() const = 0;
/// Private implementation for copyValues/copyValuesUnsafe
template <typename IterT>
void doCopyValues(const AttributeArray& sourceArray, const IterT& iter,
bool rangeChecking = true);
#endif
protected:
#if OPENVDB_ABI_VERSION_NUMBER >= 7
AttributeArray(const AttributeArray& rhs, const tbb::spin_mutex::scoped_lock&);
#endif
/// @brief Specify whether this attribute has a constant stride or not.
void setConstantStride(bool state);
/// Obtain an Accessor that stores getter and setter functors.
virtual AccessorBasePtr getAccessor() const = 0;
/// Register a attribute type along with a factory function.
static void registerType(const NamePair& type, FactoryMethod,
const ScopedRegistryLock* lock = nullptr);
/// Remove a attribute type from the registry.
static void unregisterType(const NamePair& type,
const ScopedRegistryLock* lock = nullptr);
#if OPENVDB_ABI_VERSION_NUMBER < 6
size_t mCompressedBytes = 0;
uint8_t mFlags = 0;
uint8_t mUsePagedRead = 0;
tbb::atomic<Index32> mOutOfCore; // interpreted as bool
compression::PageHandle::Ptr mPageHandle;
#else // #if OPENVDB_ABI_VERSION_NUMBER < 6
bool mIsUniform = true;
mutable tbb::spin_mutex mMutex;
uint8_t mFlags = 0;
uint8_t mUsePagedRead = 0;
tbb::atomic<Index32> mOutOfCore; // interpreted as bool
/// used for out-of-core, paged reading
union {
compression::PageHandle::Ptr mPageHandle;
size_t mCompressedBytes; // as of ABI=6, this data is packed together to save memory
};
#endif
}; // class AttributeArray
////////////////////////////////////////
/// Accessor base class for AttributeArray storage where type is not available
struct AttributeArray::AccessorBase { virtual ~AccessorBase() = default; };
/// Templated Accessor stores typed function pointers used in binding
/// AttributeHandles
template <typename T>
struct AttributeArray::Accessor : public AttributeArray::AccessorBase
{
using GetterPtr = T (*)(const AttributeArray* array, const Index n);
using SetterPtr = void (*)(AttributeArray* array, const Index n, const T& value);
using ValuePtr = void (*)(AttributeArray* array, const T& value);
Accessor(GetterPtr getter, SetterPtr setter, ValuePtr collapser, ValuePtr filler) :
mGetter(getter), mSetter(setter), mCollapser(collapser), mFiller(filler) { }
GetterPtr mGetter;
SetterPtr mSetter;
ValuePtr mCollapser;
ValuePtr mFiller;
}; // struct AttributeArray::Accessor
////////////////////////////////////////
namespace attribute_traits
{
template <typename T> struct TruncateTrait { };
template <> struct TruncateTrait<float> { using Type = half; };
template <> struct TruncateTrait<int> { using Type = short; };
template <typename T> struct TruncateTrait<math::Vec3<T>> {
using Type = math::Vec3<typename TruncateTrait<T>::Type>;
};
template <bool OneByte, typename T> struct UIntTypeTrait { };
template<typename T> struct UIntTypeTrait</*OneByte=*/true, T> { using Type = uint8_t; };
template<typename T> struct UIntTypeTrait</*OneByte=*/false, T> { using Type = uint16_t; };
template<typename T> struct UIntTypeTrait</*OneByte=*/true, math::Vec3<T>> {
using Type = math::Vec3<uint8_t>;
};
template<typename T> struct UIntTypeTrait</*OneByte=*/false, math::Vec3<T>> {
using Type = math::Vec3<uint16_t>;
};
}
////////////////////////////////////////
// Attribute codec schemes
struct UnknownCodec { };
struct NullCodec
{
template <typename T>
struct Storage { using Type = T; };
template<typename ValueType> static void decode(const ValueType&, ValueType&);
template<typename ValueType> static void encode(const ValueType&, ValueType&);
static const char* name() { return "null"; }
};
struct TruncateCodec
{
template <typename T>
struct Storage { using Type = typename attribute_traits::TruncateTrait<T>::Type; };
template<typename StorageType, typename ValueType> static void decode(const StorageType&, ValueType&);
template<typename StorageType, typename ValueType> static void encode(const ValueType&, StorageType&);
static const char* name() { return "trnc"; }
};
// Fixed-point codec range for voxel-space positions [-0.5,0.5]
struct PositionRange
{
static const char* name() { return "fxpt"; }
template <typename ValueType> static ValueType encode(const ValueType& value) { return value + ValueType(0.5); }
template <typename ValueType> static ValueType decode(const ValueType& value) { return value - ValueType(0.5); }
};
// Fixed-point codec range for unsigned values in the unit range [0.0,1.0]
struct UnitRange
{
static const char* name() { return "ufxpt"; }
template <typename ValueType> static ValueType encode(const ValueType& value) { return value; }
template <typename ValueType> static ValueType decode(const ValueType& value) { return value; }
};
template <bool OneByte, typename Range=PositionRange>
struct FixedPointCodec
{
template <typename T>
struct Storage { using Type = typename attribute_traits::UIntTypeTrait<OneByte, T>::Type; };
template<typename StorageType, typename ValueType> static void decode(const StorageType&, ValueType&);
template<typename StorageType, typename ValueType> static void encode(const ValueType&, StorageType&);
static const char* name() {
static const std::string Name = std::string(Range::name()) + (OneByte ? "8" : "16");
return Name.c_str();
}
};
struct UnitVecCodec
{
using StorageType = uint16_t;
template <typename T>
struct Storage { using Type = StorageType; };
template<typename T> static void decode(const StorageType&, math::Vec3<T>&);
template<typename T> static void encode(const math::Vec3<T>&, StorageType&);
static const char* name() { return "uvec"; }
};
////////////////////////////////////////
/// Typed class for storing attribute data
template<typename ValueType_, typename Codec_ = NullCodec>
#if OPENVDB_ABI_VERSION_NUMBER >= 6 // for ABI=6, class is final to allow for de-virtualization
class TypedAttributeArray final: public AttributeArray
#else
class TypedAttributeArray: public AttributeArray
#endif
{
public:
using Ptr = std::shared_ptr<TypedAttributeArray>;
using ConstPtr = std::shared_ptr<const TypedAttributeArray>;
using ValueType = ValueType_;
using Codec = Codec_;
using StorageType = typename Codec::template Storage<ValueType>::Type;
//////////
/// Default constructor, always constructs a uniform attribute.
explicit TypedAttributeArray(Index n = 1, Index strideOrTotalSize = 1, bool constantStride = true,
const ValueType& uniformValue = zeroVal<ValueType>());
#if OPENVDB_ABI_VERSION_NUMBER >= 7
/// Deep copy constructor.
/// @note This method is thread-safe (as of ABI=7) for concurrently reading from the
/// source attribute array while being deep-copied. Specifically, this means that the
/// attribute array being deep-copied can be out-of-core and safely loaded in one thread
/// while being copied using this copy-constructor in another thread.
/// It is not thread-safe for write.
TypedAttributeArray(const TypedAttributeArray&);
/// Deep copy constructor.
[[deprecated("Use copy-constructor without unused bool parameter")]]
TypedAttributeArray(const TypedAttributeArray&, bool /*unused*/);
#else
/// Deep copy constructor.
/// @note This method is not thread-safe for reading or writing, use
/// TypedAttributeArray::copy() to ensure thread-safety when reading concurrently.
TypedAttributeArray(const TypedAttributeArray&, bool uncompress = false);
#endif
/// Deep copy assignment operator.
/// @note this operator is thread-safe.
TypedAttributeArray& operator=(const TypedAttributeArray&);
/// Move constructor disabled.
TypedAttributeArray(TypedAttributeArray&&) = delete;
/// Move assignment operator disabled.
TypedAttributeArray& operator=(TypedAttributeArray&&) = delete;
~TypedAttributeArray() override { this->deallocate(); }
/// Return a copy of this attribute.
/// @note This method is thread-safe.
AttributeArray::Ptr copy() const override;
/// Return a copy of this attribute.
/// @note This method is thread-safe.
[[deprecated("In-memory compression no longer supported, use AttributeArray::copy() instead")]]
AttributeArray::Ptr copyUncompressed() const override;
/// Return a new attribute array of the given length @a n and @a stride with uniform value zero.
static Ptr create(Index n, Index strideOrTotalSize = 1, bool constantStride = true,
const Metadata* metadata = nullptr);
/// Cast an AttributeArray to TypedAttributeArray<T>
static TypedAttributeArray& cast(AttributeArray& attributeArray);
/// Cast an AttributeArray to TypedAttributeArray<T>
static const TypedAttributeArray& cast(const AttributeArray& attributeArray);
/// Return the name of this attribute's type (includes codec)
static const NamePair& attributeType();
/// Return the name of this attribute's type.
const NamePair& type() const override { return attributeType(); }
/// Return @c true if this attribute type is registered.
static bool isRegistered();
/// Register this attribute type along with a factory function.
static void registerType();
/// Remove this attribute type from the registry.
static void unregisterType();
/// Return the number of elements in this array.
Index size() const override { return mSize; }
/// Return the stride of this array.
/// @note A return value of zero means a variable stride
Index stride() const override { return hasConstantStride() ? mStrideOrTotalSize : 0; }
/// Return the size of the data in this array.
Index dataSize() const override {
return hasConstantStride() ? mSize * mStrideOrTotalSize : mStrideOrTotalSize;
}
#if OPENVDB_ABI_VERSION_NUMBER >= 6
/// Return the name of the value type of a single element in this array (e.g., "float" or "vec3d").
Name valueType() const override { return typeNameAsString<ValueType>(); }
/// Return the name of the codec used by this array (e.g., "trnc" or "fxpt").
Name codecType() const override { return Codec::name(); }
/// Return the size in bytes of the value type of a single element in this array.
Index valueTypeSize() const override { return sizeof(ValueType); }
/// Return the size in bytes of the storage type of a single element of this array.
/// @note If the Codec is a NullCodec, valueSize() == storageSize()
Index storageTypeSize() const override { return sizeof(StorageType); }
/// Return @c true if the value type is floating point
bool valueTypeIsFloatingPoint() const override;
/// Return @c true if the value type is a class (ie vector, matrix or quaternion return true)
bool valueTypeIsClass() const override;
/// Return @c true if the value type is a vector
bool valueTypeIsVector() const override;
/// Return @c true if the value type is a quaternion
bool valueTypeIsQuaternion() const override;
/// Return @c true if the value type is a matrix
bool valueTypeIsMatrix() const override;
#endif
/// Return the number of bytes of memory used by this attribute.
size_t memUsage() const override;
/// Return the value at index @a n (assumes in-core)
ValueType getUnsafe(Index n) const;
/// Return the value at index @a n
ValueType get(Index n) const;
/// Return the @a value at index @a n (assumes in-core)
template<typename T> void getUnsafe(Index n, T& value) const;
/// Return the @a value at index @a n
template<typename T> void get(Index n, T& value) const;
/// Non-member equivalent to getUnsafe() that static_casts array to this TypedAttributeArray
/// (assumes in-core)
static ValueType getUnsafe(const AttributeArray* array, const Index n);
/// Set @a value at the given index @a n (assumes in-core)
void setUnsafe(Index n, const ValueType& value);
/// Set @a value at the given index @a n
void set(Index n, const ValueType& value);
/// Set @a value at the given index @a n (assumes in-core)
template<typename T> void setUnsafe(Index n, const T& value);
/// Set @a value at the given index @a n
template<typename T> void set(Index n, const T& value);
/// Non-member equivalent to setUnsafe() that static_casts array to this TypedAttributeArray
/// (assumes in-core)
static void setUnsafe(AttributeArray* array, const Index n, const ValueType& value);
/// Set value at given index @a n from @a sourceIndex of another @a sourceArray
#if OPENVDB_ABI_VERSION_NUMBER >= 6
[[deprecated("From ABI 6 on, use copyValues() with source-target index pairs")]]
#endif
void set(const Index n, const AttributeArray& sourceArray, const Index sourceIndex) override;
/// Return @c true if this array is stored as a single uniform value.
bool isUniform() const override { return mIsUniform; }
/// @brief Replace the single value storage with an array of length size().
/// @note Non-uniform attributes are unchanged.
/// @param fill toggle to initialize the array elements with the pre-expanded value.
void expand(bool fill = true) override;
/// Replace the existing array with a uniform zero value.
void collapse() override;
/// Compact the existing array to become uniform if all values are identical
bool compact() override;
/// Replace the existing array with the given uniform value.
void collapse(const ValueType& uniformValue);
/// @brief Fill the existing array with the given value.
/// @note Identical to collapse() except a non-uniform array will not become uniform.
void fill(const ValueType& value);
/// Non-member equivalent to collapse() that static_casts array to this TypedAttributeArray
static void collapse(AttributeArray* array, const ValueType& value);
/// Non-member equivalent to fill() that static_casts array to this TypedAttributeArray
static void fill(AttributeArray* array, const ValueType& value);
/// Compress the attribute array.
[[deprecated("Previously this compressed the attribute array, now it does nothing")]]
bool compress() override;
/// Uncompress the attribute array.
[[deprecated("Previously this uncompressed the attribute array, now it does nothing")]]
bool decompress() override;
/// Read attribute data from a stream.
void read(std::istream&) override;
/// Write attribute data to a stream.
/// @param os the output stream
/// @param outputTransient if true, write out transient attributes
void write(std::ostream& os, bool outputTransient) const override;
/// Write attribute data to a stream, don't write transient attributes.
void write(std::ostream&) const override;
/// Read attribute metadata from a stream.
void readMetadata(std::istream&) override;
/// Write attribute metadata to a stream.
/// @param os the output stream
/// @param outputTransient if true, write out transient attributes
/// @param paged if true, data is written out in pages
void writeMetadata(std::ostream& os, bool outputTransient, bool paged) const override;
/// Read attribute buffers from a stream.
void readBuffers(std::istream&) override;
/// Write attribute buffers to a stream.
/// @param os the output stream
/// @param outputTransient if true, write out transient attributes
void writeBuffers(std::ostream& os, bool outputTransient) const override;
/// Read attribute buffers from a paged stream.
void readPagedBuffers(compression::PagedInputStream&) override;
/// Write attribute buffers to a paged stream.
/// @param os the output stream
/// @param outputTransient if true, write out transient attributes
void writePagedBuffers(compression::PagedOutputStream& os, bool outputTransient) const override;
/// Return @c true if this buffer's values have not yet been read from disk.
inline bool isOutOfCore() const;
/// Ensures all data is in-core
void loadData() const override;
#if OPENVDB_ABI_VERSION_NUMBER >= 6
/// Return @c true if all data has been loaded
bool isDataLoaded() const override;
#endif
protected:
AccessorBasePtr getAccessor() const override;
/// Return the raw data buffer
inline StorageType* data() { assert(validData()); return mData.get(); }
inline const StorageType* data() const { assert(validData()); return mData.get(); }
/// Verify that data is not out-of-core or in a partially-read state
inline bool validData() const { return !(isOutOfCore() || (flags() & PARTIALREAD)); }
private:
friend class ::TestAttributeArray;
#if OPENVDB_ABI_VERSION_NUMBER >= 7
TypedAttributeArray(const TypedAttributeArray&, const tbb::spin_mutex::scoped_lock&);
#endif
/// Load data from memory-mapped file.
inline void doLoad() const;
/// Load data from memory-mapped file (unsafe as this function is not protected by a mutex).
/// @param compression parameter no longer used
inline void doLoadUnsafe(const bool compression = true) const;
/// Compress in-core data assuming mutex is locked
inline bool compressUnsafe();
/// Toggle out-of-core state
inline void setOutOfCore(const bool);
/// Compare the this data to another attribute array. Used by the base class comparison operator
bool isEqual(const AttributeArray& other) const override;
#if OPENVDB_ABI_VERSION_NUMBER >= 6
/// Virtual function to retrieve the data buffer from the derived class cast to a char byte array
char* dataAsByteArray() override;
const char* dataAsByteArray() const override;
#endif
size_t arrayMemUsage() const;
void allocate();
void deallocate();
/// Helper function for use with registerType()
static AttributeArray::Ptr factory(Index n, Index strideOrTotalSize, bool constantStride,
const Metadata* metadata) {
return TypedAttributeArray::create(n, strideOrTotalSize, constantStride, metadata);
}
static std::unique_ptr<const NamePair> sTypeName;
std::unique_ptr<StorageType[]> mData;
Index mSize;
Index mStrideOrTotalSize;
#if OPENVDB_ABI_VERSION_NUMBER < 6 // as of ABI=6, this data lives in the base class to reduce memory
bool mIsUniform = true;
mutable tbb::spin_mutex mMutex;
#endif
}; // class TypedAttributeArray
////////////////////////////////////////
/// AttributeHandles provide access to specific TypedAttributeArray methods without needing
/// to know the compression codec, however these methods also incur the cost of a function pointer
template <typename ValueType, typename CodecType = UnknownCodec>
class AttributeHandle
{
public:
using Handle = AttributeHandle<ValueType, CodecType>;
using Ptr = std::shared_ptr<Handle>;
using UniquePtr = std::unique_ptr<Handle>;
protected:
using GetterPtr = ValueType (*)(const AttributeArray* array, const Index n);
using SetterPtr = void (*)(AttributeArray* array, const Index n, const ValueType& value);
using ValuePtr = void (*)(AttributeArray* array, const ValueType& value);
public:
static Ptr create(const AttributeArray& array, const bool collapseOnDestruction = true);
AttributeHandle(const AttributeArray& array, const bool collapseOnDestruction = true);
AttributeHandle(const AttributeHandle&) = default;
AttributeHandle& operator=(const AttributeHandle&) = default;
virtual ~AttributeHandle();
Index stride() const { return mStrideOrTotalSize; }
Index size() const { return mSize; }
bool isUniform() const;
bool hasConstantStride() const;
ValueType get(Index n, Index m = 0) const;
const AttributeArray& array() const;
protected:
Index index(Index n, Index m) const;
const AttributeArray* mArray;
GetterPtr mGetter;
SetterPtr mSetter;
ValuePtr mCollapser;
ValuePtr mFiller;
private:
friend class ::TestAttributeArray;
template <bool IsUnknownCodec>
typename std::enable_if<IsUnknownCodec, bool>::type compatibleType() const;
template <bool IsUnknownCodec>
typename std::enable_if<!IsUnknownCodec, bool>::type compatibleType() const;
template <bool IsUnknownCodec>
typename std::enable_if<IsUnknownCodec, ValueType>::type get(Index index) const;
template <bool IsUnknownCodec>
typename std::enable_if<!IsUnknownCodec, ValueType>::type get(Index index) const;
// local copy of AttributeArray (to preserve compression)
AttributeArray::Ptr mLocalArray;
Index mStrideOrTotalSize;
Index mSize;
bool mCollapseOnDestruction;
}; // class AttributeHandle
////////////////////////////////////////
/// Write-able version of AttributeHandle
template <typename ValueType, typename CodecType = UnknownCodec>
class AttributeWriteHandle : public AttributeHandle<ValueType, CodecType>
{
public:
using Handle = AttributeWriteHandle<ValueType, CodecType>;
using Ptr = std::shared_ptr<Handle>;
using ScopedPtr = std::unique_ptr<Handle>;
static Ptr create(AttributeArray& array, const bool expand = true);
AttributeWriteHandle(AttributeArray& array, const bool expand = true);
virtual ~AttributeWriteHandle() = default;
/// @brief If this array is uniform, replace it with an array of length size().
/// @param fill if true, assign the uniform value to each element of the array.
void expand(bool fill = true);
/// Replace the existing array with a uniform value (zero if none provided).
void collapse();
void collapse(const ValueType& uniformValue);
/// Compact the existing array to become uniform if all values are identical
bool compact();
/// @brief Fill the existing array with the given value.
/// @note Identical to collapse() except a non-uniform array will not become uniform.
void fill(const ValueType& value);
void set(Index n, const ValueType& value);
void set(Index n, Index m, const ValueType& value);
AttributeArray& array();
private:
friend class ::TestAttributeArray;
template <bool IsUnknownCodec>
typename std::enable_if<IsUnknownCodec, void>::type set(Index index, const ValueType& value) const;
template <bool IsUnknownCodec>
typename std::enable_if<!IsUnknownCodec, void>::type set(Index index, const ValueType& value) const;
}; // class AttributeWriteHandle
////////////////////////////////////////
// Attribute codec implementation
template<typename ValueType>
inline void
NullCodec::decode(const ValueType& data, ValueType& val)
{
val = data;
}
template<typename ValueType>
inline void
NullCodec::encode(const ValueType& val, ValueType& data)
{
data = val;
}
template<typename StorageType, typename ValueType>
inline void
TruncateCodec::decode(const StorageType& data, ValueType& val)
{
val = static_cast<ValueType>(data);
}
template<typename StorageType, typename ValueType>
inline void
TruncateCodec::encode(const ValueType& val, StorageType& data)
{
data = static_cast<StorageType>(val);
}
template <bool OneByte, typename Range>
template<typename StorageType, typename ValueType>
inline void
FixedPointCodec<OneByte, Range>::decode(const StorageType& data, ValueType& val)
{
val = fixedPointToFloatingPoint<ValueType>(data);
// shift value range to be -0.5 => 0.5 (as this is most commonly used for position)
val = Range::template decode<ValueType>(val);
}
template <bool OneByte, typename Range>
template<typename StorageType, typename ValueType>
inline void
FixedPointCodec<OneByte, Range>::encode(const ValueType& val, StorageType& data)
{
// shift value range to be -0.5 => 0.5 (as this is most commonly used for position)
const ValueType newVal = Range::template encode<ValueType>(val);
data = floatingPointToFixedPoint<StorageType>(newVal);
}
template<typename T>
inline void
UnitVecCodec::decode(const StorageType& data, math::Vec3<T>& val)
{
val = math::QuantizedUnitVec::unpack(data);
}
template<typename T>
inline void
UnitVecCodec::encode(const math::Vec3<T>& val, StorageType& data)
{
data = math::QuantizedUnitVec::pack(val);
}
////////////////////////////////////////
// AttributeArray implementation
#if OPENVDB_ABI_VERSION_NUMBER >= 6
template <typename IterT>
void AttributeArray::doCopyValues(const AttributeArray& sourceArray, const IterT& iter,
bool rangeChecking/*=true*/)
{
// ensure both arrays have float-float or integer-integer value types
assert(sourceArray.valueTypeIsFloatingPoint() == this->valueTypeIsFloatingPoint());
// ensure both arrays have been loaded from disk (if delay-loaded)
assert(sourceArray.isDataLoaded() && this->isDataLoaded());
// ensure storage size * stride matches on both arrays
assert(this->storageTypeSize()*this->stride() ==
sourceArray.storageTypeSize()*sourceArray.stride());
const size_t bytes(sourceArray.storageTypeSize()*sourceArray.stride());
const char* const sourceBuffer = sourceArray.dataAsByteArray();
char* const targetBuffer = this->dataAsByteArray();
assert(sourceBuffer && targetBuffer);
if (rangeChecking && this->isUniform()) {
OPENVDB_THROW(IndexError, "Cannot copy array data as target array is uniform.");
}
const bool sourceIsUniform = sourceArray.isUniform();
const Index sourceDataSize = rangeChecking ? sourceArray.dataSize() : 0;
const Index targetDataSize = rangeChecking ? this->dataSize() : 0;
for (IterT it(iter); it; ++it) {
const Index sourceIndex = sourceIsUniform ? 0 : it.sourceIndex();
const Index targetIndex = it.targetIndex();
if (rangeChecking) {
if (sourceIndex >= sourceDataSize) {
OPENVDB_THROW(IndexError,
"Cannot copy array data as source index exceeds size of source array.");
}
if (targetIndex >= targetDataSize) {
OPENVDB_THROW(IndexError,
"Cannot copy array data as target index exceeds size of target array.");
}
} else {
// range-checking asserts
assert(sourceIndex < sourceArray.dataSize());
assert(targetIndex < this->dataSize());
if (this->isUniform()) assert(targetIndex == Index(0));
}
const size_t targetOffset(targetIndex * bytes);
const size_t sourceOffset(sourceIndex * bytes);
std::memcpy(targetBuffer + targetOffset, sourceBuffer + sourceOffset, bytes);
}
}
template <typename IterT>
void AttributeArray::copyValuesUnsafe(const AttributeArray& sourceArray, const IterT& iter)
{
this->doCopyValues(sourceArray, iter, /*range-checking=*/false);
}
template <typename IterT>
void AttributeArray::copyValues(const AttributeArray& sourceArray, const IterT& iter,
bool compact/* = true*/)
{
const Index bytes = sourceArray.storageTypeSize();
if (bytes != this->storageTypeSize()) {
OPENVDB_THROW(TypeError, "Cannot copy array data due to mis-match in storage type sizes.");
}
// ensure both arrays have been loaded from disk
sourceArray.loadData();
this->loadData();
// if the target array is uniform, expand it first
this->expand();
// TODO: Acquire mutex locks for source and target arrays to ensure that
// value copying is always thread-safe. Note that the unsafe method will be
// faster, but can only be used if neither the source or target arrays are
// modified during copying. Note that this will require a new private
// virtual method with ABI=7 to access the mutex from the derived class.
this->doCopyValues(sourceArray, iter, true);
// attempt to compact target array
if (compact) {
this->compact();
}
}
#endif
////////////////////////////////////////
// TypedAttributeArray implementation
template<typename ValueType_, typename Codec_>
std::unique_ptr<const NamePair> TypedAttributeArray<ValueType_, Codec_>::sTypeName;
template<typename ValueType_, typename Codec_>
TypedAttributeArray<ValueType_, Codec_>::TypedAttributeArray(
Index n, Index strideOrTotalSize, bool constantStride, const ValueType& uniformValue)
: AttributeArray()
, mData(new StorageType[1])
, mSize(n)
, mStrideOrTotalSize(strideOrTotalSize)
{
if (constantStride) {
this->setConstantStride(true);
if (strideOrTotalSize == 0) {
OPENVDB_THROW(ValueError, "Creating a TypedAttributeArray with a constant stride requires that " \
"stride to be at least one.")
}
}
else {
this->setConstantStride(false);
if (mStrideOrTotalSize < n) {
OPENVDB_THROW(ValueError, "Creating a TypedAttributeArray with a non-constant stride must have " \
"a total size of at least the number of elements in the array.")
}
}
mSize = std::max(Index(1), mSize);
mStrideOrTotalSize = std::max(Index(1), mStrideOrTotalSize);
Codec::encode(uniformValue, this->data()[0]);
}
#if OPENVDB_ABI_VERSION_NUMBER >= 7
template<typename ValueType_, typename Codec_>
TypedAttributeArray<ValueType_, Codec_>::TypedAttributeArray(const TypedAttributeArray& rhs)
: TypedAttributeArray(rhs, tbb::spin_mutex::scoped_lock(rhs.mMutex))
{
}
template<typename ValueType_, typename Codec_>
TypedAttributeArray<ValueType_, Codec_>::TypedAttributeArray(const TypedAttributeArray& rhs,
const tbb::spin_mutex::scoped_lock& lock)
: AttributeArray(rhs, lock)
#else
template<typename ValueType_, typename Codec_>
TypedAttributeArray<ValueType_, Codec_>::TypedAttributeArray(const TypedAttributeArray& rhs, bool)
: AttributeArray(rhs)
#endif
, mSize(rhs.mSize)
, mStrideOrTotalSize(rhs.mStrideOrTotalSize)
#if OPENVDB_ABI_VERSION_NUMBER < 6
, mIsUniform(rhs.mIsUniform)
#endif
{
if (this->validData()) {
this->allocate();
std::memcpy(static_cast<void*>(this->data()), rhs.data(), this->arrayMemUsage());
}
}
template<typename ValueType_, typename Codec_>
TypedAttributeArray<ValueType_, Codec_>&
TypedAttributeArray<ValueType_, Codec_>::operator=(const TypedAttributeArray& rhs)
{
if (&rhs != this) {
// lock both the source and target arrays to ensure thread-safety
tbb::spin_mutex::scoped_lock lock(mMutex);
tbb::spin_mutex::scoped_lock rhsLock(rhs.mMutex);
this->deallocate();
mFlags = rhs.mFlags;
mUsePagedRead = rhs.mUsePagedRead;
mSize = rhs.mSize;
mStrideOrTotalSize = rhs.mStrideOrTotalSize;
mIsUniform = rhs.mIsUniform;
if (this->validData()) {
this->allocate();
std::memcpy(static_cast<void*>(this->data()), rhs.data(), this->arrayMemUsage());
}
}
return *this;
}
template<typename ValueType_, typename Codec_>
inline const NamePair&
TypedAttributeArray<ValueType_, Codec_>::attributeType()
{
static std::once_flag once;
std::call_once(once, []()
{
sTypeName.reset(new NamePair(typeNameAsString<ValueType>(), Codec::name()));
});
return *sTypeName;
}
template<typename ValueType_, typename Codec_>
inline bool
TypedAttributeArray<ValueType_, Codec_>::isRegistered()
{
return AttributeArray::isRegistered(TypedAttributeArray::attributeType());
}
template<typename ValueType_, typename Codec_>
inline void
TypedAttributeArray<ValueType_, Codec_>::registerType()
{
AttributeArray::registerType(TypedAttributeArray::attributeType(), TypedAttributeArray::factory);
}
template<typename ValueType_, typename Codec_>
inline void
TypedAttributeArray<ValueType_, Codec_>::unregisterType()
{
AttributeArray::unregisterType(TypedAttributeArray::attributeType());
}
template<typename ValueType_, typename Codec_>
inline typename TypedAttributeArray<ValueType_, Codec_>::Ptr
TypedAttributeArray<ValueType_, Codec_>::create(Index n, Index stride, bool constantStride,
const Metadata* metadata)
{
const TypedMetadata<ValueType>* typedMetadata = metadata ?
dynamic_cast<const TypedMetadata<ValueType>*>(metadata) : nullptr;
return Ptr(new TypedAttributeArray(n, stride, constantStride,
typedMetadata ? typedMetadata->value() : zeroVal<ValueType>()));
}
template<typename ValueType_, typename Codec_>
inline TypedAttributeArray<ValueType_, Codec_>&
TypedAttributeArray<ValueType_, Codec_>::cast(AttributeArray& attributeArray)
{
if (!attributeArray.isType<TypedAttributeArray>()) {
OPENVDB_THROW(TypeError, "Invalid Attribute Type");
}
return static_cast<TypedAttributeArray&>(attributeArray);
}
template<typename ValueType_, typename Codec_>
inline const TypedAttributeArray<ValueType_, Codec_>&
TypedAttributeArray<ValueType_, Codec_>::cast(const AttributeArray& attributeArray)
{
if (!attributeArray.isType<TypedAttributeArray>()) {
OPENVDB_THROW(TypeError, "Invalid Attribute Type");
}
return static_cast<const TypedAttributeArray&>(attributeArray);
}
template<typename ValueType_, typename Codec_>
AttributeArray::Ptr
TypedAttributeArray<ValueType_, Codec_>::copy() const
{
#if OPENVDB_ABI_VERSION_NUMBER < 7
tbb::spin_mutex::scoped_lock lock(mMutex);
#endif
return AttributeArray::Ptr(new TypedAttributeArray<ValueType, Codec>(*this));
}
template<typename ValueType_, typename Codec_>
AttributeArray::Ptr
TypedAttributeArray<ValueType_, Codec_>::copyUncompressed() const
{
return this->copy();
}
template<typename ValueType_, typename Codec_>
size_t
TypedAttributeArray<ValueType_, Codec_>::arrayMemUsage() const
{
if (this->isOutOfCore()) return 0;
return (mIsUniform ? 1 : this->dataSize()) * sizeof(StorageType);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::allocate()
{
assert(!mData);
if (mIsUniform) {
mData.reset(new StorageType[1]);
}
else {
const size_t size(this->dataSize());
assert(size > 0);
mData.reset(new StorageType[size]);
}
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::deallocate()
{
// detach from file if delay-loaded
if (this->isOutOfCore()) {
this->setOutOfCore(false);
this->mPageHandle.reset();
}
if (mData) mData.reset();
}
#if OPENVDB_ABI_VERSION_NUMBER >= 6
template<typename ValueType_, typename Codec_>
bool
TypedAttributeArray<ValueType_, Codec_>::valueTypeIsFloatingPoint() const
{
// TODO: Update to use Traits that correctly handle matrices and quaternions.
if (std::is_same<ValueType, Quats>::value ||
std::is_same<ValueType, Quatd>::value ||
std::is_same<ValueType, Mat3s>::value ||
std::is_same<ValueType, Mat3d>::value ||
std::is_same<ValueType, Mat4s>::value ||
std::is_same<ValueType, Mat4d>::value) return true;
using ElementT = typename VecTraits<ValueType>::ElementType;
// half is not defined as float point as expected, so explicitly handle it
return std::is_floating_point<ElementT>::value || std::is_same<half, ElementT>::value;
}
template<typename ValueType_, typename Codec_>
bool
TypedAttributeArray<ValueType_, Codec_>::valueTypeIsClass() const
{
// half is not defined as a non-class type as expected, so explicitly exclude it
return std::is_class<ValueType>::value && !std::is_same<half, ValueType>::value;
}
template<typename ValueType_, typename Codec_>
bool
TypedAttributeArray<ValueType_, Codec_>::valueTypeIsVector() const
{
return VecTraits<ValueType>::IsVec;
}
template<typename ValueType_, typename Codec_>
bool
TypedAttributeArray<ValueType_, Codec_>::valueTypeIsQuaternion() const
{
// TODO: improve performance by making this a compile-time check using type traits
return !this->valueType().compare(0, 4, "quat");
}
template<typename ValueType_, typename Codec_>
bool
TypedAttributeArray<ValueType_, Codec_>::valueTypeIsMatrix() const
{
// TODO: improve performance by making this a compile-time check using type traits
return !this->valueType().compare(0, 3, "mat");
}
#endif
template<typename ValueType_, typename Codec_>
size_t
TypedAttributeArray<ValueType_, Codec_>::memUsage() const
{
return sizeof(*this) + (bool(mData) ? this->arrayMemUsage() : 0);
}
template<typename ValueType_, typename Codec_>
typename TypedAttributeArray<ValueType_, Codec_>::ValueType
TypedAttributeArray<ValueType_, Codec_>::getUnsafe(Index n) const
{
assert(n < this->dataSize());
ValueType val;
Codec::decode(/*in=*/this->data()[mIsUniform ? 0 : n], /*out=*/val);
return val;
}
template<typename ValueType_, typename Codec_>
typename TypedAttributeArray<ValueType_, Codec_>::ValueType
TypedAttributeArray<ValueType_, Codec_>::get(Index n) const
{
if (n >= this->dataSize()) OPENVDB_THROW(IndexError, "Out-of-range access.");
if (this->isOutOfCore()) this->doLoad();
return this->getUnsafe(n);
}
template<typename ValueType_, typename Codec_>
template<typename T>
void
TypedAttributeArray<ValueType_, Codec_>::getUnsafe(Index n, T& val) const
{
val = static_cast<T>(this->getUnsafe(n));
}
template<typename ValueType_, typename Codec_>
template<typename T>
void
TypedAttributeArray<ValueType_, Codec_>::get(Index n, T& val) const
{
val = static_cast<T>(this->get(n));
}
template<typename ValueType_, typename Codec_>
typename TypedAttributeArray<ValueType_, Codec_>::ValueType
TypedAttributeArray<ValueType_, Codec_>::getUnsafe(const AttributeArray* array, const Index n)
{
return static_cast<const TypedAttributeArray<ValueType, Codec>*>(array)->getUnsafe(n);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::setUnsafe(Index n, const ValueType& val)
{
assert(n < this->dataSize());
assert(!this->isOutOfCore());
assert(!this->isUniform());
// this unsafe method assumes the data is not uniform, however if it is, this redirects the index
// to zero, which is marginally less efficient but ensures not writing to an illegal address
Codec::encode(/*in=*/val, /*out=*/this->data()[mIsUniform ? 0 : n]);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::set(Index n, const ValueType& val)
{
if (n >= this->dataSize()) OPENVDB_THROW(IndexError, "Out-of-range access.");
if (this->isOutOfCore()) this->doLoad();
if (this->isUniform()) this->expand();
this->setUnsafe(n, val);
}
template<typename ValueType_, typename Codec_>
template<typename T>
void
TypedAttributeArray<ValueType_, Codec_>::setUnsafe(Index n, const T& val)
{
this->setUnsafe(n, static_cast<ValueType>(val));
}
template<typename ValueType_, typename Codec_>
template<typename T>
void
TypedAttributeArray<ValueType_, Codec_>::set(Index n, const T& val)
{
this->set(n, static_cast<ValueType>(val));
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::setUnsafe(AttributeArray* array, const Index n, const ValueType& value)
{
static_cast<TypedAttributeArray<ValueType, Codec>*>(array)->setUnsafe(n, value);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::set(Index n, const AttributeArray& sourceArray, const Index sourceIndex)
{
const TypedAttributeArray& sourceTypedArray = static_cast<const TypedAttributeArray&>(sourceArray);
ValueType sourceValue;
sourceTypedArray.get(sourceIndex, sourceValue);
this->set(n, sourceValue);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::expand(bool fill)
{
if (!mIsUniform) return;
const StorageType val = this->data()[0];
{
tbb::spin_mutex::scoped_lock lock(mMutex);
this->deallocate();
mIsUniform = false;
this->allocate();
}
if (fill) {
for (Index i = 0; i < this->dataSize(); ++i) this->data()[i] = val;
}
}
template<typename ValueType_, typename Codec_>
bool
TypedAttributeArray<ValueType_, Codec_>::compact()
{
if (mIsUniform) return true;
// compaction is not possible if any values are different
const ValueType_ val = this->get(0);
for (Index i = 1; i < this->dataSize(); i++) {
if (!math::isExactlyEqual(this->get(i), val)) return false;
}
this->collapse(this->get(0));
return true;
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::collapse()
{
this->collapse(zeroVal<ValueType>());
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::collapse(const ValueType& uniformValue)
{
if (!mIsUniform) {
tbb::spin_mutex::scoped_lock lock(mMutex);
this->deallocate();
mIsUniform = true;
this->allocate();
}
Codec::encode(uniformValue, this->data()[0]);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::collapse(AttributeArray* array, const ValueType& value)
{
static_cast<TypedAttributeArray<ValueType, Codec>*>(array)->collapse(value);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::fill(const ValueType& value)
{
if (this->isOutOfCore()) {
tbb::spin_mutex::scoped_lock lock(mMutex);
this->deallocate();
this->allocate();
}
const Index size = mIsUniform ? 1 : this->dataSize();
for (Index i = 0; i < size; ++i) {
Codec::encode(value, this->data()[i]);
}
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::fill(AttributeArray* array, const ValueType& value)
{
static_cast<TypedAttributeArray<ValueType, Codec>*>(array)->fill(value);
}
template<typename ValueType_, typename Codec_>
inline bool
TypedAttributeArray<ValueType_, Codec_>::compress()
{
return false;
}
template<typename ValueType_, typename Codec_>
inline bool
TypedAttributeArray<ValueType_, Codec_>::compressUnsafe()
{
return false;
}
template<typename ValueType_, typename Codec_>
inline bool
TypedAttributeArray<ValueType_, Codec_>::decompress()
{
return false;
}
template<typename ValueType_, typename Codec_>
bool
TypedAttributeArray<ValueType_, Codec_>::isOutOfCore() const
{
return mOutOfCore;
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::setOutOfCore(const bool b)
{
mOutOfCore = b;
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::doLoad() const
{
if (!(this->isOutOfCore())) return;
TypedAttributeArray<ValueType_, Codec_>* self =
const_cast<TypedAttributeArray<ValueType_, Codec_>*>(this);
// This lock will be contended at most once, after which this buffer
// will no longer be out-of-core.
tbb::spin_mutex::scoped_lock lock(self->mMutex);
this->doLoadUnsafe();
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::loadData() const
{
this->doLoad();
}
#if OPENVDB_ABI_VERSION_NUMBER >= 6
template<typename ValueType_, typename Codec_>
bool
TypedAttributeArray<ValueType_, Codec_>::isDataLoaded() const
{
return !this->isOutOfCore();
}
#endif
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::read(std::istream& is)
{
this->readMetadata(is);
this->readBuffers(is);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::readMetadata(std::istream& is)
{
// read data
Index64 bytes = Index64(0);
is.read(reinterpret_cast<char*>(&bytes), sizeof(Index64));
bytes = bytes - /*flags*/sizeof(Int16) - /*size*/sizeof(Index);
uint8_t flags = uint8_t(0);
is.read(reinterpret_cast<char*>(&flags), sizeof(uint8_t));
mFlags = flags;
uint8_t serializationFlags = uint8_t(0);
is.read(reinterpret_cast<char*>(&serializationFlags), sizeof(uint8_t));
Index size = Index(0);
is.read(reinterpret_cast<char*>(&size), sizeof(Index));
mSize = size;
// warn if an unknown flag has been set
if (mFlags >= 0x20) {
OPENVDB_LOG_WARN("Unknown attribute flags for VDB file format.");
}
// error if an unknown serialization flag has been set,
// as this will adjust the layout of the data and corrupt the ability to read
if (serializationFlags >= 0x10) {
OPENVDB_THROW(IoError, "Unknown attribute serialization flags for VDB file format.");
}
// set uniform, compressed and page read state
mIsUniform = serializationFlags & WRITEUNIFORM;
mUsePagedRead = serializationFlags & WRITEPAGED;
mCompressedBytes = bytes;
mFlags |= PARTIALREAD; // mark data as having been partially read
// read strided value (set to 1 if array is not strided)
if (serializationFlags & WRITESTRIDED) {
Index stride = Index(0);
is.read(reinterpret_cast<char*>(&stride), sizeof(Index));
mStrideOrTotalSize = stride;
}
else {
mStrideOrTotalSize = 1;
}
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::readBuffers(std::istream& is)
{
if (mUsePagedRead) {
// use readBuffers(PagedInputStream&) for paged buffers
OPENVDB_THROW(IoError, "Cannot read paged AttributeArray buffers.");
}
tbb::spin_mutex::scoped_lock lock(mMutex);
this->deallocate();
uint8_t bloscCompressed(0);
if (!mIsUniform) is.read(reinterpret_cast<char*>(&bloscCompressed), sizeof(uint8_t));
assert(mFlags & PARTIALREAD);
std::unique_ptr<char[]> buffer(new char[mCompressedBytes]);
is.read(buffer.get(), mCompressedBytes);
mCompressedBytes = 0;
mFlags = static_cast<uint8_t>(mFlags & ~PARTIALREAD); // mark data read as having completed
// compressed on-disk
if (bloscCompressed == uint8_t(1)) {
// decompress buffer
const size_t inBytes = this->dataSize() * sizeof(StorageType);
std::unique_ptr<char[]> newBuffer = compression::bloscDecompress(buffer.get(), inBytes);
if (newBuffer) buffer.reset(newBuffer.release());
}
// set data to buffer
mData.reset(reinterpret_cast<StorageType*>(buffer.release()));
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::readPagedBuffers(compression::PagedInputStream& is)
{
if (!mUsePagedRead) {
if (!is.sizeOnly()) this->readBuffers(is.getInputStream());
return;
}
// If this array is being read from a memory-mapped file, delay loading of its data
// until the data is actually accessed.
io::MappedFile::Ptr mappedFile = io::getMappedFilePtr(is.getInputStream());
const bool delayLoad = (mappedFile.get() != nullptr);
if (is.sizeOnly())
{
size_t compressedBytes(mCompressedBytes);
mCompressedBytes = 0; // if not set to zero, mPageHandle will attempt to destroy invalid memory
mFlags = static_cast<uint8_t>(mFlags & ~PARTIALREAD); // mark data read as having completed
assert(!mPageHandle);
mPageHandle = is.createHandle(compressedBytes);
return;
}
assert(mPageHandle);
tbb::spin_mutex::scoped_lock lock(mMutex);
this->deallocate();
this->setOutOfCore(delayLoad);
is.read(mPageHandle, std::streamsize(mPageHandle->size()), delayLoad);
if (!delayLoad) {
std::unique_ptr<char[]> buffer = mPageHandle->read();
mData.reset(reinterpret_cast<StorageType*>(buffer.release()));
}
// clear page state
mUsePagedRead = 0;
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::write(std::ostream& os) const
{
this->write(os, /*outputTransient=*/false);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::write(std::ostream& os, bool outputTransient) const
{
this->writeMetadata(os, outputTransient, /*paged=*/false);
this->writeBuffers(os, outputTransient);
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::writeMetadata(std::ostream& os, bool outputTransient, bool paged) const
{
if (!outputTransient && this->isTransient()) return;
if (mFlags & PARTIALREAD) {
OPENVDB_THROW(IoError, "Cannot write out a partially-read AttributeArray.");
}
uint8_t flags(mFlags);
uint8_t serializationFlags(0);
Index size(mSize);
Index stride(mStrideOrTotalSize);
bool strideOfOne(this->stride() == 1);
bool bloscCompression = io::getDataCompression(os) & io::COMPRESS_BLOSC;
// any compressed data needs to be loaded if out-of-core
if (bloscCompression) this->doLoad();
size_t compressedBytes = 0;
if (!strideOfOne)
{
serializationFlags |= WRITESTRIDED;
}
if (mIsUniform)
{
serializationFlags |= WRITEUNIFORM;
if (bloscCompression && paged) serializationFlags |= WRITEPAGED;
}
else if (bloscCompression)
{
if (paged) serializationFlags |= WRITEPAGED;
else {
const char* charBuffer = reinterpret_cast<const char*>(this->data());
const size_t inBytes = this->arrayMemUsage();
compressedBytes = compression::bloscCompressedSize(charBuffer, inBytes);
}
}
Index64 bytes = /*flags*/ sizeof(Int16) + /*size*/ sizeof(Index);
bytes += (compressedBytes > 0) ? compressedBytes : this->arrayMemUsage();
// write data
os.write(reinterpret_cast<const char*>(&bytes), sizeof(Index64));
os.write(reinterpret_cast<const char*>(&flags), sizeof(uint8_t));
os.write(reinterpret_cast<const char*>(&serializationFlags), sizeof(uint8_t));
os.write(reinterpret_cast<const char*>(&size), sizeof(Index));
// write strided
if (!strideOfOne) os.write(reinterpret_cast<const char*>(&stride), sizeof(Index));
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::writeBuffers(std::ostream& os, bool outputTransient) const
{
if (!outputTransient && this->isTransient()) return;
if (mFlags & PARTIALREAD) {
OPENVDB_THROW(IoError, "Cannot write out a partially-read AttributeArray.");
}
this->doLoad();
if (this->isUniform()) {
os.write(reinterpret_cast<const char*>(this->data()), sizeof(StorageType));
}
else if (io::getDataCompression(os) & io::COMPRESS_BLOSC)
{
std::unique_ptr<char[]> compressedBuffer;
size_t compressedBytes = 0;
const char* charBuffer = reinterpret_cast<const char*>(this->data());
const size_t inBytes = this->arrayMemUsage();
compressedBuffer = compression::bloscCompress(charBuffer, inBytes, compressedBytes);
if (compressedBuffer) {
uint8_t bloscCompressed(1);
os.write(reinterpret_cast<const char*>(&bloscCompressed), sizeof(uint8_t));
os.write(reinterpret_cast<const char*>(compressedBuffer.get()), compressedBytes);
}
else {
uint8_t bloscCompressed(0);
os.write(reinterpret_cast<const char*>(&bloscCompressed), sizeof(uint8_t));
os.write(reinterpret_cast<const char*>(this->data()), inBytes);
}
}
else
{
uint8_t bloscCompressed(0);
os.write(reinterpret_cast<const char*>(&bloscCompressed), sizeof(uint8_t));
os.write(reinterpret_cast<const char*>(this->data()), this->arrayMemUsage());
}
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::writePagedBuffers(compression::PagedOutputStream& os, bool outputTransient) const
{
if (!outputTransient && this->isTransient()) return;
// paged compression only available when Blosc is enabled
bool bloscCompression = io::getDataCompression(os.getOutputStream()) & io::COMPRESS_BLOSC;
if (!bloscCompression) {
if (!os.sizeOnly()) this->writeBuffers(os.getOutputStream(), outputTransient);
return;
}
if (mFlags & PARTIALREAD) {
OPENVDB_THROW(IoError, "Cannot write out a partially-read AttributeArray.");
}
this->doLoad();
os.write(reinterpret_cast<const char*>(this->data()), this->arrayMemUsage());
}
template<typename ValueType_, typename Codec_>
void
TypedAttributeArray<ValueType_, Codec_>::doLoadUnsafe(const bool /*compression*/) const
{
if (!(this->isOutOfCore())) return;
// this function expects the mutex to already be locked
auto* self = const_cast<TypedAttributeArray<ValueType_, Codec_>*>(this);
assert(self->mPageHandle);
assert(!(self->mFlags & PARTIALREAD));
std::unique_ptr<char[]> buffer = self->mPageHandle->read();
self->mData.reset(reinterpret_cast<StorageType*>(buffer.release()));
self->mPageHandle.reset();
// clear all write and out-of-core flags
self->mOutOfCore = false;
}
template<typename ValueType_, typename Codec_>
AttributeArray::AccessorBasePtr
TypedAttributeArray<ValueType_, Codec_>::getAccessor() const
{
// use the faster 'unsafe' get and set methods as attribute handles
// ensure data is in-core when constructed
return AccessorBasePtr(new AttributeArray::Accessor<ValueType_>(
&TypedAttributeArray<ValueType_, Codec_>::getUnsafe,
&TypedAttributeArray<ValueType_, Codec_>::setUnsafe,
&TypedAttributeArray<ValueType_, Codec_>::collapse,
&TypedAttributeArray<ValueType_, Codec_>::fill));
}
template<typename ValueType_, typename Codec_>
bool
TypedAttributeArray<ValueType_, Codec_>::isEqual(const AttributeArray& other) const
{
const TypedAttributeArray<ValueType_, Codec_>* const otherT = dynamic_cast<const TypedAttributeArray<ValueType_, Codec_>* >(&other);
if(!otherT) return false;
if(this->mSize != otherT->mSize ||
this->mStrideOrTotalSize != otherT->mStrideOrTotalSize ||
this->mIsUniform != otherT->mIsUniform ||
this->attributeType() != this->attributeType()) return false;
this->doLoad();
otherT->doLoad();
const StorageType *target = this->data(), *source = otherT->data();
if (!target && !source) return true;
if (!target || !source) return false;
Index n = this->mIsUniform ? 1 : mSize;
while (n && math::isExactlyEqual(*target++, *source++)) --n;
return n == 0;
}
#if OPENVDB_ABI_VERSION_NUMBER >= 6
template<typename ValueType_, typename Codec_>
char*
TypedAttributeArray<ValueType_, Codec_>::dataAsByteArray()
{
return reinterpret_cast<char*>(this->data());
}
template<typename ValueType_, typename Codec_>
const char*
TypedAttributeArray<ValueType_, Codec_>::dataAsByteArray() const
{
return reinterpret_cast<const char*>(this->data());
}
#endif
////////////////////////////////////////
/// Accessor to call unsafe get and set methods based on templated Codec and Value
template <typename CodecType, typename ValueType>
struct AccessorEval
{
using GetterPtr = ValueType (*)(const AttributeArray* array, const Index n);
using SetterPtr = void (*)(AttributeArray* array, const Index n, const ValueType& value);
/// Getter that calls to TypedAttributeArray::getUnsafe()
/// @note Functor argument is provided but not required for the generic case
static ValueType get(GetterPtr /*functor*/, const AttributeArray* array, const Index n) {
return TypedAttributeArray<ValueType, CodecType>::getUnsafe(array, n);
}
/// Getter that calls to TypedAttributeArray::setUnsafe()
/// @note Functor argument is provided but not required for the generic case
static void set(SetterPtr /*functor*/, AttributeArray* array, const Index n, const ValueType& value) {
TypedAttributeArray<ValueType, CodecType>::setUnsafe(array, n, value);
}
};
/// Partial specialization when Codec is not known at compile-time to use the supplied functor instead
template <typename ValueType>
struct AccessorEval<UnknownCodec, ValueType>
{
using GetterPtr = ValueType (*)(const AttributeArray* array, const Index n);
using SetterPtr = void (*)(AttributeArray* array, const Index n, const ValueType& value);
/// Getter that calls the supplied functor
static ValueType get(GetterPtr functor, const AttributeArray* array, const Index n) {
return (*functor)(array, n);
}
/// Setter that calls the supplied functor
static void set(SetterPtr functor, AttributeArray* array, const Index n, const ValueType& value) {
(*functor)(array, n, value);
}
};
////////////////////////////////////////
// AttributeHandle implementation
template <typename ValueType, typename CodecType>
typename AttributeHandle<ValueType, CodecType>::Ptr
AttributeHandle<ValueType, CodecType>::create(const AttributeArray& array, const bool collapseOnDestruction)
{
return typename AttributeHandle<ValueType, CodecType>::Ptr(
new AttributeHandle<ValueType, CodecType>(array, collapseOnDestruction));
}
template <typename ValueType, typename CodecType>
AttributeHandle<ValueType, CodecType>::AttributeHandle(const AttributeArray& array, const bool collapseOnDestruction)
: mArray(&array)
, mStrideOrTotalSize(array.hasConstantStride() ? array.stride() : 1)
, mSize(array.hasConstantStride() ? array.size() : array.dataSize())
, mCollapseOnDestruction(collapseOnDestruction && array.isStreaming())
{
if (!this->compatibleType<std::is_same<CodecType, UnknownCodec>::value>()) {
OPENVDB_THROW(TypeError, "Cannot bind handle due to incompatible type of AttributeArray.");
}
// load data if delay-loaded
mArray->loadData();
// bind getter and setter methods
AttributeArray::AccessorBasePtr accessor = mArray->getAccessor();
assert(accessor);
AttributeArray::Accessor<ValueType>* typedAccessor = static_cast<AttributeArray::Accessor<ValueType>*>(accessor.get());
mGetter = typedAccessor->mGetter;
mSetter = typedAccessor->mSetter;
mCollapser = typedAccessor->mCollapser;
mFiller = typedAccessor->mFiller;
}
template <typename ValueType, typename CodecType>
AttributeHandle<ValueType, CodecType>::~AttributeHandle()
{
// if enabled, attribute is collapsed on destruction of the handle to save memory
if (mCollapseOnDestruction) const_cast<AttributeArray*>(this->mArray)->collapse();
}
template <typename ValueType, typename CodecType>
template <bool IsUnknownCodec>
typename std::enable_if<IsUnknownCodec, bool>::type
AttributeHandle<ValueType, CodecType>::compatibleType() const
{
// if codec is unknown, just check the value type
return mArray->hasValueType<ValueType>();
}
template <typename ValueType, typename CodecType>
template <bool IsUnknownCodec>
typename std::enable_if<!IsUnknownCodec, bool>::type
AttributeHandle<ValueType, CodecType>::compatibleType() const
{
// if the codec is known, check the value type and codec
return mArray->isType<TypedAttributeArray<ValueType, CodecType>>();
}
template <typename ValueType, typename CodecType>
const AttributeArray& AttributeHandle<ValueType, CodecType>::array() const
{
assert(mArray);
return *mArray;
}
template <typename ValueType, typename CodecType>
Index AttributeHandle<ValueType, CodecType>::index(Index n, Index m) const
{
Index index = n * mStrideOrTotalSize + m;
assert(index < (mSize * mStrideOrTotalSize));
return index;
}
template <typename ValueType, typename CodecType>
ValueType AttributeHandle<ValueType, CodecType>::get(Index n, Index m) const
{
return this->get<std::is_same<CodecType, UnknownCodec>::value>(this->index(n, m));
}
template <typename ValueType, typename CodecType>
template <bool IsUnknownCodec>
typename std::enable_if<IsUnknownCodec, ValueType>::type
AttributeHandle<ValueType, CodecType>::get(Index index) const
{
// if the codec is unknown, use the getter functor
return (*mGetter)(mArray, index);
}
template <typename ValueType, typename CodecType>
template <bool IsUnknownCodec>
typename std::enable_if<!IsUnknownCodec, ValueType>::type
AttributeHandle<ValueType, CodecType>::get(Index index) const
{
// if the codec is known, call the method on the attribute array directly
return TypedAttributeArray<ValueType, CodecType>::getUnsafe(mArray, index);
}
template <typename ValueType, typename CodecType>
bool AttributeHandle<ValueType, CodecType>::isUniform() const
{
return mArray->isUniform();
}
template <typename ValueType, typename CodecType>
bool AttributeHandle<ValueType, CodecType>::hasConstantStride() const
{
return mArray->hasConstantStride();
}
////////////////////////////////////////
// AttributeWriteHandle implementation
template <typename ValueType, typename CodecType>
typename AttributeWriteHandle<ValueType, CodecType>::Ptr
AttributeWriteHandle<ValueType, CodecType>::create(AttributeArray& array, const bool expand)
{
return typename AttributeWriteHandle<ValueType, CodecType>::Ptr(
new AttributeWriteHandle<ValueType, CodecType>(array, expand));
}
template <typename ValueType, typename CodecType>
AttributeWriteHandle<ValueType, CodecType>::AttributeWriteHandle(AttributeArray& array, const bool expand)
: AttributeHandle<ValueType, CodecType>(array, /*collapseOnDestruction=*/false)
{
if (expand) array.expand();
}
template <typename ValueType, typename CodecType>
void AttributeWriteHandle<ValueType, CodecType>::set(Index n, const ValueType& value)
{
this->set<std::is_same<CodecType, UnknownCodec>::value>(this->index(n, 0), value);
}
template <typename ValueType, typename CodecType>
void AttributeWriteHandle<ValueType, CodecType>::set(Index n, Index m, const ValueType& value)
{
this->set<std::is_same<CodecType, UnknownCodec>::value>(this->index(n, m), value);
}
template <typename ValueType, typename CodecType>
void AttributeWriteHandle<ValueType, CodecType>::expand(const bool fill)
{
const_cast<AttributeArray*>(this->mArray)->expand(fill);
}
template <typename ValueType, typename CodecType>
void AttributeWriteHandle<ValueType, CodecType>::collapse()
{
const_cast<AttributeArray*>(this->mArray)->collapse();
}
template <typename ValueType, typename CodecType>
bool AttributeWriteHandle<ValueType, CodecType>::compact()
{
return const_cast<AttributeArray*>(this->mArray)->compact();
}
template <typename ValueType, typename CodecType>
void AttributeWriteHandle<ValueType, CodecType>::collapse(const ValueType& uniformValue)
{
this->mCollapser(const_cast<AttributeArray*>(this->mArray), uniformValue);
}
template <typename ValueType, typename CodecType>
void AttributeWriteHandle<ValueType, CodecType>::fill(const ValueType& value)
{
this->mFiller(const_cast<AttributeArray*>(this->mArray), value);
}
template <typename ValueType, typename CodecType>
template <bool IsUnknownCodec>
typename std::enable_if<IsUnknownCodec, void>::type
AttributeWriteHandle<ValueType, CodecType>::set(Index index, const ValueType& value) const
{
// if the codec is unknown, use the setter functor
(*this->mSetter)(const_cast<AttributeArray*>(this->mArray), index, value);
}
template <typename ValueType, typename CodecType>
template <bool IsUnknownCodec>
typename std::enable_if<!IsUnknownCodec, void>::type
AttributeWriteHandle<ValueType, CodecType>::set(Index index, const ValueType& value) const
{
// if the codec is known, call the method on the attribute array directly
TypedAttributeArray<ValueType, CodecType>::setUnsafe(const_cast<AttributeArray*>(this->mArray), index, value);
}
template <typename ValueType, typename CodecType>
AttributeArray& AttributeWriteHandle<ValueType, CodecType>::array()
{
assert(this->mArray);
return *const_cast<AttributeArray*>(this->mArray);
}
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_ATTRIBUTE_ARRAY_HAS_BEEN_INCLUDED
| 79,926 | C | 33.391997 | 136 | 0.695181 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointDataGrid.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @author Dan Bailey
///
/// @file points/PointDataGrid.h
///
/// @brief Attribute-owned data structure for points. Point attributes are
/// stored in leaf nodes and ordered by voxel for fast random and
/// sequential access.
#ifndef OPENVDB_POINTS_POINT_DATA_GRID_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_DATA_GRID_HAS_BEEN_INCLUDED
#include <openvdb/version.h>
#include <openvdb/Grid.h>
#include <openvdb/tree/Tree.h>
#include <openvdb/tree/LeafNode.h>
#include <openvdb/tools/PointIndexGrid.h>
#include "AttributeArray.h"
#include "AttributeArrayString.h"
#include "AttributeGroup.h"
#include "AttributeSet.h"
#include "StreamCompression.h"
#include <cstring> // std::memcpy
#include <iostream>
#include <limits>
#include <memory>
#include <type_traits> // std::is_same
#include <utility> // std::pair, std::make_pair
#include <vector>
class TestPointDataLeaf;
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace io
{
/// @brief openvdb::io::readCompressedValues specialized on PointDataIndex32 arrays to
/// ignore the value mask, use a larger block size and use 16-bit size instead of 64-bit
template<>
inline void
readCompressedValues( std::istream& is, PointDataIndex32* destBuf, Index destCount,
const util::NodeMask<3>& /*valueMask*/, bool /*fromHalf*/)
{
using compression::bloscDecompress;
const bool seek = destBuf == nullptr;
const size_t destBytes = destCount*sizeof(PointDataIndex32);
const size_t maximumBytes = std::numeric_limits<uint16_t>::max();
if (destBytes >= maximumBytes) {
OPENVDB_THROW(openvdb::IoError, "Cannot read more than " <<
maximumBytes << " bytes in voxel values.")
}
uint16_t bytes16;
const io::StreamMetadata::Ptr meta = io::getStreamMetadataPtr(is);
if (seek && meta) {
// buffer size temporarily stored in the StreamMetadata pass
// to avoid having to perform an expensive disk read for 2-bytes
bytes16 = static_cast<uint16_t>(meta->pass());
// seek over size of the compressed buffer
is.seekg(sizeof(uint16_t), std::ios_base::cur);
}
else {
// otherwise read from disk
is.read(reinterpret_cast<char*>(&bytes16), sizeof(uint16_t));
}
if (bytes16 == std::numeric_limits<uint16_t>::max()) {
// read or seek uncompressed data
if (seek) {
is.seekg(destBytes, std::ios_base::cur);
}
else {
is.read(reinterpret_cast<char*>(destBuf), destBytes);
}
}
else {
// read or seek uncompressed data
if (seek) {
is.seekg(int(bytes16), std::ios_base::cur);
}
else {
// decompress into the destination buffer
std::unique_ptr<char[]> bloscBuffer(new char[int(bytes16)]);
is.read(bloscBuffer.get(), bytes16);
std::unique_ptr<char[]> buffer = bloscDecompress( bloscBuffer.get(),
destBytes,
/*resize=*/false);
std::memcpy(destBuf, buffer.get(), destBytes);
}
}
}
/// @brief openvdb::io::writeCompressedValues specialized on PointDataIndex32 arrays to
/// ignore the value mask, use a larger block size and use 16-bit size instead of 64-bit
template<>
inline void
writeCompressedValues( std::ostream& os, PointDataIndex32* srcBuf, Index srcCount,
const util::NodeMask<3>& /*valueMask*/,
const util::NodeMask<3>& /*childMask*/, bool /*toHalf*/)
{
using compression::bloscCompress;
const size_t srcBytes = srcCount*sizeof(PointDataIndex32);
const size_t maximumBytes = std::numeric_limits<uint16_t>::max();
if (srcBytes >= maximumBytes) {
OPENVDB_THROW(openvdb::IoError, "Cannot write more than " <<
maximumBytes << " bytes in voxel values.")
}
const char* charBuffer = reinterpret_cast<const char*>(srcBuf);
size_t compressedBytes;
std::unique_ptr<char[]> buffer = bloscCompress( charBuffer, srcBytes,
compressedBytes, /*resize=*/false);
if (compressedBytes > 0) {
auto bytes16 = static_cast<uint16_t>(compressedBytes); // clamp to 16-bit unsigned integer
os.write(reinterpret_cast<const char*>(&bytes16), sizeof(uint16_t));
os.write(reinterpret_cast<const char*>(buffer.get()), compressedBytes);
}
else {
auto bytes16 = static_cast<uint16_t>(maximumBytes); // max value indicates uncompressed
os.write(reinterpret_cast<const char*>(&bytes16), sizeof(uint16_t));
os.write(reinterpret_cast<const char*>(srcBuf), srcBytes);
}
}
template <typename T>
inline void
writeCompressedValuesSize(std::ostream& os, const T* srcBuf, Index srcCount)
{
using compression::bloscCompressedSize;
const size_t srcBytes = srcCount*sizeof(T);
const size_t maximumBytes = std::numeric_limits<uint16_t>::max();
if (srcBytes >= maximumBytes) {
OPENVDB_THROW(openvdb::IoError, "Cannot write more than " <<
maximumBytes << " bytes in voxel values.")
}
const char* charBuffer = reinterpret_cast<const char*>(srcBuf);
// calculate voxel buffer size after compression
size_t compressedBytes = bloscCompressedSize(charBuffer, srcBytes);
if (compressedBytes > 0) {
auto bytes16 = static_cast<uint16_t>(compressedBytes); // clamp to 16-bit unsigned integer
os.write(reinterpret_cast<const char*>(&bytes16), sizeof(uint16_t));
}
else {
auto bytes16 = static_cast<uint16_t>(maximumBytes); // max value indicates uncompressed
os.write(reinterpret_cast<const char*>(&bytes16), sizeof(uint16_t));
}
}
} // namespace io
// forward declaration
namespace tree {
template<Index, typename> struct SameLeafConfig;
}
////////////////////////////////////////
namespace points {
// forward declaration
template<typename T, Index Log2Dim> class PointDataLeafNode;
/// @brief Point index tree configured to match the default VDB configurations.
using PointDataTree = tree::Tree<tree::RootNode<tree::InternalNode<tree::InternalNode
<PointDataLeafNode<PointDataIndex32, 3>, 4>, 5>>>;
/// @brief Point data grid.
using PointDataGrid = Grid<PointDataTree>;
/// @brief Deep copy the descriptor across all leaf nodes.
///
/// @param tree the PointDataTree.
///
/// @return the new descriptor.
///
/// @note This method will fail if the Descriptors in the tree are not all identical.
template <typename PointDataTreeT>
inline AttributeSet::Descriptor::Ptr
makeDescriptorUnique(PointDataTreeT& tree);
/// @brief Toggle the streaming mode on all attributes in the tree to collapse the attributes
/// after deconstructing a bound AttributeHandle to each array. This results in better
/// memory efficiency when the data is streamed into another data structure
/// (typically for rendering).
///
/// @param tree the PointDataTree.
/// @param on @c true to enable streaming
///
/// @note Multiple threads cannot safely access the same AttributeArray when using streaming.
template <typename PointDataTreeT>
inline void
setStreamingMode(PointDataTreeT& tree, bool on = true);
/// @brief Sequentially pre-fetch all delayed-load voxel and attribute data from disk in order
/// to accelerate subsequent random access.
///
/// @param tree the PointDataTree.
/// @param position if enabled, prefetch the position attribute (default is on)
/// @param otherAttributes if enabled, prefetch all other attributes (default is on)
template <typename PointDataTreeT>
inline void
prefetch(PointDataTreeT& tree, bool position = true, bool otherAttributes = true);
////////////////////////////////////////
template <typename T, Index Log2Dim>
class PointDataLeafNode : public tree::LeafNode<T, Log2Dim>, io::MultiPass {
public:
using LeafNodeType = PointDataLeafNode<T, Log2Dim>;
using Ptr = std::shared_ptr<PointDataLeafNode>;
using ValueType = T;
using ValueTypePair = std::pair<ValueType, ValueType>;
using IndexArray = std::vector<ValueType>;
using Descriptor = AttributeSet::Descriptor;
////////////////////////////////////////
// The following methods had to be copied from the LeafNode class
// to make the derived PointDataLeafNode class compatible with the tree structure.
using BaseLeaf = tree::LeafNode<T, Log2Dim>;
using NodeMaskType = util::NodeMask<Log2Dim>;
using BaseLeaf::LOG2DIM;
using BaseLeaf::TOTAL;
using BaseLeaf::DIM;
using BaseLeaf::NUM_VALUES;
using BaseLeaf::NUM_VOXELS;
using BaseLeaf::SIZE;
using BaseLeaf::LEVEL;
/// Default constructor
PointDataLeafNode()
: mAttributeSet(new AttributeSet) { }
~PointDataLeafNode() = default;
/// Construct using deep copy of other PointDataLeafNode
explicit PointDataLeafNode(const PointDataLeafNode& other)
: BaseLeaf(other)
, mAttributeSet(new AttributeSet(*other.mAttributeSet)) { }
/// Construct using supplied origin, value and active status
explicit
PointDataLeafNode(const Coord& coords, const T& value = zeroVal<T>(), bool active = false)
: BaseLeaf(coords, zeroVal<T>(), active)
, mAttributeSet(new AttributeSet) { assertNonModifiableUnlessZero(value); }
/// Construct using supplied origin, value and active status
/// use attribute map from another PointDataLeafNode
PointDataLeafNode(const PointDataLeafNode& other, const Coord& coords,
const T& value = zeroVal<T>(), bool active = false)
: BaseLeaf(coords, zeroVal<T>(), active)
, mAttributeSet(new AttributeSet(*other.mAttributeSet))
{
assertNonModifiableUnlessZero(value);
}
// Copy-construct from a PointIndexLeafNode with the same configuration but a different ValueType.
template<typename OtherValueType>
PointDataLeafNode(const tools::PointIndexLeafNode<OtherValueType, Log2Dim>& other)
: BaseLeaf(other)
, mAttributeSet(new AttributeSet) { }
// Copy-construct from a LeafNode with the same configuration but a different ValueType.
// Used for topology copies - explicitly sets the value (background) to zeroVal
template <typename ValueType>
PointDataLeafNode(const tree::LeafNode<ValueType, Log2Dim>& other, const T& value, TopologyCopy)
: BaseLeaf(other, zeroVal<T>(), TopologyCopy())
, mAttributeSet(new AttributeSet) { assertNonModifiableUnlessZero(value); }
// Copy-construct from a LeafNode with the same configuration but a different ValueType.
// Used for topology copies - explicitly sets the on and off value (background) to zeroVal
template <typename ValueType>
PointDataLeafNode(const tree::LeafNode<ValueType, Log2Dim>& other, const T& /*offValue*/, const T& /*onValue*/, TopologyCopy)
: BaseLeaf(other, zeroVal<T>(), zeroVal<T>(), TopologyCopy())
, mAttributeSet(new AttributeSet) { }
PointDataLeafNode(PartialCreate, const Coord& coords,
const T& value = zeroVal<T>(), bool active = false)
: BaseLeaf(PartialCreate(), coords, value, active)
, mAttributeSet(new AttributeSet) { assertNonModifiableUnlessZero(value); }
public:
/// Retrieve the attribute set.
const AttributeSet& attributeSet() const { return *mAttributeSet; }
/// @brief Steal the attribute set, a new, empty attribute set is inserted in it's place.
AttributeSet::UniquePtr stealAttributeSet();
/// @brief Create a new attribute set. Existing attributes will be removed.
void initializeAttributes(const Descriptor::Ptr& descriptor, const Index arrayLength,
const AttributeArray::ScopedRegistryLock* lock = nullptr);
/// @brief Clear the attribute set.
void clearAttributes(const bool updateValueMask = true,
const AttributeArray::ScopedRegistryLock* lock = nullptr);
/// @brief Returns @c true if an attribute with this index exists.
/// @param pos Index of the attribute
bool hasAttribute(const size_t pos) const;
/// @brief Returns @c true if an attribute with this name exists.
/// @param attributeName Name of the attribute
bool hasAttribute(const Name& attributeName) const;
/// @brief Append an attribute to the leaf.
/// @param expected Existing descriptor is expected to match this parameter.
/// @param replacement New descriptor to replace the existing one.
/// @param pos Index of the new attribute in the descriptor replacement.
/// @param strideOrTotalSize Stride of the attribute array (if constantStride), total size otherwise
/// @param constantStride if @c false, stride is interpreted as total size of the array
/// @param metadata optional default value metadata
/// @param lock an optional scoped registry lock to avoid contention
AttributeArray::Ptr appendAttribute(const Descriptor& expected, Descriptor::Ptr& replacement,
const size_t pos, const Index strideOrTotalSize = 1,
const bool constantStride = true,
const Metadata* metadata = nullptr,
const AttributeArray::ScopedRegistryLock* lock = nullptr);
/// @brief Drop list of attributes.
/// @param pos vector of attribute indices to drop
/// @param expected Existing descriptor is expected to match this parameter.
/// @param replacement New descriptor to replace the existing one.
void dropAttributes(const std::vector<size_t>& pos,
const Descriptor& expected, Descriptor::Ptr& replacement);
/// @brief Reorder attribute set.
/// @param replacement New descriptor to replace the existing one.
void reorderAttributes(const Descriptor::Ptr& replacement);
/// @brief Rename attributes in attribute set (order must remain the same).
/// @param expected Existing descriptor is expected to match this parameter.
/// @param replacement New descriptor to replace the existing one.
void renameAttributes(const Descriptor& expected, Descriptor::Ptr& replacement);
/// @brief Compact all attributes in attribute set.
void compactAttributes();
/// @brief Replace the underlying attribute set with the given @a attributeSet.
/// @details This leaf will assume ownership of the given attribute set. The descriptors must
/// match and the voxel offsets values will need updating if the point order is different.
/// @throws ValueError if @a allowMismatchingDescriptors is @c false and the descriptors
/// do not match
void replaceAttributeSet(AttributeSet* attributeSet, bool allowMismatchingDescriptors = false);
/// @brief Replace the descriptor with a new one
/// The new Descriptor must exactly match the old one
void resetDescriptor(const Descriptor::Ptr& replacement);
/// @brief Sets all of the voxel offset values on this leaf, from the given vector
/// of @a offsets. If @a updateValueMask is true, then the active value mask will
/// be updated so voxels with points are active and empty voxels are inactive.
void setOffsets(const std::vector<ValueType>& offsets, const bool updateValueMask = true);
/// @brief Throws an error if the voxel values on this leaf are not monotonically
/// increasing or within the bounds of the attribute arrays
void validateOffsets() const;
/// @brief Read-write attribute array reference from index
/// @details Attribute arrays can be shared across leaf nodes, so non-const
/// access will deep-copy the array to make it unique. Always prefer
/// accessing const arrays where possible to eliminate this copying.
/// {
AttributeArray& attributeArray(const size_t pos);
const AttributeArray& attributeArray(const size_t pos) const;
const AttributeArray& constAttributeArray(const size_t pos) const;
/// }
/// @brief Read-write attribute array reference from name
/// @details Attribute arrays can be shared across leaf nodes, so non-const
/// access will deep-copy the array to make it unique. Always prefer
/// accessing const arrays where possible to eliminate this copying.
/// {
AttributeArray& attributeArray(const Name& attributeName);
const AttributeArray& attributeArray(const Name& attributeName) const;
const AttributeArray& constAttributeArray(const Name& attributeName) const;
/// }
/// @brief Read-only group handle from group index
GroupHandle groupHandle(const AttributeSet::Descriptor::GroupIndex& index) const;
/// @brief Read-only group handle from group name
GroupHandle groupHandle(const Name& group) const;
/// @brief Read-write group handle from group index
GroupWriteHandle groupWriteHandle(const AttributeSet::Descriptor::GroupIndex& index);
/// @brief Read-write group handle from group name
GroupWriteHandle groupWriteHandle(const Name& name);
/// @brief Compute the total point count for the leaf
Index64 pointCount() const;
/// @brief Compute the total active (on) point count for the leaf
Index64 onPointCount() const;
/// @brief Compute the total inactive (off) point count for the leaf
Index64 offPointCount() const;
/// @brief Compute the point count in a specific group for the leaf
Index64 groupPointCount(const Name& groupName) const;
/// @brief Activate voxels with non-zero points, deactivate voxels with zero points.
void updateValueMask();
////////////////////////////////////////
void setOffsetOn(Index offset, const ValueType& val);
void setOffsetOnly(Index offset, const ValueType& val);
/// @brief Return @c true if the given node (which may have a different @c ValueType
/// than this node) has the same active value topology as this node.
template<typename OtherType, Index OtherLog2Dim>
bool hasSameTopology(const PointDataLeafNode<OtherType, OtherLog2Dim>* other) const {
return BaseLeaf::hasSameTopology(other);
}
/// Check for buffer, state and origin equivalence first.
/// If this returns true, do a deeper comparison on the attribute set to check
bool operator==(const PointDataLeafNode& other) const {
if(BaseLeaf::operator==(other) != true) return false;
return (*this->mAttributeSet == *other.mAttributeSet);
}
bool operator!=(const PointDataLeafNode& other) const { return !(other == *this); }
void addLeaf(PointDataLeafNode*) {}
template<typename AccessorT>
void addLeafAndCache(PointDataLeafNode*, AccessorT&) {}
//@{
/// @brief Return a pointer to this node.
PointDataLeafNode* touchLeaf(const Coord&) { return this; }
template<typename AccessorT>
PointDataLeafNode* touchLeafAndCache(const Coord&, AccessorT&) { return this; }
template<typename NodeT, typename AccessorT>
NodeT* probeNodeAndCache(const Coord&, AccessorT&)
{
OPENVDB_NO_UNREACHABLE_CODE_WARNING_BEGIN
if (!(std::is_same<NodeT,PointDataLeafNode>::value)) return nullptr;
return reinterpret_cast<NodeT*>(this);
OPENVDB_NO_UNREACHABLE_CODE_WARNING_END
}
PointDataLeafNode* probeLeaf(const Coord&) { return this; }
template<typename AccessorT>
PointDataLeafNode* probeLeafAndCache(const Coord&, AccessorT&) { return this; }
//@}
//@{
/// @brief Return a @const pointer to this node.
const PointDataLeafNode* probeConstLeaf(const Coord&) const { return this; }
template<typename AccessorT>
const PointDataLeafNode* probeConstLeafAndCache(const Coord&, AccessorT&) const { return this; }
template<typename AccessorT>
const PointDataLeafNode* probeLeafAndCache(const Coord&, AccessorT&) const { return this; }
const PointDataLeafNode* probeLeaf(const Coord&) const { return this; }
template<typename NodeT, typename AccessorT>
const NodeT* probeConstNodeAndCache(const Coord&, AccessorT&) const
{
OPENVDB_NO_UNREACHABLE_CODE_WARNING_BEGIN
if (!(std::is_same<NodeT,PointDataLeafNode>::value)) return nullptr;
return reinterpret_cast<const NodeT*>(this);
OPENVDB_NO_UNREACHABLE_CODE_WARNING_END
}
//@}
// I/O methods
void readTopology(std::istream& is, bool fromHalf = false);
void writeTopology(std::ostream& os, bool toHalf = false) const;
Index buffers() const;
void readBuffers(std::istream& is, bool fromHalf = false);
void readBuffers(std::istream& is, const CoordBBox&, bool fromHalf = false);
void writeBuffers(std::ostream& os, bool toHalf = false) const;
Index64 memUsage() const;
void evalActiveBoundingBox(CoordBBox& bbox, bool visitVoxels = true) const;
/// @brief Return the bounding box of this node, i.e., the full index space
/// spanned by this leaf node.
CoordBBox getNodeBoundingBox() const;
////////////////////////////////////////
// Disable all write methods to avoid unintentional changes
// to the point-array offsets.
void assertNonmodifiable() {
assert(false && "Cannot modify voxel values in a PointDataTree.");
}
// some methods silently ignore attempts to modify the
// point-array offsets if a zero value is used
void assertNonModifiableUnlessZero(const ValueType& value) {
if (value != zeroVal<T>()) this->assertNonmodifiable();
}
void setActiveState(const Coord& xyz, bool on) { BaseLeaf::setActiveState(xyz, on); }
void setActiveState(Index offset, bool on) { BaseLeaf::setActiveState(offset, on); }
void setValueOnly(const Coord&, const ValueType&) { assertNonmodifiable(); }
void setValueOnly(Index, const ValueType&) { assertNonmodifiable(); }
void setValueOff(const Coord& xyz) { BaseLeaf::setValueOff(xyz); }
void setValueOff(Index offset) { BaseLeaf::setValueOff(offset); }
void setValueOff(const Coord&, const ValueType&) { assertNonmodifiable(); }
void setValueOff(Index, const ValueType&) { assertNonmodifiable(); }
void setValueOn(const Coord& xyz) { BaseLeaf::setValueOn(xyz); }
void setValueOn(Index offset) { BaseLeaf::setValueOn(offset); }
void setValueOn(const Coord&, const ValueType&) { assertNonmodifiable(); }
void setValueOn(Index, const ValueType&) { assertNonmodifiable(); }
void setValue(const Coord&, const ValueType&) { assertNonmodifiable(); }
void setValuesOn() { BaseLeaf::setValuesOn(); }
void setValuesOff() { BaseLeaf::setValuesOff(); }
template<typename ModifyOp>
void modifyValue(Index, const ModifyOp&) { assertNonmodifiable(); }
template<typename ModifyOp>
void modifyValue(const Coord&, const ModifyOp&) { assertNonmodifiable(); }
template<typename ModifyOp>
void modifyValueAndActiveState(const Coord&, const ModifyOp&) { assertNonmodifiable(); }
// clipping is not yet supported
void clip(const CoordBBox&, const ValueType& value) { assertNonModifiableUnlessZero(value); }
void fill(const CoordBBox&, const ValueType&, bool);
void fill(const ValueType& value) { assertNonModifiableUnlessZero(value); }
void fill(const ValueType&, bool);
template<typename AccessorT>
void setValueOnlyAndCache(const Coord&, const ValueType&, AccessorT&) {assertNonmodifiable();}
template<typename ModifyOp, typename AccessorT>
void modifyValueAndActiveStateAndCache(const Coord&, const ModifyOp&, AccessorT&) {
assertNonmodifiable();
}
template<typename AccessorT>
void setValueOffAndCache(const Coord&, const ValueType&, AccessorT&) { assertNonmodifiable(); }
template<typename AccessorT>
void setActiveStateAndCache(const Coord& xyz, bool on, AccessorT& parent) {
BaseLeaf::setActiveStateAndCache(xyz, on, parent);
}
void resetBackground(const ValueType&, const ValueType& newBackground) {
assertNonModifiableUnlessZero(newBackground);
}
void signedFloodFill(const ValueType&) { assertNonmodifiable(); }
void signedFloodFill(const ValueType&, const ValueType&) { assertNonmodifiable(); }
void negate() { assertNonmodifiable(); }
friend class ::TestPointDataLeaf;
using ValueOn = typename BaseLeaf::ValueOn;
using ValueOff = typename BaseLeaf::ValueOff;
using ValueAll = typename BaseLeaf::ValueAll;
private:
AttributeSet::UniquePtr mAttributeSet;
uint16_t mVoxelBufferSize = 0;
protected:
using ChildOn = typename BaseLeaf::ChildOn;
using ChildOff = typename BaseLeaf::ChildOff;
using ChildAll = typename BaseLeaf::ChildAll;
using MaskOnIterator = typename NodeMaskType::OnIterator;
using MaskOffIterator = typename NodeMaskType::OffIterator;
using MaskDenseIterator = typename NodeMaskType::DenseIterator;
// During topology-only construction, access is needed
// to protected/private members of other template instances.
template<typename, Index> friend class PointDataLeafNode;
friend class tree::IteratorBase<MaskOnIterator, PointDataLeafNode>;
friend class tree::IteratorBase<MaskOffIterator, PointDataLeafNode>;
friend class tree::IteratorBase<MaskDenseIterator, PointDataLeafNode>;
public:
/// @brief Leaf value voxel iterator
ValueVoxelCIter beginValueVoxel(const Coord& ijk) const;
public:
using ValueOnIter = typename BaseLeaf::template ValueIter<
MaskOnIterator, PointDataLeafNode, const ValueType, ValueOn>;
using ValueOnCIter = typename BaseLeaf::template ValueIter<
MaskOnIterator, const PointDataLeafNode, const ValueType, ValueOn>;
using ValueOffIter = typename BaseLeaf::template ValueIter<
MaskOffIterator, PointDataLeafNode, const ValueType, ValueOff>;
using ValueOffCIter = typename BaseLeaf::template ValueIter<
MaskOffIterator,const PointDataLeafNode,const ValueType,ValueOff>;
using ValueAllIter = typename BaseLeaf::template ValueIter<
MaskDenseIterator, PointDataLeafNode, const ValueType, ValueAll>;
using ValueAllCIter = typename BaseLeaf::template ValueIter<
MaskDenseIterator,const PointDataLeafNode,const ValueType,ValueAll>;
using ChildOnIter = typename BaseLeaf::template ChildIter<
MaskOnIterator, PointDataLeafNode, ChildOn>;
using ChildOnCIter = typename BaseLeaf::template ChildIter<
MaskOnIterator, const PointDataLeafNode, ChildOn>;
using ChildOffIter = typename BaseLeaf::template ChildIter<
MaskOffIterator, PointDataLeafNode, ChildOff>;
using ChildOffCIter = typename BaseLeaf::template ChildIter<
MaskOffIterator, const PointDataLeafNode, ChildOff>;
using ChildAllIter = typename BaseLeaf::template DenseIter<
PointDataLeafNode, ValueType, ChildAll>;
using ChildAllCIter = typename BaseLeaf::template DenseIter<
const PointDataLeafNode, const ValueType, ChildAll>;
using IndexVoxelIter = IndexIter<ValueVoxelCIter, NullFilter>;
using IndexAllIter = IndexIter<ValueAllCIter, NullFilter>;
using IndexOnIter = IndexIter<ValueOnCIter, NullFilter>;
using IndexOffIter = IndexIter<ValueOffCIter, NullFilter>;
/// @brief Leaf index iterator
IndexAllIter beginIndexAll() const
{
NullFilter filter;
return this->beginIndex<ValueAllCIter, NullFilter>(filter);
}
IndexOnIter beginIndexOn() const
{
NullFilter filter;
return this->beginIndex<ValueOnCIter, NullFilter>(filter);
}
IndexOffIter beginIndexOff() const
{
NullFilter filter;
return this->beginIndex<ValueOffCIter, NullFilter>(filter);
}
template<typename IterT, typename FilterT>
IndexIter<IterT, FilterT> beginIndex(const FilterT& filter) const;
/// @brief Filtered leaf index iterator
template<typename FilterT>
IndexIter<ValueAllCIter, FilterT> beginIndexAll(const FilterT& filter) const
{
return this->beginIndex<ValueAllCIter, FilterT>(filter);
}
template<typename FilterT>
IndexIter<ValueOnCIter, FilterT> beginIndexOn(const FilterT& filter) const
{
return this->beginIndex<ValueOnCIter, FilterT>(filter);
}
template<typename FilterT>
IndexIter<ValueOffCIter, FilterT> beginIndexOff(const FilterT& filter) const
{
return this->beginIndex<ValueOffCIter, FilterT>(filter);
}
/// @brief Leaf index iterator from voxel
IndexVoxelIter beginIndexVoxel(const Coord& ijk) const;
/// @brief Filtered leaf index iterator from voxel
template<typename FilterT>
IndexIter<ValueVoxelCIter, FilterT> beginIndexVoxel(const Coord& ijk, const FilterT& filter) const;
#define VMASK_ this->getValueMask()
ValueOnCIter cbeginValueOn() const { return ValueOnCIter(VMASK_.beginOn(), this); }
ValueOnCIter beginValueOn() const { return ValueOnCIter(VMASK_.beginOn(), this); }
ValueOnIter beginValueOn() { return ValueOnIter(VMASK_.beginOn(), this); }
ValueOffCIter cbeginValueOff() const { return ValueOffCIter(VMASK_.beginOff(), this); }
ValueOffCIter beginValueOff() const { return ValueOffCIter(VMASK_.beginOff(), this); }
ValueOffIter beginValueOff() { return ValueOffIter(VMASK_.beginOff(), this); }
ValueAllCIter cbeginValueAll() const { return ValueAllCIter(VMASK_.beginDense(), this); }
ValueAllCIter beginValueAll() const { return ValueAllCIter(VMASK_.beginDense(), this); }
ValueAllIter beginValueAll() { return ValueAllIter(VMASK_.beginDense(), this); }
ValueOnCIter cendValueOn() const { return ValueOnCIter(VMASK_.endOn(), this); }
ValueOnCIter endValueOn() const { return ValueOnCIter(VMASK_.endOn(), this); }
ValueOnIter endValueOn() { return ValueOnIter(VMASK_.endOn(), this); }
ValueOffCIter cendValueOff() const { return ValueOffCIter(VMASK_.endOff(), this); }
ValueOffCIter endValueOff() const { return ValueOffCIter(VMASK_.endOff(), this); }
ValueOffIter endValueOff() { return ValueOffIter(VMASK_.endOff(), this); }
ValueAllCIter cendValueAll() const { return ValueAllCIter(VMASK_.endDense(), this); }
ValueAllCIter endValueAll() const { return ValueAllCIter(VMASK_.endDense(), this); }
ValueAllIter endValueAll() { return ValueAllIter(VMASK_.endDense(), this); }
ChildOnCIter cbeginChildOn() const { return ChildOnCIter(VMASK_.endOn(), this); }
ChildOnCIter beginChildOn() const { return ChildOnCIter(VMASK_.endOn(), this); }
ChildOnIter beginChildOn() { return ChildOnIter(VMASK_.endOn(), this); }
ChildOffCIter cbeginChildOff() const { return ChildOffCIter(VMASK_.endOff(), this); }
ChildOffCIter beginChildOff() const { return ChildOffCIter(VMASK_.endOff(), this); }
ChildOffIter beginChildOff() { return ChildOffIter(VMASK_.endOff(), this); }
ChildAllCIter cbeginChildAll() const { return ChildAllCIter(VMASK_.beginDense(), this); }
ChildAllCIter beginChildAll() const { return ChildAllCIter(VMASK_.beginDense(), this); }
ChildAllIter beginChildAll() { return ChildAllIter(VMASK_.beginDense(), this); }
ChildOnCIter cendChildOn() const { return ChildOnCIter(VMASK_.endOn(), this); }
ChildOnCIter endChildOn() const { return ChildOnCIter(VMASK_.endOn(), this); }
ChildOnIter endChildOn() { return ChildOnIter(VMASK_.endOn(), this); }
ChildOffCIter cendChildOff() const { return ChildOffCIter(VMASK_.endOff(), this); }
ChildOffCIter endChildOff() const { return ChildOffCIter(VMASK_.endOff(), this); }
ChildOffIter endChildOff() { return ChildOffIter(VMASK_.endOff(), this); }
ChildAllCIter cendChildAll() const { return ChildAllCIter(VMASK_.endDense(), this); }
ChildAllCIter endChildAll() const { return ChildAllCIter(VMASK_.endDense(), this); }
ChildAllIter endChildAll() { return ChildAllIter(VMASK_.endDense(), this); }
#undef VMASK_
}; // struct PointDataLeafNode
////////////////////////////////////////
// PointDataLeafNode implementation
template<typename T, Index Log2Dim>
inline AttributeSet::UniquePtr
PointDataLeafNode<T, Log2Dim>::stealAttributeSet()
{
AttributeSet::UniquePtr ptr = std::make_unique<AttributeSet>();
std::swap(ptr, mAttributeSet);
return ptr;
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::initializeAttributes(const Descriptor::Ptr& descriptor, const Index arrayLength,
const AttributeArray::ScopedRegistryLock* lock)
{
if (descriptor->size() != 1 ||
descriptor->find("P") == AttributeSet::INVALID_POS ||
descriptor->valueType(0) != typeNameAsString<Vec3f>())
{
OPENVDB_THROW(IndexError, "Initializing attributes only allowed with one Vec3f position attribute.");
}
mAttributeSet.reset(new AttributeSet(descriptor, arrayLength, lock));
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::clearAttributes(const bool updateValueMask,
const AttributeArray::ScopedRegistryLock* lock)
{
mAttributeSet.reset(new AttributeSet(*mAttributeSet, 0, lock));
// zero voxel values
this->buffer().fill(ValueType(0));
// if updateValueMask, also de-activate all voxels
if (updateValueMask) this->setValuesOff();
}
template<typename T, Index Log2Dim>
inline bool
PointDataLeafNode<T, Log2Dim>::hasAttribute(const size_t pos) const
{
return pos < mAttributeSet->size();
}
template<typename T, Index Log2Dim>
inline bool
PointDataLeafNode<T, Log2Dim>::hasAttribute(const Name& attributeName) const
{
const size_t pos = mAttributeSet->find(attributeName);
return pos != AttributeSet::INVALID_POS;
}
template<typename T, Index Log2Dim>
inline AttributeArray::Ptr
PointDataLeafNode<T, Log2Dim>::appendAttribute( const Descriptor& expected, Descriptor::Ptr& replacement,
const size_t pos, const Index strideOrTotalSize,
const bool constantStride,
const Metadata* metadata,
const AttributeArray::ScopedRegistryLock* lock)
{
return mAttributeSet->appendAttribute(
expected, replacement, pos, strideOrTotalSize, constantStride, metadata, lock);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::dropAttributes(const std::vector<size_t>& pos,
const Descriptor& expected, Descriptor::Ptr& replacement)
{
mAttributeSet->dropAttributes(pos, expected, replacement);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::reorderAttributes(const Descriptor::Ptr& replacement)
{
mAttributeSet->reorderAttributes(replacement);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::renameAttributes(const Descriptor& expected, Descriptor::Ptr& replacement)
{
mAttributeSet->renameAttributes(expected, replacement);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::compactAttributes()
{
for (size_t i = 0; i < mAttributeSet->size(); i++) {
AttributeArray* array = mAttributeSet->get(i);
array->compact();
}
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::replaceAttributeSet(AttributeSet* attributeSet, bool allowMismatchingDescriptors)
{
if (!attributeSet) {
OPENVDB_THROW(ValueError, "Cannot replace with a null attribute set");
}
if (!allowMismatchingDescriptors && mAttributeSet->descriptor() != attributeSet->descriptor()) {
OPENVDB_THROW(ValueError, "Attribute set descriptors are not equal.");
}
mAttributeSet.reset(attributeSet);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::resetDescriptor(const Descriptor::Ptr& replacement)
{
mAttributeSet->resetDescriptor(replacement);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::setOffsets(const std::vector<ValueType>& offsets, const bool updateValueMask)
{
if (offsets.size() != LeafNodeType::NUM_VALUES) {
OPENVDB_THROW(ValueError, "Offset vector size doesn't match number of voxels.")
}
for (Index index = 0; index < offsets.size(); ++index) {
setOffsetOnly(index, offsets[index]);
}
if (updateValueMask) this->updateValueMask();
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::validateOffsets() const
{
// Ensure all of the offset values are monotonically increasing
for (Index index = 1; index < BaseLeaf::SIZE; ++index) {
if (this->getValue(index-1) > this->getValue(index)) {
OPENVDB_THROW(ValueError, "Voxel offset values are not monotonically increasing");
}
}
// Ensure all attribute arrays are of equal length
for (size_t attributeIndex = 1; attributeIndex < mAttributeSet->size(); ++attributeIndex ) {
if (mAttributeSet->getConst(attributeIndex-1)->size() != mAttributeSet->getConst(attributeIndex)->size()) {
OPENVDB_THROW(ValueError, "Attribute arrays have inconsistent length");
}
}
// Ensure the last voxel's offset value matches the size of each attribute array
if (mAttributeSet->size() > 0 && this->getValue(BaseLeaf::SIZE-1) != mAttributeSet->getConst(0)->size()) {
OPENVDB_THROW(ValueError, "Last voxel offset value does not match attribute array length");
}
}
template<typename T, Index Log2Dim>
inline AttributeArray&
PointDataLeafNode<T, Log2Dim>::attributeArray(const size_t pos)
{
if (pos >= mAttributeSet->size()) OPENVDB_THROW(LookupError, "Attribute Out Of Range - " << pos);
return *mAttributeSet->get(pos);
}
template<typename T, Index Log2Dim>
inline const AttributeArray&
PointDataLeafNode<T, Log2Dim>::attributeArray(const size_t pos) const
{
if (pos >= mAttributeSet->size()) OPENVDB_THROW(LookupError, "Attribute Out Of Range - " << pos);
return *mAttributeSet->getConst(pos);
}
template<typename T, Index Log2Dim>
inline const AttributeArray&
PointDataLeafNode<T, Log2Dim>::constAttributeArray(const size_t pos) const
{
return this->attributeArray(pos);
}
template<typename T, Index Log2Dim>
inline AttributeArray&
PointDataLeafNode<T, Log2Dim>::attributeArray(const Name& attributeName)
{
const size_t pos = mAttributeSet->find(attributeName);
if (pos == AttributeSet::INVALID_POS) OPENVDB_THROW(LookupError, "Attribute Not Found - " << attributeName);
return *mAttributeSet->get(pos);
}
template<typename T, Index Log2Dim>
inline const AttributeArray&
PointDataLeafNode<T, Log2Dim>::attributeArray(const Name& attributeName) const
{
const size_t pos = mAttributeSet->find(attributeName);
if (pos == AttributeSet::INVALID_POS) OPENVDB_THROW(LookupError, "Attribute Not Found - " << attributeName);
return *mAttributeSet->getConst(pos);
}
template<typename T, Index Log2Dim>
inline const AttributeArray&
PointDataLeafNode<T, Log2Dim>::constAttributeArray(const Name& attributeName) const
{
return this->attributeArray(attributeName);
}
template<typename T, Index Log2Dim>
inline GroupHandle
PointDataLeafNode<T, Log2Dim>::groupHandle(const AttributeSet::Descriptor::GroupIndex& index) const
{
const AttributeArray& array = this->attributeArray(index.first);
assert(isGroup(array));
const GroupAttributeArray& groupArray = GroupAttributeArray::cast(array);
return GroupHandle(groupArray, index.second);
}
template<typename T, Index Log2Dim>
inline GroupHandle
PointDataLeafNode<T, Log2Dim>::groupHandle(const Name& name) const
{
const AttributeSet::Descriptor::GroupIndex index = this->attributeSet().groupIndex(name);
return this->groupHandle(index);
}
template<typename T, Index Log2Dim>
inline GroupWriteHandle
PointDataLeafNode<T, Log2Dim>::groupWriteHandle(const AttributeSet::Descriptor::GroupIndex& index)
{
AttributeArray& array = this->attributeArray(index.first);
assert(isGroup(array));
GroupAttributeArray& groupArray = GroupAttributeArray::cast(array);
return GroupWriteHandle(groupArray, index.second);
}
template<typename T, Index Log2Dim>
inline GroupWriteHandle
PointDataLeafNode<T, Log2Dim>::groupWriteHandle(const Name& name)
{
const AttributeSet::Descriptor::GroupIndex index = this->attributeSet().groupIndex(name);
return this->groupWriteHandle(index);
}
template<typename T, Index Log2Dim>
template<typename ValueIterT, typename FilterT>
inline IndexIter<ValueIterT, FilterT>
PointDataLeafNode<T, Log2Dim>::beginIndex(const FilterT& filter) const
{
// generate no-op iterator if filter evaluates no indices
if (filter.state() == index::NONE) {
return IndexIter<ValueIterT, FilterT>(ValueIterT(), filter);
}
// copy filter to ensure thread-safety
FilterT newFilter(filter);
newFilter.reset(*this);
using IterTraitsT = tree::IterTraits<LeafNodeType, ValueIterT>;
// construct the value iterator and reset the filter to use this leaf
ValueIterT valueIter = IterTraitsT::begin(*this);
return IndexIter<ValueIterT, FilterT>(valueIter, newFilter);
}
template<typename T, Index Log2Dim>
inline ValueVoxelCIter
PointDataLeafNode<T, Log2Dim>::beginValueVoxel(const Coord& ijk) const
{
const Index index = LeafNodeType::coordToOffset(ijk);
assert(index < BaseLeaf::SIZE);
const ValueType end = this->getValue(index);
const ValueType start = (index == 0) ? ValueType(0) : this->getValue(index - 1);
return ValueVoxelCIter(start, end);
}
template<typename T, Index Log2Dim>
inline typename PointDataLeafNode<T, Log2Dim>::IndexVoxelIter
PointDataLeafNode<T, Log2Dim>::beginIndexVoxel(const Coord& ijk) const
{
ValueVoxelCIter iter = this->beginValueVoxel(ijk);
return IndexVoxelIter(iter, NullFilter());
}
template<typename T, Index Log2Dim>
template<typename FilterT>
inline IndexIter<ValueVoxelCIter, FilterT>
PointDataLeafNode<T, Log2Dim>::beginIndexVoxel(const Coord& ijk, const FilterT& filter) const
{
ValueVoxelCIter iter = this->beginValueVoxel(ijk);
FilterT newFilter(filter);
newFilter.reset(*this);
return IndexIter<ValueVoxelCIter, FilterT>(iter, newFilter);
}
template<typename T, Index Log2Dim>
inline Index64
PointDataLeafNode<T, Log2Dim>::pointCount() const
{
return this->getLastValue();
}
template<typename T, Index Log2Dim>
inline Index64
PointDataLeafNode<T, Log2Dim>::onPointCount() const
{
if (this->isEmpty()) return 0;
else if (this->isDense()) return this->pointCount();
return iterCount(this->beginIndexOn());
}
template<typename T, Index Log2Dim>
inline Index64
PointDataLeafNode<T, Log2Dim>::offPointCount() const
{
if (this->isEmpty()) return this->pointCount();
else if (this->isDense()) return 0;
return iterCount(this->beginIndexOff());
}
template<typename T, Index Log2Dim>
inline Index64
PointDataLeafNode<T, Log2Dim>::groupPointCount(const Name& groupName) const
{
if (!this->attributeSet().descriptor().hasGroup(groupName)) {
return Index64(0);
}
GroupFilter filter(groupName, this->attributeSet());
if (filter.state() == index::ALL) {
return this->pointCount();
} else {
return iterCount(this->beginIndexAll(filter));
}
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::updateValueMask()
{
ValueType start = 0, end = 0;
for (Index n = 0; n < LeafNodeType::NUM_VALUES; n++) {
end = this->getValue(n);
this->setValueMask(n, (end - start) > 0);
start = end;
}
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::setOffsetOn(Index offset, const ValueType& val)
{
this->buffer().setValue(offset, val);
this->setValueMaskOn(offset);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::setOffsetOnly(Index offset, const ValueType& val)
{
this->buffer().setValue(offset, val);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::readTopology(std::istream& is, bool fromHalf)
{
BaseLeaf::readTopology(is, fromHalf);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::writeTopology(std::ostream& os, bool toHalf) const
{
BaseLeaf::writeTopology(os, toHalf);
}
template<typename T, Index Log2Dim>
inline Index
PointDataLeafNode<T, Log2Dim>::buffers() const
{
return Index( /*voxel buffer sizes*/ 1 +
/*voxel buffers*/ 1 +
/*attribute metadata*/ 1 +
/*attribute uniform values*/ mAttributeSet->size() +
/*attribute buffers*/ mAttributeSet->size() +
/*cleanup*/ 1);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::readBuffers(std::istream& is, bool fromHalf)
{
this->readBuffers(is, CoordBBox::inf(), fromHalf);
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::readBuffers(std::istream& is, const CoordBBox& /*bbox*/, bool fromHalf)
{
struct Local
{
static void destroyPagedStream(const io::StreamMetadata::AuxDataMap& auxData, const Index index)
{
// if paged stream exists, delete it
std::string key("paged:" + std::to_string(index));
auto it = auxData.find(key);
if (it != auxData.end()) {
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData)).erase(it);
}
}
static compression::PagedInputStream& getOrInsertPagedStream( const io::StreamMetadata::AuxDataMap& auxData,
const Index index)
{
std::string key("paged:" + std::to_string(index));
auto it = auxData.find(key);
if (it != auxData.end()) {
return *(boost::any_cast<compression::PagedInputStream::Ptr>(it->second));
}
else {
compression::PagedInputStream::Ptr pagedStream = std::make_shared<compression::PagedInputStream>();
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData))[key] = pagedStream;
return *pagedStream;
}
}
static bool hasMatchingDescriptor(const io::StreamMetadata::AuxDataMap& auxData)
{
std::string matchingKey("hasMatchingDescriptor");
auto itMatching = auxData.find(matchingKey);
return itMatching != auxData.end();
}
static void clearMatchingDescriptor(const io::StreamMetadata::AuxDataMap& auxData)
{
std::string matchingKey("hasMatchingDescriptor");
std::string descriptorKey("descriptorPtr");
auto itMatching = auxData.find(matchingKey);
auto itDescriptor = auxData.find(descriptorKey);
if (itMatching != auxData.end()) (const_cast<io::StreamMetadata::AuxDataMap&>(auxData)).erase(itMatching);
if (itDescriptor != auxData.end()) (const_cast<io::StreamMetadata::AuxDataMap&>(auxData)).erase(itDescriptor);
}
static void insertDescriptor( const io::StreamMetadata::AuxDataMap& auxData,
const Descriptor::Ptr descriptor)
{
std::string descriptorKey("descriptorPtr");
std::string matchingKey("hasMatchingDescriptor");
auto itMatching = auxData.find(matchingKey);
if (itMatching == auxData.end()) {
// if matching bool is not found, insert "true" and the descriptor
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData))[matchingKey] = true;
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData))[descriptorKey] = descriptor;
}
}
static AttributeSet::Descriptor::Ptr retrieveMatchingDescriptor(const io::StreamMetadata::AuxDataMap& auxData)
{
std::string descriptorKey("descriptorPtr");
auto itDescriptor = auxData.find(descriptorKey);
assert(itDescriptor != auxData.end());
const Descriptor::Ptr descriptor = boost::any_cast<AttributeSet::Descriptor::Ptr>(itDescriptor->second);
return descriptor;
}
};
const io::StreamMetadata::Ptr meta = io::getStreamMetadataPtr(is);
if (!meta) {
OPENVDB_THROW(IoError, "Cannot read in a PointDataLeaf without StreamMetadata.");
}
const Index pass(static_cast<uint16_t>(meta->pass()));
const Index maximumPass(static_cast<uint16_t>(meta->pass() >> 16));
const Index attributes = (maximumPass - 4) / 2;
if (pass == 0) {
// pass 0 - voxel data sizes
is.read(reinterpret_cast<char*>(&mVoxelBufferSize), sizeof(uint16_t));
Local::clearMatchingDescriptor(meta->auxData());
}
else if (pass == 1) {
// pass 1 - descriptor and attribute metadata
if (Local::hasMatchingDescriptor(meta->auxData())) {
AttributeSet::Descriptor::Ptr descriptor = Local::retrieveMatchingDescriptor(meta->auxData());
mAttributeSet->resetDescriptor(descriptor, /*allowMismatchingDescriptors=*/true);
}
else {
uint8_t header;
is.read(reinterpret_cast<char*>(&header), sizeof(uint8_t));
mAttributeSet->readDescriptor(is);
if (header & uint8_t(1)) {
AttributeSet::DescriptorPtr descriptor = mAttributeSet->descriptorPtr();
Local::insertDescriptor(meta->auxData(), descriptor);
}
// a forwards-compatibility mechanism for future use,
// if a 0x2 bit is set, read and skip over a specific number of bytes
if (header & uint8_t(2)) {
uint64_t bytesToSkip;
is.read(reinterpret_cast<char*>(&bytesToSkip), sizeof(uint64_t));
if (bytesToSkip > uint64_t(0)) {
auto metadata = io::getStreamMetadataPtr(is);
if (metadata && metadata->seekable()) {
is.seekg(bytesToSkip, std::ios_base::cur);
}
else {
std::vector<uint8_t> tempData(bytesToSkip);
is.read(reinterpret_cast<char*>(&tempData[0]), bytesToSkip);
}
}
}
// this reader is only able to read headers with 0x1 and 0x2 bits set
if (header > uint8_t(3)) {
OPENVDB_THROW(IoError, "Unrecognised header flags in PointDataLeafNode");
}
}
mAttributeSet->readMetadata(is);
}
else if (pass < (attributes + 2)) {
// pass 2...n+2 - attribute uniform values
const size_t attributeIndex = pass - 2;
AttributeArray* array = attributeIndex < mAttributeSet->size() ?
mAttributeSet->get(attributeIndex) : nullptr;
if (array) {
compression::PagedInputStream& pagedStream =
Local::getOrInsertPagedStream(meta->auxData(), static_cast<Index>(attributeIndex));
pagedStream.setInputStream(is);
pagedStream.setSizeOnly(true);
array->readPagedBuffers(pagedStream);
}
}
else if (pass == attributes + 2) {
// pass n+2 - voxel data
const Index passValue(meta->pass());
// StreamMetadata pass variable used to temporarily store voxel buffer size
io::StreamMetadata& nonConstMeta = const_cast<io::StreamMetadata&>(*meta);
nonConstMeta.setPass(mVoxelBufferSize);
// readBuffers() calls readCompressedValues specialization above
BaseLeaf::readBuffers(is, fromHalf);
// pass now reset to original value
nonConstMeta.setPass(passValue);
}
else if (pass < (attributes*2 + 3)) {
// pass n+2..2n+2 - attribute buffers
const Index attributeIndex = pass - attributes - 3;
AttributeArray* array = attributeIndex < mAttributeSet->size() ?
mAttributeSet->get(attributeIndex) : nullptr;
if (array) {
compression::PagedInputStream& pagedStream =
Local::getOrInsertPagedStream(meta->auxData(), attributeIndex);
pagedStream.setInputStream(is);
pagedStream.setSizeOnly(false);
array->readPagedBuffers(pagedStream);
}
// cleanup paged stream reference in auxiliary metadata
if (pass > attributes + 3) {
Local::destroyPagedStream(meta->auxData(), attributeIndex-1);
}
}
else if (pass < buffers()) {
// pass 2n+3 - cleanup last paged stream
const Index attributeIndex = pass - attributes - 4;
Local::destroyPagedStream(meta->auxData(), attributeIndex);
}
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::writeBuffers(std::ostream& os, bool toHalf) const
{
struct Local
{
static void destroyPagedStream(const io::StreamMetadata::AuxDataMap& auxData, const Index index)
{
// if paged stream exists, flush and delete it
std::string key("paged:" + std::to_string(index));
auto it = auxData.find(key);
if (it != auxData.end()) {
compression::PagedOutputStream& stream = *(boost::any_cast<compression::PagedOutputStream::Ptr>(it->second));
stream.flush();
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData)).erase(it);
}
}
static compression::PagedOutputStream& getOrInsertPagedStream( const io::StreamMetadata::AuxDataMap& auxData,
const Index index)
{
std::string key("paged:" + std::to_string(index));
auto it = auxData.find(key);
if (it != auxData.end()) {
return *(boost::any_cast<compression::PagedOutputStream::Ptr>(it->second));
}
else {
compression::PagedOutputStream::Ptr pagedStream = std::make_shared<compression::PagedOutputStream>();
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData))[key] = pagedStream;
return *pagedStream;
}
}
static void insertDescriptor( const io::StreamMetadata::AuxDataMap& auxData,
const Descriptor::Ptr descriptor)
{
std::string descriptorKey("descriptorPtr");
std::string matchingKey("hasMatchingDescriptor");
auto itMatching = auxData.find(matchingKey);
auto itDescriptor = auxData.find(descriptorKey);
if (itMatching == auxData.end()) {
// if matching bool is not found, insert "true" and the descriptor
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData))[matchingKey] = true;
assert(itDescriptor == auxData.end());
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData))[descriptorKey] = descriptor;
}
else {
// if matching bool is found and is false, early exit (a previous descriptor did not match)
bool matching = boost::any_cast<bool>(itMatching->second);
if (!matching) return;
assert(itDescriptor != auxData.end());
// if matching bool is true, check whether the existing descriptor matches the current one and set
// matching bool to false if not
const Descriptor::Ptr existingDescriptor = boost::any_cast<AttributeSet::Descriptor::Ptr>(itDescriptor->second);
if (*existingDescriptor != *descriptor) {
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData))[matchingKey] = false;
}
}
}
static bool hasMatchingDescriptor(const io::StreamMetadata::AuxDataMap& auxData)
{
std::string matchingKey("hasMatchingDescriptor");
auto itMatching = auxData.find(matchingKey);
// if matching key is not found, no matching descriptor
if (itMatching == auxData.end()) return false;
// if matching key is found and is false, no matching descriptor
if (!boost::any_cast<bool>(itMatching->second)) return false;
return true;
}
static AttributeSet::Descriptor::Ptr retrieveMatchingDescriptor(const io::StreamMetadata::AuxDataMap& auxData)
{
std::string descriptorKey("descriptorPtr");
auto itDescriptor = auxData.find(descriptorKey);
// if matching key is true, however descriptor is not found, it has already been retrieved
if (itDescriptor == auxData.end()) return nullptr;
// otherwise remove it and return it
const Descriptor::Ptr descriptor = boost::any_cast<AttributeSet::Descriptor::Ptr>(itDescriptor->second);
(const_cast<io::StreamMetadata::AuxDataMap&>(auxData)).erase(itDescriptor);
return descriptor;
}
static void clearMatchingDescriptor(const io::StreamMetadata::AuxDataMap& auxData)
{
std::string matchingKey("hasMatchingDescriptor");
std::string descriptorKey("descriptorPtr");
auto itMatching = auxData.find(matchingKey);
auto itDescriptor = auxData.find(descriptorKey);
if (itMatching != auxData.end()) (const_cast<io::StreamMetadata::AuxDataMap&>(auxData)).erase(itMatching);
if (itDescriptor != auxData.end()) (const_cast<io::StreamMetadata::AuxDataMap&>(auxData)).erase(itDescriptor);
}
};
const io::StreamMetadata::Ptr meta = io::getStreamMetadataPtr(os);
if (!meta) {
OPENVDB_THROW(IoError, "Cannot write out a PointDataLeaf without StreamMetadata.");
}
const Index pass(static_cast<uint16_t>(meta->pass()));
// leaf traversal analysis deduces the number of passes to perform for this leaf
// then updates the leaf traversal value to ensure all passes will be written
if (meta->countingPasses()) {
const Index requiredPasses = this->buffers();
if (requiredPasses > pass) {
meta->setPass(requiredPasses);
}
return;
}
const Index maximumPass(static_cast<uint16_t>(meta->pass() >> 16));
const Index attributes = (maximumPass - 4) / 2;
if (pass == 0) {
// pass 0 - voxel data sizes
io::writeCompressedValuesSize(os, this->buffer().data(), SIZE);
// track if descriptor is shared or not
Local::insertDescriptor(meta->auxData(), mAttributeSet->descriptorPtr());
}
else if (pass == 1) {
// pass 1 - descriptor and attribute metadata
bool matchingDescriptor = Local::hasMatchingDescriptor(meta->auxData());
if (matchingDescriptor) {
AttributeSet::Descriptor::Ptr descriptor = Local::retrieveMatchingDescriptor(meta->auxData());
if (descriptor) {
// write a header to indicate a shared descriptor
uint8_t header(1);
os.write(reinterpret_cast<const char*>(&header), sizeof(uint8_t));
mAttributeSet->writeDescriptor(os, /*transient=*/false);
}
}
else {
// write a header to indicate a non-shared descriptor
uint8_t header(0);
os.write(reinterpret_cast<const char*>(&header), sizeof(uint8_t));
mAttributeSet->writeDescriptor(os, /*transient=*/false);
}
mAttributeSet->writeMetadata(os, /*transient=*/false, /*paged=*/true);
}
else if (pass < attributes + 2) {
// pass 2...n+2 - attribute buffer sizes
const Index attributeIndex = pass - 2;
// destroy previous paged stream
if (pass > 2) {
Local::destroyPagedStream(meta->auxData(), attributeIndex-1);
}
const AttributeArray* array = attributeIndex < mAttributeSet->size() ?
mAttributeSet->getConst(attributeIndex) : nullptr;
if (array) {
compression::PagedOutputStream& pagedStream =
Local::getOrInsertPagedStream(meta->auxData(), attributeIndex);
pagedStream.setOutputStream(os);
pagedStream.setSizeOnly(true);
array->writePagedBuffers(pagedStream, /*outputTransient*/false);
}
}
else if (pass == attributes + 2) {
const Index attributeIndex = pass - 3;
Local::destroyPagedStream(meta->auxData(), attributeIndex);
// pass n+2 - voxel data
BaseLeaf::writeBuffers(os, toHalf);
}
else if (pass < (attributes*2 + 3)) {
// pass n+3...2n+3 - attribute buffers
const Index attributeIndex = pass - attributes - 3;
// destroy previous paged stream
if (pass > attributes + 2) {
Local::destroyPagedStream(meta->auxData(), attributeIndex-1);
}
const AttributeArray* array = attributeIndex < mAttributeSet->size() ?
mAttributeSet->getConst(attributeIndex) : nullptr;
if (array) {
compression::PagedOutputStream& pagedStream =
Local::getOrInsertPagedStream(meta->auxData(), attributeIndex);
pagedStream.setOutputStream(os);
pagedStream.setSizeOnly(false);
array->writePagedBuffers(pagedStream, /*outputTransient*/false);
}
}
else if (pass < buffers()) {
Local::clearMatchingDescriptor(meta->auxData());
// pass 2n+3 - cleanup last paged stream
const Index attributeIndex = pass - attributes - 4;
Local::destroyPagedStream(meta->auxData(), attributeIndex);
}
}
template<typename T, Index Log2Dim>
inline Index64
PointDataLeafNode<T, Log2Dim>::memUsage() const
{
return BaseLeaf::memUsage() + mAttributeSet->memUsage();
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::evalActiveBoundingBox(CoordBBox& bbox, bool visitVoxels) const
{
BaseLeaf::evalActiveBoundingBox(bbox, visitVoxels);
}
template<typename T, Index Log2Dim>
inline CoordBBox
PointDataLeafNode<T, Log2Dim>::getNodeBoundingBox() const
{
return BaseLeaf::getNodeBoundingBox();
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::fill(const CoordBBox& bbox, const ValueType& value, bool active)
{
if (!this->allocate()) return;
this->assertNonModifiableUnlessZero(value);
// active state is permitted to be updated
for (Int32 x = bbox.min().x(); x <= bbox.max().x(); ++x) {
const Index offsetX = (x & (DIM-1u)) << 2*Log2Dim;
for (Int32 y = bbox.min().y(); y <= bbox.max().y(); ++y) {
const Index offsetXY = offsetX + ((y & (DIM-1u)) << Log2Dim);
for (Int32 z = bbox.min().z(); z <= bbox.max().z(); ++z) {
const Index offset = offsetXY + (z & (DIM-1u));
this->setValueMask(offset, active);
}
}
}
}
template<typename T, Index Log2Dim>
inline void
PointDataLeafNode<T, Log2Dim>::fill(const ValueType& value, bool active)
{
this->assertNonModifiableUnlessZero(value);
// active state is permitted to be updated
if (active) this->setValuesOn();
else this->setValuesOff();
}
////////////////////////////////////////
template <typename PointDataTreeT>
inline AttributeSet::Descriptor::Ptr
makeDescriptorUnique(PointDataTreeT& tree)
{
auto leafIter = tree.beginLeaf();
if (!leafIter) return nullptr;
const AttributeSet::Descriptor& descriptor = leafIter->attributeSet().descriptor();
auto newDescriptor = std::make_shared<AttributeSet::Descriptor>(descriptor);
for (; leafIter; ++leafIter) {
leafIter->resetDescriptor(newDescriptor);
}
return newDescriptor;
}
template <typename PointDataTreeT>
inline void
setStreamingMode(PointDataTreeT& tree, bool on)
{
auto leafIter = tree.beginLeaf();
for (; leafIter; ++leafIter) {
for (size_t i = 0; i < leafIter->attributeSet().size(); i++) {
leafIter->attributeArray(i).setStreaming(on);
}
}
}
template <typename PointDataTreeT>
inline void
prefetch(PointDataTreeT& tree, bool position, bool otherAttributes)
{
// NOTE: the following is intentionally not multi-threaded, as the I/O
// is faster if done in the order in which it is stored in the file
auto leaf = tree.cbeginLeaf();
if (!leaf) return;
const auto& attributeSet = leaf->attributeSet();
// pre-fetch leaf data
for ( ; leaf; ++leaf) {
leaf->buffer().data();
}
// pre-fetch position attribute data (position will typically have index 0)
size_t positionIndex = attributeSet.find("P");
if (position && positionIndex != AttributeSet::INVALID_POS) {
for (leaf = tree.cbeginLeaf(); leaf; ++leaf) {
assert(leaf->hasAttribute(positionIndex));
leaf->constAttributeArray(positionIndex).loadData();
}
}
// pre-fetch other attribute data
if (otherAttributes) {
const size_t attributes = attributeSet.size();
for (size_t attributeIndex = 0; attributeIndex < attributes; attributeIndex++) {
if (attributeIndex == positionIndex) continue;
for (leaf = tree.cbeginLeaf(); leaf; ++leaf) {
assert(leaf->hasAttribute(attributeIndex));
leaf->constAttributeArray(attributeIndex).loadData();
}
}
}
}
namespace internal {
/// @brief Global registration of point data-related types
/// @note This is called from @c openvdb::initialize, so there is
/// no need to call it directly.
void initialize();
/// @brief Global deregistration of point data-related types
/// @note This is called from @c openvdb::uninitialize, so there is
/// no need to call it directly.
void uninitialize();
/// @brief Recursive node chain which generates a openvdb::TypeList value
/// converted types of nodes to PointDataGrid nodes of the same configuration,
/// rooted at RootNodeType in reverse order, from LeafNode to RootNode.
/// See also TreeConverter<>.
template<typename HeadT, int HeadLevel>
struct PointDataNodeChain
{
using SubtreeT = typename PointDataNodeChain<typename HeadT::ChildNodeType, HeadLevel-1>::Type;
using RootNodeT = tree::RootNode<typename SubtreeT::Back>;
using Type = typename SubtreeT::template Append<RootNodeT>;
};
// Specialization for internal nodes which require their embedded child type to
// be switched
template <typename ChildT, Index Log2Dim, int HeadLevel>
struct PointDataNodeChain<tree::InternalNode<ChildT, Log2Dim>, HeadLevel>
{
using SubtreeT = typename PointDataNodeChain<ChildT, HeadLevel-1>::Type;
using InternalNodeT = tree::InternalNode<typename SubtreeT::Back, Log2Dim>;
using Type = typename SubtreeT::template Append<InternalNodeT>;
};
// Specialization for the last internal node of a node chain, expected
// to be templated on a leaf node
template <typename ChildT, Index Log2Dim>
struct PointDataNodeChain<tree::InternalNode<ChildT, Log2Dim>, /*HeadLevel=*/1>
{
using LeafNodeT = PointDataLeafNode<PointDataIndex32, ChildT::LOG2DIM>;
using InternalNodeT = tree::InternalNode<LeafNodeT, Log2Dim>;
using Type = TypeList<LeafNodeT, InternalNodeT>;
};
} // namespace internal
/// @brief Similiar to ValueConverter, but allows for tree configuration conversion
/// to a PointDataTree. ValueConverter<PointDataIndex32> cannot be used as a
/// PointDataLeafNode is not a specialization of LeafNode
template <typename TreeType>
struct TreeConverter {
using RootNodeT = typename TreeType::RootNodeType;
using NodeChainT = typename internal::PointDataNodeChain<RootNodeT, RootNodeT::LEVEL>::Type;
using Type = tree::Tree<typename NodeChainT::Back>;
};
} // namespace points
////////////////////////////////////////
namespace tree
{
/// Helper metafunction used to implement LeafNode::SameConfiguration
/// (which, as an inner class, can't be independently specialized)
template<Index Dim1, typename T2>
struct SameLeafConfig<Dim1, points::PointDataLeafNode<T2, Dim1>> { static const bool value = true; };
} // namespace tree
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_DATA_GRID_HAS_BEEN_INCLUDED
| 69,022 | C | 39.106334 | 129 | 0.669453 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/IndexFilter.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/IndexFilter.h
///
/// @author Dan Bailey
///
/// @brief Index filters primarily designed to be used with a FilterIndexIter.
///
/// Filters must adhere to the interface described in the example below:
/// @code
/// struct MyFilter
/// {
/// // Return true when the filter has been initialized for first use
/// bool initialized() { return true; }
///
/// // Return index::ALL if all points are valid, index::NONE if no points are valid
/// // and index::PARTIAL if some points are valid
/// index::State state() { return index::PARTIAL; }
///
/// // Return index::ALL if all points in this leaf are valid, index::NONE if no points
/// // in this leaf are valid and index::PARTIAL if some points in this leaf are valid
/// template <typename LeafT>
/// index::State state(const LeafT&) { return index::PARTIAL; }
///
/// // Resets the filter to refer to the specified leaf, all subsequent valid() calls
/// // will be relative to this leaf until reset() is called with a different leaf.
/// // Although a required method, many filters will provide an empty implementation if
/// // there is no leaf-specific logic needed.
/// template <typename LeafT> void reset(const LeafT&) { }
///
/// // Returns true if the filter is valid for the supplied iterator
/// template <typename IterT> bool valid(const IterT&) { return true; }
/// };
/// @endcode
#ifndef OPENVDB_POINTS_INDEX_FILTER_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_INDEX_FILTER_HAS_BEEN_INCLUDED
#include <openvdb/version.h>
#include <openvdb/Types.h>
#include <openvdb/math/Transform.h>
#include <openvdb/tools/Interpolation.h>
#include "IndexIterator.h"
#include "AttributeArray.h"
#include "AttributeGroup.h"
#include "AttributeSet.h"
#include <random> // std::mt19937
#include <numeric> // std::iota
#include <unordered_map>
class TestIndexFilter;
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
////////////////////////////////////////
namespace index_filter_internal {
// generate a random subset of n indices from the range [0:m]
template <typename RandGenT, typename IntType>
std::vector<IntType>
generateRandomSubset(const unsigned int seed, const IntType n, const IntType m)
{
if (n <= 0) return std::vector<IntType>();
// fill vector with ascending indices
std::vector<IntType> values(m);
std::iota(values.begin(), values.end(), 0);
if (n >= m) return values;
// shuffle indices using random generator
RandGenT randGen(seed);
std::shuffle(values.begin(), values.end(), randGen);
// resize the container to n elements
values.resize(n);
// sort the subset of the indices vector that will be used
std::sort(values.begin(), values.end());
return values;
}
} // namespace index_filter_internal
/// Index filtering on active / inactive state of host voxel
template <bool On>
class ValueMaskFilter
{
public:
static bool initialized() { return true; }
static index::State state() { return index::PARTIAL; }
template <typename LeafT>
static index::State state(const LeafT& leaf)
{
if (leaf.isDense()) return On ? index::ALL : index::NONE;
else if (leaf.isEmpty()) return On ? index::NONE : index::ALL;
return index::PARTIAL;
}
template <typename LeafT>
void reset(const LeafT&) { }
template <typename IterT>
bool valid(const IterT& iter) const
{
const bool valueOn = iter.isValueOn();
return On ? valueOn : !valueOn;
}
};
using ActiveFilter = ValueMaskFilter<true>;
using InactiveFilter = ValueMaskFilter<false>;
/// Index filtering on multiple group membership for inclusion and exclusion
///
/// @note include filters are applied first, then exclude filters
class MultiGroupFilter
{
public:
using NameVector = std::vector<Name>;
using IndexVector = std::vector<AttributeSet::Descriptor::GroupIndex>;
using HandleVector = std::vector<GroupHandle>;
private:
static IndexVector namesToIndices(const AttributeSet& attributeSet, const NameVector& names) {
IndexVector indices;
for (const auto& name : names) {
try {
indices.emplace_back(attributeSet.groupIndex(name));
} catch (LookupError&) {
// silently drop group names that don't exist
}
}
return indices;
}
public:
MultiGroupFilter( const NameVector& include,
const NameVector& exclude,
const AttributeSet& attributeSet)
: mInclude(MultiGroupFilter::namesToIndices(attributeSet, include))
, mExclude(MultiGroupFilter::namesToIndices(attributeSet, exclude)) { }
MultiGroupFilter( const IndexVector& include,
const IndexVector& exclude)
: mInclude(include)
, mExclude(exclude) { }
MultiGroupFilter( const MultiGroupFilter& filter)
: mInclude(filter.mInclude)
, mExclude(filter.mExclude)
, mIncludeHandles(filter.mIncludeHandles)
, mExcludeHandles(filter.mExcludeHandles)
, mInitialized(filter.mInitialized) { }
inline bool initialized() const { return mInitialized; }
inline index::State state() const
{
return (mInclude.empty() && mExclude.empty()) ? index::ALL : index::PARTIAL;
}
template <typename LeafT>
static index::State state(const LeafT&) { return index::PARTIAL; }
template <typename LeafT>
void reset(const LeafT& leaf) {
mIncludeHandles.clear();
mExcludeHandles.clear();
for (const auto& i : mInclude) {
mIncludeHandles.emplace_back(leaf.groupHandle(i));
}
for (const auto& i : mExclude) {
mExcludeHandles.emplace_back(leaf.groupHandle(i));
}
mInitialized = true;
}
template <typename IterT>
bool valid(const IterT& iter) const {
assert(mInitialized);
// accept no include filters as valid
bool includeValid = mIncludeHandles.empty();
for (const GroupHandle& handle : mIncludeHandles) {
if (handle.getUnsafe(*iter)) {
includeValid = true;
break;
}
}
if (!includeValid) return false;
for (const GroupHandle& handle : mExcludeHandles) {
if (handle.getUnsafe(*iter)) return false;
}
return true;
}
private:
IndexVector mInclude;
IndexVector mExclude;
HandleVector mIncludeHandles;
HandleVector mExcludeHandles;
bool mInitialized = false;
}; // class MultiGroupFilter
// Random index filtering per leaf
template <typename PointDataTreeT, typename RandGenT>
class RandomLeafFilter
{
public:
using SeedCountPair = std::pair<Index, Index>;
using LeafMap = std::unordered_map<openvdb::Coord, SeedCountPair>;
RandomLeafFilter( const PointDataTreeT& tree,
const Index64 targetPoints,
const unsigned int seed = 0) {
Index64 currentPoints = 0;
for (auto iter = tree.cbeginLeaf(); iter; ++iter) {
currentPoints += iter->pointCount();
}
const float factor = targetPoints > currentPoints ? 1.0f : float(targetPoints) / float(currentPoints);
std::mt19937 generator(seed);
std::uniform_int_distribution<unsigned int> dist(0, std::numeric_limits<unsigned int>::max() - 1);
Index32 leafCounter = 0;
float totalPointsFloat = 0.0f;
int totalPoints = 0;
for (auto iter = tree.cbeginLeaf(); iter; ++iter) {
// for the last leaf - use the remaining points to reach the target points
if (leafCounter + 1 == tree.leafCount()) {
const int leafPoints = static_cast<int>(targetPoints) - totalPoints;
mLeafMap[iter->origin()] = SeedCountPair(dist(generator), leafPoints);
break;
}
totalPointsFloat += factor * static_cast<float>(iter->pointCount());
const auto leafPoints = static_cast<int>(math::Floor(totalPointsFloat));
totalPointsFloat -= static_cast<float>(leafPoints);
totalPoints += leafPoints;
mLeafMap[iter->origin()] = SeedCountPair(dist(generator), leafPoints);
leafCounter++;
}
}
inline bool initialized() const { return mNextIndex == -1; }
static index::State state() { return index::PARTIAL; }
template <typename LeafT>
static index::State state(const LeafT&) { return index::PARTIAL; }
template <typename LeafT>
void reset(const LeafT& leaf) {
using index_filter_internal::generateRandomSubset;
auto it = mLeafMap.find(leaf.origin());
if (it == mLeafMap.end()) {
OPENVDB_THROW(openvdb::KeyError,
"Cannot find leaf origin in map for random filter - " << leaf.origin());
}
const SeedCountPair& value = it->second;
const unsigned int seed = static_cast<unsigned int>(value.first);
const auto total = static_cast<Index>(leaf.pointCount());
mCount = std::min(value.second, total);
mIndices = generateRandomSubset<RandGenT, int>(seed, mCount, total);
mSubsetOffset = -1;
mNextIndex = -1;
}
inline void next() const {
mSubsetOffset++;
mNextIndex = mSubsetOffset >= mCount ?
std::numeric_limits<int>::max() :
mIndices[mSubsetOffset];
}
template <typename IterT>
bool valid(const IterT& iter) const {
const int index = *iter;
while (mNextIndex < index) this->next();
return mNextIndex == index;
}
protected:
friend class ::TestIndexFilter;
private:
LeafMap mLeafMap;
std::vector<int> mIndices;
int mCount = 0;
mutable int mSubsetOffset = -1;
mutable int mNextIndex = -1;
}; // class RandomLeafFilter
// Hash attribute value for deterministic, but approximate filtering
template <typename RandGenT, typename IntType>
class AttributeHashFilter
{
public:
using Handle = AttributeHandle<IntType>;
AttributeHashFilter(const size_t index,
const double percentage,
const unsigned int seed = 0)
: mIndex(index)
, mFactor(percentage / 100.0)
, mSeed(seed) { }
AttributeHashFilter(const AttributeHashFilter& filter)
: mIndex(filter.mIndex)
, mFactor(filter.mFactor)
, mSeed(filter.mSeed)
{
if (filter.mIdHandle) mIdHandle.reset(new Handle(*filter.mIdHandle));
}
inline bool initialized() const { return bool(mIdHandle); }
static index::State state() { return index::PARTIAL; }
template <typename LeafT>
static index::State state(const LeafT&) { return index::PARTIAL; }
template <typename LeafT>
void reset(const LeafT& leaf) {
assert(leaf.hasAttribute(mIndex));
mIdHandle.reset(new Handle(leaf.constAttributeArray(mIndex)));
}
template <typename IterT>
bool valid(const IterT& iter) const {
assert(mIdHandle);
const IntType id = mIdHandle->get(*iter);
const unsigned int seed = mSeed + static_cast<unsigned int>(id);
RandGenT generator(seed);
std::uniform_real_distribution<double> dist(0.0, 1.0);
return dist(generator) < mFactor;
}
private:
const size_t mIndex;
const double mFactor;
const unsigned int mSeed;
typename Handle::UniquePtr mIdHandle;
}; // class AttributeHashFilter
template <typename LevelSetGridT>
class LevelSetFilter
{
public:
using ValueT = typename LevelSetGridT::ValueType;
using Handle = AttributeHandle<openvdb::Vec3f>;
LevelSetFilter( const LevelSetGridT& grid,
const math::Transform& transform,
const ValueT min,
const ValueT max)
: mAccessor(grid.getConstAccessor())
, mLevelSetTransform(grid.transform())
, mTransform(transform)
, mMin(min)
, mMax(max) { }
LevelSetFilter(const LevelSetFilter& filter)
: mAccessor(filter.mAccessor)
, mLevelSetTransform(filter.mLevelSetTransform)
, mTransform(filter.mTransform)
, mMin(filter.mMin)
, mMax(filter.mMax)
{
if (filter.mPositionHandle) mPositionHandle.reset(new Handle(*filter.mPositionHandle));
}
inline bool initialized() const { return bool(mPositionHandle); }
static index::State state() { return index::PARTIAL; }
template <typename LeafT>
static index::State state(const LeafT&) { return index::PARTIAL; }
template <typename LeafT>
void reset(const LeafT& leaf) {
mPositionHandle.reset(new Handle(leaf.constAttributeArray("P")));
}
template <typename IterT>
bool valid(const IterT& iter) const {
assert(mPositionHandle);
assert(iter);
const openvdb::Coord ijk = iter.getCoord();
const openvdb::Vec3f voxelIndexSpace = ijk.asVec3d();
// Retrieve point position in voxel space
const openvdb::Vec3f& pointVoxelSpace = mPositionHandle->get(*iter);
// Compute point position in index space
const openvdb::Vec3f pointWorldSpace = mTransform.indexToWorld(pointVoxelSpace + voxelIndexSpace);
const openvdb::Vec3f pointIndexSpace = mLevelSetTransform.worldToIndex(pointWorldSpace);
// Perform level-set sampling
const typename LevelSetGridT::ValueType value = tools::BoxSampler::sample(mAccessor, pointIndexSpace);
// if min is greater than max, we invert so that values are valid outside of the range (not inside)
const bool invert = mMin > mMax;
return invert ? (value < mMax || value > mMin) : (value < mMax && value > mMin);
}
private:
// not a reference to ensure const-accessor is unique per-thread
const typename LevelSetGridT::ConstAccessor mAccessor;
const math::Transform& mLevelSetTransform;
const math::Transform& mTransform;
const ValueT mMin;
const ValueT mMax;
Handle::UniquePtr mPositionHandle;
}; // class LevelSetFilter
// BBox index filtering
class BBoxFilter
{
public:
using Handle = AttributeHandle<openvdb::Vec3f>;
BBoxFilter(const openvdb::math::Transform& transform,
const openvdb::BBoxd& bboxWS)
: mTransform(transform)
, mBbox(transform.worldToIndex(bboxWS)) { }
BBoxFilter(const BBoxFilter& filter)
: mTransform(filter.mTransform)
, mBbox(filter.mBbox)
{
if (filter.mPositionHandle) mPositionHandle.reset(new Handle(*filter.mPositionHandle));
}
inline bool initialized() const { return bool(mPositionHandle); }
inline index::State state() const
{
return mBbox.empty() ? index::NONE : index::PARTIAL;
}
template <typename LeafT>
static index::State state(const LeafT&) { return index::PARTIAL; }
template <typename LeafT>
void reset(const LeafT& leaf) {
mPositionHandle.reset(new Handle(leaf.constAttributeArray("P")));
}
template <typename IterT>
bool valid(const IterT& iter) const {
assert(mPositionHandle);
const openvdb::Coord ijk = iter.getCoord();
const openvdb::Vec3f voxelIndexSpace = ijk.asVec3d();
// Retrieve point position in voxel space
const openvdb::Vec3f& pointVoxelSpace = mPositionHandle->get(*iter);
// Compute point position in index space
const openvdb::Vec3f pointIndexSpace = pointVoxelSpace + voxelIndexSpace;
return mBbox.isInside(pointIndexSpace);
}
private:
const openvdb::math::Transform& mTransform;
const openvdb::BBoxd mBbox;
Handle::UniquePtr mPositionHandle;
}; // class BBoxFilter
// Index filtering based on evaluating both sub-filters
template <typename T1, typename T2, bool And = true>
class BinaryFilter
{
public:
BinaryFilter( const T1& filter1,
const T2& filter2)
: mFilter1(filter1)
, mFilter2(filter2) { }
inline bool initialized() const { return mFilter1.initialized() && mFilter2.initialized(); }
inline index::State state() const
{
return this->computeState(mFilter1.state(), mFilter2.state());
}
template <typename LeafT>
inline index::State state(const LeafT& leaf) const
{
return this->computeState(mFilter1.state(leaf), mFilter2.state(leaf));
}
template <typename LeafT>
void reset(const LeafT& leaf) {
mFilter1.reset(leaf);
mFilter2.reset(leaf);
}
template <typename IterT>
bool valid(const IterT& iter) const {
if (And) return mFilter1.valid(iter) && mFilter2.valid(iter);
return mFilter1.valid(iter) || mFilter2.valid(iter);
}
private:
inline index::State computeState( index::State state1,
index::State state2) const
{
if (And) {
if (state1 == index::NONE || state2 == index::NONE) return index::NONE;
else if (state1 == index::ALL && state2 == index::ALL) return index::ALL;
} else {
if (state1 == index::NONE && state2 == index::NONE) return index::NONE;
else if (state1 == index::ALL && state2 == index::ALL) return index::ALL;
}
return index::PARTIAL;
}
T1 mFilter1;
T2 mFilter2;
}; // class BinaryFilter
////////////////////////////////////////
template<typename T>
struct FilterTraits {
static const bool RequiresCoord = false;
};
template<>
struct FilterTraits<BBoxFilter> {
static const bool RequiresCoord = true;
};
template <typename T>
struct FilterTraits<LevelSetFilter<T>> {
static const bool RequiresCoord = true;
};
template <typename T0, typename T1, bool And>
struct FilterTraits<BinaryFilter<T0, T1, And>> {
static const bool RequiresCoord = FilterTraits<T0>::RequiresCoord ||
FilterTraits<T1>::RequiresCoord;
};
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_INDEX_FILTER_HAS_BEEN_INCLUDED
| 18,450 | C | 30.702749 | 110 | 0.637453 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/StreamCompression.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/StreamCompression.cc
#include "StreamCompression.h"
#include <openvdb/util/logging.h>
#include <map>
#ifdef OPENVDB_USE_BLOSC
#include <blosc.h>
#endif
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace compression {
#ifdef OPENVDB_USE_BLOSC
bool
bloscCanCompress()
{
return true;
}
size_t
bloscUncompressedSize(const char* buffer)
{
size_t bytes, _1, _2;
blosc_cbuffer_sizes(buffer, &bytes, &_1, &_2);
return bytes;
}
void
bloscCompress(char* compressedBuffer, size_t& compressedBytes, const size_t bufferBytes,
const char* uncompressedBuffer, const size_t uncompressedBytes)
{
if (bufferBytes > BLOSC_MAX_BUFFERSIZE) {
OPENVDB_LOG_DEBUG("Blosc compress failed due to exceeding maximum buffer size.");
compressedBytes = 0;
compressedBuffer = nullptr;
return;
}
if (bufferBytes < uncompressedBytes + BLOSC_MAX_OVERHEAD) {
OPENVDB_LOG_DEBUG("Blosc compress failed due to insufficient space in compressed buffer.");
compressedBytes = 0;
compressedBuffer = nullptr;
return;
}
if (uncompressedBytes <= BLOSC_MINIMUM_BYTES) {
// no Blosc compression performed below this limit
compressedBytes = 0;
compressedBuffer = nullptr;
return;
}
if (uncompressedBytes < BLOSC_PAD_BYTES && bufferBytes < BLOSC_PAD_BYTES + BLOSC_MAX_OVERHEAD) {
OPENVDB_LOG_DEBUG(
"Blosc compress failed due to insufficient space in compressed buffer for padding.");
compressedBytes = 0;
compressedBuffer = nullptr;
return;
}
size_t inputBytes = uncompressedBytes;
const char* buffer = uncompressedBuffer;
std::unique_ptr<char[]> paddedBuffer;
if (uncompressedBytes < BLOSC_PAD_BYTES) {
// input array padded with zeros below this limit to improve compression
paddedBuffer.reset(new char[BLOSC_PAD_BYTES]);
std::memcpy(paddedBuffer.get(), buffer, uncompressedBytes);
for (int i = static_cast<int>(uncompressedBytes); i < BLOSC_PAD_BYTES; i++) {
paddedBuffer.get()[i] = 0;
}
buffer = paddedBuffer.get();
inputBytes = BLOSC_PAD_BYTES;
}
int _compressedBytes = blosc_compress_ctx(
/*clevel=*/9, // 0 (no compression) to 9 (maximum compression)
/*doshuffle=*/true,
/*typesize=*/sizeof(float), // hard-coded to 4-bytes for better compression
/*srcsize=*/inputBytes,
/*src=*/buffer,
/*dest=*/compressedBuffer,
/*destsize=*/bufferBytes,
BLOSC_LZ4_COMPNAME,
/*blocksize=*/inputBytes,
/*numthreads=*/1);
if (_compressedBytes <= 0) {
std::ostringstream ostr;
ostr << "Blosc failed to compress " << uncompressedBytes << " byte"
<< (uncompressedBytes == 1 ? "" : "s");
if (_compressedBytes < 0) ostr << " (internal error " << _compressedBytes << ")";
OPENVDB_LOG_DEBUG(ostr.str());
compressedBytes = 0;
return;
}
compressedBytes = _compressedBytes;
// fail if compression does not result in a smaller buffer
if (compressedBytes >= uncompressedBytes) {
compressedBytes = 0;
}
}
std::unique_ptr<char[]>
bloscCompress(const char* buffer, const size_t uncompressedBytes, size_t& compressedBytes,
const bool resize)
{
size_t tempBytes = uncompressedBytes;
// increase temporary buffer for padding if necessary
if (tempBytes >= BLOSC_MINIMUM_BYTES && tempBytes < BLOSC_PAD_BYTES) {
tempBytes += BLOSC_PAD_BYTES;
}
// increase by Blosc max overhead
tempBytes += BLOSC_MAX_OVERHEAD;
const bool outOfRange = tempBytes > BLOSC_MAX_BUFFERSIZE;
std::unique_ptr<char[]> outBuffer(outOfRange ? new char[1] : new char[tempBytes]);
bloscCompress(outBuffer.get(), compressedBytes, tempBytes, buffer, uncompressedBytes);
if (compressedBytes == 0) {
return nullptr;
}
// buffer size is larger due to Blosc overhead so resize
// (resize can be skipped if the buffer is only temporary)
if (resize) {
std::unique_ptr<char[]> newBuffer(new char[compressedBytes]);
std::memcpy(newBuffer.get(), outBuffer.get(), compressedBytes);
outBuffer.reset(newBuffer.release());
}
return outBuffer;
}
size_t
bloscCompressedSize( const char* buffer, const size_t uncompressedBytes)
{
size_t compressedBytes;
bloscCompress(buffer, uncompressedBytes, compressedBytes, /*resize=*/false);
return compressedBytes;
}
void
bloscDecompress(char* uncompressedBuffer, const size_t expectedBytes,
const size_t bufferBytes, const char* compressedBuffer)
{
size_t uncompressedBytes = bloscUncompressedSize(compressedBuffer);
if (bufferBytes > BLOSC_MAX_BUFFERSIZE) {
OPENVDB_THROW(RuntimeError,
"Blosc decompress failed due to exceeding maximum buffer size.");
}
if (bufferBytes < uncompressedBytes + BLOSC_MAX_OVERHEAD) {
OPENVDB_THROW(RuntimeError,
"Blosc decompress failed due to insufficient space in uncompressed buffer.");
}
uncompressedBytes = blosc_decompress_ctx( /*src=*/compressedBuffer,
/*dest=*/uncompressedBuffer,
bufferBytes,
/*numthreads=*/1);
if (uncompressedBytes < 1) {
OPENVDB_THROW(RuntimeError, "Blosc decompress returned error code " << uncompressedBytes);
}
if (uncompressedBytes == BLOSC_PAD_BYTES && expectedBytes <= BLOSC_PAD_BYTES) {
// padded array to improve compression
}
else if (uncompressedBytes != expectedBytes) {
OPENVDB_THROW(RuntimeError, "Expected to decompress " << expectedBytes
<< " byte" << (expectedBytes == 1 ? "" : "s") << ", got "
<< uncompressedBytes << " byte" << (uncompressedBytes == 1 ? "" : "s"));
}
}
std::unique_ptr<char[]>
bloscDecompress(const char* buffer, const size_t expectedBytes, const bool resize)
{
size_t uncompressedBytes = bloscUncompressedSize(buffer);
size_t tempBytes = uncompressedBytes + BLOSC_MAX_OVERHEAD;
const bool outOfRange = tempBytes > BLOSC_MAX_BUFFERSIZE;
if (outOfRange) tempBytes = 1;
std::unique_ptr<char[]> outBuffer(new char[tempBytes]);
bloscDecompress(outBuffer.get(), expectedBytes, tempBytes, buffer);
// buffer size is larger due to Blosc overhead so resize
// (resize can be skipped if the buffer is only temporary)
if (resize) {
std::unique_ptr<char[]> newBuffer(new char[expectedBytes]);
std::memcpy(newBuffer.get(), outBuffer.get(), expectedBytes);
outBuffer.reset(newBuffer.release());
}
return outBuffer;
}
#else
bool
bloscCanCompress()
{
OPENVDB_LOG_DEBUG("Can't compress array data without the blosc library.");
return false;
}
size_t
bloscUncompressedSize(const char*)
{
OPENVDB_THROW(RuntimeError, "Can't extract compressed data without the blosc library.");
}
void
bloscCompress(char*, size_t& compressedBytes, const size_t, const char*, const size_t)
{
OPENVDB_LOG_DEBUG("Can't compress array data without the blosc library.");
compressedBytes = 0;
}
std::unique_ptr<char[]>
bloscCompress(const char*, const size_t, size_t& compressedBytes, const bool)
{
OPENVDB_LOG_DEBUG("Can't compress array data without the blosc library.");
compressedBytes = 0;
return nullptr;
}
size_t
bloscCompressedSize(const char*, const size_t)
{
OPENVDB_LOG_DEBUG("Can't compress array data without the blosc library.");
return 0;
}
void
bloscDecompress(char*, const size_t, const size_t, const char*)
{
OPENVDB_THROW(RuntimeError, "Can't extract compressed data without the blosc library.");
}
std::unique_ptr<char[]>
bloscDecompress(const char*, const size_t, const bool)
{
OPENVDB_THROW(RuntimeError, "Can't extract compressed data without the blosc library.");
}
#endif // OPENVDB_USE_BLOSC
////////////////////////////////////////
void
Page::load() const
{
this->doLoad();
}
long
Page::uncompressedBytes() const
{
assert(mInfo);
return mInfo->uncompressedBytes;
}
const char*
Page::buffer(const int index) const
{
if (this->isOutOfCore()) this->load();
return mData.get() + index;
}
void
Page::readHeader(std::istream& is)
{
assert(mInfo);
// read the (compressed) size of the page
int compressedSize;
is.read(reinterpret_cast<char*>(&compressedSize), sizeof(int));
int uncompressedSize;
// if uncompressed, read the (compressed) size of the page
if (compressedSize > 0) is.read(reinterpret_cast<char*>(&uncompressedSize), sizeof(int));
else uncompressedSize = -compressedSize;
assert(compressedSize != 0);
assert(uncompressedSize != 0);
mInfo->compressedBytes = compressedSize;
mInfo->uncompressedBytes = uncompressedSize;
}
void
Page::readBuffers(std::istream&is, bool delayed)
{
assert(mInfo);
bool isCompressed = mInfo->compressedBytes > 0;
io::MappedFile::Ptr mappedFile = io::getMappedFilePtr(is);
if (delayed && mappedFile) {
SharedPtr<io::StreamMetadata> meta = io::getStreamMetadataPtr(is);
assert(meta);
std::streamoff filepos = is.tellg();
// seek over the page
is.seekg((isCompressed ? mInfo->compressedBytes : -mInfo->compressedBytes),
std::ios_base::cur);
mInfo->mappedFile = mappedFile;
mInfo->meta = meta;
mInfo->filepos = filepos;
assert(mInfo->mappedFile);
}
else {
std::unique_ptr<char[]> buffer(new char[
(isCompressed ? mInfo->compressedBytes : -mInfo->compressedBytes)]);
is.read(buffer.get(), (isCompressed ? mInfo->compressedBytes : -mInfo->compressedBytes));
if (mInfo->compressedBytes > 0) {
this->decompress(buffer);
} else {
this->copy(buffer, -static_cast<int>(mInfo->compressedBytes));
}
mInfo.reset();
}
}
bool
Page::isOutOfCore() const
{
return bool(mInfo);
}
void
Page::copy(const std::unique_ptr<char[]>& temp, int pageSize)
{
mData.reset(new char[pageSize]);
std::memcpy(mData.get(), temp.get(), pageSize);
}
void
Page::decompress(const std::unique_ptr<char[]>& temp)
{
size_t uncompressedBytes = bloscUncompressedSize(temp.get());
size_t tempBytes = uncompressedBytes;
#ifdef OPENVDB_USE_BLOSC
tempBytes += uncompressedBytes;
#endif
mData.reset(new char[tempBytes]);
bloscDecompress(mData.get(), uncompressedBytes, tempBytes, temp.get());
}
void
Page::doLoad() const
{
if (!this->isOutOfCore()) return;
Page* self = const_cast<Page*>(this);
// This lock will be contended at most once, after which this buffer
// will no longer be out-of-core.
tbb::spin_mutex::scoped_lock lock(self->mMutex);
if (!this->isOutOfCore()) return;
assert(self->mInfo);
int compressedBytes = static_cast<int>(self->mInfo->compressedBytes);
bool compressed = compressedBytes > 0;
if (!compressed) compressedBytes = -compressedBytes;
assert(compressedBytes);
std::unique_ptr<char[]> temp(new char[compressedBytes]);
assert(self->mInfo->mappedFile);
SharedPtr<std::streambuf> buf = self->mInfo->mappedFile->createBuffer();
assert(buf);
std::istream is(buf.get());
io::setStreamMetadataPtr(is, self->mInfo->meta, /*transfer=*/true);
is.seekg(self->mInfo->filepos);
is.read(temp.get(), compressedBytes);
if (compressed) self->decompress(temp);
else self->copy(temp, compressedBytes);
self->mInfo.reset();
}
////////////////////////////////////////
PageHandle::PageHandle( const Page::Ptr& page, const int index, const int size)
: mPage(page)
, mIndex(index)
, mSize(size)
{
}
Page&
PageHandle::page()
{
assert(mPage);
return *mPage;
}
std::unique_ptr<char[]>
PageHandle::read()
{
assert(mIndex >= 0);
assert(mSize > 0);
std::unique_ptr<char[]> buffer(new char[mSize]);
std::memcpy(buffer.get(), mPage->buffer(mIndex), mSize);
return buffer;
}
////////////////////////////////////////
PagedInputStream::PagedInputStream(std::istream& is)
: mIs(&is)
{
}
PageHandle::Ptr
PagedInputStream::createHandle(std::streamsize n)
{
assert(mByteIndex <= mUncompressedBytes);
if (mByteIndex == mUncompressedBytes) {
mPage = std::make_shared<Page>();
mPage->readHeader(*mIs);
mUncompressedBytes = static_cast<int>(mPage->uncompressedBytes());
mByteIndex = 0;
}
#if OPENVDB_ABI_VERSION_NUMBER >= 6
// TODO: C++14 introduces std::make_unique
PageHandle::Ptr pageHandle(new PageHandle(mPage, mByteIndex, int(n)));
#else
PageHandle::Ptr pageHandle = std::make_shared<PageHandle>(mPage, mByteIndex, int(n));
#endif
mByteIndex += int(n);
return pageHandle;
}
void
PagedInputStream::read(PageHandle::Ptr& pageHandle, std::streamsize n, bool delayed)
{
assert(mByteIndex <= mUncompressedBytes);
Page& page = pageHandle->page();
if (mByteIndex == mUncompressedBytes) {
mUncompressedBytes = static_cast<int>(page.uncompressedBytes());
page.readBuffers(*mIs, delayed);
mByteIndex = 0;
}
mByteIndex += int(n);
}
////////////////////////////////////////
PagedOutputStream::PagedOutputStream()
{
#ifdef OPENVDB_USE_BLOSC
mCompressedData.reset(new char[PageSize + BLOSC_MAX_OVERHEAD]);
#endif
}
PagedOutputStream::PagedOutputStream(std::ostream& os)
: mOs(&os)
{
#ifdef OPENVDB_USE_BLOSC
mCompressedData.reset(new char[PageSize + BLOSC_MAX_OVERHEAD]);
#endif
}
PagedOutputStream&
PagedOutputStream::write(const char* str, std::streamsize n)
{
if (n > PageSize) {
this->flush();
// write out the block as if a whole page
this->compressAndWrite(str, size_t(n));
}
else {
// if the size of this block will overflow the page, flush to disk
if ((int(n) + mBytes) > PageSize) {
this->flush();
}
// store and increment the data in the current page
std::memcpy(mData.get() + mBytes, str, n);
mBytes += int(n);
}
return *this;
}
void
PagedOutputStream::flush()
{
this->compressAndWrite(mData.get(), mBytes);
mBytes = 0;
}
void
PagedOutputStream::compressAndWrite(const char* buffer, size_t size)
{
if (size == 0) return;
assert(size < std::numeric_limits<int>::max());
this->resize(size);
size_t compressedBytes(0);
if (mSizeOnly) {
#ifdef OPENVDB_USE_BLOSC
compressedBytes = bloscCompressedSize(buffer, size);
#endif
}
else {
#ifdef OPENVDB_USE_BLOSC
bloscCompress(mCompressedData.get(), compressedBytes, mCapacity + BLOSC_MAX_OVERHEAD, buffer, size);
#endif
}
if (compressedBytes == 0) {
int uncompressedBytes = -static_cast<int>(size);
if (mSizeOnly) {
mOs->write(reinterpret_cast<const char*>(&uncompressedBytes), sizeof(int));
}
else {
mOs->write(buffer, size);
}
}
else {
if (mSizeOnly) {
mOs->write(reinterpret_cast<const char*>(&compressedBytes), sizeof(int));
mOs->write(reinterpret_cast<const char*>(&size), sizeof(int));
}
else {
#ifdef OPENVDB_USE_BLOSC
mOs->write(mCompressedData.get(), compressedBytes);
#else
OPENVDB_THROW(RuntimeError, "Cannot write out compressed data without Blosc.");
#endif
}
}
}
void
PagedOutputStream::resize(size_t size)
{
// grow the capacity if not sufficient space
size_t requiredSize = size;
if (size < BLOSC_PAD_BYTES && size >= BLOSC_MINIMUM_BYTES) {
requiredSize = BLOSC_PAD_BYTES;
}
if (requiredSize > mCapacity) {
mCapacity = requiredSize;
mData.reset(new char[mCapacity]);
#ifdef OPENVDB_USE_BLOSC
mCompressedData.reset(new char[mCapacity + BLOSC_MAX_OVERHEAD]);
#endif
}
}
} // namespace compression
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
| 16,323 | C++ | 24.747634 | 108 | 0.640446 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointSample.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @author Nick Avramoussis, Francisco Gochez, Dan Bailey
///
/// @file points/PointSample.h
///
/// @brief Sample a VDB Grid onto a VDB Points attribute
#ifndef OPENVDB_POINTS_POINT_SAMPLE_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_SAMPLE_HAS_BEEN_INCLUDED
#include <openvdb/util/NullInterrupter.h>
#include <openvdb/tools/Interpolation.h>
#include "PointDataGrid.h"
#include "PointAttribute.h"
#include <sstream>
#include <type_traits>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
/// @brief Performs closest point sampling from a VDB grid onto a VDB Points attribute
/// @param points the PointDataGrid whose points will be sampled on to
/// @param sourceGrid VDB grid which will be sampled
/// @param targetAttribute a target attribute on the points which will hold samples. This
/// attribute will be created with the source grid type if it does
/// not exist, and with the source grid name if the name is empty
/// @param filter an optional index filter
/// @param interrupter an optional interrupter
/// @note The target attribute may exist provided it can be cast to the SourceGridT ValueType
template<typename PointDataGridT, typename SourceGridT,
typename FilterT = NullFilter, typename InterrupterT = util::NullInterrupter>
inline void pointSample(PointDataGridT& points,
const SourceGridT& sourceGrid,
const Name& targetAttribute = "",
const FilterT& filter = NullFilter(),
InterrupterT* const interrupter = nullptr);
/// @brief Performs tri-linear sampling from a VDB grid onto a VDB Points attribute
/// @param points the PointDataGrid whose points will be sampled on to
/// @param sourceGrid VDB grid which will be sampled
/// @param targetAttribute a target attribute on the points which will hold samples. This
/// attribute will be created with the source grid type if it does
/// not exist, and with the source grid name if the name is empty
/// @param filter an optional index filter
/// @param interrupter an optional interrupter
/// @note The target attribute may exist provided it can be cast to the SourceGridT ValueType
template<typename PointDataGridT, typename SourceGridT,
typename FilterT = NullFilter, typename InterrupterT = util::NullInterrupter>
inline void boxSample( PointDataGridT& points,
const SourceGridT& sourceGrid,
const Name& targetAttribute = "",
const FilterT& filter = NullFilter(),
InterrupterT* const interrupter = nullptr);
/// @brief Performs tri-quadratic sampling from a VDB grid onto a VDB Points attribute
/// @param points the PointDataGrid whose points will be sampled on to
/// @param sourceGrid VDB grid which will be sampled
/// @param targetAttribute a target attribute on the points which will hold samples. This
/// attribute will be created with the source grid type if it does
/// not exist, and with the source grid name if the name is empty
/// @param filter an optional index filter
/// @param interrupter an optional interrupter
/// @note The target attribute may exist provided it can be cast to the SourceGridT ValueType
template<typename PointDataGridT, typename SourceGridT,
typename FilterT = NullFilter, typename InterrupterT = util::NullInterrupter>
inline void quadraticSample(PointDataGridT& points,
const SourceGridT& sourceGrid,
const Name& targetAttribute = "",
const FilterT& filter = NullFilter(),
InterrupterT* const interrupter = nullptr);
// This struct samples the source grid accessor using the world-space position supplied,
// with SamplerT providing the sampling scheme. In the case where ValueT does not match
// the value type of the source grid, the sample() method will also convert the sampled
// value into a ValueT value, using round-to-nearest for float-to-integer conversion.
struct SampleWithRounding
{
template<typename ValueT, typename SamplerT, typename AccessorT>
inline ValueT sample(const AccessorT& accessor, const Vec3d& position) const;
};
// A dummy struct that is used to mean that the sampled attribute should either match the type
// of the existing attribute or the type of the source grid (if the attribute doesn't exist yet)
struct DummySampleType { };
/// @brief Performs sampling and conversion from a VDB grid onto a VDB Points attribute
/// @param order the sampling order - 0 = closest-point, 1 = trilinear, 2 = triquadratic
/// @param points the PointDataGrid whose points will be sampled on to
/// @param sourceGrid VDB grid which will be sampled
/// @param targetAttribute a target attribute on the points which will hold samples. This
/// attribute will be created with the source grid type if it does
/// not exist, and with the source grid name if the name is empty
/// @param filter an optional index filter
/// @param sampler handles sampling and conversion into the target attribute type,
/// which by default this uses the SampleWithRounding struct.
/// @param interrupter an optional interrupter
/// @param threaded enable or disable threading (threading is enabled by default)
/// @note The target attribute may exist provided it can be cast to the SourceGridT ValueType
template<typename PointDataGridT, typename SourceGridT, typename TargetValueT = DummySampleType,
typename SamplerT = SampleWithRounding, typename FilterT = NullFilter,
typename InterrupterT = util::NullInterrupter>
inline void sampleGrid( size_t order,
PointDataGridT& points,
const SourceGridT& sourceGrid,
const Name& targetAttribute,
const FilterT& filter = NullFilter(),
const SamplerT& sampler = SampleWithRounding(),
InterrupterT* const interrupter = nullptr,
const bool threaded = true);
///////////////////////////////////////////////////
namespace point_sample_internal {
template<typename FromType, typename ToType>
struct CompatibleTypes { enum { value = std::is_constructible<ToType, FromType>::value }; };
// Specializations for types that can be converted from source grid to target attribute
template<typename T> struct CompatibleTypes<
T, T> { enum { value = true }; };
template<typename T> struct CompatibleTypes<
T, math::Vec2<T>> { enum { value = true }; };
template<typename T> struct CompatibleTypes<
T, math::Vec3<T>> { enum { value = true }; };
template<typename T> struct CompatibleTypes<
T, math::Vec4<T>> { enum { value = true }; };
template<typename T> struct CompatibleTypes<
math::Vec2<T>, math::Vec2<T>> { enum { value = true }; };
template<typename T> struct CompatibleTypes<
math::Vec3<T>, math::Vec3<T>> { enum { value = true }; };
template<typename T> struct CompatibleTypes<
math::Vec4<T>, math::Vec4<T>> { enum { value = true }; };
template<typename T0, typename T1> struct CompatibleTypes<
math::Vec2<T0>, math::Vec2<T1>> { enum { value = CompatibleTypes<T0, T1>::value }; };
template<typename T0, typename T1> struct CompatibleTypes<
math::Vec3<T0>, math::Vec3<T1>> { enum { value = CompatibleTypes<T0, T1>::value }; };
template<typename T0, typename T1> struct CompatibleTypes<
math::Vec4<T0>, math::Vec4<T1>> { enum { value = CompatibleTypes<T0, T1>::value }; };
template<typename T> struct CompatibleTypes<
ValueMask, T> { enum { value = CompatibleTypes<bool, T>::value }; };
// Ability to access the Order and Staggered template parameter from tools::Sampler<Order, Staggered>
template <typename T> struct SamplerTraits {
static const size_t Order = 0;
static const bool Staggered = false;
};
template <size_t T0, bool T1> struct SamplerTraits<tools::Sampler<T0, T1>> {
static const size_t Order = T0;
static const bool Staggered = T1;
};
// default sampling is incompatible, so throw an error
template <typename ValueT, typename SamplerT, typename AccessorT, bool Round, bool Compatible = false>
struct SampleWithRoundingOp
{
static inline void sample(ValueT&, const AccessorT&, const Vec3d&)
{
std::ostringstream ostr;
ostr << "Cannot sample a " << typeNameAsString<typename AccessorT::ValueType>()
<< " grid on to a " << typeNameAsString<ValueT>() << " attribute";
OPENVDB_THROW(TypeError, ostr.str());
}
};
// partial specialization to handle sampling and rounding of compatible conversion
template <typename ValueT, typename SamplerT, typename AccessorT>
struct SampleWithRoundingOp<ValueT, SamplerT, AccessorT, /*Round=*/true, /*Compatible=*/true>
{
static inline void sample(ValueT& value, const AccessorT& accessor, const Vec3d& position)
{
value = ValueT(math::Round(SamplerT::sample(accessor, position)));
}
};
// partial specialization to handle sampling and simple casting of compatible conversion
template <typename ValueT, typename SamplerT, typename AccessorT>
struct SampleWithRoundingOp<ValueT, SamplerT, AccessorT, /*Round=*/false, /*Compatible=*/true>
{
static inline void sample(ValueT& value, const AccessorT& accessor, const Vec3d& position)
{
value = ValueT(SamplerT::sample(accessor, position));
}
};
template <typename PointDataGridT, typename SamplerT, typename FilterT, typename InterrupterT>
class PointDataSampler
{
public:
PointDataSampler(size_t order,
PointDataGridT& points,
const SamplerT& sampler,
const FilterT& filter,
InterrupterT* const interrupter,
const bool threaded)
: mOrder(order)
, mPoints(points)
, mSampler(sampler)
, mFilter(filter)
, mInterrupter(interrupter)
, mThreaded(threaded) { }
private:
// No-op transformation
struct AlignedTransform
{
inline Vec3d transform(const Vec3d& position) const { return position; }
}; // struct AlignedTransform
// Re-sample world-space position from source to target transforms
struct NonAlignedTransform
{
NonAlignedTransform(const math::Transform& source, const math::Transform& target)
: mSource(source)
, mTarget(target) { }
inline Vec3d transform(const Vec3d& position) const
{
return mSource.worldToIndex(mTarget.indexToWorld(position));
}
private:
const math::Transform& mSource;
const math::Transform& mTarget;
}; // struct NonAlignedTransform
// A simple convenience wrapper that contains the source grid accessor and the sampler
template <typename ValueT, typename SourceGridT, typename GridSamplerT>
struct SamplerWrapper
{
using ValueType = ValueT;
using SourceValueType = typename SourceGridT::ValueType;
using SourceAccessorT = typename SourceGridT::ConstAccessor;
// can only sample from a bool or mask grid using a PointSampler
static const bool SourceIsBool = std::is_same<SourceValueType, bool>::value ||
std::is_same<SourceValueType, ValueMask>::value;
static const bool OrderIsZero = SamplerTraits<GridSamplerT>::Order == 0;
static const bool IsValid = !SourceIsBool || OrderIsZero;
SamplerWrapper(const SourceGridT& sourceGrid, const SamplerT& sampler)
: mAccessor(sourceGrid.getConstAccessor())
, mSampler(sampler) { }
// note that creating a new accessor from the underlying tree is faster than
// copying an existing accessor
SamplerWrapper(const SamplerWrapper& other)
: mAccessor(other.mAccessor.tree())
, mSampler(other.mSampler) { }
template <bool IsValidT = IsValid>
inline typename std::enable_if<IsValidT, ValueT>::type
sample(const Vec3d& position) const {
return mSampler.template sample<ValueT, GridSamplerT, SourceAccessorT>(
mAccessor, position);
}
template <bool IsValidT = IsValid>
inline typename std::enable_if<!IsValidT, ValueT>::type
sample(const Vec3d& /*position*/) const {
OPENVDB_THROW(RuntimeError, "Cannot sample bool grid with BoxSampler or QuadraticSampler.");
}
private:
SourceAccessorT mAccessor;
const SamplerT& mSampler;
}; // struct SamplerWrapper
template <typename SamplerWrapperT, typename TransformerT>
inline void doSample(const SamplerWrapperT& sampleWrapper, const Index targetIndex,
const TransformerT& transformer)
{
using PointDataTreeT = typename PointDataGridT::TreeType;
using LeafT = typename PointDataTreeT::LeafNodeType;
using LeafManagerT = typename tree::LeafManager<PointDataTreeT>;
const auto& filter(mFilter);
const auto& interrupter(mInterrupter);
auto sampleLambda = [targetIndex, &sampleWrapper, &transformer, &filter, &interrupter](
LeafT& leaf, size_t /*idx*/)
{
using TargetHandleT = AttributeWriteHandle<typename SamplerWrapperT::ValueType>;
if (util::wasInterrupted(interrupter)) {
tbb::task::self().cancel_group_execution();
return;
}
SamplerWrapperT newSampleWrapper(sampleWrapper);
auto positionHandle = AttributeHandle<Vec3f>::create(leaf.constAttributeArray("P"));
auto targetHandle = TargetHandleT::create(leaf.attributeArray(targetIndex));
for (auto iter = leaf.beginIndexOn(filter); iter; ++iter) {
const Vec3d position = transformer.transform(
positionHandle->get(*iter) + iter.getCoord().asVec3d());
targetHandle->set(*iter, newSampleWrapper.sample(position));
}
};
LeafManagerT leafManager(mPoints.tree());
if (mInterrupter) mInterrupter->start();
leafManager.foreach(sampleLambda, mThreaded);
if (mInterrupter) mInterrupter->end();
}
template <typename SourceGridT, typename SamplerWrapperT>
inline void resolveTransform(const SourceGridT& sourceGrid, const SamplerWrapperT& sampleWrapper,
const Index targetIndex)
{
const auto& sourceTransform = sourceGrid.constTransform();
const auto& pointsTransform = mPoints.constTransform();
if (sourceTransform == pointsTransform) {
AlignedTransform transformer;
doSample(sampleWrapper, targetIndex, transformer);
} else {
NonAlignedTransform transformer(sourceTransform, pointsTransform);
doSample(sampleWrapper, targetIndex, transformer);
}
}
template <typename SourceGridT, typename TargetValueT, size_t Order>
inline void resolveStaggered(const SourceGridT& sourceGrid, const Index targetIndex)
{
using SamplerWrapperT = SamplerWrapper<TargetValueT, SourceGridT, tools::Sampler<Order, false>>;
using StaggeredSamplerWrapperT = SamplerWrapper<TargetValueT, SourceGridT, tools::Sampler<Order, true>>;
using SourceValueType = typename SourceGridT::ValueType;
if (VecTraits<SourceValueType>::Size == 3 && sourceGrid.getGridClass() == GRID_STAGGERED) {
StaggeredSamplerWrapperT sampleWrapper(sourceGrid, mSampler);
resolveTransform(sourceGrid, sampleWrapper, targetIndex);
} else {
SamplerWrapperT sampleWrapper(sourceGrid, mSampler);
resolveTransform(sourceGrid, sampleWrapper, targetIndex);
}
}
public:
template <typename SourceGridT, typename TargetValueT = typename SourceGridT::ValueType>
inline void sample(const SourceGridT& sourceGrid, Index targetIndex)
{
using SourceValueType = typename SourceGridT::ValueType;
static const bool SourceIsMask = std::is_same<SourceValueType, bool>::value ||
std::is_same<SourceValueType, ValueMask>::value;
if (SourceIsMask || mOrder == 0) {
resolveStaggered<SourceGridT, TargetValueT, 0>(sourceGrid, targetIndex);
} else if (mOrder == 1) {
resolveStaggered<SourceGridT, TargetValueT, 1>(sourceGrid, targetIndex);
} else if (mOrder == 2) {
resolveStaggered<SourceGridT, TargetValueT, 2>(sourceGrid, targetIndex);
}
}
private:
size_t mOrder;
PointDataGridT& mPoints;
const SamplerT& mSampler;
const FilterT& mFilter;
InterrupterT* const mInterrupter;
const bool mThreaded;
}; // class PointDataSampler
template <typename PointDataGridT, typename ValueT>
struct AppendAttributeOp
{
static void append(PointDataGridT& points, const Name& attribute)
{
appendAttribute<ValueT>(points.tree(), attribute);
}
};
// partial specialization to disable attempts to append attribute type of DummySampleType
template <typename PointDataGridT>
struct AppendAttributeOp<PointDataGridT, DummySampleType>
{
static void append(PointDataGridT&, const Name&) { }
};
} // namespace point_sample_internal
////////////////////////////////////////
template<typename ValueT, typename SamplerT, typename AccessorT>
ValueT SampleWithRounding::sample(const AccessorT& accessor, const Vec3d& position) const
{
using namespace point_sample_internal;
using SourceValueT = typename AccessorT::ValueType;
static const bool staggered = SamplerTraits<SamplerT>::Staggered;
static const bool compatible = CompatibleTypes</*from=*/SourceValueT, /*to=*/ValueT>::value &&
(!staggered || (staggered && VecTraits<SourceValueT>::Size == 3));
static const bool round = std::is_floating_point<SourceValueT>::value &&
std::is_integral<ValueT>::value;
ValueT value;
SampleWithRoundingOp<ValueT, SamplerT, AccessorT, round, compatible>::sample(
value, accessor, position);
return value;
}
////////////////////////////////////////
template<typename PointDataGridT, typename SourceGridT, typename TargetValueT,
typename SamplerT, typename FilterT, typename InterrupterT>
inline void sampleGrid( size_t order,
PointDataGridT& points,
const SourceGridT& sourceGrid,
const Name& targetAttribute,
const FilterT& filter,
const SamplerT& sampler,
InterrupterT* const interrupter,
const bool threaded)
{
using point_sample_internal::AppendAttributeOp;
using point_sample_internal::PointDataSampler;
// use the name of the grid if no target attribute name supplied
Name attribute(targetAttribute);
if (targetAttribute.empty()) {
attribute = sourceGrid.getName();
}
// we do not allow sampling onto the "P" attribute
if (attribute == "P") {
OPENVDB_THROW(RuntimeError, "Cannot sample onto the \"P\" attribute");
}
auto leaf = points.tree().cbeginLeaf();
if (!leaf) return;
PointDataSampler<PointDataGridT, SamplerT, FilterT, InterrupterT> pointDataSampler(
order, points, sampler, filter, interrupter, threaded);
const auto& descriptor = leaf->attributeSet().descriptor();
size_t targetIndex = descriptor.find(attribute);
const bool attributeExists = targetIndex != AttributeSet::INVALID_POS;
if (std::is_same<TargetValueT, DummySampleType>::value) {
if (!attributeExists) {
// append attribute of source grid value type
appendAttribute<typename SourceGridT::ValueType>(points.tree(), attribute);
targetIndex = leaf->attributeSet().descriptor().find(attribute);
assert(targetIndex != AttributeSet::INVALID_POS);
// sample using same type as source grid
pointDataSampler.template sample<SourceGridT>(sourceGrid, Index(targetIndex));
} else {
auto targetIdx = static_cast<Index>(targetIndex);
// attempt to explicitly sample using type of existing attribute
const Name& targetType = descriptor.valueType(targetIndex);
if (targetType == typeNameAsString<Vec3f>()) {
pointDataSampler.template sample<SourceGridT, Vec3f>(sourceGrid, targetIdx);
} else if (targetType == typeNameAsString<Vec3d>()) {
pointDataSampler.template sample<SourceGridT, Vec3d>(sourceGrid, targetIdx);
} else if (targetType == typeNameAsString<Vec3i>()) {
pointDataSampler.template sample<SourceGridT, Vec3i>(sourceGrid, targetIdx);
} else if (targetType == typeNameAsString<int8_t>()) {
pointDataSampler.template sample<SourceGridT, int8_t>(sourceGrid, targetIdx);
} else if (targetType == typeNameAsString<int16_t>()) {
pointDataSampler.template sample<SourceGridT, int16_t>(sourceGrid, targetIdx);
} else if (targetType == typeNameAsString<int32_t>()) {
pointDataSampler.template sample<SourceGridT, int32_t>(sourceGrid, targetIdx);
} else if (targetType == typeNameAsString<int64_t>()) {
pointDataSampler.template sample<SourceGridT, int64_t>(sourceGrid, targetIdx);
} else if (targetType == typeNameAsString<float>()) {
pointDataSampler.template sample<SourceGridT, float>(sourceGrid, targetIdx);
} else if (targetType == typeNameAsString<double>()) {
pointDataSampler.template sample<SourceGridT, double>(sourceGrid, targetIdx);
} else if (targetType == typeNameAsString<bool>()) {
pointDataSampler.template sample<SourceGridT, bool>(sourceGrid, targetIdx);
} else {
std::ostringstream ostr;
ostr << "Cannot sample attribute of type - " << targetType;
OPENVDB_THROW(TypeError, ostr.str());
}
}
} else {
if (!attributeExists) {
// append attribute of target value type
// (point_sample_internal wrapper disables the ability to use DummySampleType)
AppendAttributeOp<PointDataGridT, TargetValueT>::append(points, attribute);
targetIndex = leaf->attributeSet().descriptor().find(attribute);
assert(targetIndex != AttributeSet::INVALID_POS);
}
else {
const Name targetType = typeNameAsString<TargetValueT>();
const Name attributeType = descriptor.valueType(targetIndex);
if (targetType != attributeType) {
std::ostringstream ostr;
ostr << "Requested attribute type " << targetType << " for sampling "
<< " does not match existing attribute type " << attributeType;
OPENVDB_THROW(TypeError, ostr.str());
}
}
// sample using target value type
pointDataSampler.template sample<SourceGridT, TargetValueT>(
sourceGrid, static_cast<Index>(targetIndex));
}
}
template<typename PointDataGridT, typename SourceGridT, typename FilterT, typename InterrupterT>
inline void pointSample(PointDataGridT& points,
const SourceGridT& sourceGrid,
const Name& targetAttribute,
const FilterT& filter,
InterrupterT* const interrupter)
{
SampleWithRounding sampler;
sampleGrid(/*order=*/0, points, sourceGrid, targetAttribute, filter, sampler, interrupter);
}
template<typename PointDataGridT, typename SourceGridT, typename FilterT, typename InterrupterT>
inline void boxSample( PointDataGridT& points,
const SourceGridT& sourceGrid,
const Name& targetAttribute,
const FilterT& filter,
InterrupterT* const interrupter)
{
SampleWithRounding sampler;
sampleGrid(/*order=*/1, points, sourceGrid, targetAttribute, filter, sampler, interrupter);
}
template<typename PointDataGridT, typename SourceGridT, typename FilterT, typename InterrupterT>
inline void quadraticSample(PointDataGridT& points,
const SourceGridT& sourceGrid,
const Name& targetAttribute,
const FilterT& filter,
InterrupterT* const interrupter)
{
SampleWithRounding sampler;
sampleGrid(/*order=*/2, points, sourceGrid, targetAttribute, filter, sampler, interrupter);
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_SAMPLE_HAS_BEEN_INCLUDED
| 25,485 | C | 44.028268 | 112 | 0.655798 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointScatter.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @author Nick Avramoussis
///
/// @file points/PointScatter.h
///
/// @brief Various point scattering methods for generating VDB Points.
///
/// All random number calls are made to the same generator to produce
/// temporarily consistent results in relation to the provided seed. This
/// comes with some multi-threaded performance trade-offs.
#ifndef OPENVDB_POINTS_POINT_SCATTER_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_SCATTER_HAS_BEEN_INCLUDED
#include <type_traits>
#include <algorithm>
#include <thread>
#include <random>
#include <openvdb/openvdb.h>
#include <openvdb/Types.h>
#include <openvdb/tree/LeafManager.h>
#include <openvdb/tools/Prune.h>
#include <openvdb/util/NullInterrupter.h>
#include "AttributeArray.h"
#include "PointCount.h"
#include "PointDataGrid.h"
#include <tbb/parallel_sort.h>
#include <tbb/parallel_for.h>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
/// @brief The free functions depend on the following class:
///
/// The @c InterrupterT template argument below refers to any class
/// with the following interface:
/// @code
/// class Interrupter {
/// ...
/// public:
/// void start(const char* name = nullptr) // called when computations begin
/// void end() // called when computations end
/// bool wasInterrupted(int percent=-1) // return true to break computation
///};
/// @endcode
///
/// @note If no template argument is provided for this InterrupterT
/// the util::NullInterrupter is used which implies that all
/// interrupter calls are no-ops (i.e. incurs no computational overhead).
/// @brief Uniformly scatter a total amount of points in active regions
///
/// @param grid A source grid. The resulting PointDataGrid will copy this grids
/// transform and scatter in its active voxelized topology.
/// @param count The total number of points to scatter
/// @param seed A seed for the RandGenT
/// @param spread The spread of points as a scale from each voxels center. A value of
/// 1.0f indicates points can be placed anywhere within the voxel, where
/// as a value of 0.0f will force all points to be created exactly at the
/// centers of each voxel.
/// @param interrupter An optional interrupter
/// @note returns the scattered PointDataGrid
template<
typename GridT,
typename RandGenT = std::mt19937,
typename PositionArrayT = TypedAttributeArray<Vec3f, NullCodec>,
typename PointDataGridT = Grid<
typename points::TreeConverter<typename GridT::TreeType>::Type>,
typename InterrupterT = util::NullInterrupter>
inline typename PointDataGridT::Ptr
uniformPointScatter(const GridT& grid,
const Index64 count,
const unsigned int seed = 0,
const float spread = 1.0f,
InterrupterT* interrupter = nullptr);
/// @brief Uniformly scatter a fixed number of points per active voxel. If the pointsPerVoxel
/// value provided is a fractional value, each voxel calculates a delta value of
/// how likely it is to contain an extra point.
///
/// @param grid A source grid. The resulting PointDataGrid will copy this grids
/// transform and scatter in its active voxelized topology.
/// @param pointsPerVoxel The number of points to scatter per voxel
/// @param seed A seed for the RandGenT
/// @param spread The spread of points as a scale from each voxels center. A value of
/// 1.0f indicates points can be placed anywhere within the voxel, where
/// as a value of 0.0f will force all points to be created exactly at the
/// centers of each voxel.
/// @param interrupter An optional interrupter
/// @note returns the scattered PointDataGrid
template<
typename GridT,
typename RandGenT = std::mt19937,
typename PositionArrayT = TypedAttributeArray<Vec3f, NullCodec>,
typename PointDataGridT = Grid<
typename points::TreeConverter<typename GridT::TreeType>::Type>,
typename InterrupterT = util::NullInterrupter>
inline typename PointDataGridT::Ptr
denseUniformPointScatter(const GridT& grid,
const float pointsPerVoxel,
const unsigned int seed = 0,
const float spread = 1.0f,
InterrupterT* interrupter = nullptr);
/// @brief Non uniformly scatter points per active voxel. The pointsPerVoxel value is used
/// to weight each grids cell value to compute a fixed number of points for every
/// active voxel. If the computed result is a fractional value, each voxel calculates
/// a delta value of how likely it is to contain an extra point.
///
/// @param grid A source grid. The resulting PointDataGrid will copy this grids
/// transform, voxelized topology and use its values to compute a
/// target points per voxel. The grids ValueType must be convertible
/// to a scalar value. Only active and larger than zero values will
/// contain points.
/// @param pointsPerVoxel The number of points to scatter per voxel
/// @param seed A seed for the RandGenT
/// @param spread The spread of points as a scale from each voxels center. A value of
/// 1.0f indicates points can be placed anywhere within the voxel, where
/// as a value of 0.0f will force all points to be created exactly at the
/// centers of each voxel.
/// @param interrupter An optional interrupter
/// @note returns the scattered PointDataGrid
template<
typename GridT,
typename RandGenT = std::mt19937,
typename PositionArrayT = TypedAttributeArray<Vec3f, NullCodec>,
typename PointDataGridT = Grid<
typename points::TreeConverter<typename GridT::TreeType>::Type>,
typename InterrupterT = util::NullInterrupter>
inline typename PointDataGridT::Ptr
nonUniformPointScatter(const GridT& grid,
const float pointsPerVoxel,
const unsigned int seed = 0,
const float spread = 1.0f,
InterrupterT* interrupter = nullptr);
////////////////////////////////////////
namespace point_scatter_internal
{
/// @brief initialise the topology of a PointDataGrid and ensure
/// everything is voxelized
/// @param grid The source grid from which to base the topology generation
template<typename PointDataGridT, typename GridT>
inline typename PointDataGridT::Ptr
initialisePointTopology(const GridT& grid)
{
typename PointDataGridT::Ptr points(new PointDataGridT);
points->setTransform(grid.transform().copy());
points->topologyUnion(grid);
if (points->tree().hasActiveTiles()) {
points->tree().voxelizeActiveTiles();
}
return points;
}
/// @brief Generate random point positions for a leaf node
/// @param leaf The leaf node to initialize
/// @param descriptor The descriptor containing the position type
/// @param count The number of points to generate
/// @param spread The spread of points from the voxel center
/// @param rand01 The random number generator, expected to produce floating point
/// values between 0 and 1.
template<typename PositionType,
typename CodecT,
typename RandGenT,
typename LeafNodeT>
inline void
generatePositions(LeafNodeT& leaf,
const AttributeSet::Descriptor::Ptr& descriptor,
const Index64& count,
const float spread,
RandGenT& rand01)
{
using PositionTraits = VecTraits<PositionType>;
using ValueType = typename PositionTraits::ElementType;
using PositionWriteHandle = AttributeWriteHandle<PositionType, CodecT>;
leaf.initializeAttributes(descriptor, static_cast<Index>(count));
// directly expand to avoid needlessly setting uniform values in the
// write handle
auto& array = leaf.attributeArray(0);
array.expand(/*fill*/false);
PositionWriteHandle pHandle(array, /*expand*/false);
PositionType P;
for (Index64 index = 0; index < count; ++index) {
P[0] = (spread * (rand01() - ValueType(0.5)));
P[1] = (spread * (rand01() - ValueType(0.5)));
P[2] = (spread * (rand01() - ValueType(0.5)));
pHandle.set(static_cast<Index>(index), P);
}
}
} // namespace point_scatter_internal
////////////////////////////////////////
template<
typename GridT,
typename RandGenT,
typename PositionArrayT,
typename PointDataGridT,
typename InterrupterT>
inline typename PointDataGridT::Ptr
uniformPointScatter(const GridT& grid,
const Index64 count,
const unsigned int seed,
const float spread,
InterrupterT* interrupter)
{
using PositionType = typename PositionArrayT::ValueType;
using PositionTraits = VecTraits<PositionType>;
using ValueType = typename PositionTraits::ElementType;
using CodecType = typename PositionArrayT::Codec;
using RandomGenerator = math::Rand01<ValueType, RandGenT>;
using TreeType = typename PointDataGridT::TreeType;
using LeafNodeType = typename TreeType::LeafNodeType;
using LeafManagerT = tree::LeafManager<TreeType>;
struct Local
{
/// @brief Get the prefixed voxel counts for each leaf node with an
/// additional value to represent the end voxel count.
/// See also LeafManager::getPrefixSum()
static void getPrefixSum(LeafManagerT& leafManager,
std::vector<Index64>& offsets)
{
Index64 offset = 0;
offsets.reserve(leafManager.leafCount() + 1);
offsets.push_back(0);
const auto leafRange = leafManager.leafRange();
for (auto leaf = leafRange.begin(); leaf; ++leaf) {
offset += leaf->onVoxelCount();
offsets.push_back(offset);
}
}
};
static_assert(PositionTraits::IsVec && PositionTraits::Size == 3,
"Invalid Position Array type.");
if (spread < 0.0f || spread > 1.0f) {
OPENVDB_THROW(ValueError, "Spread must be between 0 and 1.");
}
if (interrupter) interrupter->start("Uniform scattering with fixed point count");
typename PointDataGridT::Ptr points =
point_scatter_internal::initialisePointTopology<PointDataGridT>(grid);
TreeType& tree = points->tree();
if (!tree.cbeginLeaf()) return points;
LeafManagerT leafManager(tree);
const Index64 voxelCount = leafManager.activeLeafVoxelCount();
assert(voxelCount != 0);
const double pointsPerVolume = double(count) / double(voxelCount);
const Index32 pointsPerVoxel = static_cast<Index32>(math::RoundDown(pointsPerVolume));
const Index64 remainder = count - (pointsPerVoxel * voxelCount);
if (remainder == 0) {
return denseUniformPointScatter<
GridT, RandGenT, PositionArrayT, PointDataGridT, InterrupterT>(
grid, float(pointsPerVoxel), seed, spread, interrupter);
}
std::vector<Index64> voxelOffsets, values;
std::thread worker(&Local::getPrefixSum, std::ref(leafManager), std::ref(voxelOffsets));
{
math::RandInt<Index64, RandGenT> gen(seed, 0, voxelCount-1);
values.reserve(remainder);
for (Index64 i = 0; i < remainder; ++i) values.emplace_back(gen());
}
worker.join();
if (util::wasInterrupted<InterrupterT>(interrupter)) {
tree.clear();
return points;
}
tbb::parallel_sort(values.begin(), values.end());
const bool fractionalOnly(pointsPerVoxel == 0);
leafManager.foreach([&voxelOffsets, &values, fractionalOnly]
(LeafNodeType& leaf, const size_t idx)
{
const Index64 lowerOffset = voxelOffsets[idx]; // inclusive
const Index64 upperOffset = voxelOffsets[idx + 1]; // exclusive
assert(upperOffset > lowerOffset);
const auto valuesEnd = values.end();
auto lower = std::lower_bound(values.begin(), valuesEnd, lowerOffset);
auto* const data = leaf.buffer().data();
auto iter = leaf.beginValueOn();
Index32 currentOffset(0);
bool addedPoints(!fractionalOnly);
while (lower != valuesEnd) {
const Index64 vId = *lower;
if (vId >= upperOffset) break;
const Index32 nextOffset = Index32(vId - lowerOffset);
iter.increment(nextOffset - currentOffset);
currentOffset = nextOffset;
assert(iter);
auto& value = data[iter.pos()];
value = value + 1; // no += operator support
addedPoints = true;
++lower;
}
// deactivate this leaf if no points were added. This will speed up
// the unthreaded rng
if (!addedPoints) leaf.setValuesOff();
});
voxelOffsets.clear();
values.clear();
if (fractionalOnly) {
tools::pruneInactive(tree);
leafManager.rebuild();
}
const AttributeSet::Descriptor::Ptr descriptor =
AttributeSet::Descriptor::create(PositionArrayT::attributeType());
RandomGenerator rand01(seed);
const auto leafRange = leafManager.leafRange();
auto leaf = leafRange.begin();
for (; leaf; ++leaf) {
if (util::wasInterrupted<InterrupterT>(interrupter)) break;
Index32 offset(0);
for (auto iter = leaf->beginValueAll(); iter; ++iter) {
if (iter.isValueOn()) {
const Index32 value = Index32(pointsPerVolume + Index32(*iter));
if (value == 0) leaf->setValueOff(iter.pos());
else offset += value;
}
// @note can't use iter.setValue(offset) on point grids
leaf->setOffsetOnly(iter.pos(), offset);
}
// offset should always be non zero
assert(offset != 0);
point_scatter_internal::generatePositions<PositionType, CodecType>
(*leaf, descriptor, offset, spread, rand01);
}
// if interrupted, remove remaining leaf nodes
if (leaf) {
for (; leaf; ++leaf) leaf->setValuesOff();
tools::pruneInactive(tree);
}
if (interrupter) interrupter->end();
return points;
}
////////////////////////////////////////
template<
typename GridT,
typename RandGenT,
typename PositionArrayT,
typename PointDataGridT,
typename InterrupterT>
inline typename PointDataGridT::Ptr
denseUniformPointScatter(const GridT& grid,
const float pointsPerVoxel,
const unsigned int seed,
const float spread,
InterrupterT* interrupter)
{
using PositionType = typename PositionArrayT::ValueType;
using PositionTraits = VecTraits<PositionType>;
using ValueType = typename PositionTraits::ElementType;
using CodecType = typename PositionArrayT::Codec;
using RandomGenerator = math::Rand01<ValueType, RandGenT>;
using TreeType = typename PointDataGridT::TreeType;
static_assert(PositionTraits::IsVec && PositionTraits::Size == 3,
"Invalid Position Array type.");
if (pointsPerVoxel < 0.0f) {
OPENVDB_THROW(ValueError, "Points per voxel must not be less than zero.");
}
if (spread < 0.0f || spread > 1.0f) {
OPENVDB_THROW(ValueError, "Spread must be between 0 and 1.");
}
if (interrupter) interrupter->start("Dense uniform scattering with fixed point count");
typename PointDataGridT::Ptr points =
point_scatter_internal::initialisePointTopology<PointDataGridT>(grid);
TreeType& tree = points->tree();
auto leafIter = tree.beginLeaf();
if (!leafIter) return points;
const Index32 pointsPerVoxelInt = math::Floor(pointsPerVoxel);
const double delta = pointsPerVoxel - float(pointsPerVoxelInt);
const bool fractional = !math::isApproxZero(delta, 1.0e-6);
const bool fractionalOnly = pointsPerVoxelInt == 0;
const AttributeSet::Descriptor::Ptr descriptor =
AttributeSet::Descriptor::create(PositionArrayT::attributeType());
RandomGenerator rand01(seed);
for (; leafIter; ++leafIter) {
if (util::wasInterrupted<InterrupterT>(interrupter)) break;
Index32 offset(0);
for (auto iter = leafIter->beginValueAll(); iter; ++iter) {
if (iter.isValueOn()) {
offset += pointsPerVoxelInt;
if (fractional && rand01() < delta) ++offset;
else if (fractionalOnly) leafIter->setValueOff(iter.pos());
}
// @note can't use iter.setValue(offset) on point grids
leafIter->setOffsetOnly(iter.pos(), offset);
}
if (offset != 0) {
point_scatter_internal::generatePositions<PositionType, CodecType>
(*leafIter, descriptor, offset, spread, rand01);
}
}
// if interrupted, remove remaining leaf nodes
const bool prune(leafIter || fractionalOnly);
for (; leafIter; ++leafIter) leafIter->setValuesOff();
if (prune) tools::pruneInactive(tree);
if (interrupter) interrupter->end();
return points;
}
////////////////////////////////////////
template<
typename GridT,
typename RandGenT,
typename PositionArrayT,
typename PointDataGridT,
typename InterrupterT>
inline typename PointDataGridT::Ptr
nonUniformPointScatter(const GridT& grid,
const float pointsPerVoxel,
const unsigned int seed,
const float spread,
InterrupterT* interrupter)
{
using PositionType = typename PositionArrayT::ValueType;
using PositionTraits = VecTraits<PositionType>;
using ValueType = typename PositionTraits::ElementType;
using CodecType = typename PositionArrayT::Codec;
using RandomGenerator = math::Rand01<ValueType, RandGenT>;
using TreeType = typename PointDataGridT::TreeType;
static_assert(PositionTraits::IsVec && PositionTraits::Size == 3,
"Invalid Position Array type.");
static_assert(std::is_arithmetic<typename GridT::ValueType>::value,
"Scalar grid type required for weighted voxel scattering.");
if (pointsPerVoxel < 0.0f) {
OPENVDB_THROW(ValueError, "Points per voxel must not be less than zero.");
}
if (spread < 0.0f || spread > 1.0f) {
OPENVDB_THROW(ValueError, "Spread must be between 0 and 1.");
}
if (interrupter) interrupter->start("Non-uniform scattering with local point density");
typename PointDataGridT::Ptr points =
point_scatter_internal::initialisePointTopology<PointDataGridT>(grid);
TreeType& tree = points->tree();
auto leafIter = tree.beginLeaf();
if (!leafIter) return points;
const AttributeSet::Descriptor::Ptr descriptor =
AttributeSet::Descriptor::create(PositionArrayT::attributeType());
RandomGenerator rand01(seed);
const auto accessor = grid.getConstAccessor();
for (; leafIter; ++leafIter) {
if (util::wasInterrupted<InterrupterT>(interrupter)) break;
Index32 offset(0);
for (auto iter = leafIter->beginValueAll(); iter; ++iter) {
if (iter.isValueOn()) {
double fractional =
double(accessor.getValue(iter.getCoord())) * pointsPerVoxel;
fractional = std::max(0.0, fractional);
int count = int(fractional);
if (rand01() < (fractional - double(count))) ++count;
else if (count == 0) leafIter->setValueOff(iter.pos());
offset += count;
}
// @note can't use iter.setValue(offset) on point grids
leafIter->setOffsetOnly(iter.pos(), offset);
}
if (offset != 0) {
point_scatter_internal::generatePositions<PositionType, CodecType>
(*leafIter, descriptor, offset, spread, rand01);
}
}
// if interrupted, remove remaining leaf nodes
for (; leafIter; ++leafIter) leafIter->setValuesOff();
tools::pruneInactive(points->tree());
if (interrupter) interrupter->end();
return points;
}
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_SCATTER_HAS_BEEN_INCLUDED
| 20,847 | C | 36.563964 | 96 | 0.63731 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/AttributeArrayString.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/AttributeArrayString.h
///
/// @author Dan Bailey
///
/// @brief Attribute array storage for string data using Descriptor Metadata.
#ifndef OPENVDB_POINTS_ATTRIBUTE_ARRAY_STRING_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_ATTRIBUTE_ARRAY_STRING_HAS_BEEN_INCLUDED
#include "AttributeArray.h"
#include <memory>
#include <deque>
#include <unordered_map>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
////////////////////////////////////////
namespace attribute_traits
{
template <bool Truncate> struct StringTypeTrait { using Type = Index; };
template<> struct StringTypeTrait</*Truncate=*/true> { using Type = uint16_t; };
}
template <bool Truncate>
struct StringCodec
{
using ValueType = Index;
template <typename T>
struct Storage { using Type = typename attribute_traits::StringTypeTrait<Truncate>::Type; };
template<typename StorageType> static void decode(const StorageType&, ValueType&);
template<typename StorageType> static void encode(const ValueType&, StorageType&);
static const char* name() { return Truncate ? "str_trnc" : "str"; }
};
using StringAttributeArray = TypedAttributeArray<Index, StringCodec<false>>;
////////////////////////////////////////
/// Class to compute a string->index map from all string:N metadata
class OPENVDB_API StringMetaCache
{
public:
using UniquePtr = std::unique_ptr<StringMetaCache>;
using ValueMap = std::unordered_map<Name, Index>;
StringMetaCache() = default;
explicit StringMetaCache(const MetaMap& metadata);
/// Return @c true if no string elements in metadata
bool empty() const { return mCache.empty(); }
/// Returns the number of string elements in metadata
size_t size() const { return mCache.size(); }
/// Clears and re-populates the cache
void reset(const MetaMap& metadata);
/// Insert a new element in the cache
void insert(const Name& key, Index index);
/// Retrieve the value map (string -> index)
const ValueMap& map() const { return mCache; }
private:
ValueMap mCache;
}; // StringMetaCache
////////////////////////////////////////
/// Class to help with insertion of keyed string values into metadata
class OPENVDB_API StringMetaInserter
{
public:
using UniquePtr = std::unique_ptr<StringMetaInserter>;
explicit StringMetaInserter(MetaMap& metadata);
/// Returns @c true if key exists
bool hasKey(const Name& key) const;
/// Returns @c true if index exists
bool hasIndex(Index index) const;
/// @brief Insert the string into the metadata using the hint if non-zero
/// @param name the string to insert
/// @param hint requested index to use if non-zero and not already in use
/// @note the hint can be used to insert non-sequentially so as to avoid an
/// expensive re-indexing of string keys
/// @return the chosen index which will match hint if the hint was used
Index insert(const Name& name, Index hint = Index(0));
/// Reset the cache from the metadata
void resetCache();
private:
using IndexPairArray = std::deque<std::pair<Index, Index>>;
MetaMap& mMetadata;
IndexPairArray mIdBlocks;
StringMetaCache mCache;
}; // StringMetaInserter
////////////////////////////////////////
template <bool Truncate>
template<typename StorageType>
inline void
StringCodec<Truncate>::decode(const StorageType& data, ValueType& val)
{
val = static_cast<ValueType>(data);
}
template <bool Truncate>
template<typename StorageType>
inline void
StringCodec<Truncate>::encode(const ValueType& val, StorageType& data)
{
data = static_cast<ValueType>(val);
}
////////////////////////////////////////
inline bool isString(const AttributeArray& array)
{
return array.isType<StringAttributeArray>();
}
////////////////////////////////////////
class OPENVDB_API StringAttributeHandle
{
public:
using Ptr = std::shared_ptr<StringAttributeHandle>;//SharedPtr<StringAttributeHandle>;
using UniquePtr = std::unique_ptr<StringAttributeHandle>;
static Ptr create(const AttributeArray& array, const MetaMap& metadata, const bool preserveCompression = true);
StringAttributeHandle( const AttributeArray& array,
const MetaMap& metadata,
const bool preserveCompression = true);
Index stride() const { return mHandle.stride(); }
Index size() const { return mHandle.size(); }
bool isUniform() const { return mHandle.isUniform(); }
bool hasConstantStride() const { return mHandle.hasConstantStride(); }
Name get(Index n, Index m = 0) const;
void get(Name& name, Index n, Index m = 0) const;
/// @brief Returns a reference to the array held in the Handle.
const AttributeArray& array() const;
protected:
AttributeHandle<Index, StringCodec<false>> mHandle;
const MetaMap& mMetadata;
}; // class StringAttributeHandle
////////////////////////////////////////
class OPENVDB_API StringAttributeWriteHandle : public StringAttributeHandle
{
public:
using Ptr = std::shared_ptr<StringAttributeWriteHandle>;//SharedPtr<StringAttributeWriteHandle>;
using UniquePtr = std::unique_ptr<StringAttributeWriteHandle>;
static Ptr create(AttributeArray& array, const MetaMap& metadata, const bool expand = true);
StringAttributeWriteHandle( AttributeArray& array,
const MetaMap& metadata,
const bool expand = true);
/// @brief If this array is uniform, replace it with an array of length size().
/// @param fill if true, assign the uniform value to each element of the array.
void expand(bool fill = true);
/// @brief Set membership for the whole array and attempt to collapse
void collapse();
/// @brief Set membership for the whole array and attempt to collapse
/// @param name Name of the String
void collapse(const Name& name);
/// Compact the existing array to become uniform if all values are identical
bool compact();
/// @brief Fill the existing array with the given value.
/// @note Identical to collapse() except a non-uniform array will not become uniform.
void fill(const Name& name);
/// Set the value of the index to @a name
void set(Index n, const Name& name);
void set(Index n, Index m, const Name& name);
/// Reset the value cache from the metadata
void resetCache();
/// @brief Returns a reference to the array held in the Write Handle.
AttributeArray& array();
/// @brief Returns whether or not the metadata cache contains a given value.
/// @param name Name of the String.
bool contains(const Name& name) const;
private:
/// Retrieve the index of this string value from the cache
/// @note throws if name does not exist in cache
Index getIndex(const Name& name) const;
StringMetaCache mCache;
AttributeWriteHandle<Index, StringCodec<false>> mWriteHandle;
}; // class StringAttributeWriteHandle
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_ATTRIBUTE_ARRAY_STRING_HAS_BEEN_INCLUDED
| 7,418 | C | 28.915322 | 115 | 0.665543 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/AttributeArrayString.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/AttributeArrayString.cc
#include "AttributeArrayString.h"
#include <openvdb/Metadata.h>
#include <openvdb/MetaMap.h>
#include <tbb/parallel_sort.h>
#include <string>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
namespace {
Name getStringKey(const Index index)
{
return "string:" + std::to_string(index - 1);
}
} // namespace
////////////////////////////////////////
// StringMetaCache implementation
StringMetaCache::StringMetaCache(const MetaMap& metadata)
{
this->reset(metadata);
}
void StringMetaCache::insert(const Name& key, Index index)
{
mCache[key] = index;
}
void StringMetaCache::reset(const MetaMap& metadata)
{
mCache.clear();
// populate the cache
for (auto it = metadata.beginMeta(), itEnd = metadata.endMeta(); it != itEnd; ++it) {
const Name& key = it->first;
const Metadata::Ptr& meta = it->second;
// attempt to cast metadata to StringMetadata
const StringMetadata* stringMeta = dynamic_cast<StringMetadata*>(meta.get());
if (!stringMeta) continue;
// string attribute metadata must have a key that starts "string:"
if (key.compare(0, 7, "string:") != 0) continue;
// remove "string:" and cast to Index
Index index = 1 + static_cast<Index>(
std::stoul(key.substr(7, key.size() - 7)));
// add to the cache
this->insert(stringMeta->value(), index);
}
}
////////////////////////////////////////
// StringMetaInserter implementation
StringMetaInserter::StringMetaInserter(MetaMap& metadata)
: mMetadata(metadata)
, mIdBlocks()
, mCache()
{
// populate the cache
resetCache();
}
bool StringMetaInserter::hasKey(const Name& key) const
{
return mCache.map().find(key) != mCache.map().end();
}
bool StringMetaInserter::hasIndex(Index index) const
{
return bool(mMetadata[getStringKey(index)]);
}
Index StringMetaInserter::insert(const Name& name, Index hint)
{
using IterT = IndexPairArray::iterator;
// if name already exists, return the index
const auto& cacheMap = mCache.map();
auto it = cacheMap.find(name);
if (it != cacheMap.end()) {
return it->second;
}
Index index = 1;
Name hintKey;
bool canUseHint = false;
// hint must be non-zero to have been requested
if (hint > Index(0)) {
hintKey = getStringKey(hint);
// check if hint is already in use
if (!bool(mMetadata[hintKey])) {
canUseHint = true;
index = hint;
}
}
// look through the id blocks for hint or index
IterT iter = mIdBlocks.begin();
for (; iter != mIdBlocks.end(); ++iter) {
const Index start = iter->first;
const Index end = start + iter->second;
if (index < start || index >= end) break;
if (!canUseHint) index = end;
}
// index now holds the next valid index. if it's 1 (the beginning
// iterator) no initial block exists - add it
IterT prevIter;
if (iter == mIdBlocks.begin()) {
prevIter = mIdBlocks.emplace(iter, 1, 1);
iter = std::next(prevIter);
}
else {
// accumulate the id block size where the next index is going
prevIter = std::prev(iter);
prevIter->second++;
}
// see if this block and the next block can be compacted
if (iter != mIdBlocks.end() &&
prevIter->second + 1 == iter->first) {
prevIter->second += iter->second;
mIdBlocks.erase(iter);
}
// insert into metadata
const Name key = getStringKey(index);
mMetadata.insertMeta(key, StringMetadata(name));
// update the cache
mCache.insert(name, index);
return index;
}
void StringMetaInserter::resetCache()
{
mCache.reset(mMetadata);
mIdBlocks.clear();
std::vector<Index> stringIndices;
stringIndices.reserve(mCache.size());
if (mCache.empty()) return;
const auto& cacheMap = mCache.map();
for (auto it = cacheMap.cbegin(); it != cacheMap.cend(); ++it) {
const Index index = it->second;
stringIndices.emplace_back(index);
}
tbb::parallel_sort(stringIndices.begin(), stringIndices.end());
// bucket string indices
Index key = stringIndices.front();
Index size = 0;
// For each id, see if it's adjacent id is sequentially increasing and continue to
// track how many are until we find a value that isn't. Store the start and length
// of each of these blocks. For example, the following container could be created
// consisting of 3 elements:
// key -> size
// -------------
// 7 -> 1000 (values 7->1007)
// 1020 -> 5 (values 1020->1025)
// 2013 -> 30 (values 2013->2043)
// Note that the end value is exclusive (values 1007, 1025 and 2043 do not exist
// given the above example)
for (const Index id : stringIndices) {
if (key + size != id) {
assert(size > 0);
mIdBlocks.emplace_back(key, size);
size = 0;
key = id;
}
++size;
}
// add the last block
mIdBlocks.emplace_back(key, size);
}
////////////////////////////////////////
// StringAttributeHandle implementation
StringAttributeHandle::Ptr
StringAttributeHandle::create(const AttributeArray& array, const MetaMap& metadata, const bool preserveCompression)
{
return std::make_shared<StringAttributeHandle>(array, metadata, preserveCompression);
}
StringAttributeHandle::StringAttributeHandle(const AttributeArray& array,
const MetaMap& metadata,
const bool preserveCompression)
: mHandle(array, preserveCompression)
, mMetadata(metadata)
{
if (!isString(array)) {
OPENVDB_THROW(TypeError, "Cannot create a StringAttributeHandle for an attribute array that is not a string.");
}
}
Name StringAttributeHandle::get(Index n, Index m) const
{
Name name;
this->get(name, n, m);
return name;
}
void StringAttributeHandle::get(Name& name, Index n, Index m) const
{
Index index = mHandle.get(n, m);
// index zero is reserved for an empty string
if (index == 0) {
name = "";
return;
}
const Name key = getStringKey(index);
// key is assumed to exist in metadata
openvdb::StringMetadata::ConstPtr meta = mMetadata.getMetadata<StringMetadata>(key);
if (!meta) {
OPENVDB_THROW(LookupError, "String attribute cannot be found with index - \"" << index << "\".");
}
name = meta->value();
}
const AttributeArray& StringAttributeHandle::array() const
{
return mHandle.array();
}
////////////////////////////////////////
// StringAttributeWriteHandle implementation
StringAttributeWriteHandle::Ptr
StringAttributeWriteHandle::create(AttributeArray& array, const MetaMap& metadata, const bool expand)
{
return std::make_shared<StringAttributeWriteHandle>(array, metadata, expand);
}
StringAttributeWriteHandle::StringAttributeWriteHandle(AttributeArray& array,
const MetaMap& metadata,
const bool expand)
: StringAttributeHandle(array, metadata, /*preserveCompression=*/ false)
, mWriteHandle(array, expand)
{
// populate the cache
resetCache();
}
void StringAttributeWriteHandle::expand(bool fill)
{
mWriteHandle.expand(fill);
}
void StringAttributeWriteHandle::collapse()
{
// zero is used for an empty string
mWriteHandle.collapse(0);
}
void StringAttributeWriteHandle::collapse(const Name& name)
{
Index index = getIndex(name);
mWriteHandle.collapse(index);
}
bool StringAttributeWriteHandle::compact()
{
return mWriteHandle.compact();
}
void StringAttributeWriteHandle::fill(const Name& name)
{
Index index = getIndex(name);
mWriteHandle.fill(index);
}
void StringAttributeWriteHandle::set(Index n, const Name& name)
{
Index index = getIndex(name);
mWriteHandle.set(n, /*stride*/0, index);
}
void StringAttributeWriteHandle::set(Index n, Index m, const Name& name)
{
Index index = getIndex(name);
mWriteHandle.set(n, m, index);
}
void StringAttributeWriteHandle::resetCache()
{
mCache.reset(mMetadata);
}
AttributeArray& StringAttributeWriteHandle::array()
{
return mWriteHandle.array();
}
bool StringAttributeWriteHandle::contains(const Name& name) const
{
// empty strings always have an index at index zero
if (name.empty()) return true;
const auto& cacheMap = mCache.map();
return cacheMap.find(name) != cacheMap.end();
}
Index StringAttributeWriteHandle::getIndex(const Name& name) const
{
// zero used for an empty string
if (name.empty()) return Index(0);
const auto& cacheMap = mCache.map();
auto it = cacheMap.find(name);
if (it == cacheMap.end()) {
OPENVDB_THROW(LookupError, "String does not exist in Metadata, insert it and reset the cache - \"" << name << "\".");
}
return it->second;
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
| 9,454 | C++ | 22.461538 | 125 | 0.621007 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointGroup.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @author Dan Bailey
///
/// @file points/PointGroup.h
///
/// @brief Point group manipulation in a VDB Point Grid.
#ifndef OPENVDB_POINTS_POINT_GROUP_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_GROUP_HAS_BEEN_INCLUDED
#include <openvdb/openvdb.h>
#include "IndexIterator.h" // FilterTraits
#include "IndexFilter.h" // FilterTraits
#include "AttributeSet.h"
#include "PointDataGrid.h"
#include "PointAttribute.h"
#include "PointCount.h"
#include <tbb/parallel_reduce.h>
#include <algorithm>
#include <random>
#include <string>
#include <vector>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
/// @brief Delete any group that is not present in the Descriptor.
///
/// @param groups the vector of group names.
/// @param descriptor the descriptor that holds the group map.
inline void deleteMissingPointGroups( std::vector<std::string>& groups,
const AttributeSet::Descriptor& descriptor);
/// @brief Appends a new empty group to the VDB tree.
///
/// @param tree the PointDataTree to be appended to.
/// @param group name of the new group.
template <typename PointDataTree>
inline void appendGroup(PointDataTree& tree,
const Name& group);
/// @brief Appends new empty groups to the VDB tree.
///
/// @param tree the PointDataTree to be appended to.
/// @param groups names of the new groups.
template <typename PointDataTree>
inline void appendGroups(PointDataTree& tree,
const std::vector<Name>& groups);
/// @brief Drops an existing group from the VDB tree.
///
/// @param tree the PointDataTree to be dropped from.
/// @param group name of the group.
/// @param compact compact attributes if possible to reduce memory - if dropping
/// more than one group, compacting once at the end will be faster
template <typename PointDataTree>
inline void dropGroup( PointDataTree& tree,
const Name& group,
const bool compact = true);
/// @brief Drops existing groups from the VDB tree, the tree is compacted after dropping.
///
/// @param tree the PointDataTree to be dropped from.
/// @param groups names of the groups.
template <typename PointDataTree>
inline void dropGroups( PointDataTree& tree,
const std::vector<Name>& groups);
/// @brief Drops all existing groups from the VDB tree, the tree is compacted after dropping.
///
/// @param tree the PointDataTree to be dropped from.
template <typename PointDataTree>
inline void dropGroups( PointDataTree& tree);
/// @brief Compacts existing groups of a VDB Tree to use less memory if possible.
///
/// @param tree the PointDataTree to be compacted.
template <typename PointDataTree>
inline void compactGroups(PointDataTree& tree);
/// @brief Sets group membership from a PointIndexTree-ordered vector.
///
/// @param tree the PointDataTree.
/// @param indexTree the PointIndexTree.
/// @param membership @c 1 if the point is in the group, 0 otherwise.
/// @param group the name of the group.
/// @param remove if @c true also perform removal of points from the group.
///
/// @note vector<bool> is not thread-safe on concurrent write, so use vector<short> instead
template <typename PointDataTree, typename PointIndexTree>
inline void setGroup( PointDataTree& tree,
const PointIndexTree& indexTree,
const std::vector<short>& membership,
const Name& group,
const bool remove = false);
/// @brief Sets membership for the specified group for all points (on/off).
///
/// @param tree the PointDataTree.
/// @param group the name of the group.
/// @param member true / false for membership of the group.
template <typename PointDataTree>
inline void setGroup( PointDataTree& tree,
const Name& group,
const bool member = true);
/// @brief Sets group membership based on a provided filter.
///
/// @param tree the PointDataTree.
/// @param group the name of the group.
/// @param filter filter data that is used to create a per-leaf filter
template <typename PointDataTree, typename FilterT>
inline void setGroupByFilter( PointDataTree& tree,
const Name& group,
const FilterT& filter);
////////////////////////////////////////
namespace point_group_internal {
/// Copy a group attribute value from one group offset to another
template<typename PointDataTreeType>
struct CopyGroupOp {
using LeafManagerT = typename tree::LeafManager<PointDataTreeType>;
using LeafRangeT = typename LeafManagerT::LeafRange;
using GroupIndex = AttributeSet::Descriptor::GroupIndex;
CopyGroupOp(const GroupIndex& targetIndex,
const GroupIndex& sourceIndex)
: mTargetIndex(targetIndex)
, mSourceIndex(sourceIndex) { }
void operator()(const typename LeafManagerT::LeafRange& range) const {
for (auto leaf = range.begin(); leaf; ++leaf) {
GroupHandle sourceGroup = leaf->groupHandle(mSourceIndex);
GroupWriteHandle targetGroup = leaf->groupWriteHandle(mTargetIndex);
for (auto iter = leaf->beginIndexAll(); iter; ++iter) {
const bool groupOn = sourceGroup.get(*iter);
targetGroup.set(*iter, groupOn);
}
}
}
//////////
const GroupIndex mTargetIndex;
const GroupIndex mSourceIndex;
};
/// Set membership on or off for the specified group
template <typename PointDataTree, bool Member>
struct SetGroupOp
{
using LeafManagerT = typename tree::LeafManager<PointDataTree>;
using GroupIndex = AttributeSet::Descriptor::GroupIndex;
SetGroupOp(const AttributeSet::Descriptor::GroupIndex& index)
: mIndex(index) { }
void operator()(const typename LeafManagerT::LeafRange& range) const
{
for (auto leaf = range.begin(); leaf; ++leaf) {
// obtain the group attribute array
GroupWriteHandle group(leaf->groupWriteHandle(mIndex));
// set the group value
group.collapse(Member);
}
}
//////////
const GroupIndex& mIndex;
}; // struct SetGroupOp
template <typename PointDataTree, typename PointIndexTree, bool Remove>
struct SetGroupFromIndexOp
{
using LeafManagerT = typename tree::LeafManager<PointDataTree>;
using LeafRangeT = typename LeafManagerT::LeafRange;
using PointIndexLeafNode = typename PointIndexTree::LeafNodeType;
using IndexArray = typename PointIndexLeafNode::IndexArray;
using GroupIndex = AttributeSet::Descriptor::GroupIndex;
using MembershipArray = std::vector<short>;
SetGroupFromIndexOp(const PointIndexTree& indexTree,
const MembershipArray& membership,
const GroupIndex& index)
: mIndexTree(indexTree)
, mMembership(membership)
, mIndex(index) { }
void operator()(const typename LeafManagerT::LeafRange& range) const
{
for (auto leaf = range.begin(); leaf; ++leaf) {
// obtain the PointIndexLeafNode (using the origin of the current leaf)
const PointIndexLeafNode* pointIndexLeaf = mIndexTree.probeConstLeaf(leaf->origin());
if (!pointIndexLeaf) continue;
// obtain the group attribute array
GroupWriteHandle group(leaf->groupWriteHandle(mIndex));
// initialise the attribute storage
Index64 index = 0;
const IndexArray& indices = pointIndexLeaf->indices();
for (const Index64 i: indices) {
if (Remove) {
group.set(static_cast<Index>(index), mMembership[i]);
} else if (mMembership[i] == short(1)) {
group.set(static_cast<Index>(index), short(1));
}
index++;
}
// attempt to compact the array
group.compact();
}
}
//////////
const PointIndexTree& mIndexTree;
const MembershipArray& mMembership;
const GroupIndex& mIndex;
}; // struct SetGroupFromIndexOp
template <typename PointDataTree, typename FilterT, typename IterT = typename PointDataTree::LeafNodeType::ValueAllCIter>
struct SetGroupByFilterOp
{
using LeafManagerT = typename tree::LeafManager<PointDataTree>;
using LeafRangeT = typename LeafManagerT::LeafRange;
using LeafNodeT = typename PointDataTree::LeafNodeType;
using GroupIndex = AttributeSet::Descriptor::GroupIndex;
SetGroupByFilterOp( const GroupIndex& index, const FilterT& filter)
: mIndex(index)
, mFilter(filter) { }
void operator()(const typename LeafManagerT::LeafRange& range) const
{
for (auto leaf = range.begin(); leaf; ++leaf) {
// obtain the group attribute array
GroupWriteHandle group(leaf->groupWriteHandle(mIndex));
auto iter = leaf->template beginIndex<IterT, FilterT>(mFilter);
for (; iter; ++iter) {
group.set(*iter, true);
}
// attempt to compact the array
group.compact();
}
}
//////////
const GroupIndex& mIndex;
const FilterT& mFilter; // beginIndex takes a copy of mFilter
}; // struct SetGroupByFilterOp
////////////////////////////////////////
} // namespace point_group_internal
////////////////////////////////////////
inline void deleteMissingPointGroups( std::vector<std::string>& groups,
const AttributeSet::Descriptor& descriptor)
{
for (auto it = groups.begin(); it != groups.end();) {
if (!descriptor.hasGroup(*it)) it = groups.erase(it);
else ++it;
}
}
////////////////////////////////////////
template <typename PointDataTreeT>
inline void appendGroup(PointDataTreeT& tree, const Name& group)
{
if (group.empty()) {
OPENVDB_THROW(KeyError, "Cannot use an empty group name as a key.");
}
auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
auto descriptor = attributeSet.descriptorPtr();
// don't add if group already exists
if (descriptor->hasGroup(group)) return;
const bool hasUnusedGroup = descriptor->unusedGroups() > 0;
// add a new group attribute if there are no unused groups
if (!hasUnusedGroup) {
// find a new internal group name
const Name groupName = descriptor->uniqueName("__group");
descriptor = descriptor->duplicateAppend(groupName, GroupAttributeArray::attributeType());
const size_t pos = descriptor->find(groupName);
// insert new group attribute
tree::LeafManager<PointDataTreeT> leafManager(tree);
leafManager.foreach(
[&](typename PointDataTreeT::LeafNodeType& leaf, size_t /*idx*/) {
auto expected = leaf.attributeSet().descriptorPtr();
leaf.appendAttribute(*expected, descriptor, pos);
}, /*threaded=*/true
);
}
else {
// make the descriptor unique before we modify the group map
makeDescriptorUnique(tree);
descriptor = attributeSet.descriptorPtr();
}
// ensure that there are now available groups
assert(descriptor->unusedGroups() > 0);
// find next unused offset
const size_t offset = descriptor->unusedGroupOffset();
// add the group mapping to the descriptor
descriptor->setGroup(group, offset);
// if there was an unused group then we did not need to append a new attribute, so
// we must manually clear membership in the new group as its bits may have been
// previously set
if (hasUnusedGroup) setGroup(tree, group, false);
}
////////////////////////////////////////
template <typename PointDataTree>
inline void appendGroups(PointDataTree& tree,
const std::vector<Name>& groups)
{
// TODO: could be more efficient by appending multiple groups at once
// instead of one-by-one, however this is likely not that common a use case
for (const Name& name : groups) {
appendGroup(tree, name);
}
}
////////////////////////////////////////
template <typename PointDataTree>
inline void dropGroup(PointDataTree& tree, const Name& group, const bool compact)
{
using Descriptor = AttributeSet::Descriptor;
if (group.empty()) {
OPENVDB_THROW(KeyError, "Cannot use an empty group name as a key.");
}
auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
// make the descriptor unique before we modify the group map
makeDescriptorUnique(tree);
Descriptor::Ptr descriptor = attributeSet.descriptorPtr();
// now drop the group
descriptor->dropGroup(group);
if (compact) {
compactGroups(tree);
}
}
////////////////////////////////////////
template <typename PointDataTree>
inline void dropGroups( PointDataTree& tree,
const std::vector<Name>& groups)
{
for (const Name& name : groups) {
dropGroup(tree, name, /*compact=*/false);
}
// compaction done once for efficiency
compactGroups(tree);
}
////////////////////////////////////////
template <typename PointDataTree>
inline void dropGroups( PointDataTree& tree)
{
using Descriptor = AttributeSet::Descriptor;
auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
// make the descriptor unique before we modify the group map
makeDescriptorUnique(tree);
Descriptor::Ptr descriptor = attributeSet.descriptorPtr();
descriptor->clearGroups();
// find all indices for group attribute arrays
std::vector<size_t> indices = attributeSet.groupAttributeIndices();
// drop these attributes arrays
dropAttributes(tree, indices);
}
////////////////////////////////////////
template <typename PointDataTree>
inline void compactGroups(PointDataTree& tree)
{
using Descriptor = AttributeSet::Descriptor;
using GroupIndex = Descriptor::GroupIndex;
using LeafManagerT = typename tree::template LeafManager<PointDataTree>;
using point_group_internal::CopyGroupOp;
auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
// early exit if not possible to compact
if (!attributeSet.descriptor().canCompactGroups()) return;
// make the descriptor unique before we modify the group map
makeDescriptorUnique(tree);
Descriptor::Ptr descriptor = attributeSet.descriptorPtr();
// generate a list of group offsets and move them (one-by-one)
// TODO: improve this algorithm to move multiple groups per array at once
// though this is likely not that common a use case
Name sourceName;
size_t sourceOffset, targetOffset;
while (descriptor->requiresGroupMove(sourceName, sourceOffset, targetOffset)) {
const GroupIndex sourceIndex = attributeSet.groupIndex(sourceOffset);
const GroupIndex targetIndex = attributeSet.groupIndex(targetOffset);
CopyGroupOp<PointDataTree> copy(targetIndex, sourceIndex);
LeafManagerT leafManager(tree);
tbb::parallel_for(leafManager.leafRange(), copy);
descriptor->setGroup(sourceName, targetOffset);
}
// drop unused attribute arrays
const std::vector<size_t> indices = attributeSet.groupAttributeIndices();
const size_t totalAttributesToDrop = descriptor->unusedGroups() / descriptor->groupBits();
assert(totalAttributesToDrop <= indices.size());
const std::vector<size_t> indicesToDrop(indices.end() - totalAttributesToDrop,
indices.end());
dropAttributes(tree, indicesToDrop);
}
////////////////////////////////////////
template <typename PointDataTree, typename PointIndexTree>
inline void setGroup( PointDataTree& tree,
const PointIndexTree& indexTree,
const std::vector<short>& membership,
const Name& group,
const bool remove)
{
using Descriptor = AttributeSet::Descriptor;
using LeafManagerT = typename tree::template LeafManager<PointDataTree>;
using point_group_internal::SetGroupFromIndexOp;
auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
const Descriptor& descriptor = attributeSet.descriptor();
if (!descriptor.hasGroup(group)) {
OPENVDB_THROW(LookupError, "Group must exist on Tree before defining membership.");
}
{
// Check that that the largest index in the PointIndexTree is smaller than the size
// of the membership vector. The index tree will be used to lookup membership
// values. If the index tree was constructed with nan positions, this index will
// differ from the PointDataTree count
using IndexTreeManager = tree::LeafManager<const PointIndexTree>;
IndexTreeManager leafManager(indexTree);
const int64_t max = tbb::parallel_reduce(leafManager.leafRange(), -1,
[](const typename IndexTreeManager::LeafRange& range, int64_t value) -> int64_t {
for (auto leaf = range.begin(); leaf; ++leaf) {
auto it = std::max_element(leaf->indices().begin(), leaf->indices().end());
value = std::max(value, static_cast<int64_t>(*it));
}
return value;
},
[](const int64_t a, const int64_t b) {
return std::max(a, b);
}
);
if (max != -1 && membership.size() <= static_cast<size_t>(max)) {
OPENVDB_THROW(IndexError, "Group membership vector size must be larger than "
" the maximum index within the provided index tree.");
}
}
const Descriptor::GroupIndex index = attributeSet.groupIndex(group);
LeafManagerT leafManager(tree);
// set membership
if (remove) {
SetGroupFromIndexOp<PointDataTree, PointIndexTree, true>
set(indexTree, membership, index);
tbb::parallel_for(leafManager.leafRange(), set);
}
else {
SetGroupFromIndexOp<PointDataTree, PointIndexTree, false>
set(indexTree, membership, index);
tbb::parallel_for(leafManager.leafRange(), set);
}
}
////////////////////////////////////////
template <typename PointDataTree>
inline void setGroup( PointDataTree& tree,
const Name& group,
const bool member)
{
using Descriptor = AttributeSet::Descriptor;
using LeafManagerT = typename tree::template LeafManager<PointDataTree>;
using point_group_internal::SetGroupOp;
auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
const Descriptor& descriptor = attributeSet.descriptor();
if (!descriptor.hasGroup(group)) {
OPENVDB_THROW(LookupError, "Group must exist on Tree before defining membership.");
}
const Descriptor::GroupIndex index = attributeSet.groupIndex(group);
LeafManagerT leafManager(tree);
// set membership based on member variable
if (member) tbb::parallel_for(leafManager.leafRange(), SetGroupOp<PointDataTree, true>(index));
else tbb::parallel_for(leafManager.leafRange(), SetGroupOp<PointDataTree, false>(index));
}
////////////////////////////////////////
template <typename PointDataTree, typename FilterT>
inline void setGroupByFilter( PointDataTree& tree,
const Name& group,
const FilterT& filter)
{
using Descriptor = AttributeSet::Descriptor;
using LeafManagerT = typename tree::template LeafManager<PointDataTree>;
using point_group_internal::SetGroupByFilterOp;
auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
const Descriptor& descriptor = attributeSet.descriptor();
if (!descriptor.hasGroup(group)) {
OPENVDB_THROW(LookupError, "Group must exist on Tree before defining membership.");
}
const Descriptor::GroupIndex index = attributeSet.groupIndex(group);
// set membership using filter
SetGroupByFilterOp<PointDataTree, FilterT> set(index, filter);
LeafManagerT leafManager(tree);
tbb::parallel_for(leafManager.leafRange(), set);
}
////////////////////////////////////////
template <typename PointDataTree>
inline void setGroupByRandomTarget( PointDataTree& tree,
const Name& group,
const Index64 targetPoints,
const unsigned int seed = 0)
{
using RandomFilter = RandomLeafFilter<PointDataTree, std::mt19937>;
RandomFilter filter(tree, targetPoints, seed);
setGroupByFilter<PointDataTree, RandomFilter>(tree, group, filter);
}
////////////////////////////////////////
template <typename PointDataTree>
inline void setGroupByRandomPercentage( PointDataTree& tree,
const Name& group,
const float percentage = 10.0f,
const unsigned int seed = 0)
{
using RandomFilter = RandomLeafFilter<PointDataTree, std::mt19937>;
const int currentPoints = static_cast<int>(pointCount(tree));
const int targetPoints = int(math::Round((percentage * float(currentPoints))/100.0f));
RandomFilter filter(tree, targetPoints, seed);
setGroupByFilter<PointDataTree, RandomFilter>(tree, group, filter);
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_GROUP_HAS_BEEN_INCLUDED
| 22,542 | C | 30.008253 | 121 | 0.630201 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/IndexIterator.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/IndexIterator.h
///
/// @author Dan Bailey
///
/// @brief Index Iterators.
#ifndef OPENVDB_POINTS_INDEX_ITERATOR_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_INDEX_ITERATOR_HAS_BEEN_INCLUDED
#include <openvdb/version.h>
#include <openvdb/Types.h>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
/// @brief Count up the number of times the iterator can iterate
///
/// @param iter the iterator.
///
/// @note counting by iteration only performed where a dynamic filter is in use,
template <typename IterT>
inline Index64 iterCount(const IterT& iter);
////////////////////////////////////////
namespace index {
// Enum for informing early-exit optimizations
// PARTIAL - No optimizations are possible
// NONE - No indices to evaluate, can skip computation
// ALL - All indices to evaluate, can skip filtering
enum State
{
PARTIAL=0,
NONE,
ALL
};
}
/// @brief A no-op filter that can be used when iterating over all indices
/// @see points/IndexFilter.h for the documented interface for an index filter
class NullFilter
{
public:
static bool initialized() { return true; }
static index::State state() { return index::ALL; }
template <typename LeafT>
static index::State state(const LeafT&) { return index::ALL; }
template <typename LeafT> void reset(const LeafT&) { }
template <typename IterT> static bool valid(const IterT&) { return true; }
}; // class NullFilter
/// @brief A forward iterator over array indices in a single voxel
class ValueVoxelCIter
{
public:
struct Parent
{
Parent() = default;
explicit Parent(Index32 offset): mOffset(offset) { }
Index32 getValue(unsigned /*offset*/) const { return mOffset; }
private:
Index32 mOffset = 0;
}; // struct Parent
using NodeType = Parent;
ValueVoxelCIter() = default;
ValueVoxelCIter(Index32 prevOffset, Index32 offset)
: mOffset(offset), mParent(prevOffset) {}
ValueVoxelCIter(const ValueVoxelCIter& other)
: mOffset(other.mOffset), mParent(other.mParent), mValid(other.mValid) {}
/// @brief Return the item to which this iterator is currently pointing.
Index32 operator*() { return mOffset; }
Index32 operator*() const { return mOffset; }
/// @brief Advance to the next (valid) item (prefix).
ValueVoxelCIter& operator++() { mValid = false; return *this; }
operator bool() const { return mValid; }
bool test() const { return mValid; }
Index32 end() const { return mOffset+1; }
void reset(Index32 /*item*/, Index32 /*end*/) {}
Parent& parent() { return mParent; }
Index32 offset() { return mOffset; }
inline bool next() { this->operator++(); return this->test(); }
/// @brief For efficiency, Coord and active state assumed to be readily available
/// when iterating over indices of a single voxel
Coord getCoord [[noreturn]] () const {
OPENVDB_THROW(RuntimeError, "ValueVoxelCIter does not provide a valid Coord.");
}
void getCoord [[noreturn]] (Coord& /*coord*/) const {
OPENVDB_THROW(RuntimeError, "ValueVoxelCIter does not provide a valid Coord.");
}
bool isValueOn [[noreturn]] () const {
OPENVDB_THROW(RuntimeError, "ValueVoxelCIter does not test if voxel is active.");
}
/// @{
/// @brief Equality operators
bool operator==(const ValueVoxelCIter& other) const { return mOffset == other.mOffset; }
bool operator!=(const ValueVoxelCIter& other) const { return !this->operator==(other); }
/// @}
private:
Index32 mOffset = 0;
Parent mParent;
mutable bool mValid = true;
}; // class ValueVoxelCIter
/// @brief A forward iterator over array indices with filtering
/// IteratorT can be either IndexIter or ValueIndexIter (or some custom index iterator)
/// FilterT should be a struct or class with a valid() method than can be evaluated per index
/// Here's a simple filter example that only accepts even indices:
///
/// struct EvenIndexFilter
/// {
/// bool valid(const Index32 offset) const {
/// return (offset % 2) == 0;
/// }
/// };
///
template <typename IteratorT, typename FilterT>
class IndexIter
{
public:
/// @brief A forward iterator over array indices from a value iterator (such as ValueOnCIter)
class ValueIndexIter
{
public:
ValueIndexIter(const IteratorT& iter)
: mIter(iter), mParent(&mIter.parent())
{
if (mIter) {
assert(mParent);
Index32 start = (mIter.offset() > 0 ?
Index32(mParent->getValue(mIter.offset() - 1)) : Index32(0));
this->reset(start, *mIter);
if (mItem >= mEnd) this->operator++();
}
}
ValueIndexIter(const ValueIndexIter& other)
: mEnd(other.mEnd), mItem(other.mItem), mIter(other.mIter), mParent(other.mParent)
{
assert(mParent);
}
ValueIndexIter& operator=(const ValueIndexIter&) = default;
inline Index32 end() const { return mEnd; }
inline void reset(Index32 item, Index32 end) {
mItem = item;
mEnd = end;
}
/// @brief Returns the item to which this iterator is currently pointing.
inline Index32 operator*() { assert(mIter); return mItem; }
inline Index32 operator*() const { assert(mIter); return mItem; }
/// @brief Return @c true if this iterator is not yet exhausted.
inline operator bool() const { return mIter; }
inline bool test() const { return mIter; }
/// @brief Advance to the next (valid) item (prefix).
inline ValueIndexIter& operator++() {
++mItem;
while (mItem >= mEnd && mIter.next()) {
assert(mParent);
this->reset(mParent->getValue(mIter.offset() - 1), *mIter);
}
return *this;
}
/// @brief Advance to the next (valid) item.
inline bool next() { this->operator++(); return this->test(); }
inline bool increment() { this->next(); return this->test(); }
/// Return the coordinates of the item to which the value iterator is pointing.
inline Coord getCoord() const { assert(mIter); return mIter.getCoord(); }
/// Return in @a xyz the coordinates of the item to which the value iterator is pointing.
inline void getCoord(Coord& xyz) const { assert(mIter); xyz = mIter.getCoord(); }
/// @brief Return @c true if this iterator is pointing to an active value.
inline bool isValueOn() const { assert(mIter); return mIter.isValueOn(); }
/// Return the const value iterator
inline const IteratorT& valueIter() const { return mIter; }
/// @brief Equality operators
bool operator==(const ValueIndexIter& other) const { return mItem == other.mItem; }
bool operator!=(const ValueIndexIter& other) const { return !this->operator==(other); }
private:
Index32 mEnd = 0;
Index32 mItem = 0;
IteratorT mIter;
const typename IteratorT::NodeType* mParent;
}; // ValueIndexIter
IndexIter(const IteratorT& iterator, const FilterT& filter)
: mIterator(iterator)
, mFilter(filter)
{
if (!mFilter.initialized()) {
OPENVDB_THROW(RuntimeError,
"Filter needs to be initialized before constructing the iterator.");
}
if (mIterator) {
this->reset(*mIterator, mIterator.end());
}
}
IndexIter(const IndexIter& other)
: mIterator(other.mIterator)
, mFilter(other.mFilter)
{
if (!mFilter.initialized()) {
OPENVDB_THROW(RuntimeError,
"Filter needs to be initialized before constructing the iterator.");
}
}
IndexIter& operator=(const IndexIter& other)
{
if (&other != this) {
mIterator = other.mIterator;
mFilter = other.mFilter;
if (!mFilter.initialized()) {
OPENVDB_THROW(RuntimeError,
"Filter needs to be initialized before constructing the iterator.");
}
}
return *this;
}
Index32 end() const { return mIterator.end(); }
/// @brief Reset the begining and end of the iterator.
void reset(Index32 begin, Index32 end) {
mIterator.reset(begin, end);
while (mIterator.test() && !mFilter.template valid<ValueIndexIter>(mIterator)) {
++mIterator;
}
}
/// @brief Returns the item to which this iterator is currently pointing.
Index32 operator*() { assert(mIterator); return *mIterator; }
Index32 operator*() const { assert(mIterator); return *mIterator; }
/// @brief Return @c true if this iterator is not yet exhausted.
operator bool() const { return mIterator.test(); }
bool test() const { return mIterator.test(); }
/// @brief Advance to the next (valid) item (prefix).
IndexIter& operator++() {
while (true) {
++mIterator;
if (!mIterator.test() || mFilter.template valid<ValueIndexIter>(mIterator)) {
break;
}
}
return *this;
}
/// @brief Advance to the next (valid) item (postfix).
IndexIter operator++(int /*dummy*/) {
IndexIter newIterator(*this);
this->operator++();
return newIterator;
}
/// @brief Advance to the next (valid) item.
bool next() { this->operator++(); return this->test(); }
bool increment() { this->next(); return this->test(); }
/// Return the const filter
inline const FilterT& filter() const { return mFilter; }
/// Return the coordinates of the item to which the value iterator is pointing.
inline Coord getCoord() const { assert(mIterator); return mIterator.getCoord(); }
/// Return in @a xyz the coordinates of the item to which the value iterator is pointing.
inline void getCoord(Coord& xyz) const { assert(mIterator); xyz = mIterator.getCoord(); }
/// @brief Return @c true if the value iterator is pointing to an active value.
inline bool isValueOn() const { assert(mIterator); return mIterator.valueIter().isValueOn(); }
/// @brief Equality operators
bool operator==(const IndexIter& other) const { return mIterator == other.mIterator; }
bool operator!=(const IndexIter& other) const { return !this->operator==(other); }
private:
ValueIndexIter mIterator;
FilterT mFilter;
}; // class IndexIter
////////////////////////////////////////
template <typename IterT>
inline Index64 iterCount(const IterT& iter)
{
Index64 size = 0;
for (IterT newIter(iter); newIter; ++newIter, ++size) { }
return size;
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_INDEX_ITERATOR_HAS_BEEN_INCLUDED
| 11,115 | C | 32.684848 | 98 | 0.623032 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/StreamCompression.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/StreamCompression.h
///
/// @author Dan Bailey
///
/// @brief Convenience wrappers to using Blosc and reading and writing of Paged data.
///
/// Blosc is most effective with large (> ~256KB) blocks of data. Writing the entire
/// data block contiguously would provide the most optimal compression, however would
/// limit the ability to use delayed-loading as the whole block would be required to
/// be loaded from disk at once. To balance these two competing factors, Paging is used
/// to write out blocks of data that are a reasonable size for Blosc. These Pages are
/// loaded lazily, tracking the input stream pointers and creating Handles that reference
/// portions of the buffer. When the Page buffer is accessed, the data will be read from
/// the stream.
#ifndef OPENVDB_TOOLS_STREAM_COMPRESSION_HAS_BEEN_INCLUDED
#define OPENVDB_TOOLS_STREAM_COMPRESSION_HAS_BEEN_INCLUDED
#include <openvdb/io/io.h>
#include <tbb/spin_mutex.h>
#include <memory>
#include <string>
class TestStreamCompression;
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace compression {
// This is the minimum number of bytes below which Blosc compression is not used to
// avoid unecessary computation, as Blosc offers minimal compression until this limit
static const int BLOSC_MINIMUM_BYTES = 48;
// This is the minimum number of bytes below which the array is padded with zeros up
// to this number of bytes to allow Blosc to perform compression with small arrays
static const int BLOSC_PAD_BYTES = 128;
/// @brief Returns true if compression is available
OPENVDB_API bool bloscCanCompress();
/// @brief Retrieves the uncompressed size of buffer when uncompressed
///
/// @param buffer the compressed buffer
OPENVDB_API size_t bloscUncompressedSize(const char* buffer);
/// @brief Compress into the supplied buffer.
///
/// @param compressedBuffer the buffer to compress
/// @param compressedBytes number of compressed bytes
/// @param bufferBytes the number of bytes in compressedBuffer available to be filled
/// @param uncompressedBuffer the uncompressed buffer to compress
/// @param uncompressedBytes number of uncompressed bytes
OPENVDB_API void bloscCompress(char* compressedBuffer, size_t& compressedBytes,
const size_t bufferBytes, const char* uncompressedBuffer, const size_t uncompressedBytes);
/// @brief Compress and return the heap-allocated compressed buffer.
///
/// @param buffer the buffer to compress
/// @param uncompressedBytes number of uncompressed bytes
/// @param compressedBytes number of compressed bytes (written to this variable)
/// @param resize the compressed buffer will be exactly resized to remove the
/// portion used for Blosc overhead, for efficiency this can be
/// skipped if it is known that the resulting buffer is temporary
OPENVDB_API std::unique_ptr<char[]> bloscCompress(const char* buffer,
const size_t uncompressedBytes, size_t& compressedBytes, const bool resize = true);
/// @brief Convenience wrapper to retrieve the compressed size of buffer when compressed
///
/// @param buffer the uncompressed buffer
/// @param uncompressedBytes number of uncompressed bytes
OPENVDB_API size_t bloscCompressedSize(const char* buffer, const size_t uncompressedBytes);
/// @brief Decompress into the supplied buffer. Will throw if decompression fails or
/// uncompressed buffer has insufficient space in which to decompress.
///
/// @param uncompressedBuffer the uncompressed buffer to decompress into
/// @param expectedBytes the number of bytes expected once the buffer is decompressed
/// @param bufferBytes the number of bytes in uncompressedBuffer available to be filled
/// @param compressedBuffer the compressed buffer to decompress
OPENVDB_API void bloscDecompress(char* uncompressedBuffer, const size_t expectedBytes,
const size_t bufferBytes, const char* compressedBuffer);
/// @brief Decompress and return the the heap-allocated uncompressed buffer.
///
/// @param buffer the buffer to decompress
/// @param expectedBytes the number of bytes expected once the buffer is decompressed
/// @param resize the compressed buffer will be exactly resized to remove the
/// portion used for Blosc overhead, for efficiency this can be
/// skipped if it is known that the resulting buffer is temporary
OPENVDB_API std::unique_ptr<char[]> bloscDecompress(const char* buffer,
const size_t expectedBytes, const bool resize = true);
////////////////////////////////////////
// 1MB = 1048576 Bytes
static const int PageSize = 1024 * 1024;
/// @brief Stores a variable-size, compressed, delayed-load Page of data
/// that is loaded into memory when accessed. Access to the Page is
/// thread-safe as loading and decompressing the data is protected by a mutex.
class OPENVDB_API Page
{
private:
struct Info
{
io::MappedFile::Ptr mappedFile;
SharedPtr<io::StreamMetadata> meta;
std::streamoff filepos;
long compressedBytes;
long uncompressedBytes;
}; // Info
public:
using Ptr = std::shared_ptr<Page>;
Page() = default;
/// @brief load the Page into memory
void load() const;
/// @brief Uncompressed bytes of the Paged data, available
/// when the header has been read.
long uncompressedBytes() const;
/// @brief Retrieves a data pointer at the specific @param index
/// @note Will force a Page load when called.
const char* buffer(const int index) const;
/// @brief Read the Page header
void readHeader(std::istream&);
/// @brief Read the Page buffers. If @a delayed is true, stream
/// pointers will be stored to load the data lazily.
void readBuffers(std::istream&, bool delayed);
/// @brief Test if the data is out-of-core
bool isOutOfCore() const;
private:
/// @brief Convenience method to store a copy of the supplied buffer
void copy(const std::unique_ptr<char[]>& temp, int pageSize);
/// @brief Decompress and store the supplied data
void decompress(const std::unique_ptr<char[]>& temp);
/// @brief Thread-safe loading of the data
void doLoad() const;
std::unique_ptr<Info> mInfo = std::unique_ptr<Info>(new Info);
std::unique_ptr<char[]> mData;
tbb::spin_mutex mMutex;
}; // class Page
/// @brief A PageHandle holds a unique ptr to a Page and a specific stream
/// pointer to a point within the decompressed Page buffer
class OPENVDB_API PageHandle
{
public:
#if OPENVDB_ABI_VERSION_NUMBER >= 6
using Ptr = std::unique_ptr<PageHandle>;
#else
using Ptr = std::shared_ptr<PageHandle>;
#endif
/// @brief Create the page handle
/// @param page a shared ptr to the page that stores the buffer
/// @param index start position of the buffer to be read
/// @param size total size of the buffer to be read in bytes
PageHandle(const Page::Ptr& page, const int index, const int size);
/// @brief Retrieve a reference to the stored page
Page& page();
/// @brief Return the size of the buffer
int size() const { return mSize; }
/// @brief Read and return the buffer, loading and decompressing
/// the Page if necessary.
std::unique_ptr<char[]> read();
/// @brief Return a copy of this PageHandle
Ptr copy() { return Ptr(new PageHandle(mPage, mIndex, mSize)); }
protected:
friend class ::TestStreamCompression;
private:
Page::Ptr mPage;
int mIndex = -1;
int mSize = 0;
}; // class PageHandle
/// @brief A Paging wrapper to std::istream that is responsible for reading
/// from a given input stream and creating Page objects and PageHandles that
/// reference those pages for delayed reading.
class OPENVDB_API PagedInputStream
{
public:
using Ptr = std::shared_ptr<PagedInputStream>;
PagedInputStream() = default;
explicit PagedInputStream(std::istream& is);
/// @brief Size-only mode tags the stream as only reading size data.
void setSizeOnly(bool sizeOnly) { mSizeOnly = sizeOnly; }
bool sizeOnly() const { return mSizeOnly; }
// @brief Set and get the input stream
std::istream& getInputStream() { assert(mIs); return *mIs; }
void setInputStream(std::istream& is) { mIs = &is; }
/// @brief Creates a PageHandle to access the next @param n bytes of the Page.
PageHandle::Ptr createHandle(std::streamsize n);
/// @brief Takes a @a pageHandle and updates the referenced page with the
/// current stream pointer position and if @a delayed is false performs
/// an immediate read of the data.
void read(PageHandle::Ptr& pageHandle, std::streamsize n, bool delayed = true);
private:
int mByteIndex = 0;
int mUncompressedBytes = 0;
std::istream* mIs = nullptr;
Page::Ptr mPage;
bool mSizeOnly = false;
}; // class PagedInputStream
/// @brief A Paging wrapper to std::ostream that is responsible for writing
/// from a given output stream at intervals set by the PageSize. As Pages are
/// variable in size, they are flushed to disk as soon as sufficiently large.
class OPENVDB_API PagedOutputStream
{
public:
using Ptr = std::shared_ptr<PagedOutputStream>;
PagedOutputStream();
explicit PagedOutputStream(std::ostream& os);
/// @brief Size-only mode tags the stream as only writing size data.
void setSizeOnly(bool sizeOnly) { mSizeOnly = sizeOnly; }
bool sizeOnly() const { return mSizeOnly; }
/// @brief Set and get the output stream
std::ostream& getOutputStream() { assert(mOs); return *mOs; }
void setOutputStream(std::ostream& os) { mOs = &os; }
/// @brief Writes the given @param str buffer of size @param n
PagedOutputStream& write(const char* str, std::streamsize n);
/// @brief Manually flushes the current page to disk if non-zero
void flush();
private:
/// @brief Compress the @param buffer of @param size bytes and write
/// out to the stream.
void compressAndWrite(const char* buffer, size_t size);
/// @brief Resize the internal page buffer to @param size bytes
void resize(size_t size);
std::unique_ptr<char[]> mData = std::unique_ptr<char[]>(new char[PageSize]);
std::unique_ptr<char[]> mCompressedData = nullptr;
size_t mCapacity = PageSize;
int mBytes = 0;
std::ostream* mOs = nullptr;
bool mSizeOnly = false;
}; // class PagedOutputStream
} // namespace compression
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_TOOLS_STREAM_COMPRESSION_HAS_BEEN_INCLUDED
| 10,745 | C | 36.055172 | 94 | 0.707213 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/AttributeGroup.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/AttributeGroup.h
///
/// @author Dan Bailey
///
/// @brief Attribute Group access and filtering for iteration.
#ifndef OPENVDB_POINTS_ATTRIBUTE_GROUP_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_ATTRIBUTE_GROUP_HAS_BEEN_INCLUDED
#include "AttributeArray.h"
#include "AttributeSet.h"
#include <memory>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
////////////////////////////////////////
struct GroupCodec
{
using StorageType = GroupType;
using ValueType = GroupType;
template <typename T>
struct Storage { using Type = StorageType; };
static void decode(const StorageType&, ValueType&);
static void encode(const ValueType&, StorageType&);
static const char* name() { return "grp"; }
};
using GroupAttributeArray = TypedAttributeArray<GroupType, GroupCodec>;
////////////////////////////////////////
inline void
GroupCodec::decode(const StorageType& data, ValueType& val)
{
val = data;
}
inline void
GroupCodec::encode(const ValueType& val, StorageType& data)
{
data = val;
}
////////////////////////////////////////
inline bool isGroup(const AttributeArray& array)
{
return array.isType<GroupAttributeArray>();
}
////////////////////////////////////////
class OPENVDB_API GroupHandle
{
public:
using Ptr = std::shared_ptr<GroupHandle>;
using UniquePtr = std::unique_ptr<GroupHandle>;
// Dummy class that distinguishes an offset from a bitmask on construction
struct BitMask { };
using GroupIndex = std::pair<Index, uint8_t>;
GroupHandle(const GroupAttributeArray& array, const GroupType& offset);
GroupHandle(const GroupAttributeArray& array, const GroupType& bitMask, BitMask);
Index size() const { return mArray.size(); }
bool isUniform() const { return mArray.isUniform(); }
bool get(Index n) const;
bool getUnsafe(Index n) const;
protected:
const GroupAttributeArray& mArray;
const GroupType mBitMask;
}; // class GroupHandle
////////////////////////////////////////
class OPENVDB_API GroupWriteHandle : public GroupHandle
{
public:
using Ptr = std::shared_ptr<GroupWriteHandle>;
using UniquePtr = std::unique_ptr<GroupWriteHandle>;
GroupWriteHandle(GroupAttributeArray& array, const GroupType& offset);
/// Set @a on at the given index @a n
void set(Index n, bool on);
/// Set @a on at the given index @a n (assumes in-core and non-uniform)
void setUnsafe(Index n, bool on);
/// @brief Set membership for the whole array and attempt to collapse
///
/// @param on True or false for inclusion in group
///
/// @note This method guarantees that all attributes will have group membership
/// changed according to the input bool, however compaction will not be performed
/// if other groups that share the same underlying array are non-uniform.
/// The return value indicates if the group array ends up being uniform.
bool collapse(bool on);
/// Compact the existing array to become uniform if all values are identical
bool compact();
}; // class GroupWriteHandle
////////////////////////////////////////
/// Index filtering on group membership
class GroupFilter
{
public:
GroupFilter(const Name& name, const AttributeSet& attributeSet)
: mIndex(attributeSet.groupIndex(name)) { }
explicit GroupFilter(const AttributeSet::Descriptor::GroupIndex& index)
: mIndex(index) { }
inline bool initialized() const { return bool(mHandle); }
static index::State state() { return index::PARTIAL; }
template <typename LeafT>
static index::State state(const LeafT&) { return index::PARTIAL; }
template <typename LeafT>
void reset(const LeafT& leaf) {
mHandle.reset(new GroupHandle(leaf.groupHandle(mIndex)));
}
template <typename IterT>
bool valid(const IterT& iter) const {
assert(mHandle);
return mHandle->getUnsafe(*iter);
}
private:
const AttributeSet::Descriptor::GroupIndex mIndex;
GroupHandle::Ptr mHandle;
}; // class GroupFilter
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_ATTRIBUTE_GROUP_HAS_BEEN_INCLUDED
| 4,385 | C | 23.920454 | 85 | 0.659293 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/AttributeArray.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/AttributeArray.cc
#include "AttributeArray.h"
#include <map>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
////////////////////////////////////////
namespace {
using AttributeFactoryMap = std::map<NamePair, AttributeArray::FactoryMethod>;
struct LockedAttributeRegistry
{
tbb::spin_mutex mMutex;
AttributeFactoryMap mMap;
};
// Global function for accessing the registry
LockedAttributeRegistry*
getAttributeRegistry()
{
static LockedAttributeRegistry registry;
return ®istry;
}
} // unnamed namespace
////////////////////////////////////////
// AttributeArray::ScopedRegistryLock implementation
AttributeArray::ScopedRegistryLock::ScopedRegistryLock()
: lock(getAttributeRegistry()->mMutex)
{
}
////////////////////////////////////////
// AttributeArray implementation
#if OPENVDB_ABI_VERSION_NUMBER >= 6
#if OPENVDB_ABI_VERSION_NUMBER >= 7
AttributeArray::AttributeArray(const AttributeArray& rhs)
: AttributeArray(rhs, tbb::spin_mutex::scoped_lock(rhs.mMutex))
{
}
AttributeArray::AttributeArray(const AttributeArray& rhs, const tbb::spin_mutex::scoped_lock&)
#else
AttributeArray::AttributeArray(const AttributeArray& rhs)
#endif
: mIsUniform(rhs.mIsUniform)
, mFlags(rhs.mFlags)
, mUsePagedRead(rhs.mUsePagedRead)
, mOutOfCore(rhs.mOutOfCore)
, mPageHandle()
{
if (mFlags & PARTIALREAD) mCompressedBytes = rhs.mCompressedBytes;
else if (rhs.mPageHandle) mPageHandle = rhs.mPageHandle->copy();
}
AttributeArray&
AttributeArray::operator=(const AttributeArray& rhs)
{
// if this AttributeArray has been partially read, zero the compressed bytes,
// so the page handle won't attempt to clean up invalid memory
if (mFlags & PARTIALREAD) mCompressedBytes = 0;
mIsUniform = rhs.mIsUniform;
mFlags = rhs.mFlags;
mUsePagedRead = rhs.mUsePagedRead;
mOutOfCore = rhs.mOutOfCore;
if (mFlags & PARTIALREAD) mCompressedBytes = rhs.mCompressedBytes;
else if (rhs.mPageHandle) mPageHandle = rhs.mPageHandle->copy();
else mPageHandle.reset();
return *this;
}
#endif
AttributeArray::Ptr
AttributeArray::create(const NamePair& type, Index length, Index stride,
bool constantStride, const Metadata* metadata, const ScopedRegistryLock* lock)
{
auto* registry = getAttributeRegistry();
tbb::spin_mutex::scoped_lock _lock;
if (!lock) _lock.acquire(registry->mMutex);
auto iter = registry->mMap.find(type);
if (iter == registry->mMap.end()) {
OPENVDB_THROW(LookupError,
"Cannot create attribute of unregistered type " << type.first << "_" << type.second);
}
return (iter->second)(length, stride, constantStride, metadata);
}
bool
AttributeArray::isRegistered(const NamePair& type, const ScopedRegistryLock* lock)
{
LockedAttributeRegistry* registry = getAttributeRegistry();
tbb::spin_mutex::scoped_lock _lock;
if (!lock) _lock.acquire(registry->mMutex);
return (registry->mMap.find(type) != registry->mMap.end());
}
void
AttributeArray::clearRegistry(const ScopedRegistryLock* lock)
{
LockedAttributeRegistry* registry = getAttributeRegistry();
tbb::spin_mutex::scoped_lock _lock;
if (!lock) _lock.acquire(registry->mMutex);
registry->mMap.clear();
}
void
AttributeArray::registerType(const NamePair& type, FactoryMethod factory, const ScopedRegistryLock* lock)
{
{ // check the type of the AttributeArray generated by the factory method
auto array = (*factory)(/*length=*/0, /*stride=*/0, /*constantStride=*/false, /*metadata=*/nullptr);
const NamePair& factoryType = array->type();
if (factoryType != type) {
OPENVDB_THROW(KeyError, "Attribute type " << type.first << "_" << type.second
<< " does not match the type created by the factory method "
<< factoryType.first << "_" << factoryType.second << ".");
}
}
LockedAttributeRegistry* registry = getAttributeRegistry();
tbb::spin_mutex::scoped_lock _lock;
if (!lock) _lock.acquire(registry->mMutex);
registry->mMap[type] = factory;
}
void
AttributeArray::unregisterType(const NamePair& type, const ScopedRegistryLock* lock)
{
LockedAttributeRegistry* registry = getAttributeRegistry();
tbb::spin_mutex::scoped_lock _lock;
if (!lock) _lock.acquire(registry->mMutex);
registry->mMap.erase(type);
}
void
AttributeArray::setTransient(bool state)
{
if (state) mFlags = static_cast<uint8_t>(mFlags | Int16(TRANSIENT));
else mFlags = static_cast<uint8_t>(mFlags & ~Int16(TRANSIENT));
}
void
AttributeArray::setHidden(bool state)
{
if (state) mFlags = static_cast<uint8_t>(mFlags | Int16(HIDDEN));
else mFlags = static_cast<uint8_t>(mFlags & ~Int16(HIDDEN));
}
void
AttributeArray::setStreaming(bool state)
{
if (state) mFlags = static_cast<uint8_t>(mFlags | Int16(STREAMING));
else mFlags = static_cast<uint8_t>(mFlags & ~Int16(STREAMING));
}
void
AttributeArray::setConstantStride(bool state)
{
if (state) mFlags = static_cast<uint8_t>(mFlags | Int16(CONSTANTSTRIDE));
else mFlags = static_cast<uint8_t>(mFlags & ~Int16(CONSTANTSTRIDE));
}
bool
AttributeArray::operator==(const AttributeArray& other) const
{
this->loadData();
other.loadData();
if (this->mUsePagedRead != other.mUsePagedRead ||
this->mFlags != other.mFlags) return false;
return this->isEqual(other);
}
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
| 5,735 | C++ | 26.184834 | 108 | 0.678989 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointAdvect.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @author Dan Bailey
///
/// @file points/PointAdvect.h
///
/// @brief Ability to advect VDB Points through a velocity field.
#ifndef OPENVDB_POINTS_POINT_ADVECT_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_ADVECT_HAS_BEEN_INCLUDED
#include <openvdb/openvdb.h>
#include <openvdb/tools/Prune.h>
#include <openvdb/tools/VelocityFields.h>
#include <openvdb/points/AttributeGroup.h>
#include <openvdb/points/PointDataGrid.h>
#include <openvdb/points/PointGroup.h>
#include <openvdb/points/PointMove.h>
#include <memory>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
/// @brief Advect points in a PointDataGrid through a velocity grid
/// @param points the PointDataGrid containing the points to be advected.
/// @param velocity a velocity grid to be sampled.
/// @param integrationOrder the integration scheme to use (1 is forward euler, 4 is runge-kutta 4th)
/// @param dt delta time.
/// @param timeSteps number of advection steps to perform.
/// @param advectFilter an optional advection index filter (moves a subset of the points)
/// @param filter an optional index filter (deletes a subset of the points)
/// @param cached caches velocity interpolation for faster performance, disable to use
/// less memory (default is on).
template <typename PointDataGridT, typename VelGridT,
typename AdvectFilterT = NullFilter, typename FilterT = NullFilter>
inline void advectPoints(PointDataGridT& points, const VelGridT& velocity,
const Index integrationOrder, const double dt, const Index timeSteps,
const AdvectFilterT& advectFilter = NullFilter(),
const FilterT& filter = NullFilter(),
const bool cached = true);
////////////////////////////////////////
namespace point_advect_internal {
enum IntegrationOrder {
INTEGRATION_ORDER_FWD_EULER = 1,
INTEGRATION_ORDER_RK_2ND,
INTEGRATION_ORDER_RK_3RD,
INTEGRATION_ORDER_RK_4TH
};
template <typename VelGridT, Index IntegrationOrder, bool Staggered, typename FilterT>
class AdvectionDeformer
{
public:
using IntegratorT = openvdb::tools::VelocityIntegrator<VelGridT, Staggered>;
AdvectionDeformer(const VelGridT& velocityGrid, const double timeStep, const int steps,
const FilterT& filter)
: mIntegrator(velocityGrid)
, mTimeStep(timeStep)
, mSteps(steps)
, mFilter(filter) { }
template <typename LeafT>
void reset(const LeafT& leaf, size_t /*idx*/)
{
mFilter.reset(leaf);
}
template <typename IndexIterT>
void apply(Vec3d& position, const IndexIterT& iter) const
{
if (mFilter.valid(iter)) {
for (int n = 0; n < mSteps; ++n) {
mIntegrator.template rungeKutta<IntegrationOrder, openvdb::Vec3d>(
static_cast<typename IntegratorT::ElementType>(mTimeStep), position);
}
}
}
private:
IntegratorT mIntegrator;
double mTimeStep;
const int mSteps;
FilterT mFilter;
}; // class AdvectionDeformer
template <typename PointDataGridT, typename VelGridT, typename AdvectFilterT, typename FilterT>
struct AdvectionOp
{
using CachedDeformerT = CachedDeformer<double>;
AdvectionOp(PointDataGridT& points, const VelGridT& velocity,
const Index integrationOrder, const double timeStep, const Index steps,
const AdvectFilterT& advectFilter,
const FilterT& filter)
: mPoints(points)
, mVelocity(velocity)
, mIntegrationOrder(integrationOrder)
, mTimeStep(timeStep)
, mSteps(steps)
, mAdvectFilter(advectFilter)
, mFilter(filter) { }
void cache()
{
mCachedDeformer.reset(new CachedDeformerT(mCache));
(*this)(true);
}
void advect()
{
(*this)(false);
}
private:
template <int IntegrationOrder, bool Staggered>
void resolveIntegrationOrder(bool buildCache)
{
const auto leaf = mPoints.constTree().cbeginLeaf();
if (!leaf) return;
// move points according to the pre-computed cache
if (!buildCache && mCachedDeformer) {
movePoints(mPoints, *mCachedDeformer, mFilter);
return;
}
NullFilter nullFilter;
if (buildCache) {
// disable group filtering from the advection deformer and perform group filtering
// in the cache deformer instead, this restricts the cache to just containing
// positions from points which are both deforming *and* are not being deleted
AdvectionDeformer<VelGridT, IntegrationOrder, Staggered, NullFilter> deformer(
mVelocity, mTimeStep, mSteps, nullFilter);
if (mFilter.state() == index::ALL && mAdvectFilter.state() == index::ALL) {
mCachedDeformer->evaluate(mPoints, deformer, nullFilter);
} else {
BinaryFilter<AdvectFilterT, FilterT, /*And=*/true> binaryFilter(
mAdvectFilter, mFilter);
mCachedDeformer->evaluate(mPoints, deformer, binaryFilter);
}
}
else {
// revert to NullFilter if all points are being evaluated
if (mAdvectFilter.state() == index::ALL) {
AdvectionDeformer<VelGridT, IntegrationOrder, Staggered, NullFilter> deformer(
mVelocity, mTimeStep, mSteps, nullFilter);
movePoints(mPoints, deformer, mFilter);
}
else {
AdvectionDeformer<VelGridT, IntegrationOrder, Staggered, AdvectFilterT> deformer(
mVelocity, mTimeStep, mSteps, mAdvectFilter);
movePoints(mPoints, deformer, mFilter);
}
}
}
template <bool Staggered>
void resolveStaggered(bool buildCache)
{
if (mIntegrationOrder == INTEGRATION_ORDER_FWD_EULER) {
resolveIntegrationOrder<1, Staggered>(buildCache);
} else if (mIntegrationOrder == INTEGRATION_ORDER_RK_2ND) {
resolveIntegrationOrder<2, Staggered>(buildCache);
} else if (mIntegrationOrder == INTEGRATION_ORDER_RK_3RD) {
resolveIntegrationOrder<3, Staggered>(buildCache);
} else if (mIntegrationOrder == INTEGRATION_ORDER_RK_4TH) {
resolveIntegrationOrder<4, Staggered>(buildCache);
}
}
void operator()(bool buildCache)
{
// early-exit if no leafs
if (mPoints.constTree().leafCount() == 0) return;
if (mVelocity.getGridClass() == openvdb::GRID_STAGGERED) {
resolveStaggered<true>(buildCache);
} else {
resolveStaggered<false>(buildCache);
}
}
PointDataGridT& mPoints;
const VelGridT& mVelocity;
const Index mIntegrationOrder;
const double mTimeStep;
const Index mSteps;
const AdvectFilterT& mAdvectFilter;
const FilterT& mFilter;
CachedDeformerT::Cache mCache;
std::unique_ptr<CachedDeformerT> mCachedDeformer;
}; // struct AdvectionOp
} // namespace point_advect_internal
////////////////////////////////////////
template <typename PointDataGridT, typename VelGridT, typename AdvectFilterT, typename FilterT>
inline void advectPoints(PointDataGridT& points, const VelGridT& velocity,
const Index integrationOrder, const double timeStep, const Index steps,
const AdvectFilterT& advectFilter,
const FilterT& filter,
const bool cached)
{
using namespace point_advect_internal;
if (steps == 0) return;
if (integrationOrder > 4) {
throw ValueError{"Unknown integration order for advecting points."};
}
AdvectionOp<PointDataGridT, VelGridT, AdvectFilterT, FilterT> op(
points, velocity, integrationOrder, timeStep, steps,
advectFilter, filter);
// if caching is enabled, sample the velocity field using a CachedDeformer to store the
// intermediate positions before moving the points, this uses more memory but typically
// results in faster overall performance
if (cached) op.cache();
// advect the points
op.advect();
}
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_ADVECT_HAS_BEEN_INCLUDED
| 8,666 | C | 33.947581 | 104 | 0.639626 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/AttributeSet.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/AttributeSet.h
///
/// @authors Dan Bailey, Mihai Alden
///
/// @brief Set of Attribute Arrays which tracks metadata about each array.
#ifndef OPENVDB_POINTS_ATTRIBUTE_SET_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_ATTRIBUTE_SET_HAS_BEEN_INCLUDED
#include "AttributeArray.h"
#include <openvdb/version.h>
#include <openvdb/MetaMap.h>
#include <limits>
#include <memory>
#include <vector>
class TestAttributeSet;
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
using GroupType = uint8_t;
////////////////////////////////////////
/// Ordered collection of uniquely-named attribute arrays
class OPENVDB_API AttributeSet
{
public:
enum { INVALID_POS = std::numeric_limits<size_t>::max() };
using Ptr = std::shared_ptr<AttributeSet>;
using ConstPtr = std::shared_ptr<const AttributeSet>;
using UniquePtr = std::unique_ptr<AttributeSet>;
class Descriptor;
using DescriptorPtr = std::shared_ptr<Descriptor>;
using DescriptorConstPtr = std::shared_ptr<const Descriptor>;
//////////
struct Util
{
/// Attribute and type name pair.
struct NameAndType {
NameAndType(const std::string& n, const NamePair& t, const Index s = 1)
: name(n), type(t), stride(s) {}
Name name;
NamePair type;
Index stride;
};
using NameAndTypeVec = std::vector<NameAndType>;
using NameToPosMap = std::map<std::string, size_t>;
using GroupIndex = std::pair<size_t, uint8_t>;
};
//////////
AttributeSet();
/// Construct a new AttributeSet from the given AttributeSet.
/// @param attributeSet the old attribute set
/// @param arrayLength the desired length of the arrays in the new AttributeSet
/// @param lock an optional scoped registry lock to avoid contention
/// @note This constructor is typically used to resize an existing AttributeSet as
/// it transfers attribute metadata such as hidden and transient flags
AttributeSet(const AttributeSet& attributeSet, Index arrayLength,
const AttributeArray::ScopedRegistryLock* lock = nullptr);
/// Construct a new AttributeSet from the given Descriptor.
/// @param descriptor stored in the new AttributeSet and used in construction
/// @param arrayLength the desired length of the arrays in the new AttributeSet
/// @param lock an optional scoped registry lock to avoid contention
/// @note Descriptors do not store attribute metadata such as hidden and transient flags
/// which live on the AttributeArrays, so for constructing from an existing AttributeSet
/// use the AttributeSet(const AttributeSet&, Index) constructor instead
AttributeSet(const DescriptorPtr& descriptor, Index arrayLength = 1,
const AttributeArray::ScopedRegistryLock* lock = nullptr);
/// Shallow copy constructor, the descriptor and attribute arrays will be shared.
AttributeSet(const AttributeSet&);
/// Disallow copy assignment, since it wouldn't be obvious whether the copy is deep or shallow.
AttributeSet& operator=(const AttributeSet&) = delete;
//@{
/// @brief Return a reference to this attribute set's descriptor, which might
/// be shared with other sets.
Descriptor& descriptor() { return *mDescr; }
const Descriptor& descriptor() const { return *mDescr; }
//@}
/// @brief Return a pointer to this attribute set's descriptor, which might be
/// shared with other sets
DescriptorPtr descriptorPtr() const { return mDescr; }
/// Return the number of attributes in this set.
size_t size() const { return mAttrs.size(); }
/// Return the number of bytes of memory used by this attribute set.
size_t memUsage() const;
/// @brief Return the position of the attribute array whose name is @a name,
/// or @c INVALID_POS if no match is found.
size_t find(const std::string& name) const;
/// @brief Replace the attribute array whose name is @a name.
/// @return The position of the updated attribute array or @c INVALID_POS
/// if the given name does not exist or if the replacement failed because
/// the new array type does not comply with the descriptor.
size_t replace(const std::string& name, const AttributeArray::Ptr&);
/// @brief Replace the attribute array stored at position @a pos in this container.
/// @return The position of the updated attribute array or @c INVALID_POS
/// if replacement failed because the new array type does not comply with
/// the descriptor.
size_t replace(size_t pos, const AttributeArray::Ptr&);
//@{
/// @brief Return a pointer to the attribute array whose name is @a name or
/// a null pointer if no match is found.
const AttributeArray* getConst(const std::string& name) const;
const AttributeArray* get(const std::string& name) const;
AttributeArray* get(const std::string& name);
//@}
//@{
/// @brief Return a pointer to the attribute array stored at position @a pos
/// in this set.
const AttributeArray* getConst(size_t pos) const;
const AttributeArray* get(size_t pos) const;
AttributeArray* get(size_t pos);
//@}
//@{
/// @brief Return the group offset from the name or index of the group
/// A group attribute array is a single byte (8-bit), each bit of which
/// can denote a group. The group offset is the position of the bit that
/// denotes the requested group if all group attribute arrays in the set
/// (and only attribute arrays marked as group) were to be laid out linearly
/// according to their order in the set.
size_t groupOffset(const Name& groupName) const;
size_t groupOffset(const Util::GroupIndex& index) const;
//@}
/// Return the group index from the name of the group
Util::GroupIndex groupIndex(const Name& groupName) const;
/// Return the group index from the offset of the group
/// @note see offset description for groupOffset()
Util::GroupIndex groupIndex(const size_t offset) const;
/// Return the indices of the attribute arrays which are group attribute arrays
std::vector<size_t> groupAttributeIndices() const;
/// Return true if the attribute array stored at position @a pos is shared.
bool isShared(size_t pos) const;
/// @brief If the attribute array stored at position @a pos is shared,
/// replace the array with a deep copy of itself that is not
/// shared with anyone else.
void makeUnique(size_t pos);
/// Append attribute @a attribute (simple method)
AttributeArray::Ptr appendAttribute(const Name& name,
const NamePair& type,
const Index strideOrTotalSize = 1,
const bool constantStride = true,
const Metadata* defaultValue = nullptr);
/// Append attribute @a attribute (descriptor-sharing)
/// Requires current descriptor to match @a expected
/// On append, current descriptor is replaced with @a replacement
/// Provide a @a lock object to avoid contention from appending in parallel
AttributeArray::Ptr appendAttribute(const Descriptor& expected, DescriptorPtr& replacement,
const size_t pos, const Index strideOrTotalSize = 1,
const bool constantStride = true,
const Metadata* defaultValue = nullptr,
const AttributeArray::ScopedRegistryLock* lock = nullptr);
/// @brief Remove and return an attribute array by name
/// @param name the name of the attribute array to release
/// @details Detaches the attribute array from this attribute set and returns it, if
/// @a name is invalid, returns an empty shared pointer. This also updates the descriptor
/// to remove the reference to the attribute array.
/// @note AttributeArrays are stored as shared pointers, so they are not guaranteed
/// to be unique. Check the reference count before blindly re-using in a new AttributeSet.
AttributeArray::Ptr removeAttribute(const Name& name);
/// @brief Remove and return an attribute array by index
/// @param pos the position index of the attribute to release
/// @details Detaches the attribute array from this attribute set and returns it, if
/// @a pos is invalid, returns an empty shared pointer. This also updates the descriptor
/// to remove the reference to the attribute array.
/// @note AttributeArrays are stored as shared pointers, so they are not guaranteed
/// to be unique. Check the reference count before blindly re-using in a new AttributeSet.
AttributeArray::Ptr removeAttribute(const size_t pos);
/// @brief Remove and return an attribute array by index (unsafe method)
/// @param pos the position index of the attribute to release
/// @details Detaches the attribute array from this attribute set and returns it, if
/// @a pos is invalid, returns an empty shared pointer.
/// In cases where the AttributeSet is due to be destroyed, a small performance
/// advantage can be gained by leaving the attribute array as a nullptr and not
/// updating the descriptor. However, this leaves the AttributeSet in an invalid
/// state making it unsafe to call any methods that implicitly derefence the attribute array.
/// @note AttributeArrays are stored as shared pointers, so they are not guaranteed
/// to be unique. Check the reference count before blindly re-using in a new AttributeSet.
/// @warning Only use this method if you're an expert and know the risks of not
/// updating the array of attributes or the descriptor.
AttributeArray::Ptr removeAttributeUnsafe(const size_t pos);
/// Drop attributes with @a pos indices (simple method)
/// Creates a new descriptor for this attribute set
void dropAttributes(const std::vector<size_t>& pos);
/// Drop attributes with @a pos indices (descriptor-sharing method)
/// Requires current descriptor to match @a expected
/// On drop, current descriptor is replaced with @a replacement
void dropAttributes(const std::vector<size_t>& pos,
const Descriptor& expected, DescriptorPtr& replacement);
/// Re-name attributes in set to match a provided descriptor
/// Replaces own descriptor with @a replacement
void renameAttributes(const Descriptor& expected, const DescriptorPtr& replacement);
/// Re order attribute set to match a provided descriptor
/// Replaces own descriptor with @a replacement
void reorderAttributes(const DescriptorPtr& replacement);
/// Replace the current descriptor with a @a replacement
/// Note the provided Descriptor must be identical to the replacement
/// unless @a allowMismatchingDescriptors is true (default is false)
void resetDescriptor(const DescriptorPtr& replacement, const bool allowMismatchingDescriptors = false);
/// Read the entire set from a stream.
void read(std::istream&);
/// Write the entire set to a stream.
/// @param outputTransient if true, write out transient attributes
void write(std::ostream&, bool outputTransient = false) const;
/// This will read the attribute descriptor from a stream.
void readDescriptor(std::istream&);
/// This will write the attribute descriptor to a stream.
/// @param outputTransient if true, write out transient attributes
void writeDescriptor(std::ostream&, bool outputTransient = false) const;
/// This will read the attribute metadata from a stream.
void readMetadata(std::istream&);
/// This will write the attribute metadata to a stream.
/// @param outputTransient if true, write out transient attributes
/// @param paged if true, data is written out in pages
void writeMetadata(std::ostream&, bool outputTransient = false, bool paged = false) const;
/// This will read the attribute data from a stream.
void readAttributes(std::istream&);
/// This will write the attribute data to a stream.
/// @param outputTransient if true, write out transient attributes
void writeAttributes(std::ostream&, bool outputTransient = false) const;
/// Compare the descriptors and attribute arrays on the attribute sets
/// Exit early if the descriptors do not match
bool operator==(const AttributeSet& other) const;
bool operator!=(const AttributeSet& other) const { return !this->operator==(other); }
private:
using AttrArrayVec = std::vector<AttributeArray::Ptr>;
DescriptorPtr mDescr;
AttrArrayVec mAttrs;
}; // class AttributeSet
////////////////////////////////////////
/// A container for ABI=5 to help ease introduction of upcoming features
namespace future {
class Container
{
class Element { };
std::vector<std::shared_ptr<Element>> mElements;
};
}
////////////////////////////////////////
/// @brief An immutable object that stores name, type and AttributeSet position
/// for a constant collection of attribute arrays.
/// @note The attribute name is actually mutable, but the attribute type
/// and position can not be changed after creation.
class OPENVDB_API AttributeSet::Descriptor
{
public:
using Ptr = std::shared_ptr<Descriptor>;
using NameAndType = Util::NameAndType;
using NameAndTypeVec = Util::NameAndTypeVec;
using GroupIndex = Util::GroupIndex;
using NameToPosMap = Util::NameToPosMap;
using ConstIterator = NameToPosMap::const_iterator;
/// Utility method to construct a NameAndType sequence.
struct Inserter {
NameAndTypeVec vec;
Inserter& add(const NameAndType& nameAndType) {
vec.push_back(nameAndType); return *this;
}
Inserter& add(const Name& name, const NamePair& type) {
vec.emplace_back(name, type); return *this;
}
Inserter& add(const NameAndTypeVec& other) {
for (NameAndTypeVec::const_iterator it = other.begin(), itEnd = other.end(); it != itEnd; ++it) {
vec.emplace_back(it->name, it->type);
}
return *this;
}
};
//////////
Descriptor();
/// Copy constructor
Descriptor(const Descriptor&);
/// Create a new descriptor from a position attribute type and assumes "P" (for convenience).
static Ptr create(const NamePair&);
/// Create a new descriptor as a duplicate with a new attribute appended
Ptr duplicateAppend(const Name& name, const NamePair& type) const;
/// Create a new descriptor as a duplicate with existing attributes dropped
Ptr duplicateDrop(const std::vector<size_t>& pos) const;
/// Return the number of attributes in this descriptor.
size_t size() const { return mTypes.size(); }
/// Return the number of attributes with this attribute type
size_t count(const NamePair& type) const;
/// Return the number of bytes of memory used by this attribute set.
size_t memUsage() const;
/// @brief Return the position of the attribute array whose name is @a name,
/// or @c INVALID_POS if no match is found.
size_t find(const std::string& name) const;
/// Rename an attribute array
size_t rename(const std::string& fromName, const std::string& toName);
/// Return the name of the attribute array's type.
const Name& valueType(size_t pos) const;
/// Return the name of the attribute array's type.
const NamePair& type(size_t pos) const;
/// Retrieve metadata map
MetaMap& getMetadata();
const MetaMap& getMetadata() const;
/// Return true if the attribute has a default value
bool hasDefaultValue(const Name& name) const;
/// Get a default value for an existing attribute
template<typename ValueType>
ValueType getDefaultValue(const Name& name) const
{
const size_t pos = find(name);
if (pos == INVALID_POS) {
OPENVDB_THROW(LookupError, "Cannot find attribute name to set default value.")
}
std::stringstream ss;
ss << "default:" << name;
auto metadata = mMetadata.getMetadata<TypedMetadata<ValueType>>(ss.str());
if (metadata) return metadata->value();
return zeroVal<ValueType>();
}
/// Set a default value for an existing attribute
void setDefaultValue(const Name& name, const Metadata& defaultValue);
// Remove the default value if it exists
void removeDefaultValue(const Name& name);
// Prune any default values for which the key is no longer present
void pruneUnusedDefaultValues();
/// Return true if this descriptor is equal to the given one.
bool operator==(const Descriptor&) const;
/// Return true if this descriptor is not equal to the given one.
bool operator!=(const Descriptor& rhs) const { return !this->operator==(rhs); }
/// Return true if this descriptor contains the same attributes
/// as the given descriptor, ignoring attribute order
bool hasSameAttributes(const Descriptor& rhs) const;
/// Return a reference to the name-to-position map.
const NameToPosMap& map() const { return mNameMap; }
/// Return a reference to the name-to-position group map.
const NameToPosMap& groupMap() const { return mGroupMap; }
/// Return @c true if group exists
bool hasGroup(const Name& group) const;
/// @brief Define a group name to offset mapping
/// @param group group name
/// @param offset group offset
/// @param checkValidOffset throws if offset out-of-range or in-use
void setGroup(const Name& group, const size_t offset,
const bool checkValidOffset = false);
/// Drop any mapping keyed by group name
void dropGroup(const Name& group);
/// Clear all groups
void clearGroups();
/// Rename a group
size_t renameGroup(const std::string& fromName, const std::string& toName);
/// Return a unique name for a group based on given name
const Name uniqueGroupName(const Name& name) const;
//@{
/// @brief Return the group offset from the name or index of the group
/// A group attribute array is a single byte (8-bit), each bit of which
/// can denote a group. The group offset is the position of the bit that
/// denotes the requested group if all group attribute arrays in the set
/// (and only attribute arrays marked as group) were to be laid out linearly
/// according to their order in the set.
size_t groupOffset(const Name& groupName) const;
size_t groupOffset(const GroupIndex& index) const;
//@}
/// Return the group index from the name of the group
GroupIndex groupIndex(const Name& groupName) const;
/// Return the group index from the offset of the group
/// @note see offset description for groupOffset()
GroupIndex groupIndex(const size_t offset) const;
/// Return number of bits occupied by a group attribute array
static size_t groupBits() { return sizeof(GroupType) * CHAR_BIT; }
/// Return the total number of available groups
/// (group bits * number of group attributes)
size_t availableGroups() const;
/// Return the number of empty group slots which correlates to the number of groups
/// that can be stored without increasing the number of group attribute arrays
size_t unusedGroups() const;
/// Return @c true if there are sufficient empty slots to allow compacting
bool canCompactGroups() const;
/// @brief Return a group offset that is not in use
/// @param hint if provided, request a specific offset as a hint
/// @return index of an offset or size_t max if no available group offsets
size_t unusedGroupOffset(size_t hint = std::numeric_limits<size_t>::max()) const;
/// @brief Determine if a move is required to efficiently compact the data and store the
/// source name, offset and the target offset in the input parameters
/// @param sourceName source name
/// @param sourceOffset source offset
/// @param targetOffset target offset
/// @return @c true if move is required to compact the data
bool requiresGroupMove(Name& sourceName, size_t& sourceOffset, size_t& targetOffset) const;
/// @brief Test if there are any group names shared by both descriptors which
/// have a different index
/// @param rhs the descriptor to compare with
/// @return @c true if an index collision exists
bool groupIndexCollision(const Descriptor& rhs) const;
/// Return a unique name for an attribute array based on given name
const Name uniqueName(const Name& name) const;
/// Return true if the name is valid
static bool validName(const Name& name);
/// @brief Extract each name from @a nameStr into @a includeNames, or into @a excludeNames
/// if the name is prefixed with a caret.
/// @param nameStr the input string of names
/// @param includeNames on exit, the list of names that are not prefixed with a caret
/// @param excludeNames on exit, the list of names that are prefixed with a caret
/// @param includeAll on exit, @c true if a "*" wildcard is present in the @a includeNames
static void parseNames( std::vector<std::string>& includeNames,
std::vector<std::string>& excludeNames,
bool& includeAll,
const std::string& nameStr);
/// @brief Extract each name from @a nameStr into @a includeNames, or into @a excludeNames
/// if the name is prefixed with a caret.
static void parseNames( std::vector<std::string>& includeNames,
std::vector<std::string>& excludeNames,
const std::string& nameStr);
/// Serialize this descriptor to the given stream.
void write(std::ostream&) const;
/// Unserialize this transform from the given stream.
void read(std::istream&);
protected:
/// Append to a vector of names and types from this Descriptor in position order
void appendTo(NameAndTypeVec& attrs) const;
/// Create a new descriptor from the given attribute and type name pairs
/// and copy the group maps and metamap.
static Ptr create(const NameAndTypeVec&, const NameToPosMap&, const MetaMap&);
size_t insert(const std::string& name, const NamePair& typeName);
private:
friend class ::TestAttributeSet;
NameToPosMap mNameMap;
std::vector<NamePair> mTypes;
NameToPosMap mGroupMap;
MetaMap mMetadata;
// as this change is part of an ABI change, there's no good reason to reduce the reserved
// space aside from keeping the memory size of an AttributeSet the same for convenience
// (note that this assumes a typical three-pointer implementation for std::vector)
future::Container mFutureContainer; // occupies 3 reserved slots
int64_t mReserved[5]; // for future use
}; // class Descriptor
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_ATTRIBUTE_ARRAY_HAS_BEEN_INCLUDED
| 23,694 | C | 43.124767 | 109 | 0.672153 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/points.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/points.cc
#include "PointDataGrid.h"
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
void
internal::initialize()
{
// Register attribute arrays with no compression
TypedAttributeArray<bool>::registerType();
TypedAttributeArray<int8_t>::registerType();
TypedAttributeArray<int16_t>::registerType();
TypedAttributeArray<int32_t>::registerType();
TypedAttributeArray<int64_t>::registerType();
TypedAttributeArray<float>::registerType();
TypedAttributeArray<double>::registerType();
TypedAttributeArray<math::Vec3<int32_t>>::registerType();
TypedAttributeArray<math::Vec3<float>>::registerType();
TypedAttributeArray<math::Vec3<double>>::registerType();
// Register attribute arrays with group and string attribute
GroupAttributeArray::registerType();
StringAttributeArray::registerType();
// Register attribute arrays with matrix and quaternion attributes
TypedAttributeArray<math::Mat3<float>>::registerType();
TypedAttributeArray<math::Mat3<double>>::registerType();
TypedAttributeArray<math::Mat4<float>>::registerType();
TypedAttributeArray<math::Mat4<double>>::registerType();
TypedAttributeArray<math::Quat<float>>::registerType();
TypedAttributeArray<math::Quat<double>>::registerType();
// Register attribute arrays with truncate compression
TypedAttributeArray<float, TruncateCodec>::registerType();
TypedAttributeArray<math::Vec3<float>, TruncateCodec>::registerType();
// Register attribute arrays with fixed point compression
TypedAttributeArray<math::Vec3<float>, FixedPointCodec<true>>::registerType();
TypedAttributeArray<math::Vec3<float>, FixedPointCodec<false>>::registerType();
TypedAttributeArray<math::Vec3<float>, FixedPointCodec<true, PositionRange>>::registerType();
TypedAttributeArray<math::Vec3<float>, FixedPointCodec<false, PositionRange>>::registerType();
TypedAttributeArray<math::Vec3<float>, FixedPointCodec<true, UnitRange>>::registerType();
TypedAttributeArray<math::Vec3<float>, FixedPointCodec<false, UnitRange>>::registerType();
// Register attribute arrays with unit vector compression
TypedAttributeArray<math::Vec3<float>, UnitVecCodec>::registerType();
// Register types associated with point data grids.
Metadata::registerType(typeNameAsString<PointDataIndex32>(), Int32Metadata::createMetadata);
Metadata::registerType(typeNameAsString<PointDataIndex64>(), Int64Metadata::createMetadata);
PointDataGrid::registerGrid();
}
void
internal::uninitialize()
{
AttributeArray::clearRegistry();
}
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
| 2,832 | C++ | 38.901408 | 98 | 0.754944 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointMove.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @author Dan Bailey
///
/// @file PointMove.h
///
/// @brief Ability to move VDB Points using a custom deformer.
///
/// Deformers used when moving points are in world space by default and must adhere
/// to the interface described in the example below:
/// @code
/// struct MyDeformer
/// {
/// // A reset is performed on each leaf in turn before the points in that leaf are
/// // deformed. A leaf and leaf index (standard leaf traversal order) are supplied as
/// // the arguments, which matches the functor interface for LeafManager::foreach().
/// template <typename LeafNoteType>
/// void reset(LeafNoteType& leaf, size_t idx);
///
/// // Evaluate the deformer and modify the given position to generate the deformed
/// // position. An index iterator is supplied as the argument to allow querying the
/// // point offset or containing voxel coordinate.
/// template <typename IndexIterT>
/// void apply(Vec3d& position, const IndexIterT& iter) const;
/// };
/// @endcode
///
/// @note The DeformerTraits struct (defined in PointMask.h) can be used to configure
/// a deformer to evaluate in index space.
#ifndef OPENVDB_POINTS_POINT_MOVE_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_MOVE_HAS_BEEN_INCLUDED
#include <openvdb/openvdb.h>
#include <openvdb/points/PointDataGrid.h>
#include <openvdb/points/PointMask.h>
#include <tbb/concurrent_vector.h>
#include <algorithm>
#include <iterator> // for std::begin(), std::end()
#include <map>
#include <numeric> // for std::iota()
#include <tuple>
#include <unordered_map>
#include <vector>
class TestPointMove;
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
// dummy object for future use
namespace future { struct Advect { }; }
/// @brief Move points in a PointDataGrid using a custom deformer
/// @param points the PointDataGrid containing the points to be moved.
/// @param deformer a custom deformer that defines how to move the points.
/// @param filter an optional index filter
/// @param objectNotInUse for future use, this object is currently ignored
/// @param threaded enable or disable threading (threading is enabled by default)
template <typename PointDataGridT, typename DeformerT, typename FilterT = NullFilter>
inline void movePoints(PointDataGridT& points,
DeformerT& deformer,
const FilterT& filter = NullFilter(),
future::Advect* objectNotInUse = nullptr,
bool threaded = true);
/// @brief Move points in a PointDataGrid using a custom deformer and a new transform
/// @param points the PointDataGrid containing the points to be moved.
/// @param transform target transform to use for the resulting points.
/// @param deformer a custom deformer that defines how to move the points.
/// @param filter an optional index filter
/// @param objectNotInUse for future use, this object is currently ignored
/// @param threaded enable or disable threading (threading is enabled by default)
template <typename PointDataGridT, typename DeformerT, typename FilterT = NullFilter>
inline void movePoints(PointDataGridT& points,
const math::Transform& transform,
DeformerT& deformer,
const FilterT& filter = NullFilter(),
future::Advect* objectNotInUse = nullptr,
bool threaded = true);
// define leaf index in use as 32-bit
namespace point_move_internal { using LeafIndex = Index32; }
/// @brief A Deformer that caches the resulting positions from evaluating another Deformer
template <typename T>
class CachedDeformer
{
public:
using LeafIndex = point_move_internal::LeafIndex;
using Vec3T = typename math::Vec3<T>;
using LeafVecT = std::vector<Vec3T>;
using LeafMapT = std::unordered_map<LeafIndex, Vec3T>;
// Internal data cache to allow the deformer to offer light-weight copying
struct Cache
{
struct Leaf
{
/// @brief clear data buffers and reset counter
void clear() {
vecData.clear();
mapData.clear();
totalSize = 0;
}
LeafVecT vecData;
LeafMapT mapData;
Index totalSize = 0;
}; // struct Leaf
std::vector<Leaf> leafs;
}; // struct Cache
/// Cache is expected to be persistent for the lifetime of the CachedDeformer
explicit CachedDeformer(Cache& cache);
/// Caches the result of evaluating the supplied point grid using the deformer and filter
/// @param grid the points to be moved
/// @param deformer the deformer to apply to the points
/// @param filter the point filter to use when evaluating the points
/// @param threaded enable or disable threading (threading is enabled by default)
template <typename PointDataGridT, typename DeformerT, typename FilterT>
void evaluate(PointDataGridT& grid, DeformerT& deformer, const FilterT& filter,
bool threaded = true);
/// Stores pointers to the vector or map and optionally expands the map into a vector
/// @throw IndexError if idx is out-of-range of the leafs in the cache
template <typename LeafT>
void reset(const LeafT& leaf, size_t idx);
/// Retrieve the new position from the cache
template <typename IndexIterT>
void apply(Vec3d& position, const IndexIterT& iter) const;
private:
friend class ::TestPointMove;
Cache& mCache;
const LeafVecT* mLeafVec = nullptr;
const LeafMapT* mLeafMap = nullptr;
}; // class CachedDeformer
////////////////////////////////////////
namespace point_move_internal {
using IndexArray = std::vector<Index>;
using IndexTriple = std::tuple<LeafIndex, Index, Index>;
using IndexTripleArray = tbb::concurrent_vector<IndexTriple>;
using GlobalPointIndexMap = std::vector<IndexTripleArray>;
using GlobalPointIndexIndices = std::vector<IndexArray>;
using IndexPair = std::pair<Index, Index>;
using IndexPairArray = std::vector<IndexPair>;
using LocalPointIndexMap = std::vector<IndexPairArray>;
using LeafIndexArray = std::vector<LeafIndex>;
using LeafOffsetArray = std::vector<LeafIndexArray>;
using LeafMap = std::unordered_map<Coord, LeafIndex>;
template <typename DeformerT, typename TreeT, typename FilterT>
struct BuildMoveMapsOp
{
using LeafT = typename TreeT::LeafNodeType;
using LeafArrayT = std::vector<LeafT*>;
using LeafManagerT = typename tree::LeafManager<TreeT>;
BuildMoveMapsOp(const DeformerT& deformer,
GlobalPointIndexMap& globalMoveLeafMap,
LocalPointIndexMap& localMoveLeafMap,
const LeafMap& targetLeafMap,
const math::Transform& targetTransform,
const math::Transform& sourceTransform,
const FilterT& filter)
: mDeformer(deformer)
, mGlobalMoveLeafMap(globalMoveLeafMap)
, mLocalMoveLeafMap(localMoveLeafMap)
, mTargetLeafMap(targetLeafMap)
, mTargetTransform(targetTransform)
, mSourceTransform(sourceTransform)
, mFilter(filter) { }
void operator()(LeafT& leaf, size_t idx) const
{
DeformerT deformer(mDeformer);
deformer.reset(leaf, idx);
// determine source leaf node origin and offset in the source leaf vector
Coord sourceLeafOrigin = leaf.origin();
auto sourceHandle = AttributeWriteHandle<Vec3f>::create(leaf.attributeArray("P"));
for (auto iter = leaf.beginIndexOn(mFilter); iter; iter++) {
const bool useIndexSpace = DeformerTraits<DeformerT>::IndexSpace;
// extract index-space position and apply index-space deformation (if applicable)
Vec3d positionIS = sourceHandle->get(*iter) + iter.getCoord().asVec3d();
if (useIndexSpace) {
deformer.apply(positionIS, iter);
}
// transform to world-space position and apply world-space deformation (if applicable)
Vec3d positionWS = mSourceTransform.indexToWorld(positionIS);
if (!useIndexSpace) {
deformer.apply(positionWS, iter);
}
// transform to index-space position of target grid
positionIS = mTargetTransform.worldToIndex(positionWS);
// determine target voxel and offset
Coord targetVoxel = Coord::round(positionIS);
Index targetOffset = LeafT::coordToOffset(targetVoxel);
// set new local position in source transform space (if point has been deformed)
Vec3d voxelPosition(positionIS - targetVoxel.asVec3d());
sourceHandle->set(*iter, voxelPosition);
// determine target leaf node origin and offset in the target leaf vector
Coord targetLeafOrigin = targetVoxel & ~(LeafT::DIM - 1);
assert(mTargetLeafMap.find(targetLeafOrigin) != mTargetLeafMap.end());
const LeafIndex targetLeafOffset(mTargetLeafMap.at(targetLeafOrigin));
// insert into move map based on whether point ends up in a new leaf node or not
if (targetLeafOrigin == sourceLeafOrigin) {
mLocalMoveLeafMap[targetLeafOffset].emplace_back(targetOffset, *iter);
}
else {
mGlobalMoveLeafMap[targetLeafOffset].push_back(IndexTriple(
LeafIndex(static_cast<LeafIndex>(idx)), targetOffset, *iter));
}
}
}
private:
const DeformerT& mDeformer;
GlobalPointIndexMap& mGlobalMoveLeafMap;
LocalPointIndexMap& mLocalMoveLeafMap;
const LeafMap& mTargetLeafMap;
const math::Transform& mTargetTransform;
const math::Transform& mSourceTransform;
const FilterT& mFilter;
}; // struct BuildMoveMapsOp
template <typename LeafT>
inline Index
indexOffsetFromVoxel(const Index voxelOffset, const LeafT& leaf, IndexArray& offsets)
{
// compute the target point index by summing the point index of the previous
// voxel with the current number of points added to this voxel, tracked by the
// offsets array
Index targetOffset = offsets[voxelOffset]++;
if (voxelOffset > 0) {
targetOffset += static_cast<Index>(leaf.getValue(voxelOffset - 1));
}
return targetOffset;
}
#if OPENVDB_ABI_VERSION_NUMBER >= 6
template <typename TreeT>
struct GlobalMovePointsOp
{
using LeafT = typename TreeT::LeafNodeType;
using LeafArrayT = std::vector<LeafT*>;
using LeafManagerT = typename tree::LeafManager<TreeT>;
using AttributeArrays = std::vector<AttributeArray*>;
GlobalMovePointsOp(LeafOffsetArray& offsetMap,
LeafManagerT& sourceLeafManager,
const Index attributeIndex,
const GlobalPointIndexMap& moveLeafMap,
const GlobalPointIndexIndices& moveLeafIndices)
: mOffsetMap(offsetMap)
, mSourceLeafManager(sourceLeafManager)
, mAttributeIndex(attributeIndex)
, mMoveLeafMap(moveLeafMap)
, mMoveLeafIndices(moveLeafIndices) { }
// A CopyIterator is designed to use the indices in a GlobalPointIndexMap for this leaf
// and match the interface required for AttributeArray::copyValues()
struct CopyIterator
{
CopyIterator(const LeafT& leaf, const IndexArray& sortedIndices,
const IndexTripleArray& moveIndices, IndexArray& offsets)
: mLeaf(leaf)
, mSortedIndices(sortedIndices)
, mMoveIndices(moveIndices)
, mOffsets(offsets) { }
operator bool() const { return bool(mIt); }
void reset(Index startIndex, Index endIndex)
{
mIndex = startIndex;
mEndIndex = endIndex;
this->advance();
}
CopyIterator& operator++()
{
this->advance();
return *this;
}
Index leafIndex(Index i) const
{
if (i < mSortedIndices.size()) {
return std::get<0>(this->leafIndexTriple(i));
}
return std::numeric_limits<Index>::max();
}
Index sourceIndex() const
{
assert(mIt);
return std::get<2>(*mIt);
}
Index targetIndex() const
{
assert(mIt);
return indexOffsetFromVoxel(std::get<1>(*mIt), mLeaf, mOffsets);
}
private:
void advance()
{
if (mIndex >= mEndIndex || mIndex >= mSortedIndices.size()) {
mIt = nullptr;
}
else {
mIt = &this->leafIndexTriple(mIndex);
}
++mIndex;
}
const IndexTriple& leafIndexTriple(Index i) const
{
return mMoveIndices[mSortedIndices[i]];
}
private:
const LeafT& mLeaf;
Index mIndex;
Index mEndIndex;
const IndexArray& mSortedIndices;
const IndexTripleArray& mMoveIndices;
IndexArray& mOffsets;
const IndexTriple* mIt = nullptr;
}; // struct CopyIterator
void operator()(LeafT& leaf, size_t idx) const
{
const IndexTripleArray& moveIndices = mMoveLeafMap[idx];
if (moveIndices.empty()) return;
const IndexArray& sortedIndices = mMoveLeafIndices[idx];
// extract per-voxel offsets for this leaf
LeafIndexArray& offsets = mOffsetMap[idx];
// extract target array and ensure data is out-of-core and non-uniform
auto& targetArray = leaf.attributeArray(mAttributeIndex);
targetArray.loadData();
targetArray.expand();
// perform the copy
CopyIterator copyIterator(leaf, sortedIndices, moveIndices, offsets);
// use the sorted indices to track the index of the source leaf
Index sourceLeafIndex = copyIterator.leafIndex(0);
Index startIndex = 0;
for (size_t i = 1; i <= sortedIndices.size(); i++) {
Index endIndex = static_cast<Index>(i);
Index newSourceLeafIndex = copyIterator.leafIndex(endIndex);
// when it changes, do a batch-copy of all the indices that lie within this range
// TODO: this step could use nested parallelization for cases where there are a
// large number of points being moved per attribute
if (newSourceLeafIndex > sourceLeafIndex) {
copyIterator.reset(startIndex, endIndex);
const LeafT& sourceLeaf = mSourceLeafManager.leaf(sourceLeafIndex);
const auto& sourceArray = sourceLeaf.constAttributeArray(mAttributeIndex);
sourceArray.loadData();
targetArray.copyValuesUnsafe(sourceArray, copyIterator);
sourceLeafIndex = newSourceLeafIndex;
startIndex = endIndex;
}
}
}
private:
LeafOffsetArray& mOffsetMap;
LeafManagerT& mSourceLeafManager;
const Index mAttributeIndex;
const GlobalPointIndexMap& mMoveLeafMap;
const GlobalPointIndexIndices& mMoveLeafIndices;
}; // struct GlobalMovePointsOp
template <typename TreeT>
struct LocalMovePointsOp
{
using LeafT = typename TreeT::LeafNodeType;
using LeafArrayT = std::vector<LeafT*>;
using LeafManagerT = typename tree::LeafManager<TreeT>;
using AttributeArrays = std::vector<AttributeArray*>;
LocalMovePointsOp( LeafOffsetArray& offsetMap,
const LeafIndexArray& sourceIndices,
LeafManagerT& sourceLeafManager,
const Index attributeIndex,
const LocalPointIndexMap& moveLeafMap)
: mOffsetMap(offsetMap)
, mSourceIndices(sourceIndices)
, mSourceLeafManager(sourceLeafManager)
, mAttributeIndex(attributeIndex)
, mMoveLeafMap(moveLeafMap) { }
// A CopyIterator is designed to use the indices in a LocalPointIndexMap for this leaf
// and match the interface required for AttributeArray::copyValues()
struct CopyIterator
{
CopyIterator(const LeafT& leaf, const IndexPairArray& indices, IndexArray& offsets)
: mLeaf(leaf)
, mIndices(indices)
, mOffsets(offsets) { }
operator bool() const { return mIndex < static_cast<int>(mIndices.size()); }
CopyIterator& operator++() { ++mIndex; return *this; }
Index sourceIndex() const
{
return mIndices[mIndex].second;
}
Index targetIndex() const
{
return indexOffsetFromVoxel(mIndices[mIndex].first, mLeaf, mOffsets);
}
private:
const LeafT& mLeaf;
const IndexPairArray& mIndices;
IndexArray& mOffsets;
int mIndex = 0;
}; // struct CopyIterator
void operator()(LeafT& leaf, size_t idx) const
{
const IndexPairArray& moveIndices = mMoveLeafMap[idx];
if (moveIndices.empty()) return;
// extract per-voxel offsets for this leaf
LeafIndexArray& offsets = mOffsetMap[idx];
// extract source array that has the same origin as the target leaf
assert(idx < mSourceIndices.size());
const Index sourceLeafOffset(mSourceIndices[idx]);
LeafT& sourceLeaf = mSourceLeafManager.leaf(sourceLeafOffset);
const auto& sourceArray = sourceLeaf.constAttributeArray(mAttributeIndex);
sourceArray.loadData();
// extract target array and ensure data is out-of-core and non-uniform
auto& targetArray = leaf.attributeArray(mAttributeIndex);
targetArray.loadData();
targetArray.expand();
// perform the copy
CopyIterator copyIterator(leaf, moveIndices, offsets);
targetArray.copyValuesUnsafe(sourceArray, copyIterator);
}
private:
LeafOffsetArray& mOffsetMap;
const LeafIndexArray& mSourceIndices;
LeafManagerT& mSourceLeafManager;
const Index mAttributeIndex;
const LocalPointIndexMap& mMoveLeafMap;
}; // struct LocalMovePointsOp
#else
// The following infrastructure - ArrayProcessor, PerformTypedMoveOp, processTypedArray()
// is required to improve AttributeArray copying performance beyond using the virtual function
// AttributeArray::set(Index, AttributeArray&, Index). An ABI=6 addition to AttributeArray
// improves this by introducing an AttributeArray::copyValues() method to significantly
// simplify this logic without incurring the same virtual function cost.
/// Helper class used internally by processTypedArray()
template<typename ValueType, typename OpType>
struct ArrayProcessor {
static inline void call(OpType& op, const AttributeArray& array) {
op.template operator()<ValueType>(array);
}
};
/// @brief Utility function that, given a generic attribute array,
/// calls a functor with the fully-resolved value type of the array
template<typename ArrayType, typename OpType>
bool
processTypedArray(const ArrayType& array, OpType& op)
{
using namespace openvdb;
using namespace openvdb::math;
if (array.template hasValueType<bool>()) ArrayProcessor<bool, OpType>::call(op, array);
else if (array.template hasValueType<int16_t>()) ArrayProcessor<int16_t, OpType>::call(op, array);
else if (array.template hasValueType<int32_t>()) ArrayProcessor<int32_t, OpType>::call(op, array);
else if (array.template hasValueType<int64_t>()) ArrayProcessor<int64_t, OpType>::call(op, array);
else if (array.template hasValueType<float>()) ArrayProcessor<float, OpType>::call(op, array);
else if (array.template hasValueType<double>()) ArrayProcessor<double, OpType>::call(op, array);
else if (array.template hasValueType<Vec3<int32_t>>()) ArrayProcessor<Vec3<int32_t>, OpType>::call(op, array);
else if (array.template hasValueType<Vec3<float>>()) ArrayProcessor<Vec3<float>, OpType>::call(op, array);
else if (array.template hasValueType<Vec3<double>>()) ArrayProcessor<Vec3<double>, OpType>::call(op, array);
else if (array.template hasValueType<GroupType>()) ArrayProcessor<GroupType, OpType>::call(op, array);
else if (array.template hasValueType<Index>()) ArrayProcessor<Index, OpType>::call(op, array);
else if (array.template hasValueType<Mat3<float>>()) ArrayProcessor<Mat3<float>, OpType>::call(op, array);
else if (array.template hasValueType<Mat3<double>>()) ArrayProcessor<Mat3<double>, OpType>::call(op, array);
else if (array.template hasValueType<Mat4<float>>()) ArrayProcessor<Mat4<float>, OpType>::call(op, array);
else if (array.template hasValueType<Mat4<double>>()) ArrayProcessor<Mat4<double>, OpType>::call(op, array);
else if (array.template hasValueType<Quat<float>>()) ArrayProcessor<Quat<float>, OpType>::call(op, array);
else if (array.template hasValueType<Quat<double>>()) ArrayProcessor<Quat<double>, OpType>::call(op, array);
else return false;
return true;
}
/// Cache read and write attribute handles to amortize construction cost
struct AttributeHandles
{
using HandleArray = std::vector<AttributeHandle<int>::Ptr>;
AttributeHandles(const size_t size)
: mHandles() { mHandles.reserve(size); }
AttributeArray& getArray(const Index leafOffset)
{
auto* handle = reinterpret_cast<AttributeWriteHandle<int>*>(mHandles[leafOffset].get());
assert(handle);
return handle->array();
}
const AttributeArray& getConstArray(const Index leafOffset) const
{
const auto* handle = mHandles[leafOffset].get();
assert(handle);
return handle->array();
}
template <typename ValueT>
AttributeHandle<ValueT>& getHandle(const Index leafOffset)
{
auto* handle = reinterpret_cast<AttributeHandle<ValueT>*>(mHandles[leafOffset].get());
assert(handle);
return *handle;
}
template <typename ValueT>
AttributeWriteHandle<ValueT>& getWriteHandle(const Index leafOffset)
{
auto* handle = reinterpret_cast<AttributeWriteHandle<ValueT>*>(mHandles[leafOffset].get());
assert(handle);
return *handle;
}
/// Create a handle and reinterpret cast as an int handle to store
struct CacheHandleOp
{
CacheHandleOp(HandleArray& handles)
: mHandles(handles) { }
template<typename ValueT>
void operator()(const AttributeArray& array) const
{
auto* handleAsInt = reinterpret_cast<AttributeHandle<int>*>(
new AttributeHandle<ValueT>(array));
mHandles.emplace_back(handleAsInt);
}
private:
HandleArray& mHandles;
}; // struct CacheHandleOp
template <typename LeafRangeT>
void cache(const LeafRangeT& range, const Index attributeIndex)
{
using namespace openvdb::math;
mHandles.clear();
CacheHandleOp op(mHandles);
for (auto leaf = range.begin(); leaf; ++leaf) {
const auto& array = leaf->constAttributeArray(attributeIndex);
processTypedArray(array, op);
}
}
private:
HandleArray mHandles;
}; // struct AttributeHandles
template <typename TreeT>
struct GlobalMovePointsOp
{
using LeafT = typename TreeT::LeafNodeType;
using LeafArrayT = std::vector<LeafT*>;
using LeafManagerT = typename tree::LeafManager<TreeT>;
GlobalMovePointsOp(LeafOffsetArray& offsetMap,
AttributeHandles& targetHandles,
AttributeHandles& sourceHandles,
const Index attributeIndex,
const GlobalPointIndexMap& moveLeafMap,
const GlobalPointIndexIndices& moveLeafIndices)
: mOffsetMap(offsetMap)
, mTargetHandles(targetHandles)
, mSourceHandles(sourceHandles)
, mAttributeIndex(attributeIndex)
, mMoveLeafMap(moveLeafMap)
, mMoveLeafIndices(moveLeafIndices) { }
struct PerformTypedMoveOp
{
PerformTypedMoveOp(AttributeHandles& targetHandles, AttributeHandles& sourceHandles,
Index targetOffset, const LeafT& targetLeaf,
IndexArray& offsets, const IndexTripleArray& indices,
const IndexArray& sortedIndices)
: mTargetHandles(targetHandles)
, mSourceHandles(sourceHandles)
, mTargetOffset(targetOffset)
, mTargetLeaf(targetLeaf)
, mOffsets(offsets)
, mIndices(indices)
, mSortedIndices(sortedIndices) { }
template<typename ValueT>
void operator()(const AttributeArray&) const
{
auto& targetHandle = mTargetHandles.getWriteHandle<ValueT>(mTargetOffset);
targetHandle.expand();
for (const auto& index : mSortedIndices) {
const auto& it = mIndices[index];
const auto& sourceHandle = mSourceHandles.getHandle<ValueT>(std::get<0>(it));
const Index targetIndex = indexOffsetFromVoxel(std::get<1>(it), mTargetLeaf, mOffsets);
for (Index i = 0; i < sourceHandle.stride(); i++) {
ValueT sourceValue = sourceHandle.get(std::get<2>(it), i);
targetHandle.set(targetIndex, i, sourceValue);
}
}
}
private:
AttributeHandles& mTargetHandles;
AttributeHandles& mSourceHandles;
Index mTargetOffset;
const LeafT& mTargetLeaf;
IndexArray& mOffsets;
const IndexTripleArray& mIndices;
const IndexArray& mSortedIndices;
}; // struct PerformTypedMoveOp
void performMove(Index targetOffset, const LeafT& targetLeaf,
IndexArray& offsets, const IndexTripleArray& indices,
const IndexArray& sortedIndices) const
{
auto& targetArray = mTargetHandles.getArray(targetOffset);
targetArray.loadData();
targetArray.expand();
for (const auto& index : sortedIndices) {
const auto& it = indices[index];
const auto& sourceArray = mSourceHandles.getConstArray(std::get<0>(it));
const Index sourceOffset = std::get<2>(it);
const Index targetOffset = indexOffsetFromVoxel(std::get<1>(it), targetLeaf, offsets);
targetArray.set(targetOffset, sourceArray, sourceOffset);
}
}
void operator()(LeafT& leaf, size_t aIdx) const
{
const Index idx(static_cast<Index>(aIdx));
const auto& moveIndices = mMoveLeafMap[aIdx];
if (moveIndices.empty()) return;
const auto& sortedIndices = mMoveLeafIndices[aIdx];
// extract per-voxel offsets for this leaf
auto& offsets = mOffsetMap[aIdx];
const auto& array = leaf.constAttributeArray(mAttributeIndex);
PerformTypedMoveOp op(mTargetHandles, mSourceHandles, idx, leaf, offsets,
moveIndices, sortedIndices);
if (!processTypedArray(array, op)) {
this->performMove(idx, leaf, offsets, moveIndices, sortedIndices);
}
}
private:
LeafOffsetArray& mOffsetMap;
AttributeHandles& mTargetHandles;
AttributeHandles& mSourceHandles;
const Index mAttributeIndex;
const GlobalPointIndexMap& mMoveLeafMap;
const GlobalPointIndexIndices& mMoveLeafIndices;
}; // struct GlobalMovePointsOp
template <typename TreeT>
struct LocalMovePointsOp
{
using LeafT = typename TreeT::LeafNodeType;
using LeafArrayT = std::vector<LeafT*>;
using LeafManagerT = typename tree::LeafManager<TreeT>;
LocalMovePointsOp( LeafOffsetArray& offsetMap,
AttributeHandles& targetHandles,
const LeafIndexArray& sourceIndices,
AttributeHandles& sourceHandles,
const Index attributeIndex,
const LocalPointIndexMap& moveLeafMap)
: mOffsetMap(offsetMap)
, mTargetHandles(targetHandles)
, mSourceIndices(sourceIndices)
, mSourceHandles(sourceHandles)
, mAttributeIndex(attributeIndex)
, mMoveLeafMap(moveLeafMap) { }
struct PerformTypedMoveOp
{
PerformTypedMoveOp(AttributeHandles& targetHandles, AttributeHandles& sourceHandles,
Index targetOffset, Index sourceOffset, const LeafT& targetLeaf,
IndexArray& offsets, const IndexPairArray& indices)
: mTargetHandles(targetHandles)
, mSourceHandles(sourceHandles)
, mTargetOffset(targetOffset)
, mSourceOffset(sourceOffset)
, mTargetLeaf(targetLeaf)
, mOffsets(offsets)
, mIndices(indices) { }
template<typename ValueT>
void operator()(const AttributeArray&) const
{
auto& targetHandle = mTargetHandles.getWriteHandle<ValueT>(mTargetOffset);
const auto& sourceHandle = mSourceHandles.getHandle<ValueT>(mSourceOffset);
targetHandle.expand();
for (const auto& it : mIndices) {
const Index targetIndex = indexOffsetFromVoxel(it.first, mTargetLeaf, mOffsets);
for (Index i = 0; i < sourceHandle.stride(); i++) {
ValueT sourceValue = sourceHandle.get(it.second, i);
targetHandle.set(targetIndex, i, sourceValue);
}
}
}
private:
AttributeHandles& mTargetHandles;
AttributeHandles& mSourceHandles;
Index mTargetOffset;
Index mSourceOffset;
const LeafT& mTargetLeaf;
IndexArray& mOffsets;
const IndexPairArray& mIndices;
}; // struct PerformTypedMoveOp
template <typename ValueT>
void performTypedMove(Index sourceOffset, Index targetOffset, const LeafT& targetLeaf,
IndexArray& offsets, const IndexPairArray& indices) const
{
auto& targetHandle = mTargetHandles.getWriteHandle<ValueT>(targetOffset);
const auto& sourceHandle = mSourceHandles.getHandle<ValueT>(sourceOffset);
targetHandle.expand();
for (const auto& it : indices) {
const Index tgtOffset = indexOffsetFromVoxel(it.first, targetLeaf, offsets);
for (Index i = 0; i < sourceHandle.stride(); i++) {
ValueT sourceValue = sourceHandle.get(it.second, i);
targetHandle.set(tgtOffset, i, sourceValue);
}
}
}
void performMove(Index targetOffset, Index sourceOffset, const LeafT& targetLeaf,
IndexArray& offsets, const IndexPairArray& indices) const
{
auto& targetArray = mTargetHandles.getArray(targetOffset);
const auto& sourceArray = mSourceHandles.getConstArray(sourceOffset);
for (const auto& it : indices) {
const Index sourceOffset = it.second;
const Index targetOffset = indexOffsetFromVoxel(it.first, targetLeaf, offsets);
targetArray.set(targetOffset, sourceArray, sourceOffset);
}
}
void operator()(const LeafT& leaf, size_t aIdx) const
{
const Index idx(static_cast<Index>(aIdx));
const auto& moveIndices = mMoveLeafMap.at(aIdx);
if (moveIndices.empty()) return;
// extract target leaf and per-voxel offsets for this leaf
auto& offsets = mOffsetMap[aIdx];
// extract source leaf that has the same origin as the target leaf (if any)
assert(aIdx < mSourceIndices.size());
const Index sourceOffset(mSourceIndices[aIdx]);
const auto& array = leaf.constAttributeArray(mAttributeIndex);
PerformTypedMoveOp op(mTargetHandles, mSourceHandles,
idx, sourceOffset, leaf, offsets, moveIndices);
if (!processTypedArray(array, op)) {
this->performMove(idx, sourceOffset, leaf, offsets, moveIndices);
}
}
private:
LeafOffsetArray& mOffsetMap;
AttributeHandles& mTargetHandles;
const LeafIndexArray& mSourceIndices;
AttributeHandles& mSourceHandles;
const Index mAttributeIndex;
const LocalPointIndexMap& mMoveLeafMap;
}; // struct LocalMovePointsOp
#endif // OPENVDB_ABI_VERSION_NUMBER >= 6
} // namespace point_move_internal
////////////////////////////////////////
template <typename PointDataGridT, typename DeformerT, typename FilterT>
inline void movePoints( PointDataGridT& points,
const math::Transform& transform,
DeformerT& deformer,
const FilterT& filter,
future::Advect* objectNotInUse,
bool threaded)
{
using LeafIndex = point_move_internal::LeafIndex;
using PointDataTreeT = typename PointDataGridT::TreeType;
using LeafT = typename PointDataTreeT::LeafNodeType;
using LeafManagerT = typename tree::LeafManager<PointDataTreeT>;
using namespace point_move_internal;
// this object is for future use only
assert(!objectNotInUse);
(void)objectNotInUse;
PointDataTreeT& tree = points.tree();
// early exit if no LeafNodes
PointDataTree::LeafCIter iter = tree.cbeginLeaf();
if (!iter) return;
// build voxel topology taking into account any point group deletion
auto newPoints = point_mask_internal::convertPointsToScalar<PointDataGrid>(
points, transform, filter, deformer, threaded);
auto& newTree = newPoints->tree();
// create leaf managers for both trees
LeafManagerT sourceLeafManager(tree);
LeafManagerT targetLeafManager(newTree);
// extract the existing attribute set
const auto& existingAttributeSet = points.tree().cbeginLeaf()->attributeSet();
// build a coord -> index map for looking up target leafs by origin and a faster
// unordered map for finding the source index from a target index
LeafMap targetLeafMap;
LeafIndexArray sourceIndices(targetLeafManager.leafCount(),
std::numeric_limits<LeafIndex>::max());
LeafOffsetArray offsetMap(targetLeafManager.leafCount());
{
LeafMap sourceLeafMap;
auto sourceRange = sourceLeafManager.leafRange();
for (auto leaf = sourceRange.begin(); leaf; ++leaf) {
sourceLeafMap.insert({leaf->origin(), LeafIndex(static_cast<LeafIndex>(leaf.pos()))});
}
auto targetRange = targetLeafManager.leafRange();
for (auto leaf = targetRange.begin(); leaf; ++leaf) {
targetLeafMap.insert({leaf->origin(), LeafIndex(static_cast<LeafIndex>(leaf.pos()))});
}
// acquire registry lock to avoid locking when appending attributes in parallel
AttributeArray::ScopedRegistryLock lock;
// perform four independent per-leaf operations in parallel
targetLeafManager.foreach(
[&](LeafT& leaf, size_t idx) {
// map frequency => cumulative histogram
auto* buffer = leaf.buffer().data();
for (Index i = 1; i < leaf.buffer().size(); i++) {
buffer[i] = buffer[i-1] + buffer[i];
}
// replace attribute set with a copy of the existing one
leaf.replaceAttributeSet(
new AttributeSet(existingAttributeSet, leaf.getLastValue(), &lock),
/*allowMismatchingDescriptors=*/true);
// store the index of the source leaf in a corresponding target leaf array
const auto it = sourceLeafMap.find(leaf.origin());
if (it != sourceLeafMap.end()) {
sourceIndices[idx] = it->second;
}
// allocate offset maps
offsetMap[idx].resize(LeafT::SIZE);
},
threaded);
}
// moving leaf
GlobalPointIndexMap globalMoveLeafMap(targetLeafManager.leafCount());
LocalPointIndexMap localMoveLeafMap(targetLeafManager.leafCount());
// build global and local move leaf maps and update local positions
if (filter.state() == index::ALL) {
NullFilter nullFilter;
BuildMoveMapsOp<DeformerT, PointDataTreeT, NullFilter> op(deformer,
globalMoveLeafMap, localMoveLeafMap, targetLeafMap,
transform, points.transform(), nullFilter);
sourceLeafManager.foreach(op, threaded);
} else {
BuildMoveMapsOp<DeformerT, PointDataTreeT, FilterT> op(deformer,
globalMoveLeafMap, localMoveLeafMap, targetLeafMap,
transform, points.transform(), filter);
sourceLeafManager.foreach(op, threaded);
}
// build a sorted index vector for each leaf that references the global move map
// indices in order of their source leafs and voxels to ensure determinism in the
// resulting point orders
GlobalPointIndexIndices globalMoveLeafIndices(globalMoveLeafMap.size());
targetLeafManager.foreach(
[&](LeafT& /*leaf*/, size_t idx) {
const IndexTripleArray& moveIndices = globalMoveLeafMap[idx];
if (moveIndices.empty()) return;
IndexArray& sortedIndices = globalMoveLeafIndices[idx];
sortedIndices.resize(moveIndices.size());
std::iota(std::begin(sortedIndices), std::end(sortedIndices), 0);
std::sort(std::begin(sortedIndices), std::end(sortedIndices),
[&](int i, int j)
{
const Index& indexI0(std::get<0>(moveIndices[i]));
const Index& indexJ0(std::get<0>(moveIndices[j]));
if (indexI0 < indexJ0) return true;
if (indexI0 > indexJ0) return false;
return std::get<2>(moveIndices[i]) < std::get<2>(moveIndices[j]);
}
);
},
threaded);
#if OPENVDB_ABI_VERSION_NUMBER < 6
// initialize attribute handles
AttributeHandles sourceHandles(sourceLeafManager.leafCount());
AttributeHandles targetHandles(targetLeafManager.leafCount());
#endif
for (const auto& it : existingAttributeSet.descriptor().map()) {
const Index attributeIndex = static_cast<Index>(it.second);
// zero offsets
targetLeafManager.foreach(
[&offsetMap](const LeafT& /*leaf*/, size_t idx) {
std::fill(offsetMap[idx].begin(), offsetMap[idx].end(), 0);
},
threaded);
#if OPENVDB_ABI_VERSION_NUMBER >= 6
// move points between leaf nodes
GlobalMovePointsOp<PointDataTreeT> globalMoveOp(offsetMap,
sourceLeafManager, attributeIndex, globalMoveLeafMap, globalMoveLeafIndices);
targetLeafManager.foreach(globalMoveOp, threaded);
// move points within leaf nodes
LocalMovePointsOp<PointDataTreeT> localMoveOp(offsetMap,
sourceIndices, sourceLeafManager, attributeIndex, localMoveLeafMap);
targetLeafManager.foreach(localMoveOp, threaded);
#else
// cache attribute handles
sourceHandles.cache(sourceLeafManager.leafRange(), attributeIndex);
targetHandles.cache(targetLeafManager.leafRange(), attributeIndex);
// move points between leaf nodes
GlobalMovePointsOp<PointDataTreeT> globalMoveOp(offsetMap, targetHandles,
sourceHandles, attributeIndex, globalMoveLeafMap, globalMoveLeafIndices);
targetLeafManager.foreach(globalMoveOp, threaded);
// move points within leaf nodes
LocalMovePointsOp<PointDataTreeT> localMoveOp(offsetMap, targetHandles,
sourceIndices, sourceHandles,
attributeIndex, localMoveLeafMap);
targetLeafManager.foreach(localMoveOp, threaded);
#endif // OPENVDB_ABI_VERSION_NUMBER >= 6
}
points.setTree(newPoints->treePtr());
}
template <typename PointDataGridT, typename DeformerT, typename FilterT>
inline void movePoints( PointDataGridT& points,
DeformerT& deformer,
const FilterT& filter,
future::Advect* objectNotInUse,
bool threaded)
{
movePoints(points, points.transform(), deformer, filter, objectNotInUse, threaded);
}
////////////////////////////////////////
template <typename T>
CachedDeformer<T>::CachedDeformer(Cache& cache)
: mCache(cache) { }
template <typename T>
template <typename PointDataGridT, typename DeformerT, typename FilterT>
void CachedDeformer<T>::evaluate(PointDataGridT& grid, DeformerT& deformer, const FilterT& filter,
bool threaded)
{
using TreeT = typename PointDataGridT::TreeType;
using LeafT = typename TreeT::LeafNodeType;
using LeafManagerT = typename tree::LeafManager<TreeT>;
LeafManagerT leafManager(grid.tree());
// initialize cache
auto& leafs = mCache.leafs;
leafs.resize(leafManager.leafCount());
const auto& transform = grid.transform();
// insert deformed positions into the cache
auto cachePositionsOp = [&](const LeafT& leaf, size_t idx) {
const Index64 totalPointCount = leaf.pointCount();
if (totalPointCount == 0) return;
// deformer is copied to ensure that it is unique per-thread
DeformerT newDeformer(deformer);
newDeformer.reset(leaf, idx);
auto handle = AttributeHandle<Vec3f>::create(leaf.constAttributeArray("P"));
auto& cache = leafs[idx];
cache.clear();
// only insert into a vector directly if the filter evaluates all points
// and all points are stored in active voxels
const bool useVector = filter.state() == index::ALL &&
(leaf.isDense() || (leaf.onPointCount() == leaf.pointCount()));
if (useVector) {
cache.vecData.resize(totalPointCount);
}
for (auto iter = leaf.beginIndexOn(filter); iter; iter++) {
// extract index-space position and apply index-space deformation (if defined)
Vec3d position = handle->get(*iter) + iter.getCoord().asVec3d();
// if deformer is designed to be used in index-space, perform deformation prior
// to transforming position to world-space, otherwise perform deformation afterwards
if (DeformerTraits<DeformerT>::IndexSpace) {
newDeformer.apply(position, iter);
position = transform.indexToWorld(position);
}
else {
position = transform.indexToWorld(position);
newDeformer.apply(position, iter);
}
// insert new position into the cache
if (useVector) {
cache.vecData[*iter] = static_cast<Vec3T>(position);
}
else {
cache.mapData.insert({*iter, static_cast<Vec3T>(position)});
}
}
// store the total number of points to allow use of an expanded vector on access
if (!cache.mapData.empty()) {
cache.totalSize = static_cast<Index>(totalPointCount);
}
};
leafManager.foreach(cachePositionsOp, threaded);
}
template <typename T>
template <typename LeafT>
void CachedDeformer<T>::reset(const LeafT& /*leaf*/, size_t idx)
{
if (idx >= mCache.leafs.size()) {
if (mCache.leafs.empty()) {
throw IndexError("No leafs in cache, perhaps CachedDeformer has not been evaluated?");
} else {
throw IndexError("Leaf index is out-of-range of cache leafs.");
}
}
auto& cache = mCache.leafs[idx];
if (!cache.mapData.empty()) {
mLeafMap = &cache.mapData;
mLeafVec = nullptr;
}
else {
mLeafVec = &cache.vecData;
mLeafMap = nullptr;
}
}
template <typename T>
template <typename IndexIterT>
void CachedDeformer<T>::apply(Vec3d& position, const IndexIterT& iter) const
{
assert(*iter >= 0);
if (mLeafMap) {
auto it = mLeafMap->find(*iter);
if (it == mLeafMap->end()) return;
position = static_cast<openvdb::Vec3d>(it->second);
}
else {
assert(mLeafVec);
if (mLeafVec->empty()) return;
assert(*iter < mLeafVec->size());
position = static_cast<openvdb::Vec3d>((*mLeafVec)[*iter]);
}
}
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_MOVE_HAS_BEEN_INCLUDED
| 44,778 | C | 35.287682 | 119 | 0.642481 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/AttributeSet.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/AttributeSet.cc
#include "AttributeSet.h"
#include "AttributeGroup.h"
#include <algorithm> // std::equal
#include <string>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
namespace {
// remove the items from the vector corresponding to the indices
template <typename T>
void eraseIndices(std::vector<T>& vec,
const std::vector<size_t>& indices)
{
// early-exit if no indices to erase
if (indices.empty()) return;
// build the sorted, unique indices to remove
std::vector<size_t> toRemove(indices);
std::sort(toRemove.rbegin(), toRemove.rend());
toRemove.erase(unique(toRemove.begin(), toRemove.end()), toRemove.end());
// throw if the largest index is out of range
if (*toRemove.begin() >= vec.size()) {
OPENVDB_THROW(LookupError, "Cannot erase indices as index is out of range.")
}
// erase elements from the back
for (auto it = toRemove.cbegin(); it != toRemove.cend(); ++it) {
vec.erase(vec.begin() + (*it));
}
}
// return true if a string begins with a particular substring
bool startsWith(const std::string& str, const std::string& prefix)
{
return str.compare(0, prefix.length(), prefix) == 0;
}
}
////////////////////////////////////////
// AttributeSet implementation
AttributeSet::AttributeSet()
: mDescr(new Descriptor())
{
}
AttributeSet::AttributeSet(const AttributeSet& attrSet, Index arrayLength,
const AttributeArray::ScopedRegistryLock* lock)
: mDescr(attrSet.descriptorPtr())
, mAttrs(attrSet.descriptor().size(), AttributeArray::Ptr())
{
std::unique_ptr<AttributeArray::ScopedRegistryLock> localLock;
if (!lock) {
localLock.reset(new AttributeArray::ScopedRegistryLock);
lock = localLock.get();
}
const MetaMap& meta = mDescr->getMetadata();
bool hasMetadata = meta.metaCount();
for (const auto& namePos : mDescr->map()) {
const size_t& pos = namePos.second;
Metadata::ConstPtr metadata;
if (hasMetadata) metadata = meta["default:" + namePos.first];
const AttributeArray* existingArray = attrSet.getConst(pos);
const bool constantStride = existingArray->hasConstantStride();
const Index stride = constantStride ? existingArray->stride() : existingArray->dataSize();
AttributeArray::Ptr array = AttributeArray::create(mDescr->type(pos), arrayLength,
stride, constantStride, metadata.get(), lock);
// transfer hidden and transient flags
if (existingArray->isHidden()) array->setHidden(true);
if (existingArray->isTransient()) array->setTransient(true);
mAttrs[pos] = array;
}
}
AttributeSet::AttributeSet(const DescriptorPtr& descr, Index arrayLength,
const AttributeArray::ScopedRegistryLock* lock)
: mDescr(descr)
, mAttrs(descr->size(), AttributeArray::Ptr())
{
std::unique_ptr<AttributeArray::ScopedRegistryLock> localLock;
if (!lock) {
localLock.reset(new AttributeArray::ScopedRegistryLock);
lock = localLock.get();
}
const MetaMap& meta = mDescr->getMetadata();
bool hasMetadata = meta.metaCount();
for (const auto& namePos : mDescr->map()) {
const size_t& pos = namePos.second;
Metadata::ConstPtr metadata;
if (hasMetadata) metadata = meta["default:" + namePos.first];
mAttrs[pos] = AttributeArray::create(mDescr->type(pos), arrayLength,
/*stride=*/1, /*constantStride=*/true, metadata.get(), lock);
}
}
AttributeSet::AttributeSet(const AttributeSet& rhs)
: mDescr(rhs.mDescr)
, mAttrs(rhs.mAttrs)
{
}
size_t
AttributeSet::memUsage() const
{
size_t bytes = sizeof(*this) + mDescr->memUsage();
for (const auto& attr : mAttrs) {
bytes += attr->memUsage();
}
return bytes;
}
size_t
AttributeSet::find(const std::string& name) const
{
return mDescr->find(name);
}
size_t
AttributeSet::replace(const std::string& name, const AttributeArray::Ptr& attr)
{
const size_t pos = this->find(name);
return pos != INVALID_POS ? this->replace(pos, attr) : INVALID_POS;
}
size_t
AttributeSet::replace(size_t pos, const AttributeArray::Ptr& attr)
{
assert(pos != INVALID_POS);
assert(pos < mAttrs.size());
if (attr->type() != mDescr->type(pos)) {
return INVALID_POS;
}
mAttrs[pos] = attr;
return pos;
}
const AttributeArray*
AttributeSet::getConst(const std::string& name) const
{
const size_t pos = this->find(name);
if (pos < mAttrs.size()) return this->getConst(pos);
return nullptr;
}
const AttributeArray*
AttributeSet::get(const std::string& name) const
{
return this->getConst(name);
}
AttributeArray*
AttributeSet::get(const std::string& name)
{
const size_t pos = this->find(name);
if (pos < mAttrs.size()) return this->get(pos);
return nullptr;
}
const AttributeArray*
AttributeSet::getConst(size_t pos) const
{
assert(pos != INVALID_POS);
assert(pos < mAttrs.size());
return mAttrs[pos].get();
}
const AttributeArray*
AttributeSet::get(size_t pos) const
{
assert(pos != INVALID_POS);
assert(pos < mAttrs.size());
return this->getConst(pos);
}
AttributeArray*
AttributeSet::get(size_t pos)
{
makeUnique(pos);
return mAttrs[pos].get();
}
size_t
AttributeSet::groupOffset(const Name& group) const
{
return mDescr->groupOffset(group);
}
size_t
AttributeSet::groupOffset(const Util::GroupIndex& index) const
{
return mDescr->groupOffset(index);
}
AttributeSet::Descriptor::GroupIndex
AttributeSet::groupIndex(const Name& group) const
{
return mDescr->groupIndex(group);
}
AttributeSet::Descriptor::GroupIndex
AttributeSet::groupIndex(const size_t offset) const
{
return mDescr->groupIndex(offset);
}
std::vector<size_t>
AttributeSet::groupAttributeIndices() const
{
std::vector<size_t> indices;
for (const auto& namePos : mDescr->map()) {
const AttributeArray* array = this->getConst(namePos.first);
if (isGroup(*array)) {
indices.push_back(namePos.second);
}
}
return indices;
}
bool
AttributeSet::isShared(size_t pos) const
{
assert(pos != INVALID_POS);
assert(pos < mAttrs.size());
return !mAttrs[pos].unique();
}
void
AttributeSet::makeUnique(size_t pos)
{
assert(pos != INVALID_POS);
assert(pos < mAttrs.size());
if (!mAttrs[pos].unique()) {
mAttrs[pos] = mAttrs[pos]->copy();
}
}
AttributeArray::Ptr
AttributeSet::appendAttribute( const Name& name,
const NamePair& type,
const Index strideOrTotalSize,
const bool constantStride,
const Metadata* defaultValue)
{
Descriptor::Ptr descriptor = mDescr->duplicateAppend(name, type);
// store the attribute default value in the descriptor metadata
if (defaultValue) descriptor->setDefaultValue(name, *defaultValue);
// extract the index from the descriptor
const size_t pos = descriptor->find(name);
return this->appendAttribute(*mDescr, descriptor, pos, strideOrTotalSize, constantStride, defaultValue);
}
AttributeArray::Ptr
AttributeSet::appendAttribute( const Descriptor& expected, DescriptorPtr& replacement,
const size_t pos, const Index strideOrTotalSize, const bool constantStride,
const Metadata* defaultValue,
const AttributeArray::ScopedRegistryLock* lock)
{
// ensure the descriptor is as expected
if (*mDescr != expected) {
OPENVDB_THROW(LookupError, "Cannot append attributes as descriptors do not match.")
}
assert(replacement->size() >= mDescr->size());
const size_t offset = mDescr->size();
// extract the array length from the first attribute array if it exists
const Index arrayLength = offset > 0 ? this->get(0)->size() : 1;
// extract the type from the descriptor
const NamePair& type = replacement->type(pos);
// append the new array
AttributeArray::Ptr array = AttributeArray::create(
type, arrayLength, strideOrTotalSize, constantStride,
defaultValue, lock);
// if successful, update Descriptor and append the created array
mDescr = replacement;
mAttrs.push_back(array);
return array;
}
AttributeArray::Ptr
AttributeSet::removeAttribute(const Name& name)
{
const size_t pos = this->find(name);
if (pos == INVALID_POS) return AttributeArray::Ptr();
return this->removeAttribute(pos);
}
AttributeArray::Ptr
AttributeSet::removeAttribute(const size_t pos)
{
if (pos >= mAttrs.size()) return AttributeArray::Ptr();
assert(mAttrs[pos]);
AttributeArray::Ptr array;
std::swap(array, mAttrs[pos]);
assert(array);
// safely drop the attribute and update the descriptor
std::vector<size_t> toDrop{pos};
this->dropAttributes(toDrop);
return array;
}
AttributeArray::Ptr
AttributeSet::removeAttributeUnsafe(const size_t pos)
{
if (pos >= mAttrs.size()) return AttributeArray::Ptr();
assert(mAttrs[pos]);
AttributeArray::Ptr array;
std::swap(array, mAttrs[pos]);
return array;
}
void
AttributeSet::dropAttributes(const std::vector<size_t>& pos)
{
if (pos.empty()) return;
Descriptor::Ptr descriptor = mDescr->duplicateDrop(pos);
this->dropAttributes(pos, *mDescr, descriptor);
}
void
AttributeSet::dropAttributes( const std::vector<size_t>& pos,
const Descriptor& expected, DescriptorPtr& replacement)
{
if (pos.empty()) return;
// ensure the descriptor is as expected
if (*mDescr != expected) {
OPENVDB_THROW(LookupError, "Cannot drop attributes as descriptors do not match.")
}
mDescr = replacement;
eraseIndices(mAttrs, pos);
// remove any unused default values
mDescr->pruneUnusedDefaultValues();
}
void
AttributeSet::renameAttributes(const Descriptor& expected, const DescriptorPtr& replacement)
{
// ensure the descriptor is as expected
if (*mDescr != expected) {
OPENVDB_THROW(LookupError, "Cannot rename attribute as descriptors do not match.")
}
mDescr = replacement;
}
void
AttributeSet::reorderAttributes(const DescriptorPtr& replacement)
{
if (*mDescr == *replacement) {
this->resetDescriptor(replacement);
return;
}
if (!mDescr->hasSameAttributes(*replacement)) {
OPENVDB_THROW(LookupError, "Cannot reorder attributes as descriptors do not contain the same attributes.")
}
AttrArrayVec attrs(replacement->size());
// compute target indices for attributes from the given decriptor
for (const auto& namePos : mDescr->map()) {
const size_t index = replacement->find(namePos.first);
attrs[index] = AttributeArray::Ptr(mAttrs[namePos.second]);
}
// copy the ordering to the member attributes vector and update descriptor to be target
std::copy(attrs.begin(), attrs.end(), mAttrs.begin());
mDescr = replacement;
}
void
AttributeSet::resetDescriptor(const DescriptorPtr& replacement, const bool allowMismatchingDescriptors)
{
// ensure the descriptors match
if (!allowMismatchingDescriptors && *mDescr != *replacement) {
OPENVDB_THROW(LookupError, "Cannot swap descriptor as replacement does not match.")
}
mDescr = replacement;
}
void
AttributeSet::read(std::istream& is)
{
this->readDescriptor(is);
this->readMetadata(is);
this->readAttributes(is);
}
void
AttributeSet::write(std::ostream& os, bool outputTransient) const
{
this->writeDescriptor(os, outputTransient);
this->writeMetadata(os, outputTransient);
this->writeAttributes(os, outputTransient);
}
void
AttributeSet::readDescriptor(std::istream& is)
{
mDescr->read(is);
}
void
AttributeSet::writeDescriptor(std::ostream& os, bool outputTransient) const
{
// build a vector of all attribute arrays that have a transient flag
// unless also writing transient attributes
std::vector<size_t> transientArrays;
if (!outputTransient) {
for (size_t i = 0; i < size(); i++) {
const AttributeArray* array = this->getConst(i);
if (array->isTransient()) {
transientArrays.push_back(i);
}
}
}
// write out a descriptor without transient attributes
if (transientArrays.empty()) {
mDescr->write(os);
}
else {
Descriptor::Ptr descr = mDescr->duplicateDrop(transientArrays);
descr->write(os);
}
}
void
AttributeSet::readMetadata(std::istream& is)
{
AttrArrayVec(mDescr->size()).swap(mAttrs); // allocate vector
for (size_t n = 0, N = mAttrs.size(); n < N; ++n) {
mAttrs[n] = AttributeArray::create(mDescr->type(n), 1, 1);
mAttrs[n]->readMetadata(is);
}
}
void
AttributeSet::writeMetadata(std::ostream& os, bool outputTransient, bool paged) const
{
// write attribute metadata
for (size_t i = 0; i < size(); i++) {
const AttributeArray* array = this->getConst(i);
array->writeMetadata(os, outputTransient, paged);
}
}
void
AttributeSet::readAttributes(std::istream& is)
{
for (size_t i = 0; i < mAttrs.size(); i++) {
mAttrs[i]->readBuffers(is);
}
}
void
AttributeSet::writeAttributes(std::ostream& os, bool outputTransient) const
{
for (auto attr : mAttrs) {
attr->writeBuffers(os, outputTransient);
}
}
bool
AttributeSet::operator==(const AttributeSet& other) const {
if(*this->mDescr != *other.mDescr) return false;
if(this->mAttrs.size() != other.mAttrs.size()) return false;
for (size_t n = 0; n < this->mAttrs.size(); ++n) {
if (*this->mAttrs[n] != *other.mAttrs[n]) return false;
}
return true;
}
////////////////////////////////////////
// AttributeSet::Descriptor implementation
AttributeSet::Descriptor::Descriptor()
{
}
AttributeSet::Descriptor::Descriptor(const Descriptor& rhs)
: mNameMap(rhs.mNameMap)
, mTypes(rhs.mTypes)
, mGroupMap(rhs.mGroupMap)
, mMetadata(rhs.mMetadata)
{
}
bool
AttributeSet::Descriptor::operator==(const Descriptor& rhs) const
{
if (this == &rhs) return true;
if (mTypes.size() != rhs.mTypes.size() ||
mNameMap.size() != rhs.mNameMap.size() ||
mGroupMap.size() != rhs.mGroupMap.size()) {
return false;
}
for (size_t n = 0, N = mTypes.size(); n < N; ++n) {
if (mTypes[n] != rhs.mTypes[n]) return false;
}
if (this->mMetadata != rhs.mMetadata) return false;
return std::equal(mGroupMap.begin(), mGroupMap.end(), rhs.mGroupMap.begin()) &&
std::equal(mNameMap.begin(), mNameMap.end(), rhs.mNameMap.begin());
}
bool
AttributeSet::Descriptor::hasSameAttributes(const Descriptor& rhs) const
{
if (this == &rhs) return true;
if (mTypes.size() != rhs.mTypes.size() ||
mNameMap.size() != rhs.mNameMap.size() ||
mGroupMap.size() != rhs.mGroupMap.size()) {
return false;
}
for (const auto& namePos : mNameMap) {
const size_t index = rhs.find(namePos.first);
if (index == INVALID_POS) return false;
if (mTypes[namePos.second] != rhs.mTypes[index]) return false;
}
return std::equal(mGroupMap.begin(), mGroupMap.end(), rhs.mGroupMap.begin());
}
size_t
AttributeSet::Descriptor::count(const NamePair& matchType) const
{
return std::count(mTypes.begin(), mTypes.end(), matchType);
}
size_t
AttributeSet::Descriptor::memUsage() const
{
size_t bytes = sizeof(NameToPosMap::mapped_type) * this->size();
for (const auto& namePos : mNameMap) {
bytes += namePos.first.capacity();
}
for (const NamePair& type : mTypes) {
bytes += type.first.capacity();
bytes += type.second.capacity();
}
return sizeof(*this) + bytes;
}
size_t
AttributeSet::Descriptor::find(const std::string& name) const
{
auto it = mNameMap.find(name);
if (it != mNameMap.end()) {
return it->second;
}
return INVALID_POS;
}
size_t
AttributeSet::Descriptor::rename(const std::string& fromName, const std::string& toName)
{
if (!validName(toName)) throw RuntimeError("Attribute name contains invalid characters - " + toName);
size_t pos = INVALID_POS;
// check if the new name is already used.
auto it = mNameMap.find(toName);
if (it != mNameMap.end()) return pos;
it = mNameMap.find(fromName);
if (it != mNameMap.end()) {
pos = it->second;
mNameMap.erase(it);
mNameMap[toName] = pos;
// rename default value if it exists
std::stringstream ss;
ss << "default:" << fromName;
Metadata::Ptr defaultValue = mMetadata[ss.str()];
if (defaultValue) {
mMetadata.removeMeta(ss.str());
ss.str("");
ss << "default:" << toName;
mMetadata.insertMeta(ss.str(), *defaultValue);
}
}
return pos;
}
size_t
AttributeSet::Descriptor::renameGroup(const std::string& fromName, const std::string& toName)
{
if (!validName(toName)) throw RuntimeError("Group name contains invalid characters - " + toName);
size_t pos = INVALID_POS;
// check if the new name is already used.
auto it = mGroupMap.find(toName);
if (it != mGroupMap.end()) return pos;
it = mGroupMap.find(fromName);
if (it != mGroupMap.end()) {
pos = it->second;
mGroupMap.erase(it);
mGroupMap[toName] = pos;
}
return pos;
}
const Name&
AttributeSet::Descriptor::valueType(size_t pos) const
{
// pos is assumed to exist
return this->type(pos).first;
}
const NamePair&
AttributeSet::Descriptor::type(size_t pos) const
{
// assert that pos is valid and in-range
assert(pos != AttributeSet::INVALID_POS);
assert(pos < mTypes.size());
return mTypes[pos];
}
MetaMap&
AttributeSet::Descriptor::getMetadata()
{
return mMetadata;
}
const MetaMap&
AttributeSet::Descriptor::getMetadata() const
{
return mMetadata;
}
bool
AttributeSet::Descriptor::hasDefaultValue(const Name& name) const
{
std::stringstream ss;
ss << "default:" << name;
return bool(mMetadata[ss.str()]);
}
void
AttributeSet::Descriptor::setDefaultValue(const Name& name, const Metadata& defaultValue)
{
const size_t pos = find(name);
if (pos == INVALID_POS) {
OPENVDB_THROW(LookupError, "Cannot find attribute name to set default value.")
}
// check type of metadata matches attribute type
const Name& valueType = this->valueType(pos);
if (valueType != defaultValue.typeName()) {
OPENVDB_THROW(TypeError, "Mis-matching Default Value Type");
}
std::stringstream ss;
ss << "default:" << name;
mMetadata.insertMeta(ss.str(), defaultValue);
}
void
AttributeSet::Descriptor::removeDefaultValue(const Name& name)
{
std::stringstream ss;
ss << "default:" << name;
mMetadata.removeMeta(ss.str());
}
void
AttributeSet::Descriptor::pruneUnusedDefaultValues()
{
// store any default metadata keys for which the attribute name is no longer present
std::vector<Name> metaToErase;
for (auto it = mMetadata.beginMeta(), itEnd = mMetadata.endMeta(); it != itEnd; ++it) {
const Name name = it->first;
// ignore non-default metadata
if (!startsWith(name, "default:")) continue;
const Name defaultName = name.substr(8, it->first.size() - 8);
if (mNameMap.find(defaultName) == mNameMap.end()) {
metaToErase.push_back(name);
}
}
// remove this metadata
for (const Name& name : metaToErase) {
mMetadata.removeMeta(name);
}
}
size_t
AttributeSet::Descriptor::insert(const std::string& name, const NamePair& typeName)
{
if (!validName(name)) throw RuntimeError("Attribute name contains invalid characters - " + name);
size_t pos = INVALID_POS;
auto it = mNameMap.find(name);
if (it != mNameMap.end()) {
assert(it->second < mTypes.size());
if (mTypes[it->second] != typeName) {
OPENVDB_THROW(KeyError,
"Cannot insert into a Descriptor with a duplicate name, but different type.")
}
pos = it->second;
} else {
if (!AttributeArray::isRegistered(typeName)) {
OPENVDB_THROW(KeyError, "Failed to insert '" << name
<< "' with unregistered attribute type '" << typeName.first << "_" << typeName.second);
}
pos = mTypes.size();
mTypes.push_back(typeName);
mNameMap.insert(it, NameToPosMap::value_type(name, pos));
}
return pos;
}
AttributeSet::Descriptor::Ptr
AttributeSet::Descriptor::create(const NameAndTypeVec& attrs,
const NameToPosMap& groupMap,
const MetaMap& metadata)
{
auto newDescriptor = std::make_shared<Descriptor>();
for (const NameAndType& attr : attrs) {
newDescriptor->insert(attr.name, attr.type);
}
newDescriptor->mGroupMap = groupMap;
newDescriptor->mMetadata = metadata;
return newDescriptor;
}
AttributeSet::Descriptor::Ptr
AttributeSet::Descriptor::create(const NamePair& positionType)
{
auto descr = std::make_shared<Descriptor>();
descr->insert("P", positionType);
return descr;
}
AttributeSet::Descriptor::Ptr
AttributeSet::Descriptor::duplicateAppend(const Name& name, const NamePair& type) const
{
Inserter attributes;
this->appendTo(attributes.vec);
attributes.add(NameAndType(name, type));
return Descriptor::create(attributes.vec, mGroupMap, mMetadata);
}
AttributeSet::Descriptor::Ptr
AttributeSet::Descriptor::duplicateDrop(const std::vector<size_t>& pos) const
{
NameAndTypeVec vec;
this->appendTo(vec);
Descriptor::Ptr descriptor;
// If groups exist, check to see if those arrays are being dropped
if (!mGroupMap.empty()) {
// extract all attribute array group indices and specific groups
// to drop
std::vector<size_t> groups, groupsToDrop;
for (size_t i = 0; i < vec.size(); i++) {
if (vec[i].type == GroupAttributeArray::attributeType()) {
groups.push_back(i);
if (std::find(pos.begin(), pos.end(), i) != pos.end()) {
groupsToDrop.push_back(i);
}
}
}
// drop the indices in indices from vec
eraseIndices(vec, pos);
if (!groupsToDrop.empty()) {
// configure group mapping if group arrays have been dropped
NameToPosMap droppedGroupMap = mGroupMap;
const size_t GROUP_BITS = sizeof(GroupType) * CHAR_BIT;
for (auto iter = droppedGroupMap.begin(); iter != droppedGroupMap.end();) {
const size_t groupArrayPos = iter->second / GROUP_BITS;
const size_t arrayPos = groups[groupArrayPos];
if (std::find(pos.begin(), pos.end(), arrayPos) != pos.end()) {
iter = droppedGroupMap.erase(iter);
}
else {
size_t offset(0);
for (const size_t& idx : groupsToDrop) {
if (idx >= arrayPos) break;
++offset;
}
iter->second -= (offset * GROUP_BITS);
++iter;
}
}
descriptor = Descriptor::create(vec, droppedGroupMap, mMetadata);
// remove any unused default values
descriptor->pruneUnusedDefaultValues();
return descriptor;
}
}
else {
// drop the indices in pos from vec
eraseIndices(vec, pos);
}
descriptor = Descriptor::create(vec, mGroupMap, mMetadata);
// remove any unused default values
descriptor->pruneUnusedDefaultValues();
return descriptor;
}
void
AttributeSet::Descriptor::appendTo(NameAndTypeVec& attrs) const
{
// build a std::map<pos, name> (ie key and value swapped)
using PosToNameMap = std::map<size_t, std::string>;
PosToNameMap posToNameMap;
for (const auto& namePos : mNameMap) {
posToNameMap[namePos.second] = namePos.first;
}
// std::map is sorted by key, so attributes can now be inserted in position order
for (const auto& posName : posToNameMap) {
attrs.emplace_back(posName.second, this->type(posName.first));
}
}
bool
AttributeSet::Descriptor::hasGroup(const Name& group) const
{
return mGroupMap.find(group) != mGroupMap.end();
}
void
AttributeSet::Descriptor::setGroup(const Name& group, const size_t offset,
const bool checkValidOffset)
{
if (!validName(group)) {
throw RuntimeError("Group name contains invalid characters - " + group);
}
if (checkValidOffset) {
// check offset is not out-of-range
if (offset >= this->availableGroups()) {
throw RuntimeError("Group offset is out-of-range - " + group);
}
// check offset is not already in use
for (const auto& namePos : mGroupMap) {
if (namePos.second == offset) {
throw RuntimeError("Group offset is already in use - " + group);
}
}
}
mGroupMap[group] = offset;
}
void
AttributeSet::Descriptor::dropGroup(const Name& group)
{
mGroupMap.erase(group);
}
void
AttributeSet::Descriptor::clearGroups()
{
mGroupMap.clear();
}
const Name
AttributeSet::Descriptor::uniqueName(const Name& name) const
{
auto it = mNameMap.find(name);
if (it == mNameMap.end()) return name;
std::ostringstream ss;
size_t i(0);
while (it != mNameMap.end()) {
ss.str("");
ss << name << i++;
it = mNameMap.find(ss.str());
}
return ss.str();
}
const Name
AttributeSet::Descriptor::uniqueGroupName(const Name& name) const
{
auto it = mGroupMap.find(name);
if (it == mGroupMap.end()) return name;
std::ostringstream ss;
size_t i(0);
while (it != mGroupMap.end()) {
ss.str("");
ss << name << i++;
it = mGroupMap.find(ss.str());
}
return ss.str();
}
size_t
AttributeSet::Descriptor::groupOffset(const Name& group) const
{
const auto it = mGroupMap.find(group);
if (it == mGroupMap.end()) {
return INVALID_POS;
}
return it->second;
}
size_t
AttributeSet::Descriptor::groupOffset(const Util::GroupIndex& index) const
{
if (index.first >= mNameMap.size()) {
OPENVDB_THROW(LookupError, "Out of range group index.")
}
if (mTypes[index.first] != GroupAttributeArray::attributeType()) {
OPENVDB_THROW(LookupError, "Group index invalid.")
}
// find the relative index in the group attribute arrays
size_t relativeIndex = 0;
for (const auto& namePos : mNameMap) {
if (namePos.second < index.first &&
mTypes[namePos.second] == GroupAttributeArray::attributeType()) {
relativeIndex++;
}
}
const size_t GROUP_BITS = sizeof(GroupType) * CHAR_BIT;
return (relativeIndex * GROUP_BITS) + index.second;
}
AttributeSet::Descriptor::GroupIndex
AttributeSet::Descriptor::groupIndex(const Name& group) const
{
const size_t offset = this->groupOffset(group);
if (offset == INVALID_POS) {
OPENVDB_THROW(LookupError, "Group not found - " << group << ".")
}
return this->groupIndex(offset);
}
AttributeSet::Descriptor::GroupIndex
AttributeSet::Descriptor::groupIndex(const size_t offset) const
{
// extract all attribute array group indices
std::vector<size_t> groups;
for (const auto& namePos : mNameMap) {
if (mTypes[namePos.second] == GroupAttributeArray::attributeType()) {
groups.push_back(namePos.second);
}
}
if (offset >= groups.size() * this->groupBits()) {
OPENVDB_THROW(LookupError, "Out of range group offset - " << offset << ".")
}
// adjust relative offset to find offset into the array vector
std::sort(groups.begin(), groups.end());
return Util::GroupIndex(groups[offset / this->groupBits()],
static_cast<uint8_t>(offset % this->groupBits()));
}
size_t
AttributeSet::Descriptor::availableGroups() const
{
// the number of group attributes * number of bits per group
const size_t groupAttributes =
this->count(GroupAttributeArray::attributeType());
return groupAttributes * this->groupBits();
}
size_t
AttributeSet::Descriptor::unusedGroups() const
{
// compute total slots (one slot per bit of the group attributes)
const size_t availableGroups = this->availableGroups();
if (availableGroups == 0) return 0;
// compute slots in use
const size_t usedGroups = mGroupMap.size();
return availableGroups - usedGroups;
}
bool
AttributeSet::Descriptor::canCompactGroups() const
{
// can compact if more unused groups than in one group attribute array
return this->unusedGroups() >= this->groupBits();
}
size_t
AttributeSet::Descriptor::unusedGroupOffset(size_t hint) const
{
// all group offsets are in use
if (unusedGroups() == size_t(0)) {
return std::numeric_limits<size_t>::max();
}
// build a list of group indices
std::vector<size_t> indices;
indices.reserve(mGroupMap.size());
for (const auto& namePos : mGroupMap) {
indices.push_back(namePos.second);
}
std::sort(indices.begin(), indices.end());
// return hint if not already in use
if (hint != std::numeric_limits<Index>::max() &&
hint < availableGroups() &&
std::find(indices.begin(), indices.end(), hint) == indices.end()) {
return hint;
}
// otherwise return first index not present
size_t offset = 0;
for (const size_t& index : indices) {
if (index != offset) break;
offset++;
}
return offset;
}
bool
AttributeSet::Descriptor::requiresGroupMove(Name& sourceName,
size_t& sourceOffset, size_t& targetOffset) const
{
targetOffset = this->unusedGroupOffset();
for (const auto& namePos : mGroupMap) {
// move only required if source comes after the target
if (namePos.second >= targetOffset) {
sourceName = namePos.first;
sourceOffset = namePos.second;
return true;
}
}
return false;
}
bool
AttributeSet::Descriptor::groupIndexCollision(const Descriptor& rhs) const
{
const auto& groupMap = this->groupMap();
const auto& otherGroupMap = rhs.groupMap();
// iterate both group maps at the same time and find any keys that occur
// in both maps and test their values for equality
auto groupsIt1 = groupMap.cbegin();
auto groupsIt2 = otherGroupMap.cbegin();
while (groupsIt1 != groupMap.cend() && groupsIt2 != otherGroupMap.cend()) {
if (groupsIt1->first < groupsIt2->first) {
++groupsIt1;
} else if (groupsIt1->first > groupsIt2->first) {
++groupsIt2;
} else {
if (groupsIt1->second != groupsIt2->second) {
return true;
} else {
++groupsIt1;
++groupsIt2;
}
}
}
return false;
}
bool
AttributeSet::Descriptor::validName(const Name& name)
{
if (name.empty()) return false;
return std::find_if(name.begin(), name.end(),
[&](int c) { return !(isalnum(c) || (c == '_') || (c == '|') || (c == ':')); } ) == name.end();
}
void
AttributeSet::Descriptor::parseNames( std::vector<std::string>& includeNames,
std::vector<std::string>& excludeNames,
bool& includeAll,
const std::string& nameStr)
{
includeAll = false;
std::stringstream tokenStream(nameStr);
Name token;
while (tokenStream >> token) {
bool negate = startsWith(token, "^") || startsWith(token, "!");
if (negate) {
if (token.length() < 2) throw RuntimeError("Negate character (^) must prefix a name.");
token = token.substr(1, token.length()-1);
if (!validName(token)) throw RuntimeError("Name contains invalid characters - " + token);
excludeNames.push_back(token);
}
else if (!includeAll) {
if (token == "*") {
includeAll = true;
includeNames.clear();
continue;
}
if (!validName(token)) throw RuntimeError("Name contains invalid characters - " + token);
includeNames.push_back(token);
}
}
}
void
AttributeSet::Descriptor::parseNames( std::vector<std::string>& includeNames,
std::vector<std::string>& excludeNames,
const std::string& nameStr)
{
bool includeAll = false;
Descriptor::parseNames(includeNames, excludeNames, includeAll, nameStr);
}
void
AttributeSet::Descriptor::write(std::ostream& os) const
{
const Index64 arraylength = Index64(mTypes.size());
os.write(reinterpret_cast<const char*>(&arraylength), sizeof(Index64));
for (const NamePair& np : mTypes) {
writeString(os, np.first);
writeString(os, np.second);
}
for (auto it = mNameMap.begin(), endIt = mNameMap.end(); it != endIt; ++it) {
writeString(os, it->first);
os.write(reinterpret_cast<const char*>(&it->second), sizeof(Index64));
}
const Index64 grouplength = Index64(mGroupMap.size());
os.write(reinterpret_cast<const char*>(&grouplength), sizeof(Index64));
for (auto groupIt = mGroupMap.cbegin(), endGroupIt = mGroupMap.cend(); groupIt != endGroupIt; ++groupIt) {
writeString(os, groupIt->first);
os.write(reinterpret_cast<const char*>(&groupIt->second), sizeof(Index64));
}
mMetadata.writeMeta(os);
}
void
AttributeSet::Descriptor::read(std::istream& is)
{
Index64 arraylength = 0;
is.read(reinterpret_cast<char*>(&arraylength), sizeof(Index64));
std::vector<NamePair>(size_t(arraylength)).swap(mTypes);
for (NamePair& np : mTypes) {
np.first = readString(is);
np.second = readString(is);
}
mNameMap.clear();
std::pair<std::string, size_t> nameAndOffset;
for (Index64 n = 0; n < arraylength; ++n) {
nameAndOffset.first = readString(is);
if (!validName(nameAndOffset.first)) throw IoError("Attribute name contains invalid characters - " + nameAndOffset.first);
is.read(reinterpret_cast<char*>(&nameAndOffset.second), sizeof(Index64));
mNameMap.insert(nameAndOffset);
}
Index64 grouplength = 0;
is.read(reinterpret_cast<char*>(&grouplength), sizeof(Index64));
for (Index64 n = 0; n < grouplength; ++n) {
nameAndOffset.first = readString(is);
if (!validName(nameAndOffset.first)) throw IoError("Group name contains invalid characters - " + nameAndOffset.first);
is.read(reinterpret_cast<char*>(&nameAndOffset.second), sizeof(Index64));
mGroupMap.insert(nameAndOffset);
}
mMetadata.readMeta(is);
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
| 35,714 | C++ | 24.861694 | 131 | 0.624685 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointAttribute.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @author Dan Bailey, Khang Ngo
///
/// @file points/PointAttribute.h
///
/// @brief Point attribute manipulation in a VDB Point Grid.
#ifndef OPENVDB_POINTS_POINT_ATTRIBUTE_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_ATTRIBUTE_HAS_BEEN_INCLUDED
#include <openvdb/openvdb.h>
#include "AttributeArrayString.h"
#include "AttributeSet.h"
#include "AttributeGroup.h"
#include "PointDataGrid.h"
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
namespace point_attribute_internal {
template <typename ValueType>
struct Default
{
static inline ValueType value() { return zeroVal<ValueType>(); }
};
} // namespace point_attribute_internal
/// @brief Appends a new attribute to the VDB tree
/// (this method does not require a templated AttributeType)
///
/// @param tree the PointDataTree to be appended to.
/// @param name name for the new attribute.
/// @param type the type of the attibute.
/// @param strideOrTotalSize the stride of the attribute
/// @param constantStride if @c false, stride is interpreted as total size of the array
/// @param defaultValue metadata default attribute value
/// @param hidden mark attribute as hidden
/// @param transient mark attribute as transient
template <typename PointDataTreeT>
inline void appendAttribute(PointDataTreeT& tree,
const Name& name,
const NamePair& type,
const Index strideOrTotalSize = 1,
const bool constantStride = true,
const Metadata* defaultValue = nullptr,
const bool hidden = false,
const bool transient = false);
/// @brief Appends a new attribute to the VDB tree.
///
/// @param tree the PointDataTree to be appended to.
/// @param name name for the new attribute
/// @param uniformValue the initial value of the attribute
/// @param strideOrTotalSize the stride of the attribute
/// @param constantStride if @c false, stride is interpreted as total size of the array
/// @param defaultValue metadata default attribute value
/// @param hidden mark attribute as hidden
/// @param transient mark attribute as transient
template <typename ValueType,
typename CodecType = NullCodec,
typename PointDataTreeT = PointDataTree>
inline void appendAttribute(PointDataTreeT& tree,
const std::string& name,
const ValueType& uniformValue =
point_attribute_internal::Default<ValueType>::value(),
const Index strideOrTotalSize = 1,
const bool constantStride = true,
const TypedMetadata<ValueType>* defaultValue = nullptr,
const bool hidden = false,
const bool transient = false);
/// @brief Collapse the attribute into a uniform value
///
/// @param tree the PointDataTree in which to collapse the attribute.
/// @param name name for the attribute.
/// @param uniformValue value of the attribute
template <typename ValueType, typename PointDataTreeT>
inline void collapseAttribute( PointDataTreeT& tree,
const Name& name,
const ValueType& uniformValue =
point_attribute_internal::Default<ValueType>::value());
/// @brief Drops attributes from the VDB tree.
///
/// @param tree the PointDataTree to be dropped from.
/// @param indices indices of the attributes to drop.
template <typename PointDataTreeT>
inline void dropAttributes( PointDataTreeT& tree,
const std::vector<size_t>& indices);
/// @brief Drops attributes from the VDB tree.
///
/// @param tree the PointDataTree to be dropped from.
/// @param names names of the attributes to drop.
template <typename PointDataTreeT>
inline void dropAttributes( PointDataTreeT& tree,
const std::vector<Name>& names);
/// @brief Drop one attribute from the VDB tree (convenience method).
///
/// @param tree the PointDataTree to be dropped from.
/// @param index index of the attribute to drop.
template <typename PointDataTreeT>
inline void dropAttribute( PointDataTreeT& tree,
const size_t& index);
/// @brief Drop one attribute from the VDB tree (convenience method).
///
/// @param tree the PointDataTree to be dropped from.
/// @param name name of the attribute to drop.
template <typename PointDataTreeT>
inline void dropAttribute( PointDataTreeT& tree,
const Name& name);
/// @brief Rename attributes in a VDB tree.
///
/// @param tree the PointDataTree.
/// @param oldNames a list of old attribute names to rename from.
/// @param newNames a list of new attribute names to rename to.
///
/// @note Number of oldNames must match the number of newNames.
///
/// @note Duplicate names and renaming group attributes are not allowed.
template <typename PointDataTreeT>
inline void renameAttributes(PointDataTreeT& tree,
const std::vector<Name>& oldNames,
const std::vector<Name>& newNames);
/// @brief Rename an attribute in a VDB tree.
///
/// @param tree the PointDataTree.
/// @param oldName the old attribute name to rename from.
/// @param newName the new attribute name to rename to.
///
/// @note newName must not already exist and must not be a group attribute.
template <typename PointDataTreeT>
inline void renameAttribute(PointDataTreeT& tree,
const Name& oldName,
const Name& newName);
/// @brief Compact attributes in a VDB tree (if possible).
///
/// @param tree the PointDataTree.
template <typename PointDataTreeT>
inline void compactAttributes(PointDataTreeT& tree);
////////////////////////////////////////
namespace point_attribute_internal {
template <typename ValueType>
inline void collapseAttribute(AttributeArray& array,
const AttributeSet::Descriptor&, const ValueType& uniformValue)
{
AttributeWriteHandle<ValueType> handle(array);
handle.collapse(uniformValue);
}
inline void collapseAttribute(AttributeArray& array,
const AttributeSet::Descriptor& descriptor, const Name& uniformValue)
{
StringAttributeWriteHandle handle(array, descriptor.getMetadata());
handle.collapse(uniformValue);
}
////////////////////////////////////////
template <typename ValueType, typename CodecType>
struct AttributeTypeConversion
{
static const NamePair& type() {
return TypedAttributeArray<ValueType, CodecType>::attributeType();
}
};
template <typename CodecType>
struct AttributeTypeConversion<Name, CodecType>
{
static const NamePair& type() { return StringAttributeArray::attributeType(); }
};
////////////////////////////////////////
template <typename PointDataTreeT, typename ValueType>
struct MetadataStorage
{
static void add(PointDataTreeT&, const ValueType&) {}
template<typename AttributeListType>
static void add(PointDataTreeT&, const AttributeListType&) {}
};
template <typename PointDataTreeT>
struct MetadataStorage<PointDataTreeT, Name>
{
static void add(PointDataTreeT& tree, const Name& uniformValue) {
MetaMap& metadata = makeDescriptorUnique(tree)->getMetadata();
StringMetaInserter inserter(metadata);
inserter.insert(uniformValue);
}
template<typename AttributeListType>
static void add(PointDataTreeT& tree, const AttributeListType& data) {
MetaMap& metadata = makeDescriptorUnique(tree)->getMetadata();
StringMetaInserter inserter(metadata);
Name value;
for (size_t i = 0; i < data.size(); i++) {
data.get(value, i);
inserter.insert(value);
}
}
};
} // namespace point_attribute_internal
////////////////////////////////////////
template <typename PointDataTreeT>
inline void appendAttribute(PointDataTreeT& tree,
const Name& name,
const NamePair& type,
const Index strideOrTotalSize,
const bool constantStride,
const Metadata* defaultValue,
const bool hidden,
const bool transient)
{
auto iter = tree.cbeginLeaf();
if (!iter) return;
// do not append a non-unique attribute
const auto& descriptor = iter->attributeSet().descriptor();
const size_t index = descriptor.find(name);
if (index != AttributeSet::INVALID_POS) {
OPENVDB_THROW(KeyError,
"Cannot append an attribute with a non-unique name - " << name << ".");
}
// create a new attribute descriptor
auto newDescriptor = descriptor.duplicateAppend(name, type);
// store the attribute default value in the descriptor metadata
if (defaultValue) {
newDescriptor->setDefaultValue(name, *defaultValue);
}
// extract new pos
const size_t pos = newDescriptor->find(name);
// acquire registry lock to avoid locking when appending attributes in parallel
AttributeArray::ScopedRegistryLock lock;
// insert attributes using the new descriptor
tree::LeafManager<PointDataTreeT> leafManager(tree);
leafManager.foreach(
[&](typename PointDataTree::LeafNodeType& leaf, size_t /*idx*/) {
auto expected = leaf.attributeSet().descriptorPtr();
auto attribute = leaf.appendAttribute(*expected, newDescriptor,
pos, strideOrTotalSize, constantStride, defaultValue,
&lock);
if (hidden) attribute->setHidden(true);
if (transient) attribute->setTransient(true);
}, /*threaded=*/ true
);
}
////////////////////////////////////////
template <typename ValueType, typename CodecType, typename PointDataTreeT>
inline void appendAttribute(PointDataTreeT& tree,
const std::string& name,
const ValueType& uniformValue,
const Index strideOrTotalSize,
const bool constantStride,
const TypedMetadata<ValueType>* defaultValue,
const bool hidden,
const bool transient)
{
static_assert(!std::is_base_of<AttributeArray, ValueType>::value,
"ValueType must not be derived from AttributeArray");
using point_attribute_internal::AttributeTypeConversion;
using point_attribute_internal::Default;
using point_attribute_internal::MetadataStorage;
appendAttribute(tree, name, AttributeTypeConversion<ValueType, CodecType>::type(),
strideOrTotalSize, constantStride, defaultValue, hidden, transient);
// if the uniform value is equal to either the default value provided
// through the metadata argument or the default value for this value type,
// it is not necessary to perform the collapse
const bool uniformIsDefault = math::isExactlyEqual(uniformValue,
bool(defaultValue) ? defaultValue->value() : Default<ValueType>::value());
if (!uniformIsDefault) {
MetadataStorage<PointDataTreeT, ValueType>::add(tree, uniformValue);
collapseAttribute<ValueType>(tree, name, uniformValue);
}
}
////////////////////////////////////////
template <typename ValueType, typename PointDataTreeT>
inline void collapseAttribute( PointDataTreeT& tree,
const Name& name,
const ValueType& uniformValue)
{
static_assert(!std::is_base_of<AttributeArray, ValueType>::value,
"ValueType must not be derived from AttributeArray");
auto iter = tree.cbeginLeaf();
if (!iter) return;
const auto& descriptor = iter->attributeSet().descriptor();
// throw if attribute name does not exist
const size_t index = descriptor.find(name);
if (index == AttributeSet::INVALID_POS) {
OPENVDB_THROW(KeyError, "Cannot find attribute name in PointDataTree.");
}
tree::LeafManager<PointDataTreeT> leafManager(tree);
leafManager.foreach(
[&](typename PointDataTree::LeafNodeType& leaf, size_t /*idx*/) {
assert(leaf.hasAttribute(index));
AttributeArray& array = leaf.attributeArray(index);
point_attribute_internal::collapseAttribute(
array, descriptor, uniformValue);
}, /*threaded=*/true
);
}
////////////////////////////////////////
template <typename PointDataTreeT>
inline void dropAttributes( PointDataTreeT& tree,
const std::vector<size_t>& indices)
{
auto iter = tree.cbeginLeaf();
if (!iter) return;
const auto& descriptor = iter->attributeSet().descriptor();
// throw if position index present in the indices as this attribute is mandatory
const size_t positionIndex = descriptor.find("P");
if (positionIndex!= AttributeSet::INVALID_POS &&
std::find(indices.begin(), indices.end(), positionIndex) != indices.end()) {
OPENVDB_THROW(KeyError, "Cannot drop mandatory position attribute.");
}
// insert attributes using the new descriptor
auto newDescriptor = descriptor.duplicateDrop(indices);
tree::LeafManager<PointDataTreeT> leafManager(tree);
leafManager.foreach(
[&](typename PointDataTree::LeafNodeType& leaf, size_t /*idx*/) {
auto expected = leaf.attributeSet().descriptorPtr();
leaf.dropAttributes(indices, *expected, newDescriptor);
}, /*threaded=*/true
);
}
////////////////////////////////////////
template <typename PointDataTreeT>
inline void dropAttributes( PointDataTreeT& tree,
const std::vector<Name>& names)
{
auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
const AttributeSet::Descriptor& descriptor = attributeSet.descriptor();
std::vector<size_t> indices;
for (const Name& name : names) {
const size_t index = descriptor.find(name);
// do not attempt to drop an attribute that does not exist
if (index == AttributeSet::INVALID_POS) {
OPENVDB_THROW(KeyError,
"Cannot drop an attribute that does not exist - " << name << ".");
}
indices.push_back(index);
}
dropAttributes(tree, indices);
}
////////////////////////////////////////
template <typename PointDataTreeT>
inline void dropAttribute( PointDataTreeT& tree,
const size_t& index)
{
std::vector<size_t> indices{index};
dropAttributes(tree, indices);
}
template <typename PointDataTreeT>
inline void dropAttribute( PointDataTreeT& tree,
const Name& name)
{
std::vector<Name> names{name};
dropAttributes(tree, names);
}
////////////////////////////////////////
template <typename PointDataTreeT>
inline void renameAttributes( PointDataTreeT& tree,
const std::vector<Name>& oldNames,
const std::vector<Name>& newNames)
{
if (oldNames.size() != newNames.size()) {
OPENVDB_THROW(ValueError, "Mis-matching sizes of name vectors, cannot rename attributes.");
}
using Descriptor = AttributeSet::Descriptor;
auto iter = tree.beginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
const Descriptor::Ptr descriptor = attributeSet.descriptorPtr();
auto newDescriptor = std::make_shared<Descriptor>(*descriptor);
for (size_t i = 0; i < oldNames.size(); i++) {
const Name& oldName = oldNames[i];
if (descriptor->find(oldName) == AttributeSet::INVALID_POS) {
OPENVDB_THROW(KeyError, "Cannot find requested attribute - " << oldName << ".");
}
const Name& newName = newNames[i];
if (descriptor->find(newName) != AttributeSet::INVALID_POS) {
OPENVDB_THROW(KeyError,
"Cannot rename attribute as new name already exists - " << newName << ".");
}
const AttributeArray* array = attributeSet.getConst(oldName);
assert(array);
if (isGroup(*array)) {
OPENVDB_THROW(KeyError, "Cannot rename group attribute - " << oldName << ".");
}
newDescriptor->rename(oldName, newName);
}
for (; iter; ++iter) {
iter->renameAttributes(*descriptor, newDescriptor);
}
}
template <typename PointDataTreeT>
inline void renameAttribute(PointDataTreeT& tree,
const Name& oldName,
const Name& newName)
{
renameAttributes(tree, {oldName}, {newName});
}
////////////////////////////////////////
template <typename PointDataTreeT>
inline void compactAttributes(PointDataTreeT& tree)
{
auto iter = tree.beginLeaf();
if (!iter) return;
tree::LeafManager<PointDataTreeT> leafManager(tree);
leafManager.foreach(
[&](typename PointDataTree::LeafNodeType& leaf, size_t /*idx*/) {
leaf.compactAttributes();
}, /*threaded=*/ true
);
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_ATTRIBUTE_HAS_BEEN_INCLUDED
| 17,919 | C | 31.820513 | 99 | 0.62124 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointDelete.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @author Nick Avramoussis, Francisco Gochez, Dan Bailey
///
/// @file PointDelete.h
///
/// @brief Methods for deleting points based on group membership
#ifndef OPENVDB_POINTS_POINT_DELETE_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_DELETE_HAS_BEEN_INCLUDED
#include "PointDataGrid.h"
#include "PointGroup.h"
#include "IndexIterator.h"
#include "IndexFilter.h"
#include <openvdb/tools/Prune.h>
#include <openvdb/tree/LeafManager.h>
#include <memory>
#include <string>
#include <vector>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
/// @brief Delete points that are members of specific groups
///
/// @details This method will delete points which are members of any of the supplied groups and
/// will optionally drop the groups from the tree. An invert flag can be used to
/// delete points that belong to none of the groups.
///
/// @param pointTree the point tree
/// @param groups the groups from which to delete points
/// @param invert if enabled, points not belonging to any of the groups will be deleted
/// @param drop if enabled and invert is disabled, the groups will be dropped from the tree
///
/// @note If the invert flag is true, none of the groups will be dropped after deleting points
/// regardless of the value of the drop parameter.
template <typename PointDataTreeT>
inline void deleteFromGroups(PointDataTreeT& pointTree,
const std::vector<std::string>& groups,
bool invert = false,
bool drop = true);
/// @brief Delete points that are members of a group
///
/// @details This method will delete points which are members of the supplied group and will
/// optionally drop the group from the tree. An invert flag can be used to
/// delete points that belong to none of the groups.
///
/// @param pointTree the point tree with the group to delete
/// @param group the name of the group to delete
/// @param invert if enabled, points not belonging to any of the groups will be deleted
/// @param drop if enabled and invert is disabled, the group will be dropped from the tree
///
/// @note If the invert flag is true, the group will not be dropped after deleting points
/// regardless of the value of the drop parameter.
template <typename PointDataTreeT>
inline void deleteFromGroup(PointDataTreeT& pointTree,
const std::string& group,
bool invert = false,
bool drop = true);
////////////////////////////////////////
namespace point_delete_internal {
struct VectorWrapper
{
using T = std::vector<std::pair<Index, Index>>;
VectorWrapper(const T& _data) : data(_data) { }
operator bool() const { return index < data.size(); }
VectorWrapper& operator++() { index++; return *this; }
Index sourceIndex() const { assert(*this); return data[index].first; }
Index targetIndex() const { assert(*this); return data[index].second; }
private:
const T& data;
T::size_type index = 0;
}; // struct VectorWrapper
template <typename PointDataTreeT, typename FilterT>
struct DeleteByFilterOp
{
using LeafManagerT = tree::LeafManager<PointDataTreeT>;
using LeafRangeT = typename LeafManagerT::LeafRange;
using LeafNodeT = typename PointDataTreeT::LeafNodeType;
using ValueType = typename LeafNodeT::ValueType;
DeleteByFilterOp(const FilterT& filter,
const AttributeArray::ScopedRegistryLock* lock)
: mFilter(filter)
, mLock(lock) { }
void operator()(const LeafRangeT& range) const
{
for (auto leaf = range.begin(); leaf != range.end(); ++leaf) {
const size_t newSize =
iterCount(leaf->template beginIndexAll<FilterT>(mFilter));
// if all points are being deleted, clear the leaf attributes
if (newSize == 0) {
leaf->clearAttributes(/*updateValueMask=*/true, mLock);
continue;
}
// early exit if no points are being deleted
const size_t currentSize = leaf->getLastValue();
if (newSize == currentSize) continue;
const AttributeSet& existingAttributeSet = leaf->attributeSet();
AttributeSet* newAttributeSet = new AttributeSet(
existingAttributeSet, static_cast<Index>(newSize), mLock);
const size_t attributeSetSize = existingAttributeSet.size();
// cache the attribute arrays for efficiency
std::vector<AttributeArray*> newAttributeArrays;
std::vector<const AttributeArray*> existingAttributeArrays;
for (size_t i = 0; i < attributeSetSize; i++) {
AttributeArray* newArray = newAttributeSet->get(i);
const AttributeArray* existingArray = existingAttributeSet.getConst(i);
if (!newArray->hasConstantStride() || !existingArray->hasConstantStride()) {
OPENVDB_THROW(openvdb::NotImplementedError,
"Transfer of attribute values for dynamic arrays not currently supported.");
}
if (newArray->stride() != existingArray->stride()) {
OPENVDB_THROW(openvdb::LookupError,
"Cannot transfer attribute values with mis-matching strides.");
}
newAttributeArrays.push_back(newArray);
existingAttributeArrays.push_back(existingArray);
}
Index attributeIndex = 0;
std::vector<ValueType> endOffsets;
endOffsets.reserve(LeafNodeT::NUM_VALUES);
// now construct new attribute arrays which exclude data from deleted points
#if OPENVDB_ABI_VERSION_NUMBER >= 6
std::vector<std::pair<Index, Index>> indexMapping;
indexMapping.reserve(newSize);
for (auto voxel = leaf->cbeginValueAll(); voxel; ++voxel) {
for (auto iter = leaf->beginIndexVoxel(voxel.getCoord(), mFilter);
iter; ++iter) {
indexMapping.emplace_back(*iter, attributeIndex++);
}
endOffsets.push_back(static_cast<ValueType>(attributeIndex));
}
for (size_t i = 0; i < attributeSetSize; i++) {
VectorWrapper indexMappingWrapper(indexMapping);
newAttributeArrays[i]->copyValues(*(existingAttributeArrays[i]), indexMappingWrapper);
}
#else
for (auto voxel = leaf->cbeginValueAll(); voxel; ++voxel) {
for (auto iter = leaf->beginIndexVoxel(voxel.getCoord(), mFilter);
iter; ++iter) {
for (size_t i = 0; i < attributeSetSize; i++) {
newAttributeArrays[i]->set(attributeIndex, *(existingAttributeArrays[i]),
*iter);
}
++attributeIndex;
}
endOffsets.push_back(static_cast<ValueType>(attributeIndex));
}
#endif
leaf->replaceAttributeSet(newAttributeSet);
leaf->setOffsets(endOffsets);
}
}
private:
const FilterT& mFilter;
const AttributeArray::ScopedRegistryLock* mLock;
}; // struct DeleteByFilterOp
} // namespace point_delete_internal
////////////////////////////////////////
template <typename PointDataTreeT>
inline void deleteFromGroups(PointDataTreeT& pointTree,
const std::vector<std::string>& groups,
bool invert,
bool drop)
{
const typename PointDataTreeT::LeafCIter leafIter = pointTree.cbeginLeaf();
if (!leafIter) return;
const openvdb::points::AttributeSet& attributeSet = leafIter->attributeSet();
const AttributeSet::Descriptor& descriptor = attributeSet.descriptor();
std::vector<std::string> availableGroups;
// determine which of the requested groups exist, and early exit
// if none are present in the tree
for (const auto& groupName : groups) {
if (descriptor.hasGroup(groupName)) {
availableGroups.push_back(groupName);
}
}
if (availableGroups.empty()) return;
std::vector<std::string> empty;
std::unique_ptr<MultiGroupFilter> filter;
if (invert) {
filter.reset(new MultiGroupFilter(groups, empty, leafIter->attributeSet()));
}
else {
filter.reset(new MultiGroupFilter(empty, groups, leafIter->attributeSet()));
}
{ // acquire registry lock to avoid locking when appending attributes in parallel
AttributeArray::ScopedRegistryLock lock;
tree::LeafManager<PointDataTreeT> leafManager(pointTree);
point_delete_internal::DeleteByFilterOp<PointDataTreeT, MultiGroupFilter> deleteOp(
*filter, &lock);
tbb::parallel_for(leafManager.leafRange(), deleteOp);
}
// remove empty leaf nodes
tools::pruneInactive(pointTree);
// drop the now-empty groups if requested (unless invert = true)
if (drop && !invert) {
dropGroups(pointTree, availableGroups);
}
}
template <typename PointDataTreeT>
inline void deleteFromGroup(PointDataTreeT& pointTree,
const std::string& group,
bool invert,
bool drop)
{
std::vector<std::string> groups(1, group);
deleteFromGroups(pointTree, groups, invert, drop);
}
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_DELETE_HAS_BEEN_INCLUDED
| 9,907 | C | 34.512545 | 102 | 0.619663 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/AttributeGroup.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file points/AttributeGroup.cc
#include "AttributeGroup.h"
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
////////////////////////////////////////
// GroupHandle implementation
GroupHandle::GroupHandle(const GroupAttributeArray& array, const GroupType& offset)
: mArray(array)
, mBitMask(static_cast<GroupType>(1 << offset))
{
assert(isGroup(mArray));
// load data if delay-loaded
mArray.loadData();
}
GroupHandle::GroupHandle(const GroupAttributeArray& array, const GroupType& bitMask,
BitMask)
: mArray(array)
, mBitMask(bitMask)
{
assert(isGroup(mArray));
// load data if delay-loaded
mArray.loadData();
}
bool GroupHandle::get(Index n) const
{
return (mArray.get(n) & mBitMask) == mBitMask;
}
bool GroupHandle::getUnsafe(Index n) const
{
return (mArray.getUnsafe(n) & mBitMask) == mBitMask;
}
////////////////////////////////////////
// GroupWriteHandle implementation
GroupWriteHandle::GroupWriteHandle(GroupAttributeArray& array, const GroupType& offset)
: GroupHandle(array, offset)
{
assert(isGroup(mArray));
}
void GroupWriteHandle::set(Index n, bool on)
{
const GroupType& value = mArray.get(n);
GroupAttributeArray& array(const_cast<GroupAttributeArray&>(mArray));
if (on) array.set(n, value | mBitMask);
else array.set(n, value & ~mBitMask);
}
void GroupWriteHandle::setUnsafe(Index n, bool on)
{
const GroupType& value = mArray.getUnsafe(n);
GroupAttributeArray& array(const_cast<GroupAttributeArray&>(mArray));
if (on) array.setUnsafe(n, value | mBitMask);
else array.setUnsafe(n, value & ~mBitMask);
}
bool GroupWriteHandle::collapse(bool on)
{
using ValueT = GroupAttributeArray::ValueType;
GroupAttributeArray& array(const_cast<GroupAttributeArray&>(mArray));
array.compact();
if (this->isUniform()) {
if (on) array.collapse(static_cast<ValueT>(array.get(0) | mBitMask));
else array.collapse(static_cast<ValueT>(array.get(0) & ~mBitMask));
return true;
}
for (Index i = 0; i < array.size(); i++) {
if (on) array.set(i, static_cast<ValueT>(array.get(i) | mBitMask));
else array.set(i, static_cast<ValueT>(array.get(i) & ~mBitMask));
}
return false;
}
bool GroupWriteHandle::compact()
{
GroupAttributeArray& array(const_cast<GroupAttributeArray&>(mArray));
return array.compact();
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
| 2,742 | C++ | 20.429687 | 87 | 0.641138 |
NVIDIA-Omniverse/ext-openvdb/openvdb/openvdb/points/PointConversion.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @author Dan Bailey, Nick Avramoussis
///
/// @file points/PointConversion.h
///
/// @brief Convert points and attributes to and from VDB Point Data grids.
#ifndef OPENVDB_POINTS_POINT_CONVERSION_HAS_BEEN_INCLUDED
#define OPENVDB_POINTS_POINT_CONVERSION_HAS_BEEN_INCLUDED
#include <openvdb/math/Transform.h>
#include <openvdb/tools/PointIndexGrid.h>
#include <openvdb/tools/PointsToMask.h>
#include <openvdb/util/NullInterrupter.h>
#include "AttributeArrayString.h"
#include "AttributeSet.h"
#include "IndexFilter.h"
#include "PointAttribute.h"
#include "PointDataGrid.h"
#include "PointGroup.h"
#include <tbb/parallel_reduce.h>
#include <type_traits>
namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {
namespace points {
/// @brief Localises points with position into a @c PointDataGrid into two stages:
/// allocation of the leaf attribute data and population of the positions.
///
/// @param pointIndexGrid a PointIndexGrid into the points.
/// @param positions list of world space point positions.
/// @param xform world to index space transform.
/// @param positionDefaultValue metadata default position value
///
/// @note The position data must be supplied in a Point-Partitioner compatible
/// data structure. A convenience PointAttributeVector class is offered.
///
/// @note The position data is populated separately to perform world space to
/// voxel space conversion and apply quantisation.
///
/// @note A @c PointIndexGrid to the points must be supplied to perform this
/// operation. Typically this is built implicitly by the PointDataGrid constructor.
template<
typename CompressionT,
typename PointDataGridT,
typename PositionArrayT,
typename PointIndexGridT>
inline typename PointDataGridT::Ptr
createPointDataGrid(const PointIndexGridT& pointIndexGrid,
const PositionArrayT& positions,
const math::Transform& xform,
const Metadata* positionDefaultValue = nullptr);
/// @brief Convenience method to create a @c PointDataGrid from a std::vector of
/// point positions.
///
/// @param positions list of world space point positions.
/// @param xform world to index space transform.
/// @param positionDefaultValue metadata default position value
///
/// @note This method implicitly wraps the std::vector for a Point-Partitioner compatible
/// data structure and creates the required @c PointIndexGrid to the points.
template <typename CompressionT, typename PointDataGridT, typename ValueT>
inline typename PointDataGridT::Ptr
createPointDataGrid(const std::vector<ValueT>& positions,
const math::Transform& xform,
const Metadata* positionDefaultValue = nullptr);
/// @brief Stores point attribute data in an existing @c PointDataGrid attribute.
///
/// @param tree the PointDataGrid to be populated.
/// @param pointIndexTree a PointIndexTree into the points.
/// @param attributeName the name of the VDB Points attribute to be populated.
/// @param data a wrapper to the attribute data.
/// @param stride the stride of the attribute
/// @param insertMetadata true if strings are to be automatically inserted as metadata.
///
/// @note A @c PointIndexGrid to the points must be supplied to perform this
/// operation. This is required to ensure the same point index ordering.
template <typename PointDataTreeT, typename PointIndexTreeT, typename PointArrayT>
inline void
populateAttribute( PointDataTreeT& tree,
const PointIndexTreeT& pointIndexTree,
const openvdb::Name& attributeName,
const PointArrayT& data,
const Index stride = 1,
const bool insertMetadata = true);
/// @brief Convert the position attribute from a Point Data Grid
///
/// @param positionAttribute the position attribute to be populated.
/// @param grid the PointDataGrid to be converted.
/// @param pointOffsets a vector of cumulative point offsets for each leaf
/// @param startOffset a value to shift all the point offsets by
/// @param filter an index filter
/// @param inCoreOnly true if out-of-core leaf nodes are to be ignored
///
template <typename PositionAttribute, typename PointDataGridT, typename FilterT = NullFilter>
inline void
convertPointDataGridPosition( PositionAttribute& positionAttribute,
const PointDataGridT& grid,
const std::vector<Index64>& pointOffsets,
const Index64 startOffset,
const FilterT& filter = NullFilter(),
const bool inCoreOnly = false);
/// @brief Convert the attribute from a PointDataGrid
///
/// @param attribute the attribute to be populated.
/// @param tree the PointDataTree to be converted.
/// @param pointOffsets a vector of cumulative point offsets for each leaf.
/// @param startOffset a value to shift all the point offsets by
/// @param arrayIndex the index in the Descriptor of the array to be converted.
/// @param stride the stride of the attribute
/// @param filter an index filter
/// @param inCoreOnly true if out-of-core leaf nodes are to be ignored
template <typename TypedAttribute, typename PointDataTreeT, typename FilterT = NullFilter>
inline void
convertPointDataGridAttribute( TypedAttribute& attribute,
const PointDataTreeT& tree,
const std::vector<Index64>& pointOffsets,
const Index64 startOffset,
const unsigned arrayIndex,
const Index stride = 1,
const FilterT& filter = NullFilter(),
const bool inCoreOnly = false);
/// @brief Convert the group from a PointDataGrid
///
/// @param group the group to be populated.
/// @param tree the PointDataTree to be converted.
/// @param pointOffsets a vector of cumulative point offsets for each leaf
/// @param startOffset a value to shift all the point offsets by
/// @param index the group index to be converted.
/// @param filter an index filter
/// @param inCoreOnly true if out-of-core leaf nodes are to be ignored
///
template <typename Group, typename PointDataTreeT, typename FilterT = NullFilter>
inline void
convertPointDataGridGroup( Group& group,
const PointDataTreeT& tree,
const std::vector<Index64>& pointOffsets,
const Index64 startOffset,
const AttributeSet::Descriptor::GroupIndex index,
const FilterT& filter = NullFilter(),
const bool inCoreOnly = false);
/// @ brief Given a container of world space positions and a target points per voxel,
/// compute a uniform voxel size that would best represent the storage of the points in a grid.
/// This voxel size is typically used for conversion of the points into a PointDataGrid.
///
/// @param positions array of world space positions
/// @param pointsPerVoxel the target number of points per voxel, must be positive and non-zero
/// @param transform voxel size will be computed using this optional transform if provided
/// @param decimalPlaces for readability, truncate voxel size to this number of decimals
/// @param interrupter an optional interrupter
///
/// @note if none or one point provided in positions, the default voxel size of 0.1 will be returned
///
template<typename PositionWrapper, typename InterrupterT = openvdb::util::NullInterrupter>
inline float
computeVoxelSize( const PositionWrapper& positions,
const uint32_t pointsPerVoxel,
const math::Mat4d transform = math::Mat4d::identity(),
const Index decimalPlaces = 5,
InterrupterT* const interrupter = nullptr);
////////////////////////////////////////
/// @brief Point-partitioner compatible STL vector attribute wrapper for convenience
template<typename ValueType>
class PointAttributeVector {
public:
using PosType = ValueType;
using value_type= ValueType;
PointAttributeVector(const std::vector<value_type>& data,
const Index stride = 1)
: mData(data)
, mStride(stride) { }
size_t size() const { return mData.size(); }
void getPos(size_t n, ValueType& xyz) const { xyz = mData[n]; }
void get(ValueType& value, size_t n) const { value = mData[n]; }
void get(ValueType& value, size_t n, openvdb::Index m) const { value = mData[n * mStride + m]; }
private:
const std::vector<value_type>& mData;
const Index mStride;
}; // PointAttributeVector
////////////////////////////////////////
namespace point_conversion_internal {
// ConversionTraits to create the relevant Attribute Handles from a LeafNode
template <typename T> struct ConversionTraits
{
using Handle = AttributeHandle<T, UnknownCodec>;
using WriteHandle = AttributeWriteHandle<T, UnknownCodec>;
static T zero() { return zeroVal<T>(); }
template <typename LeafT>
static typename Handle::Ptr handleFromLeaf(LeafT& leaf, Index index) {
const AttributeArray& array = leaf.constAttributeArray(index);
return Handle::create(array);
}
template <typename LeafT>
static typename WriteHandle::Ptr writeHandleFromLeaf(LeafT& leaf, Index index) {
AttributeArray& array = leaf.attributeArray(index);
return WriteHandle::create(array);
}
}; // ConversionTraits
template <> struct ConversionTraits<openvdb::Name>
{
using Handle = StringAttributeHandle;
using WriteHandle = StringAttributeWriteHandle;
static openvdb::Name zero() { return ""; }
template <typename LeafT>
static typename Handle::Ptr handleFromLeaf(LeafT& leaf, Index index) {
const AttributeArray& array = leaf.constAttributeArray(index);
const AttributeSet::Descriptor& descriptor = leaf.attributeSet().descriptor();
return Handle::create(array, descriptor.getMetadata());
}
template <typename LeafT>
static typename WriteHandle::Ptr writeHandleFromLeaf(LeafT& leaf, Index index) {
AttributeArray& array = leaf.attributeArray(index);
const AttributeSet::Descriptor& descriptor = leaf.attributeSet().descriptor();
return WriteHandle::create(array, descriptor.getMetadata());
}
}; // ConversionTraits<openvdb::Name>
template< typename PointDataTreeType,
typename PointIndexTreeType,
typename AttributeListType>
struct PopulateAttributeOp {
using LeafManagerT = typename tree::LeafManager<PointDataTreeType>;
using LeafRangeT = typename LeafManagerT::LeafRange;
using PointIndexLeafNode = typename PointIndexTreeType::LeafNodeType;
using IndexArray = typename PointIndexLeafNode::IndexArray;
using ValueType = typename AttributeListType::value_type;
using HandleT = typename ConversionTraits<ValueType>::WriteHandle;
PopulateAttributeOp(const PointIndexTreeType& pointIndexTree,
const AttributeListType& data,
const size_t index,
const Index stride = 1)
: mPointIndexTree(pointIndexTree)
, mData(data)
, mIndex(index)
, mStride(stride) { }
void operator()(const typename LeafManagerT::LeafRange& range) const {
for (auto leaf = range.begin(); leaf; ++leaf) {
// obtain the PointIndexLeafNode (using the origin of the current leaf)
const PointIndexLeafNode* pointIndexLeaf =
mPointIndexTree.probeConstLeaf(leaf->origin());
if (!pointIndexLeaf) continue;
typename HandleT::Ptr attributeWriteHandle =
ConversionTraits<ValueType>::writeHandleFromLeaf(*leaf, static_cast<Index>(mIndex));
Index64 index = 0;
const IndexArray& indices = pointIndexLeaf->indices();
for (const Index64 leafIndex: indices)
{
ValueType value;
for (Index i = 0; i < mStride; i++) {
mData.get(value, leafIndex, i);
attributeWriteHandle->set(static_cast<Index>(index), i, value);
}
index++;
}
// attempt to compact the array
attributeWriteHandle->compact();
}
}
//////////
const PointIndexTreeType& mPointIndexTree;
const AttributeListType& mData;
const size_t mIndex;
const Index mStride;
};
template<typename PointDataTreeType, typename Attribute, typename FilterT>
struct ConvertPointDataGridPositionOp {
using LeafNode = typename PointDataTreeType::LeafNodeType;
using ValueType = typename Attribute::ValueType;
using HandleT = typename Attribute::Handle;
using SourceHandleT = AttributeHandle<ValueType>;
using LeafManagerT = typename tree::LeafManager<const PointDataTreeType>;
using LeafRangeT = typename LeafManagerT::LeafRange;
ConvertPointDataGridPositionOp( Attribute& attribute,
const std::vector<Index64>& pointOffsets,
const Index64 startOffset,
const math::Transform& transform,
const size_t index,
const FilterT& filter,
const bool inCoreOnly)
: mAttribute(attribute)
, mPointOffsets(pointOffsets)
, mStartOffset(startOffset)
, mTransform(transform)
, mIndex(index)
, mFilter(filter)
, mInCoreOnly(inCoreOnly)
{
// only accept Vec3f as ValueType
static_assert(VecTraits<ValueType>::Size == 3 &&
std::is_floating_point<typename ValueType::ValueType>::value,
"ValueType is not Vec3f");
}
template <typename IterT>
void convert(IterT& iter, HandleT& targetHandle,
SourceHandleT& sourceHandle, Index64& offset) const
{
for (; iter; ++iter) {
const Vec3d xyz = iter.getCoord().asVec3d();
const Vec3d pos = sourceHandle.get(*iter);
targetHandle.set(static_cast<Index>(offset++), /*stride=*/0,
mTransform.indexToWorld(pos + xyz));
}
}
void operator()(const LeafRangeT& range) const
{
HandleT pHandle(mAttribute);
for (auto leaf = range.begin(); leaf; ++leaf) {
assert(leaf.pos() < mPointOffsets.size());
if (mInCoreOnly && leaf->buffer().isOutOfCore()) continue;
Index64 offset = mStartOffset;
if (leaf.pos() > 0) offset += mPointOffsets[leaf.pos() - 1];
auto handle = SourceHandleT::create(leaf->constAttributeArray(mIndex));
if (mFilter.state() == index::ALL) {
auto iter = leaf->beginIndexOn();
convert(iter, pHandle, *handle, offset);
}
else {
auto iter = leaf->beginIndexOn(mFilter);
convert(iter, pHandle, *handle, offset);
}
}
}
//////////
Attribute& mAttribute;
const std::vector<Index64>& mPointOffsets;
const Index64 mStartOffset;
const math::Transform& mTransform;
const size_t mIndex;
const FilterT& mFilter;
const bool mInCoreOnly;
}; // ConvertPointDataGridPositionOp
template<typename PointDataTreeType, typename Attribute, typename FilterT>
struct ConvertPointDataGridAttributeOp {
using LeafNode = typename PointDataTreeType::LeafNodeType;
using ValueType = typename Attribute::ValueType;
using HandleT = typename Attribute::Handle;
using SourceHandleT = typename ConversionTraits<ValueType>::Handle;
using LeafManagerT = typename tree::LeafManager<const PointDataTreeType>;
using LeafRangeT = typename LeafManagerT::LeafRange;
ConvertPointDataGridAttributeOp(Attribute& attribute,
const std::vector<Index64>& pointOffsets,
const Index64 startOffset,
const size_t index,
const Index stride,
const FilterT& filter,
const bool inCoreOnly)
: mAttribute(attribute)
, mPointOffsets(pointOffsets)
, mStartOffset(startOffset)
, mIndex(index)
, mStride(stride)
, mFilter(filter)
, mInCoreOnly(inCoreOnly) { }
template <typename IterT>
void convert(IterT& iter, HandleT& targetHandle,
SourceHandleT& sourceHandle, Index64& offset) const
{
if (sourceHandle.isUniform()) {
const ValueType uniformValue(sourceHandle.get(0));
for (; iter; ++iter) {
for (Index i = 0; i < mStride; i++) {
targetHandle.set(static_cast<Index>(offset), i, uniformValue);
}
offset++;
}
}
else {
for (; iter; ++iter) {
for (Index i = 0; i < mStride; i++) {
targetHandle.set(static_cast<Index>(offset), i,
sourceHandle.get(*iter, /*stride=*/i));
}
offset++;
}
}
}
void operator()(const LeafRangeT& range) const
{
HandleT pHandle(mAttribute);
for (auto leaf = range.begin(); leaf; ++leaf) {
assert(leaf.pos() < mPointOffsets.size());
if (mInCoreOnly && leaf->buffer().isOutOfCore()) continue;
Index64 offset = mStartOffset;
if (leaf.pos() > 0) offset += mPointOffsets[leaf.pos() - 1];
typename SourceHandleT::Ptr handle = ConversionTraits<ValueType>::handleFromLeaf(
*leaf, static_cast<Index>(mIndex));
if (mFilter.state() == index::ALL) {
auto iter = leaf->beginIndexOn();
convert(iter, pHandle, *handle, offset);
} else {
auto iter = leaf->beginIndexOn(mFilter);
convert(iter, pHandle, *handle, offset);
}
}
}
//////////
Attribute& mAttribute;
const std::vector<Index64>& mPointOffsets;
const Index64 mStartOffset;
const size_t mIndex;
const Index mStride;
const FilterT& mFilter;
const bool mInCoreOnly;
}; // ConvertPointDataGridAttributeOp
template<typename PointDataTreeType, typename Group, typename FilterT>
struct ConvertPointDataGridGroupOp {
using LeafNode = typename PointDataTreeType::LeafNodeType;
using GroupIndex = AttributeSet::Descriptor::GroupIndex;
using LeafManagerT = typename tree::LeafManager<const PointDataTreeType>;
using LeafRangeT = typename LeafManagerT::LeafRange;
ConvertPointDataGridGroupOp(Group& group,
const std::vector<Index64>& pointOffsets,
const Index64 startOffset,
const AttributeSet::Descriptor::GroupIndex index,
const FilterT& filter,
const bool inCoreOnly)
: mGroup(group)
, mPointOffsets(pointOffsets)
, mStartOffset(startOffset)
, mIndex(index)
, mFilter(filter)
, mInCoreOnly(inCoreOnly) { }
template <typename IterT>
void convert(IterT& iter, const GroupAttributeArray& groupArray, Index64& offset) const
{
const auto bitmask = static_cast<GroupType>(1 << mIndex.second);
if (groupArray.isUniform()) {
if (groupArray.get(0) & bitmask) {
for (; iter; ++iter) {
mGroup.setOffsetOn(static_cast<Index>(offset));
offset++;
}
}
}
else {
for (; iter; ++iter) {
if (groupArray.get(*iter) & bitmask) {
mGroup.setOffsetOn(static_cast<Index>(offset));
}
offset++;
}
}
}
void operator()(const LeafRangeT& range) const
{
for (auto leaf = range.begin(); leaf; ++leaf) {
assert(leaf.pos() < mPointOffsets.size());
if (mInCoreOnly && leaf->buffer().isOutOfCore()) continue;
Index64 offset = mStartOffset;
if (leaf.pos() > 0) offset += mPointOffsets[leaf.pos() - 1];
const AttributeArray& array = leaf->constAttributeArray(mIndex.first);
assert(isGroup(array));
const GroupAttributeArray& groupArray = GroupAttributeArray::cast(array);
if (mFilter.state() == index::ALL) {
auto iter = leaf->beginIndexOn();
convert(iter, groupArray, offset);
}
else {
auto iter = leaf->beginIndexOn(mFilter);
convert(iter, groupArray, offset);
}
}
}
//////////
Group& mGroup;
const std::vector<Index64>& mPointOffsets;
const Index64 mStartOffset;
const GroupIndex mIndex;
const FilterT& mFilter;
const bool mInCoreOnly;
}; // ConvertPointDataGridGroupOp
template<typename PositionArrayT>
struct CalculatePositionBounds
{
CalculatePositionBounds(const PositionArrayT& positions,
const math::Mat4d& inverse)
: mPositions(positions)
, mInverseMat(inverse)
, mMin(std::numeric_limits<Real>::max())
, mMax(-std::numeric_limits<Real>::max()) {}
CalculatePositionBounds(const CalculatePositionBounds& other, tbb::split)
: mPositions(other.mPositions)
, mInverseMat(other.mInverseMat)
, mMin(std::numeric_limits<Real>::max())
, mMax(-std::numeric_limits<Real>::max()) {}
void operator()(const tbb::blocked_range<size_t>& range) {
Vec3R pos;
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
mPositions.getPos(n, pos);
pos = mInverseMat.transform(pos);
mMin = math::minComponent(mMin, pos);
mMax = math::maxComponent(mMax, pos);
}
}
void join(const CalculatePositionBounds& other) {
mMin = math::minComponent(mMin, other.mMin);
mMax = math::maxComponent(mMax, other.mMax);
}
BBoxd getBoundingBox() const {
return BBoxd(mMin, mMax);
}
private:
const PositionArrayT& mPositions;
const math::Mat4d& mInverseMat;
Vec3R mMin, mMax;
};
} // namespace point_conversion_internal
////////////////////////////////////////
template<typename CompressionT, typename PointDataGridT, typename PositionArrayT, typename PointIndexGridT>
inline typename PointDataGridT::Ptr
createPointDataGrid(const PointIndexGridT& pointIndexGrid,
const PositionArrayT& positions,
const math::Transform& xform,
const Metadata* positionDefaultValue)
{
using PointDataTreeT = typename PointDataGridT::TreeType;
using LeafT = typename PointDataTree::LeafNodeType;
using PointIndexLeafT = typename PointIndexGridT::TreeType::LeafNodeType;
using PointIndexT = typename PointIndexLeafT::ValueType;
using LeafManagerT = typename tree::LeafManager<PointDataTreeT>;
using PositionAttributeT = TypedAttributeArray<Vec3f, CompressionT>;
const NamePair positionType = PositionAttributeT::attributeType();
// construct the Tree using a topology copy of the PointIndexGrid
const auto& pointIndexTree = pointIndexGrid.tree();
typename PointDataTreeT::Ptr treePtr(new PointDataTreeT(pointIndexTree));
// create attribute descriptor from position type
auto descriptor = AttributeSet::Descriptor::create(positionType);
// add default value for position if provided
if (positionDefaultValue) descriptor->setDefaultValue("P", *positionDefaultValue);
// retrieve position index
const size_t positionIndex = descriptor->find("P");
assert(positionIndex != AttributeSet::INVALID_POS);
// acquire registry lock to avoid locking when appending attributes in parallel
AttributeArray::ScopedRegistryLock lock;
// populate position attribute
LeafManagerT leafManager(*treePtr);
leafManager.foreach(
[&](LeafT& leaf, size_t /*idx*/) {
// obtain the PointIndexLeafNode (using the origin of the current leaf)
const auto* pointIndexLeaf = pointIndexTree.probeConstLeaf(leaf.origin());
assert(pointIndexLeaf);
// initialise the attribute storage
Index pointCount(static_cast<Index>(pointIndexLeaf->indices().size()));
leaf.initializeAttributes(descriptor, pointCount, &lock);
// create write handle for position
auto attributeWriteHandle = AttributeWriteHandle<Vec3f, CompressionT>::create(
leaf.attributeArray(positionIndex));
Index index = 0;
const PointIndexT
*begin = static_cast<PointIndexT*>(nullptr),
*end = static_cast<PointIndexT*>(nullptr);
// iterator over every active voxel in the point index leaf
for (auto iter = pointIndexLeaf->cbeginValueOn(); iter; ++iter) {
// find the voxel center
const Coord& ijk = iter.getCoord();
const Vec3d& positionCellCenter(ijk.asVec3d());
// obtain pointers for this voxel from begin to end in the indices array
pointIndexLeaf->getIndices(ijk, begin, end);
while (begin < end) {
typename PositionArrayT::value_type positionWorldSpace;
positions.getPos(*begin, positionWorldSpace);
// compute the index-space position and then subtract the voxel center
const Vec3d positionIndexSpace = xform.worldToIndex(positionWorldSpace);
const Vec3f positionVoxelSpace(positionIndexSpace - positionCellCenter);
attributeWriteHandle->set(index++, positionVoxelSpace);
++begin;
}
}
},
/*threaded=*/true);
auto grid = PointDataGridT::create(treePtr);
grid->setTransform(xform.copy());
return grid;
}
////////////////////////////////////////
template <typename CompressionT, typename PointDataGridT, typename ValueT>
inline typename PointDataGridT::Ptr
createPointDataGrid(const std::vector<ValueT>& positions,
const math::Transform& xform,
const Metadata* positionDefaultValue)
{
const PointAttributeVector<ValueT> pointList(positions);
tools::PointIndexGrid::Ptr pointIndexGrid =
tools::createPointIndexGrid<tools::PointIndexGrid>(pointList, xform);
return createPointDataGrid<CompressionT, PointDataGridT>(
*pointIndexGrid, pointList, xform, positionDefaultValue);
}
////////////////////////////////////////
template <typename PointDataTreeT, typename PointIndexTreeT, typename PointArrayT>
inline void
populateAttribute(PointDataTreeT& tree, const PointIndexTreeT& pointIndexTree,
const openvdb::Name& attributeName, const PointArrayT& data, const Index stride,
const bool insertMetadata)
{
using point_conversion_internal::PopulateAttributeOp;
using ValueType = typename PointArrayT::value_type;
auto iter = tree.cbeginLeaf();
if (!iter) return;
const size_t index = iter->attributeSet().find(attributeName);
if (index == AttributeSet::INVALID_POS) {
OPENVDB_THROW(KeyError, "Attribute not found to populate - " << attributeName << ".");
}
if (insertMetadata) {
point_attribute_internal::MetadataStorage<PointDataTreeT, ValueType>::add(tree, data);
}
// populate attribute
typename tree::LeafManager<PointDataTreeT> leafManager(tree);
PopulateAttributeOp<PointDataTreeT,
PointIndexTreeT,
PointArrayT> populate(pointIndexTree, data, index, stride);
tbb::parallel_for(leafManager.leafRange(), populate);
}
////////////////////////////////////////
template <typename PositionAttribute, typename PointDataGridT, typename FilterT>
inline void
convertPointDataGridPosition( PositionAttribute& positionAttribute,
const PointDataGridT& grid,
const std::vector<Index64>& pointOffsets,
const Index64 startOffset,
const FilterT& filter,
const bool inCoreOnly)
{
using TreeType = typename PointDataGridT::TreeType;
using LeafManagerT = typename tree::LeafManager<const TreeType>;
using point_conversion_internal::ConvertPointDataGridPositionOp;
const TreeType& tree = grid.tree();
auto iter = tree.cbeginLeaf();
if (!iter) return;
const size_t positionIndex = iter->attributeSet().find("P");
positionAttribute.expand();
LeafManagerT leafManager(tree);
ConvertPointDataGridPositionOp<TreeType, PositionAttribute, FilterT> convert(
positionAttribute, pointOffsets, startOffset, grid.transform(), positionIndex,
filter, inCoreOnly);
tbb::parallel_for(leafManager.leafRange(), convert);
positionAttribute.compact();
}
////////////////////////////////////////
template <typename TypedAttribute, typename PointDataTreeT, typename FilterT>
inline void
convertPointDataGridAttribute( TypedAttribute& attribute,
const PointDataTreeT& tree,
const std::vector<Index64>& pointOffsets,
const Index64 startOffset,
const unsigned arrayIndex,
const Index stride,
const FilterT& filter,
const bool inCoreOnly)
{
using LeafManagerT = typename tree::LeafManager<const PointDataTreeT>;
using point_conversion_internal::ConvertPointDataGridAttributeOp;
auto iter = tree.cbeginLeaf();
if (!iter) return;
attribute.expand();
LeafManagerT leafManager(tree);
ConvertPointDataGridAttributeOp<PointDataTreeT, TypedAttribute, FilterT> convert(
attribute, pointOffsets, startOffset, arrayIndex, stride,
filter, inCoreOnly);
tbb::parallel_for(leafManager.leafRange(), convert);
attribute.compact();
}
////////////////////////////////////////
template <typename Group, typename PointDataTreeT, typename FilterT>
inline void
convertPointDataGridGroup( Group& group,
const PointDataTreeT& tree,
const std::vector<Index64>& pointOffsets,
const Index64 startOffset,
const AttributeSet::Descriptor::GroupIndex index,
const FilterT& filter,
const bool inCoreOnly)
{
using LeafManagerT= typename tree::LeafManager<const PointDataTreeT>;
using point_conversion_internal::ConvertPointDataGridGroupOp;
auto iter = tree.cbeginLeaf();
if (!iter) return;
LeafManagerT leafManager(tree);
ConvertPointDataGridGroupOp<PointDataTree, Group, FilterT> convert(
group, pointOffsets, startOffset, index,
filter, inCoreOnly);
tbb::parallel_for(leafManager.leafRange(), convert);
// must call this after modifying point groups in parallel
group.finalize();
}
template<typename PositionWrapper, typename InterrupterT>
inline float
computeVoxelSize( const PositionWrapper& positions,
const uint32_t pointsPerVoxel,
const math::Mat4d transform,
const Index decimalPlaces,
InterrupterT* const interrupter)
{
using namespace point_conversion_internal;
struct Local {
static bool voxelSizeFromVolume(const double volume,
const size_t estimatedVoxelCount,
float& voxelSize)
{
// dictated by the math::ScaleMap limit
static const double minimumVoxelVolume(3e-15);
static const double maximumVoxelVolume(std::numeric_limits<float>::max());
double voxelVolume = volume / static_cast<double>(estimatedVoxelCount);
bool valid = true;
if (voxelVolume < minimumVoxelVolume) {
voxelVolume = minimumVoxelVolume;
valid = false;
}
else if (voxelVolume > maximumVoxelVolume) {
voxelVolume = maximumVoxelVolume;
valid = false;
}
voxelSize = static_cast<float>(math::Pow(voxelVolume, 1.0/3.0));
return valid;
}
static float truncate(const float voxelSize, Index decPlaces)
{
float truncatedVoxelSize = voxelSize;
// attempt to truncate from decPlaces -> 11
for (int i = decPlaces; i < 11; i++) {
truncatedVoxelSize = static_cast<float>(math::Truncate(double(voxelSize), i));
if (truncatedVoxelSize != 0.0f) break;
}
return truncatedVoxelSize;
}
};
if (pointsPerVoxel == 0) OPENVDB_THROW(ValueError, "Points per voxel cannot be zero.");
// constructed with the default voxel size as specified by openvdb interface values
float voxelSize(0.1f);
const size_t numPoints = positions.size();
// return the default voxel size if we have zero or only 1 point
if (numPoints <= 1) return voxelSize;
size_t targetVoxelCount(numPoints / size_t(pointsPerVoxel));
if (targetVoxelCount == 0) targetVoxelCount++;
// calculate the world space, transform-oriented bounding box
math::Mat4d inverseTransform = transform.inverse();
inverseTransform = math::unit(inverseTransform);
tbb::blocked_range<size_t> range(0, numPoints);
CalculatePositionBounds<PositionWrapper> calculateBounds(positions, inverseTransform);
tbb::parallel_reduce(range, calculateBounds);
BBoxd bbox = calculateBounds.getBoundingBox();
// return default size if points are coincident
if (bbox.min() == bbox.max()) return voxelSize;
double volume = bbox.volume();
// handle points that are collinear or coplanar by expanding the volume
if (math::isApproxZero(volume)) {
Vec3d extents = bbox.extents().sorted().reversed();
if (math::isApproxZero(extents[1])) {
// colinear (maxExtent^3)
volume = extents[0]*extents[0]*extents[0];
}
else {
// coplanar (maxExtent*nextMaxExtent^2)
volume = extents[0]*extents[1]*extents[1];
}
}
double previousVolume = volume;
if (!Local::voxelSizeFromVolume(volume, targetVoxelCount, voxelSize)) {
OPENVDB_LOG_DEBUG("Out of range, clamping voxel size.");
return voxelSize;
}
size_t previousVoxelCount(0);
size_t voxelCount(1);
if (interrupter) interrupter->start("Computing voxel size");
while (voxelCount > previousVoxelCount)
{
math::Transform::Ptr newTransform;
if (!math::isIdentity(transform))
{
// if using a custom transform, pre-scale by coefficients
// which define the new voxel size
math::Mat4d matrix(transform);
matrix.preScale(Vec3d(voxelSize) / math::getScale(matrix));
newTransform = math::Transform::createLinearTransform(matrix);
}
else
{
newTransform = math::Transform::createLinearTransform(voxelSize);
}
// create a mask grid of the points from the calculated voxel size
// this is the same function call as tools::createPointMask() which has
// been duplicated to provide an interrupter
MaskGrid::Ptr mask = createGrid<MaskGrid>(false);
mask->setTransform(newTransform);
tools::PointsToMask<MaskGrid, InterrupterT> pointMaskOp(*mask, interrupter);
pointMaskOp.addPoints(positions);
if (interrupter && util::wasInterrupted(interrupter)) break;
previousVoxelCount = voxelCount;
voxelCount = mask->activeVoxelCount();
volume = math::Pow3(voxelSize) * static_cast<float>(voxelCount);
// stop if no change in the volume or the volume has increased
if (volume >= previousVolume) break;
previousVolume = volume;
const float previousVoxelSize = voxelSize;
// compute the new voxel size and if invalid return the previous value
if (!Local::voxelSizeFromVolume(volume, targetVoxelCount, voxelSize)) {
voxelSize = previousVoxelSize;
break;
}
// halt convergence if the voxel size has decreased by less
// than 10% in this iteration
if (voxelSize / previousVoxelSize > 0.9f) break;
}
if (interrupter) interrupter->end();
// truncate the voxel size for readability and return the value
return Local::truncate(voxelSize, decimalPlaces);
}
////////////////////////////////////////
} // namespace points
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb
#endif // OPENVDB_POINTS_POINT_CONVERSION_HAS_BEEN_INCLUDED
| 38,932 | C | 36.256459 | 107 | 0.610192 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GT_GEOPrimCollectVDB.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c) Side Effects Software Inc.
*
* Produced by:
* Side Effects Software Inc
* 123 Front Street West, Suite 1401
* Toronto, Ontario
* Canada M5J 2M2
* 416-504-9876
*
* NAME: GT_GEOPrimCollectVDB.h ( GT Library, C++)
*
* COMMENTS:
*/
#ifndef __GT_GEOPrimCollectVDB__
#define __GT_GEOPrimCollectVDB__
#include <GT/GT_GEOPrimCollect.h>
#include <openvdb/Platform.h>
namespace openvdb_houdini {
class OPENVDB_HOUDINI_API GT_GEOPrimCollectVDB : public GT_GEOPrimCollect
{
public:
GT_GEOPrimCollectVDB(const GA_PrimitiveTypeId &id);
virtual ~GT_GEOPrimCollectVDB();
static void registerPrimitive(const GA_PrimitiveTypeId &id);
virtual GT_GEOPrimCollectData *
beginCollecting(
const GT_GEODetailListHandle &,
const GT_RefineParms *) const;
virtual GT_PrimitiveHandle
collect(
const GT_GEODetailListHandle &geometry,
const GEO_Primitive *const* prim_list,
int nsegments,
GT_GEOPrimCollectData *data) const;
virtual GT_PrimitiveHandle
endCollecting(
const GT_GEODetailListHandle &geometry,
GT_GEOPrimCollectData *data) const;
private:
GA_PrimitiveTypeId myId;
};
} // namespace openvdb_houdini
#endif // __GT_GEOPrimCollectVDB__
| 1,572 | C | 25.216666 | 73 | 0.603053 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Clip.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file SOP_OpenVDB_Clip.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Clip grids
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/GeometryUtil.h> // for drawFrustum(), frustumTransformFromCamera()
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/Clip.h> // for tools::clip()
#include <openvdb/tools/LevelSetUtil.h> // for tools::sdfInteriorMask()
#include <openvdb/tools/Mask.h> // for tools::interiorMask()
#include <openvdb/tools/Morphology.h> // for tools::dilateActiveValues(), tools::erodeVoxels()
#include <openvdb/points/PointDataGrid.h>
#include <OBJ/OBJ_Camera.h>
#include <cmath> // for std::abs(), std::round()
#include <exception>
#include <string>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Clip: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Clip(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Clip() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned input) const override { return (input == 1); }
class Cache: public SOP_VDBCacheOptions
{
public:
openvdb::math::Transform::Ptr frustum() const { return mFrustum; }
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
private:
void getFrustum(OP_Context&);
openvdb::math::Transform::Ptr mFrustum;
}; // class Cache
protected:
void resolveObsoleteParms(PRM_ParmList*) override;
bool updateParmsFlags() override;
OP_ERROR cookMyGuide1(OP_Context&) override;
};
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of VDBs from the first input to be clipped.")
.setDocumentation(
"A subset of VDBs from the first input to be clipped"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "inside", "Keep Inside")
.setDefault(PRMoneDefaults)
.setTooltip(
"If enabled, keep voxels that lie inside the clipping region.\n"
"If disabled, keep voxels that lie outside the clipping region.")
.setDocumentation(
"If enabled, keep voxels that lie inside the clipping region,"
" otherwise keep voxels that lie outside the clipping region."));
parms.add(hutil::ParmFactory(PRM_STRING, "clipper", "Clip To")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"camera", "Camera",
"geometry", "Geometry",
"mask", "Mask VDB"
})
.setDefault("geometry")
.setTooltip("Specify how the clipping region should be defined.")
.setDocumentation("\
How to define the clipping region\n\
\n\
Camera:\n\
Use a camera frustum as the clipping region.\n\
Geometry:\n\
Use the bounding box of geometry from the second input as the clipping region.\n\
Mask VDB:\n\
Use the active voxels of a VDB volume from the second input as a clipping mask.\n"));
parms.add(hutil::ParmFactory(PRM_STRING, "mask", "Mask VDB")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("Specify a VDB whose active voxels are to be used as a clipping mask.")
.setDocumentation(
"A VDB from the second input whose active voxels are to be used as a clipping mask"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "camera", "Camera")
.setTypeExtended(PRM_TYPE_DYNAMIC_PATH)
.setSpareData(&PRM_SpareData::objCameraPath)
.setTooltip("Specify the path to a reference camera")
.setDocumentation(
"The path to the camera whose frustum is to be used as a clipping region"
" (e.g., `/obj/cam1`)"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setnear", "")
.setDefault(PRMzeroDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("If enabled, override the camera's near clipping plane."));
parms.add(hutil::ParmFactory(PRM_FLT_E, "near", "Near Clipping")
.setDefault(0.001)
.setTooltip("The position of the near clipping plane")
.setDocumentation(
"The position of the near clipping plane\n\n"
"If enabled, this setting overrides the camera's clipping plane."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setfar", "")
.setDefault(PRMzeroDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("If enabled, override the camera's far clipping plane."));
parms.add(hutil::ParmFactory(PRM_FLT_E, "far", "Far Clipping")
.setDefault(10000)
.setTooltip("The position of the far clipping plane")
.setDocumentation(
"The position of the far clipping plane\n\n"
"If enabled, this setting overrides the camera's clipping plane."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setpadding", "")
.setDefault(PRMzeroDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("If enabled, expand or shrink the clipping region."));
parms.add(hutil::ParmFactory(PRM_FLT_E, "padding", "Padding")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setTooltip("Padding in world units to be added to the clipping region")
.setDocumentation(
"Padding in world units to be added to the clipping region\n\n"
"Negative values shrink the clipping region.\n\n"
"Nonuniform padding is not supported when clipping to a VDB volume.\n"
"The mask volume will be dilated or eroded uniformly"
" by the _x_-axis padding value."));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "usemask", "").setDefault(PRMzeroDefaults));
hvdb::OpenVDBOpFactory("VDB Clip", SOP_OpenVDB_Clip::factory, parms, *table)
.addInput("VDBs")
.addOptionalInput("Mask VDB or bounding geometry")
.setObsoleteParms(obsoleteParms)
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Clip::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Clip VDB volumes using a camera frustum, a bounding box, or another VDB as a mask.\"\"\"\n\
\n\
@overview\n\
\n\
This node clips VDB volumes, that is, it removes voxels that lie outside\n\
(or, optionally, inside) a given region by deactivating them and setting them\n\
to the background value.\n\
The clipping region may be one of the following:\n\
* the frustum of a camera\n\
* the bounding box of reference geometry\n\
* the active voxels of another VDB.\n\
\n\
When the clipping region is defined by a VDB, the operation\n\
is similar to [activity intersection|Node:sop/DW_OpenVDBCombine],\n\
except that clipped voxels are not only deactivated but also set\n\
to the background value.\n\
\n\
@related\n\
\n\
- [OpenVDB Combine|Node:sop/DW_OpenVDBCombine]\n\
- [OpenVDB Occlusion Mask|Node:sop/DW_OpenVDBOcclusionMask]\n\
- [Node:sop/vdbactivate]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Clip::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
auto* parm = obsoleteParms->getParmPtr("usemask");
if (parm && !parm->isFactoryDefault()) { // factory default was Off
setString("clipper", CH_STRING_LITERAL, "mask", 0, 0.0);
}
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
bool
SOP_OpenVDB_Clip::updateParmsFlags()
{
bool changed = false;
UT_String clipper;
evalString(clipper, "clipper", 0, 0.0);
const bool clipToCamera = (clipper == "camera");
changed |= enableParm("mask", clipper == "mask");
changed |= enableParm("camera", clipToCamera);
changed |= enableParm("setnear", clipToCamera);
changed |= enableParm("near", clipToCamera && evalInt("setnear", 0, 0.0));
changed |= enableParm("setfar", clipToCamera);
changed |= enableParm("far", clipToCamera && evalInt("setfar", 0, 0.0));
changed |= enableParm("padding", 0 != evalInt("setpadding", 0, 0.0));
changed |= setVisibleState("mask", clipper == "mask");
changed |= setVisibleState("camera", clipToCamera);
changed |= setVisibleState("setnear", clipToCamera);
changed |= setVisibleState("near", clipToCamera);
changed |= setVisibleState("setfar", clipToCamera);
changed |= setVisibleState("far", clipToCamera);
return changed;
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Clip::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Clip(net, name, op);
}
SOP_OpenVDB_Clip::SOP_OpenVDB_Clip(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
namespace {
// Functor to convert a mask grid of arbitrary type to a BoolGrid
// and to dilate or erode it
struct DilatedMaskOp
{
DilatedMaskOp(int dilation_): dilation{dilation_} {}
template<typename GridType>
void operator()(const GridType& grid)
{
if (dilation == 0) return;
maskGrid = openvdb::BoolGrid::create();
maskGrid->setTransform(grid.transform().copy());
maskGrid->topologyUnion(grid);
if (dilation < 0) {
// Densify the mask, since tools::erodeVoxels() ignores active tiles.
/// @todo Remove this once tools::erodeActiveValues() is implemented.
maskGrid->tree().voxelizeActiveTiles();
}
UT_AutoInterrupt progress{
((dilation > 0 ? "Dilating" : "Eroding") + std::string{" VDB mask"}).c_str()};
int numIterations = std::abs(dilation);
const int kNumIterationsPerPass = 4;
const int numPasses = numIterations / kNumIterationsPerPass;
auto morphologyOp = [&](int iterations) {
if (dilation > 0) {
openvdb::tools::dilateActiveValues(maskGrid->tree(), iterations);
} else {
/// @todo Replace with tools::erodeActiveValues() once it is implemented.
openvdb::tools::erodeVoxels(maskGrid->tree(), iterations);
}
};
// Since large dilations and erosions can be expensive, apply them
// in multiple passes and check for interrupts.
for (int pass = 0; pass < numPasses; ++pass, numIterations -= kNumIterationsPerPass) {
const bool interrupt = progress.wasInterrupted(
/*pct=*/int((100.0 * pass * kNumIterationsPerPass) / std::abs(dilation)));
if (interrupt) {
maskGrid.reset();
throw std::runtime_error{"interrupted"};
}
morphologyOp(kNumIterationsPerPass);
}
if (numIterations > 0) {
morphologyOp(numIterations);
}
}
int dilation = 0; // positive = dilation, negative = erosion
openvdb::BoolGrid::Ptr maskGrid;
};
struct LevelSetMaskOp
{
template<typename GridType>
void operator()(const GridType& grid)
{
outputGrid = openvdb::tools::sdfInteriorMask(grid);
}
hvdb::GridPtr outputGrid;
};
struct BBoxClipOp
{
BBoxClipOp(const openvdb::BBoxd& bbox_, bool inside_ = true):
bbox(bbox_), inside(inside_)
{}
template<typename GridType>
void operator()(const GridType& grid)
{
outputGrid = openvdb::tools::clip(grid, bbox, inside);
}
openvdb::BBoxd bbox;
hvdb::GridPtr outputGrid;
bool inside = true;
};
struct FrustumClipOp
{
FrustumClipOp(const openvdb::math::Transform::Ptr& frustum_, bool inside_ = true):
frustum(frustum_), inside(inside_)
{}
template<typename GridType>
void operator()(const GridType& grid)
{
openvdb::math::NonlinearFrustumMap::ConstPtr mapPtr;
if (frustum) mapPtr = frustum->constMap<openvdb::math::NonlinearFrustumMap>();
if (mapPtr) {
outputGrid = openvdb::tools::clip(grid, *mapPtr, inside);
}
}
const openvdb::math::Transform::ConstPtr frustum;
const bool inside = true;
hvdb::GridPtr outputGrid;
};
template<typename GridType>
struct MaskClipDispatchOp
{
MaskClipDispatchOp(const GridType& grid_, bool inside_ = true):
grid(&grid_), inside(inside_)
{}
template<typename MaskGridType>
void operator()(const MaskGridType& mask)
{
outputGrid.reset();
if (grid) outputGrid = openvdb::tools::clip(*grid, mask, inside);
}
const GridType* grid;
hvdb::GridPtr outputGrid;
bool inside = true;
};
struct MaskClipOp
{
MaskClipOp(hvdb::GridCPtr mask_, bool inside_ = true):
mask(mask_), inside(inside_)
{}
template<typename GridType>
void operator()(const GridType& grid)
{
outputGrid.reset();
if (mask) {
// Dispatch on the mask grid type, now that the source grid type is resolved.
MaskClipDispatchOp<GridType> op(grid, inside);
if (mask->apply<hvdb::AllGridTypes>(op)) {
outputGrid = op.outputGrid;
}
}
}
hvdb::GridCPtr mask;
hvdb::GridPtr outputGrid;
bool inside = true;
};
} // unnamed namespace
////////////////////////////////////////
/// Get the selected camera's frustum transform.
void
SOP_OpenVDB_Clip::Cache::getFrustum(OP_Context& context)
{
mFrustum.reset();
const auto time = context.getTime();
UT_String cameraPath;
evalString(cameraPath, "camera", 0, time);
if (!cameraPath.isstring()) {
throw std::runtime_error{"no camera path was specified"};
}
OBJ_Camera* camera = nullptr;
if (auto* obj = cookparms()->getCwd()->findOBJNode(cameraPath)) {
camera = obj->castToOBJCamera();
}
OP_Node* self = cookparms()->getCwd();
if (!camera) {
throw std::runtime_error{"camera \"" + cameraPath.toStdString() + "\" was not found"};
}
self->addExtraInput(camera, OP_INTEREST_DATA);
OBJ_CameraParms cameraParms;
camera->getCameraParms(cameraParms, time);
if (cameraParms.projection != OBJ_PROJ_PERSPECTIVE) {
throw std::runtime_error{cameraPath.toStdString() + " is not a perspective camera"};
/// @todo support ortho and other cameras?
}
const bool pad = (0 != evalInt("setpadding", 0, time));
const auto padding = pad ? evalVec3f("padding", time) : openvdb::Vec3f{0};
const float nearPlane = (evalInt("setnear", 0, time)
? static_cast<float>(evalFloat("near", 0, time))
: static_cast<float>(camera->getNEAR(time))) - padding[2];
const float farPlane = (evalInt("setfar", 0, time)
? static_cast<float>(evalFloat("far", 0, time))
: static_cast<float>(camera->getFAR(time))) + padding[2];
mFrustum = hvdb::frustumTransformFromCamera(*self, context, *camera,
/*offset=*/0.f, nearPlane, farPlane, /*voxelDepth=*/1.f, /*voxelCountX=*/100);
if (!mFrustum || !mFrustum->constMap<openvdb::math::NonlinearFrustumMap>()) {
throw std::runtime_error{
"failed to compute frustum bounds for camera " + cameraPath.toStdString()};
}
if (pad) {
const auto extents =
mFrustum->constMap<openvdb::math::NonlinearFrustumMap>()->getBBox().extents();
mFrustum->preScale(openvdb::Vec3d{
(extents[0] + 2 * padding[0]) / extents[0],
(extents[1] + 2 * padding[1]) / extents[1],
1.0});
}
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Clip::cookMyGuide1(OP_Context&)
{
myGuide1->clearAndDestroy();
openvdb::math::Transform::ConstPtr frustum;
// Attempt to extract the frustum from our cache.
if (auto* cache = dynamic_cast<SOP_OpenVDB_Clip::Cache*>(myNodeVerbCache)) {
frustum = cache->frustum();
}
if (frustum) {
const UT_Vector3 color{0.9f, 0.0f, 0.0f};
hvdb::drawFrustum(*myGuide1, *frustum, &color,
/*tickColor=*/nullptr, /*shaded=*/false, /*ticks=*/false);
}
return error();
}
OP_ERROR
SOP_OpenVDB_Clip::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
UT_AutoInterrupt progress{"Clipping VDBs"};
const GU_Detail* maskGeo = inputGeo(1);
UT_String clipper;
evalString(clipper, "clipper", 0, time);
const bool
useCamera = (clipper == "camera"),
useMask = (clipper == "mask"),
inside = evalInt("inside", 0, time),
pad = evalInt("setpadding", 0, time);
const auto padding = pad ? evalVec3f("padding", time) : openvdb::Vec3f{0};
mFrustum.reset();
openvdb::BBoxd clipBox;
hvdb::GridCPtr maskGrid;
if (useCamera) {
getFrustum(context);
} else if (maskGeo) {
if (useMask) {
const GA_PrimitiveGroup* maskGroup = parsePrimitiveGroups(
evalStdString("mask", time).c_str(), GroupCreator{maskGeo});
hvdb::VdbPrimCIterator maskIt{maskGeo, maskGroup};
if (maskIt) {
if (maskIt->getConstGrid().getGridClass() == openvdb::GRID_LEVEL_SET) {
// If the mask grid is a level set, extract an interior mask from it.
LevelSetMaskOp op;
hvdb::GEOvdbApply<hvdb::NumericGridTypes>(**maskIt, op);
maskGrid = op.outputGrid;
} else {
maskGrid = maskIt->getConstGridPtr();
}
}
if (!maskGrid) {
addError(SOP_MESSAGE, "mask VDB not found");
return error();
}
if (pad) {
// If padding is enabled and nonzero, dilate or erode the mask grid.
const auto paddingInVoxels = padding / maskGrid->voxelSize();
if (!openvdb::math::isApproxEqual(paddingInVoxels[0], paddingInVoxels[1])
|| !openvdb::math::isApproxEqual(paddingInVoxels[1], paddingInVoxels[2]))
{
addWarning(SOP_MESSAGE,
"nonuniform padding is not supported for mask clipping");
}
if (const int dilation = int(std::round(paddingInVoxels[0]))) {
DilatedMaskOp op{dilation};
maskGrid->apply<hvdb::AllGridTypes>(op);
if (op.maskGrid) maskGrid = op.maskGrid;
}
}
} else {
UT_BoundingBox box;
maskGeo->getBBox(&box);
clipBox.min()[0] = box.xmin();
clipBox.min()[1] = box.ymin();
clipBox.min()[2] = box.zmin();
clipBox.max()[0] = box.xmax();
clipBox.max()[1] = box.ymax();
clipBox.max()[2] = box.zmax();
if (pad) {
clipBox.min() -= padding;
clipBox.max() += padding;
}
}
} else {
addError(SOP_MESSAGE, "Not enough sources specified.");
return error();
}
// Get the group of grids to process.
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
int numLevelSets = 0;
for (hvdb::VdbPrimIterator it{gdp, group}; it; ++it) {
if (progress.wasInterrupted()) { throw std::runtime_error{"interrupted"}; }
const auto& inGrid = it->getConstGrid();
hvdb::GridPtr outGrid;
if (inGrid.getGridClass() == openvdb::GRID_LEVEL_SET) {
++numLevelSets;
}
progress.getInterrupt()->setAppTitle(
("Clipping VDB " + it.getPrimitiveIndexAndName().toStdString()).c_str());
if (maskGrid) {
MaskClipOp op{maskGrid, inside};
if (hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, op)) { // all Houdini-supported volume grid types
outGrid = op.outputGrid;
} else if (inGrid.isType<openvdb::points::PointDataGrid>()) {
addWarning(SOP_MESSAGE,
"only bounding box clipping is currently supported for point data grids");
}
} else if (useCamera) {
FrustumClipOp op{mFrustum, inside};
if (hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, op)) { // all Houdini-supported volume grid types
outGrid = op.outputGrid;
} else if (inGrid.isType<openvdb::points::PointDataGrid>()) {
addWarning(SOP_MESSAGE,
"only bounding box clipping is currently supported for point data grids");
}
} else {
BBoxClipOp op{clipBox, inside};
if (hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, op)) { // all Houdini-supported volume grid types
outGrid = op.outputGrid;
} else if (inGrid.isType<openvdb::points::PointDataGrid>()) {
if (inside) {
outGrid = inGrid.deepCopyGrid();
outGrid->clipGrid(clipBox);
} else {
addWarning(SOP_MESSAGE,
"only Keep Inside mode is currently supported for point data grids");
}
}
}
// Replace the original VDB primitive with a new primitive that contains
// the output grid and has the same attributes and group membership.
hvdb::replaceVdbPrimitive(*gdp, outGrid, **it, true);
}
if (numLevelSets > 0) {
if (numLevelSets == 1) {
addWarning(SOP_MESSAGE, "a level set grid was clipped;"
" the resulting grid might not be a valid level set");
} else {
addWarning(SOP_MESSAGE, "some level sets were clipped;"
" the resulting grids might not be valid level sets");
}
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 22,848 | C++ | 33.256372 | 116 | 0.595895 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Morph_Level_Set.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Morph_Level_Set.cc
///
/// @author Ken Museth
///
/// @brief Level set morphing SOP
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/LevelSetMorph.h>
#include <hboost/algorithm/string/join.hpp>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
// Utilities
namespace {
struct MorphingParms {
MorphingParms()
: mLSGroup(nullptr)
, mAdvectSpatial(openvdb::math::UNKNOWN_BIAS)
, mRenormSpatial(openvdb::math::UNKNOWN_BIAS)
, mAdvectTemporal(openvdb::math::UNKNOWN_TIS)
, mRenormTemporal(openvdb::math::UNKNOWN_TIS)
, mNormCount(1)
, mTimeStep(0.0)
, mMinMask(0)
, mMaxMask(1)
, mInvertMask(false)
{
}
const GA_PrimitiveGroup* mLSGroup;
openvdb::FloatGrid::ConstPtr mTargetGrid;
openvdb::FloatGrid::ConstPtr mMaskGrid;
openvdb::math::BiasedGradientScheme mAdvectSpatial, mRenormSpatial;
openvdb::math::TemporalIntegrationScheme mAdvectTemporal, mRenormTemporal;
int mNormCount;
float mTimeStep;
float mMinMask, mMaxMask;
bool mInvertMask;
};
class MorphOp
{
public:
MorphOp(MorphingParms& parms, hvdb::Interrupter& boss)
: mParms(&parms)
, mBoss(&boss)
{
}
void operator()(openvdb::FloatGrid& grid)
{
if (mBoss->wasInterrupted()) return;
openvdb::tools::LevelSetMorphing<openvdb::FloatGrid, hvdb::Interrupter>
morph(grid, *(mParms->mTargetGrid), mBoss);
if (mParms->mMaskGrid) {
morph.setAlphaMask(*(mParms->mMaskGrid));
morph.setMaskRange(mParms->mMinMask, mParms->mMaxMask);
morph.invertMask(mParms->mInvertMask);
}
morph.setSpatialScheme(mParms->mAdvectSpatial);
morph.setTemporalScheme(mParms->mAdvectTemporal);
morph.setTrackerSpatialScheme(mParms->mRenormSpatial);
morph.setTrackerTemporalScheme(mParms->mRenormTemporal);
morph.setNormCount(mParms->mNormCount);
morph.advect(0, mParms->mTimeStep);
}
private:
MorphingParms* mParms;
hvdb::Interrupter* mBoss;
};
} // namespace
////////////////////////////////////////
// SOP Declaration
class SOP_OpenVDB_Morph_Level_Set: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Morph_Level_Set(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Morph_Level_Set() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i ) const override { return (i > 0); }
class Cache: public SOP_VDBCacheOptions
{
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
OP_ERROR evalMorphingParms(OP_Context&, MorphingParms&);
bool processGrids(MorphingParms&, hvdb::Interrupter&);
};
protected:
void resolveObsoleteParms(PRM_ParmList*) override;
bool updateParmsFlags() override;
};
////////////////////////////////////////
// Build UI and register this operator
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
using namespace openvdb::math;
hutil::ParmList parms;
// Level set grid
parms.add(hutil::ParmFactory(PRM_STRING, "sourcegroup", "Source")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setDocumentation(
"A subset of the input level set VDBs to be morphed"
" (see [specifying volumes|/model/volumes#group])"));
// Target grid
parms.add(hutil::ParmFactory(PRM_STRING, "targetgroup", "Target")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setDocumentation(
"The target level set VDB (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "mask", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("Enable/disable the mask.")
.setDocumentation(nullptr));
// Alpha grid
parms.add(hutil::ParmFactory(PRM_STRING, "maskname", "Alpha Mask")
.setChoiceList(&hutil::PrimGroupMenuInput3)
.setTooltip(
"An optional scalar VDB to be used for alpha masking"
" (see [specifying volumes|/model/volumes#group])\n\n"
"Voxel values are assumed to be between 0 and 1."));
parms.add(hutil::ParmFactory(PRM_HEADING, "morphingheading", "Morphing")
.setDocumentation(
"These parameters control how the SDF moves from the source to the target."));
// Advect: timestep
parms.add(hutil::ParmFactory(PRM_FLT, "timestep", "Timestep")
.setDefault(1, "1.0/$FPS")
.setDocumentation(
"The number of seconds of movement to apply to the input points\n\n"
"The default is `1/$FPS` (one frame's worth of time).\n\n"
"TIP:\n"
" This parameter can be animated through time using the `$T`\n"
" expression. To control how fast the morphing is done, multiply `$T`\n"
" by a scale factor. For example, to animate it twice as fast, use\n"
" the expression, `$T*2`.\n"));
// Advect: spatial menu
{
std::vector<std::string> items;
items.push_back(biasedGradientSchemeToString(FIRST_BIAS));
items.push_back(biasedGradientSchemeToMenuName(FIRST_BIAS));
items.push_back(biasedGradientSchemeToString(HJWENO5_BIAS));
items.push_back(biasedGradientSchemeToMenuName(HJWENO5_BIAS));
parms.add(hutil::ParmFactory(PRM_STRING, "advectspatial", "Spatial Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(biasedGradientSchemeToString(HJWENO5_BIAS))
.setTooltip("Set the spatial finite difference scheme.")
.setDocumentation(
"How accurately the gradients of the signed distance field\n"
"are computed during advection\n\n"
"The later choices are more accurate but take more time."));
}
// Advect: temporal menu
{
std::vector<std::string> items;
for (int i = 0; i < NUM_TEMPORAL_SCHEMES; ++i) {
TemporalIntegrationScheme it = TemporalIntegrationScheme(i);
items.push_back(temporalIntegrationSchemeToString(it)); // token
items.push_back(temporalIntegrationSchemeToMenuName(it)); // label
}
parms.add(hutil::ParmFactory(PRM_STRING, "advecttemporal", "Temporal Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(temporalIntegrationSchemeToString(TVD_RK2))
.setTooltip("Set the temporal integration scheme.")
.setDocumentation(
"How accurately time is evolved within each advection step\n\n"
"The later choices are more accurate but take more time."));
}
parms.add(hutil::ParmFactory(PRM_HEADING, "renormheading", "Renormalization")
.setDocumentation(
"After morphing the signed distance field, it will often no longer"
" contain valid distances. A number of renormalization passes can be"
" performed to convert it back into a proper signed distance field."));
parms.add(hutil::ParmFactory(PRM_INT_J, "normsteps", "Steps")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip("The number of times to renormalize between each substep"));
// Renorm: spatial menu
{
std::vector<std::string> items;
items.push_back(biasedGradientSchemeToString(FIRST_BIAS));
items.push_back(biasedGradientSchemeToMenuName(FIRST_BIAS));
items.push_back(biasedGradientSchemeToString(HJWENO5_BIAS));
items.push_back(biasedGradientSchemeToMenuName(HJWENO5_BIAS));
parms.add(hutil::ParmFactory(PRM_STRING, "renormspatial", "Spatial Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(biasedGradientSchemeToString(HJWENO5_BIAS))
.setTooltip("Set the spatial finite difference scheme.")
.setDocumentation(
"How accurately the gradients of the signed distance field\n"
"are computed during renormalization\n\n"
"The later choices are more accurate but take more time."));
}
// Renorm: temporal menu
{
std::vector<std::string> items;
for (int i = 0; i < NUM_TEMPORAL_SCHEMES; ++i) {
TemporalIntegrationScheme it = TemporalIntegrationScheme(i);
items.push_back(temporalIntegrationSchemeToString(it)); // token
items.push_back(temporalIntegrationSchemeToMenuName(it)); // label
}
parms.add(hutil::ParmFactory(PRM_STRING, "renormtemporal", "Temporal Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(temporalIntegrationSchemeToString(TVD_RK2))
.setTooltip("Set the temporal integration scheme.")
.setDocumentation(
"How accurately time is evolved during renormalization\n\n"
"The later choices are more accurate but take more time."));
}
parms.add(hutil::ParmFactory(PRM_HEADING, "maskheading", "Alpha Mask"));
//Invert mask.
parms.add(hutil::ParmFactory(PRM_TOGGLE, "invert", "Invert Alpha Mask")
.setTooltip("Invert the optional mask so that alpha value 0 maps to 1 and 1 maps to 0."));
// Min mask range
parms.add(hutil::ParmFactory(PRM_FLT_J, "minmask", "Min Mask Cutoff")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_UI, 0.0, PRM_RANGE_UI, 1.0)
.setTooltip("Threshold below which to clamp mask values to zero"));
// Max mask range
parms.add(hutil::ParmFactory(PRM_FLT_J, "maxmask", "Max Mask Cutoff")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_UI, 0.0, PRM_RANGE_UI, 1.0)
.setTooltip("Threshold above which to clamp mask values to one"));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_FLT, "beginTime", "Begin time"));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT, "endTime", "Time step"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "lsGroup", "Source Level Set"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "targetGroup", "Target"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "maskGroup", "Alpha Mask"));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "morphingHeading", "Morphing"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "advectSpatial", "Spatial Scheme")
.setDefault(biasedGradientSchemeToString(HJWENO5_BIAS)));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "advectTemporal", "Temporal Scheme")
.setDefault(temporalIntegrationSchemeToString(TVD_RK2)));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "renormHeading", "Renormalization"));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "normSteps", "Steps")
.setDefault(PRMthreeDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "renormSpatial", "Spatial Scheme")
.setDefault(biasedGradientSchemeToString(HJWENO5_BIAS)));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "renormTemporal", "Temporal Scheme")
.setDefault(temporalIntegrationSchemeToString(TVD_RK2)));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "maskHeading", "Alpha Mask"));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "minMask", "Min Mask Cutoff")
.setDefault(PRMzeroDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "maxMask", "Max Mask Cutoff")
.setDefault(PRMoneDefaults));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Morph SDF",
SOP_OpenVDB_Morph_Level_Set::factory, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBMorphLevelSet")
#endif
.setObsoleteParms(obsoleteParms)
.addInput("Source SDF VDBs to Morph")
.addInput("Target SDF VDB")
.addOptionalInput("Optional VDB Alpha Mask")
.setVerb(SOP_NodeVerb::COOK_INPLACE,
[]() { return new SOP_OpenVDB_Morph_Level_Set::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Blend between source and target level set VDBs.\"\"\"\n\
\n\
@overview\n\
\n\
This node advects a source narrow-band signed distance field\n\
towards a target narrow-band signed distance field.\n\
\n\
@related\n\
- [OpenVDB Advect|Node:sop/DW_OpenVDBAdvect]\n\
- [OpenVDB Advect Points|Node:sop/DW_OpenVDBAdvectPoints]\n\
- [Node:sop/vdbmorphsdf]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Morph_Level_Set::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
resolveRenamedParm(*obsoleteParms, "advectSpatial", "advectspatial");
resolveRenamedParm(*obsoleteParms, "advectTemporal", "advecttemporal");
resolveRenamedParm(*obsoleteParms, "lsGroup", "sourcegroup");
resolveRenamedParm(*obsoleteParms, "maskGroup", "maskname");
resolveRenamedParm(*obsoleteParms, "maxMask", "maxmask");
resolveRenamedParm(*obsoleteParms, "minMask", "minmask");
resolveRenamedParm(*obsoleteParms, "normSteps", "normsteps");
resolveRenamedParm(*obsoleteParms, "renormSpatial", "renormspatial");
resolveRenamedParm(*obsoleteParms, "renormTemporal", "renormtemporal");
resolveRenamedParm(*obsoleteParms, "targetGroup", "targetgroup");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
// Enable/disable or show/hide parameters in the UI.
bool
SOP_OpenVDB_Morph_Level_Set::updateParmsFlags()
{
bool changed = false;
const bool hasMask = (this->nInputs() == 3);
changed |= enableParm("mask", hasMask);
const bool useMask = hasMask && bool(evalInt("mask", 0, 0));
changed |= enableParm("invert", useMask);
changed |= enableParm("minmask", useMask);
changed |= enableParm("maxmask", useMask);
changed |= enableParm("maskname", useMask);
return changed;
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Morph_Level_Set::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Morph_Level_Set(net, name, op);
}
SOP_OpenVDB_Morph_Level_Set::SOP_OpenVDB_Morph_Level_Set(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Morph_Level_Set::Cache::cookVDBSop(OP_Context& context)
{
try {
// Evaluate UI parameters
MorphingParms parms;
if (evalMorphingParms(context, parms) >= UT_ERROR_ABORT) return error();
hvdb::Interrupter boss("Morphing level set");
processGrids(parms, boss);
if (boss.wasInterrupted()) addWarning(SOP_MESSAGE, "Process was interrupted");
boss.end();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Morph_Level_Set::Cache::evalMorphingParms(
OP_Context& context, MorphingParms& parms)
{
const fpreal now = context.getTime();
parms.mLSGroup = matchGroup(*gdp, evalStdString("sourcegroup", now));
parms.mTimeStep = static_cast<float>(evalFloat("timestep", 0, now));
parms.mAdvectSpatial =
openvdb::math::stringToBiasedGradientScheme(evalStdString("advectspatial", now));
if (parms.mAdvectSpatial == openvdb::math::UNKNOWN_BIAS) {
addError(SOP_MESSAGE, "Morph: Unknown biased gradient");
return UT_ERROR_ABORT;
}
parms.mRenormSpatial =
openvdb::math::stringToBiasedGradientScheme(evalStdString("renormspatial", now));
if (parms.mRenormSpatial == openvdb::math::UNKNOWN_BIAS) {
addError(SOP_MESSAGE, "Renorm: Unknown biased gradient");
return UT_ERROR_ABORT;
}
parms.mAdvectTemporal =
openvdb::math::stringToTemporalIntegrationScheme(evalStdString("advecttemporal", now));
if (parms.mAdvectTemporal == openvdb::math::UNKNOWN_TIS) {
addError(SOP_MESSAGE, "Morph: Unknown temporal integration");
return UT_ERROR_ABORT;
}
parms.mRenormTemporal =
openvdb::math::stringToTemporalIntegrationScheme(evalStdString("renormtemporal", now));
if (parms.mRenormTemporal == openvdb::math::UNKNOWN_TIS) {
addError(SOP_MESSAGE, "Renorm: Unknown temporal integration");
return UT_ERROR_ABORT;
}
parms.mNormCount = static_cast<int>(evalInt("normsteps", 0, now));
const GU_Detail* targetGeo = inputGeo(1);
if (!targetGeo) {
addError(SOP_MESSAGE, "Missing target grid input");
return UT_ERROR_ABORT;
}
const GA_PrimitiveGroup* targetGroup =
matchGroup(*targetGeo, evalStdString("targetgroup", now));
hvdb::VdbPrimCIterator it(targetGeo, targetGroup);
if (it) {
if (it->getStorageType() != UT_VDB_FLOAT) {
addError(SOP_MESSAGE, "Unrecognized target grid type.");
return UT_ERROR_ABORT;
}
parms.mTargetGrid = hvdb::Grid::constGrid<openvdb::FloatGrid>(it->getConstGridPtr());
}
if (!parms.mTargetGrid) {
addError(SOP_MESSAGE, "Missing target grid");
return UT_ERROR_ABORT;
}
const GU_Detail* maskGeo = evalInt("mask", 0, now) ? inputGeo(2) : nullptr;
if (maskGeo) {
const GA_PrimitiveGroup* maskGroup =
matchGroup(*maskGeo, evalStdString("maskname", now));
hvdb::VdbPrimCIterator maskIt(maskGeo, maskGroup);
if (maskIt) {
if (maskIt->getStorageType() != UT_VDB_FLOAT) {
addError(SOP_MESSAGE, "Unrecognized alpha mask grid type.");
return UT_ERROR_ABORT;
}
parms.mMaskGrid = hvdb::Grid::constGrid<openvdb::FloatGrid>(maskIt->getConstGridPtr());
}
if (!parms.mMaskGrid) {
addError(SOP_MESSAGE, "Missing alpha mask grid");
return UT_ERROR_ABORT;
}
}
parms.mMinMask = static_cast<float>(evalFloat("minmask", 0, now));
parms.mMaxMask = static_cast<float>(evalFloat("maxmask", 0, now));
parms.mInvertMask = evalInt("invert", 0, now);
return error();
}
////////////////////////////////////////
bool
SOP_OpenVDB_Morph_Level_Set::Cache::processGrids(
MorphingParms& parms, hvdb::Interrupter& boss)
{
MorphOp op(parms, boss);
std::vector<std::string> skippedGrids, nonLevelSetGrids, narrowBands;
for (hvdb::VdbPrimIterator it(gdp, parms.mLSGroup); it; ++it) {
if (boss.wasInterrupted()) break;
GU_PrimVDB* vdbPrim = *it;
const openvdb::GridClass gridClass = vdbPrim->getGrid().getGridClass();
if (gridClass != openvdb::GRID_LEVEL_SET) {
nonLevelSetGrids.push_back(it.getPrimitiveNameOrIndex().toStdString());
continue;
}
if (vdbPrim->getStorageType() == UT_VDB_FLOAT) {
vdbPrim->makeGridUnique();
openvdb::FloatGrid& grid = UTvdbGridCast<openvdb::FloatGrid>(vdbPrim->getGrid());
if ( grid.background() < float(openvdb::LEVEL_SET_HALF_WIDTH * grid.voxelSize()[0]) ) {
narrowBands.push_back(it.getPrimitiveNameOrIndex().toStdString());
}
op(grid);
} else {
skippedGrids.push_back(it.getPrimitiveNameOrIndex().toStdString());
}
}
if (!skippedGrids.empty()) {
std::string s = "The following non-floating-point grids were skipped: "
+ hboost::algorithm::join(skippedGrids, ", ");
addWarning(SOP_MESSAGE, s.c_str());
}
if (!nonLevelSetGrids.empty()) {
std::string s = "The following non-level-set grids were skipped: "
+ hboost::algorithm::join(nonLevelSetGrids, ", ");
addWarning(SOP_MESSAGE, s.c_str());
}
if (!narrowBands.empty()) {
std::string s = "The following grids have a narrow band width that is"
" less than 3 voxel units: " + hboost::algorithm::join(narrowBands, ", ");
addWarning(SOP_MESSAGE, s.c_str());
}
return true;
}
| 20,548 | C++ | 34.551903 | 99 | 0.647557 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Topology_To_Level_Set.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Topology_To_Level_Set.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/GU_VDBPointTools.h>
#include <openvdb/tools/TopologyToLevelSet.h>
#include <openvdb/tools/LevelSetUtil.h>
#include <openvdb/points/PointDataGrid.h>
#include <UT/UT_Interrupt.h>
#include <GA/GA_Handle.h>
#include <GA/GA_Types.h>
#include <GA/GA_Iterator.h>
#include <GU/GU_Detail.h>
#include <PRM/PRM_Parm.h>
#include <stdexcept>
#include <string>
namespace cvdb = openvdb;
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Topology_To_Level_Set: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Topology_To_Level_Set(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Topology_To_Level_Set() override {}
bool updateParmsFlags() override;
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
void resolveObsoleteParms(PRM_ParmList*) override;
};
////////////////////////////////////////
namespace {
struct Converter
{
float bandWidthWorld;
int bandWidthVoxels, closingWidth, dilation, smoothingSteps;
bool worldSpaceUnits;
std::string outputName, customName;
Converter(GU_Detail& geo, hvdb::Interrupter& boss)
: bandWidthWorld(0)
, bandWidthVoxels(3)
, closingWidth(1)
, dilation(0)
, smoothingSteps(0)
, worldSpaceUnits(false)
, outputName("keep")
, customName("vdb")
, mGeoPt(&geo)
, mBossPt(&boss)
{
}
template<typename GridType>
void operator()(const GridType& grid)
{
int bandWidth = bandWidthVoxels;
if (worldSpaceUnits) {
bandWidth = int(openvdb::math::Round(bandWidthWorld / grid.transform().voxelSize()[0]));
}
openvdb::FloatGrid::Ptr sdfGrid = openvdb::tools::topologyToLevelSet(
grid, bandWidth, closingWidth, dilation, smoothingSteps, mBossPt);
std::string name = grid.getName();
if (outputName == "append") name += customName;
else if (outputName == "replace") name = customName;
hvdb::createVdbPrimitive(*mGeoPt, sdfGrid, name.c_str());
}
private:
GU_Detail * const mGeoPt;
hvdb::Interrupter * const mBossPt;
}; // struct Converter
} // unnamed namespace
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenu)
.setTooltip("Specify a subset of the input VDBs to be processed.")
.setDocumentation(
"A subset of the input VDB grids to be processed"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "outputname", "Output Name")
.setDefault("keep")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"keep", "Keep Original Name",
"append", "Add Suffix",
"replace", "Custom Name",
})
.setTooltip("Output VDB naming scheme")
.setDocumentation(
"Give the output VDB the same name as the input VDB,"
" or add a suffix to the input name, or use a custom name."));
parms.add(hutil::ParmFactory(PRM_STRING, "customname", "Custom Name")
.setTooltip("The suffix or custom name to be used"));
/// Narrow-band width {
parms.add(hutil::ParmFactory(PRM_TOGGLE, "worldspaceunits", "Use World Space for Band")
.setDocumentation(
"If enabled, specify the width of the narrow band in world units,"
" otherwise specify it in voxels. Voxel units work with all scales of geometry."));
parms.add(hutil::ParmFactory(PRM_INT_J, "bandwidth", "Half-Band in Voxels")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip(
"Specify the half width of the narrow band in voxels."
" Three voxels is optimal for many level set operations."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "bandwidthws", "Half-Band in World")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 10)
.setTooltip("Specify the half width of the narrow band in world units."));
/// }
parms.add(hutil::ParmFactory(PRM_INT_J, "dilation", "Voxel Dilation")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10)
.setTooltip("Expand the filled voxel region by the specified number of voxels."));
parms.add(hutil::ParmFactory(PRM_INT_J, "closingwidth", "Closing Width")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip(
"First expand the filled voxel region, then shrink it by the specified "
"number of voxels. This causes holes and valleys to be filled."));
parms.add(hutil::ParmFactory(PRM_INT_J, "smoothingsteps", "Smoothing Steps")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10)
.setTooltip("Number of smoothing iterations"));
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "outputName", "Output Name")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"keep", "Keep Original Name",
"append", "Add Suffix",
"replace", "Custom Name",
}));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "customName", "Custom Name"));
obsoleteParms.add(
hutil::ParmFactory(PRM_TOGGLE, "worldSpaceUnits", "Use World Space for Band"));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "bandWidth", "Half-Band in Voxels")
.setDefault(PRMthreeDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "bandWidthWS", "Half-Band in World")
.setDefault(PRMoneDefaults));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Topology to SDF",
SOP_OpenVDB_Topology_To_Level_Set::factory, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBTopologyToLevelSet")
#endif
.addInput("VDB Grids")
.setObsoleteParms(obsoleteParms)
.setVerb(SOP_NodeVerb::COOK_GENERATOR,
[]() { return new SOP_OpenVDB_Topology_To_Level_Set::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Create a level set VDB based on the active voxels of another VDB.\"\"\"\n\
\n\
@overview\n\
\n\
This node creates a narrow-band level set VDB that conforms to the active voxels\n\
of the input VDB. This forms a shell or wrapper that can be used\n\
to conservatively enclose the input volume.\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Topology_To_Level_Set::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Topology_To_Level_Set(net, name, op);
}
SOP_OpenVDB_Topology_To_Level_Set::SOP_OpenVDB_Topology_To_Level_Set(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
// Enable or disable parameters in the UI.
bool
SOP_OpenVDB_Topology_To_Level_Set::updateParmsFlags()
{
bool changed = false;
const fpreal time = 0;
const bool wsUnits = bool(evalInt("worldspaceunits", 0, time));
changed |= enableParm("bandwidth", !wsUnits);
changed |= enableParm("bandwidthws", wsUnits);
changed |= setVisibleState("bandwidth", !wsUnits);
changed |= setVisibleState("bandwidthws", wsUnits);
const auto outputName = evalStdString("outputname", time);
changed |= enableParm("customname", (outputName != "keep"));
return changed;
}
void
SOP_OpenVDB_Topology_To_Level_Set::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
const fpreal time = 0.0;
if (PRM_Parm* parm = obsoleteParms->getParmPtr("outputName")) {
if (!parm->isFactoryDefault()) {
std::string val{"keep"};
switch (obsoleteParms->evalInt("outputName", 0, time)) {
case 0: val = "keep"; break;
case 1: val = "append"; break;
case 2: val = "replace"; break;
}
setString(val.c_str(), CH_STRING_LITERAL, "outputname", 0, time);
}
}
resolveRenamedParm(*obsoleteParms, "customName", "customname");
resolveRenamedParm(*obsoleteParms, "worldSpaceUnits", "worldspaceunits");
resolveRenamedParm(*obsoleteParms, "bandWidth", "bandwidth");
resolveRenamedParm(*obsoleteParms, "bandWidthWS", "bandwidthws");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Topology_To_Level_Set::Cache::cookVDBSop(
OP_Context& context)
{
try {
const fpreal time = context.getTime();
const GU_Detail* inputGeoPt = inputGeo(0);
if (inputGeoPt == nullptr) return error();
hvdb::Interrupter boss;
// Get UI settings
Converter converter(*gdp, boss);
converter.worldSpaceUnits = evalInt("worldspaceunits", 0, time) != 0;
converter.bandWidthWorld = float(evalFloat("bandwidthws", 0, time));
converter.bandWidthVoxels = static_cast<int>(evalInt("bandwidth", 0, time));
converter.closingWidth = static_cast<int>(evalInt("closingwidth", 0, time));
converter.dilation = static_cast<int>(evalInt("dilation", 0, time));
converter.smoothingSteps = static_cast<int>(evalInt("smoothingsteps", 0, time));
converter.outputName = evalStdString("outputname", time);
converter.customName = evalStdString("customname", time);
// Process VDB primitives
const GA_PrimitiveGroup* group = matchGroup(*inputGeoPt, evalStdString("group", time));
hvdb::VdbPrimCIterator vdbIt(inputGeoPt, group);
if (!vdbIt) {
addWarning(SOP_MESSAGE, "No VDB grids to process.");
return error();
}
for (; vdbIt; ++vdbIt) {
if (boss.wasInterrupted()) break;
hvdb::GEOvdbApply<hvdb::AllGridTypes::Append<cvdb::MaskGrid>>(**vdbIt, converter);
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 10,835 | C++ | 31.346269 | 100 | 0.643286 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_VDBVerbUtils.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c)
* Side Effects Software Inc. All rights reserved.
*/
#ifndef OPENVDB_HOUDINI_SOP_VDBVERBUTILS_HAS_BEEN_INCLUDED
#define OPENVDB_HOUDINI_SOP_VDBVERBUTILS_HAS_BEEN_INCLUDED
#include <GOP/GOP_Manager.h>
#include <SOP/SOP_NodeParmsOptions.h> // for SOP_NodeCacheOptions
#include <openvdb/Types.h>
#include <string>
////////////////////////////////////////
/// @brief SOP_NodeCacheOptions subclass that adds methods specific to SOP_NodeVDB
class SOP_VDBCacheOptions: public SOP_NodeCacheOptions
{
public:
SOP_VDBCacheOptions() {}
~SOP_VDBCacheOptions() override {}
openvdb::Vec3f evalVec3f(const char* name, fpreal time) const
{
return openvdb::Vec3f(static_cast<float>(evalFloat(name, 0, time)),
static_cast<float>(evalFloat(name, 1, time)),
static_cast<float>(evalFloat(name, 2, time)));
}
openvdb::Vec3R evalVec3R(const char* name, fpreal time) const
{
return openvdb::Vec3R(evalFloat(name, 0, time),
evalFloat(name, 1, time),
evalFloat(name, 2, time));
}
openvdb::Vec3i evalVec3i(const char* name, fpreal time) const
{
using IntT = openvdb::Vec3i::ValueType;
return openvdb::Vec3i(static_cast<IntT>(evalInt(name, 0, time)),
static_cast<IntT>(evalInt(name, 1, time)),
static_cast<IntT>(evalInt(name, 2, time)));
}
openvdb::Vec2R evalVec2R(const char* name, fpreal time) const
{
return openvdb::Vec2R(evalFloat(name, 0, time),
evalFloat(name, 1, time));
}
openvdb::Vec2i evalVec2i(const char* name, fpreal time) const
{
using IntT = openvdb::Vec2i::ValueType;
return openvdb::Vec2i(static_cast<IntT>(evalInt(name, 0, time)),
static_cast<IntT>(evalInt(name, 1, time)));
}
std::string evalStdString(const char* name, fpreal time, int index = 0) const
{
UT_String str;
evalString(str, name, index, time);
return str.toStdString();
}
const GA_PrimitiveGroup *matchGroup(const GU_Detail &gdp, const UT_StringRef &groupname)
{
const GA_PrimitiveGroup *group = 0;
if (groupname.isstring())
{
bool success = false;
group = gop.parseOrderedPrimitiveDetached(groupname, &gdp, false, success);
if (!success)
{
UT_StringHolder error;
error = "Invalid group (";
error += groupname;
error += ")";
throw std::runtime_error(error.c_str());
}
}
return group;
}
const GA_PrimitiveGroup *
parsePrimitiveGroups(const UT_StringRef &maskStr, const GroupCreator &maskGeo)
{
return gop.parsePrimitiveGroups(maskStr, maskGeo);
}
GA_PrimitiveGroup *
parsePrimitiveGroupsCopy(const UT_StringRef &maskStr, const GroupCreator &maskGeo)
{
return gop.parsePrimitiveGroupsCopy(maskStr, maskGeo);
}
const GA_PointGroup *
parsePointGroups(const UT_StringRef &maskStr, const GroupCreator &maskGeo)
{
return gop.parsePointGroups(maskStr, maskGeo);
}
const GA_PointGroup *
parsePointGroups(const UT_StringRef &maskStr, const GU_Detail *gdp)
{
return parsePointGroups(maskStr, GroupCreator(gdp));
}
protected:
OP_ERROR cook(OP_Context &context) override final
{
auto result = cookMySop(context);
gop.destroyAdhocGroups();
return result;
}
virtual OP_ERROR cookVDBSop(OP_Context&) = 0;
OP_ERROR cookMySop(OP_Context& context) { return cookVDBSop(context); }
// Handles ad-hoc group creation.
GOP_Manager gop;
}; // class SOP_VDBCacheOptions
#endif // OPENVDB_HOUDINI_SOP_VDBVERBUTILS_HAS_BEEN_INCLUDED
| 4,055 | C | 31.448 | 92 | 0.602219 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Write.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Write.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/GEO_PrimVDB.h>
#include <openvdb_houdini/GU_PrimVDB.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_Interrupt.h>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Write: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Write(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Write() override {}
void getDescriptiveParmName(UT_String& s) const override { s = "file_name"; }
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
static int writeNowCallback(void* data, int index, float now, const PRM_Template*);
protected:
void resolveObsoleteParms(PRM_ParmList*) override;
OP_ERROR cookVDBSop(OP_Context&) override;
void writeOnNextCook(bool write = true) { mWriteOnNextCook = write; }
using StringSet = std::set<std::string>;
void reportFloatPrecisionConflicts(const StringSet& conflicts);
private:
void doCook(const fpreal time = 0);
bool mWriteOnNextCook;
};
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms, obsoleteParms;
// File name
parms.add(hutil::ParmFactory(PRM_FILE, "file_name", "File Name")
.setDefault(0, "./filename.vdb")
.setTooltip("Path name for the output VDB file"));
// Group
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Write only a subset of the input grids.")
.setDocumentation(
"Write only a subset of the input VDBs"
" (see [specifying volumes|/model/volumes#group])."));
// Compression
{
char const * const items[] = {
"none", "None",
"zip", "Zip",
"blosc", "Blosc",
nullptr
};
#ifdef OPENVDB_USE_BLOSC
parms.add(hutil::ParmFactory(PRM_ORD, "compression", "Compression")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault("blosc")
.setTooltip(
"Zip is slow but compresses very well. Blosc is fast and compresses well,\n"
"but files written with Blosc cannot be read by older versions of Houdini.\n")
.setDocumentation(
"[Blosc|http://www.blosc.org] is fast and compresses well."
" Zip is slow but compresses very well."
" For most cases Blosc is the recommended compression type."));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "compress_zip", "Zip Compression"));
#else
#ifdef OPENVDB_USE_ZLIB
parms.add(hutil::ParmFactory(PRM_TOGGLE, "compress_zip", "Zip Compression")
.setDefault(true)
.setTooltip(
"Apply Zip \"deflate\" compression to non-SDF and non-fog grids.\n"
"(Zip compression can be slow for large volumes.)"));
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "compression", "Compression")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items));
#else
// no compression available
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "compress_zip", "Zip Compression"));
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "compression", "Compression")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items));
#endif
#endif
}
// Write mode (manual/auto)
parms.add(hutil::ParmFactory(PRM_ORD, "writeMode", "Write Mode")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"manual", "Manual",
"auto", "Automatic"
})
.setTooltip(
"In Manual mode, click the Write Now button\n"
"to write the output file.\n"
"In Automatic mode, the file is written\n"
"each time this node cooks."));
// "Write Now" button
parms.add(hutil::ParmFactory(PRM_CALLBACK, "write", "Write Now")
.setCallbackFunc(&SOP_OpenVDB_Write::writeNowCallback)
.setTooltip("Click to write the output file."));
{ // Float precision
parms.add(hutil::ParmFactory(PRM_HEADING, "float_header", "Float Precision"));
parms.add(hutil::ParmFactory(PRM_STRING, "float_16_group", "Write 16-Bit")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip(
"For grids that belong to the group(s) listed here,\n"
"write floating-point scalar or vector voxel values\n"
"using 16-bit half floats.\n"
"If no groups are listed, all grids will be written\n"
"using their existing precision settings."));
parms.add(hutil::ParmFactory(PRM_STRING, "float_full_group", "Write Full-Precision")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip(
"For grids that belong to the group(s) listed here,\n"
"write floating-point scalar or vector voxel values\n"
"using full-precision floats or doubles.\n"
"If no groups are listed, all grids will be written\n"
"using their existing precision settings."));
}
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Write", SOP_OpenVDB_Write::factory, parms, *table)
.setNativeName("")
.setObsoleteParms(obsoleteParms)
.addInput("VDBs to be written to disk")
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Write a `.vdb` file to disk.\"\"\"\n\
\n\
@overview\n\
\n\
This node writes VDB volumes to a `.vdb` file.\n\
It is usually preferable to use Houdini's native [File|Node:sop/file] node,\n\
but this node allows one to specify the file compression scheme\n\
and to control floating-point precision for individual volumes,\n\
options that are not available on the native node.\n\
\n\
@related\n\
- [OpenVDB Read|Node:sop/DW_OpenVDBRead]\n\
- [Node:sop/file]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Write::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
#ifdef OPENVDB_USE_BLOSC
PRM_Parm* parm = obsoleteParms->getParmPtr("compress_zip");
if (parm && !parm->isFactoryDefault()) {
const bool zip = obsoleteParms->evalInt("compress_zip", 0, /*time=*/0.0);
const UT_String compression(zip ? "zip" : "none");
setString(compression, CH_STRING_LITERAL, "compression", 0, 0.0);
}
#else
#ifdef OPENVDB_USE_ZLIB
if (nullptr != obsoleteParms->getParmPtr("compression")
&& !obsoleteParms->getParmPtr("compression")->isFactoryDefault()) {
UT_String compression;
obsoleteParms->evalString(compression, "compression", 0, /*time=*/0.0);
setInt("compress_zip", 0, 0.0, (compression == "zip" ? 1 : 0));
}
#endif
#endif
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
OP_Node*
SOP_OpenVDB_Write::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Write(net, name, op);
}
SOP_OpenVDB_Write::SOP_OpenVDB_Write(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op),
mWriteOnNextCook(false)
{
}
////////////////////////////////////////
int
SOP_OpenVDB_Write::writeNowCallback(
void *data, int /*index*/, float /*now*/,
const PRM_Template*)
{
if (SOP_OpenVDB_Write* self = static_cast<SOP_OpenVDB_Write*>(data)) {
self->writeOnNextCook();
self->forceRecook();
return 1;
}
return 0;
}
////////////////////////////////////////
/// If any grids belong to both the "Write 16-Bit" and "Write Full-Precision"
/// groups, display a warning.
void
SOP_OpenVDB_Write::reportFloatPrecisionConflicts(const StringSet& conflicts)
{
if (conflicts.empty()) return;
std::ostringstream ostr;
if (conflicts.size() == 1) {
ostr << "For grid \"" << *conflicts.begin() << "\"";
} else {
StringSet::const_iterator i = conflicts.begin(), e = conflicts.end();
ostr << "For grids \"" << *i << "\"";
// Join grid names into a string of the form "grid1, grid2 and grid3".
size_t count = conflicts.size(), n = 1;
for (++i; i != e; ++i, ++n) {
if (n + 1 < count) ostr << ", "; else ostr << " and ";
ostr << "\"" << *i << "\"";
}
}
ostr << ", specify either 16-bit output or full-precision output"
<< " or neither, but not both.";
// Word wrap the message at 60 columns and indent the first line.
const std::string prefix(20, '#');
UT_String word_wrapped(prefix + ostr.str());
word_wrapped.format(60/*cols*/);
word_wrapped.replacePrefix(prefix.c_str(), "");
addWarning(SOP_MESSAGE, word_wrapped);
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Write::cookVDBSop(OP_Context& context)
{
try {
hutil::ScopedInputLock lock(*this, context);
const fpreal t = context.getTime();
if (mWriteOnNextCook || 1 == evalInt("writeMode", 0, t)) {
duplicateSource(0, context);
doCook(t);
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
void
SOP_OpenVDB_Write::doCook(const fpreal time)
{
// Get the filename of the output file.
const std::string filename = evalStdString("file_name", time);
if (filename.empty()) {
addWarning(SOP_MESSAGE, "no name given for the output file");
return;
}
// Get grid groups.
UT_String groupStr, halfGroupStr, fullGroupStr;
evalString(groupStr, "group", 0, time);
evalString(halfGroupStr, "float_16_group", 0, time);
evalString(fullGroupStr, "float_full_group", 0, time);
const GA_PrimitiveGroup
*group = matchGroup(*gdp, groupStr.toStdString()),
*halfGroup = nullptr,
*fullGroup = nullptr;
if (halfGroupStr.isstring()) {
// Normally, an empty group pattern matches all primitives, but
// for the float precision filters, we want it to match nothing.
halfGroup = matchGroup(*gdp, halfGroupStr.toStdString());
}
if (fullGroupStr.isstring()) {
fullGroup = matchGroup(*gdp, fullGroupStr.toStdString());
}
// Get compression options.
#ifdef OPENVDB_USE_BLOSC
UT_String compression;
evalString(compression, "compression", 0, time);
#else
#ifdef OPENVDB_USE_ZLIB
const bool zip = evalInt("compress_zip", 0, time);
#endif
#endif
UT_AutoInterrupt progress(("Writing " + filename).c_str());
// Set of names of grids that the user selected for both 16-bit
// and full-precision conversion
StringSet conflicts;
// Collect pointers to grids from VDB primitives found in the geometry.
openvdb::GridPtrSet outGrids;
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (progress.wasInterrupted()) {
throw std::runtime_error("Interrupted");
}
const GU_PrimVDB* vdb = *it;
// Create a new grid that shares the primitive's tree and transform
// and then transfer primitive attributes to the new grid as metadata.
hvdb::GridPtr grid = openvdb::ConstPtrCast<hvdb::Grid>(vdb->getGrid().copyGrid());
GU_PrimVDB::createMetadataFromGridAttrs(*grid, *vdb, *gdp);
grid->removeMeta("is_vdb");
// Retrieve the grid's name from the primitive attribute.
const std::string gridName = it.getPrimitiveName().toStdString();
// Check if the user has overridden this grid's saveFloatAsHalf setting.
if (halfGroup && halfGroup->contains(vdb)) {
if (fullGroup && fullGroup->contains(vdb)) {
// This grid belongs to both the 16-bit and full-precision groups.
conflicts.insert(gridName);
} else {
grid->setSaveFloatAsHalf(true);
}
} else if (fullGroup && fullGroup->contains(vdb)) {
if (halfGroup && halfGroup->contains(vdb)) {
// This grid belongs to both the 16-bit and full-precision groups.
conflicts.insert(gridName);
} else {
grid->setSaveFloatAsHalf(false);
}
} else {
// Preserve this grid's existing saveFloatAsHalf setting.
}
outGrids.insert(grid);
}
if (outGrids.empty()) {
addWarning(SOP_MESSAGE, ("No grids were written to " + filename).c_str());
}
reportFloatPrecisionConflicts(conflicts);
// Add file-level metadata.
openvdb::MetaMap outMeta;
outMeta.insertMeta("creator",
openvdb::StringMetadata("Houdini/SOP_OpenVDB_Write"));
// Create a VDB file object.
openvdb::io::File file(filename);
#ifdef OPENVDB_USE_BLOSC
uint32_t compressionFlags = file.compression();
if (compression == "none") {
compressionFlags &= ~(openvdb::io::COMPRESS_ZIP | openvdb::io::COMPRESS_BLOSC);
} else if (compression == "blosc") {
compressionFlags &= ~openvdb::io::COMPRESS_ZIP;
compressionFlags |= openvdb::io::COMPRESS_BLOSC;
} else if (compression == "zip") {
compressionFlags |= openvdb::io::COMPRESS_ZIP;
compressionFlags &= ~openvdb::io::COMPRESS_BLOSC;
}
#else
uint32_t compressionFlags = openvdb::io::COMPRESS_ACTIVE_MASK;
#ifdef OPENVDB_USE_ZLIB
if (zip) compressionFlags |= openvdb::io::COMPRESS_ZIP;
#endif
#endif // OPENVDB_USE_BLOSC
file.setCompression(compressionFlags);
file.write(outGrids, outMeta);
file.close();
mWriteOnNextCook = false;
}
| 14,101 | C++ | 32.103286 | 94 | 0.62024 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GEO_VDBTranslator.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c)
* Side Effects Software Inc. All rights reserved.
*/
#include "GU_PrimVDB.h"
#include "Utils.h"
#include <UT/UT_EnvControl.h>
#include <UT/UT_Error.h>
#include <UT/UT_ErrorManager.h>
#include <UT/UT_IOTable.h>
#include <UT/UT_IStream.h>
#include <UT/UT_Version.h>
#include <FS/FS_IStreamDevice.h>
#include <GA/GA_Stat.h>
#include <GU/GU_Detail.h>
#include <SOP/SOP_Node.h>
#include <GEO/GEO_IOTranslator.h>
#include <openvdb/io/Stream.h>
#include <openvdb/io/File.h>
#include <openvdb/Metadata.h>
#include <stdio.h>
#include <iostream>
using namespace openvdb_houdini;
using std::cerr;
namespace {
class GEO_VDBTranslator : public GEO_IOTranslator
{
public:
GEO_VDBTranslator() {}
~GEO_VDBTranslator() override {}
GEO_IOTranslator *duplicate() const override;
const char *formatName() const override;
int checkExtension(const char *name) override;
void getFileExtensions(
UT_StringArray &extensions) const override;
int checkMagicNumber(unsigned magic) override;
bool fileStat(
const char *filename,
GA_Stat &stat,
uint level) override;
GA_Detail::IOStatus fileLoad(
GEO_Detail *gdp,
UT_IStream &is,
bool ate_magic) override;
GA_Detail::IOStatus fileSave(
const GEO_Detail *gdp,
std::ostream &os) override;
GA_Detail::IOStatus fileSaveToFile(
const GEO_Detail *gdp,
const char *fname) override;
};
GEO_IOTranslator *
GEO_VDBTranslator::duplicate() const
{
return new GEO_VDBTranslator();
}
const char *
GEO_VDBTranslator::formatName() const
{
return "VDB Format";
}
int
GEO_VDBTranslator::checkExtension(const char *name)
{
return UT_String(name).matchFileExtension(".vdb");
}
void
GEO_VDBTranslator::getFileExtensions(UT_StringArray &extensions) const
{
extensions.clear();
extensions.append(".vdb");
}
int
GEO_VDBTranslator::checkMagicNumber(unsigned /*magic*/)
{
return 0;
}
bool
GEO_VDBTranslator::fileStat(const char *filename, GA_Stat &stat, uint /*level*/)
{
stat.clear();
try {
openvdb::io::File file(filename);
file.open(/*delayLoad*/false);
int nprim = 0;
UT_BoundingBox bbox;
bbox.makeInvalid();
// Loop over all grids in the file.
for (openvdb::io::File::NameIterator nameIter = file.beginName();
nameIter != file.endName(); ++nameIter)
{
const std::string& gridName = nameIter.gridName();
// Read the grid metadata.
auto grid = file.readGridMetadata(gridName);
auto stats = grid->getStatsMetadata();
openvdb::Vec3IMetadata::Ptr meta_minbbox, meta_maxbbox;
UT_BoundingBox voxelbox;
voxelbox.initBounds();
meta_minbbox = stats->getMetadata<openvdb::Vec3IMetadata>("file_bbox_min");
meta_maxbbox = stats->getMetadata<openvdb::Vec3IMetadata>("file_bbox_max");
if (meta_minbbox && meta_maxbbox)
{
UT_Vector3 minv, maxv;
minv = UTvdbConvert(meta_minbbox->value());
maxv = UTvdbConvert(meta_maxbbox->value());
voxelbox.enlargeBounds(minv);
voxelbox.enlargeBounds(maxv);
// We need to convert from corner-sampled (as in VDB)
// to center-sampled (as our BBOX elsewhere reports)
voxelbox.expandBounds(0.5, 0.5, 0.5);
// Transform
UT_Vector3 voxelpts[8];
UT_BoundingBox worldbox;
worldbox.initBounds();
voxelbox.getBBoxPoints(voxelpts);
for (int i = 0; i < 8; i++)
{
worldbox.enlargeBounds(
UTvdbConvert( grid->indexToWorld(UTvdbConvert(voxelpts[i])) ) );
}
bbox.enlargeBounds(worldbox);
}
if (voxelbox.isValid()) {
stat.appendVolume(nprim, gridName.c_str(),
static_cast<int>(voxelbox.size().x()),
static_cast<int>(voxelbox.size().y()),
static_cast<int>(voxelbox.size().z()));
} else {
stat.appendVolume(nprim, gridName.c_str(), 0, 0, 0);
}
nprim++;
}
// Straightforward correspondence:
stat.setPointCount(nprim);
stat.setVertexCount(nprim);
stat.setPrimitiveCount(nprim);
stat.setBounds(bbox);
file.close();
} catch (std::exception &e) {
cerr << "Stat failure: " << e.what() << "\n";
return false;
}
return true;
}
GA_Detail::IOStatus
GEO_VDBTranslator::fileLoad(GEO_Detail *geogdp, UT_IStream &is, bool /*ate_magic*/)
{
UT_WorkBuffer buf;
GU_Detail *gdp = static_cast<GU_Detail*>(geogdp);
bool ok = true;
// Create a std::stream proxy.
FS_IStreamDevice reader(&is);
auto streambuf = new FS_IStreamDeviceBuffer(reader);
auto stdstream = new std::istream(streambuf);
try {
// Create and open a VDB file, but don't read any grids yet.
openvdb::io::Stream file(*stdstream, /*delayLoad*/false);
// Read the file-level metadata into global attributes.
openvdb::MetaMap::Ptr fileMetadata = file.getMetadata();
if (fileMetadata) {
GU_PrimVDB::createAttrsFromMetadata(
GA_ATTRIB_GLOBAL, GA_Offset(0), *fileMetadata, *geogdp);
}
// Loop over all grids in the file.
auto && allgrids = file.getGrids();
for (auto && grid : *allgrids)
{
// Add a new VDB primitive for this grid.
// Note: this clears the grid's metadata.
createVdbPrimitive(*gdp, grid);
}
} catch (std::exception &e) {
// Add a warning here instead of an error or else the File SOP's
// Missing Frame parameter won't be able to suppress cook errors.
UTaddCommonWarning(UT_ERROR_JUST_STRING, e.what());
ok = false;
}
delete stdstream;
delete streambuf;
return ok;
}
template <typename FileT, typename OutputT>
bool
fileSaveVDB(const GEO_Detail *geogdp, OutputT os)
{
const GU_Detail *gdp = static_cast<const GU_Detail*>(geogdp);
if (!gdp) return false;
try {
// Populate an output GridMap with VDB grid primitives found in the
// geometry.
openvdb::GridPtrVec outGrids;
for (VdbPrimCIterator it(gdp); it; ++it) {
const GU_PrimVDB* vdb = *it;
// Create a new grid that shares the primitive's tree and transform
// and then transfer primitive attributes to the new grid as metadata.
GridPtr grid = openvdb::ConstPtrCast<Grid>(vdb->getGrid().copyGrid());
GU_PrimVDB::createMetadataFromGridAttrs(*grid, *vdb, *gdp);
grid->removeMeta("is_vdb");
// Retrieve the grid's name from the primitive attribute.
grid->setName(it.getPrimitiveName().toStdString());
outGrids.push_back(grid);
}
// Add file-level metadata.
openvdb::MetaMap fileMetadata;
std::string versionStr = "Houdini ";
versionStr += UTgetFullVersion();
versionStr += "/GEO_VDBTranslator";
fileMetadata.insertMeta("creator", openvdb::StringMetadata(versionStr));
#if defined(SESI_OPENVDB)
GU_PrimVDB::createMetadataFromAttrs(
fileMetadata, GA_ATTRIB_GLOBAL, GA_Offset(0), *gdp);
#endif
// Create a VDB file object.
FileT file(os);
// Always enable active mask compression, since it is fast
// and compresses level sets and fog volumes well.
uint32_t compression = openvdb::io::COMPRESS_ACTIVE_MASK;
// Enable Blosc unless backwards compatibility is requested.
if (openvdb::io::Archive::hasBloscCompression()
&& !UT_EnvControl::getInt(ENV_HOUDINI13_VOLUME_COMPATIBILITY)) {
compression |= openvdb::io::COMPRESS_BLOSC;
}
file.setCompression(compression);
file.write(outGrids, fileMetadata);
} catch (std::exception &e) {
cerr << "Save failure: " << e.what() << "\n";
return false;
}
return true;
}
GA_Detail::IOStatus
GEO_VDBTranslator::fileSave(const GEO_Detail *geogdp, std::ostream &os)
{
// Saving via io::Stream will NOT save grid offsets, disabling partial
// reading.
return fileSaveVDB<openvdb::io::Stream, std::ostream &>(geogdp, os);
}
GA_Detail::IOStatus
GEO_VDBTranslator::fileSaveToFile(const GEO_Detail *geogdp, const char *fname)
{
// Saving via io::File will save grid offsets that allow for partial
// reading.
return fileSaveVDB<openvdb::io::File, const char *>(geogdp, fname);
}
} // unnamed namespace
void
new_VDBGeometryIO(void *)
{
GU_Detail::registerIOTranslator(new GEO_VDBTranslator());
// addExtension() will ignore if vdb is already in the list of extensions
UTgetGeoExtensions()->addExtension("vdb");
}
#ifndef SESI_OPENVDB
void
newGeometryIO(void *data)
{
// Initialize the version of the OpenVDB library that this library is built against
// (i.e., not the HDK native OpenVDB library).
openvdb::initialize();
// Register a .vdb file translator.
new_VDBGeometryIO(data);
}
#endif
| 9,883 | C++ | 28.951515 | 92 | 0.587069 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Analysis.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Analysis.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Compute gradient fields and other differential properties from VDB volumes
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/GridOperators.h>
#include <openvdb/tools/LevelSetUtil.h>
#include <openvdb/tools/Mask.h> // for tools::interiorMask()
#include <openvdb/tools/GridTransformer.h>
#include <UT/UT_Interrupt.h>
#include <sstream>
#include <stdexcept>
#include <string>
namespace cvdb = openvdb;
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace {
enum OpId {
OP_GRADIENT = 0,
OP_CURVATURE = 1,
OP_LAPLACIAN = 2,
OP_CPT = 3,
OP_DIVERGENCE = 4,
OP_CURL = 5,
OP_MAGNITUDE = 6,
OP_NORMALIZE = 7
};
}
class SOP_OpenVDB_Analysis: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Analysis(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Analysis() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i == 1); }
static const char* sOpName[];
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
};
////////////////////////////////////////
const char* SOP_OpenVDB_Analysis::sOpName[] = {
"gradient",
"curvature",
"laplacian",
"closest point transform",
"divergence",
"curl",
"magnitude",
"normalize"
};
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Group pattern
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to be processed.")
.setDocumentation(
"A subset of VDBs to analyze (see [specifying volumes|/model/volumes#group])"));
// Operator
parms.add(hutil::ParmFactory(PRM_ORD, "operator", "Operator")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"gradient", "Gradient (Scalar->Vector)",
"curvature", "Curvature (Scalar->Scalar)",
"laplacian", "Laplacian (Scalar->Scalar)",
"closestpoint", "Closest Point (Scalar->Vector)",
"divergence", "Divergence (Vector->Scalar)",
"curl", "Curl (Vector->Vector)",
"length", "Length (Vector->Scalar)",
"normalize", "Normalize (Vector->Vector)"
})
.setDocumentation("\
What to compute\n\
\n\
The labels on the items in the menu indicate what datatype\n\
the incoming VDB volume must be and the datatype of the output volume.\n\
\n\
Gradient (scalar -> vector):\n\
The gradient of a scalar field\n\
\n\
Curvature (scalar -> scalar):\n\
The mean curvature of a scalar field\n\
\n\
Laplacian (scalar -> scalar):\n\
The Laplacian of a scalar field\n\
\n\
Closest Point (scalar -> vector):\n\
The location, at each voxel, of the closest point on a surface\n\
defined by the incoming signed distance field\n\
\n\
You can use the resulting field with the\n\
[OpenVDB Advect Points node|Node:sop/DW_OpenVDBAdvectPoints]\n\
to stick points to the surface.\n\
\n\
Divergence (vector -> scalar):\n\
The divergence of a vector field\n\
\n\
Curl (vector -> vector):\n\
The curl of a vector field\n\
\n\
Magnitude (vector -> scalar):\n\
The length of the vectors in a vector field\n\
\n\
Normalize (vector -> vector):\n\
The vectors in a vector field divided by their lengths\n"));
parms.add(hutil::ParmFactory(PRM_STRING, "maskname", "Mask VDB")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("VDB (from the second input) used to define the iteration space")
.setDocumentation(
"A VDB from the second input used to define the iteration space"
" (see [specifying volumes|/model/volumes#group])\n\n"
"The selected __Operator__ will be applied only where the mask VDB has"
" [active|http://www.openvdb.org/documentation/doxygen/overview.html#subsecInactive]"
" voxels or, if the mask VDB is a level set, only in the interior of the level set."));
// Output name
parms.add(hutil::ParmFactory(PRM_STRING, "outputname", "Output Name")
.setDefault("keep")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"keep", "Keep Incoming VDB Names",
"append", "Append Operation Name",
"custom", "Custom Name"
})
.setTooltip("Rename output grid(s)")
.setDocumentation(
"How to name the generated VDB volumes\n\n"
"If you choose __Keep Incoming VDB Names__, the generated fields"
" will replace the input fields."));
parms.add(hutil::ParmFactory(PRM_STRING, "customname", "Custom Name")
.setTooltip("Rename all output grids with this custom name")
.setDocumentation("If this is not blank, the output VDB will use this name."));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "threaded", "Multithreaded"));
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "outputName", "Output Name")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"keep", "Keep Incoming VDB Names",
"append", "Append Operation Name",
"custom", "Custom Name"
}));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "customName", "Custom Name"));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Analysis", SOP_OpenVDB_Analysis::factory, parms, *table)
.setObsoleteParms(obsoleteParms)
.addInput("VDBs to Analyze")
.addOptionalInput("Optional VDB mask input")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Analysis::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Compute an analytic property of a VDB volume, such as gradient or curvature.\"\"\"\n\
\n\
@overview\n\
\n\
This node computes certain properties from the values of VDB volumes,\n\
and generates new VDB volumes where the voxel values are the computed results.\n\
Using the __Output Name__ parameter you can choose whether the generated\n\
volumes replace the original volumes.\n\
\n\
@related\n\
\n\
- [OpenVDB Advect Points|Node:sop/DW_OpenVDBAdvectPoints]\n\
- [Node:sop/volumeanalysis]\n\
- [Node:sop/vdbanalysis]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Analysis::factory(OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Analysis(net, name, op);
}
SOP_OpenVDB_Analysis::SOP_OpenVDB_Analysis(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
namespace {
template<template<typename GridT, typename MaskType, typename InterruptT> class ToolT>
struct ToolOp
{
ToolOp(bool t, hvdb::Interrupter& boss, const cvdb::BoolGrid *mask = nullptr)
: mMaskGrid(mask)
, mThreaded(t)
, mBoss(boss)
{
}
template<typename GridType>
void operator()(const GridType& inGrid)
{
if (mMaskGrid) {
// match transform
cvdb::BoolGrid regionMask;
regionMask.setTransform(inGrid.transform().copy());
openvdb::tools::resampleToMatch<openvdb::tools::PointSampler>(
*mMaskGrid, regionMask, mBoss);
ToolT<GridType, cvdb::BoolGrid, hvdb::Interrupter> tool(inGrid, regionMask, &mBoss);
mOutGrid = tool.process(mThreaded);
} else {
ToolT<GridType, cvdb::BoolGrid/*dummy*/, hvdb::Interrupter> tool(inGrid, &mBoss);
mOutGrid = tool.process(mThreaded);
}
}
const cvdb::BoolGrid *mMaskGrid;
hvdb::GridPtr mOutGrid;
bool mThreaded;
hvdb::Interrupter& mBoss;
};
struct MaskOp
{
template<typename GridType>
void operator()(const GridType& grid) { mMaskGrid = cvdb::tools::interiorMask(grid); }
cvdb::BoolGrid::Ptr mMaskGrid;
};
} // unnamed namespace
////////////////////////////////////////
// Enable or disable parameters in the UI.
bool
SOP_OpenVDB_Analysis::updateParmsFlags()
{
bool changed = false;
bool useCustomName = (evalStdString("outputname", 0) == "custom");
changed |= enableParm("customname", useCustomName);
#ifndef SESI_OPENVDB
changed |= setVisibleState("customname", useCustomName);
#endif
const bool hasMask = (2 == nInputs());
changed |= enableParm("maskname", hasMask);
return changed;
}
void
SOP_OpenVDB_Analysis::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
const fpreal time = 0.0;
if (PRM_Parm* parm = obsoleteParms->getParmPtr("outputName")) {
if (!parm->isFactoryDefault()) {
std::string val{"keep"};
switch (obsoleteParms->evalInt("outputName", 0, time)) {
case 0: val = "keep"; break;
case 1: val = "append"; break;
case 2: val = "custom"; break;
}
setString(val.c_str(), CH_STRING_LITERAL, "outputname", 0, time);
}
}
resolveRenamedParm(*obsoleteParms, "customName", "customname");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Analysis::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
// Get the group of grids to be transformed.
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
const int whichOp = static_cast<int>(evalInt("operator", 0, time));
if (whichOp < 0 || whichOp > 7) {
std::ostringstream ostr;
ostr << "expected 0 <= operator <= 7, got " << whichOp;
throw std::runtime_error(ostr.str().c_str());
}
const bool threaded = true;
hvdb::Interrupter boss(
(std::string("Computing ") + sOpName[whichOp] + " of VDB grids").c_str());
// Check mask input
const GU_Detail* maskGeo = inputGeo(1);
cvdb::BoolGrid::Ptr maskGrid;
if (maskGeo) {
const GA_PrimitiveGroup* maskGroup = parsePrimitiveGroups(
evalStdString("maskname", time).c_str(), GroupCreator(maskGeo));
hvdb::VdbPrimCIterator maskIt(maskGeo, maskGroup);
if (maskIt) {
MaskOp op;
if (hvdb::GEOvdbApply<hvdb::AllGridTypes>(**maskIt, op)) {
maskGrid = op.mMaskGrid;
}
}
if (!maskGrid) addWarning(SOP_MESSAGE, "Mask VDB not found.");
}
// For each VDB primitive (with a non-null grid pointer) in the given group...
std::string operationName;
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (boss.wasInterrupted()) throw std::runtime_error("was interrupted");
GU_PrimVDB* vdb = *it;
hvdb::GridPtr outGrid;
bool ok = true;
switch (whichOp)
{
case OP_GRADIENT: // gradient of scalar field
{
ToolOp<cvdb::tools::Gradient> op(threaded, boss, maskGrid.get());
if (hvdb::GEOvdbApply<hvdb::NumericGridTypes>(*vdb, op, /*makeUnique=*/false)) {
outGrid = op.mOutGrid;
}
operationName = "_gradient";
break;
}
case OP_CURVATURE: // mean curvature of scalar field
{
ToolOp<cvdb::tools::MeanCurvature> op(threaded, boss, maskGrid.get());
if (hvdb::GEOvdbApply<hvdb::NumericGridTypes>(*vdb, op, /*makeUnique=*/false)) {
outGrid = op.mOutGrid;
}
operationName = "_curvature";
break;
}
case OP_LAPLACIAN: // Laplacian of scalar field
{
ToolOp<cvdb::tools::Laplacian> op(threaded, boss, maskGrid.get());
if (hvdb::GEOvdbApply<hvdb::NumericGridTypes>(*vdb, op, /*makeUnique=*/false)) {
outGrid = op.mOutGrid;
}
operationName = "_laplacian";
break;
}
case OP_CPT: // closest point transform of scalar level set
{
ToolOp<cvdb::tools::Cpt> op(threaded, boss, maskGrid.get());
if (hvdb::GEOvdbApply<hvdb::NumericGridTypes>(*vdb, op, /*makeUnique=*/false)) {
outGrid = op.mOutGrid;
}
operationName = "_cpt";
break;
}
case OP_DIVERGENCE: // divergence of vector field
{
ToolOp<cvdb::tools::Divergence> op(threaded, boss, maskGrid.get());
if (hvdb::GEOvdbApply<hvdb::Vec3GridTypes>(*vdb, op, /*makeUnique=*/false)) {
outGrid = op.mOutGrid;
}
operationName = "_divergence";
break;
}
case OP_CURL: // curl (rotation) of vector field
{
ToolOp<cvdb::tools::Curl> op(threaded, boss, maskGrid.get());
if (hvdb::GEOvdbApply<hvdb::Vec3GridTypes>(*vdb, op, /*makeUnique=*/false)) {
outGrid = op.mOutGrid;
}
operationName = "_curl";
break;
}
case OP_MAGNITUDE: // magnitude of vector field
{
ToolOp<cvdb::tools::Magnitude> op(threaded, boss, maskGrid.get());
if (hvdb::GEOvdbApply<hvdb::Vec3GridTypes>(*vdb, op, /*makeUnique=*/false)) {
outGrid = op.mOutGrid;
}
operationName = "_magnitude";
break;
}
case OP_NORMALIZE: // normalize vector field
{
ToolOp<cvdb::tools::Normalize> op(threaded, boss, maskGrid.get());
if (hvdb::GEOvdbApply<hvdb::Vec3GridTypes>(*vdb, op, /*makeUnique=*/false)) {
outGrid = op.mOutGrid;
}
operationName = "_normalize";
break;
}
}
if (!ok) {
UT_String inGridName = it.getPrimitiveNameOrIndex();
std::ostringstream ss;
ss << "Can't compute " << sOpName[whichOp] << " from grid";
if (inGridName.isstring()) ss << " " << inGridName;
ss << " of type " << UTvdbGetGridTypeString(vdb->getGrid());
addWarning(SOP_MESSAGE, ss.str().c_str());
}
// Rename grid
std::string gridName = vdb->getGridName();
const auto renaming = evalStdString("outputname", time);
if (renaming == "append") {
if (operationName.size() > 0) gridName += operationName;
} else if (renaming == "custom") {
const auto customName = evalStdString("customname", time);
if (!customName.empty()) gridName = customName;
}
// Replace the original VDB primitive with a new primitive that contains
// the output grid and has the same attributes and group membership.
hvdb::replaceVdbPrimitive(*gdp, outGrid, *vdb, true, gridName.c_str());
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 16,611 | C++ | 32.559596 | 100 | 0.568118 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Points_Convert.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file SOP_OpenVDB_Points_Convert.cc
///
/// @authors Dan Bailey, Nick Avramoussis, James Bird
///
/// @brief Converts points to OpenVDB points.
#include <openvdb/openvdb.h>
#include <openvdb/points/PointDataGrid.h>
#include <openvdb/points/PointCount.h>
#include <openvdb/points/PointMask.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/PointUtils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <houdini_utils/geometry.h>
#include <houdini_utils/ParmFactory.h>
#include <CH/CH_Manager.h> // for CHgetEvalTime
#include <GU/GU_DetailHandle.h>
#include <GU/GU_PackedContext.h>
#include <GU/GU_PackedGeometry.h>
#include <GU/GU_PackedFragment.h>
#include <GU/GU_PrimPacked.h>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
using namespace openvdb;
using namespace openvdb::points;
using namespace openvdb::math;
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace {
enum TRANSFORM_MODE {
TRANSFORM_TARGET_POINTS = 0,
TRANSFORM_VOXEL_SIZE,
TRANSFORM_REF_GRID
};
enum CONVERSION_MODE {
MODE_CONVERT_TO_VDB = 0,
MODE_CONVERT_FROM_VDB,
MODE_GENERATE_MASK,
MODE_COUNT_POINTS,
};
enum OUTPUT_NAME_MODE {
NAME_KEEP = 0,
NAME_APPEND,
NAME_REPLACE
};
} // anonymous namespace
////////////////////////////////////////
class SOP_OpenVDB_Points_Convert: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Points_Convert(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Points_Convert() override = default;
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i == 1); }
static OUTPUT_NAME_MODE getOutputNameMode(const std::string& modeName);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
};
////////////////////////////////////////
namespace {
inline int
lookupAttrInput(const PRM_SpareData* spare)
{
const char *istring;
if (!spare) return 0;
istring = spare->getValue("sop_input");
return istring ? atoi(istring) : 0;
}
inline void
sopBuildAttrMenu(void* data, PRM_Name* menuEntries, int themenusize,
const PRM_SpareData* spare, const PRM_Parm*)
{
if (data == nullptr || menuEntries == nullptr || spare == nullptr) return;
SOP_Node* sop = CAST_SOPNODE(static_cast<OP_Node*>(data));
if (sop == nullptr) {
// terminate and quit
menuEntries[0].setToken(0);
menuEntries[0].setLabel(0);
return;
}
int inputIndex = lookupAttrInput(spare);
const GU_Detail* gdp = sop->getInputLastGeo(inputIndex, CHgetEvalTime());
size_t menuIdx = 0, menuEnd(themenusize - 2);
// null object
menuEntries[menuIdx].setToken("0");
menuEntries[menuIdx++].setLabel("- no attribute selected -");
if (gdp) {
// point attribute names
auto iter = gdp->pointAttribs().begin(GA_SCOPE_PUBLIC);
if (!iter.atEnd() && menuIdx != menuEnd) {
if (menuIdx > 0) {
menuEntries[menuIdx].setToken(PRM_Name::mySeparator);
menuEntries[menuIdx++].setLabel(PRM_Name::mySeparator);
}
for (; !iter.atEnd() && menuIdx != menuEnd; ++iter) {
const char* str = (*iter)->getName();
if (str) {
Name name = str;
if (name != "P") {
menuEntries[menuIdx].setToken(name.c_str());
menuEntries[menuIdx++].setLabel(name.c_str());
}
}
}
}
}
// terminator
menuEntries[menuIdx].setToken(0);
menuEntries[menuIdx].setLabel(0);
}
const PRM_ChoiceList PrimAttrMenu(
PRM_ChoiceListType(PRM_CHOICELIST_REPLACE), sopBuildAttrMenu);
} // unnamed namespace
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
openvdb::initialize();
// Force the building of the unit vector codec as it isn't threadsafe.
const uint16_t data = 0;
auto SYS_UNUSED_VAR_ATTRIB ignoredResult = openvdb::math::QuantizedUnitVec::unpack(data);
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_ORD, "conversion", "Conversion")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"vdb", "Pack Points into VDB Points",
"hdk", "Extract Points from VDB Points",
"mask", "Generate Mask from VDB Points",
"count", "Points/Voxel Count from VDB Points"
})
.setTooltip("The conversion method for the expected input types.")
.setDocumentation(
"Whether to pack points into a VDB Points primitive"
" or to extract points from such a primitive or to generate"
" a mask from the primitive or to count the number of"
" points-per-voxel in the primitive"));
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenu)
.setTooltip("Specify a subset of the input point data grids to convert.")
.setDocumentation(
"A subset of the input VDB Points primitives to be processed"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "vdbpointsgroup", "VDB Points Group")
.setChoiceList(&hvdb::VDBPointsGroupMenuInput1)
.setTooltip("Specify VDB Points Groups to use as an input.")
.setDocumentation(
"The point group inside the VDB Points primitive to extract\n\n"
"This may be a normal point group that was collapsed into the"
" VDB Points primitive when it was created, or a new group created"
" with the [OpenVDB Points Group node|Node:sop/DW_OpenVDBPointsGroup]."));
// point grid name
parms.add(hutil::ParmFactory(PRM_STRING, "name", "VDB Name")
.setDefault("points")
.setTooltip("The name of the VDB Points primitive to be created")
.setDocumentation(nullptr));
// VDB points grid name
parms.add(hutil::ParmFactory(PRM_STRING, "outputname", "Output Name")
.setDefault("keep")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"keep", "Keep Original Name",
"append", "Add Suffix",
"replace", "Custom Name",
})
.setTooltip("Output VDB naming scheme")
.setDocumentation(
"Give the output VDB Points the same name as the input VDB,"
" or add a suffix to the input name, or use a custom name."));
parms.add(hutil::ParmFactory(PRM_STRING, "countname", "VDB Name")
.setDefault("count")
.setTooltip("The name of the VDB count primitive to be created")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_STRING, "maskname", "VDB Name")
.setDefault("mask")
.setTooltip("The name of the VDB mask primitive to be created")
.setDocumentation("The name of the VDB primitive to be created"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "keep", "Keep Original Geometry")
.setDefault(PRMzeroDefaults)
.setTooltip("The incoming geometry will not be deleted if this is set.")
.setDocumentation("The incoming geometry will not be deleted if this is set."));
// Transform
parms.add(hutil::ParmFactory(PRM_ORD, "transform", "Define Transform")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"targetpointspervoxel", "Using Target Points Per Voxel",
"voxelsizeonly", "Using Voxel Size Only",
"userefvdb", "To Match Reference VDB"
})
.setTooltip(
"Specify how to construct the PointDataGrid transform. If\n"
"an optional transform input is provided for the first two\n"
"options, the rotate and translate components are preserved.\n"
"Using Target Points Per Voxel:\n"
" Automatically calculates a voxel size based off the input\n"
" point set and a target amount of points per voxel.\n"
"Using Voxel Size Only:\n"
" Explicitly sets a voxel size.\n"
"To Match Reference VDB:\n"
" Uses the complete transform provided from the second input.")
.setDocumentation("\
How to construct the VDB Points primitive's transform\n\n\
An important consideration is how big to make the grid cells\n\
that contain the points. Too large and there are too many points\n\
per cell and little optimization occurs. Too small and the cost\n\
of the cells outweighs the points.\n\
\n\
Using Target Points Per Voxel:\n\
Automatically calculate a voxel size so that the given number\n\
of points ends up in each voxel. This will assume uniform\n\
distribution of points.\n\
\n\
If an optional transform input is provided, use its rotation\n\
and translation.\n\
Using Voxel Size Only:\n\
Provide an explicit voxel size, and if an optional transform input\n\
is provided, use its rotation and translation.\n\
To Match Reference VDB:\n\
Use the complete transform provided from the second input.\n"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxelsize", "Voxel Size")
.setDefault(PRMpointOneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 5)
.setTooltip("The desired voxel size of the new VDB Points grid"));
parms.add(hutil::ParmFactory(PRM_INT_J, "pointspervoxel", "Points per Voxel")
.setDefault(8)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 16)
.setTooltip(
"The number of points per voxel to use as the target for "
"automatic voxel size computation"));
// Group name (Transform reference)
parms.add(hutil::ParmFactory(PRM_STRING, "refvdb", "Reference VDB")
.setChoiceList(&hutil::PrimGroupMenu)
.setSpareData(&SOP_Node::theSecondInput)
.setTooltip("References the first/selected grid's transform.")
.setDocumentation(
"Which VDB in the second input to use as the reference for the transform\n\n"
"If this is not set, use the first VDB found."));
//////////
// Point attribute transfer
parms.add(hutil::ParmFactory(PRM_ORD, "poscompression", "Position Compression")
.setDefault(PRMoneDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"none", "None",
"int16", "16-bit Fixed Point",
"int8", "8-bit Fixed Point"
})
.setTooltip("The position attribute compression setting.")
.setDocumentation(
"The position can be stored relative to the center of the voxel.\n"
"This means it does not require the full 32-bit float representation,\n"
"but can be quantized to a smaller fixed-point value."));
parms.add(hutil::ParmFactory(PRM_HEADING, "transferheading", "Attribute Transfer"));
// Mode. Either convert all or convert specifc attributes
parms.add(hutil::ParmFactory(PRM_ORD, "mode", "Mode")
.setDefault(PRMzeroDefaults)
.setTooltip("Whether to transfer only specific attributes or all attributes found")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"all", "All Attributes",
"spec", "Specific Attributes"
}));
hutil::ParmList attrParms;
// Attribute name
attrParms.add(hutil::ParmFactory(PRM_STRING, "attribute#", "Attribute")
.setChoiceList(&PrimAttrMenu)
.setSpareData(&SOP_Node::theFirstInput)
.setTooltip("Select a point attribute to transfer.\n\n"
"Supports integer and floating-point attributes of "
"arbitrary precisions and tuple sizes."));
{
char const * const items[] = {
"none", "None",
"truncate", "16-bit Truncate",
UnitVecCodec::name(), "Unit Vector",
FixedPointCodec<true, UnitRange>::name(), "8-bit Unit",
FixedPointCodec<false, UnitRange>::name(), "16-bit Unit",
nullptr
};
attrParms.add(hutil::ParmFactory(PRM_ORD, "valuecompression#", "Value Compression")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip("Value compression to use for specific attributes.")
.setDocumentation("\
How to compress attribute values\n\
\n\
None:\n\
Values are stored with their full precision.\n\
\n\
16-bit Truncate:\n\
Values are stored at half precision, truncating lower-order bits.\n\
\n\
Unit Vector:\n\
Values are treated as unit vectors, so that if two components\n\
are known, the third is implied and need not be stored.\n\
\n\
8-bit Unit:\n\
Values are treated as lying in the 0..1 range and are quantized to 8 bits.\n\
\n\
16-bit Unit:\n\
Values are treated as lying in the 0..1 range and are quantized to 16 bits.\n"));
}
attrParms.add(hutil::ParmFactory(PRM_TOGGLE, "blosccompression#", "Blosc Compression")
.setInvisible() // this parm is now a no-op as in-memory blosc compression is deprecated
.setDefault(PRMzeroDefaults));
// Add multi parm
parms.add(hutil::ParmFactory(PRM_MULTITYPE_LIST, "attrList", "Point Attributes")
.setTooltip("Transfer point attributes to each voxel in the level set's narrow band")
.setMultiparms(attrParms)
.setDefault(PRMzeroDefaults));
parms.add(hutil::ParmFactory(PRM_LABEL, "attributespacer", ""));
{
char const * const items[] = {
"none", "None",
UnitVecCodec::name(), "Unit Vector",
"truncate", "16-bit Truncate",
nullptr
};
parms.add(hutil::ParmFactory(PRM_ORD, "normalcompression", "Normal Compression")
.setDefault(PRMzeroDefaults)
.setTooltip("All normal attributes will use this compression codec.")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items));
}
{
char const * const items[] = {
"none", "None",
FixedPointCodec<false, UnitRange>::name(), "16-bit Unit",
FixedPointCodec<true, UnitRange>::name(), "8-bit Unit",
"truncate", "16-bit Truncate",
nullptr
};
parms.add(hutil::ParmFactory(PRM_ORD, "colorcompression", "Color Compression")
.setDefault(PRMzeroDefaults)
.setTooltip("All color attributes will use this compression codec.")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items));
}
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "transferHeading", "Attribute Transfer"));
//////////
// Register this operator.
hvdb::OpenVDBOpFactory("Convert VDB Points",
SOP_OpenVDB_Points_Convert::factory, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBPointsConvert")
#endif
.addInput("Points to Convert")
.addOptionalInput("Optional Reference VDB (for transform)")
.setObsoleteParms(obsoleteParms)
.setVerb(SOP_NodeVerb::COOK_GENERIC,
[]() { return new SOP_OpenVDB_Points_Convert::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Convert a point cloud into a VDB Points primitive, or vice versa.\"\"\"\n\
\n\
@overview\n\
\n\
This node converts an unstructured cloud of points to and from a single\n\
[VDB Points|http://www.openvdb.org/documentation/doxygen/points.html] primitive.\n\
The resulting primitive will reorder the points to place spatially\n\
close points close together.\n\
It is then able to efficiently unpack regions of interest within that primitive.\n\
The [OpenVDB Points Group node|Node:sop/DW_OpenVDBPointsGroup] can be used\n\
to create regions of interest.\n\
\n\
Because nearby points often have similar data, there is the possibility\n\
of aggressively compressing attribute data to minimize data size.\n\
\n\
@related\n\
- [OpenVDB Points Group|Node:sop/DW_OpenVDBPointsGroup]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Points_Convert::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Points_Convert(net, name, op);
}
SOP_OpenVDB_Points_Convert::SOP_OpenVDB_Points_Convert(OP_Network* net,
const char* name, OP_Operator* op)
: hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
// Enable or disable parameters in the UI.
bool
SOP_OpenVDB_Points_Convert::updateParmsFlags()
{
bool changed = false;
const bool toVdbPoints = evalInt("conversion", 0, 0) == 0;
const bool toMask = evalInt("conversion", 0, 0) == 2;
const bool toCount = evalInt("conversion", 0, 0) == 3;
const bool convertAll = evalInt("mode", 0, 0) == 0;
const auto transform = evalInt("transform", 0, 0);
changed |= enableParm("group", !toVdbPoints);
changed |= setVisibleState("group", !toVdbPoints);
changed |= enableParm("vdbpointsgroup", !toVdbPoints);
changed |= setVisibleState("vdbpointsgroup", !toVdbPoints);
changed |= enableParm("name", toVdbPoints);
changed |= setVisibleState("name", toVdbPoints);
changed |= enableParm("outputname", toCount || toMask);
changed |= setVisibleState("outputname", toCount || toMask);
const bool useCustomName =
(getOutputNameMode(evalStdString("outputname", 0.0)) != NAME_KEEP);
changed |= enableParm("countname", useCustomName && toCount);
changed |= setVisibleState("countname", toCount);
changed |= enableParm("maskname", useCustomName && toMask);
changed |= setVisibleState("maskname", toMask);
changed |= enableParm("keep", !toVdbPoints);
changed |= setVisibleState("keep", !toVdbPoints);
const int refexists = (this->nInputs() == 2);
changed |= enableParm("transform", toVdbPoints);
changed |= setVisibleState("transform", toVdbPoints);
changed |= enableParm("refvdb", refexists);
changed |= setVisibleState("refvdb", toVdbPoints);
changed |= enableParm("voxelsize", toVdbPoints && transform == TRANSFORM_VOXEL_SIZE);
changed |= setVisibleState("voxelsize", toVdbPoints && transform == TRANSFORM_VOXEL_SIZE);
changed |= enableParm("pointspervoxel", toVdbPoints && transform == TRANSFORM_TARGET_POINTS);
changed |= setVisibleState("pointspervoxel",
toVdbPoints && transform == TRANSFORM_TARGET_POINTS);
changed |= setVisibleState("transferheading", toVdbPoints);
changed |= enableParm("poscompression", toVdbPoints);
changed |= setVisibleState("poscompression", toVdbPoints);
changed |= enableParm("mode", toVdbPoints);
changed |= setVisibleState("mode", toVdbPoints);
changed |= enableParm("attrList", toVdbPoints && !convertAll);
changed |= setVisibleState("attrList", toVdbPoints && !convertAll);
changed |= enableParm("normalcompression", toVdbPoints && convertAll);
changed |= setVisibleState("normalcompression", toVdbPoints && convertAll);
changed |= enableParm("colorcompression", toVdbPoints && convertAll);
changed |= setVisibleState("colorcompression", toVdbPoints && convertAll);
return changed;
}
////////////////////////////////////////
OUTPUT_NAME_MODE
SOP_OpenVDB_Points_Convert::getOutputNameMode(const std::string& modeName)
{
if (modeName == "append") return NAME_APPEND;
if (modeName == "replace") return NAME_REPLACE;
return NAME_KEEP;
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Points_Convert::Cache::cookVDBSop(OP_Context& context)
{
try {
hvdb::Interrupter boss{"Converting points"};
hvdb::WarnFunc warnFunction = [this](const std::string& msg) {
this->addWarning(SOP_MESSAGE, msg.c_str());
};
const fpreal time = context.getTime();
const int conversion = static_cast<int>(evalInt("conversion", 0, time));
const bool keepOriginalGeo = evalInt("keep", 0, time) == 1;
const GA_PrimitiveGroup* group = (conversion != MODE_CONVERT_TO_VDB) ?
matchGroup(*inputGeo(0), evalStdString("group", time)) : nullptr;
// Extract VDB Point groups to filter
const std::string pointsGroup = evalStdString("vdbpointsgroup", time);
std::vector<std::string> includeGroups;
std::vector<std::string> excludeGroups;
if (conversion != MODE_CONVERT_TO_VDB) {
openvdb::points::AttributeSet::Descriptor::parseNames(
includeGroups, excludeGroups, pointsGroup);
}
// Optionally copy transform parameters from reference grid (if not converting from VDB).
Transform::Ptr transform;
if (conversion != MODE_CONVERT_FROM_VDB) {
if (const GU_Detail* refGeo = inputGeo(1, context)) {
const GA_PrimitiveGroup* refGroup =
matchGroup(*refGeo, evalStdString("refvdb", time));
hvdb::VdbPrimCIterator it(refGeo, refGroup);
const hvdb::GU_PrimVDB* refPrim = *it;
if (!refPrim) {
addError(SOP_MESSAGE, "Second input has no VDB primitives.");
return error();
}
transform = refPrim->getGrid().transform().copy();
}
}
// handle to VDB, count and mask conversion options
if (conversion != MODE_CONVERT_TO_VDB) {
UT_Array<GEO_Primitive*> primsToDelete;
primsToDelete.clear();
if (keepOriginalGeo) {
// Duplicate primary (left) input geometry
if (const auto* input0 = inputGeo(0)) {
gdp->replaceWith(*input0);
} else {
gdp->stashAll();
}
// Extract VDB primitives to delete
for (hvdb::VdbPrimIterator vdbIt(gdp, group); vdbIt; ++vdbIt) {
openvdb::GridBase::ConstPtr gridBase = vdbIt->getConstGridPtr();
PointDataGrid::ConstPtr points =
openvdb::GridBase::constGrid<PointDataGrid>(gridBase);
if (!points) continue;
primsToDelete.append(*vdbIt);
}
} else {
gdp->stashAll();
}
// Extract point grids and names for conversion
std::vector<PointDataGrid::ConstPtr> pointGrids;
std::vector<std::string> pointNames;
const GU_Detail* sourceGdp = keepOriginalGeo ? gdp : inputGeo(0, context);
for (hvdb::VdbPrimCIterator vdbIt(sourceGdp, group); vdbIt; ++vdbIt) {
openvdb::GridBase::ConstPtr gridBase = vdbIt->getConstGridPtr();
PointDataGrid::ConstPtr points =
openvdb::GridBase::constGrid<PointDataGrid>(gridBase);
if (!points) continue;
pointGrids.push_back(points);
if (conversion != MODE_CONVERT_FROM_VDB) {
const std::string gridName = vdbIt.getPrimitiveName().toStdString();
pointNames.push_back(gridName);
}
}
if (keepOriginalGeo) {
gdp->deletePrimitives(primsToDelete, true);
}
if (conversion == MODE_CONVERT_FROM_VDB) {
// passing an empty vector of attribute names implies that
// all attributes should be converted
const std::vector<std::string> emptyNameVector;
// if all point data is being converted, sequentially pre-fetch any out-of-core
// data for faster performance when using delayed-loading
const bool allData = emptyNameVector.empty() &&
includeGroups.empty() &&
excludeGroups.empty();
for (const PointDataGrid::ConstPtr &grid : pointGrids) {
GU_Detail geo;
// if all the data is being loaded, prefetch it for faster load performance
if (allData) {
prefetch(grid->tree());
}
// perform conversion
hvdb::convertPointDataGridToHoudini(
geo, *grid, emptyNameVector, includeGroups, excludeGroups);
const MetaMap& metaMap = *grid;
hvdb::convertMetadataToHoudini(geo, metaMap, warnFunction);
gdp->merge(geo);
}
return error();
}
else {
const auto outputName = getOutputNameMode(evalStdString("outputname", time));
size_t i = 0;
for (const PointDataGrid::ConstPtr &grid : pointGrids) {
assert(i < pointNames.size());
const std::string gridName = pointNames[i++];
GU_Detail geo;
if (conversion == MODE_GENERATE_MASK) {
openvdb::BoolGrid::Ptr maskGrid;
auto leaf = grid->tree().cbeginLeaf();
if (leaf) {
MultiGroupFilter filter(includeGroups, excludeGroups, leaf->attributeSet());
if (transform) {
maskGrid = openvdb::points::convertPointsToMask(
*grid, *transform, filter);
}
else {
maskGrid = openvdb::points::convertPointsToMask(
*grid, filter);
}
} else {
maskGrid = openvdb::BoolGrid::create();
}
const std::string customName = evalStdString("maskname", time);
std::string vdbName;
switch (outputName) {
case NAME_KEEP: vdbName = gridName; break;
case NAME_APPEND: vdbName = gridName + customName; break;
case NAME_REPLACE: vdbName = customName; break;
}
hvdb::createVdbPrimitive(*gdp, maskGrid, vdbName.c_str());
}
else {
openvdb::Int32Grid::Ptr countGrid;
auto leaf = grid->tree().cbeginLeaf();
if (leaf) {
MultiGroupFilter filter(includeGroups, excludeGroups, leaf->attributeSet());
if (transform) {
countGrid = openvdb::points::pointCountGrid(
*grid, *transform, filter);
}
else {
countGrid = openvdb::points::pointCountGrid(
*grid, filter);
}
}
else {
countGrid = openvdb::Int32Grid::create();
}
const std::string customName = evalStdString("maskname", time);
std::string vdbName;
switch (outputName) {
case NAME_KEEP: vdbName = gridName; break;
case NAME_APPEND: vdbName = gridName + customName; break;
case NAME_REPLACE: vdbName = customName; break;
}
hvdb::createVdbPrimitive(*gdp, countGrid, vdbName.c_str());
}
}
return error();
}
}
// if we're here, we're converting Houdini points to OpenVDB. Clear gdp entirely
// before proceeding, then check for particles in the primary (left) input port
gdp->clearAndDestroy();
const GU_Detail* ptGeo = inputGeo(0, context);
GU_Detail nonConstDetail; // tmp storage of unpacked geo
const GU_Detail* detail; // ptr to geo to convert; either ptGeo or nonConstDetail
boss.start();
// Unpack any packed primitives
std::unique_ptr<GA_PrimitiveGroup> packgroup(ptGeo->newDetachedPrimitiveGroup());
for (GA_Iterator it(ptGeo->getPrimitiveRange()); !it.atEnd(); ++it) {
GA_Offset offset = *it;
const GA_Primitive* primitive = ptGeo->getPrimitive(offset);
if (!primitive || !GU_PrimPacked::isPackedPrimitive(*primitive)) continue;
const GU_PrimPacked* packedPrimitive = static_cast<const GU_PrimPacked*>(primitive);
packedPrimitive->unpack(nonConstDetail);
packgroup->addOffset(offset);
}
if (packgroup->entries() == 0) {
// If no packed geometry was converted, avoid the merge by
// simply using the original geometry
detail = ptGeo;
}
else {
// Convert the prim group to points - we have to use mergePoints
// instead of mergePrims to make sure we merge points that are not
// associated with any primitive
GA_PointGroup pointsWithPackedPrims(*ptGeo);
pointsWithPackedPrims.combine(packgroup.get());
// Merge everything except the geo associated with prims we've just unpacked
nonConstDetail.mergePoints(*ptGeo, GA_Range(pointsWithPackedPrims, /*invert*/true));
detail = &nonConstDetail;
}
packgroup.reset();
// Configure the transform
const auto transformMode = evalInt("transform", 0, time);
math::Mat4d matrix(math::Mat4d::identity());
if (transform && transformMode != TRANSFORM_REF_GRID) {
const math::AffineMap::ConstPtr affineMap = transform->baseMap()->getAffineMap();
matrix = affineMap->getMat4();
}
else if (!transform && transformMode == TRANSFORM_REF_GRID) {
addError(SOP_MESSAGE, "No target VDB transform found on second input.");
return error();
}
if (transformMode == TRANSFORM_TARGET_POINTS) {
const int pointsPerVoxel = static_cast<int>(evalInt("pointspervoxel", 0, time));
const float voxelSize =
hvdb::computeVoxelSizeFromHoudini(*detail, pointsPerVoxel,
matrix, /*rounding*/ 5, boss);
matrix.preScale(Vec3d(voxelSize) / math::getScale(matrix));
transform = Transform::createLinearTransform(matrix);
} else if (transformMode == TRANSFORM_VOXEL_SIZE) {
const auto voxelSize = evalFloat("voxelsize", 0, time);
matrix.preScale(Vec3d(voxelSize) / math::getScale(matrix));
transform = Transform::createLinearTransform(matrix);
}
// Convert
UT_String attrName;
openvdb_houdini::AttributeInfoMap attributes;
if (evalInt("mode", 0, time) != 0) {
// Transfer point attributes.
if (evalInt("attrList", 0, time) > 0) {
for (int i = 1, N = static_cast<int>(evalInt("attrList", 0, 0)); i <= N; ++i) {
evalStringInst("attribute#", &i, attrName, 0, 0);
const Name attributeName = Name(attrName);
const GA_ROAttributeRef attrRef =
detail->findPointAttribute(attributeName.c_str());
if (!attrRef.isValid()) continue;
const GA_Attribute* const attribute = attrRef.getAttribute();
if (!attribute) continue;
const GA_Storage storage(hvdb::attributeStorageType(attribute));
// only tuple and string tuple attributes are supported
if (storage == GA_STORE_INVALID) {
throw std::runtime_error{"Invalid attribute type - " + attributeName};
}
const int16_t width(hvdb::attributeTupleSize(attribute));
assert(width > 0);
const GA_TypeInfo typeInfo(attribute->getOptions().typeInfo());
const bool isVector = width == 3 && (typeInfo == GA_TYPE_VECTOR ||
typeInfo == GA_TYPE_NORMAL ||
typeInfo == GA_TYPE_COLOR);
const bool isQuaternion = width == 4 && (typeInfo == GA_TYPE_QUATERNION);
const bool isMatrix = width == 16 && (typeInfo == GA_TYPE_TRANSFORM);
int valueCompression = static_cast<int>(
evalIntInst("valuecompression#", &i, 0, 0));
// check value compression compatibility with attribute type
if (valueCompression != hvdb::COMPRESSION_NONE) {
if (storage == GA_STORE_STRING) {
// disable value compression for strings and add a SOP warning
valueCompression = hvdb::COMPRESSION_NONE;
warnFunction("Value compression not supported on string attributes."
" Disabling compression for attribute \""
+ attributeName + "\".");
} else {
// disable value compression for incompatible types
// and add a SOP warning
if (valueCompression == hvdb::COMPRESSION_TRUNCATE &&
(storage != GA_STORE_REAL32 || isQuaternion || isMatrix))
{
valueCompression = hvdb::COMPRESSION_NONE;
warnFunction("Truncate value compression only supported for 32-bit"
" floating-point attributes. Disabling compression for"
" attribute \"" + attributeName + "\".");
}
if (valueCompression == hvdb::COMPRESSION_UNIT_VECTOR &&
(storage != GA_STORE_REAL32 || !isVector))
{
valueCompression = hvdb::COMPRESSION_NONE;
warnFunction("Unit Vector value compression only supported for"
" vector 3 x 32-bit floating-point attributes. "
"Disabling compression for attribute \""
+ attributeName + "\".");
}
const bool isUnit =
(valueCompression == hvdb::COMPRESSION_UNIT_FIXED_POINT_8
|| valueCompression == hvdb::COMPRESSION_UNIT_FIXED_POINT_16);
if (isUnit && (storage != GA_STORE_REAL32 || (width != 1 && !isVector)))
{
valueCompression = hvdb::COMPRESSION_NONE;
warnFunction("Unit compression only supported for scalar and vector"
" 3 x 32-bit floating-point attributes. "
"Disabling compression for attribute \""
+ attributeName + "\".");
}
}
}
attributes[attributeName] = std::pair<int, bool>(valueCompression, false);
}
}
} else {
// point attribute names
auto iter = detail->pointAttribs().begin(GA_SCOPE_PUBLIC);
const auto normalCompression = evalInt("normalcompression", 0, time);
const auto colorCompression = evalInt("colorcompression", 0, time);
if (!iter.atEnd()) {
for (; !iter.atEnd(); ++iter) {
const char* str = (*iter)->getName();
if (!str) continue;
const Name attributeName = str;
if (attributeName == "P") continue;
const GA_ROAttributeRef attrRef =
detail->findPointAttribute(attributeName.c_str());
if (!attrRef.isValid()) continue;
const GA_Attribute* const attribute = attrRef.getAttribute();
if (!attribute) continue;
const GA_Storage storage(hvdb::attributeStorageType(attribute));
// only tuple and string tuple attributes are supported
if (storage == GA_STORE_INVALID) {
throw std::runtime_error{"Invalid attribute type - " + attributeName};
}
const int16_t width(hvdb::attributeTupleSize(attribute));
assert(width > 0);
const GA_TypeInfo typeInfo(attribute->getOptions().typeInfo());
const bool isNormal = width == 3 && typeInfo == GA_TYPE_NORMAL;
const bool isColor = width == 3 && typeInfo == GA_TYPE_COLOR;
int valueCompression = hvdb::COMPRESSION_NONE;
if (isNormal) {
if (normalCompression == 1) {
valueCompression = hvdb::COMPRESSION_UNIT_VECTOR;
} else if (normalCompression == 2) {
valueCompression = hvdb::COMPRESSION_TRUNCATE;
}
}
else if (isColor) {
if (colorCompression == 1) {
valueCompression = hvdb::COMPRESSION_UNIT_FIXED_POINT_16;
} else if (colorCompression == 2) {
valueCompression = hvdb::COMPRESSION_UNIT_FIXED_POINT_8;
} else if (colorCompression == 3) {
valueCompression = hvdb::COMPRESSION_TRUNCATE;
}
}
attributes[attributeName] = std::pair<int, bool>(valueCompression, false);
}
}
}
// Determine position compression
const int positionCompression = static_cast<int>(evalInt("poscompression", 0, time));
PointDataGrid::Ptr pointDataGrid = hvdb::convertHoudiniToPointDataGrid(
*detail, positionCompression, attributes, *transform, warnFunction);
hvdb::populateMetadataFromHoudini(*pointDataGrid, *detail, warnFunction);
hvdb::createVdbPrimitive(*gdp, pointDataGrid, evalStdString("name", time).c_str());
boss.end();
} catch (const std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 39,596 | C++ | 36.891866 | 104 | 0.570613 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Potential_Flow.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file SOP_OpenVDB_Potential_Flow.cc
///
/// @authors Todd Keeler, Dan Bailey
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/Types.h>
#include <openvdb/tools/PotentialFlow.h>
#include <openvdb/tools/TopologyToLevelSet.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_Version.h>
#include <GU/GU_Detail.h>
#include <PRM/PRM_Parm.h>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <sstream>
#include <stdexcept>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace {
const int DEFAULT_MAX_ITERATIONS = 10000;
const double DEFAULT_MAX_ERROR = 1.0e-20;
}
// SOP Implementation
struct SOP_OpenVDB_Potential_Flow: public hvdb::SOP_NodeVDB
{
SOP_OpenVDB_Potential_Flow(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i == 1); }
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
}; // SOP_OpenVDB_Potential_Flow
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setHelpText("Specify grids to process")
.setChoiceList(&hutil::PrimGroupMenuInput1));
parms.add(hutil::ParmFactory(PRM_STRING, "velocity", "Velocity VDB")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip(
"Name of the reference VDB volume whose active voxels denote solid obstacles\n\n"
"If multiple volumes are selected, only the first one will be used."));
parms.add(hutil::ParmFactory(PRM_STRING, "maskvdbname", "Mask VDB")
.setHelpText("VDB (from the second input) used to modify the solution domain.")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setDocumentation(
"A VDB from the second input used to modify the volume where the potential flow"
" will be solved. The domain can either be restricted to the VDB input, or excluded"
" from expanding in the VDB input."));
parms.add(hutil::ParmFactory(PRM_ORD, "masktype", "Domain Mask Type")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"intersection", "Intersection",
"difference", "Difference"
})
.setTooltip("Mode for applying the domain modification mask (second input)")
.setDocumentation("Modify the constructed domain using the second input VDB mask for"
" calculating the potential flow velocity. __Intersection__ causes the created"
" domain to be restricted to the Mask's active topology. __Difference__ removes"
" any overlap between the constructed domain and the topology. The domain geometry"
" will likely change the results"));
parms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep1", ""));
{
std::ostringstream ostr;
ostr << "If disabled, limit the potential flow solver to "
<< DEFAULT_MAX_ITERATIONS << " iterations.";
const std::string tooltip = ostr.str();
parms.add(hutil::ParmFactory(PRM_TOGGLE, "useiterations", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip(tooltip.c_str()));
parms.add(hutil::ParmFactory(PRM_INT_J, "iterations", "Iterations")
.setDefault(1000)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 2000)
.setTooltip("Maximum number of iterations of the potential flow solver")
.setDocumentation(
("Maximum number of iterations of the potential flow solver\n\n" + tooltip).c_str()));
}
{
std::ostringstream ostr;
ostr << "If disabled, limit the potential flow solver error to "
<< std::setprecision(3) << DEFAULT_MAX_ERROR << ".";
const std::string tooltip = ostr.str();
parms.add(hutil::ParmFactory(PRM_TOGGLE, "usetolerance", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip(tooltip.c_str()));
ostr.str("");
ostr << "If disabled, limit the potential flow solver error to 10<sup>"
<< int(std::log10(DEFAULT_MAX_ERROR)) << "</sup>.";
parms.add(hutil::ParmFactory(PRM_FLT_J, "tolerance", "Tolerance")
.setDefault(openvdb::math::Delta<float>::value())
.setRange(PRM_RANGE_RESTRICTED, DEFAULT_MAX_ERROR, PRM_RANGE_UI, 1)
.setTooltip(
"The potential flow solver is deemed to have converged when\n"
"the magnitude of the absolute error is less than this tolerance.")
.setDocumentation(
("The potential flow solver is deemed to have converged when"
" the magnitude of the absolute error is less than this tolerance.\n\n"
+ ostr.str()).c_str()));
}
// Toggle between world- and index-space units for offset
parms.add(hutil::ParmFactory(PRM_TOGGLE, "useworldspace", "Use World Space Units")
.setDefault(PRMzeroDefaults)
.setTooltip("If enabled, use world-space units, otherwise use voxels."));
// Stencil width
parms.add(hutil::ParmFactory(PRM_INT_J, "dilationvoxels", "Dilation Voxels")
.setDefault(PRMtenDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 100)
.setTooltip(
" The number of voxels to dilate the incoming geometry to create the domain"
" in which the potential flow will be computed")
.setDocumentation(
" The number of voxels to dilate the incoming geometry to create the domain"
" in which the potential flow will be computed"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "dilation", "Dilation")
.setDefault(1.0)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 100)
.setTooltip(
" The distance in world space units to dilate the incoming geometry to create"
" the domain in which the potential flow will be computed")
.setDocumentation(
" The distance in world space units to dilate the incoming geometry to create"
" the domain in which the potential flow will be computed"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "usebackgroundvelocity", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("If enabled, a background velocity will be applied regardless of any velocity"
" VDBs that are also provided. This can be used to create a similar effect"
" to an object in a wind tunnel."));
std::vector<fpreal> backgrounddefault{1,0,0};
parms.add(hutil::ParmFactory(PRM_XYZ_J, "backgroundvelocity", "Background Velocity")
.setVectorSize(3)
.setDefault(backgrounddefault)
.setTooltip("A constant background fluid velocity"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "applybackgroundvelocity",
"Apply Background Velocity to Flow Field")
.setDefault(PRMoneDefaults)
.setTooltip("If enabled, apply the background velocity to the resulting flow field."
" This can be useful for a simulation where particles are simply advected through a"
" passive velocity field. In disabling this, a similar result can be achieved by"
" sampling the velocity and adding to an existing velocity point attribute"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "outputpotential", "Output Potential")
.setDefault(PRMzeroDefaults)
.setTooltip("Output the scalar potential"));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Potential Flow",
SOP_OpenVDB_Potential_Flow::factory, parms, *table)
#if UT_VERSION_INT < 0x11050000 // earlier than 17.5.0
.setNativeName("")
#endif
.addInput("VDB Surface and optional velocity VDB")
.addOptionalInput("Optional VDB Mask")
.setVerb(SOP_NodeVerb::COOK_INPLACE,
[]() { return new SOP_OpenVDB_Potential_Flow::Cache; })
.setDocumentation(
"#icon: COMMON/openvdb\n"
"#tags: vdb\n"
"\n"
"\"\"\"Generate Potential Flow VDB velocity field. \"\"\"\n"
"\n"
"@overview\n"
"\n"
" Potential flow is the non-rotational flow of a fluid around solid moving or deforming"
" objects constructed only from velocity values on their surface."
" This flow field is not time-dependent and does not require an input fluid flow from the"
" previous frame."
" With the combination of procedural curl noise, this operator can construct fluid"
" flows around obstacles without simulation dependencies, and therefore allows frames to "
" be computed in parallel."
" The potential flow field is generally used to create a flow field that cancels out movement"
" of fluid into or out of a solid object."
" A constant surface velocity is given as a parameter to the node, and an additional variable"
" surface velocity can also be defined via a velocity VDB added to the first input."
" When both are defined, they are added together on the surface boundary."
" For objects in three dimensions, the potential flow decays at greater distances to the"
" boundary.\n\n"
" The node automatically creates the domain of the flow field by dilating the initial solid"
" object boundaries."
" It is up to the user to determine the dilation extent and therefore velocity decay needed"
" for their application."
" The primary input is a VDB signed distance field (SDF) on the first input."
" The resolution and grid transform for the new velocity field will be taken from the input"
" SDF."
" If there are multiple SDFs only the first one is used, it is recommended to sample multiple"
" SDFs into a single one for multiple obstacles."
" This SDF can be accompanied by a VDB velocity field which will be used to impart the SDF"
" velocity into the solver."
" The potential flow created is divergence free by design and has the same velocity on the"
" boundary as the background velocity.\n\n"
" The simplest workflow for multiple moving objects is to animate the polygonal geometry and"
" then create SDFs and velocity VDBs by using the VDB from Polygons node."
" The output can be fed directly into the first input of the Potential Flow SOP."
" The second input of the SOP allows a Mask VDB input for modifiying the solution domain"
" created by the Potential Flow SOP."
" The created domain can either be restricted to the active voxels of the Mask VDB, or"
" restricted from creating a domain inside the active voxels."
" These modes are defined by the respective __Intersection__ or __Difference__ modes on the"
" parameter toggle"
);
}
// Enable or disable parameters in the UI.
bool
SOP_OpenVDB_Potential_Flow::updateParmsFlags()
{
bool changed = false;
const bool worldUnits = bool(evalInt("useworldspace", 0, 0));
changed |= enableParm("dilationvoxels", !worldUnits);
changed |= setVisibleState("dilationvoxels", !worldUnits);
changed |= enableParm("dilation", worldUnits);
changed |= setVisibleState("dilation", worldUnits);
const bool hasMask = (2 == nInputs());
changed |= enableParm("maskvdbname", hasMask);
changed |= enableParm("masktype", hasMask);
changed |= enableParm("iterations", bool(evalInt("useiterations", 0, 0)));
changed |= enableParm("tolerance", bool(evalInt("usetolerance", 0, 0)));
changed |= enableParm("backgroundvelocity", bool(evalInt("usebackgroundvelocity", 0, 0)));
changed |= enableParm("applybackgroundvelocity", bool(evalInt("usebackgroundvelocity", 0, 0)));
return changed;
}
OP_Node*
SOP_OpenVDB_Potential_Flow::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Potential_Flow(net, name, op);
}
SOP_OpenVDB_Potential_Flow::SOP_OpenVDB_Potential_Flow(
OP_Network* net, const char* name, OP_Operator* op)
: hvdb::SOP_NodeVDB(net, name, op)
{
}
namespace {
struct MaskOp
{
template<typename GridType>
void operator()(const GridType& grid) { mMaskGrid = openvdb::tools::interiorMask(grid); }
openvdb::BoolGrid::Ptr mMaskGrid;
};
struct MaskToLevelSetOp
{
template<typename GridType>
void operator()(const GridType& grid) { mSdfGrid = openvdb::tools::topologyToLevelSet(grid); }
openvdb::FloatGrid::Ptr mSdfGrid;
};
template <typename VelGridT, typename MaskGridT>
struct PotentialFlowOp
{
using GridT = typename VelGridT::template ValueConverter<typename
VelGridT::ValueType::value_type>::Type;
using VecT = typename VelGridT::ValueType;
using ScalarT = typename GridT::ValueType;
PotentialFlowOp(const openvdb::FloatGrid& solidBoundary,
const MaskGridT& domain,
const typename VelGridT::ConstPtr& boundaryVelocity,
const VecT& backgroundVelocity,
const bool applyBackgroundVelocity)
: mSolidBoundary(solidBoundary)
, mDomain(domain)
, mBoundaryVelocity(boundaryVelocity)
, mBackgroundVelocity(backgroundVelocity)
, mApplyBackgroundVelocity(applyBackgroundVelocity) { }
openvdb::math::pcg::State
process(int iterations, float absoluteError) {
using namespace openvdb;
typename VelGridT::Ptr neumann = tools::createPotentialFlowNeumannVelocities(
mSolidBoundary, mDomain, mBoundaryVelocity, mBackgroundVelocity);
// create solver state
math::pcg::State state = math::pcg::terminationDefaults<ScalarT>();
state.iterations = iterations;
state.absoluteError = absoluteError;
state.relativeError = 0.0;
potential = tools::computeScalarPotential(mDomain, *neumann, state);
if (mApplyBackgroundVelocity) {
flowvel = tools::computePotentialFlow(*potential, *neumann, mBackgroundVelocity);
} else {
flowvel = tools::computePotentialFlow(*potential, *neumann);
}
return state;
}
typename VelGridT::Ptr flowvel;
typename GridT::Ptr potential;
private:
const openvdb::FloatGrid& mSolidBoundary;
const MaskGridT& mDomain;
const typename VelGridT::ConstPtr mBoundaryVelocity;
const VecT mBackgroundVelocity;
const bool mApplyBackgroundVelocity;
}; // struct PotentialFlowOp
} // unnamed namespace
OP_ERROR
SOP_OpenVDB_Potential_Flow::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
hvdb::Interrupter boss("Computing Potential Flow");
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
const std::string velocity = evalStdString("velocity", time);
const GA_PrimitiveGroup* velocityGroup = matchGroup(*gdp, velocity);
// SOP currently only supports float level sets
using SdfGridT = openvdb::FloatGrid;
using MaskGridT = openvdb::BoolGrid;
typename SdfGridT::ConstPtr grid;
const GU_PrimVDB * velGridPrim(nullptr);
hvdb::VdbPrimCIterator vdbIt(gdp, group);
// find the first level set
for (; vdbIt; ++vdbIt) {
if (boss.wasInterrupted()) break;
const openvdb::GridClass gridClass = vdbIt->getGrid().getGridClass();
if (!grid && vdbIt->getStorageType() == UT_VDB_FLOAT
&& gridClass == openvdb::GRID_LEVEL_SET) {
grid = openvdb::gridConstPtrCast<SdfGridT>(vdbIt->getGridPtr());
}
}
// find a vec3 grid for velocity
if (!velocity.empty()) {
hvdb::VdbPrimCIterator velocityIt(gdp, velocityGroup);
for (; velocityIt; ++velocityIt) {
if (!velGridPrim && (velocityIt->getStorageType() == UT_VDB_VEC3F ||
velocityIt->getStorageType() == UT_VDB_VEC3D)) {
velGridPrim = *velocityIt;
}
}
}
else {
hvdb::VdbPrimCIterator velocityIt(gdp);
for (; velocityIt; ++velocityIt) {
if (!velGridPrim && (velocityIt->getStorageType() == UT_VDB_VEC3F ||
velocityIt->getStorageType() == UT_VDB_VEC3D)) {
velGridPrim = *velocityIt;
}
}
}
// if no level set found, use the topology of the first VDB and turn it into a level set
if (!grid) {
for (; vdbIt; ++vdbIt) {
if (boss.wasInterrupted()) break;
MaskToLevelSetOp op;
if (hvdb::GEOvdbApply<hvdb::AllGridTypes>(**vdbIt, op)) {
grid = op.mSdfGrid;
}
}
}
if (grid) {
// Check for mask input
const GU_Detail* maskGeo = inputGeo(1);
MaskGridT::Ptr mask;
if (maskGeo) {
const GA_PrimitiveGroup* maskGroup = parsePrimitiveGroups(
evalStdString("maskvdbname", time).c_str(), GroupCreator(maskGeo));
hvdb::VdbPrimCIterator maskIt(maskGeo, maskGroup);
if (maskIt) {
MaskOp op;
if (hvdb::GEOvdbApply<hvdb::AllGridTypes>(**maskIt, op)) {
mask = op.mMaskGrid;
} else {
addWarning(SOP_MESSAGE, "Cannot convert VDB type to mask.");
}
if (mask && mask->transform() != grid->transform()) {
MaskGridT::Ptr resampledMask = mask->copy();
resampledMask->setTransform(grid->transform().copy());
// resample the mask to match the boundary level set
openvdb::tools::resampleToMatch<openvdb::tools::PointSampler>(
*mask, *resampledMask);
}
}
}
// dilate mask topology by world-space distance
const bool useWorldSpace = static_cast<int>(evalInt("useworldspace", 0, time)) == 1;
int dilation;
if (useWorldSpace) {
const double dilationDistance(static_cast<float>(evalFloat("dilation", 0, time)));
dilation = std::max(1, static_cast<int>(dilationDistance / grid->voxelSize()[0]));
} else {
dilation = static_cast<int>(evalInt("dilationvoxels", 0, time));
}
auto domain = openvdb::tools::createPotentialFlowMask(*grid, dilation);
if (mask) {
if (static_cast<int>(evalInt("masktype", 0, time)) == /*intersection*/0) {
domain->treePtr()->topologyIntersection(mask->tree());
} else {
domain->treePtr()->topologyDifference(mask->tree());
}
}
const int iterations = (static_cast<int>(evalInt("useiterations", 0, time)) == 1 ?
static_cast<int>(evalInt("iterations", 0, time)) : DEFAULT_MAX_ITERATIONS);
const float absoluteError = static_cast<float>(
static_cast<int>(evalInt("usetolerance", 0, time)) == 1 ?
evalFloat("tolerance", 0, time) : DEFAULT_MAX_ERROR);
openvdb::Vec3f backgroundVelocity(0);
bool applyBackground(false);
const bool useBackgroundVelocity =
static_cast<int>(evalInt("usebackgroundvelocity", 0, time)) == 1;
if (useBackgroundVelocity) {
backgroundVelocity = openvdb::Vec3f(
static_cast<float>(evalFloat("backgroundvelocity", 0, time)),
static_cast<float>(evalFloat("backgroundvelocity", 1, time)),
static_cast<float>(evalFloat("backgroundvelocity", 2, time)));
applyBackground = static_cast<int>(
evalInt("applybackgroundvelocity", 0, time)) == 1;
}
const bool outputPotential = static_cast<int>(
evalInt("outputpotential", 0, time)) == 1;
openvdb::math::pcg::State solverState;
if (velGridPrim && velGridPrim->getStorageType() == UT_VDB_VEC3D) {
openvdb::Vec3d backgroundVelocityD(
backgroundVelocity[0], backgroundVelocity[1], backgroundVelocity[2]);
openvdb::Vec3dGrid::ConstPtr velGrid =
openvdb::gridConstPtrCast<openvdb::Vec3dGrid>(velGridPrim->getGridPtr());
PotentialFlowOp<openvdb::Vec3dGrid, openvdb::MaskGrid> potentialFlowOp(
*grid, *domain, velGrid, backgroundVelocityD, applyBackground);
solverState = potentialFlowOp.process(iterations, absoluteError);
hvdb::createVdbPrimitive(*gdp, potentialFlowOp.flowvel, "flowvel");
if (outputPotential) {
hvdb::createVdbPrimitive(*gdp, potentialFlowOp.potential, "potential");
}
}
else {
openvdb::Vec3fGrid::ConstPtr velGrid;
if (velGridPrim && velGridPrim->getStorageType() == UT_VDB_VEC3F) {
velGrid = openvdb::gridConstPtrCast<openvdb::Vec3fGrid>(
velGridPrim->getGridPtr());
}
PotentialFlowOp<openvdb::Vec3fGrid, openvdb::MaskGrid> potentialFlowOp(
*grid, *domain, velGrid, backgroundVelocity, applyBackground);
solverState = potentialFlowOp.process(iterations, absoluteError);
hvdb::createVdbPrimitive(*gdp, potentialFlowOp.flowvel, "flowvel");
if (outputPotential) {
hvdb::createVdbPrimitive(*gdp, potentialFlowOp.potential, "potential");
}
}
if (!solverState.success) {
std::ostringstream errStrm;
errStrm << "potential flow failed to converge " <<
" with error " << solverState.absoluteError;
addWarning(SOP_MESSAGE, errStrm.str().c_str());
}
else {
std::ostringstream infoStrm;
infoStrm << "solver converged in " <<
solverState.iterations << " iteration"
<< (solverState.iterations == 1 ? "" : "s")
<< " with error " << solverState.absoluteError;
const std::string info = infoStrm.str();
if (!info.empty()) {
addMessage(SOP_MESSAGE, info.c_str());
}
}
}
if (!grid && !boss.wasInterrupted()) {
addWarning(SOP_MESSAGE, "No valid VDB primitives found.");
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 23,391 | C++ | 39.611111 | 99 | 0.619982 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GU_PrimVDB.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c) Side Effects Software Inc.
*
* Produced by:
* Side Effects Software Inc
* 477 Richmond Street West
* Toronto, Ontario
* Canada M5V 3E7
* 416-504-9876
*
* NAME: GU_PrimVDB.h ( GU Library, C++)
*
* COMMENTS: Custom VDB primitive.
*/
#include <UT/UT_Version.h>
// Using the native OpenVDB Primitive shipped with Houdini is strongly recommended,
// as there is no guarantee that this code will be kept in sync with Houdini.
// However, for debugging it can be useful, so supply -DSESI_OPENVDB_PRIM to
// the compiler to build this custom primitive.
#if !defined(SESI_OPENVDB) && !defined(SESI_OPENVDB_PRIM)
#include <GU/GU_PrimVDB.h>
namespace openvdb_houdini {
using ::GU_PrimVDB;
}
#else // SESI_OPENVDB || SESI_OPENVDB_PRIM
#ifndef __HDK_GU_PrimVDB__
#define __HDK_GU_PrimVDB__
#include <GA/GA_PrimitiveDefinition.h>
#include "GEO_PrimVDB.h"
#include <GU/GU_Detail.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_VoxelArray.h>
#include <openvdb/Platform.h>
#include <stddef.h>
class GA_Attribute;
class GEO_PrimVolume;
class UT_MemoryCounter;
class GEO_ConvertParms;
typedef GEO_ConvertParms GU_ConvertParms;
class OPENVDB_HOUDINI_API GU_PrimVDB : public GEO_PrimVDB
{
protected:
/// NOTE: Primitives should not be deleted directly. They are managed
/// by the GA_PrimitiveList and the stash.
~GU_PrimVDB() override {}
public:
/// NOTE: This constructor should only be called via GU_PrimitiveFactory.
GU_PrimVDB(GU_Detail *gdp, GA_Offset offset=GA_INVALID_OFFSET)
: GEO_PrimVDB(gdp, offset)
{}
/// Report approximate memory usage.
int64 getMemoryUsage() const override;
/// Count memory usage using a UT_MemoryCounter in order to count
/// shared memory correctly.
/// NOTE: This should always include sizeof(*this).
void countMemory(UT_MemoryCounter &counter) const override;
#ifndef SESI_OPENVDB
/// Allows you to find out what this primitive type was named.
static GA_PrimitiveTypeId theTypeId() { return theDefinition->getId(); }
/// Must be invoked during the factory callback to add us to the
/// list of primitives
static void registerMyself(GA_PrimitiveFactory *factory);
#endif
const GA_PrimitiveDefinition &getTypeDef() const override
{
UT_ASSERT(theDefinition);
return *theDefinition;
}
// Conversion Methods
GEO_Primitive *convert(GU_ConvertParms &parms,
GA_PointGroup *usedpts = 0) override;
GEO_Primitive *convertNew(GU_ConvertParms &parms) override;
/// Convert all GEO_PrimVolume primitives in geometry to
/// GEO_PrimVDB, preserving prim/vertex/point attributes (and prim/point
/// groups if requested).
static void convertVolumesToVDBs(
GU_Detail &dst_geo,
const GU_Detail &src_geo,
GU_ConvertParms &parms,
bool flood_sdf,
bool prune,
fpreal tolerance,
bool keep_original,
bool activate_inside = true);
/// Convert all GEO_PrimVDB primitives in geometry to parms.toType,
/// preserving prim/vertex/point attributes (and prim/point groups if
/// requested).
/// @{
static void convertVDBs(
GU_Detail &dst_geo,
const GU_Detail &src_geo,
GU_ConvertParms &parms,
fpreal adaptivity,
bool keep_original);
static void convertVDBs(
GU_Detail &dst_geo,
const GU_Detail &src_geo,
GU_ConvertParms &parms,
fpreal adaptivity,
bool keep_original,
bool split_disjoint_volumes);
/// @}
// NOTE: For static member functions please call in the following
// manner. <ptrvalue> = GU_PrimVDB::<functname>
// i.e. partptr = GU_PrimVDB::build(params...);
// Optional Build Method
static GU_PrimVDB * build(GU_Detail *gdp, bool append_points = true);
/// Store a VDB grid in a new VDB primitive and add the primitive
/// to a geometry detail.
/// @param gdp the detail to which to add the new primitive
/// @param grid a grid to be associated with the new primitive
/// @param src if non-null, copy attributes and groups from this primitive
/// @param name if non-null, set the new primitive's @c name attribute to
/// this string; otherwise, if @a src is non-null, use its name
static SYS_FORCE_INLINE
GU_PrimVDB* buildFromGrid(GU_Detail& gdp, openvdb::GridBase::Ptr grid,
const GEO_PrimVDB* src = NULL, const char* name = NULL)
{
return GU_PrimVDB::buildFromGridAdapter(gdp, &grid, src, name);
}
/// Create new VDB primitive from the given native volume primitive
static GU_PrimVDB * buildFromPrimVolume(
GU_Detail &geo,
const GEO_PrimVolume &vol,
const char *name,
const bool flood_sdf = false,
const bool prune = false,
const float tolerance = 0.0,
const bool activate_inside_sdf = true);
/// A fast method for converting a primitive volume to a polysoup via VDB
/// into the given gdp. It will _not_ copy attributes because this is a
/// special case used for display purposes only.
static void convertPrimVolumeToPolySoup(
GU_Detail &dst_geo,
const GEO_PrimVolume &src_vol);
void normal(NormalComp &output) const override;
/// @brief Transfer any metadata associated with this primitive's
/// VDB grid to primitive attributes.
void syncAttrsFromMetadata();
/// @brief Transfer any metadata associated with a VDB grid
/// to primitive attributes on a VDB primitive.
/// @param prim the primitive to be populated with attributes
/// @param grid the grid whose metadata should be transferred
/// @param gdp the detail to which to transfer attributes
static SYS_FORCE_INLINE
void createGridAttrsFromMetadata(
const GEO_PrimVDB& prim,
const openvdb::GridBase& grid,
GEO_Detail& gdp)
{
GU_PrimVDB::createGridAttrsFromMetadataAdapter(prim, &grid, gdp);
}
/// @brief Transfer any metadata associated with the given MetaMap
/// to attributes on the given element specified by owner.
/// @param owner the type of element
/// @param element the offset of the element
/// @param meta_map the metadata that should be transferred
/// @param gdp the detail to which to transfer attributes
static SYS_FORCE_INLINE
void createAttrsFromMetadata(
GA_AttributeOwner owner,
GA_Offset element,
const openvdb::MetaMap& meta_map,
GEO_Detail& gdp)
{
GU_PrimVDB::createAttrsFromMetadataAdapter(owner, element, &meta_map, gdp);
}
/// @brief Transfer a VDB primitive's attributes to a VDB grid as metadata.
/// @param grid the grid to be populated with metadata
/// @param prim the primitive whose attributes should be transferred
/// @param gdp the detail from which to retrieve primitive attributes
static SYS_FORCE_INLINE
void createMetadataFromGridAttrs(
openvdb::GridBase& grid,
const GEO_PrimVDB& prim,
const GEO_Detail& gdp)
{
GU_PrimVDB::createMetadataFromGridAttrsAdapter(&grid, prim, gdp);
}
/// @brief Transfer attributes to VDB metadata.
/// @param meta_map the output metadata
/// @param owner the type of element
/// @param element the offset of the element
/// @param geo the detail from which to retrieve primitive attributes
static SYS_FORCE_INLINE
void createMetadataFromAttrs(
openvdb::MetaMap& meta_map,
GA_AttributeOwner owner,
GA_Offset element,
const GEO_Detail& geo)
{
GU_PrimVDB::createMetadataFromAttrsAdapter(&meta_map, owner, element, geo);
}
private: // METHODS
/// Add a border of the given radius by evaluating from the given volume.
/// It assumes that the VDB is a float grid and that the voxel array has
/// the same index space, so this can really only be safely called after
/// buildFromPrimVolume(). This is used to ensure that non-constant borders
/// can be converted at the expense of some extra memory.
void expandBorderFromPrimVolume(
const GEO_PrimVolume &vol,
int border_radius);
GEO_Primitive * convertToNewPrim(
GEO_Detail &dst_geo,
GU_ConvertParms &parms,
fpreal adaptivity,
bool split_disjoint_volumes,
bool &success) const;
GEO_Primitive * convertToPrimVolume(
GEO_Detail &dst_geo,
GU_ConvertParms &parms,
bool split_disjoint_volumes) const;
GEO_Primitive * convertToPoly(
GEO_Detail &dst_geo,
GU_ConvertParms &parms,
fpreal adaptivity,
bool buildpolysoup,
bool &success) const;
static GU_PrimVDB* buildFromGridAdapter(
GU_Detail& gdp,
void* grid,
const GEO_PrimVDB*,
const char* name);
static void createGridAttrsFromMetadataAdapter(
const GEO_PrimVDB& prim,
const void* grid,
GEO_Detail& gdp);
static void createMetadataFromGridAttrsAdapter(
void* grid,
const GEO_PrimVDB&,
const GEO_Detail&);
static void createAttrsFromMetadataAdapter(
GA_AttributeOwner owner,
GA_Offset element,
const void* meta_map_ptr,
GEO_Detail& geo);
static void createMetadataFromAttrsAdapter(
void* meta_map_ptr,
GA_AttributeOwner owner,
GA_Offset element,
const GEO_Detail& geo);
private: // DATA
static GA_PrimitiveDefinition *theDefinition;
friend class GU_PrimitiveFactory;
SYS_DEPRECATED_PUSH_DISABLE()
};
SYS_DEPRECATED_POP_DISABLE()
#ifndef SESI_OPENVDB
namespace openvdb_houdini {
using ::GU_PrimVDB;
} // namespace openvdb_houdini
#endif
#endif // __HDK_GU_PrimVDB__
#endif // SESI_OPENVDB || SESI_OPENVDB_PRIM
| 11,527 | C | 36.921053 | 83 | 0.578555 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/Utils.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file openvdb_houdini/Utils.h
/// @author FX R&D Simulation team
/// @brief Utility classes and functions for OpenVDB plugins
#ifndef OPENVDB_HOUDINI_UTILS_HAS_BEEN_INCLUDED
#define OPENVDB_HOUDINI_UTILS_HAS_BEEN_INCLUDED
#include "GU_PrimVDB.h"
#include <OP/OP_Node.h> // for OP_OpTypeId
#include <UT/UT_SharedPtr.h>
#include <UT/UT_Interrupt.h>
#include <openvdb/openvdb.h>
#include <functional>
#include <type_traits>
#ifdef SESI_OPENVDB
#ifdef OPENVDB_HOUDINI_API
#undef OPENVDB_HOUDINI_API
#define OPENVDB_HOUDINI_API
#endif
#endif
class GEO_PrimVDB;
class GU_Detail;
class UT_String;
namespace openvdb_houdini {
using Grid = openvdb::GridBase;
using GridPtr = openvdb::GridBase::Ptr;
using GridCPtr = openvdb::GridBase::ConstPtr;
using GridRef = openvdb::GridBase&;
using GridCRef = const openvdb::GridBase&;
/// @brief Iterator over const VDB primitives on a geometry detail
///
/// @details At least until @c GEO_PrimVDB becomes a built-in primitive type
/// (that can be used as the mask for a @c GA_GBPrimitiveIterator), use this
/// iterator to iterate over all VDB grids belonging to a gdp and, optionally,
/// belonging to a particular group.
class OPENVDB_HOUDINI_API VdbPrimCIterator
{
public:
using FilterFunc = std::function<bool (const GU_PrimVDB&)>;
/// @param gdp
/// the geometry detail over which to iterate
/// @param group
/// a group in the detail over which to iterate (if @c nullptr,
/// iterate over all VDB primitives)
/// @param filter
/// an optional function or functor that takes a const reference
/// to a GU_PrimVDB and returns a boolean specifying whether
/// that primitive should be visited (@c true) or not (@c false)
explicit VdbPrimCIterator(const GEO_Detail* gdp, const GA_PrimitiveGroup* group = nullptr,
FilterFunc filter = FilterFunc());
VdbPrimCIterator(const VdbPrimCIterator&);
VdbPrimCIterator& operator=(const VdbPrimCIterator&);
//@{
/// Advance to the next VDB primitive.
void advance();
VdbPrimCIterator& operator++() { advance(); return *this; }
//@}
//@{
/// Return a pointer to the current VDB primitive (@c nullptr if at end).
const GU_PrimVDB* getPrimitive() const;
const GU_PrimVDB* operator*() const { return getPrimitive(); }
const GU_PrimVDB* operator->() const { return getPrimitive(); }
//@}
//@{
GA_Offset getOffset() const { return getPrimitive()->getMapOffset(); }
GA_Index getIndex() const { return getPrimitive()->getMapIndex(); }
//@}
/// Return @c false if there are no more VDB primitives.
operator bool() const { return getPrimitive() != nullptr; }
/// @brief Return the value of the current VDB primitive's @c name attribute.
/// @param defaultName
/// if the current primitive has no @c name attribute
/// or its name is empty, return this name instead
UT_String getPrimitiveName(const UT_String& defaultName = "") const;
/// @brief Return the value of the current VDB primitive's @c name attribute
/// or, if the name is empty, the primitive's index (as a UT_String).
UT_String getPrimitiveNameOrIndex() const;
/// @brief Return a string of the form "N (NAME)", where @e N is
/// the current VDB primitive's index and @e NAME is the value
/// of the primitive's @c name attribute.
/// @param keepEmptyName if the current primitive has no @c name attribute
/// or its name is empty, then if this flag is @c true, return a string
/// "N ()", otherwise return a string "N" omitting the empty name
UT_String getPrimitiveIndexAndName(bool keepEmptyName = true) const;
protected:
/// Allow primitives to be deleted during iteration.
VdbPrimCIterator(const GEO_Detail*, GA_Range::safedeletions,
const GA_PrimitiveGroup* = nullptr, FilterFunc = FilterFunc());
UT_SharedPtr<GA_GBPrimitiveIterator> mIter;
FilterFunc mFilter;
}; // class VdbPrimCIterator
/// @brief Iterator over non-const VDB primitives on a geometry detail
///
/// @details At least until @c GEO_PrimVDB becomes a built-in primitive type
/// (that can be used as the mask for a @c GA_GBPrimitiveIterator), use this
/// iterator to iterate over all VDB grids belonging to a gdp and, optionally,
/// belonging to a particular group.
class OPENVDB_HOUDINI_API VdbPrimIterator: public VdbPrimCIterator
{
public:
/// @param gdp
/// the geometry detail over which to iterate
/// @param group
/// a group in the detail over which to iterate (if @c nullptr,
/// iterate over all VDB primitives)
/// @param filter
/// an optional function or functor that takes a @c const reference
/// to a GU_PrimVDB and returns a boolean specifying whether
/// that primitive should be visited (@c true) or not (@c false)
explicit VdbPrimIterator(GEO_Detail* gdp, const GA_PrimitiveGroup* group = nullptr,
FilterFunc filter = FilterFunc()):
VdbPrimCIterator(gdp, group, filter) {}
/// @brief Allow primitives to be deleted during iteration.
/// @param gdp
/// the geometry detail over which to iterate
/// @param group
/// a group in the detail over which to iterate (if @c nullptr,
/// iterate over all VDB primitives)
/// @param filter
/// an optional function or functor that takes a @c const reference
/// to a GU_PrimVDB and returns a boolean specifying whether
/// that primitive should be visited (@c true) or not (@c false)
VdbPrimIterator(GEO_Detail* gdp, GA_Range::safedeletions,
const GA_PrimitiveGroup* group = nullptr, FilterFunc filter = FilterFunc()):
VdbPrimCIterator(gdp, GA_Range::safedeletions(), group, filter) {}
VdbPrimIterator(const VdbPrimIterator&);
VdbPrimIterator& operator=(const VdbPrimIterator&);
/// Advance to the next VDB primitive.
VdbPrimIterator& operator++() { advance(); return *this; }
//@{
/// Return a pointer to the current VDB primitive (@c nullptr if at end).
GU_PrimVDB* getPrimitive() const {
return const_cast<GU_PrimVDB*>(VdbPrimCIterator::getPrimitive());
}
GU_PrimVDB* operator*() const { return getPrimitive(); }
GU_PrimVDB* operator->() const { return getPrimitive(); }
//@}
}; // class VdbPrimIterator
////////////////////////////////////////
/// @brief Wrapper class that adapts a Houdini @c UT_Interrupt object
/// for use with OpenVDB library routines
/// @sa openvdb/util/NullInterrupter.h
class Interrupter
{
public:
explicit Interrupter(const char* title = nullptr):
mUTI{UTgetInterrupt()}, mRunning{false}, mTitle{title ? title : ""}
{}
~Interrupter() { if (mRunning) this->end(); }
Interrupter(const Interrupter&) = default;
Interrupter& operator=(const Interrupter&) = default;
/// @brief Signal the start of an interruptible operation.
/// @param name an optional descriptive name for the operation
void start(const char* name = nullptr) {
if (!mRunning) { mRunning = true; mUTI->opStart(name ? name : mTitle.c_str()); }
}
/// Signal the end of an interruptible operation.
void end() { if (mRunning) { mUTI->opEnd(); mRunning = false; } }
/// @brief Check if an interruptible operation should be aborted.
/// @param percent an optional (when >= 0) percentage indicating
/// the fraction of the operation that has been completed
bool wasInterrupted(int percent=-1) { return mUTI->opInterrupt(percent); }
private:
UT_Interrupt* mUTI;
bool mRunning;
std::string mTitle;
};
////////////////////////////////////////
// Utility methods
/// @brief Store a VDB grid in a new VDB primitive and add the primitive
/// to a geometry detail.
/// @return the newly-created VDB primitive.
/// @param gdp the detail to which to add the primitive
/// @param grid the VDB grid to be added
/// @param name if non-null, set the new primitive's @c name attribute to this string
/// @note This operation clears the input grid's metadata.
OPENVDB_HOUDINI_API
GU_PrimVDB* createVdbPrimitive(GU_Detail& gdp, GridPtr grid, const char* name = nullptr);
/// @brief Replace an existing VDB primitive with a new primitive that contains
/// the given grid.
/// @return the newly-created VDB primitive.
/// @param gdp the detail to which to add the primitive
/// @param grid the VDB grid to be added
/// @param src replace this primitive with the newly-created primitive
/// @param copyAttrs if @c true, copy attributes and group membership from the @a src primitive
/// @param name if non-null, set the new primitive's @c name attribute to this string;
/// otherwise, if @a copyAttrs is @c true, copy the name from @a src
/// @note This operation clears the input grid's metadata.
OPENVDB_HOUDINI_API
GU_PrimVDB* replaceVdbPrimitive(GU_Detail& gdp, GridPtr grid, GEO_PrimVDB& src,
const bool copyAttrs = true, const char* name = nullptr);
/// @brief Return in @a corners the corners of the given grid's active voxel bounding box.
/// @return @c false if the grid has no active voxels.
OPENVDB_HOUDINI_API
bool evalGridBBox(GridCRef grid, UT_Vector3 corners[8], bool expandHalfVoxel = false);
/// Construct an index-space CoordBBox from a UT_BoundingBox.
OPENVDB_HOUDINI_API
openvdb::CoordBBox makeCoordBBox(const UT_BoundingBox&, const openvdb::math::Transform&);
/// @{
/// @brief Start forwarding OpenVDB log messages to the Houdini error manager
/// for all operators of the given type.
/// @details Typically, log forwarding is enabled for specific operator types
/// during initialization of the openvdb_houdini library, and there's no need
/// for client code to call this function.
/// @details This function has no effect unless OpenVDB was built with
/// <A HREF="http://log4cplus.sourceforge.net/">log4cplus</A>.
/// @note OpenVDB messages are typically logged to the console as well.
/// This function has no effect on console logging.
/// @sa stopLogForwarding(), isLogForwarding()
OPENVDB_HOUDINI_API
void startLogForwarding(OP_OpTypeId);
/// @brief Stop forwarding OpenVDB log messages to the Houdini error manager
/// for all operators of the given type.
/// @details Typically, log forwarding is enabled for specific operator types
/// during initialization of the openvdb_houdini library, and there's no need
/// for client code to disable it.
/// @details This function has no effect unless OpenVDB was built with
/// <A HREF="http://log4cplus.sourceforge.net/">log4cplus</A>.
/// @note OpenVDB messages are typically logged to the console as well.
/// This function has no effect on console logging.
/// @sa startLogForwarding(), isLogForwarding()
OPENVDB_HOUDINI_API
void stopLogForwarding(OP_OpTypeId);
/// @brief Return @c true if OpenVDB messages logged by operators
/// of the given type are forwarded to the Houdini error manager.
/// @sa startLogForwarding(), stopLogForwarding()
OPENVDB_HOUDINI_API
bool isLogForwarding(OP_OpTypeId);
/// @}
////////////////////////////////////////
// Grid type lists, for use with GEO_PrimVDB::apply(), GEOvdbApply(),
// or openvdb::GridBase::apply()
using ScalarGridTypes = openvdb::TypeList<
openvdb::BoolGrid,
openvdb::FloatGrid,
openvdb::DoubleGrid,
openvdb::Int32Grid,
openvdb::Int64Grid>;
using NumericGridTypes = openvdb::TypeList<
openvdb::FloatGrid,
openvdb::DoubleGrid,
openvdb::Int32Grid,
openvdb::Int64Grid>;
using RealGridTypes = openvdb::TypeList<
openvdb::FloatGrid,
openvdb::DoubleGrid>;
using Vec3GridTypes = openvdb::TypeList<
openvdb::Vec3SGrid,
openvdb::Vec3DGrid,
openvdb::Vec3IGrid>;
using PointGridTypes = openvdb::TypeList<
openvdb::points::PointDataGrid>;
using VolumeGridTypes = ScalarGridTypes::Append<Vec3GridTypes>;
using AllGridTypes = VolumeGridTypes::Append<PointGridTypes>;
/// @brief If the given primitive's grid resolves to one of the listed grid types,
/// invoke the functor @a op on the resolved grid.
/// @return @c true if the functor was invoked, @c false otherwise
template<typename GridTypeListT, typename OpT>
inline bool
GEOvdbApply(const GEO_PrimVDB& vdb, OpT& op)
{
if (auto gridPtr = vdb.getConstGridPtr()) {
return gridPtr->apply<GridTypeListT>(op);
}
return false;
}
/// @brief If the given primitive's grid resolves to one of the listed grid types,
/// invoke the functor @a op on the resolved grid.
/// @return @c true if the functor was invoked, @c false otherwise
/// @details If @a makeUnique is true, deep copy the grid's tree before
/// invoking the functor if the tree is shared with other grids.
template<typename GridTypeListT, typename OpT>
inline bool
GEOvdbApply(GEO_PrimVDB& vdb, OpT& op, bool makeUnique = true)
{
if (vdb.hasGrid()) {
auto gridPtr = vdb.getGridPtr();
if (makeUnique) {
auto treePtr = gridPtr->baseTreePtr();
if (treePtr.use_count() > 2) { // grid + treePtr = 2
// If the grid resolves to one of the listed types and its tree
// is shared with other grids, replace the tree with a deep copy.
gridPtr->apply<GridTypeListT>(
[](Grid& baseGrid) { baseGrid.setTree(baseGrid.constBaseTree().copy()); });
}
}
return gridPtr->apply<GridTypeListT>(op);
}
return false;
}
} // namespace openvdb_houdini
#endif // OPENVDB_HOUDINI_UTILS_HAS_BEEN_INCLUDED
| 13,654 | C | 37.142458 | 96 | 0.686466 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/UT_VDBTools.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file UT_VDBTools.h
/// @author FX R&D Simulation team
/// @brief Less commonly-used utility classes and functions for OpenVDB plugins
#ifndef OPENVDB_HOUDINI_UT_VDBTOOLS_HAS_BEEN_INCLUDED
#define OPENVDB_HOUDINI_UT_VDBTOOLS_HAS_BEEN_INCLUDED
#include <openvdb/openvdb.h>
#include <openvdb/tools/GridTransformer.h>
#include "Utils.h" // for GridPtr
namespace openvdb_houdini {
/// @brief GridTransformOp is a functor class for use with GridBase::apply()
/// that samples an input grid into an output grid of the same type through
/// a given affine transform.
/// @details The output grid's transform is unchanged by this operation.
/// @sa GridResampleOp, GridResampleToMatchOp
/// @par Example:
/// @code
/// const Grid& inGrid = ...; // generic reference to a grid of any type
///
/// // Create a new, empty output grid of the same (so far, unknown) type
/// // as the input grid and with the same transform and metadata.
/// GridPtr outGrid = inGrid.copyGridWithNewTree();
///
/// // Initialize a GridTransformer with the parameters of an affine transform.
/// openvdb::tools::GridTransformer xform(pivot, scale, rotate, ...);
///
/// // Resolve the input grid's type and resample it into the output grid,
/// // using a second-order sampling kernel.
/// GridTransformOp<openvdb::tools::QuadraticSampler> op(outGrid, xform);
/// inGrid.apply<openvdb_houdini::ScalarGridTypes>(op);
/// @endcode
template<typename Sampler>
class GridTransformOp
{
public:
/// @param outGrid a generic pointer to an output grid of the same type
/// as the grid to be resampled
/// @param t a @c GridTransformer that defines an affine transform
/// @note GridTransformOp makes an internal copy of the @c GridTransformer
/// and supplies the copy with a default Interrupter that replaces any
/// existing interrupter.
GridTransformOp(GridPtr& outGrid, const openvdb::tools::GridTransformer& t):
mOutGrid(outGrid), mTransformer(t) {}
template<typename GridType>
void operator()(const GridType& inGrid)
{
typename GridType::Ptr outGrid = openvdb::gridPtrCast<GridType>(mOutGrid);
Interrupter interrupter;
mTransformer.setInterrupter(interrupter);
mTransformer.transformGrid<Sampler, GridType>(inGrid, *outGrid);
}
private:
GridPtr mOutGrid;
openvdb::tools::GridTransformer mTransformer;
};
////////////////////////////////////////
/// @brief GridResampleOp is a functor class for use with UTvdbProcessTypedGrid()
/// that samples an input grid into an output grid of the same type through
/// a given transform.
/// @details The output grid's transform is unchanged by this operation.
/// @sa GridTransformOp, GridResampleToMatchOp
/// @par Example:
/// @code
/// namespace {
/// // Class that implements GridResampler's Transformer interface
/// struct MyXform
/// {
/// bool isAffine() const { ... }
/// openvdb::Vec3d transform(const openvdb::Vec3d&) const { ... }
/// openvdb::Vec3d invTransform(const openvdb::Vec3d&) const { ... }
/// };
/// }
///
/// const Grid& inGrid = ...; // generic reference to a grid of any type
///
/// // Create a new, empty output grid of the same (so far, unknown) type
/// // as the input grid and with the same transform and metadata.
/// GridPtr outGrid = inGrid.copyGridWithNewTree();
///
/// // Resolve the input grid's type and resample it into the output grid,
/// // using a trilinear sampling kernel.
/// GridResampleOp<openvdb::tools::BoxSampler, MyXform> op(outGrid, MyXform());
/// inGrid.apply<openvdb_houdini::ScalarGridTypes>(op);
/// @endcode
template<typename Sampler, typename TransformerType>
class GridResampleOp
{
public:
/// @param outGrid a generic pointer to an output grid of the same type
/// as the grid to be resampled
/// @param t an object that implements <tt>GridResampler</tt>'s
/// Transformer interface
/// @note GridResampleOp makes an internal copy of @a t.
GridResampleOp(GridPtr& outGrid, const TransformerType& t):
mOutGrid(outGrid), mTransformer(t) {}
template<typename GridType>
void operator()(const GridType& inGrid)
{
typename GridType::Ptr outGrid = openvdb::gridPtrCast<GridType>(mOutGrid);
openvdb::tools::GridResampler resampler;
Interrupter interrupter;
resampler.setInterrupter(interrupter);
resampler.transformGrid<Sampler>(mTransformer, inGrid, *outGrid);
}
private:
GridPtr mOutGrid;
const TransformerType mTransformer;
};
////////////////////////////////////////
/// @brief GridResampleToMatchOp is a functor class for use with
/// GridBase::apply() that samples an input grid into an output grid
/// of the same type such that, after resampling, the input and output grids
/// coincide, but the output grid's transform is unchanged.
/// @sa GridTransformOp, GridResampleOp
/// @par Example:
/// @code
/// const Grid& inGrid = ...; // generic reference to a grid of any type
///
/// // Create a new, empty output grid of the same (so far, unknown) type as
/// // the input grid and with the same metadata, but with a different transform.
/// GridPtr outGrid = inGrid.copyGridWithNewTree();
/// outGrid->setTransform(myTransform);
///
/// // Resolve the input grid's type and resample it into the output grid,
/// // using a second-order sampling kernel.
/// GridResampleToMatchOp<openvdb::tools::QuadraticSampler> op(outGrid);
/// inGrid.apply<openvdb_houdini::ScalarGridTypes>(op);
/// @endcode
template<typename Sampler>
class GridResampleToMatchOp
{
public:
GridResampleToMatchOp(GridPtr outGrid): mOutGrid(outGrid) {}
template<typename GridType>
void operator()(const GridType& inGrid)
{
typename GridType::Ptr outGrid = openvdb::gridPtrCast<GridType>(mOutGrid);
Interrupter interrupter;
openvdb::tools::resampleToMatch<Sampler>(inGrid, *outGrid, interrupter);
}
private:
GridPtr mOutGrid;
};
} // namespace openvdb_houdini
#endif // OPENVDB_HOUDINI_UT_VDBTOOLS_HAS_BEEN_INCLUDED
| 6,174 | C | 34.693641 | 82 | 0.693878 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Resample.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
///
/// @file SOP_OpenVDB_Resample.cc
//
/// @author FX R&D OpenVDB team
///
/// @class SOP_OpenVDB_Resample
/// This node resamples voxels from input VDB grids into new grids
/// (of the same type) through a sampling transform that is either
/// specified by user-supplied translation, rotation, scale and pivot
/// parameters or taken from an optional reference grid.
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/UT_VDBTools.h> // for GridTransformOp, et al.
#include <openvdb_houdini/UT_VDBUtils.h> // for UTvdbGridCast()
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/openvdb.h>
#include <openvdb/tools/GridTransformer.h>
#include <openvdb/tools/LevelSetRebuild.h>
#include <openvdb/tools/VectorTransformer.h> // for transformVectors()
#include <UT/UT_Interrupt.h>
#include <functional>
#include <stdexcept>
#include <string>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace {
enum { MODE_PARMS = 0, MODE_REF_GRID, MODE_VOXEL_SIZE, MODE_VOXEL_SCALE };
}
class SOP_OpenVDB_Resample: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Resample(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Resample() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i == 1); }
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
void resolveObsoleteParms(PRM_ParmList*) override;
bool updateParmsFlags() override;
};
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Group pattern
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDBs to be resampled")
.setDocumentation(
"A subset of the input VDBs to be resampled"
" (see [specifying volumes|/model/volumes#group])"));
// Reference grid group
parms.add(hutil::ParmFactory(PRM_STRING, "reference", "Reference")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip(
"Specify a single reference VDB from the\n"
"first input whose transform is to be matched.\n"
"Alternatively, connect the reference VDB\n"
"to the second input."));
parms.add(hutil::ParmFactory(PRM_ORD, "order", "Interpolation")
.setDefault(PRMoneDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"point", "Nearest",
"linear", "Linear",
"quadratic", "Quadratic"
})
.setDocumentation("\
How to interpolate values at fractional voxel positions\n\
\n\
Nearest:\n\
Use the value from the nearest voxel.\n\n\
This is fast but can cause aliasing artifacts.\n\
Linear:\n\
Interpolate trilinearly between the values of immediate neighbors.\n\n\
This matches what [Node:sop/volumemix] and [Vex:volumesample] do.\n\
Quadratic:\n\
Interpolate triquadratically between the values of neighbors.\n\n\
This produces smoother results than trilinear interpolation but is slower.\n"));
// Transform source
parms.add(hutil::ParmFactory(PRM_ORD, "mode", "Define Transform")
.setDefault(PRMoneDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"explicit", "Explicitly",
"refvdb", "To Match Reference VDB",
"voxelsizeonly", "Using Voxel Size Only",
"voxelscaleonly", "Using Voxel Scale Only"
})
.setTooltip(
"Specify how to define the relative transform\n"
"between an input and an output VDB.")
.setDocumentation("\
How to generate the new VDB's transform\n\
\n\
Explicitly:\n\
Use the values of the transform parameters below.\n\
To Match Reference VDB:\n\
Match the transform and voxel size of a reference VDB.\n\n\
The resulting volume is a copy of the input VDB,\n\
aligned to the reference VDB.\n\
Using Voxel Size Only:\n\
Keep the transform of the input VDB but set a new voxel size,\n\
increasing or decreasing the resolution.\n\
Using Voxel Scale Only:\n\
Keep the transform of the input VDB but scale the voxel size,\n\
increasing or decreasing the resolution.\n"));
parms.add(hutil::ParmFactory(PRM_ORD, "xOrd", "Transform Order")
.setDefault(0, "tsr")
.setChoiceList(&PRMtrsMenu)
.setTypeExtended(PRM_TYPE_JOIN_PAIR)
.setTooltip(
"When __Define Transform__ is Explicitly, the order of operations"
" for the new transform"));
parms.add(hutil::ParmFactory(
PRM_ORD | PRM_Type(PRM_Type::PRM_INTERFACE_LABEL_NONE), "rOrd", "")
.setDefault(0, "zyx")
.setChoiceList(&PRMxyzMenu)
.setTooltip(
"When __Define Transform__ is Explicitly, the order of rotations"
" for the new transform"));
// Translation
parms.add(hutil::ParmFactory(PRM_XYZ_J, "t", "Translate Voxels")
.setDefault(PRMzeroDefaults)
.setVectorSize(3)
.setTooltip(
"When __Define Transform__ is Explicitly, the shift in voxels for the new transform"));
// Rotation
parms.add(hutil::ParmFactory(PRM_XYZ_J, "r", "Rotate")
.setDefault(PRMzeroDefaults)
.setVectorSize(3)
.setTooltip(
"When __Define Transform__ is Explicitly, the rotation for the new transform"));
// Scale
parms.add(hutil::ParmFactory(PRM_XYZ_J, "s", "Scale")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.000001f, PRM_RANGE_UI, 10)
.setVectorSize(3)
.setTooltip(
"When __Define Transform__ is Explicitly, the scale for the new transform"));
// Pivot
parms.add(hutil::ParmFactory(PRM_XYZ_J, "p", "Pivot")
.setDefault(PRMzeroDefaults)
.setVectorSize(3)
.setTooltip(
"When __Define Transform__ is Explicitly, the world-space pivot point"
" for scaling and rotation in the new transform"));
// Voxel size
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxelsize", "Voxel Size")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.000001f, PRM_RANGE_UI, 1)
.setTooltip(
"The desired absolute voxel size for all output VDBs\n\n"
"Larger voxels correspond to lower resolution.\n"));
// Voxel scale
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxelscale", "Voxel Scale")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.000001f, PRM_RANGE_UI, 1)
.setTooltip(
"The amount by which to scale the voxel size for each output VDB\n\n"
"Larger voxels correspond to lower resolution.\n"));
// Toggle to apply transform to vector values
parms.add(hutil::ParmFactory(PRM_TOGGLE, "xformvectors", "Transform Vectors")
.setDefault(PRMzeroDefaults)
.setTooltip(
"Apply the resampling transform to the voxel values of vector-valued VDBs,"
" in accordance with those VDBs'"
" [Vector Type|http://www.openvdb.org/documentation/doxygen/overview.html#secGrid]"
" attributes."));
// Level set rebuild toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "rebuild", "Rebuild SDF")
.setDefault(PRMoneDefaults)
.setTooltip(
"Transforming (especially scaling) a level set might invalidate\n"
"signed distances, necessitating reconstruction of the SDF.\n\n"
"This option affects only level set volumes, and it should\n"
"almost always be enabled."));
// Prune toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "prune", "Prune Tolerance")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip(
"Reduce the memory footprint of output VDBs that have"
" (sufficiently large) regions of voxels with the same value.\n\n"
"Voxel values are considered equal if they differ by less than"
" the specified threshold.\n\n"
"NOTE:\n"
" Pruning affects only the memory usage of a grid.\n"
" It does not remove voxels, apart from inactive voxels\n"
" whose value is equal to the background."));
// Pruning tolerance slider
parms.add(hutil::ParmFactory(
PRM_FLT_J, "tolerance", "Prune Tolerance")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 1)
.setDocumentation(nullptr));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep2", "separator"));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep3", "separator"));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep4", "separator"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "reference_grid", "Reference"));
obsoleteParms.add(hutil::ParmFactory(PRM_XYZ_J, "translate", "Translate")
.setDefault(PRMzeroDefaults)
.setVectorSize(3));
obsoleteParms.add(hutil::ParmFactory(PRM_XYZ_J, "rotate", "Rotate")
.setDefault(PRMzeroDefaults)
.setVectorSize(3));
obsoleteParms.add(hutil::ParmFactory(PRM_XYZ_J, "scale", "Scale")
.setDefault(PRMoneDefaults)
.setVectorSize(3));
obsoleteParms.add(hutil::ParmFactory(PRM_XYZ_J, "pivot", "Pivot")
.setDefault(PRMzeroDefaults)
.setVectorSize(3));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "voxel_size", "Voxel Size")
.setDefault(PRMoneDefaults));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Resample", SOP_OpenVDB_Resample::factory, parms, *table)
.setObsoleteParms(obsoleteParms)
.addInput("Source VDB grids to resample")
.addOptionalInput("Optional transform reference VDB grid")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Resample::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Resample a VDB volume into a new orientation and/or voxel size.\"\"\"\n\
\n\
@overview\n\
\n\
This node resamples voxels from input VDBs into new VDBs (of the same type)\n\
through a sampling transform that is either specified by user-supplied\n\
translation, rotation, scale and pivot parameters or taken from\n\
an optional reference VDB.\n\
\n\
@related\n\
- [OpenVDB Combine|Node:sop/DW_OpenVDBCombine]\n\
- [Node:sop/vdbresample]\n\
- [Node:sop/xform]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Resample::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
resolveRenamedParm(*obsoleteParms, "reference_grid", "reference");
resolveRenamedParm(*obsoleteParms, "voxel_size", "voxelsize");
resolveRenamedParm(*obsoleteParms, "translate", "t");
resolveRenamedParm(*obsoleteParms, "rotate", "r");
resolveRenamedParm(*obsoleteParms, "scale", "s");
resolveRenamedParm(*obsoleteParms, "pivot", "p");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
// Disable UI Parms.
bool
SOP_OpenVDB_Resample::updateParmsFlags()
{
bool changed = false;
const auto mode = evalInt("mode", 0, 0);
changed |= enableParm("t", mode == MODE_PARMS);
changed |= enableParm("r", mode == MODE_PARMS);
changed |= enableParm("s", mode == MODE_PARMS);
changed |= enableParm("p", mode == MODE_PARMS);
changed |= enableParm("xOrd", mode == MODE_PARMS);
changed |= enableParm("rOrd", mode == MODE_PARMS);
changed |= enableParm("xformvectors", mode == MODE_PARMS);
changed |= enableParm("reference", mode == MODE_REF_GRID);
changed |= enableParm("voxelsize", mode == MODE_VOXEL_SIZE);
changed |= enableParm("voxelscale", mode == MODE_VOXEL_SCALE);
// Show either the voxel size or the voxel scale parm, but not both.
changed |= setVisibleState("voxelsize", mode != MODE_VOXEL_SCALE);
changed |= setVisibleState("voxelscale", mode == MODE_VOXEL_SCALE);
changed |= enableParm("tolerance", bool(evalInt("prune", 0, 0)));
return changed;
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Resample::factory(OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Resample(net, name, op);
}
SOP_OpenVDB_Resample::SOP_OpenVDB_Resample(OP_Network* net, const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
namespace {
// Helper class for use with GridBase::apply()
struct RebuildOp
{
std::function<void (const std::string&)> addWarning;
openvdb::math::Transform xform;
hvdb::GridPtr outGrid;
template<typename GridT>
void operator()(const GridT& grid)
{
using ValueT = typename GridT::ValueType;
const ValueT halfWidth = ValueT(grid.background() * (1.0 / grid.voxelSize()[0]));
hvdb::Interrupter interrupter;
try {
outGrid = openvdb::tools::doLevelSetRebuild(grid,
/*isovalue=*/openvdb::zeroVal<ValueT>(),
/*exWidth=*/halfWidth, /*inWidth=*/halfWidth, &xform, &interrupter);
} catch (openvdb::TypeError&) {
addWarning("skipped rebuild of level set grid " + grid.getName()
+ " of type " + grid.type());
outGrid = openvdb::ConstPtrCast<GridT>(grid.copy());
}
}
}; // struct RebuildOp
// Functor for use with GridBase::apply() to apply a transform
// to the voxel values of vector-valued grids
struct VecXformOp
{
openvdb::Mat4d mat;
VecXformOp(const openvdb::Mat4d& _mat): mat(_mat) {}
template<typename GridT> void operator()(GridT& grid) const
{
openvdb::tools::transformVectors(grid, mat);
}
};
} // unnamed namespace
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Resample::Cache::cookVDBSop(OP_Context& context)
{
try {
auto addWarningCB = [this](const std::string& s) { addWarning(SOP_MESSAGE, s.c_str()); };
const fpreal time = context.getTime();
// Get parameters.
const int samplingOrder = static_cast<int>(evalInt("order", 0, time));
if (samplingOrder < 0 || samplingOrder > 2) {
throw std::runtime_error{"expected interpolation order between 0 and 2, got "
+ std::to_string(samplingOrder)};
}
char const* const xOrdMenu[] = { "srt", "str", "rst", "rts", "tsr", "trs" };
char const* const rOrdMenu[] = { "xyz", "xzy", "yxz", "yzx", "zxy", "zyx" };
const UT_String
xformOrder = xOrdMenu[evalInt("xOrd", 0, time)],
rotOrder = rOrdMenu[evalInt("rOrd", 0, time)];
const int mode = static_cast<int>(evalInt("mode", 0, time));
if (mode < MODE_PARMS || mode > MODE_VOXEL_SCALE) {
throw std::runtime_error{"expected mode between " + std::to_string(int(MODE_PARMS))
+ " and " + std::to_string(int(MODE_VOXEL_SCALE))
+ ", got " + std::to_string(mode)};
}
const openvdb::Vec3R
translate = evalVec3R("t", time),
rotate = (M_PI / 180.0) * evalVec3R("r", time),
scale = evalVec3R("s", time),
pivot = evalVec3R("p", time);
const float
voxelSize = static_cast<float>(evalFloat("voxelsize", 0, time)),
voxelScale = static_cast<float>(evalFloat("voxelscale", 0, time));
const bool
prune = evalInt("prune", 0, time),
rebuild = evalInt("rebuild", 0, time),
xformVec = evalInt("xformvectors", 0, time);
const float tolerance = static_cast<float>(evalFloat("tolerance", 0, time));
// Get the group of grids to be resampled.
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
hvdb::GridCPtr refGrid;
if (mode == MODE_VOXEL_SIZE) {
// Create a dummy reference grid whose (linear) transform specifies
// the desired voxel size.
hvdb::GridPtr grid = openvdb::FloatGrid::create();
grid->setTransform(openvdb::math::Transform::createLinearTransform(voxelSize));
refGrid = grid;
} else if (mode == MODE_VOXEL_SCALE) {
// Create a dummy reference grid with a default (linear) transform.
refGrid = openvdb::FloatGrid::create();
} else if (mode == MODE_REF_GRID) {
// Get the user-specified reference grid from the second input,
// if it is connected, or else from the first input.
const GU_Detail* refGdp = inputGeo(1, context);
if (!refGdp) { refGdp = gdp; }
if (auto it = hvdb::VdbPrimCIterator(refGdp,
matchGroup(*refGdp, evalStdString("reference", time))))
{
refGrid = it->getConstGridPtr();
if (++it) { addWarning(SOP_MESSAGE, "more than one reference grid was found"); }
} else {
throw std::runtime_error("no reference grid was found");
}
}
UT_AutoInterrupt progress("Resampling VDB grids");
// Iterate over the input grids.
for (hvdb::VdbPrimIterator it(gdp, GA_Range::safedeletions(), group); it; ++it) {
if (progress.wasInterrupted()) throw std::runtime_error("Was Interrupted");
GU_PrimVDB* vdb = *it;
const UT_VDBType valueType = vdb->getStorageType();
const bool isLevelSet = ((vdb->getGrid().getGridClass() == openvdb::GRID_LEVEL_SET)
&& (valueType == UT_VDB_FLOAT || valueType == UT_VDB_DOUBLE));
if (isLevelSet && !rebuild) {
// If the input grid is a level set but level set rebuild is disabled,
// set the grid's class to "unknown", to prevent the resample tool
// from triggering a rebuild.
vdb->getGrid().setGridClass(openvdb::GRID_UNKNOWN);
}
const hvdb::Grid& grid = vdb->getGrid();
// Override the sampling order for boolean grids.
int curOrder = samplingOrder;
if (valueType == UT_VDB_BOOL && (samplingOrder != 0)) {
addWarning(SOP_MESSAGE,
("a boolean VDB grid can't be order-" + std::to_string(samplingOrder)
+ " sampled; using nearest neighbor sampling instead").c_str());
curOrder = 0;
}
// Create a new, empty output grid of the same type as the input grid
// and with the same metadata.
hvdb::GridPtr outGrid = grid.copyGridWithNewTree();
UT_AutoInterrupt scopedInterrupt(
("Resampling " + it.getPrimitiveName().toStdString()).c_str());
if (refGrid) {
// If a reference grid was provided, then after resampling, the
// output grid's transform will be the same as the reference grid's.
openvdb::math::Transform::Ptr refXform = refGrid->transform().copy();
if (mode == MODE_VOXEL_SCALE) {
openvdb::Vec3d scaledVoxelSize = grid.voxelSize() * voxelScale;
refXform->preScale(scaledVoxelSize);
}
if (isLevelSet && rebuild) {
// Use the level set rebuild tool to both resample and rebuild.
RebuildOp op;
op.addWarning = addWarningCB;
op.xform = *refXform;
grid.apply<hvdb::RealGridTypes>(op);
outGrid = op.outGrid;
} else {
// Use the resample tool to sample the input grid into the output grid.
// Set the correct transform on the output grid.
outGrid->setTransform(refXform);
if (curOrder == 0) {
hvdb::GridResampleToMatchOp<openvdb::tools::PointSampler> op(outGrid);
grid.apply<hvdb::AllGridTypes>(op);
} else if (curOrder == 1) {
hvdb::GridResampleToMatchOp<openvdb::tools::BoxSampler> op(outGrid);
grid.apply<hvdb::AllGridTypes>(op);
} else if (curOrder == 2) {
hvdb::GridResampleToMatchOp<openvdb::tools::QuadraticSampler> op(outGrid);
grid.apply<hvdb::AllGridTypes>(op);
}
#ifdef SESI_OPENVDB
if (isLevelSet) {
auto tempgrid = UTvdbGridCast<openvdb::FloatGrid>(outGrid);
openvdb::tools::pruneLevelSet(tempgrid->tree());
openvdb::tools::signedFloodFill(tempgrid->tree());
}
#endif
}
} else {
// Resample into the output grid using the user-supplied transform.
// The output grid's transform will be the same as the input grid's.
openvdb::tools::GridTransformer xform(pivot, scale, rotate, translate,
xformOrder.toStdString(), rotOrder.toStdString());
if (isLevelSet && rebuild) {
// Use the level set rebuild tool to both resample and rebuild.
RebuildOp op;
op.addWarning = addWarningCB;
// Compose the input grid's transform with the user-supplied transform.
// (The latter is retrieved from the GridTransformer, so that the
// order of operations and the rotation order are respected.)
op.xform = grid.constTransform();
op.xform.preMult(xform.getTransform().inverse());
grid.apply<hvdb::RealGridTypes>(op);
outGrid = op.outGrid;
outGrid->setTransform(grid.constTransform().copy());
} else {
// Use the resample tool to sample the input grid into the output grid.
hvdb::Interrupter interrupter;
xform.setInterrupter(interrupter);
if (curOrder == 0) {
hvdb::GridTransformOp<openvdb::tools::PointSampler> op(outGrid, xform);
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(*vdb, op);
} else if (curOrder == 1) {
hvdb::GridTransformOp<openvdb::tools::BoxSampler> op(outGrid, xform);
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(*vdb, op);
} else if (curOrder == 2) {
hvdb::GridTransformOp<openvdb::tools::QuadraticSampler> op(outGrid, xform);
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(*vdb, op);
}
#ifdef SESI_OPENVDB
if (isLevelSet) {
auto tempgrid = UTvdbGridCast<openvdb::FloatGrid>(outGrid);
openvdb::tools::pruneLevelSet(tempgrid->tree());
openvdb::tools::signedFloodFill(tempgrid->tree());
}
#endif
}
if (xformVec && outGrid->isInWorldSpace()
&& outGrid->getVectorType() != openvdb::VEC_INVARIANT)
{
// If (and only if) the grid is vector-valued, apply the transform
// to each voxel's value.
VecXformOp op(xform.getTransform());
outGrid->apply<hvdb::Vec3GridTypes>(op);
}
}
if (prune) outGrid->pruneGrid(tolerance);
// Replace the original VDB primitive with a new primitive that contains
// the output grid and has the same attributes and group membership.
hvdb::replaceVdbPrimitive(*gdp, outGrid, *vdb);
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 24,505 | C++ | 38.653722 | 99 | 0.600816 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Advect.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Advect.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Level set advection SOP
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/LevelSetAdvect.h>
#include <openvdb/tools/Interpolation.h>
#include <openvdb/tools/VolumeAdvect.h>
#include <UT/UT_Interrupt.h>
#include <GA/GA_PageIterator.h>
#include <GU/GU_PrimPoly.h>
#include <CH/CH_Manager.h>
#include <PRM/PRM_Parm.h>
#include <hboost/algorithm/string/join.hpp>
#include <functional>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace { struct AdvectionParms; }
class SOP_OpenVDB_Advect: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Advect(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Advect() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i > 0); }
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
};
////////////////////////////////////////
// Build UI and register this operator
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
using namespace openvdb::math;
hutil::ParmList parms;
// Level set grid
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("VDB grid(s) to advect.")
.setDocumentation(
"A subset of VDBs in the first input to move using the velocity field"
" (see [specifying volumes|/model/volumes#group])"));
// Velocity grid
parms.add(hutil::ParmFactory(PRM_STRING, "velgroup", "Velocity")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("Velocity grid")
.setDocumentation(
"The name of a VDB primitive in the second input to use as"
" the velocity field (see [specifying volumes|/model/volumes#group])\n\n"
"This must be a vector-valued VDB primitive."
" You can use the [Vector Merge node|Node:sop/DW_OpenVDBVectorMerge]"
" to turn a `vel.[xyz]` triple into a single primitive."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "respectclass", "Respect Grid Class")
.setDefault(PRMoneDefaults)
.setTooltip("If disabled, advect level sets using general advection scheme.")
.setDocumentation(
"When this option is disabled, all VDBs will use a general numerical"
" advection scheme, otherwise level set VDBs will be advected using"
" a spatial finite-difference scheme."));
// Advect: timestep
parms.add(hutil::ParmFactory(PRM_FLT, "timestep", "Timestep")
.setDefault(1, "1.0/$FPS")
.setDocumentation(
"Number of seconds of movement to apply to the input points\n\n"
"The default is `1/$FPS` (one frame's worth of time)."
" You can use negative values to move the points backwards through"
" the velocity field."));
parms.add(hutil::ParmFactory(PRM_HEADING, "general", "General Advection")
.setDocumentation(
"These control how VDBs that are not level sets are moved through the velocity field."
" If the grid class is not being respected, all grids will be advected"
" using general advection regardless of whether they are level sets or not."));
// SubSteps
parms.add(hutil::ParmFactory(PRM_INT_J, "substeps", "Substeps")
.setDefault(1)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip(
"The number of substeps per integration step.\n"
"The only reason to increase it above its default value of one"
" is to reduce the memory footprint from dilations--likely at the cost"
" of more smoothing!")
.setDocumentation(
"The number of substeps per integration step\n\n"
"The only reason to increase this above its default value of one is to reduce"
" the memory footprint from dilations—likely at the cost of more smoothing."));
// Advection Scheme
parms.add(hutil::ParmFactory(PRM_STRING, "advection", "Advection Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"semi", "Semi-Lagrangian",
"mid", "Mid-Point",
"rk3", "3rd order Runge-Kutta",
"rk4", "4th order Runge-Kutta",
"mac", "MacCormack",
"bfecc", "BFECC"
})
.setDefault("semi")
.setTooltip("Set the numerical advection scheme."));
// Limiter Scheme
parms.add(hutil::ParmFactory(PRM_STRING, "limiter", "Limiter Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"none", "No limiter",
"clamp", "Clamp to extrema",
"revert", "Revert to 1st order"
})
.setDefault("revert")
.setTooltip(
"Set the limiter scheme used to stabilize the second-order"
" MacCormack and BFECC schemes."));
parms.add(hutil::ParmFactory(PRM_HEADING, "advectionHeading", "Level Set Advection")
.setDocumentation(
"These control how level set VDBs are moved through the velocity field."
" If the grid class is not being respected, these options are not used."));
// Advect: spatial menu
{
std::vector<std::string> items;
items.push_back(biasedGradientSchemeToString(FIRST_BIAS));
items.push_back(biasedGradientSchemeToMenuName(FIRST_BIAS));
items.push_back(biasedGradientSchemeToString(HJWENO5_BIAS));
items.push_back(biasedGradientSchemeToMenuName(HJWENO5_BIAS));
parms.add(hutil::ParmFactory(PRM_STRING, "advectspatial", "Spatial Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(biasedGradientSchemeToString(HJWENO5_BIAS))
.setTooltip("Set the spatial finite difference scheme.")
.setDocumentation(
"How accurately the gradients of the signed distance field are computed\n\n"
"The later choices are more accurate but take more time."));
}
// Advect: temporal menu
{
std::vector<std::string> items;
for (int i = 0; i < NUM_TEMPORAL_SCHEMES; ++i) {
TemporalIntegrationScheme it = TemporalIntegrationScheme(i);
items.push_back(temporalIntegrationSchemeToString(it)); // token
items.push_back(temporalIntegrationSchemeToMenuName(it)); // label
}
parms.add(hutil::ParmFactory(PRM_STRING, "advecttemporal", "Temporal Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(temporalIntegrationSchemeToString(TVD_RK2))
.setTooltip("Set the temporal integration scheme.")
.setDocumentation(
"How accurately time is evolved within the timestep\n\n"
"The later choices are more accurate but take more time."));
}
parms.add(hutil::ParmFactory(PRM_HEADING, "renormheading", "Renormalization"));
parms.add(hutil::ParmFactory(PRM_INT_J, "normsteps", "Steps")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip("The number of normalizations performed after each CFL iteration.")
.setDocumentation(
"After advection, a signed distance field will often no longer contain correct"
" distances. A number of renormalization passes can be performed between"
" every substep to convert it back into a proper signed distance field."));
// Renorm: spatial menu
{
std::vector<std::string> items;
items.push_back(biasedGradientSchemeToString(FIRST_BIAS));
items.push_back(biasedGradientSchemeToMenuName(FIRST_BIAS));
items.push_back(biasedGradientSchemeToString(HJWENO5_BIAS));
items.push_back(biasedGradientSchemeToMenuName(HJWENO5_BIAS));
parms.add(hutil::ParmFactory(PRM_STRING, "renormspatial", "Spatial Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(biasedGradientSchemeToString(HJWENO5_BIAS))
.setTooltip("Set the spatial finite difference scheme.")
.setDocumentation(
"How accurately the gradients of the signed distance field are computed\n\n"
"The later choices are more accurate but take more time."));
}
// Renorm: temporal menu
{
std::vector<std::string> items;
for (int i = 0; i < NUM_TEMPORAL_SCHEMES; ++i) {
TemporalIntegrationScheme it = TemporalIntegrationScheme(i);
items.push_back(temporalIntegrationSchemeToString(it)); // token
items.push_back(temporalIntegrationSchemeToMenuName(it)); // label
}
parms.add(hutil::ParmFactory(PRM_STRING, "renormtemporal", "Temporal Scheme")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(items[0])
.setTooltip("Set the temporal integration scheme.")
.setDocumentation(
"How accurately time is evolved within the renormalization stage\n\n"
"The later choices are more accurate but take more time."));
}
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_FLT, "beginTime", "Begin time"));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT, "endTime", "Time step"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "lsGroup", "Group"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "densityGroup", "Group"));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "renormHeading", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "velGroup", "Velocity"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "advectSpatial", "Spatial Scheme")
.setDefault(biasedGradientSchemeToString(HJWENO5_BIAS)));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "advectTemporal", "Temporal Scheme")
.setDefault(temporalIntegrationSchemeToString(TVD_RK2)));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "normSteps", "Renormalization Steps")
.setDefault(PRMthreeDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "renormSpatial", "Spatial Renormalization")
.setDefault(biasedGradientSchemeToString(HJWENO5_BIAS)));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "renormTemporal", "Temporal Renormalization")
.setDefault(temporalIntegrationSchemeToString(TemporalIntegrationScheme(0))));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Advect",
SOP_OpenVDB_Advect::factory, parms, *table)
.setNativeName("vdbadvectsdf")
.setObsoleteParms(obsoleteParms)
.addInput("VDBs to Advect")
.addInput("Velocity VDB")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Advect::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Move VDBs in the input geometry along a VDB velocity field.\"\"\"\n\
\n\
@overview\n\
The OpenVDB Advect operation will advect VDB volumes according to\n\
a velocity field defined in a vector VDB.\n\
\n\
@animation Animating advection\n\
\n\
*This node is not a feedback loop*.\n\
\n\
It moves the fields it finds in the input geometry.\n\
It _cannot_ modify the fields over time.\n\
(That is, if you hook this node up to do advection and press play,\n\
the fields will not animate.)\n\
\n\
To set up a feedback loop, where the advection at each frame affects\n\
the advected field from the previous frame, do one of the following:\n\
* Do the advection inside a [SOP Solver|Node:sop/solver].\n\
* Set the __Time Step__ to `$T`\n\
\n\
This will cause the node to recalculate, _at every frame_, the path\n\
of every particle through _every previous frame_ to get the current one.\n\
This is obviously not very practical.\n\
\n\
@related\n\
- [OpenVDB Advect Points|Node:sop/DW_OpenVDBAdvectPoints]\n\
- [OpenVDB Morph Level Set|Node:sop/DW_OpenVDBMorphLevelSet]\n\
- [Node:sop/vdbadvectsdf]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Advect::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Advect(net, name, op);
}
SOP_OpenVDB_Advect::SOP_OpenVDB_Advect(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
void
SOP_OpenVDB_Advect::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
resolveRenamedParm(*obsoleteParms, "lsGroup", "group");
resolveRenamedParm(*obsoleteParms, "densityGroup", "group");
resolveRenamedParm(*obsoleteParms, "advectSpatial", "advectspatial");
resolveRenamedParm(*obsoleteParms, "advectTemporal", "advecttemporal");
resolveRenamedParm(*obsoleteParms, "normSteps", "normsteps");
resolveRenamedParm(*obsoleteParms, "renormSpatial", "renormspatial");
resolveRenamedParm(*obsoleteParms, "renormTemporal", "renormtemporal");
resolveRenamedParm(*obsoleteParms, "velGroup", "velgroup");
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
////////////////////////////////////////
bool
SOP_OpenVDB_Advect::updateParmsFlags()
{
bool changed = false;
const bool respectClass = bool(evalInt("respectclass", 0, 0));
changed |= enableParm("advectspatial", respectClass);
changed |= enableParm("advecttemporal", respectClass);
changed |= enableParm("normsteps", respectClass);
changed |= enableParm("renormspatial", respectClass);
changed |= enableParm("renormtemporal", respectClass);
return changed;
}
////////////////////////////////////////
// Utilities
namespace {
struct AdvectionParms {
AdvectionParms()
: mGroup(nullptr)
, mAdvectSpatial(openvdb::math::UNKNOWN_BIAS)
, mRenormSpatial(openvdb::math::UNKNOWN_BIAS)
, mAdvectTemporal(openvdb::math::UNKNOWN_TIS)
, mRenormTemporal(openvdb::math::UNKNOWN_TIS)
, mIntegrator(openvdb::tools::Scheme::SEMI)
, mLimiter(openvdb::tools::Scheme::NO_LIMITER)
, mNormCount(1)
, mSubSteps(1)
, mTimeStep(0.0)
, mStaggered(false)
, mRespectClass(true)
{
}
const GA_PrimitiveGroup * mGroup;
hvdb::Grid::ConstPtr mVelocityGrid;
openvdb::math::BiasedGradientScheme mAdvectSpatial, mRenormSpatial;
openvdb::math::TemporalIntegrationScheme mAdvectTemporal, mRenormTemporal;
openvdb::tools::Scheme::SemiLagrangian mIntegrator;
openvdb::tools::Scheme::Limiter mLimiter;
int mNormCount, mSubSteps;
float mTimeStep;
bool mStaggered, mRespectClass;
};
template<class VelocityGridT>
class AdvectOp
{
public:
AdvectOp(AdvectionParms& parms, const VelocityGridT& velGrid, hvdb::Interrupter& boss)
: mParms(parms)
, mVelGrid(velGrid)
, mBoss(boss)
{
}
template<typename GridT, typename SamplerT>
void process(GridT& grid)
{
using FieldT = openvdb::tools::DiscreteField<VelocityGridT, SamplerT>;
const FieldT field(mVelGrid);
openvdb::tools::LevelSetAdvection<GridT, FieldT, hvdb::Interrupter>
advection(grid, field, &mBoss);
advection.setSpatialScheme(mParms.mAdvectSpatial);
advection.setTemporalScheme(mParms.mAdvectTemporal);
advection.setTrackerSpatialScheme(mParms.mRenormSpatial);
advection.setTrackerTemporalScheme(mParms.mRenormTemporal);
advection.setNormCount(mParms.mNormCount);
if (mBoss.wasInterrupted()) return;
advection.advect(0, mParms.mTimeStep);
}
template<typename GridT>
void operator()(GridT& grid)
{
if (mBoss.wasInterrupted()) return;
if (mParms.mStaggered) process<GridT, openvdb::tools::StaggeredBoxSampler>(grid);
else process<GridT, openvdb::tools::BoxSampler>(grid);
}
private:
AdvectOp(const AdvectOp&);// undefined
AdvectOp& operator=(const AdvectOp&);// undefined
AdvectionParms& mParms;
const VelocityGridT& mVelGrid;
hvdb::Interrupter& mBoss;
};
template<typename VelocityGridT, bool StaggeredVelocity>
inline bool
processGrids(GU_Detail* gdp, AdvectionParms& parms, hvdb::Interrupter& boss,
const std::function<void (const std::string&)>& warningCallback)
{
using VolumeAdvection =
openvdb::tools::VolumeAdvection<VelocityGridT, StaggeredVelocity, hvdb::Interrupter>;
using VelocityGridCPtr = typename VelocityGridT::ConstPtr;
VelocityGridCPtr velGrid = hvdb::Grid::constGrid<VelocityGridT>(parms.mVelocityGrid);
if (!velGrid) return false;
AdvectOp<VelocityGridT> advectLevelSet(parms, *velGrid, boss);
VolumeAdvection advectVolume(*velGrid, &boss);
advectVolume.setIntegrator(parms.mIntegrator);
advectVolume.setLimiter(parms.mLimiter);
advectVolume.setSubSteps(parms.mSubSteps);
std::vector<std::string> skippedGrids, doubleGrids;
for (hvdb::VdbPrimIterator it(gdp, parms.mGroup); it; ++it) {
if (boss.wasInterrupted()) break;
GU_PrimVDB* vdbPrim = *it;
if (parms.mRespectClass && vdbPrim->getGrid().getGridClass() == openvdb::GRID_LEVEL_SET) {
if (vdbPrim->getStorageType() == UT_VDB_FLOAT) {
vdbPrim->makeGridUnique();
auto& grid = UTvdbGridCast<openvdb::FloatGrid>(vdbPrim->getGrid());
advectLevelSet(grid);
}
//else if (vdbPrim->getStorageType() == UT_VDB_DOUBLE) {
// vdbPrim->makeGridUnique();
// auto& grid = UTvdbGridCast<openvdb::DoubleGrid>(vdbPrim->getGrid());
// advectLevelSet(grid);
//}
else {
skippedGrids.push_back(it.getPrimitiveNameOrIndex().toStdString());
}
} else {
switch (vdbPrim->getStorageType()) {
case UT_VDB_FLOAT:
{
const auto& inGrid = UTvdbGridCast<openvdb::FloatGrid>(vdbPrim->getConstGrid());
auto outGrid = advectVolume.template advect<openvdb::FloatGrid,
openvdb::tools::Sampler<1, false>>(inGrid, parms.mTimeStep);
hvdb::replaceVdbPrimitive(*gdp, outGrid, *vdbPrim);
break;
}
case UT_VDB_DOUBLE:
{
const auto& inGrid = UTvdbGridCast<openvdb::DoubleGrid>(vdbPrim->getConstGrid());
auto outGrid = advectVolume.template advect<openvdb::DoubleGrid,
openvdb::tools::Sampler<1, false>>(inGrid, parms.mTimeStep);
hvdb::replaceVdbPrimitive(*gdp, outGrid, *vdbPrim);
break;
}
case UT_VDB_VEC3F:
{
const auto& inGrid = UTvdbGridCast<openvdb::Vec3SGrid>(vdbPrim->getConstGrid());
auto outGrid = advectVolume.template advect<openvdb::Vec3SGrid,
openvdb::tools::Sampler<1, false>>(inGrid, parms.mTimeStep);
hvdb::replaceVdbPrimitive(*gdp, outGrid, *vdbPrim);
break;
}
default:
skippedGrids.push_back(it.getPrimitiveNameOrIndex().toStdString());
break;
}
}
}
if (!skippedGrids.empty() && warningCallback) {
std::string s = "The following non-floating-point grids were skipped: "
+ hboost::algorithm::join(skippedGrids, ", ");
warningCallback(s);
}
return true;
} // processGrids()
} // anonymous namespace
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Advect::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal now = context.getTime();
// Evaluate UI parameters
AdvectionParms parms;
{
parms.mGroup = matchGroup(*gdp, evalStdString("group", now));
parms.mTimeStep = static_cast<float>(evalFloat("timestep", 0, now));
parms.mAdvectSpatial =
openvdb::math::stringToBiasedGradientScheme(evalStdString("advectspatial", now));
if (parms.mAdvectSpatial == openvdb::math::UNKNOWN_BIAS) {
throw std::runtime_error{"Advect: Unknown biased gradient"};
}
parms.mRenormSpatial = openvdb::math::stringToBiasedGradientScheme(
evalStdString("renormspatial", now));
if (parms.mRenormSpatial == openvdb::math::UNKNOWN_BIAS) {
throw std::runtime_error{"Renorm: Unknown biased gradient"};
}
parms.mAdvectTemporal = openvdb::math::stringToTemporalIntegrationScheme(
evalStdString("advecttemporal", now));
if (parms.mAdvectTemporal == openvdb::math::UNKNOWN_TIS) {
throw std::runtime_error{"Advect: Unknown temporal integration"};
}
parms.mRenormTemporal = openvdb::math::stringToTemporalIntegrationScheme(
evalStdString("renormtemporal", now));
if (parms.mRenormTemporal == openvdb::math::UNKNOWN_TIS) {
throw std::runtime_error{"Renorm: Unknown temporal integration"};
}
parms.mNormCount = static_cast<int>(evalInt("normsteps", 0, now));
const GU_Detail* velGeo = inputGeo(1);
if (!velGeo) throw std::runtime_error{"Missing velocity grid input"};
hvdb::VdbPrimCIterator it{velGeo, matchGroup(*velGeo, evalStdString("velgroup", now))};
if (it) {
if (it->getStorageType() != UT_VDB_VEC3F) {
throw std::runtime_error{"Unrecognized velocity grid type"};
}
parms.mVelocityGrid = it->getConstGridPtr();
}
if (!parms.mVelocityGrid) {
throw std::runtime_error{"Missing velocity grid"};
}
parms.mStaggered = parms.mVelocityGrid->getGridClass() == openvdb::GRID_STAGGERED;
parms.mRespectClass = bool(evalInt("respectclass", 0, now));
// General advection options
parms.mSubSteps = static_cast<int>(evalInt("substeps", 0, now));
{
const auto str = evalStdString("advection", now);
if (str == "semi") { parms.mIntegrator = openvdb::tools::Scheme::SEMI; }
else if (str == "mid") { parms.mIntegrator = openvdb::tools::Scheme::MID; }
else if (str == "rk3") { parms.mIntegrator = openvdb::tools::Scheme::RK3; }
else if (str == "rk4") { parms.mIntegrator = openvdb::tools::Scheme::RK4; }
else if (str == "mac") { parms.mIntegrator = openvdb::tools::Scheme::MAC; }
else if (str == "bfecc") { parms.mIntegrator = openvdb::tools::Scheme::BFECC; }
else { throw std::runtime_error{"Invalid advection scheme"}; }
}
{
const auto str = evalStdString("limiter", now);
if (str == "none") {
parms.mLimiter = openvdb::tools::Scheme::NO_LIMITER;
if (parms.mIntegrator == openvdb::tools::Scheme::MAC) {
addWarning(SOP_MESSAGE, "MacCormack is unstable without a limiter");
}
} else if (str == "clamp") {
parms.mLimiter = openvdb::tools::Scheme::CLAMP;
} else if (str == "revert") {
parms.mLimiter = openvdb::tools::Scheme::REVERT;
} else {
throw std::runtime_error{"Invalid limiter scheme"};
}
}
}
hvdb::Interrupter boss("Advecting level set");
auto warningCallback = [this](const std::string& s) {
this->addWarning(SOP_MESSAGE, s.c_str());
};
if (parms.mStaggered) {
processGrids<openvdb::Vec3SGrid, true>(gdp, parms, boss, warningCallback);
} else {
processGrids<openvdb::Vec3SGrid, false>(gdp, parms, boss, warningCallback);
}
if (boss.wasInterrupted()) addWarning(SOP_MESSAGE, "Process was interrupted");
boss.end();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 25,098 | C++ | 37.319084 | 99 | 0.625946 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_LOD.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_LOD.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Generate one or more levels of a volume mipmap.
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb/tools/MultiResGrid.h>
#include <hboost/algorithm/string/join.hpp>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_LOD: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_LOD(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_LOD() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned input) const override { return (input > 0); }
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
};
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to be processed.")
.setDocumentation(
"A subset of the input VDB grids to be processed"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_ORD, "lod", "LOD Mode")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"single", "Single Level",
"range", "Level Range",
"mipmaps","LOD Pyramid"
})
.setDocumentation(
"How to build the LOD pyramid\n\n"
"Single Level:\n"
" Build a single, filtered VDB.\n\n"
"Level Range:\n"
" Build a series of VDBs of progressively lower resolution\n"
" within a given range of scales.\n\n"
"LOD Pyramid:\n"
" Build a standard pyramid of VDBs of decreasing resolution.\n"
" Each level of the pyramid is half the resolution in each\n"
" dimension of the previous level, starting with the input VDB.\n"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "level", "Level")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_UI, 10.0)
.setTooltip("Specify which single level to produce.\n"
"Level 0, the highest-resolution level, is the input VDB."));
{
const std::vector<fpreal> defaultRange{
fpreal(0.0), // start
fpreal(2.0), // end
fpreal(1.0) // step
};
parms.add(hutil::ParmFactory(PRM_FLT_J, "range", "Range")
.setDefault(defaultRange)
.setVectorSize(3)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_UI, 10.0)
.setTooltip(
"In Level Range mode, specify the (inclusive) starting and ending levels"
" and the level step. Level 0, the highest-resolution level, is the input VDB;"
" fractional levels are allowed."));
}
parms.add(hutil::ParmFactory(PRM_INT_J, "count", "Count")
.setDefault(PRMtwoDefaults)
.setRange(PRM_RANGE_RESTRICTED, 2, PRM_RANGE_UI, 10)
.setTooltip(
"In LOD Pyramid mode, specify the number of pyramid levels to generate."
" Each level is half the resolution of the previous level."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "reuse", "Preserve Grid Names")
.setDefault(PRMzeroDefaults)
.setTooltip(
"In Single Level mode, give the output VDB the same name as the input VDB."));
hvdb::OpenVDBOpFactory("VDB LOD", SOP_OpenVDB_LOD::factory, parms, *table)
.addInput("VDBs")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_LOD::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Build an LOD pyramid from a VDB volume.\"\"\"\n\
\n\
@overview\n\
\n\
This node creates filtered versions of a VDB volume at multiple resolutions,\n\
providing mipmap-like levels of detail.\n\
The low-resolution versions can be used both as thumbnails for fast processing\n\
and for constant-time, filtered lookups over large areas of a volume.\n\
\n\
@related\n\
- [OpenVDB Resample|Node:sop/DW_OpenVDBResample]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
bool
SOP_OpenVDB_LOD::updateParmsFlags()
{
bool changed = false;
const auto lodMode = evalInt("lod", 0, 0);
changed |= enableParm("level", lodMode == 0);
changed |= enableParm("reuse", lodMode == 0);
changed |= enableParm("range", lodMode == 1);
changed |= enableParm("count", lodMode == 2);
return changed;
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_LOD::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_LOD(net, name, op);
}
SOP_OpenVDB_LOD::SOP_OpenVDB_LOD(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
namespace {
template<openvdb::Index Order>
struct MultiResGridFractionalOp
{
MultiResGridFractionalOp(float f) : level(f) {}
template<typename GridType>
void operator()(const GridType& grid)
{
if ( level <= 0.0f ) {
outputGrid = typename GridType::Ptr( new GridType(grid) );
} else {
const size_t levels = openvdb::math::Ceil(level) + 1;
using TreeT = typename GridType::TreeType;
openvdb::tools::MultiResGrid<TreeT> mrg( levels, grid );
outputGrid = mrg.template createGrid<Order>( level );
}
}
const float level;
hvdb::GridPtr outputGrid;
};
template<openvdb::Index Order>
struct MultiResGridRangeOp
{
MultiResGridRangeOp(float start_, float end_, float step_, hvdb::Interrupter& boss_)
: start(start_), end(end_), step(step_), outputGrids(), boss(&boss_)
{}
template<typename GridType>
void operator()(const GridType& grid)
{
if ( end > 0.0f ) {
const size_t levels = openvdb::math::Ceil(end) + 1;
using TreeT = typename GridType::TreeType;
openvdb::tools::MultiResGrid<TreeT> mrg( levels, grid );
// inclusive range
for (float level = start; !(level > end); level += step) {
if (boss->wasInterrupted()) break;
outputGrids.push_back( mrg.template createGrid<Order>( level ) );
}
}
}
const float start, end, step;
std::vector<hvdb::GridPtr> outputGrids;
hvdb::Interrupter * const boss;
};
struct MultiResGridIntegerOp
{
MultiResGridIntegerOp(size_t n) : levels(n) {}
template<typename GridType>
void operator()(const GridType& grid)
{
using TreeT = typename GridType::TreeType;
openvdb::tools::MultiResGrid<TreeT> mrg( levels, grid );
outputGrids = mrg.grids();
}
const size_t levels;
openvdb::GridPtrVecPtr outputGrids;
};
inline bool
isValidRange(float start, float end, float step)
{
if (start < 0.0f || !(step > 0.0f) || end < 0.0f) {
return false;
}
return !(start > end);
}
}//unnamed namespace
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_LOD::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
// Get the group of grids to process.
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
std::vector<std::string> skipped;
hvdb::Interrupter boss("Creating VDB LoD pyramid");
GA_RWHandleS name_h(gdp, GA_ATTRIB_PRIMITIVE, "name");
const auto lodMode = evalInt("lod", 0, 0);
if (lodMode == 0) {
const bool reuseName = evalInt("reuse", 0, 0) > 0;
MultiResGridFractionalOp<1> op( float(evalFloat("level", 0, time)) );
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (boss.wasInterrupted()) return error();
if (name_h.isValid())
it->getGrid().setName(static_cast<const char *>(name_h.get(it->getMapOffset())));
if (!it->getGrid().transform().isLinear()) {
skipped.push_back(it->getGrid().getName());
continue;
}
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, op);
if (boss.wasInterrupted()) return error();
if (reuseName) op.outputGrid->setName( it->getGrid().getName() );
hvdb::createVdbPrimitive(*gdp, op.outputGrid);
gdp->destroyPrimitiveOffset(it->getMapOffset(), /*and_points=*/true);
}
} else if (lodMode == 1) {
const float start = float(evalFloat("range", 0, time));
const float end = float(evalFloat("range", 1, time));
const float step = float(evalFloat("range", 2, time));
if (!isValidRange(start, end, step)) {
addError(SOP_MESSAGE, "Invalid range, make sure that "
"start <= end and the step size is a positive number.");
return error();
}
MultiResGridRangeOp<1> op( start, end, step, boss );
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (boss.wasInterrupted()) return error();
if (name_h.isValid())
it->getGrid().setName(static_cast<const char *>(name_h.get(it->getMapOffset())));
if (!it->getGrid().transform().isLinear()) {
skipped.push_back(it->getGrid().getName());
continue;
}
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, op);
if (boss.wasInterrupted()) return error();
for (size_t i=0; i< op.outputGrids.size(); ++i) {
hvdb::createVdbPrimitive(*gdp, op.outputGrids[i]);
}
gdp->destroyPrimitiveOffset(it->getMapOffset(), /*and_points=*/true);
}
} else if (lodMode == 2) {
MultiResGridIntegerOp op( evalInt("count", 0, time) );
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (boss.wasInterrupted()) return error();
if (name_h.isValid())
it->getGrid().setName(static_cast<const char *>(name_h.get(it->getMapOffset())));
if (!it->getGrid().transform().isLinear()) {
skipped.push_back(it->getGrid().getName());
continue;
}
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, op);
if (boss.wasInterrupted()) return error();
for (size_t i=0; i< op.outputGrids->size(); ++i) {
hvdb::createVdbPrimitive(*gdp, op.outputGrids->at(i));
}
gdp->destroyPrimitiveOffset(it->getMapOffset(), /*and_points=*/true);
}
} else {
addError(SOP_MESSAGE, "Invalid LOD option.");
}
if (!skipped.empty()) {
addWarning(SOP_MESSAGE, ("Unable to process grid(s): " +
hboost::algorithm::join(skipped, ", ")).c_str());
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 11,730 | C++ | 30.199468 | 101 | 0.574339 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GEO_PrimVDB.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c) Side Effects Software Inc.
*
* Produced by:
* Side Effects Software Inc
* 477 Richmond Street West
* Toronto, Ontario
* Canada M5V 3E7
* 416-504-9876
*
* NAME: GEO_PrimVDB.C ( GEO Library, C++)
*
* COMMENTS: Base class for vdbs.
*/
#if defined(SESI_OPENVDB) || defined(SESI_OPENVDB_PRIM)
#include "GEO_PrimVDB.h"
#include <SYS/SYS_AtomicPtr.h>
#include <SYS/SYS_Math.h>
#include <SYS/SYS_MathCbrt.h>
#include <SYS/SYS_SharedMemory.h>
#include <UT/UT_Debug.h>
#include <UT/UT_Defines.h>
#include <UT/UT_EnvControl.h>
#include <UT/UT_FSATable.h>
#include <UT/UT_IStream.h>
#include <UT/UT_JSONParser.h>
#include <UT/UT_JSONValue.h>
#include <UT/UT_JSONWriter.h>
#include <UT/UT_Matrix.h>
#include <UT/UT_MatrixSolver.h>
#include <UT/UT_MemoryCounter.h>
#include <UT/UT_SharedMemoryManager.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_SparseArray.h>
#include <UT/UT_StackTrace.h>
#include <UT/UT_SysClone.h>
#include <UT/UT_UniquePtr.h>
#include "UT_VDBUtils.h"
#include <UT/UT_Vector.h>
#include <UT/UT_XformOrder.h>
#include <GA/GA_AttributeRefMap.h>
#include <GA/GA_AttributeRefMapDestHandle.h>
#include <GA/GA_Defragment.h>
#include <GA/GA_ElementWrangler.h>
#include <GA/GA_IntrinsicMacros.h>
#include <GA/GA_LoadMap.h>
#include <GA/GA_MergeMap.h>
#include <GA/GA_PrimitiveJSON.h>
#include <GA/GA_RangeMemberQuery.h>
#include <GA/GA_SaveMap.h>
#include <GA/GA_WeightedSum.h>
#include <GA/GA_WorkVertexBuffer.h>
#include <GEO/GEO_AttributeHandleList.h>
#include <GEO/GEO_Detail.h>
#include <GEO/GEO_PrimType.h>
#include <GEO/GEO_PrimVolume.h>
#include <GEO/GEO_VolumeOptions.h>
#include <GEO/GEO_WorkVertexBuffer.h>
#include <openvdb/io/Stream.h>
#include <openvdb/math/Maps.h>
#include <openvdb/tools/Composite.h>
#include <openvdb/tools/Interpolation.h>
#include <openvdb/tools/LevelSetMeasure.h>
#include <openvdb/tools/Statistics.h>
#include <openvdb/tools/VectorTransformer.h>
#include <iostream>
#include <stdexcept>
using namespace UT::Literal;
static const UT_StringHolder theKWVertex = "vertex"_sh;
static const UT_StringHolder theKWVDB = "vdb"_sh;
static const UT_StringHolder theKWVDBShm = "vdbshm"_sh;
static const UT_StringHolder theKWVDBVis = "vdbvis"_sh;
GEO_PrimVDB::UniqueId
GEO_PrimVDB::nextUniqueId()
{
static AtomicUniqueId theUniqueId;
return static_cast<UniqueId>(theUniqueId.add(1));
}
GEO_PrimVDB::GEO_PrimVDB(GEO_Detail *d, GA_Offset offset)
: GEO_Primitive(d, offset)
, myGridAccessor()
, myVis()
, myUniqueId(GEO_PrimVDB::nextUniqueId())
, myTreeUniqueId(GEO_PrimVDB::nextUniqueId())
, myMetadataUniqueId(GEO_PrimVDB::nextUniqueId())
, myTransformUniqueId(GEO_PrimVDB::nextUniqueId())
{
}
void
GEO_PrimVDB::stashed(bool beingstashed, GA_Offset offset)
{
// NB: Base class must be unstashed before we can call allocateVertex().
GEO_Primitive::stashed(beingstashed, offset);
if (!beingstashed)
{
// Reset to state as if freshly constructed
myVis = GEO_VolumeOptions();
myUniqueId.relaxedStore(GEO_PrimVDB::nextUniqueId());
myTreeUniqueId.relaxedStore(GEO_PrimVDB::nextUniqueId());
myMetadataUniqueId.relaxedStore(GEO_PrimVDB::nextUniqueId());
myTransformUniqueId.relaxedStore(GEO_PrimVDB::nextUniqueId());
}
else
{
// Free the grid and transform.
// This also makes sure that myGridAccessor will be
// as if freshly constructed when unstashing.
myGridAccessor.clear();
}
// Set our internal state to default
myVis = GEO_VolumeOptions(GEO_VOLUMEVIS_SMOKE, /*iso*/0.0, /*density*/1.0,
GEO_VOLUMEVISLOD_FULL);
}
bool
GEO_PrimVDB::evaluatePointRefMap(GA_Offset result_vtx,
GA_AttributeRefMap &map,
fpreal /*u*/, fpreal /*v*/,
uint /*du*/, uint /*dv*/) const
{
map.copyValue(GA_ATTRIB_VERTEX, result_vtx,
GA_ATTRIB_VERTEX, getVertexOffset(0));
return true;
}
// Houdini assumes that the depth scaling of the frustum is being done in the
// linear part of the NonlinearFrustumMap. This method ensures that if the
// grid has a frustum depth not equal to 1, then it returns an equivalent map
// which does.
static openvdb::math::NonlinearFrustumMap::ConstPtr
geoStandardFrustumMapPtr(const GEO_PrimVDB &vdb)
{
using namespace openvdb::math;
using openvdb::Vec3d;
const Transform &transform = vdb.getGrid().transform();
UT_ASSERT(transform.baseMap()->isType<NonlinearFrustumMap>());
NonlinearFrustumMap::ConstPtr
frustum_map = transform.constMap<NonlinearFrustumMap>();
// If the depth is already 1, then just return the original
OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
if (frustum_map->getDepth() == 1.0)
return frustum_map;
OPENVDB_NO_FP_EQUALITY_WARNING_END
AffineMap secondMap = frustum_map->secondMap();
secondMap.accumPreScale(Vec3d(1, 1, frustum_map->getDepth()));
return NonlinearFrustumMap::ConstPtr(
new NonlinearFrustumMap(frustum_map->getBBox(),
frustum_map->getTaper(),
/*depth*/1.0, secondMap.copy()));
}
// The returned space's fromVoxelSpace() method will convert 0-1
// coordinates over the bbox extents to world space (and vice versa for
// toVoxelSpace()).
GEO_PrimVolumeXform
GEO_PrimVDB::getSpaceTransform(const UT_BoundingBoxD &bbox) const
{
using namespace openvdb;
using namespace openvdb::math;
using openvdb::Vec3d;
using openvdb::Mat4d;
MapBase::ConstPtr base_map = getGrid().transform().baseMap();
BBoxd active_bbox(UTvdbConvert(bbox.minvec()),
UTvdbConvert(bbox.maxvec()));
UT_Matrix4D transform(1.0); // identity
fpreal new_taper(1.0); // no taper default
// If the active_bbox is empty(), we do not want to produce a singular
// matrix.
if (active_bbox.empty())
{
if (base_map->isType<NonlinearFrustumMap>())
{
// Ideally, we use getFrustumBounds() here but it returns the
// wrong type.
const NonlinearFrustumMap& frustum_map =
*getGrid().transform().constMap<NonlinearFrustumMap>();
active_bbox = frustum_map.getBBox();
active_bbox.translate(Vec3d(+0.5));
}
else
{
// Use a single voxel from index origin to act as a pass-through
active_bbox = BBoxd(Vec3d(0.0), 1.0);
}
}
// Shift the active_bbox by half a voxel to account for the fact that
// UT_VoxelArray's index coordinates are cell-centred while grid indices
// are cell edge-aligned.
active_bbox.translate(Vec3d(-0.5));
if (base_map->isType<NonlinearFrustumMap>())
{
// NOTES:
// - VDB's nonlinear frustum goes from index-space to world-space in
// two steps:
// 1. From index-space to NDC space where we have [-0.5,+0.5] XY
// on the Z=0 plane, tapered outwards to to the Z=1 plane
// (where depth=1).
// 2. Then the base_map->secondMap() is applied to convert it
// into world-space.
// - Our goal is to come up with an equivalent transform which goes
// from [-1,+1] unit-space to world-space, matching GEO_PrimVDB's
// node-centred samples with GEO_PrimVolume's cell-centered samples.
NonlinearFrustumMap::ConstPtr map_ptr = geoStandardFrustumMapPtr(*this);
const NonlinearFrustumMap& frustum_map = *map_ptr;
// Math below only handles NonlinearFrustumMap's with a depth of 1.
UT_ASSERT(frustum_map.getDepth() == 1);
BBoxd frustum_bbox = frustum_map.getBBox();
UT_Vector3D frustum_size(UTvdbConvert(frustum_bbox.extents()));
UT_Vector3D inv_frustum_size = 1.0 / frustum_size;
// Find active_bbox in the 1 by 1 -> taper by taper frustum
UT_Vector3D active_size(UTvdbConvert(active_bbox.extents()));
UT_Vector3D offset_uniform =
UTvdbConvert(active_bbox.min() - frustum_bbox.min())
* inv_frustum_size;
UT_Vector3 scale = active_size * inv_frustum_size;
// Compute the z coordinates of 'active_bbox' in the
// 0-1 space (normed to the frustum size)
fpreal z_min = offset_uniform.z();
fpreal z_max = offset_uniform.z() + scale.z();
// We need a new taper since active_bbox might have a different
// near/far plane ratio. The mag values are calculated using VDB's
// taper function but then we divide min by max because Houdini's taper
// ratio is inversed.
fpreal frustum_taper = frustum_map.getTaper();
fpreal gamma = 1.0/frustum_taper - 1.0;
fpreal mag_min = 1 + gamma * z_min;
fpreal mag_max = 1 + gamma * z_max;
new_taper = mag_min / mag_max;
// xform will go from 0-1 voxel space to the tapered, near=1x1 frustum
UT_Matrix4D xform(1);
xform.scale(mag_min, mag_min, 1.0);
xform.scale(0.5, 0.5, 0.5);
xform.scale(scale.x(), scale.y(), scale.z());
// Scale our correctly tapered box
// Offset the correctly scaled and tapered box into the right xy
// position.
OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
if (gamma != 0.0)
OPENVDB_NO_FP_EQUALITY_WARNING_END
{
// Scale by the inverse of the taper since NonlinearFrustumMap
// creates tapers in the -z direction (a positive taper will
// increase the ratio of the near / far) but only scales the far
// face (effectively, the +z face is scaled by 1 / taper and
// the -z face is kept at 1.0)
xform.scale(1.0 / new_taper, 1.0 / new_taper, 1.0);
// The distance from the near plane that the tapered frustum sides
// meet ie. the position of the z-plane that gets mapped to 0 in
// the taper map
fpreal z_i = 1.0 / gamma;
xform.translate(0, 0, z_i + z_min + 0.5 * scale.z());
// Compute the shear: it is the offset on the near plane of the
// current frustum to where we want it to be
UT_Vector3D frustum_center(0.5*frustum_size);
UT_Vector3D active_center(0.5*active_size);
// The current active_bbox position
UT_Vector3D bbox_offset = frustum_center - active_center;
// Compute the offset to the real position. We add back half-voxel
// so that the reference base is at the old min
UT_Vector3D shear = UTvdbConvert(active_bbox.min() + Vec3d(0.5))
- bbox_offset;
shear *= inv_frustum_size;
shear /= z_i;
xform.shear(0, shear.x(), shear.y());
// Translate ourselves back so that the tapered plane of
// frustum_bbox is at 0
xform.translate(0, 0, -z_i);
}
else
{
// Translate bottom corner of box to (0,0,0)
xform.translate(-0.5, -0.5, 0.0);
xform.translate(0.5*scale.x(), 0.5*scale.y(), 0.5*scale.z());
xform.translate(offset_uniform.x(),
offset_uniform.y(),
offset_uniform.z());
}
// `transform` now brings us from a tapered (1*y/x) box to world space,
// We want to go from a tapered, near=1x1 frustum to world space, so
// prescale by the aspect
fpreal aspect = frustum_bbox.extents().y() / frustum_bbox.extents().x();
xform.scale(1.0, aspect, 1.0);
Mat4d mat4 = frustum_map.secondMap().getMat4();
transform = xform * UTvdbConvert(mat4);
}
else
{
// NOTES:
// - VDB's grid transform goes from index-space to world-space.
// - Our goal is to come up with an equivalent transform which goes
// from [-1,+1] unit-space to world-space, matching GEO_PrimVDB's
// node-centred samples with GEO_PrimVolume's cell-centered samples.
// (NOTE: fromVoxelSpace() converts from [0,+1] to [-1,+1])
// Create transform which converts [-1,+1] unit-space to [0,+1]
transform.translate(1.0, 1.0, 1.0);
transform.scale(0.5, 0.5, 0.5);
// Go from the [0,1] volume space, to [min,max] where
// min and max are in the vdb index space. Note that UT_VoxelArray
// doesn't support negative coordinates which is why we need to shift
// the index origin to the bbox min.
transform.scale(active_bbox.extents().x(),
active_bbox.extents().y(),
active_bbox.extents().z());
transform.translate(active_bbox.min().x(),
active_bbox.min().y(),
active_bbox.min().z());
// Post-multiply by the affine map which converts index to world space
transform = transform * UTvdbConvert(base_map->getAffineMap()->getMat4());
}
UT_Vector3 translate;
transform.getTranslates(translate);
GEO_PrimVolumeXform result;
result.myXform = transform;
result.myCenter = translate;
OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
result.myHasTaper = (new_taper != 1.0);
OPENVDB_NO_FP_EQUALITY_WARNING_END
transform.invert();
result.myInverseXform = transform;
result.myTaperX = new_taper;
result.myTaperY = new_taper;
return result;
}
// Return a GEO_PrimVolumeXform which maps [-0.5,+0.5] Houdini voxel space
// coordinates over the VDB's active voxel bbox into world space.
GEO_PrimVolumeXform
GEO_PrimVDB::getSpaceTransform() const
{
const openvdb::CoordBBox bbox = getGrid().evalActiveVoxelBoundingBox();
return getSpaceTransform(UTvdbConvert(bbox));
}
bool
GEO_PrimVDB::conditionMatrix(UT_Matrix4D &mat4)
{
// This tolerance is just one factor larger than what
// AffineMap::updateAcceleration() uses to ensure that we never trigger the
// exception.
const double tol = 4.0 * openvdb::math::Tolerance<double>::value();
const double min_diag = SYScbrt(tol);
if (!SYSequalZero(mat4.determinant3(), tol))
{
// openvdb::math::simplify uses openvdb::math::isApproxEqual to detect
// uniform scaling, which has a more stringent tolerance than SYSisEqual.
// As a result we often have uniform voxel / axis aligned Volumes being
// converted to VDBs with Maps that are simplified to ScaleTranslate
// rather than UniformScaleTranslate. The latter is more correct, plus
// some operations (e.g. LevelSetMorph) don't work with non-Uniform
// scales. So we unify the diagonal if the diagonals are SYSisEqual,
// but not exactly equal.
if (SYSisEqual(mat4(0, 0), mat4(1, 1)) &&
SYSisEqual(mat4(0, 0), mat4(2, 2)) &&
!(mat4(0, 0) == mat4(1,1) && mat4(0, 0) == mat4(2,2)))
{
// Unify to mat(0, 0) like openvdb::math::simplify.
mat4(1, 1) = mat4(2, 2) = mat4(0, 0);
return true;
}
if (SYSalmostEqual((float)mat4(0, 0), (float)mat4(1, 1)) &&
SYSalmostEqual((float)mat4(0, 0), (float)mat4(2, 2)) &&
!(mat4(0, 0) == mat4(1,1) && mat4(0, 0) == mat4(2,2)))
{
// Unify to mat(0, 0) like openvdb::math::simplify.
mat4(1, 1) = mat4(2, 2) = mat4(0, 0);
return true;
}
return false;
}
UT_MatrixSolverD solver;
UT_Matrix3D mat3(mat4);
const int N = 3;
UT_MatrixD m(1,N, 1,N), v(1,N, 1,N), diag(1,N, 1,N), tmp(1,N, 1,N);
UT_VectorD w(1,N);
m.setSubmatrix3(1, 1, mat3);
if (!solver.SVDDecomp(m, w, v))
{
// Give up and return a scale matrix as small as possible
mat4.identity();
mat4.scale(min_diag, min_diag, min_diag);
}
else
{
v.transpose(tmp);
v = tmp;
diag.makeIdentity();
for (int i = 1; i <= N; i++)
diag(i,i) = SYSmax(min_diag, w(i));
m.postMult(diag, tmp);
tmp.postMult(v, m);
m.getSubmatrix3(mat3, 1, 1);
mat4 = mat3;
}
return true;
}
// All AffineMap creation must to through this to avoid crashes when passing
// singular matrices into OpenVDB
template<typename T>
static openvdb::SharedPtr<T>
geoCreateAffineMap(const UT_Matrix4D& mat4)
{
using namespace openvdb::math;
openvdb::SharedPtr<T> transform;
UT_Matrix4D new_mat4(mat4);
(void) GEO_PrimVDB::conditionMatrix(new_mat4);
try
{
transform.reset(new AffineMap(UTvdbConvert(new_mat4)));
}
catch (openvdb::ArithmeticError &)
{
// Fall back to trying to clear the last column first, since
// VDB seems to not like that, instead of falling back to identity.
new_mat4 = mat4;
new_mat4[0][3] = 0;
new_mat4[1][3] = 0;
new_mat4[2][3] = 0;
new_mat4[3][3] = 1;
(void) GEO_PrimVDB::conditionMatrix(new_mat4);
try
{
transform.reset(new AffineMap(UTvdbConvert(new_mat4)));
}
catch (openvdb::ArithmeticError &)
{
UT_ASSERT(!"Failed to create affine map");
transform.reset(new AffineMap());
}
}
return transform;
}
// All calls to createLinearTransform with a matrix4 must to through this to
// avoid crashes when passing singular matrices into OpenVDB
static openvdb::math::Transform::Ptr
geoCreateLinearTransform(const UT_Matrix4D& mat4)
{
using namespace openvdb::math;
return Transform::Ptr(new Transform(geoCreateAffineMap<MapBase>(mat4)));
}
void
GEO_PrimVDB::setSpaceTransform(
const GEO_PrimVolumeXform &space,
const UT_Vector3R &resolution,
bool force_taper)
{
using namespace openvdb;
using namespace openvdb::math;
using openvdb::Vec3d;
// VDB's nonlinear frustum goes from index-space to world-space in
// two steps:
// 1. From index-space to NDC space where we have [-0.5,+0.5] XY
// on the Z=0 plane, tapered outwards to to the Z=1 plane
// (where depth=1).
// 2. Then the base_map->secondMap() is applied to convert it
// into world-space.
// On the other hand, 'space' converts from [-1,+1] space over the given
// resolution into world-space.
//
// Our goal is to come up with an equivalent NonlinearTransformMap of
// 'space' which converts from index space to world-space, matching
// GEO_PrimVDB's node-centred samples with GEO_PrimVolume's cell-centered
// samples.
Transform::Ptr xform;
if (force_taper || space.myHasTaper)
{
// VDB only supports a single taper value so use average of the two
fpreal taper = 0.5*(space.myTaperX + space.myTaperY);
// Create a matrix which goes from vdb's post-taper XY(-0.5,+0.5) space
// to [-1,1] space so that we can post-multiply by space's transform to
// get into world-space.
//
// NonlinearFrustumMap use's 1/taper as its taper value, going from
// Z=0 to Z=1. So we first scale it by the taper to undo this.
UT_Matrix4D transform(1.0);
transform.scale(taper, taper, 1.0);
// Account for aspect ratio
transform.scale(1.0, resolution.x() / resolution.y(), 1.0);
// We now go from XY(-0.5,+0.5)/Z(0,1) to XY(-1,+1)/Z(2)
transform.scale(2.0, 2.0, 2.0);
// Translate into [-1,+1] on all axes by centering the Z axis
transform.translate(0.0, 0.0, -1.0);
// Now apply the space's linear transform
UT_Matrix4D linear;
linear = space.myXform; // convert UT_Matrix3 to UT_Matrix4
transform *= linear;
transform.translate(
space.myCenter.x(), space.myCenter.y(), space.myCenter.z());
// In order to get VDB to match Houdini, we create a frustum map using
// Houdini's bbox, so we offset by -0.5 voxel in order taper the
// Houdini bbox in VDB index space. This allows us to align Houdini's
// cell-centered samples with VDB node-centered ones.
BBoxd bbox(Vec3d(0.0), UTvdbConvert(resolution));
bbox.translate(Vec3d(-0.5));
// Build a NonlinearFrustumMap from this
MapBase::Ptr affine_map(geoCreateAffineMap<MapBase>(transform));
xform.reset(new Transform(MapBase::Ptr(
new NonlinearFrustumMap(bbox, taper, /*depth*/1.0, affine_map))));
}
else // optimize for a linear transform if we have no taper
{
// NOTES:
// - Houdini's transform goes from [-1,+1] unit-space to world-space.
// - VDB's grid transform goes from index-space to world-space.
UT_Matrix4D matx(/*identity*/1.0);
UT_Matrix4D mult;
// UT_VoxelArray's index coordinates are cell-centred while grid
// indices are cell edge-aligned. So first offset the VDB indices by
// +0.5 voxel to convert them into Houdini indices.
matx.translate(0.5, 0.5, 0.5);
// Now convert the indices from [0,dim] to [-1,+1]
matx.scale(2.0/resolution(0), 2.0/resolution(1), 2.0/resolution(2));
matx.translate(-1.0, -1.0, -1.0);
// Post-multiply with Houdini transform to get result that converts
// into world-space.
mult = space.myXform;
matx *= mult;
matx.translate(space.myCenter(0), space.myCenter(1), space.myCenter(2));
// Create a linear transform using the matrix
xform = geoCreateLinearTransform(matx);
}
myGridAccessor.setTransform(*xform, *this);
}
// This will give you the a GEO_PrimVolumeXform. Given an index, it will
// compute the world space position of that index.
GEO_PrimVolumeXform
GEO_PrimVDB::getIndexSpaceTransform() const
{
using namespace openvdb;
using namespace openvdb::math;
using openvdb::Vec3d;
using openvdb::Mat4d;
// This taper function follows from the conversion code in
// GEO_PrimVolume::fromVoxelSpace() until until myXform/myCenter is
// applied. It has been simplified somewhat, and uses the definition that
// gamma = taper - 1.
struct Local
{
static fpreal taper(fpreal x, fpreal z, fpreal gamma)
{
return 2 * (x - 0.5) * (1 + gamma * (1 - z));
}
};
fpreal new_taper = 1.0;
UT_Matrix4D transform(1.0); // identity
MapBase::ConstPtr base_map = getGrid().transform().baseMap();
if (base_map->isType<NonlinearFrustumMap>())
{
// NOTES:
// - VDB's nonlinear frustum goes from index-space to world-space in
// two steps:
// 1. From index-space to NDC space where we have [-0.5,+0.5] XY
// on the Z=0 plane, tapered outwards to to the Z=1 plane
// (where depth=1).
// 2. Then the base_map->secondMap() is applied to convert it
// into world-space.
// - Our goal is to come up with an equivalent GEO_PrimVolumeXform
// which goes from index-space to world-space, matching GEO_PrimVDB's
// node-centred samples with GEO_PrimVolume's cell-centered samples.
// - The gotcha here is that callers use fromVoxelSpace() which will
// first do a mapping of [0,1] to [-1,+1] which we need to undo.
NonlinearFrustumMap::ConstPtr map_ptr = geoStandardFrustumMapPtr(*this);
const NonlinearFrustumMap& frustum_map = *map_ptr;
// Math below only handles NonlinearFrustumMap's with a depth of 1.
UT_ASSERT(frustum_map.getDepth() == 1);
fpreal taper = frustum_map.getTaper();
// We need to create a taper value for fromVoxelSpace()'s incoming
// Houdini index space coordinate, so the bbox we want to taper with is
// actually the Houdini index bbox.
UT_BoundingBox bbox;
getFrustumBounds(bbox);
fpreal x = bbox.xsize();
fpreal y = bbox.ysize();
fpreal z = bbox.zsize();
Vec3d real_min(bbox.xmin(), bbox.ymin(), bbox.zmin());
Vec3d real_max(bbox.xmax(), bbox.ymax(), bbox.zmax());
// Compute a new taper based on the expected ratio of these two
// z positions
fpreal z_min = real_min.z();
fpreal z_max = real_max.z();
//
// If t = (1+g(1-a))/(1+g(1-b)) then g = (1-t)/(t(1-b) - (1-a))
// where t = taper; g = new_taper - 1, a = z_min, b = z_max;
//
fpreal new_gamma = (1 - taper) / (taper * (1 - z_max) - (1 - z_min));
new_taper = new_gamma + 1;
// Since we are tapering the index space, the taper map adds a
// scale and a shear so we find these and invert them
fpreal x_max_pos = Local::taper(real_max.x(), z_max, new_gamma);
fpreal x_min_pos = Local::taper(real_min.x(), z_max, new_gamma);
// Now, move x_max_pos = -x_min_pos with a shear
fpreal x_scale = x_max_pos - x_min_pos;
fpreal shear_x = 0.5 * x_scale - x_max_pos;
// Do the same for y
fpreal y_max_pos = Local::taper(real_max.y(), z_max, new_gamma);
fpreal y_min_pos = Local::taper(real_min.y(), z_max, new_gamma);
fpreal y_scale = y_max_pos - y_min_pos;
fpreal shear_y = 0.5 * y_scale - y_max_pos;
transform.translate(0, 0, -2*(z_min - 0.5));
// Scale z so that our frustum depth range is 0-1
transform.scale(1, 1, 0.5/z);
// Apply the shear
OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
if (taper != 1.0)
OPENVDB_NO_FP_EQUALITY_WARNING_END
{
fpreal z_i = 1.0 / (taper - 1);
transform.translate(0, 0, -z_i-1.0);
transform.shear(0, -shear_x / z_i, -shear_y / z_i);
transform.translate(0, 0, z_i+1.0);
}
else
{
transform.translate(shear_x, shear_y, 0.0);
}
transform.scale(1.0/x_scale, 1.0/y_scale, 1.0);
// Scale by 1/taper to convert taper definitions
transform.scale(1.0 / taper, 1.0 / taper, 1.0);
// Account for aspect ratio
transform.scale(1, y/x, 1);
Mat4d mat4 = frustum_map.secondMap().getMat4();
transform *= UTvdbConvert(mat4);
}
else
{
// We only deal with nonlinear maps that are frustum maps
UT_ASSERT(base_map->isLinear()
&& "Found unexpected nonlinear MapBase.");
// Since VDB's transform is already from index-space to world-space, we
// just need to undo the [0,1] -> [-1,+1] mapping that fromVoxelSpace()
// does before transforming by myXform/myCenter. The math is thus:
// scale(1/2)*translate(0.5)
// But we also want to shift VDB's node-centred samples to match
// GEO_PrimVolume's cell-centered ones so we want:
// scale(1/2)*translate(0.5)*translate(-0.5)
// This reduces down to just scale(1/2)
//
transform.scale(0.5, 0.5, 0.5);
transform *= UTvdbConvert(base_map->getAffineMap()->getMat4());
}
GEO_PrimVolumeXform result;
result.myXform = transform;
transform.getTranslates(result.myCenter);
OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
result.myHasTaper = (new_taper != 1.0);
OPENVDB_NO_FP_EQUALITY_WARNING_END
transform.invert();
result.myInverseXform = transform;
result.myTaperX = new_taper;
result.myTaperY = new_taper;
return result;
}
bool
GEO_PrimVDB::isSDF() const
{
if (getGrid().getGridClass() == openvdb::GRID_LEVEL_SET)
return true;
return false;
}
fpreal
GEO_PrimVDB::getTaper() const
{
return getSpaceTransform().myTaperX;
}
void
GEO_PrimVDB::reverse()
{
}
UT_Vector3
GEO_PrimVDB::computeNormal() const
{
return UT_Vector3(0, 0, 0);
}
template <typename GridType>
static void
geo_calcVolume(const GridType &grid, fpreal &volume)
{
bool calculated = false;
if (grid.getGridClass() == openvdb::GRID_LEVEL_SET) {
try {
volume = openvdb::tools::levelSetVolume(grid);
calculated = true;
} catch (std::exception& /*e*/) {
// do nothing
}
}
// Simply account for the total number of active voxels
if (!calculated) {
const openvdb::Vec3d size = grid.voxelSize();
volume = size[0] * size[1] * size[2] * grid.activeVoxelCount();
}
}
fpreal
GEO_PrimVDB::calcVolume(const UT_Vector3 &) const
{
fpreal volume = 0;
UTvdbCallAllTopology(getStorageType(), geo_calcVolume, getGrid(), volume);
return volume;
}
template <typename GridType>
static void
geo_calcArea(const GridType &grid, fpreal &area)
{
bool calculated = false;
if (grid.getGridClass() == openvdb::GRID_LEVEL_SET) {
try {
area = openvdb::tools::levelSetArea(grid);
calculated = true;
} catch (std::exception& /*e*/) {
// do nothing
}
}
if (!calculated) {
using LeafIter = typename GridType::TreeType::LeafCIter;
using VoxelIter = typename GridType::TreeType::LeafNodeType::ValueOnCIter;
using openvdb::Coord;
const Coord normals[] = {Coord(0,0,-1), Coord(0,0,1), Coord(-1,0,0),
Coord(1,0,0), Coord(0,-1,0), Coord(0,1,0)};
// NOTE: we assume rectangular prism voxels
openvdb::Vec3d voxel_size = grid.voxelSize();
const fpreal areas[] = {fpreal(voxel_size.x() * voxel_size.y()),
fpreal(voxel_size.x() * voxel_size.y()),
fpreal(voxel_size.y() * voxel_size.z()),
fpreal(voxel_size.y() * voxel_size.z()),
fpreal(voxel_size.z() * voxel_size.x()),
fpreal(voxel_size.z() * voxel_size.x())};
area = 0;
for (LeafIter leaf = grid.tree().cbeginLeaf(); leaf; ++leaf) {
// Visit all the active voxels in this leaf node.
for (VoxelIter iter = leaf->cbeginValueOn(); iter; ++iter) {
// Iterate through all the neighboring voxels
for (int i=0; i<6; i++)
if (!grid.tree().isValueOn(iter.getCoord() + normals[i])) area += areas[i];
}
}
}
}
fpreal
GEO_PrimVDB::calcArea() const
{
// Calculate the surface area of all the exterior voxels.
fpreal area = 0;
UTvdbCallAllTopology(getStorageType(), geo_calcArea, getGrid(), area);
return area;
}
void
GEO_PrimVDB::enlargePointBounds(UT_BoundingBox &box) const
{
UT_BoundingBox qbox;
if (getBBox(&qbox))
box.enlargeBounds(qbox);
}
bool
GEO_PrimVDB::enlargeBoundingBox(UT_BoundingRect &box,
const GA_Attribute *P) const
{
const GA_Detail &gdp = getDetail();
if (!P)
P = gdp.getP();
else if (P != gdp.getP())
return GEO_Primitive::enlargeBoundingBox(box, P);
UT_BoundingBox my_bbox;
if (getBBox(&my_bbox))
{
box.enlargeBounds(my_bbox.xmin(), my_bbox.ymin());
box.enlargeBounds(my_bbox.xmax(), my_bbox.ymax());
return true;
}
return true;
}
bool
GEO_PrimVDB::enlargeBoundingBox(UT_BoundingBox &box,
const GA_Attribute *P) const
{
const GA_Detail &gdp = getDetail();
if (!P)
P = gdp.getP();
else if (P != gdp.getP())
return GEO_Primitive::enlargeBoundingBox(box, P);
UT_BoundingBox my_bbox;
if (getBBox(&my_bbox))
{
box.enlargeBounds(my_bbox);
return true;
}
return true;
}
bool
GEO_PrimVDB::enlargeBoundingSphere(UT_BoundingSphere &sphere,
const GA_Attribute *P) const
{
const GA_Detail &gdp = getDetail();
if (!P)
P = gdp.getP();
else if (P != gdp.getP())
return GEO_Primitive::enlargeBoundingSphere(sphere, P);
addToBSphere(&sphere);
return true;
}
int64
GEO_PrimVDB::getBaseMemoryUsage() const
{
exint mem = 0;
if (hasGrid())
mem += getGrid().memUsage();
return mem;
}
void
GEO_PrimVDB::countBaseMemory(UT_MemoryCounter &counter) const
{
if (hasGrid())
{
// NOTE: We don't share the grid object or its transform
// We don't know what type of Grid we have, but apart from what's
// in GridBase, it just has a shared pointer to the tree extra,
// so just add that in separately.
counter.countUnshared(sizeof(openvdb::GridBase) + sizeof(openvdb::TreeBase::Ptr));
// We don't know what type of MapBase the Transform uses,
// so just guess the largest one
counter.countUnshared(sizeof(openvdb::math::Transform) + sizeof(openvdb::math::NonlinearFrustumMap));
// The grid's tree is shared. In order to get the reference count,
// we need to get our own shared pointer to it, then use one less
// than the ref count (ours counts as one).
exint refcount;
exint size;
const openvdb::TreeBase *ptr;
{
openvdb::TreeBase::ConstPtr ref = getGrid().constBaseTreePtr();
refcount = ref.use_count() - 1;
size = ref->memUsage();
ptr = ref.get();
}
counter.countShared(size, refcount, ptr);
}
}
template <typename GridType>
static inline typename GridType::ValueType
geo_doubleToGridValue(double val)
{
using ValueT = typename GridType::ValueType;
// This ugly construction avoids compiler warnings when,
// for example, initializing an openvdb::Vec3i with a double.
return ValueT(openvdb::zeroVal<ValueT>() + val);
}
template <typename GridType>
static fpreal
geo_sampleGrid(const GridType &grid, const UT_Vector3 &pos)
{
const openvdb::math::Transform & xform = grid.transform();
openvdb::math::Vec3d vpos;
typename GridType::ValueType value;
vpos = openvdb::math::Vec3d(pos.x(), pos.y(), pos.z());
vpos = xform.worldToIndex(vpos);
openvdb::tools::BoxSampler::sample(grid.tree(), vpos, value);
fpreal result = value;
return result;
}
template <typename GridType>
static fpreal
geo_sampleBoolGrid(const GridType &grid, const UT_Vector3 &pos)
{
const openvdb::math::Transform & xform = grid.transform();
openvdb::math::Vec3d vpos;
typename GridType::ValueType value;
vpos = openvdb::math::Vec3d(pos.x(), pos.y(), pos.z());
vpos = xform.worldToIndex(vpos);
openvdb::tools::PointSampler::sample(grid.tree(), vpos, value);
fpreal result = value;
return result;
}
template <typename GridType>
static UT_Vector3D
geo_sampleGridV3(const GridType &grid, const UT_Vector3 &pos)
{
const openvdb::math::Transform & xform = grid.transform();
openvdb::math::Vec3d vpos;
typename GridType::ValueType value;
vpos = openvdb::math::Vec3d(pos.x(), pos.y(), pos.z());
vpos = xform.worldToIndex(vpos);
openvdb::tools::BoxSampler::sample(grid.tree(), vpos, value);
UT_Vector3D result;
result.x() = double(value[0]);
result.y() = double(value[1]);
result.z() = double(value[2]);
return result;
}
template <typename GridType, typename T, typename IDX>
static void
geo_sampleGridMany(const GridType &grid,
T *f, int stride,
const IDX *pos,
int num)
{
typename GridType::ConstAccessor accessor = grid.getAccessor();
const openvdb::math::Transform & xform = grid.transform();
openvdb::math::Vec3d vpos;
typename GridType::ValueType value;
for (int i = 0; i < num; i++)
{
vpos = openvdb::math::Vec3d(pos[i].x(), pos[i].y(), pos[i].z());
vpos = xform.worldToIndex(vpos);
openvdb::tools::BoxSampler::sample(accessor, vpos, value);
*f = T(value);
f += stride;
}
}
template <typename GridType, typename T, typename IDX>
static void
geo_sampleBoolGridMany(const GridType &grid,
T *f, int stride,
const IDX *pos,
int num)
{
typename GridType::ConstAccessor accessor = grid.getAccessor();
const openvdb::math::Transform & xform = grid.transform();
openvdb::math::Vec3d vpos;
typename GridType::ValueType value;
for (int i = 0; i < num; i++)
{
vpos = openvdb::math::Vec3d(pos[i].x(), pos[i].y(), pos[i].z());
vpos = xform.worldToIndex(vpos);
openvdb::tools::PointSampler::sample(accessor, vpos, value);
*f = T(value);
f += stride;
}
}
template <typename GridType, typename T, typename IDX>
static void
geo_sampleVecGridMany(const GridType &grid,
T *f, int stride,
const IDX *pos,
int num)
{
typename GridType::ConstAccessor accessor = grid.getAccessor();
const openvdb::math::Transform & xform = grid.transform();
openvdb::math::Vec3d vpos;
typename GridType::ValueType value;
for (int i = 0; i < num; i++)
{
vpos = openvdb::math::Vec3d(pos[i].x(), pos[i].y(), pos[i].z());
vpos = xform.worldToIndex(vpos);
openvdb::tools::BoxSampler::sample(accessor, vpos, value);
f->x() = value[0];
f->y() = value[1];
f->z() = value[2];
f += stride;
}
}
static fpreal
geoEvaluateVDB(const GEO_PrimVDB *vdb, const UT_Vector3 &pos)
{
UTvdbReturnScalarType(vdb->getStorageType(), geo_sampleGrid, vdb->getGrid(), pos);
UTvdbReturnBoolType(vdb->getStorageType(), geo_sampleBoolGrid, vdb->getGrid(), pos);
return 0;
}
static UT_Vector3D
geoEvaluateVDB_V3(const GEO_PrimVDB *vdb, const UT_Vector3 &pos)
{
UTvdbReturnVec3Type(vdb->getStorageType(),
geo_sampleGridV3, vdb->getGrid(), pos);
return UT_Vector3D(0, 0, 0);
}
static void
geoEvaluateVDBMany(const GEO_PrimVDB *vdb, float *f, int stride, const UT_Vector3 *pos, int num)
{
UTvdbReturnScalarType(vdb->getStorageType(),
geo_sampleGridMany, vdb->getGrid(), f, stride, pos, num);
UTvdbReturnBoolType(vdb->getStorageType(),
geo_sampleBoolGridMany, vdb->getGrid(), f, stride, pos, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateVDBMany(const GEO_PrimVDB *vdb, int *f, int stride, const UT_Vector3 *pos, int num)
{
UTvdbReturnScalarType(vdb->getStorageType(),
geo_sampleGridMany, vdb->getGrid(), f, stride, pos, num);
UTvdbReturnBoolType(vdb->getStorageType(),
geo_sampleBoolGridMany, vdb->getGrid(), f, stride, pos, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateVDBMany(const GEO_PrimVDB *vdb, UT_Vector3 *f, int stride, const UT_Vector3 *pos, int num)
{
UTvdbReturnVec3Type(vdb->getStorageType(),
geo_sampleVecGridMany, vdb->getGrid(), f, stride, pos, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateVDBMany(const GEO_PrimVDB *vdb, double *f, int stride, const UT_Vector3D *pos, int num)
{
UTvdbReturnScalarType(vdb->getStorageType(),
geo_sampleGridMany, vdb->getGrid(), f, stride, pos, num);
UTvdbReturnBoolType(vdb->getStorageType(),
geo_sampleBoolGridMany, vdb->getGrid(), f, stride, pos, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateVDBMany(const GEO_PrimVDB *vdb, exint *f, int stride, const UT_Vector3D *pos, int num)
{
UTvdbReturnScalarType(vdb->getStorageType(),
geo_sampleGridMany, vdb->getGrid(), f, stride, pos, num);
UTvdbReturnBoolType(vdb->getStorageType(),
geo_sampleBoolGridMany, vdb->getGrid(), f, stride, pos, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateVDBMany(const GEO_PrimVDB *vdb, UT_Vector3D *f, int stride, const UT_Vector3D *pos, int num)
{
UTvdbReturnVec3Type(vdb->getStorageType(),
geo_sampleVecGridMany, vdb->getGrid(), f, stride, pos, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
fpreal
GEO_PrimVDB::getValueF(const UT_Vector3 &pos) const
{
return geoEvaluateVDB(this, pos);
}
UT_Vector3D
GEO_PrimVDB::getValueV3(const UT_Vector3 &pos) const
{
return geoEvaluateVDB_V3(this, pos);
}
void
GEO_PrimVDB::getValues(float *f, int stride, const UT_Vector3 *pos, int num) const
{
return geoEvaluateVDBMany(this, f, stride, pos, num);
}
void
GEO_PrimVDB::getValues(int *f, int stride, const UT_Vector3 *pos, int num) const
{
return geoEvaluateVDBMany(this, f, stride, pos, num);
}
void
GEO_PrimVDB::getValues(UT_Vector3 *f, int stride, const UT_Vector3 *pos, int num) const
{
return geoEvaluateVDBMany(this, f, stride, pos, num);
}
void
GEO_PrimVDB::getValues(double *f, int stride, const UT_Vector3D *pos, int num) const
{
return geoEvaluateVDBMany(this, f, stride, pos, num);
}
void
GEO_PrimVDB::getValues(exint *f, int stride, const UT_Vector3D *pos, int num) const
{
return geoEvaluateVDBMany(this, f, stride, pos, num);
}
void
GEO_PrimVDB::getValues(UT_Vector3D *f, int stride, const UT_Vector3D *pos, int num) const
{
return geoEvaluateVDBMany(this, f, stride, pos, num);
}
namespace // anonymous
{
template <bool NORMALIZE>
class geo_EvalGradients
{
public:
geo_EvalGradients(
UT_Vector3 *gradients,
int stride,
const UT_Vector3 *positions,
int num_positions)
: myGradients(gradients)
, myStride(stride)
, myPos(positions)
, myNumPos(num_positions)
{
}
template<typename GridT>
void operator()(const GridT &grid)
{
using namespace openvdb;
using AccessorT = typename GridT::ConstAccessor;
using ValueT = typename GridT::ValueType;
const math::Transform & xform = grid.transform();
const math::Vec3d dim = grid.voxelSize();
const double vox_size = SYSmin(dim[0], dim[1], dim[2]);
const double h = 0.5 * vox_size;
const math::Vec3d mask[] =
{ math::Vec3d(h, 0, 0)
, math::Vec3d(0, h, 0)
, math::Vec3d(0, 0, h)
};
AccessorT accessor = grid.getConstAccessor();
UT_Vector3 * gradient = myGradients;
for (int i = 0; i < myNumPos; i++, gradient += myStride)
{
const math::Vec3d pos(myPos[i].x(), myPos[i].y(), myPos[i].z());
for (int j = 0; j < 3; j++)
{
const math::Vec3d vpos0 = xform.worldToIndex(pos - mask[j]);
const math::Vec3d vpos1 = xform.worldToIndex(pos + mask[j]);
ValueT v0, v1;
tools::BoxSampler::sample<AccessorT>(accessor, vpos0, v0);
tools::BoxSampler::sample<AccessorT>(accessor, vpos1, v1);
if (NORMALIZE)
(*gradient)(j) = (v1 - v0);
else
(*gradient)(j) = (v1 - v0) / vox_size;
}
if (NORMALIZE)
gradient->normalize();
}
}
private:
UT_Vector3 * myGradients;
int myStride;
const UT_Vector3 * myPos;
int myNumPos;
};
} // namespace anonymous
bool
GEO_PrimVDB::evalGradients(
UT_Vector3 *gradients,
int stride,
const UT_Vector3 *pos,
int num_pos,
bool normalize) const
{
if (normalize)
{
geo_EvalGradients<true> eval(gradients, stride, pos, num_pos);
return UTvdbProcessTypedGridScalar(getStorageType(), getGrid(), eval);
}
else
{
geo_EvalGradients<false> eval(gradients, stride, pos, num_pos);
return UTvdbProcessTypedGridScalar(getStorageType(), getGrid(), eval);
}
}
bool
GEO_PrimVDB::isAligned(const GEO_PrimVDB *vdb) const
{
if (getGrid().transform() == vdb->getGrid().transform())
return true;
return false;
}
bool
GEO_PrimVDB::isWorldAxisAligned() const
{
// Tapered are trivially not aligned.
if (!SYSisEqual(getTaper(), 1))
return false;
UT_Matrix4D x;
x = getTransform4();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (i == j)
{
if (x(i, j) <= 0)
return false;
}
else
{
if (x(i,j) != 0)
return false;
}
}
}
return true;
}
bool
GEO_PrimVDB::isActiveRegionMatched(const GEO_PrimVDB *vdb) const
{
if (!isAligned(vdb))
return false;
// Ideally we'd invoke hasSameTopology?
return vdb->getGrid().baseTreePtr() == getGrid().baseTreePtr();
}
void
GEO_PrimVDB::indexToPos(int x, int y, int z, UT_Vector3 &pos) const
{
openvdb::math::Vec3d vpos;
vpos = openvdb::math::Vec3d(x, y, z);
vpos = getGrid().indexToWorld(vpos);
pos = UT_Vector3(vpos[0], vpos[1], vpos[2]);
}
void
GEO_PrimVDB::findexToPos(UT_Vector3 idx, UT_Vector3 &pos) const
{
openvdb::math::Vec3d vpos;
vpos = openvdb::math::Vec3d(idx.x(), idx.y(), idx.z());
vpos = getGrid().indexToWorld(vpos);
pos = UT_Vector3(vpos[0], vpos[1], vpos[2]);
}
void
GEO_PrimVDB::posToIndex(UT_Vector3 pos, int &x, int &y, int &z) const
{
openvdb::math::Vec3d vpos(pos.data());
openvdb::math::Coord
coord = getGrid().transform().worldToIndexCellCentered(vpos);
x = coord.x();
y = coord.y();
z = coord.z();
}
void
GEO_PrimVDB::posToIndex(UT_Vector3 pos, UT_Vector3 &index) const
{
openvdb::math::Vec3d vpos;
vpos = openvdb::math::Vec3d(pos.x(), pos.y(), pos.z());
vpos = getGrid().worldToIndex(vpos);
index = UTvdbConvert(vpos);
}
void
GEO_PrimVDB::indexToPos(exint x, exint y, exint z, UT_Vector3D &pos) const
{
openvdb::math::Vec3d vpos;
vpos = openvdb::math::Vec3d(x, y, z);
vpos = getGrid().indexToWorld(vpos);
pos = UT_Vector3D(vpos[0], vpos[1], vpos[2]);
}
void
GEO_PrimVDB::findexToPos(UT_Vector3D idx, UT_Vector3D &pos) const
{
openvdb::math::Vec3d vpos;
vpos = openvdb::math::Vec3d(idx.x(), idx.y(), idx.z());
vpos = getGrid().indexToWorld(vpos);
pos = UT_Vector3D(vpos[0], vpos[1], vpos[2]);
}
void
GEO_PrimVDB::posToIndex(UT_Vector3D pos, exint &x, exint &y, exint &z) const
{
openvdb::math::Vec3d vpos(pos.data());
openvdb::math::Coord
coord = getGrid().transform().worldToIndexCellCentered(vpos);
x = coord.x();
y = coord.y();
z = coord.z();
}
void
GEO_PrimVDB::posToIndex(UT_Vector3D pos, UT_Vector3D &index) const
{
openvdb::math::Vec3d vpos;
vpos = openvdb::math::Vec3d(pos.x(), pos.y(), pos.z());
vpos = getGrid().worldToIndex(vpos);
index = UTvdbConvert(vpos);
}
template <typename GridType>
static fpreal
geo_sampleIndex(const GridType &grid, int ix, int iy, int iz)
{
openvdb::math::Coord xyz;
typename GridType::ValueType value;
xyz = openvdb::math::Coord(ix, iy, iz);
value = grid.tree().getValue(xyz);
fpreal result = value;
return result;
}
template <typename GridType>
static UT_Vector3D
geo_sampleIndexV3(const GridType &grid, int ix, int iy, int iz)
{
openvdb::math::Coord xyz;
typename GridType::ValueType value;
xyz = openvdb::math::Coord(ix, iy, iz);
value = grid.tree().getValue(xyz);
UT_Vector3D result;
result.x() = double(value[0]);
result.y() = double(value[1]);
result.z() = double(value[2]);
return result;
}
template <typename GridType, typename T, typename IDX>
static void
geo_sampleIndexMany(const GridType &grid,
T *f, int stride,
const IDX *ix, const IDX *iy, const IDX *iz,
int num)
{
typename GridType::ConstAccessor accessor = grid.getAccessor();
openvdb::math::Coord xyz;
typename GridType::ValueType value;
for (int i = 0; i < num; i++)
{
xyz = openvdb::math::Coord(ix[i], iy[i], iz[i]);
value = accessor.getValue(xyz);
*f = T(value);
f += stride;
}
}
template <typename GridType, typename T, typename IDX>
static void
geo_sampleVecIndexMany(const GridType &grid,
T *f, int stride,
const IDX *ix, const IDX *iy, const IDX *iz,
int num)
{
typename GridType::ConstAccessor accessor = grid.getAccessor();
openvdb::math::Coord xyz;
typename GridType::ValueType value;
for (int i = 0; i < num; i++)
{
xyz = openvdb::math::Coord(ix[i], iy[i], iz[i]);
value = accessor.getValue(xyz);
f->x() = value[0];
f->y() = value[1];
f->z() = value[2];
f += stride;
}
}
static fpreal
geoEvaluateIndexVDB(const GEO_PrimVDB *vdb,
int ix, int iy, int iz)
{
UTvdbReturnScalarType(vdb->getStorageType(),
geo_sampleIndex, vdb->getGrid(), ix, iy, iz);
return 0.0;
}
static UT_Vector3D
geoEvaluateIndexVDB_V3(const GEO_PrimVDB *vdb,
int ix, int iy, int iz)
{
UTvdbReturnVec3Type(vdb->getStorageType(),
geo_sampleIndexV3, vdb->getGrid(), ix, iy, iz);
return UT_Vector3D(0.0, 0, 0);
}
static void
geoEvaluateIndexVDBMany(const GEO_PrimVDB *vdb,
float *f, int stride,
const int *ix, const int *iy, const int *iz,
int num)
{
UTvdbReturnScalarType(vdb->getStorageType(),
geo_sampleIndexMany, vdb->getGrid(), f, stride, ix, iy, iz, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateIndexVDBMany(const GEO_PrimVDB *vdb,
int *f, int stride,
const int *ix, const int *iy, const int *iz,
int num)
{
UTvdbReturnScalarType(vdb->getStorageType(),
geo_sampleIndexMany, vdb->getGrid(), f, stride, ix, iy, iz, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateIndexVDBMany(const GEO_PrimVDB *vdb,
UT_Vector3 *f, int stride,
const int *ix, const int *iy, const int *iz,
int num)
{
UTvdbReturnVec3Type(vdb->getStorageType(),
geo_sampleVecIndexMany, vdb->getGrid(), f, stride, ix, iy, iz, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateIndexVDBMany(const GEO_PrimVDB *vdb,
double *f, int stride,
const exint *ix, const exint *iy, const exint *iz,
int num)
{
UTvdbReturnScalarType(vdb->getStorageType(),
geo_sampleIndexMany, vdb->getGrid(), f, stride, ix, iy, iz, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateIndexVDBMany(const GEO_PrimVDB *vdb,
exint *f, int stride,
const exint *ix, const exint *iy, const exint *iz,
int num)
{
UTvdbReturnScalarType(vdb->getStorageType(),
geo_sampleIndexMany, vdb->getGrid(), f, stride, ix, iy, iz, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
static void
geoEvaluateIndexVDBMany(const GEO_PrimVDB *vdb,
UT_Vector3D *f, int stride,
const exint *ix, const exint *iy, const exint *iz,
int num)
{
UTvdbReturnVec3Type(vdb->getStorageType(),
geo_sampleVecIndexMany, vdb->getGrid(), f, stride, ix, iy, iz, num);
for (int i = 0; i < num; i++)
{
*f = 0;
f += stride;
}
}
fpreal
GEO_PrimVDB::getValueAtIndexF(int ix, int iy, int iz) const
{
return geoEvaluateIndexVDB(this, ix, iy, iz);
}
UT_Vector3D
GEO_PrimVDB::getValueAtIndexV3(int ix, int iy, int iz) const
{
return geoEvaluateIndexVDB_V3(this, ix, iy, iz);
}
void
GEO_PrimVDB::getValuesAtIndices(float *f, int stride, const int *ix, const int *iy, const int *iz, int num) const
{
geoEvaluateIndexVDBMany(this, f, stride, ix, iy, iz, num);
}
void
GEO_PrimVDB::getValuesAtIndices(int *f, int stride, const int *ix, const int *iy, const int *iz, int num) const
{
geoEvaluateIndexVDBMany(this, f, stride, ix, iy, iz, num);
}
void
GEO_PrimVDB::getValuesAtIndices(UT_Vector3 *f, int stride, const int *ix, const int *iy, const int *iz, int num) const
{
geoEvaluateIndexVDBMany(this, f, stride, ix, iy, iz, num);
}
void
GEO_PrimVDB::getValuesAtIndices(double *f, int stride, const exint *ix, const exint *iy, const exint *iz, int num) const
{
geoEvaluateIndexVDBMany(this, f, stride, ix, iy, iz, num);
}
void
GEO_PrimVDB::getValuesAtIndices(exint *f, int stride, const exint *ix, const exint *iy, const exint *iz, int num) const
{
geoEvaluateIndexVDBMany(this, f, stride, ix, iy, iz, num);
}
void
GEO_PrimVDB::getValuesAtIndices(UT_Vector3D *f, int stride, const exint *ix, const exint *iy, const exint *iz, int num) const
{
geoEvaluateIndexVDBMany(this, f, stride, ix, iy, iz, num);
}
UT_Vector3
GEO_PrimVDB::getGradient(const UT_Vector3 &pos) const
{
UT_Vector3 grad;
grad = 0;
evalGradients(&grad, 1, &pos, 1, false);
return grad;
}
////////////////////////////////////////
namespace {
// Functor for use with UTvdbProcessTypedGridVec3() to apply a transform
// to the voxel values of vector-valued grids
struct gu_VecXformOp
{
openvdb::Mat4d mat;
gu_VecXformOp(const openvdb::Mat4d& _mat): mat(_mat) {}
template<typename GridT> void operator()(GridT& grid) const
{
openvdb::tools::transformVectors(grid, mat);
}
};
} // unnamed namespace
void
GEO_PrimVDB::transform(const UT_Matrix4 &mat)
{
if (!hasGrid()) return;
try {
using openvdb::GridBase;
using namespace openvdb::math;
// Get the transform
const GridBase& const_grid = getConstGrid();
MapBase::ConstPtr base_map = const_grid.transform().baseMap();
Mat4d base_mat4 = base_map->getAffineMap()->getMat4();
// Get the 3x3 subcomponent of the matrix
Vec3d translation = base_mat4.getTranslation();
Mat3d vdbmatrix = base_mat4.getMat3();
// Multiply our mat with the mat3
UT_Matrix3D transformed(mat);
transformed = UTvdbConvert(vdbmatrix) * transformed;
// Put it into a mat4 and translate it
UT_Matrix4D final;
final = transformed;
final.setTranslates(UTvdbConvert(translation));
// Make an affine matrix out of it
AffineMap::Ptr map(geoCreateAffineMap<AffineMap>(final));
// Set the affine matrix from our base_map into this map
MapBase::Ptr result = simplify(map);
if (base_map->isType<NonlinearFrustumMap>()) {
const NonlinearFrustumMap& frustum_map =
*const_grid.transform().constMap<NonlinearFrustumMap>();
MapBase::Ptr new_frustum_map (new NonlinearFrustumMap(
frustum_map.getBBox(),
frustum_map.getTaper(),
frustum_map.getDepth(),
result));
result = new_frustum_map;
}
// This sets the vertex position to `translation` as well
myGridAccessor.setTransform(Transform(result), *this);
// If (and only if) the grid is vector-valued, apply the transform to
// each voxel's value.
if (const_grid.getVectorType() != openvdb::VEC_INVARIANT) {
gu_VecXformOp op(UTvdbConvert(UT_Matrix4D(mat)));
GEOvdbProcessTypedGridVec3(*this, op, /*make_unique*/true);
}
} catch (std::exception& /*e*/) {
UT_ASSERT(!"Failed to apply transform");
}
}
void
GEO_PrimVDB::copyGridFrom(const GEO_PrimVDB& src_prim, bool copyPosition)
{
setGrid(src_prim.getGrid(), copyPosition); // makes a shallow copy
// Copy the source primitive's grid serial numbers.
myTreeUniqueId.exchange(src_prim.getTreeUniqueId());
myMetadataUniqueId.exchange(src_prim.getMetadataUniqueId());
myTransformUniqueId.exchange(src_prim.getTransformUniqueId());
}
// If myGrid's tree is shared, replace the tree with a deep copy of itself.
// Note: myGrid's metadata and transform are assumed to never be shared
// (see setGrid()).
void
GEO_PrimVDB::GridAccessor::makeGridUnique()
{
if (myGrid) {
UT_ASSERT(myGrid.unique());
openvdb::TreeBase::Ptr localTreePtr = myGrid->baseTreePtr();
if (localTreePtr.use_count() > 2) { // myGrid + localTreePtr = 2
myGrid->setTree(myGrid->constBaseTree().copy());
}
}
}
bool
GEO_PrimVDB::GridAccessor::isGridUnique() const
{
if (myGrid) {
// We require the grid to always be unique, it is the tree
// that is allowed to be shared.
UT_ASSERT(myGrid.unique());
openvdb::TreeBase::Ptr localTreePtr = myGrid->baseTreePtr();
if (localTreePtr.use_count() > 2) { // myGrid + localTreePtr = 2
return false;
}
return true;
}
// Empty grids are trivially unique
return true;
}
void
GEO_PrimVDB::setTransform4(const UT_Matrix4 &xform4)
{
setTransform4(static_cast<UT_DMatrix4>(xform4));
}
void
GEO_PrimVDB::setTransform4(const UT_DMatrix4 &xform4)
{
using namespace openvdb::math;
myGridAccessor.setTransform(*geoCreateLinearTransform(xform4), *this);
}
void
GEO_PrimVDB::getRes(int &rx, int &ry, int &rz) const
{
using namespace openvdb;
const GridBase & grid = getGrid();
const math::Vec3d dim = grid.evalActiveVoxelDim().asVec3d();
rx = static_cast<int>(dim[0]);
ry = static_cast<int>(dim[1]);
rz = static_cast<int>(dim[2]);
}
fpreal
GEO_PrimVDB::getVoxelDiameter() const
{
UT_Vector3 p1, p2;
indexToPos(0, 0, 0, p1);
indexToPos(1, 1, 1, p2);
p2 -= p1;
return p2.length();
}
UT_Vector3
GEO_PrimVDB::getVoxelSize() const
{
UT_Vector3 p1, p2;
UT_Vector3 vsize;
indexToPos(0, 0, 0, p1);
indexToPos(1, 0, 0, p2);
p2 -= p1;
vsize.x() = p2.length();
indexToPos(0, 1, 0, p2);
p2 -= p1;
vsize.y() = p2.length();
indexToPos(0, 0, 1, p2);
p2 -= p1;
vsize.z() = p2.length();
return vsize;
}
template <typename GridType>
static void
geo_calcMinVDB( GridType &grid,
fpreal &result)
{
auto val = openvdb::tools::extrema(grid.cbeginValueOn());
result = val.min();
}
fpreal
GEO_PrimVDB::calcMinimum() const
{
fpreal value = SYS_FPREAL_MAX;
UTvdbCallScalarType( getStorageType(),
geo_calcMinVDB,
SYSconst_cast(getConstGrid()),
value);
return value;
}
template <typename GridType>
static void
geo_calcMaxVDB( GridType &grid,
fpreal &result)
{
auto val = openvdb::tools::extrema(grid.cbeginValueOn());
result = val.max();
}
fpreal
GEO_PrimVDB::calcMaximum() const
{
fpreal value = -SYS_FPREAL_MAX;
UTvdbCallScalarType( getStorageType(),
geo_calcMaxVDB,
SYSconst_cast(getConstGrid()),
value);
return value;
}
template <typename GridType>
static void
geo_calcAvgVDB( GridType &grid,
fpreal &result)
{
auto val = openvdb::tools::statistics(grid.cbeginValueOn());
result = val.avg();
}
fpreal
GEO_PrimVDB::calcAverage() const
{
fpreal value = 0;
UTvdbCallScalarType( getStorageType(),
geo_calcAvgVDB,
SYSconst_cast(getConstGrid()),
value);
return value;
}
bool
GEO_PrimVDB::getFrustumBounds(UT_BoundingBox &idxbox) const
{
using namespace openvdb;
using namespace openvdb::math;
using openvdb::CoordBBox;
using openvdb::Vec3d;
idxbox.makeInvalid();
// See if we have a non-linear map, this is the sign
// we want to be bounded.
MapBase::ConstPtr base_map = getGrid().transform().baseMap();
if (base_map->isType<NonlinearFrustumMap>())
{
const NonlinearFrustumMap& frustum_map =
*getGrid().transform().constMap<NonlinearFrustumMap>();
// The returned idxbox is intended to be used with
// getIndexSpaceTransform() which will shift it by -0.5 voxel. So we
// need to add +0.5 to compensate.
BBoxd bbox = frustum_map.getBBox();
bbox.translate(Vec3d(+0.5));
idxbox.initBounds( UTvdbConvert(bbox.min()) );
idxbox.enlargeBounds( UTvdbConvert(bbox.max()) );
return true;
}
return false;
}
static bool
geoGetFrustumBoundsFromVDB(const GEO_PrimVDB *vdb, openvdb::CoordBBox &box)
{
using namespace openvdb;
UT_BoundingBox clip;
bool doclip;
doclip = vdb->getFrustumBounds(clip);
if (doclip)
{
box = CoordBBox( Coord( (int)SYSrint(clip.xmin()), (int)SYSrint(clip.ymin()), (int)SYSrint(clip.zmin()) ),
Coord( (int)SYSrint(clip.xmax()), (int)SYSrint(clip.ymax()), (int)SYSrint(clip.zmax()) ) );
}
return doclip;
}
// The result of the intersection of active regions goes into grid_a
template <typename GridTypeA, typename GridTypeB>
static void
geoIntersect(GridTypeA& grid_a, const GridTypeB &grid_b)
{
typename GridTypeA::Accessor access_a = grid_a.getAccessor();
typename GridTypeB::ConstAccessor access_b = grid_b.getAccessor();
// For each on value in a, set it off if b is also off
for (typename GridTypeA::ValueOnCIter
iter = grid_a.cbeginValueOn(); iter; ++iter)
{
openvdb::CoordBBox bbox = iter.getBoundingBox();
for (int k=bbox.min().z(); k<=bbox.max().z(); k++)
{
for (int j=bbox.min().y(); j<=bbox.max().y(); j++)
{
for (int i=bbox.min().x(); i<=bbox.max().x(); i++)
{
openvdb::Coord coord(i, j, k);
if (!access_b.isValueOn(coord))
{
access_a.setValue(coord, grid_a.background());
access_a.setValueOff(coord);
}
}
}
}
}
}
/// This class is used as a functor to set inactive voxels to the background
/// value.
template<typename GridType>
class geoInactiveToBackground
{
public:
typedef typename GridType::ValueOffIter Iterator;
typedef typename GridType::ValueType ValueType;
geoInactiveToBackground(const GridType& grid)
{
background = grid.background();
}
inline void operator()(const Iterator& iter) const
{
iter.setValue(background);
}
private:
ValueType background;
};
template <typename GridType>
static void
geoActivateBBox(GridType& grid,
const openvdb::CoordBBox &bbox,
bool setvalue,
double value,
GEO_PrimVDB::ActivateOperation operation,
bool doclip,
const openvdb::CoordBBox &clipbox)
{
typename GridType::Accessor access = grid.getAccessor();
switch (operation)
{
case GEO_PrimVDB::ACTIVATE_UNION: // Union
if (doclip)
{
openvdb::CoordBBox clipped = bbox;
clipped = bbox;
clipped.min().maxComponent(clipbox.min());
clipped.max().minComponent(clipbox.max());
geoActivateBBox(grid, clipped, setvalue, value,
operation,
false,
clipped);
break;
}
if (setvalue)
{
grid.fill(bbox, geo_doubleToGridValue<GridType>(value), /*active*/true);
}
else
{
openvdb::MaskGrid mask(false);
mask.denseFill(bbox, true, true);
grid.topologyUnion(mask);
}
break;
case GEO_PrimVDB::ACTIVATE_INTERSECT: // Intersect
{
openvdb::MaskGrid mask(false);
mask.fill(bbox, true, true);
grid.topologyIntersection(mask);
geoInactiveToBackground<GridType> bgop(grid);
openvdb::tools::foreach(grid.beginValueOff(), bgop);
}
break;
case GEO_PrimVDB::ACTIVATE_SUBTRACT: // Difference
// No matter what, we clear the background colour
// for inactive.
grid.fill(bbox, grid.background(), /*active*/false);
break;
case GEO_PrimVDB::ACTIVATE_COPY: // Copy
// intersect
geoActivateBBox(grid, bbox, setvalue, value, GEO_PrimVDB::ACTIVATE_INTERSECT, doclip, clipbox);
// and union
geoActivateBBox(grid, bbox, setvalue, value, GEO_PrimVDB::ACTIVATE_UNION, doclip, clipbox);
break;
}
}
void
GEO_PrimVDB::activateIndexBBoxAdapter(const void* bboxPtr,
ActivateOperation operation,
bool setvalue,
fpreal value)
{
using namespace openvdb;
// bboxPtr is assumed to point to an openvdb::vX_Y_Z::CoordBBox, for some
// version X.Y.Z of OpenVDB that may be newer than the one with which
// libHoudiniGEO.so was built. This is safe provided that CoordBBox and
// its member objects are ABI-compatible between the two OpenVDB versions.
const CoordBBox& bbox = *static_cast<const CoordBBox*>(bboxPtr);
bool doclip;
CoordBBox clipbox;
doclip = geoGetFrustumBoundsFromVDB(this, clipbox);
// Activate based on the parameters and inputs
UTvdbCallAllTopology(this->getStorageType(), geoActivateBBox,
this->getGrid(),
bbox,
setvalue,
value,
operation,
doclip, clipbox);
}
// Gets a conservative bounding box that maps to a coordinate
// in index space.
openvdb::CoordBBox
geoMapCoord(const openvdb::CoordBBox& bbox_b,
GEO_PrimVolumeXform xform_a,
GEO_PrimVolumeXform xform_b)
{
using openvdb::Coord;
using openvdb::CoordBBox;
// Get the eight corners of the voxel
Coord x = Coord(bbox_b.extents().x(), 0, 0);
Coord y = Coord(0, bbox_b.extents().y(), 0);
Coord z = Coord(0, 0, bbox_b.extents().z());
Coord m = bbox_b.min();
const Coord corners[] = {
m, m+z, m+y, m+y+z, m+x, m+x+z, m+x+y, m+x+y+z,
};
CoordBBox index_bbox;
for (int i=0; i<8; i++)
{
UT_Vector3 corner = UT_Vector3(corners[i].x(), corners[i].y(), corners[i].z());
UT_Vector3 index = xform_a.toVoxelSpace(xform_b.fromVoxelSpace(corner));
Coord coord(int32(index.x()), int32(index.y()), int32(index.z()));
if (i == 0)
index_bbox = CoordBBox(coord, coord);
else
index_bbox.expand(coord);
}
return index_bbox;
}
openvdb::CoordBBox
geoMapCoord(const openvdb::Coord& coord_b,
GEO_PrimVolumeXform xform_a,
GEO_PrimVolumeXform xform_b)
{
const openvdb::CoordBBox bbox_b(coord_b, coord_b + openvdb::Coord(1,1,1));
return geoMapCoord(bbox_b, xform_a, xform_b);
}
/// This class is used as a functor to create a mask for a grid's active
/// region.
template<typename GridType>
class geoMaskTopology
{
public:
typedef typename GridType::ValueOnCIter Iterator;
typedef typename openvdb::MaskGrid::Accessor Accessor;
geoMaskTopology(const GEO_PrimVolumeXform& a, const GEO_PrimVolumeXform& b)
: xform_a(a), xform_b(b)
{
}
inline void operator()(const Iterator& iter, Accessor& accessor) const
{
openvdb::CoordBBox bbox = geoMapCoord(iter.getBoundingBox(), xform_a,
xform_b);
accessor.getTree()->fill(bbox, true, true);
}
private:
const GEO_PrimVolumeXform& xform_a;
const GEO_PrimVolumeXform& xform_b;
};
/// This class is used as a functor to create a mask for the intersection
/// of two grids.
template<typename GridTypeA, typename GridTypeB>
class geoMaskIntersect
{
public:
typedef typename GridTypeA::ValueOnCIter IteratorA;
typedef typename GridTypeB::ConstAccessor AccessorB;
typedef typename openvdb::MaskGrid::Accessor Accessor;
geoMaskIntersect(const GridTypeB& source,
const GEO_PrimVolumeXform& a,
const GEO_PrimVolumeXform& b)
: myAccessor(source.getAccessor()),
myXformA(a),
myXformB(b)
{
}
inline void operator()(const IteratorA& iter, Accessor& accessor) const
{
openvdb::CoordBBox bbox = iter.getBoundingBox();
for(int k = bbox.min().z(); k <= bbox.max().z(); k++) {
for (int j = bbox.min().y(); j <= bbox.max().y(); j++) {
for (int i = bbox.min().x(); i <= bbox.max().x(); i++) {
openvdb::Coord coord(i, j, k);
accessor.setActiveState(coord,
containsActiveVoxels(geoMapCoord(coord, myXformB, myXformA)));
}
}
}
}
private:
AccessorB myAccessor;
const GEO_PrimVolumeXform& myXformA;
const GEO_PrimVolumeXform& myXformB;
// Returns true if there is at least one voxel in the source grid that is active
// within the specified bounding box.
inline bool containsActiveVoxels(const openvdb::CoordBBox& bbox) const
{
for(int k = bbox.min().z(); k <= bbox.max().z(); k++)
{
for(int j = bbox.min().y(); j <= bbox.max().y(); j++)
{
for(int i = bbox.min().x(); i <= bbox.max().x(); i++)
{
if(myAccessor.isValueOn(openvdb::Coord(i, j, k)))
return true;
}
}
}
return false;
}
};
template <typename GridTypeA, typename GridTypeB>
void
geoUnalignedUnion(GridTypeA &grid_a,
const GridTypeB &grid_b,
GEO_PrimVolumeXform xform_a,
GEO_PrimVolumeXform xform_b,
bool setvalue, double value,
bool doclip, const openvdb::CoordBBox &clipbox)
{
openvdb::MaskGrid mask(false);
geoMaskTopology<GridTypeB> maskop(xform_a, xform_b);
openvdb::tools::transformValues(grid_b.cbeginValueOn(), mask, maskop);
if(doclip)
mask.clip(clipbox);
if(setvalue)
{
typename GridTypeA::TreeType newTree(mask.tree(),
geo_doubleToGridValue<GridTypeA>(value), openvdb::TopologyCopy());
openvdb::tools::compReplace(grid_a.tree(), newTree);
}
else
grid_a.tree().topologyUnion(mask.tree());
}
template <typename GridTypeA, typename GridTypeB>
void
geoUnalignedDifference(GridTypeA &grid_a,
const GridTypeB &grid_b,
GEO_PrimVolumeXform xform_a,
GEO_PrimVolumeXform xform_b)
{
openvdb::MaskGrid mask(false);
geoMaskIntersect<GridTypeA, GridTypeB> maskop(grid_b, xform_a, xform_b);
openvdb::tools::transformValues(grid_a.cbeginValueOn(), mask, maskop, true,
// DO NOT SHARE THE OPERATOR, since grid_b's accessor does caching...
false);
grid_a.tree().topologyDifference(mask.tree());
geoInactiveToBackground<GridTypeA> bgop(grid_a);
openvdb::tools::foreach(grid_a.beginValueOff(), bgop);
}
template <typename GridTypeA, typename GridTypeB>
static void
geoUnalignedIntersect(GridTypeA &grid_a,
const GridTypeB &grid_b,
GEO_PrimVolumeXform xform_a,
GEO_PrimVolumeXform xform_b)
{
openvdb::MaskGrid mask(false);
geoMaskIntersect<GridTypeA, GridTypeB> maskop(grid_b, xform_a, xform_b);
openvdb::tools::transformValues(grid_a.cbeginValueOn(), mask, maskop, true,
// DO NOT SHARE THE OPERATOR, since grid_b's accessor does caching...
false);
grid_a.tree().topologyIntersection(mask.tree());
geoInactiveToBackground<GridTypeA> bgop(grid_a);
openvdb::tools::foreach(grid_a.beginValueOff(), bgop);
}
// The result of the union of active regions goes into grid_a
template <typename GridTypeA, typename GridTypeB>
static void
geoUnion(GridTypeA& grid_a, const GridTypeB &grid_b, bool setvalue, double value, bool doclip, const openvdb::CoordBBox &clipbox)
{
typename GridTypeA::Accessor access_a = grid_a.getAccessor();
typename GridTypeB::ConstAccessor access_b = grid_b.getAccessor();
if (!doclip && !setvalue) {
grid_a.tree().topologyUnion(grid_b.tree());
return;
}
// For each on value in b, set a on
for (typename GridTypeB::ValueOnCIter iter = grid_b.cbeginValueOn(); iter; ++iter) {
openvdb::CoordBBox bbox = iter.getBoundingBox();
// Intersect with our destination
if (doclip) {
bbox.min().maxComponent(clipbox.min());
bbox.max().minComponent(clipbox.max());
}
for (int k=bbox.min().z(); k<=bbox.max().z(); k++) {
for (int j=bbox.min().y(); j<=bbox.max().y(); j++) {
for (int i=bbox.min().x(); i<=bbox.max().x(); i++) {
openvdb::Coord coord(i, j, k);
if (setvalue) {
access_a.setValue(coord, geo_doubleToGridValue<GridTypeA>(value));
} else {
access_a.setValueOn(coord);
}
}
}
}
}
}
// The result of the union of active regions goes into grid_a
template <typename GridTypeA, typename GridTypeB>
static void
geoDifference(GridTypeA& grid_a, const GridTypeB &grid_b)
{
typename GridTypeA::Accessor access_a = grid_a.getAccessor();
typename GridTypeB::ConstAccessor access_b = grid_b.getAccessor();
// For each on value in a, set it off if b is on
for (typename GridTypeA::ValueOnCIter
iter = grid_a.cbeginValueOn(); iter; ++iter)
{
openvdb::CoordBBox bbox = iter.getBoundingBox();
for (int k=bbox.min().z(); k<=bbox.max().z(); k++)
{
for (int j=bbox.min().y(); j<=bbox.max().y(); j++)
{
for (int i=bbox.min().x(); i<=bbox.max().x(); i++)
{
openvdb::Coord coord(i, j, k);
// TODO: conditional needed? Profile please.
if (access_b.isValueOn(coord))
{
access_a.setValue(coord, grid_a.background());
access_a.setValueOff(coord);
}
}
}
}
}
}
template <typename GridTypeB>
static void
geoDoUnion(const GridTypeB &grid_b,
GEO_PrimVolumeXform xform_b,
GEO_PrimVDB &vdb_a,
bool setvalue, double value,
bool doclip, const openvdb::CoordBBox &clipbox,
bool ignore_transform)
{
// If the transforms are equal, we can do an aligned union
if (ignore_transform || grid_b.transform() == vdb_a.getGrid().transform())
{
UTvdbCallAllTopology(vdb_a.getStorageType(), geoUnion,
vdb_a.getGrid(), grid_b, setvalue, value,
doclip, clipbox);
}
else
{
UTvdbCallAllTopology(vdb_a.getStorageType(), geoUnalignedUnion,
vdb_a.getGrid(), grid_b,
vdb_a.getIndexSpaceTransform(),
xform_b, setvalue, value,
doclip, clipbox);
}
}
template <typename GridTypeB>
static void
geoDoIntersect(
const GridTypeB &grid_b,
GEO_PrimVolumeXform xform_b,
GEO_PrimVDB &vdb_a,
bool ignore_transform)
{
if (ignore_transform || grid_b.transform() == vdb_a.getGrid().transform())
{
UTvdbCallAllTopology(vdb_a.getStorageType(),
geoIntersect, vdb_a.getGrid(), grid_b);
}
else
{
UTvdbCallAllTopology(vdb_a.getStorageType(),
geoUnalignedIntersect, vdb_a.getGrid(),
grid_b, vdb_a.getIndexSpaceTransform(),
xform_b);
}
}
template <typename GridTypeB>
static void
geoDoDifference(
const GridTypeB &grid_b,
GEO_PrimVolumeXform xform_b,
GEO_PrimVDB &vdb_a,
bool ignore_transform)
{
if (ignore_transform || grid_b.transform() == vdb_a.getGrid().transform())
{
UTvdbCallAllTopology(vdb_a.getStorageType(), geoDifference,
vdb_a.getGrid(), grid_b);
}
else
{
UTvdbCallAllTopology(vdb_a.getStorageType(), geoUnalignedDifference,
vdb_a.getGrid(), grid_b,
vdb_a.getIndexSpaceTransform(),
xform_b);
}
}
void
GEO_PrimVDB::activateByVDB(
const GEO_PrimVDB *input_vdb,
ActivateOperation operation,
bool setvalue, fpreal value,
bool ignore_transform)
{
const openvdb::GridBase& input_grid = input_vdb->getGrid();
bool doclip;
openvdb::CoordBBox clipbox;
doclip = geoGetFrustumBoundsFromVDB(this, clipbox);
switch (operation)
{
case GEO_PrimVDB::ACTIVATE_UNION: // Union
UTvdbCallAllTopology(input_vdb->getStorageType(),
geoDoUnion, input_grid,
input_vdb->getIndexSpaceTransform(),
*this,
setvalue,
value,
doclip, clipbox,
ignore_transform);
break;
case GEO_PrimVDB::ACTIVATE_INTERSECT: // Intersect
UTvdbCallAllTopology(input_vdb->getStorageType(),
geoDoIntersect, input_grid,
input_vdb->getIndexSpaceTransform(),
*this,
ignore_transform);
break;
case GEO_PrimVDB::ACTIVATE_SUBTRACT: // Difference
UTvdbCallAllTopology(input_vdb->getStorageType(),
geoDoDifference, input_grid,
input_vdb->getIndexSpaceTransform(),
*this,
ignore_transform);
break;
case GEO_PrimVDB::ACTIVATE_COPY: // Copy
UTvdbCallAllTopology(input_vdb->getStorageType(),
geoDoIntersect, input_grid,
input_vdb->getIndexSpaceTransform(),
*this,
ignore_transform);
UTvdbCallAllTopology(input_vdb->getStorageType(),
geoDoUnion, input_grid,
input_vdb->getIndexSpaceTransform(),
*this,
setvalue,
value,
doclip, clipbox,
ignore_transform);
break;
}
}
UT_Matrix4D
GEO_PrimVDB::getTransform4() const
{
using namespace openvdb;
using namespace openvdb::math;
UT_Matrix4D mat4;
const Transform &gxform = getGrid().transform();
NonlinearFrustumMap::ConstPtr fmap = gxform.map<NonlinearFrustumMap>();
if (fmap)
{
const openvdb::BBoxd &bbox = fmap->getBBox();
const openvdb::Vec3d center = bbox.getCenter();
const openvdb::Vec3d size = bbox.extents();
// TODO: Use fmap->linearMap() once that actually works
mat4.identity();
mat4.translate(-center.x(), -center.y(), -bbox.min().z());
// NOTE: We scale both XY axes by size.x() because the secondMap()
// has the aspect ratio baked in
mat4.scale(1.0/size.x(), 1.0/size.x(), 1.0/size.z());
mat4 *= UTvdbConvert(fmap->secondMap().getMat4());
}
else
{
mat4 = UTvdbConvert(gxform.baseMap()->getAffineMap()->getMat4());
}
return mat4;
}
void
GEO_PrimVDB::getLocalTransform(UT_Matrix3D &result) const
{
result = getTransform4();
}
void
GEO_PrimVDB::setLocalTransform(const UT_Matrix3D &new_mat3)
{
using namespace openvdb;
using namespace openvdb::math;
Transform::Ptr xform;
UT_Matrix4D new_mat4;
new_mat4 = new_mat3;
new_mat4.setTranslates(getDetail().getPos3(vertexPoint(0)));
const Transform & gxform = getGrid().transform();
NonlinearFrustumMap::ConstPtr fmap = gxform.map<NonlinearFrustumMap>();
if (fmap)
{
fmap = geoStandardFrustumMapPtr(*this);
const openvdb::BBoxd &bbox = fmap->getBBox();
const openvdb::Vec3d center = bbox.getCenter();
const openvdb::Vec3d size = bbox.extents();
// TODO: Use fmap->linearMap() once that actually works
UT_Matrix4D second;
second.identity();
second.translate(-0.5, -0.5, 0.0); // adjust for frustum map center
// NOTE: We scale both XY axes by size.x() because the secondMap()
// has the aspect ratio baked in
second.scale(size.x(), size.x(), size.z());
second.translate(center.x(), center.y(), bbox.min().z());
second *= new_mat4;
xform.reset(new Transform(MapBase::Ptr(
new NonlinearFrustumMap(fmap->getBBox(), fmap->getTaper(),
/*depth*/1.0,
geoCreateAffineMap<MapBase>(second)))));
}
else
{
xform = geoCreateLinearTransform(new_mat4);
}
myGridAccessor.setTransform(*xform, *this);
}
int
GEO_PrimVDB::detachPoints(GA_PointGroup &grp)
{
int count = 0;
if (grp.containsOffset(vertexPoint(0)))
count++;
if (count == 0)
return 0;
if (count == 1)
return -2;
return -1;
}
GA_Primitive::GA_DereferenceStatus
GEO_PrimVDB::dereferencePoint(GA_Offset point, bool)
{
return vertexPoint(0) == point
? GA_DEREFERENCE_DESTROY
: GA_DEREFERENCE_OK;
}
GA_Primitive::GA_DereferenceStatus
GEO_PrimVDB::dereferencePoints(const GA_RangeMemberQuery &point_query, bool)
{
return point_query.contains(vertexPoint(0))
? GA_DEREFERENCE_DESTROY
: GA_DEREFERENCE_OK;
}
///
/// JSON methods
///
namespace { // unnamed
class geo_PrimVDBJSON : public GA_PrimitiveJSON
{
public:
static const char *theSharedMemKey;
public:
geo_PrimVDBJSON() {}
~geo_PrimVDBJSON() override {}
enum
{
geo_TBJ_VERTEX,
geo_TBJ_VDB,
geo_TBJ_VDB_SHMEM,
geo_TBJ_VDB_VISUALIZATION,
geo_TBJ_ENTRIES
};
const GEO_PrimVDB *vdb(const GA_Primitive *p) const
{ return static_cast<const GEO_PrimVDB *>(p); }
GEO_PrimVDB *vdb(GA_Primitive *p) const
{ return static_cast<GEO_PrimVDB *>(p); }
int getEntries() const override
{ return geo_TBJ_ENTRIES; }
const UT_StringHolder &
getKeyword(int i) const override
{
switch (i)
{
case geo_TBJ_VERTEX: return theKWVertex;
case geo_TBJ_VDB: return theKWVDB;
case geo_TBJ_VDB_SHMEM: return theKWVDBShm;
case geo_TBJ_VDB_VISUALIZATION: return theKWVDBVis;
case geo_TBJ_ENTRIES: break;
}
UT_ASSERT(0);
return UT_StringHolder::theEmptyString;
}
bool
shouldSaveField(const GA_Primitive *prim, int i,
const GA_SaveMap &sm) const override
{
bool is_shmem = sm.getOptions().hasOption("geo:sharedmemowner");
switch (i)
{
case geo_TBJ_VERTEX: return true;
case geo_TBJ_VDB: return !is_shmem;
case geo_TBJ_VDB_SHMEM: return is_shmem;
case geo_TBJ_VDB_VISUALIZATION: return true;
case geo_TBJ_ENTRIES: break;
}
UT_ASSERT(0);
return false;
}
bool
saveField(const GA_Primitive *pr, int i, UT_JSONWriter &w,
const GA_SaveMap &map) const override
{
switch (i)
{
case geo_TBJ_VERTEX:
{
GA_Offset vtx = vdb(pr)->getVertexOffset(0);
return w.jsonInt(int64(map.getVertexIndex(vtx)));
}
case geo_TBJ_VDB:
return vdb(pr)->saveVDB(w, map);
case geo_TBJ_VDB_SHMEM:
return vdb(pr)->saveVDB(w, map, true);
case geo_TBJ_VDB_VISUALIZATION:
return vdb(pr)->saveVisualization(w, map);
case geo_TBJ_ENTRIES:
break;
}
return false;
}
bool
loadField(GA_Primitive *pr, int i, UT_JSONParser &p,
const GA_LoadMap &map) const override
{
switch (i)
{
case geo_TBJ_VERTEX:
{
int64 vidx;
if (!p.parseInt(vidx))
return false;
GA_Offset voff = map.getVertexOffset(GA_Index(vidx));
// Assign the preallocated vertex, but
// do not bother updating the topology,
// which will be done at the end of the
// load anyway.
vdb(pr)->assignVertex(voff, false);
return true;
}
case geo_TBJ_VDB:
return vdb(pr)->loadVDB(p);
case geo_TBJ_VDB_SHMEM:
return vdb(pr)->loadVDB(p, true);
case geo_TBJ_VDB_VISUALIZATION:
return vdb(pr)->loadVisualization(p, map);
case geo_TBJ_ENTRIES:
break;
}
UT_ASSERT(0);
return false;
}
bool
saveField(const GA_Primitive *pr, int i, UT_JSONValue &val,
const GA_SaveMap &map) const override
{
UT_AutoJSONWriter w(val);
return saveField(pr, i, *w, map);
}
// Re-implement the H12.5 base class version, note that this was pure
// virtual in H12.1.
bool
loadField(GA_Primitive *pr, int i, UT_JSONParser &p,
const UT_JSONValue &jval, const GA_LoadMap &map) const override
{
UT_AutoJSONParser parser(jval);
bool ok = loadField(pr, i, *parser, map);
p.stealErrors(*parser);
return ok;
}
bool
isEqual(int i,
const GA_Primitive *p0, const GA_Primitive *p1) const override
{
switch (i)
{
case geo_TBJ_VERTEX:
return (p0->getVertexOffset(0) == p1->getVertexOffset(0));
case geo_TBJ_VDB_SHMEM:
case geo_TBJ_VDB:
return false; // never save these tags as uniform
case geo_TBJ_VDB_VISUALIZATION:
return (vdb(p0)->getVisOptions() == vdb(p1)->getVisOptions());
case geo_TBJ_ENTRIES:
break;
}
UT_ASSERT(0);
return false;
}
private:
};
const char *geo_PrimVDBJSON::theSharedMemKey = "sharedkey";
} // namespace unnamed
static const GA_PrimitiveJSON *
vdbJSON()
{
static SYS_AtomicPtr<GA_PrimitiveJSON> theJSON;
if (!theJSON) {
GA_PrimitiveJSON* json = new geo_PrimVDBJSON;
if (nullptr != theJSON.compare_swap(nullptr, json)) {
delete json;
json = nullptr;
}
}
return theJSON;
}
const GA_PrimitiveJSON *
GEO_PrimVDB::getJSON() const
{
return vdbJSON();
}
// This method is called by multiple places internally in Houdini.
static void
geoSetVDBStreamCompression(openvdb::io::Stream& vos, bool backwards_compatible)
{
// Always enable full compression, since it is fast and compresses level
// sets and fog volumes well.
uint32_t compression = openvdb::io::COMPRESS_ACTIVE_MASK;
// Enable blosc compression unless we want it to be backwards compatible.
if (vos.hasBloscCompression() && !backwards_compatible) {
compression |= openvdb::io::COMPRESS_BLOSC;
}
vos.setCompression(compression);
}
bool
GEO_PrimVDB::saveVDB(UT_JSONWriter &w, const GA_SaveMap &sm,
bool as_shmem) const
{
bool ok = true;
try
{
openvdb::GridCPtrVec grids;
grids.push_back(getConstGridPtr());
if (as_shmem)
{
openvdb::MetaMap meta;
UT_String shmem_owner;
sm.getOptions().importOption("geo:sharedmemowner", shmem_owner);
if (!shmem_owner.isstring())
return false;
// First do a pass to collect the final size
SYS_SharedMemoryOutputStream os_count(NULL);
{
openvdb::io::Stream vos(os_count);
geoSetVDBStreamCompression(vos, /*backwards_compatible*/false);
vos.write(grids, meta);
}
// Create the shmem segment
UT_WorkBuffer shmem_key;
shmem_key.sprintf("%s:%p", shmem_owner.buffer(), this);
UT_SharedMemoryManager &shmgr = UT_SharedMemoryManager::get();
SYS_SharedMemory *shmem = shmgr.get(shmem_key.buffer());
if (shmem->size() != os_count.size())
shmem->reset(os_count.size());
// Save the vdb stream to the shmem segment
SYS_SharedMemoryOutputStream os_shm(shmem);
{
openvdb::io::Stream vos(os_shm);
geoSetVDBStreamCompression(vos, /*backwards_compatible*/false);
vos.write(grids, meta);
}
// In the main json stream, just tag it with the shmem key
ok = ok && w.jsonBeginArray();
ok = ok && w.jsonKeyToken(geo_PrimVDBJSON::theSharedMemKey);
ok = ok && w.jsonString(shmem->id());
ok = ok && w.jsonEndArray();
}
else
{
UT_JSONWriter::TiledStream os(w);
openvdb::io::Stream vos(os);
openvdb::MetaMap meta;
geoSetVDBStreamCompression(
vos, UT_EnvControl::getInt(ENV_HOUDINI13_VOLUME_COMPATIBILITY));
// Visual C++ requires a default meta object declared on the stack
vos.write(grids, meta);
}
}
catch (std::exception &e)
{
std::cerr << "Save failure: " << e.what() << "\n";
ok = false;
}
return ok;
}
bool
GEO_PrimVDB::loadVDB(UT_JSONParser &p, bool as_shmem)
{
if (as_shmem)
{
bool array_error = false;
UT_WorkBuffer key;
if (!p.parseBeginArray(array_error) || array_error)
return false;
if (!p.parseString(key))
return false;
if (key != geo_PrimVDBJSON::theSharedMemKey)
return false;
UT_WorkBuffer shmem_key;
if (!p.parseString(shmem_key))
return false;
SYS_SharedMemory *shmem = new SYS_SharedMemory(shmem_key.buffer(),
/*read_only*/true);
if (shmem->size())
{
try
{
SYS_SharedMemoryInputStream is_shm(*shmem);
openvdb::io::Stream vis(is_shm, /*delayLoad*/false);
openvdb::GridPtrVecPtr grids = vis.getGrids();
int count = (grids ? grids->size() : 0);
if (count != 1)
{
UT_String mesg;
mesg.sprintf("expected to read 1 grid, got %d grid%s",
count, count == 1 ? "" : "s");
throw std::runtime_error(mesg.nonNullBuffer());
}
openvdb::GridBase::Ptr grid = (*grids)[0];
UT_ASSERT(grid);
if (grid) setGrid(*grid);
}
catch (std::exception &e)
{
std::cerr << "Shared memory load failure: " << e.what() << "\n";
return false;
}
}
else
{
// If the shared memory was set to zero, it probably died while
// the IFD stream was in transit. Create a dummy grid so that
// mantra doesn't flip out like a ninja.
openvdb::GridBase::Ptr grid = openvdb::FloatGrid::create(0);
setGrid(*grid);
}
if (!p.parseEndArray(array_error) || array_error)
return false;
}
else
{
try
{
UT_JSONParser::TiledStream is(p);
openvdb::io::Stream vis(is, /*delayLoad*/false);
openvdb::GridPtrVecPtr grids = vis.getGrids();
int count = (grids ? grids->size() : 0);
if (count != 1)
{
UT_String mesg;
mesg.sprintf("expected to read 1 grid, got %d grid%s",
count, count == 1 ? "" : "s");
throw std::runtime_error(mesg.nonNullBuffer());
}
openvdb::GridBase::Ptr grid = (*grids)[0];
UT_ASSERT(grid);
if (grid)
{
// When we saved the grid, we auto-added metadata
// which isn't reflected by our primitive attributes.
// if any later node tries to sync the metadata from
// the vdb primitive, we'll gain extra data such as
// file_bbox
const char *file_metadata[] =
{
"file_bbox_min",
"file_bbox_max",
"file_compression",
"file_mem_bytes",
"file_voxel_count",
"file_delayed_load",
0
};
for (int i = 0; file_metadata[i]; i++)
{
grid->removeMeta(file_metadata[i]);
}
setGrid(*grid);
}
}
catch (std::exception &e)
{
std::cerr << "Load failure: " << e.what() << "\n";
return false;
}
}
return true;
}
namespace // anonymous
{
enum
{
geo_JVOL_VISMODE,
geo_JVOL_VISISO,
geo_JVOL_VISDENSITY,
geo_JVOL_VISLOD,
};
UT_FSATable theJVolumeViz(
geo_JVOL_VISMODE, "mode",
geo_JVOL_VISISO, "iso",
geo_JVOL_VISDENSITY, "density",
geo_JVOL_VISLOD, "lod",
-1, nullptr
);
} // namespace anonymous
bool
GEO_PrimVDB::saveVisualization(UT_JSONWriter &w, const GA_SaveMap &) const
{
bool ok = true;
ok = ok && w.jsonBeginMap();
ok = ok && w.jsonKeyToken(theJVolumeViz.getToken(geo_JVOL_VISMODE));
ok = ok && w.jsonString(GEOgetVolumeVisToken(myVis.myMode));
ok = ok && w.jsonKeyToken(theJVolumeViz.getToken(geo_JVOL_VISISO));
ok = ok && w.jsonReal(myVis.myIso);
ok = ok && w.jsonKeyToken(theJVolumeViz.getToken(geo_JVOL_VISDENSITY));
ok = ok && w.jsonReal(myVis.myDensity);
// Only save myLod when non-default so that it loads in older builds
if (myVis.myLod != GEO_VOLUMEVISLOD_FULL)
{
ok = ok && w.jsonKeyToken(theJVolumeViz.getToken(geo_JVOL_VISLOD));
ok = ok && w.jsonString(GEOgetVolumeVisLodToken(myVis.myLod));
}
return ok && w.jsonEndMap();
}
bool
GEO_PrimVDB::loadVisualization(UT_JSONParser &p, const GA_LoadMap &)
{
UT_JSONParser::traverser it;
GEO_VolumeVis mode = myVis.myMode;
fpreal iso = myVis.myIso;
fpreal density = myVis.myDensity;
GEO_VolumeVisLod lod = myVis.myLod;
UT_WorkBuffer key;
fpreal64 fval;
bool foundmap=false, ok = true;
for (it = p.beginMap(); ok && !it.atEnd(); ++it)
{
foundmap = true;
if (!it.getLowerKey(key))
{
ok = false;
break;
}
switch (theJVolumeViz.findSymbol(key.buffer()))
{
case geo_JVOL_VISMODE:
if ((ok = p.parseString(key)))
mode = GEOgetVolumeVisEnum(
key.buffer(), GEO_VOLUMEVIS_SMOKE);
break;
case geo_JVOL_VISISO:
if ((ok = p.parseReal(fval)))
iso = fval;
break;
case geo_JVOL_VISDENSITY:
if ((ok = p.parseReal(fval)))
density = fval;
break;
case geo_JVOL_VISLOD:
if ((ok = p.parseString(key)))
lod = GEOgetVolumeVisLodEnum(
key.buffer(), GEO_VOLUMEVISLOD_FULL);
break;
default:
p.addWarning("Unexpected key for volume visualization: %s",
key.buffer());
ok = p.skipNextObject();
break;
}
}
if (!foundmap)
{
p.addFatal("Expected a JSON map for volume visualization data");
ok = false;
}
if (ok)
setVisualization(mode, iso, density, lod);
return ok;
}
template <typename GridType>
static void
geo_sumPosDensity(const GridType &grid, fpreal64 &sum)
{
sum = 0;
for (typename GridType::ValueOnCIter iter = grid.cbeginValueOn(); iter; ++iter) {
fpreal value = *iter;
if (value > 0) {
if (iter.isTileValue()) sum += value * iter.getVoxelCount();
else sum += value;
}
}
}
fpreal
GEO_PrimVDB::calcPositiveDensity() const
{
fpreal64 density = 0;
UT_IF_ASSERT(UT_VDBType type = getStorageType();)
UT_ASSERT(type == UT_VDB_FLOAT || type == UT_VDB_DOUBLE);
UTvdbCallRealType(getStorageType(), geo_sumPosDensity, getGrid(), density);
UTvdbCallBoolType(getStorageType(), geo_sumPosDensity, getGrid(), density);
int numvoxel = getGrid().activeVoxelCount();
if (numvoxel)
density /= numvoxel;
UT_Vector3 zero(0, 0, 0);
density *= calcVolume(zero);
return density;
}
int
GEO_PrimVDB::getBBox(UT_BoundingBox *bbox) const
{
if (hasGrid())
{
using namespace openvdb;
CoordBBox vbox;
const openvdb::GridBase &grid = getGrid();
// NOTE: We use evalActiveVoxelBoundingBox() so that it matches
// getRes() which calls evalActiveVoxelDim().
if (!grid.baseTree().evalActiveVoxelBoundingBox(vbox))
{
bbox->makeInvalid();
return false;
}
// Currently VDB may return true even if the final bounds
// were zero, so to avoid generating a massive bound, detect
// invalid bounding boxes and return false.
if (vbox.min()[0] > vbox.max()[0])
{
bbox->makeInvalid();
return false;
}
const math::Transform &xform = grid.transform();
for (int i = 0; i < 8; i++)
{
math::Vec3d vpos(
(i&1) ? vbox.min()[0] - 0.5 : vbox.max()[0] + 0.5,
(i&2) ? vbox.min()[1] - 0.5 : vbox.max()[1] + 0.5,
(i&4) ? vbox.min()[2] - 0.5 : vbox.max()[2] + 0.5);
vpos = xform.indexToWorld(vpos);
UT_Vector3 worldpos(vpos.x(), vpos.y(), vpos.z());
if (i == 0)
bbox->initBounds(worldpos);
else
bbox->enlargeBounds(worldpos);
}
return true;
}
bbox->initBounds(getDetail().getPos3(vertexPoint(0)));
return true;
}
UT_Vector3
GEO_PrimVDB::baryCenter() const
{
// Return the center of the index space
if (!hasGrid())
return UT_Vector3(0, 0, 0);
const openvdb::GridBase &grid = getGrid();
openvdb::CoordBBox bbox = grid.evalActiveVoxelBoundingBox();
UT_Vector3 pos;
findexToPos(UTvdbConvert(bbox.getCenter()), pos);
return pos;
}
bool
GEO_PrimVDB::isDegenerate() const
{
return false;
}
//
// Methods to handle vertex attributes for the attribute dictionary
//
void
GEO_PrimVDB::copyPrimitive(const GEO_Primitive *psrc)
{
if (psrc == this) return;
const GEO_PrimVDB *src = (const GEO_PrimVDB *)psrc;
copyGridFrom(*src); // makes a shallow copy
// TODO: Well and good to reuse the attribute handle for all our
// vertices, but we should do so across primitives as well.
GA_VertexWrangler vertex_wrangler(*getParent(), *src->getParent());
GEO_Primitive::copyPrimitive(psrc);
myVis = src->myVis;
}
static inline
openvdb::math::Vec3d
vdbTranslation(const openvdb::math::Transform &xform)
{
return xform.baseMap()->getAffineMap()->getMat4().getTranslation();
}
// Replace the grid's translation with the prim's vertex position
void
GEO_PrimVDB::GridAccessor::updateGridTranslates(const GEO_PrimVDB &prim) const
{
using namespace openvdb::math;
const GA_Detail & geo = prim.getDetail();
// It is possible our vertex offset is invalid, such as us
// being a stashed primitive.
if (!GAisValid(prim.getVertexOffset(0)))
return;
GA_Offset ptoff = prim.vertexPoint(0);
Vec3d newpos = UTvdbConvert(geo.getPos3(ptoff));
Vec3d oldpos = vdbTranslation(myGrid->transform());
MapBase::ConstPtr map = myGrid->transform().baseMap();
if (isApproxEqual(oldpos, newpos))
return;
const_cast<GEO_PrimVDB&>(prim).incrTransformUniqueId();
Vec3d delta = newpos - oldpos;
const_cast<GEO_PrimVDB::GridAccessor *>(this)->makeGridUnique();
myGrid->setTransform(
std::make_shared<Transform>(map->postTranslate(delta)));
}
// Copy the translation from xform and set into our vertex position
void
GEO_PrimVDB::GridAccessor::setVertexPositionAdapter(
const void* xformPtr,
GEO_PrimVDB &prim)
{
// xformPtr is assumed to point to an openvdb::vX_Y_Z::math::Transform,
// for some version X.Y.Z of OpenVDB that may be newer than the one
// with which libHoudiniGEO.so was built. This is safe provided that
// math::Transform and its member objects are ABI-compatible between
// the two OpenVDB versions.
const openvdb::math::Transform& xform =
*static_cast<const openvdb::math::Transform*>(xformPtr);
if (myGrid && &myGrid->transform() == &xform)
return;
prim.incrTransformUniqueId();
prim.getDetail().setPos3(
prim.vertexPoint(0), UTvdbConvert(vdbTranslation(xform)));
}
void
GEO_PrimVDB::GridAccessor::setTransformAdapter(
const void* xformPtr,
GEO_PrimVDB &prim)
{
if (!myGrid)
return;
// xformPtr is assumed to point to an openvdb::vX_Y_Z::math::Transform,
// for some version X.Y.Z of OpenVDB that may be newer than the one
// with which libHoudiniGEO.so was built. This is safe provided that
// math::Transform and its member objects are ABI-compatible between
// the two OpenVDB versions.
const openvdb::math::Transform& xform =
*static_cast<const openvdb::math::Transform*>(xformPtr);
setVertexPosition(xform, prim);
myGrid->setTransform(xform.copy());
}
void
GEO_PrimVDB::GridAccessor::setGridAdapter(
const void* gridPtr,
GEO_PrimVDB &prim,
bool copyPosition)
{
// gridPtr is assumed to point to an openvdb::vX_Y_Z::GridBase, for some
// version X.Y.Z of OpenVDB that may be newer than the one with which
// libHoudiniGEO.so was built. This is safe provided that GridBase and
// its member objects are ABI-compatible between the two OpenVDB versions.
const openvdb::GridBase& grid =
*static_cast<const openvdb::GridBase*>(gridPtr);
if (myGrid.get() == &grid)
return;
if (copyPosition)
setVertexPosition(grid.transform(), prim);
myGrid = openvdb::ConstPtrCast<openvdb::GridBase>(
grid.copyGrid()); // always shallow-copy the source grid
myStorageType = UTvdbGetGridType(*myGrid);
}
GEO_Primitive *
GEO_PrimVDB::copy(int preserve_shared_pts) const
{
GEO_Primitive *clone = GEO_Primitive::copy(preserve_shared_pts);
if (!clone)
return nullptr;
GEO_PrimVDB* vdb = static_cast<GEO_PrimVDB*>(clone);
// Give the clone the same serial number as this primitive.
vdb->myUniqueId.exchange(this->getUniqueId());
// Give the clone a shallow copy of this primitive's grid.
vdb->copyGridFrom(*this);
vdb->myVis = myVis;
return clone;
}
void
GEO_PrimVDB::copySubclassData(const GA_Primitive *source)
{
UT_ASSERT(source != this);
const GEO_PrimVDB* src = static_cast<const GEO_PrimVDB*>(source);
GEO_Primitive::copySubclassData(source);
// DO NOT copy P from the source, since copySubclassData
// should be independent of any attributes!
copyGridFrom(*src, false); // makes a shallow copy
myVis = src->myVis;
}
void
GEO_PrimVDB::assignVertex(GA_Offset new_vtx, bool update_topology)
{
if (getVertexCount() == 1)
{
GA_Offset orig_vtx = getVertexOffset();
if (orig_vtx == new_vtx)
return;
UT_ASSERT_P(GAisValid(orig_vtx));
destroyVertex(orig_vtx);
myVertexList.set(0, new_vtx);
}
else
{
myVertexList.setTrivial(new_vtx, 1);
}
if (update_topology)
registerVertex(new_vtx);
}
const char *
GEO_PrimVDB::getGridName() const
{
GA_ROHandleS nameAttr(getParent(), GA_ATTRIB_PRIMITIVE, "name");
return nameAttr.isValid() ? nameAttr.get(getMapOffset()) : "";
}
namespace // anonymous
{
using geo_Size = GA_Size;
// Intrinsic attributes
enum geo_Intrinsic
{
geo_INTRINSIC_BACKGROUND,
geo_INTRINSIC_VOXELSIZE,
geo_INTRINSIC_ACTIVEVOXELDIM,
geo_INTRINSIC_ACTIVEVOXELCOUNT,
geo_INTRINSIC_TRANSFORM,
geo_INTRINSIC_VOLUMEVISUALMODE,
geo_INTRINSIC_VOLUMEVISUALDENSITY,
geo_INTRINSIC_VOLUMEVISUALISO,
geo_INTRINSIC_VOLUMEVISUALLOD,
geo_INTRINSIC_META_GRID_CLASS,
geo_INTRINSIC_META_GRID_CREATOR,
geo_INTRINSIC_META_IS_LOCAL_SPACE,
geo_INTRINSIC_META_SAVE_HALF_FLOAT,
geo_INTRINSIC_META_VALUE_TYPE,
geo_INTRINSIC_META_VECTOR_TYPE,
geo_NUM_INTRINSICS
};
const UT_FSATable theMetaNames(
geo_INTRINSIC_META_GRID_CLASS, "vdb_class",
geo_INTRINSIC_META_GRID_CREATOR, "vdb_creator",
geo_INTRINSIC_META_IS_LOCAL_SPACE, "vdb_is_local_space",
geo_INTRINSIC_META_SAVE_HALF_FLOAT, "vdb_is_saved_as_half_float",
geo_INTRINSIC_META_VALUE_TYPE, "vdb_value_type",
geo_INTRINSIC_META_VECTOR_TYPE, "vdb_vector_type",
-1, nullptr
);
geo_Size
intrinsicBackgroundTupleSize(const GEO_PrimVDB *p)
{
return UTvdbGetGridTupleSize(p->getStorageType());
}
template <typename GridT> void
intrinsicBackgroundV(const GridT &grid, fpreal64 *v, GA_Size n)
{
typename GridT::ValueType background = grid.background();
for (GA_Size i = 0; i < n; i++)
v[i] = background[i];
}
template <typename GridT> void
intrinsicBackgroundS(const GridT &grid, fpreal64 *v)
{
v[0] = (fpreal64)grid.background();
}
geo_Size
intrinsicBackground(const GEO_PrimVDB *p, fpreal64 *v, GA_Size size)
{
UT_VDBType grid_type = p->getStorageType();
GA_Size n = SYSmin(UTvdbGetGridTupleSize(grid_type), size);
UT_ASSERT(n > 0);
UTvdbCallScalarType(grid_type, intrinsicBackgroundS, p->getGrid(), v)
else UTvdbCallVec3Type(grid_type, intrinsicBackgroundV,
p->getGrid(), v, n)
else if (grid_type == UT_VDB_BOOL)
{
intrinsicBackgroundS<openvdb::BoolGrid>(
UTvdbGridCast<openvdb::BoolGrid>(p->getGrid()), v);
}
else
n = 0;
return n;
}
geo_Size
intrinsicVoxelSize(const GEO_PrimVDB *prim, fpreal64 *v, GA_Size size)
{
openvdb::Vec3d voxel_size = prim->getGrid().voxelSize();
GA_Size n = SYSmin(3, size);
for (GA_Size i = 0; i < n; i++)
v[i] = voxel_size[i];
return n;
}
geo_Size
intrinsicActiveVoxelDim(const GEO_PrimVDB *prim, int64 *v, GA_Size size)
{
using namespace openvdb;
Coord dim = prim->getGrid().evalActiveVoxelDim();
GA_Size n = SYSmin(3, size);
for (GA_Size i = 0; i < n; i++)
v[i] = dim[i];
return n;
}
int64
intrinsicActiveVoxelCount(const GEO_PrimVDB *prim)
{
return prim->getGrid().activeVoxelCount();
}
geo_Size
intrinsicTransform(const GEO_PrimVDB *prim, fpreal64 *v, GA_Size size)
{
using namespace openvdb;
const GridBase & grid = prim->getGrid();
const math::Transform & xform = grid.transform();
math::MapBase::ConstPtr bmap = xform.baseMap();
math::AffineMap::Ptr amap = bmap->getAffineMap();
math::Mat4d m4 = amap->getMat4();
const double * data = m4.asPointer();
size = SYSmin(size, 16);
for (int i = 0; i < size; ++i)
v[i] = data[i];
return geo_Size(size);
}
geo_Size
intrinsicSetTransform(GEO_PrimVDB *q, const fpreal64 *v, GA_Size size)
{
if (size < 16)
return 0;
UT_DMatrix4 m(v[0], v[1], v[2], v[3],
v[4], v[5], v[6], v[7],
v[8], v[9], v[10], v[11],
v[12], v[13], v[14], v[15]);
q->setTransform4(m);
return 16;
}
const char *
intrinsicVisualMode(const GEO_PrimVDB *p)
{
return GEOgetVolumeVisToken(p->getVisualization());
}
const char *
intrinsicVisualLod(const GEO_PrimVDB *p)
{
return GEOgetVolumeVisLodToken(p->getVisLod());
}
openvdb::Metadata::ConstPtr
intrinsicGetMeta(const GEO_PrimVDB *p, geo_Intrinsic id)
{
using namespace openvdb;
return p->getGrid()[theMetaNames.getToken(id) + 4];
}
void
intrinsicSetMeta(
GEO_PrimVDB *p,
geo_Intrinsic id,
const openvdb::Metadata &meta)
{
using namespace openvdb;
MetaMap &meta_map = p->getMetadata();
const char *name = theMetaNames.getToken(id) + 4;
meta_map.removeMeta(name);
meta_map.insertMeta(name, meta);
}
void
intrinsicGetMetaString(
const GEO_PrimVDB *p,
geo_Intrinsic id,
UT_String &v)
{
using namespace openvdb;
Metadata::ConstPtr meta = intrinsicGetMeta(p, id);
if (meta)
v = meta->str();
else
v = "";
}
void
intrinsicSetMetaString(
GEO_PrimVDB *p,
geo_Intrinsic id,
const char *v)
{
intrinsicSetMeta(p, id, openvdb::StringMetadata(v));
}
bool
intrinsicGetMetaBool(const GEO_PrimVDB *p, geo_Intrinsic id)
{
using namespace openvdb;
Metadata::ConstPtr meta = intrinsicGetMeta(p, id);
if (meta)
return meta->asBool();
else
return false;
}
void
intrinsicSetMetaBool(GEO_PrimVDB *p, geo_Intrinsic id, int64 v)
{
intrinsicSetMeta(p, id, openvdb::BoolMetadata(v != 0));
}
} // namespace anonymous
#define VDB_INTRINSIC_META_STR(CLASS, ID) { \
struct callbacks { \
static geo_Size evalS(const CLASS *o, UT_String &v) \
{ intrinsicGetMetaString(o, ID, v); return 1; } \
static geo_Size evalSA(const CLASS *o, UT_StringArray &v) \
{ \
UT_String str; \
intrinsicGetMetaString(o, ID, str); \
v.append(str); \
return 1; \
} \
static geo_Size setSS(CLASS *o, const char **v, GA_Size) \
{ intrinsicSetMetaString(o, ID, v[0]); return 1; } \
static geo_Size setSA(CLASS *o, const UT_StringArray &a) \
{ intrinsicSetMetaString(o, ID, a(0)); return 1; } \
}; \
GA_INTRINSIC_DEF_S(ID, theMetaNames.getToken(ID), 1) \
myEval[ID].myS = callbacks::evalS; \
myEval[ID].mySA = callbacks::evalSA; \
myEval[ID].mySetSS = callbacks::setSS; \
myEval[ID].mySetSA = callbacks::setSA; \
myEval[ID].myReadOnly = false; \
}
#define VDB_INTRINSIC_META_BOOL(CLASS, ID) { \
struct callbacks { \
static geo_Size eval(const CLASS *o, int64 *v, GA_Size) \
{ v[0] = intrinsicGetMetaBool(o, ID); return 1; } \
static geo_Size setFunc(CLASS *o, const int64 *v, GA_Size) \
{ intrinsicSetMetaBool(o, ID, v[0]); return 1; } \
}; \
GA_INTRINSIC_DEF_I(ID, theMetaNames.getToken(ID), 1) \
myEval[ID].myI = callbacks::eval; \
myEval[ID].mySetI = callbacks::setFunc; \
myEval[ID].myReadOnly = false; \
}
GA_START_INTRINSIC_DEF(GEO_PrimVDB, geo_NUM_INTRINSICS)
GA_INTRINSIC_VARYING_F(GEO_PrimVDB, geo_INTRINSIC_BACKGROUND,
"background", intrinsicBackgroundTupleSize, intrinsicBackground);
GA_INTRINSIC_TUPLE_F(GEO_PrimVDB, geo_INTRINSIC_VOXELSIZE,
"voxelsize", 3, intrinsicVoxelSize);
GA_INTRINSIC_TUPLE_I(GEO_PrimVDB, geo_INTRINSIC_ACTIVEVOXELDIM,
"activevoxeldimensions", 3, intrinsicActiveVoxelDim);
GA_INTRINSIC_I(GEO_PrimVDB, geo_INTRINSIC_ACTIVEVOXELCOUNT,
"activevoxelcount", intrinsicActiveVoxelCount);
GA_INTRINSIC_TUPLE_F(GEO_PrimVDB, geo_INTRINSIC_TRANSFORM,
"transform", 16, intrinsicTransform);
GA_INTRINSIC_SET_TUPLE_F(GEO_PrimVDB, geo_INTRINSIC_TRANSFORM,
intrinsicSetTransform);
GA_INTRINSIC_S(GEO_PrimVDB, geo_INTRINSIC_VOLUMEVISUALMODE,
"volumevisualmode", intrinsicVisualMode)
GA_INTRINSIC_METHOD_F(GEO_PrimVDB, geo_INTRINSIC_VOLUMEVISUALDENSITY,
"volumevisualdensity", getVisDensity)
GA_INTRINSIC_METHOD_F(GEO_PrimVDB, geo_INTRINSIC_VOLUMEVISUALISO,
"volumevisualiso", getVisIso)
GA_INTRINSIC_S(GEO_PrimVDB, geo_INTRINSIC_VOLUMEVISUALLOD,
"volumevisuallod", intrinsicVisualLod)
VDB_INTRINSIC_META_STR(GEO_PrimVDB, geo_INTRINSIC_META_GRID_CLASS)
VDB_INTRINSIC_META_STR(GEO_PrimVDB, geo_INTRINSIC_META_GRID_CREATOR)
VDB_INTRINSIC_META_BOOL(GEO_PrimVDB, geo_INTRINSIC_META_IS_LOCAL_SPACE)
VDB_INTRINSIC_META_BOOL(GEO_PrimVDB, geo_INTRINSIC_META_SAVE_HALF_FLOAT)
VDB_INTRINSIC_META_STR(GEO_PrimVDB, geo_INTRINSIC_META_VALUE_TYPE)
VDB_INTRINSIC_META_STR(GEO_PrimVDB, geo_INTRINSIC_META_VECTOR_TYPE)
GA_END_INTRINSIC_DEF(GEO_PrimVDB, GEO_Primitive)
/*static*/ bool
GEO_PrimVDB::isIntrinsicMetadata(const char *name)
{
return theMetaNames.contains(name);
}
#endif // SESI_OPENVDB || SESI_OPENVDB_PRIM
| 116,179 | C++ | 30.247983 | 129 | 0.581069 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GU_VDBPointTools.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
#include "GU_VDBPointTools.h"
| 118 | C++ | 15.999998 | 48 | 0.754237 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GEO_PrimVDB.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c) Side Effects Software Inc.
*
* Produced by:
* Side Effects Software Inc
* 477 Richmond Street West
* Toronto, Ontario
* Canada M5V 3E7
* 416-504-9876
*
* NAME: GEO_PrimVDB.h ( GEO Library, C++)
*
* COMMENTS: Custom VDB primitive.
*/
// Using the native OpenVDB Primitive shipped with Houdini is strongly recommended,
// as there is no guarantee that this code will be kept in sync with Houdini.
// However, for debugging it can be useful, so supply -DSESI_OPENVDB_PRIM to
// the compiler to build this custom primitive.
#if !defined(SESI_OPENVDB) && !defined(SESI_OPENVDB_PRIM)
#include <GEO/GEO_PrimVDB.h>
namespace openvdb_houdini {
using ::GEO_VolumeOptions;
using ::GEO_PrimVDB;
}
#else // SESI_OPENVDB || SESI_OPENVDB_PRIM
#ifndef __HDK_GEO_PrimVDB__
#define __HDK_GEO_PrimVDB__
#include <GEO/GEO_Primitive.h>
#include <GEO/GEO_VolumeOptions.h>
#include <GA/GA_Defines.h>
#include <SYS/SYS_AtomicInt.h> // for SYS_AtomicCounter
#include <UT/UT_BoundingBox.h>
#include "UT_VDBUtils.h"
#include <openvdb/Platform.h>
#include <openvdb/openvdb.h>
class GEO_Detail;
class GEO_PrimVolume;
class GEO_PrimVolumeXform;
class UT_MemoryCounter;
class OPENVDB_HOUDINI_API GEO_PrimVDB : public GEO_Primitive
{
public:
typedef uint64 UniqueId;
protected:
/// NOTE: The constructor should only be called from subclass
/// constructors.
GEO_PrimVDB(GEO_Detail *d, GA_Offset offset = GA_INVALID_OFFSET);
~GEO_PrimVDB() override;
public:
static GA_PrimitiveFamilyMask buildFamilyMask()
{ return GA_FAMILY_NONE; }
/// @{
/// Required interface methods
bool isDegenerate() const override;
int getBBox(UT_BoundingBox *bbox) const override;
void reverse() override;
UT_Vector3 computeNormal() const override;
void copyPrimitive(const GEO_Primitive *src) override;
void copySubclassData(const GA_Primitive *source) override;
using GEO_Primitive::getVertexOffset;
using GEO_Primitive::getPointOffset;
using GEO_Primitive::setPointOffset;
using GEO_Primitive::getPos3;
using GEO_Primitive::setPos3;
SYS_FORCE_INLINE
GA_Offset getVertexOffset() const
{ return getVertexOffset(0); }
SYS_FORCE_INLINE
GA_Offset getPointOffset() const
{ return getPointOffset(0); }
SYS_FORCE_INLINE
void setPointOffset(GA_Offset pt)
{ setPointOffset(0, pt); }
SYS_FORCE_INLINE
UT_Vector3 getPos3() const
{ return getPos3(0); }
SYS_FORCE_INLINE
void setPos3(const UT_Vector3 &pos)
{ setPos3(0, pos); }
/// Convert an index in the voxel array into the corresponding worldspace
/// location
void indexToPos(int x, int y, int z, UT_Vector3 &pos) const;
void findexToPos(UT_Vector3 index, UT_Vector3 &pos) const;
void indexToPos(exint x, exint y, exint z, UT_Vector3D &pos) const;
void findexToPos(UT_Vector3D index, UT_Vector3D &pos) const;
/// Convert a 3d position into the closest index value.
void posToIndex(UT_Vector3 pos, int &x, int &y, int &z) const;
void posToIndex(UT_Vector3 pos, UT_Vector3 &index) const;
void posToIndex(UT_Vector3D pos, exint &x, exint &y, exint &z) const;
void posToIndex(UT_Vector3D pos, UT_Vector3D &index) const;
/// Evaluate the voxel value at the given world space position.
/// Note that depending on the underlying VDB type, this may not
/// be sensible, in which case a zero will silently be returned
fpreal getValueF(const UT_Vector3 &pos) const;
fpreal getValueAtIndexF(int ix, int iy, int iz) const;
UT_Vector3D getValueV3(const UT_Vector3 &pos) const;
UT_Vector3D getValueAtIndexV3(int ix, int iy, int iz) const;
void getValues(float *f, int stride, const UT_Vector3 *pos, int num) const;
void getValues(int *f, int stride, const UT_Vector3 *pos, int num) const;
void getValuesAtIndices(float *f, int stride, const int *ix, const int *iy, const int *iz, int num) const;
void getValuesAtIndices(int *f, int stride, const int *ix, const int *iy, const int *iz, int num) const;
/// Vector grid variants.
void getValues(UT_Vector3 *f, int stride, const UT_Vector3 *pos, int num) const;
void getValuesAtIndices(UT_Vector3 *f, int stride, const int *ix, const int *iy, const int *iz, int num) const;
void getValues(double *f, int stride, const UT_Vector3D *pos, int num) const;
void getValues(exint *f, int stride, const UT_Vector3D *pos, int num) const;
void getValuesAtIndices(double *f, int stride, const exint *ix, const exint *iy, const exint *iz, int num) const;
void getValuesAtIndices(exint *f, int stride, const exint *ix, const exint *iy, const exint *iz, int num) const;
/// Vector grid variants.
void getValues(UT_Vector3D *f, int stride, const UT_Vector3D *pos, int num) const;
void getValuesAtIndices(UT_Vector3D *f, int stride, const exint *ix, const exint *iy, const exint *iz, int num) const;
// Worldspace gradient at the given position
UT_Vector3 getGradient(const UT_Vector3 &pos) const;
/// Evaluate this grid's gradients at the given world space positions.
/// Does nothing and returns false if grid is non-scalar.
/// If normalize is true, then the gradients will be normalized to be unit
/// length.
bool evalGradients(
UT_Vector3 *gradients,
int gradients_stride,
const UT_Vector3 *positions,
int num_positions,
bool normalize = false) const;
/// Get the storage type of the grid
SYS_FORCE_INLINE
UT_VDBType getStorageType() const
{ return myGridAccessor.getStorageType(); }
/// Get the tuple size, usually 1 or 3
SYS_FORCE_INLINE
int getTupleSize() const
{ return UTvdbGetGridTupleSize(getStorageType()); }
bool isSDF() const;
/// True if the two volumes map the same indices to the same positions.
bool isAligned(const GEO_PrimVDB *vdb) const;
/// True if the two volumes have the same active regions
bool isActiveRegionMatched(const GEO_PrimVDB *vdb) const;
/// True if we are aligned with the world axes. Ie, all our
/// off diagonals are zero and our diagonal is positive.
bool isWorldAxisAligned() const;
// Transform the matrix associated with this primitive. Translate is
// ignored.
void transform(const UT_Matrix4 &mat) override;
/// Accessors for the 4x4 matrix representing the affine transform that
/// converts from index space voxel coordinates to world space. For frustum
/// maps, this will be transform as if the taper value is set to 1.
/// @{
void setTransform4(const UT_DMatrix4 &xform4);
void setTransform4(const UT_Matrix4 &xform4);
UT_Matrix4D getTransform4() const;
/// @}
// Take the whole set of points into consideration when applying the
// point removal operation to this primitive. The method returns 0 if
// successful, -1 if it failed because it would have become degenerate,
// and -2 if it failed because it would have had to remove the primitive
// altogether.
int detachPoints(GA_PointGroup &grp) override;
/// Before a point is deleted, all primitives using the point will be
/// notified. The method should return "false" if it's impossible to
/// delete the point. Otherwise, the vertices should be removed.
GA_DereferenceStatus dereferencePoint(GA_Offset point,
bool dry_run=false) override;
GA_DereferenceStatus dereferencePoints(const GA_RangeMemberQuery &pt_q,
bool dry_run=false) override;
const GA_PrimitiveJSON *getJSON() const override;
/// This method assigns a preallocated vertex to the quadric, optionally
/// creating the topological link between the primitive and new vertex.
void assignVertex(GA_Offset new_vtx, bool update_topology);
/// Evalaute a point given a u,v coordinate (with derivatives)
bool evaluatePointRefMap(
GA_Offset result_vtx,
GA_AttributeRefMap &hlist,
fpreal u, fpreal v,
uint du, uint dv) const override;
/// Evalaute position given a u,v coordinate (with derivatives)
int evaluatePointV4(
UT_Vector4 &pos,
float u, float v = 0,
unsigned du=0, unsigned dv=0) const override
{
return GEO_Primitive::evaluatePointV4(pos, u, v,
du, dv);
}
/// @}
/// Convert transforms between native volumes and VDBs
/// @{
/// Get a GEO_PrimVolumeXform which represent's the grid's full transform.
/// The returned space's fromVoxelSpace() method will convert index space
/// voxel coordinates to world space positions (and the vice versa for
/// toVoxelSpace()).
GEO_PrimVolumeXform getIndexSpaceTransform() const;
/// Equivalent to getSpaceTransform(getGrid().evalActiveVoxelBoundingBox()).
/// The returned space's fromVoxelSpace() method will convert 0-1
/// coordinates over the active voxel bounding box to world space (and vice
/// versa for toVoxelSpace()).
GEO_PrimVolumeXform getSpaceTransform() const;
/// Gives the equivalent to GEO_PrimVolume's getSpaceTransform() by using
/// the given bounding box to determine the bounds of the transform.
/// The resulting world space sample points will be offset by half a voxel
/// so that they match GEO_PrimVolume.
/// The returned space's fromVoxelSpace() method will convert 0-1
/// coordinates over the bbox extents to world space (and vice versa for
/// toVoxelSpace()).
GEO_PrimVolumeXform getSpaceTransform(const UT_BoundingBoxD &bbox) const;
/// Sets the transform from a GEO_PrimVolume's getSpaceTransform() by using
/// the index space [(0,0,0), resolution] bbox. If force_taper is true,
/// then the resulting transform will always be a NonlinearFrustumMap even
/// if there is no tapering.
void setSpaceTransform(const GEO_PrimVolumeXform &space,
const UT_Vector3R &resolution,
bool force_taper = false);
/// @}
fpreal getTaper() const;
/// Returns the resolution of the active voxel array.
/// Does *not* mean the indices go from 0..rx, however!
void getRes(int &rx, int &ry, int &rz) const;
/// Computes the voxel diameter by taking a step in x, y, and z
/// converting to world space and taking the length of that vector.
fpreal getVoxelDiameter() const;
/// Returns the length of the voxel when you take an x, y, and z step
UT_Vector3 getVoxelSize() const;
/// Compute useful aggregate properties of the volume.
fpreal calcMinimum() const;
fpreal calcMaximum() const;
fpreal calcAverage() const;
/// VDBs may either be unbounded, or created with a specific frustum
/// range. The latter is important for tapered VDBs that otherwise
/// have a singularity at the camera location. Tools can use the
/// presence of an idxbox as a clipping box in index space.
/// This does *NOT* relate to getRes - it may be much larger or
/// even in some cases smaller.
bool getFrustumBounds(UT_BoundingBox &idxbox) const;
enum ActivateOperation
{
ACTIVATE_UNION, // Activate anything in source
ACTIVATE_INTERSECT, // Deactivate anything not in source
ACTIVATE_SUBTRACT, // Deactivate anything in source
ACTIVATE_COPY // Set our activation to match source
};
/// Activates voxels given an *index* space bounding box. This
/// is an inclusive box.
/// If this is Frustum VDB, the activation will be clipped by that.
/// Setting the value only takes effect if the voxels are activated,
/// deactivated voxels are set to the background.
void activateIndexBBox(
const openvdb::CoordBBox& bbox,
ActivateOperation operation,
bool setvalue, fpreal value)
{
activateIndexBBoxAdapter(
&bbox, operation, setvalue, value);
}
/// Activates all of the voxels in this VDB that are touched
/// by active voxels in the source.
/// If ignore_transform is true, voxels will be activated
/// by grid index instead of world space position.
void activateByVDB(const GEO_PrimVDB *vdb,
ActivateOperation operation,
bool setvalue, fpreal value,
bool ignore_transform=false);
/// @{
/// Though not strictly required (i.e. not pure virtual), these methods
/// should be implemented for proper behaviour.
GEO_Primitive *copy(int preserve_shared_pts = 0) const override;
// Have we been deactivated and stashed?
void stashed(bool beingstashed,
GA_Offset offset=GA_INVALID_OFFSET) override;
/// @}
/// @{
/// Optional interface methods. Though not required, implementing these
/// will give better behaviour for the new primitive.
UT_Vector3 baryCenter() const override;
fpreal calcVolume(const UT_Vector3 &refpt) const override;
/// Calculate the surface area of the active voxels where
/// a voxel face contributes if it borders an inactive voxel.
fpreal calcArea() const override;
/// @}
/// @{
/// Enlarge a bounding box by the bounding box of the primitive. A
/// return value of false indicates an error in the operation, most
/// likely an invalid P. For any attribute other than the position
/// these methods simply enlarge the bounding box based on the vertex.
bool enlargeBoundingBox(
UT_BoundingRect &b,
const GA_Attribute *P) const override;
bool enlargeBoundingBox(
UT_BoundingBox &b,
const GA_Attribute *P) const override;
void enlargePointBounds(UT_BoundingBox &e) const override;
/// @}
/// Enlarge a bounding sphere to encompass the primitive. A return value
/// of false indicates an error in the operation, most likely an invalid
/// P. For any attribute other than the position this method simply
/// enlarges the sphere based on the vertex.
bool enlargeBoundingSphere(
UT_BoundingSphere &b,
const GA_Attribute *P) const override;
/// Accessor for the local 3x3 affine transform matrix for the primitive.
/// For frustum maps, this will be transform as if the taper value is set
/// to 1.
/// @{
void getLocalTransform(UT_Matrix3D &result) const override;
void setLocalTransform(const UT_Matrix3D &new_mat3) override;
/// @}
/// @internal Hack to condition 4x4 matrices that we avoid creating what
/// OpenVDB erroneously thinks are singular matrices. Returns true if mat4
/// was modified.
static bool conditionMatrix(UT_Matrix4D &mat4);
/// Visualization accessors
/// @{
const GEO_VolumeOptions &getVisOptions() const { return myVis; }
void setVisOptions(const GEO_VolumeOptions &vis)
{ setVisualization(vis.myMode, vis.myIso, vis.myDensity, vis.myLod); }
void setVisualization(
GEO_VolumeVis vismode,
fpreal iso,
fpreal density,
GEO_VolumeVisLod lod = GEO_VOLUMEVISLOD_FULL)
{
myVis.myMode = vismode;
myVis.myIso = iso;
myVis.myDensity = density;
myVis.myLod = lod;
}
GEO_VolumeVis getVisualization() const { return myVis.myMode; }
fpreal getVisIso() const { return myVis.myIso; }
fpreal getVisDensity() const { return myVis.myDensity; }
GEO_VolumeVisLod getVisLod() const { return myVis.myLod; }
/// @}
/// Load the order from a JSON value
bool loadOrder(const UT_JSONValue &p);
/// @{
/// Save/Load vdb to a JSON stream
bool saveVDB(UT_JSONWriter &w, const GA_SaveMap &sm,
bool as_shmem = false) const;
bool loadVDB(UT_JSONParser &p,
bool as_shmem = false);
/// @}
bool saveVisualization(
UT_JSONWriter &w,
const GA_SaveMap &map) const;
bool loadVisualization(
UT_JSONParser &p,
const GA_LoadMap &map);
/// Method to perform quick lookup of vertex without the virtual call
GA_Offset fastVertexOffset(GA_Size UT_IF_ASSERT_P(index)) const
{
UT_ASSERT_P(index < 1);
return getVertexOffset();
}
void setVertexPoint(int i, GA_Offset pt)
{
if (i == 0)
setPointOffset(pt);
}
/// @brief Computes the total density of the volume, scaled by
/// the volume's size. Negative values will be ignored.
fpreal calcPositiveDensity() const;
SYS_FORCE_INLINE
bool hasGrid() const { return myGridAccessor.hasGrid(); }
/// @brief If this primitive's grid's voxel data (i.e., its tree)
/// is shared, replace the tree with a deep copy of itself that is
/// not shared with anyone else.
SYS_FORCE_INLINE
void makeGridUnique()
{ myGridAccessor.makeGridUnique(); }
/// @brief Returns true if the tree is not shared. If it is not shared,
/// one can make destructive edits without makeGridUnique.
bool isGridUnique() const
{ return myGridAccessor.isGridUnique(); }
/// @brief Return a reference to this primitive's grid.
/// @note Calling setGrid() invalidates all references previously returned.
SYS_FORCE_INLINE
const openvdb::GridBase & getConstGrid() const
{ return myGridAccessor.getConstGrid(*this); }
/// @brief Return a reference to this primitive's grid.
/// @note Calling setGrid() invalidates all references previously returned.
SYS_FORCE_INLINE
const openvdb::GridBase & getGrid() const
{ return getConstGrid(); }
/// @brief Return a reference to this primitive's grid.
/// @note Calling setGrid() invalidates all references previously returned.
/// @warning Call makeGridUnique() before modifying the grid's voxel data.
SYS_FORCE_INLINE
openvdb::GridBase & getGrid()
{
incrGridUniqueIds();
return myGridAccessor.getGrid(*this);
}
/// @brief Return a shared pointer to this primitive's grid.
/// @note Calling setGrid() causes the grid to which the shared pointer
/// refers to be disassociated with this primitive.
SYS_FORCE_INLINE
openvdb::GridBase::ConstPtr getConstGridPtr() const
{ return myGridAccessor.getConstGridPtr(*this); }
/// @brief Return a shared pointer to this primitive's grid.
/// @note Calling setGrid() causes the grid to which the shared pointer
/// refers to be disassociated with this primitive.
SYS_FORCE_INLINE
openvdb::GridBase::ConstPtr getGridPtr() const
{ return getConstGridPtr(); }
/// @brief Return a shared pointer to this primitive's grid.
/// @note Calling setGrid() causes the grid to which the shared pointer
/// refers to be disassociated with this primitive.
/// @warning Call makeGridUnique() before modifying the grid's voxel data.
SYS_FORCE_INLINE
openvdb::GridBase::Ptr getGridPtr()
{
incrGridUniqueIds();
return myGridAccessor.getGridPtr(*this);
}
/// @brief Set this primitive's grid to a shallow copy of the given grid.
/// @note Invalidates all previous getGrid() and getConstGrid() references
SYS_FORCE_INLINE
void setGrid(const openvdb::GridBase &grid, bool copyPosition=true)
{
incrGridUniqueIds();
myGridAccessor.setGrid(grid, *this, copyPosition);
}
/// @brief Return a reference to this primitive's grid metadata.
/// @note Calling setGrid() invalidates all references previously returned.
const openvdb::MetaMap& getConstMetadata() const
{ return getConstGrid(); }
/// @brief Return a reference to this primitive's grid metadata.
/// @note Calling setGrid() invalidates all references previously returned.
const openvdb::MetaMap& getMetadata() const
{ return getConstGrid(); }
/// @brief Return a reference to this primitive's grid metadata.
/// @note Calling setGrid() invalidates all references previously returned.
SYS_FORCE_INLINE
openvdb::MetaMap& getMetadata()
{
incrMetadataUniqueId();
return myGridAccessor.getGrid(*this);
}
/// @brief Return the value of this primitive's "name" attribute
/// in the given detail.
const char * getGridName() const;
/// @brief Return this primitive's serial number.
/// @details A primitive's serial number never changes.
UniqueId getUniqueId() const
{ return static_cast<UniqueId>(myUniqueId.relaxedLoad()); }
/// @brief Return the serial number of this primitive's voxel data.
/// @details The serial number is incremented whenever a non-const
/// reference or pointer to this primitive's grid is requested
/// (whether or not the voxel data is ultimately modified).
UniqueId getTreeUniqueId() const
{ return static_cast<UniqueId>(myTreeUniqueId.relaxedLoad()); }
/// @brief Return the serial number of this primitive's grid metadata.
/// @details The serial number is incremented whenever a non-const
/// reference to the metadata or non-const access to the grid is requested
/// (whether or not the metadata is ultimately modified).
UniqueId getMetadataUniqueId() const
{ return static_cast<UniqueId>(myMetadataUniqueId.relaxedLoad()); }
/// @brief Return the serial number of this primitive's transform.
/// @details The serial number is incremented whenever the transform
/// is modified or non-const access to this primitive's grid is requested
/// (whether or not the transform is ultimately modified).
UniqueId getTransformUniqueId() const
{ return static_cast<UniqueId>(myTransformUniqueId.relaxedLoad()); }
/// @brief If this primitive's grid resolves to one of the listed grid types,
/// invoke the functor @a op on the resolved grid.
/// @return @c true if the functor was invoked, @c false otherwise
///
/// @par Example:
/// @code
/// auto printOp = [](const openvdb::GridBase& grid) { grid.print(); };
/// const GEO_PrimVDB* prim = ...;
/// using RealGridTypes = openvdb::TypeList<openvdb::FloatGrid, openvdb::DoubleGrid>;
/// // Print info about the primitive's grid if it is a floating-point grid.
/// prim->apply<RealGridTypes>(printOp);
/// @endcode
template<typename GridTypeListT, typename OpT>
bool apply(OpT& op) const
{ return hasGrid() ? getConstGrid().apply<GridTypeListT>(op) : false; }
/// @brief If this primitive's grid resolves to one of the listed grid types,
/// invoke the functor @a op on the resolved grid.
/// @return @c true if the functor was invoked, @c false otherwise
/// @details If @a makeUnique is true, deep copy the grid's tree before
/// invoking the functor if the tree is shared with other grids.
///
/// @par Example:
/// @code
/// auto fillOp = [](const auto& grid) { // C++14
/// // Convert voxels in the given bounding box into background voxels.
/// grid.fill(openvdb::CoordBBox(openvdb::Coord(0), openvdb::Coord(99)),
/// grid.background(), /*active=*/false);
/// };
/// GEO_PrimVDB* prim = ...;
/// // Set background voxels in the primitive's grid if it is a floating-point grid.
/// using RealGridTypes = openvdb::TypeList<openvdb::FloatGrid, openvdb::DoubleGrid>;
/// prim->apply<RealGridTypes>(fillOp);
/// @endcode
template<typename GridTypeListT, typename OpT>
bool apply(OpT& op, bool makeUnique = true)
{
if (hasGrid()) {
auto& grid = myGridAccessor.getGrid(*this);
if (makeUnique) {
auto treePtr = grid.baseTreePtr();
if (treePtr.use_count() > 2) { // grid + treePtr = 2
// If the grid resolves to one of the listed types and its tree
// is shared with other grids, replace the tree with a deep copy.
grid.apply<GridTypeListT>([this](openvdb::GridBase& baseGrid) {
baseGrid.setTree(baseGrid.constBaseTree().copy());
this->incrTreeUniqueId();
});
}
}
if (grid.apply<GridTypeListT>(op)) {
incrGridUniqueIds();
return true;
}
}
return false;
}
protected:
typedef SYS_AtomicCounter AtomicUniqueId; // 64-bit
/// Register intrinsic attributes
GA_DECLARE_INTRINSICS(override)
/// Return true if the given metadata token is an intrinsic
static bool isIntrinsicMetadata(const char *name);
/// @warning vertexPoint() doesn't check the bounds. Use with caution.
GA_Offset vertexPoint(GA_Size) const
{ return getPointOffset(); }
/// Report approximate memory usage, excluding sizeof(*this),
/// because the subclass doesn't have access to myGridAccessor.
int64 getBaseMemoryUsage() const;
// This is called by the subclasses to count the
// memory used by this, excluding sizeof(*this).
void countBaseMemory(UT_MemoryCounter &counter) const;
/// @brief Return an ID number that is guaranteed to be unique across
/// all VDB primitives.
static UniqueId nextUniqueId();
void incrTreeUniqueId()
{ myTreeUniqueId.maximum(nextUniqueId()); }
void incrMetadataUniqueId()
{ myMetadataUniqueId.maximum(nextUniqueId()); }
void incrTransformUniqueId()
{ myTransformUniqueId.maximum(nextUniqueId()); }
void incrGridUniqueIds()
{
incrTreeUniqueId();
incrMetadataUniqueId();
incrTransformUniqueId();
}
/// @brief Replace this primitive's grid with a shallow copy
/// of another primitive's grid.
void copyGridFrom(const GEO_PrimVDB&, bool copyPosition=true);
/// @brief GridAccessor manages access to a GEO_PrimVDB's grid.
/// @details In keeping with OpenVDB library conventions, the grid
/// is stored internally by shared pointer. However, grid objects
/// are never shared among primitives, though their voxel data
/// (i.e., their trees) may be shared.
/// <p>Among other things, GridAccessor
/// - ensures that each primitive's transform and metadata are unique
/// (i.e., not shared with anyone else)
/// - allows primitives to share voxel data but, via makeGridUnique(),
/// provides a way to break the connection
/// - ensures that the primitive's transform and the grid's transform
/// are in sync (specifically, the translation component, which is
/// stored independently as a vertex offset).
class OPENVDB_HOUDINI_API GridAccessor
{
public:
SYS_FORCE_INLINE
GridAccessor() : myStorageType(UT_VDB_INVALID)
{ }
SYS_FORCE_INLINE
void clear()
{
myGrid.reset();
myStorageType = UT_VDB_INVALID;
}
SYS_FORCE_INLINE
openvdb::GridBase &
getGrid(const GEO_PrimVDB &prim)
{ updateGridTranslates(prim); return *myGrid; }
SYS_FORCE_INLINE
const openvdb::GridBase &
getConstGrid(const GEO_PrimVDB &prim) const
{ updateGridTranslates(prim); return *myGrid; }
SYS_FORCE_INLINE
openvdb::GridBase::Ptr
getGridPtr(const GEO_PrimVDB &prim)
{ updateGridTranslates(prim); return myGrid; }
SYS_FORCE_INLINE
openvdb::GridBase::ConstPtr
getConstGridPtr(const GEO_PrimVDB &prim) const
{ updateGridTranslates(prim); return myGrid; }
// These accessors will ensure the transform's translate is set into
// the vertex position.
SYS_FORCE_INLINE
void setGrid(const openvdb::GridBase& grid, GEO_PrimVDB& prim, bool copyPosition=true)
{ setGridAdapter(&grid, prim, copyPosition); }
SYS_FORCE_INLINE
void setTransform(
const openvdb::math::Transform &xform,
GEO_PrimVDB &prim)
{ setTransformAdapter(&xform, prim); }
void makeGridUnique();
bool isGridUnique() const;
SYS_FORCE_INLINE
UT_VDBType getStorageType() const { return myStorageType; }
SYS_FORCE_INLINE
bool hasGrid() const { return myGrid != 0; }
private:
void updateGridTranslates(const GEO_PrimVDB &prim) const;
SYS_FORCE_INLINE
void setVertexPosition(
const openvdb::math::Transform &xform,
GEO_PrimVDB &prim)
{ setVertexPositionAdapter(&xform, prim); }
void setGridAdapter(const void* grid, GEO_PrimVDB&, bool copyPosition);
void setTransformAdapter(const void* xform, GEO_PrimVDB&);
void setVertexPositionAdapter(const void* xform, GEO_PrimVDB&);
private:
openvdb::GridBase::Ptr myGrid;
UT_VDBType myStorageType;
};
private:
void activateIndexBBoxAdapter(
const void* bbox,
ActivateOperation,
bool setvalue, fpreal value);
GridAccessor myGridAccessor;
GEO_VolumeOptions myVis;
AtomicUniqueId myUniqueId;
AtomicUniqueId myTreeUniqueId;
AtomicUniqueId myMetadataUniqueId;
AtomicUniqueId myTransformUniqueId;
}; // class GEO_PrimVDB
#ifndef SESI_OPENVDB
namespace openvdb_houdini {
using ::GEO_VolumeOptions;
using ::GEO_PrimVDB;
}
#endif
////////////////////////////////////////
namespace UT_VDBUtils {
// This overload of UT_VDBUtils::callTypedGrid(), for GridBaseType = GEO_PrimVDB,
// calls makeGridUnique() on the primitive just before instantiating and
// invoking the functor on the primitive's grid. This delays the call
// to makeGridUnique() until it is known to be necessary and thus avoids
// making deep copies of grids of types that won't be processed.
template<typename GridType, typename OpType>
inline void
callTypedGrid(GEO_PrimVDB& prim, OpType& op)
{
prim.makeGridUnique();
op.template operator()<GridType>(*(UTverify_cast<GridType*>(&prim.getGrid())));
}
// Overload of callTypedGrid() for GridBaseType = const GEO_PrimVDB
template<typename GridType, typename OpType>
inline void
callTypedGrid(const GEO_PrimVDB& prim, OpType& op)
{
op.template operator()<GridType>(*(UTverify_cast<const GridType*>(&prim.getConstGrid())));
}
} // namespace UT_VDBUtils
// Define UTvdbProcessTypedGrid*() (see UT_VDBUtils.h) for grids
// belonging to primitives, for various subsets of grid types.
UT_VDB_DECL_PROCESS_TYPED_GRID(GEO_PrimVDB&)
UT_VDB_DECL_PROCESS_TYPED_GRID(const GEO_PrimVDB&)
////////////////////////////////////////
/// @brief Utility function to process the grid of a const primitive using functor @a op.
/// @details It will invoke @code op.operator()<GridT>(const GridT &grid) @endcode
/// @{
template <typename OpT>
inline bool GEOvdbProcessTypedGrid(const GEO_PrimVDB &vdb, OpT &op)
{
return UTvdbProcessTypedGrid(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridReal(const GEO_PrimVDB &vdb, OpT &op)
{
return UTvdbProcessTypedGridReal(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridScalar(const GEO_PrimVDB &vdb, OpT &op)
{
return UTvdbProcessTypedGridScalar(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridTopology(const GEO_PrimVDB &vdb, OpT &op)
{
return UTvdbProcessTypedGridTopology(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridVec3(const GEO_PrimVDB &vdb, OpT &op)
{
return UTvdbProcessTypedGridVec3(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridPoint(const GEO_PrimVDB &vdb, OpT &op)
{
return UTvdbProcessTypedGridPoint(vdb.getStorageType(), vdb.getGrid(), op);
}
/// @}
/// @brief Utility function to process the grid of a primitive using functor @a op.
/// @param vdb the primitive whose grid is to be processed
/// @param op a functor with a call operator of the form
/// @code op.operator()<GridT>(GridT &grid) @endcode
/// @param makeUnique if @c true, call <tt>vdb.makeGridUnique()</tt> before
/// invoking the functor
/// @{
template <typename OpT>
inline bool GEOvdbProcessTypedGrid(GEO_PrimVDB &vdb, OpT &op, bool makeUnique = true)
{
if (makeUnique) return UTvdbProcessTypedGrid(vdb.getStorageType(), vdb, op);
return UTvdbProcessTypedGrid(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridReal(GEO_PrimVDB &vdb, OpT &op, bool makeUnique = true)
{
if (makeUnique) return UTvdbProcessTypedGridReal(vdb.getStorageType(), vdb, op);
return UTvdbProcessTypedGridReal(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridScalar(GEO_PrimVDB &vdb, OpT &op, bool makeUnique = true)
{
if (makeUnique) return UTvdbProcessTypedGridScalar(vdb.getStorageType(), vdb, op);
return UTvdbProcessTypedGridScalar(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridTopology(GEO_PrimVDB &vdb, OpT &op, bool makeUnique = true)
{
if (makeUnique) return UTvdbProcessTypedGridTopology(vdb.getStorageType(), vdb, op);
return UTvdbProcessTypedGridTopology(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridVec3(GEO_PrimVDB &vdb, OpT &op, bool makeUnique = true)
{
if (makeUnique) return UTvdbProcessTypedGridVec3(vdb.getStorageType(), vdb, op);
return UTvdbProcessTypedGridVec3(vdb.getStorageType(), vdb.getGrid(), op);
}
template <typename OpT>
inline bool GEOvdbProcessTypedGridPoint(GEO_PrimVDB &vdb, OpT &op, bool makeUnique = true)
{
if (makeUnique) return UTvdbProcessTypedGridPoint(vdb.getStorageType(), vdb, op);
return UTvdbProcessTypedGridPoint(vdb.getStorageType(), vdb.getGrid(), op);
}
/// @}
#endif // __HDK_GEO_PrimVDB__
#endif // SESI_OPENVDB || SESI_OPENVDB_PRIM
| 38,266 | C | 42.288461 | 137 | 0.602728 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Vector_Merge.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Vector_Merge.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Merge groups of up to three scalar grids into vector grids.
#ifdef _WIN32
#define BOOST_REGEX_NO_LIB
#define HBOOST_REGEX_NO_LIB
#endif
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/ValueTransformer.h> // for tools::foreach()
#include <openvdb/tools/Prune.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_String.h>
#include <hboost/regex.hpp>
#include <functional>
#include <memory>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
// HAVE_MERGE_GROUP is disabled in Houdini
#ifdef SESI_OPENVDB
#define HAVE_MERGE_GROUP 0
#else
#define HAVE_MERGE_GROUP 1
#endif
class SOP_OpenVDB_Vector_Merge: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Vector_Merge(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Vector_Merge() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
static void addWarningMessage(SOP_OpenVDB_Vector_Merge* self, const char* msg)
{ if (self && msg) self->addWarning(SOP_MESSAGE, msg); }
};
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Group of X grids
parms.add(hutil::ParmFactory(PRM_STRING, "xgroup", "X Group")
.setDefault("@name=*.x")
.setTooltip(
"Specify a group of scalar input VDB grids to be used\n"
"as the x components of the merged vector grids.\n"
"Each x grid will be paired with a y and a z grid\n"
"(if provided) to produce an output vector grid.")
.setChoiceList(&hutil::PrimGroupMenuInput1));
// Group of Y grids
parms.add(hutil::ParmFactory(PRM_STRING, "ygroup", "Y Group")
.setDefault("@name=*.y")
.setTooltip(
"Specify a group of scalar input VDB grids to be used\n"
"as the y components of the merged vector grids.\n"
"Each y grid will be paired with an x and a z grid\n"
"(if provided) to produce an output vector grid.")
.setChoiceList(&hutil::PrimGroupMenuInput1));
// Group of Z grids
parms.add(hutil::ParmFactory(PRM_STRING, "zgroup", "Z Group")
.setDefault("@name=*.z")
.setTooltip(
"Specify a group of scalar input VDB grids to be used\n"
"as the z components of the merged vector grids.\n"
"Each z grid will be paired with an x and a y grid\n"
"(if provided) to produce an output vector grid.")
.setChoiceList(&hutil::PrimGroupMenuInput1));
// Use X name
parms.add(hutil::ParmFactory(PRM_TOGGLE, "usexname", "Use Basename of X VDB")
#ifdef SESI_OPENVDB
.setDefault(PRMoneDefaults)
#else
.setDefault(PRMzeroDefaults)
#endif
.setDocumentation(
"Use the base name of the __X Group__ as the name for the output VDB."
" For example, if __X Group__ is `Cd.x`, the generated vector VDB"
" will be named `Cd`.\n\n"
"If this option is disabled or if the __X__ primitive has no `name` attribute,"
" the output VDB will be given the __Merged VDB Name__."));
// Output vector grid name
parms.add(hutil::ParmFactory(PRM_STRING, "merge_name", "Merged VDB Name")
.setDefault("merged#")
.setTooltip(
"Specify a name for the merged vector grids.\n"
"Include a '#' character in the name to number the output grids\n"
"(starting from 1) in the order that they are processed."));
{
// Output grid's vector type (invariant, covariant, etc.)
std::vector<std::string> items;
for (int i = 0; i < openvdb::NUM_VEC_TYPES ; ++i) {
items.push_back(openvdb::GridBase::vecTypeToString(openvdb::VecType(i)));
items.push_back(openvdb::GridBase::vecTypeExamples(openvdb::VecType(i)));
}
parms.add(hutil::ParmFactory(PRM_ORD, "vectype", "Vector Type")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDocumentation("\
Specify how the output VDB's vector values should be affected by transforms:\n\
\n\
Tuple / Color / UVW:\n\
No transformation\n\
\n\
Gradient / Normal:\n\
Inverse-transpose transformation, ignoring translation\n\
\n\
Unit Normal:\n\
Inverse-transpose transformation, ignoring translation,\n\
followed by renormalization\n\
\n\
Displacement / Velocity / Acceleration:\n\
\"Regular\" transformation, ignoring translation\n\
\n\
Position:\n\
\"Regular\" transformation with translation\n"));
}
#if HAVE_MERGE_GROUP
// Toggle to enable/disable grouping
parms.add(hutil::ParmFactory(PRM_TOGGLE, "enable_grouping", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("If enabled, create a group for all merged vector grids."));
// Output vector grid group name
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Merge Group")
.setTooltip("Specify a name for the output group of merged vector grids."));
#endif
// Toggle to keep/remove source grids
parms.add(hutil::ParmFactory(PRM_TOGGLE, "remove_sources", "Remove Source VDBs")
.setDefault(PRMoneDefaults)
.setTooltip("Remove scalar grids that have been merged."));
// Toggle to copy inactive values in addition to active values
parms.add(
hutil::ParmFactory(PRM_TOGGLE, "copyinactive", "Copy Inactive Values")
.setDefault(PRMzeroDefaults)
.setTooltip(
"If enabled, merge the values of both active and inactive voxels.\n"
"If disabled, merge the values of active voxels only, treating\n"
"inactive voxels as active background voxels wherever\n"
"corresponding input voxels have different active states."));
#ifndef SESI_OPENVDB
// Verbosity toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "verbose", "Verbose")
.setDocumentation("If enabled, print debugging information to the terminal."));
#endif
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "scalar_x_group", "X Group")
.setDefault("@name=*.x"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "scalar_y_group", "Y Group")
.setDefault("@name=*.y"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "scalar_z_group", "Z Group")
.setDefault("@name=*.z"));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Vector Merge",
SOP_OpenVDB_Vector_Merge::factory, parms, *table)
.addInput("Scalar VDBs to merge into vector")
.setObsoleteParms(obsoleteParms)
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Vector_Merge::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Merge three scalar VDB primitives into one vector VDB primitive.\"\"\"\n\
\n\
@overview\n\
\n\
This node will create a vector-valued VDB volume using the values of\n\
corresponding voxels from up to three scalar VDBs as the vector components.\n\
The scalar VDBs must have the same voxel size and transform; if they do not,\n\
use the [OpenVDB Resample node|Node:sop/DW_OpenVDBResample] to resample\n\
two of the VDBs to match the third.\n\
\n\
TIP:\n\
To reverse the merge (i.e., to split a vector VDB into three scalar VDBs),\n\
use the [OpenVDB Vector Split node|Node:sop/DW_OpenVDBVectorSplit].\n\
\n\
@related\n\
- [OpenVDB Vector Split|Node:sop/DW_OpenVDBVectorSplit]\n\
- [Node:sop/vdbvectormerge]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Vector_Merge::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
for (auto axis: { "x", "y", "z" }) {
const std::string
oldName = "scalar_" + (axis + std::string{"_group"}),
newName = axis + std::string{"group"};
resolveRenamedParm(*obsoleteParms, oldName.c_str(), newName.c_str());
}
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
bool
SOP_OpenVDB_Vector_Merge::updateParmsFlags()
{
bool changed = false;
#if HAVE_MERGE_GROUP
changed |= enableParm("group", evalInt("enable_grouping", 0, 0) != 0);
#endif
return changed;
}
OP_Node*
SOP_OpenVDB_Vector_Merge::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Vector_Merge(net, name, op);
}
SOP_OpenVDB_Vector_Merge::SOP_OpenVDB_Vector_Merge(OP_Network* net,
const char* name, OP_Operator* op):
SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
namespace {
// Mapping from scalar ValueTypes to Vec3::value_types of registered vector-valued Grid types
template<typename T> struct VecValueTypeMap { using Type = T; static const bool Changed = false; };
//template<> struct VecValueTypeMap<bool> {
// using Type = int32_t; static const bool Changed = true;
//};
//template<> struct VecValueTypeMap<uint32_t> {
// using Type = int32_t; static const bool Changed = true;
//};
//template<> struct VecValueTypeMap<int64_t> {
// using Type = int32_t; static const bool Changed = true;
//};
//template<> struct VecValueTypeMap<uint64_t> {
// using Type = int32_t; static const bool Changed = true;
//};
struct InterruptException {};
// Functor to merge inactive tiles and voxels from up to three
// scalar-valued trees into one vector-valued tree
template<typename VectorTreeT, typename ScalarTreeT>
class MergeActiveOp
{
public:
using VectorValueT = typename VectorTreeT::ValueType;
using ScalarValueT = typename ScalarTreeT::ValueType;
using ScalarAccessor = typename openvdb::tree::ValueAccessor<const ScalarTreeT>;
MergeActiveOp(const ScalarTreeT* xTree, const ScalarTreeT* yTree, const ScalarTreeT* zTree,
UT_Interrupt* interrupt)
: mDummyTree(new ScalarTreeT)
, mXAcc(xTree ? *xTree : *mDummyTree)
, mYAcc(yTree ? *yTree : *mDummyTree)
, mZAcc(zTree ? *zTree : *mDummyTree)
, mInterrupt(interrupt)
{
/// @todo Consider initializing x, y and z dummy trees with background values
/// taken from the vector tree. Currently, though, missing components are always
/// initialized to zero.
// Note that copies of this op share the original dummy tree.
// That's OK, since this op doesn't modify the dummy tree.
}
MergeActiveOp(const MergeActiveOp& other)
: mDummyTree(other.mDummyTree)
, mXAcc(other.mXAcc)
, mYAcc(other.mYAcc)
, mZAcc(other.mZAcc)
, mInterrupt(other.mInterrupt)
{
if (mInterrupt && mInterrupt->opInterrupt()) { throw InterruptException(); }
}
// Given an active tile or voxel in the vector tree, set its value based on
// the values of corresponding tiles or voxels in the scalar trees.
void operator()(const typename VectorTreeT::ValueOnIter& it) const
{
const openvdb::Coord xyz = it.getCoord();
ScalarValueT
xval = mXAcc.getValue(xyz),
yval = mYAcc.getValue(xyz),
zval = mZAcc.getValue(xyz);
it.setValue(VectorValueT(xval, yval, zval));
}
private:
UT_SharedPtr<const ScalarTreeT> mDummyTree;
ScalarAccessor mXAcc, mYAcc, mZAcc;
UT_Interrupt* mInterrupt;
}; // MergeActiveOp
// Functor to merge inactive tiles and voxels from up to three
// scalar-valued trees into one vector-valued tree
template<typename VectorTreeT, typename ScalarTreeT>
struct MergeInactiveOp
{
using VectorValueT = typename VectorTreeT::ValueType;
using VectorElemT = typename VectorValueT::value_type;
using ScalarValueT = typename ScalarTreeT::ValueType;
using VectorAccessor = typename openvdb::tree::ValueAccessor<VectorTreeT>;
using ScalarAccessor = typename openvdb::tree::ValueAccessor<const ScalarTreeT>;
MergeInactiveOp(const ScalarTreeT* xTree, const ScalarTreeT* yTree, const ScalarTreeT* zTree,
VectorTreeT& vecTree, UT_Interrupt* interrupt)
: mDummyTree(new ScalarTreeT)
, mXAcc(xTree ? *xTree : *mDummyTree)
, mYAcc(yTree ? *yTree : *mDummyTree)
, mZAcc(zTree ? *zTree : *mDummyTree)
, mVecAcc(vecTree)
, mInterrupt(interrupt)
{
/// @todo Consider initializing x, y and z dummy trees with background values
/// taken from the vector tree. Currently, though, missing components are always
/// initialized to zero.
// Note that copies of this op share the original dummy tree.
// That's OK, since this op doesn't modify the dummy tree.
}
MergeInactiveOp(const MergeInactiveOp& other)
: mDummyTree(other.mDummyTree)
, mXAcc(other.mXAcc)
, mYAcc(other.mYAcc)
, mZAcc(other.mZAcc)
, mVecAcc(other.mVecAcc)
, mInterrupt(other.mInterrupt)
{
if (mInterrupt && mInterrupt->opInterrupt()) { throw InterruptException(); }
}
// Given an inactive tile or voxel in a scalar tree, activate the corresponding
// tile or voxel in the vector tree.
void operator()(const typename ScalarTreeT::ValueOffCIter& it) const
{
// Skip background tiles and voxels, since the output vector tree
// is assumed to be initialized with the correct background.
if (openvdb::math::isExactlyEqual(it.getValue(), it.getTree()->background())) return;
const openvdb::Coord& xyz = it.getCoord();
if (it.isVoxelValue()) {
mVecAcc.setActiveState(xyz, true);
} else {
// Because the vector tree was constructed with the same node configuration
// as the scalar trees, tiles can be transferred directly between the two.
mVecAcc.addTile(it.getLevel(), xyz,
openvdb::zeroVal<VectorValueT>(), /*active=*/true);
}
}
// Given an active tile or voxel in the vector tree, set its value based on
// the values of corresponding tiles or voxels in the scalar trees.
void operator()(const typename VectorTreeT::ValueOnIter& it) const
{
const openvdb::Coord xyz = it.getCoord();
ScalarValueT
xval = mXAcc.getValue(xyz),
yval = mYAcc.getValue(xyz),
zval = mZAcc.getValue(xyz);
it.setValue(VectorValueT(xval, yval, zval));
}
// Deactivate all voxels in a leaf node of the vector tree.
void operator()(const typename VectorTreeT::LeafIter& it) const
{
it->setValuesOff();
}
private:
UT_SharedPtr<const ScalarTreeT> mDummyTree;
ScalarAccessor mXAcc, mYAcc, mZAcc;
mutable VectorAccessor mVecAcc;
UT_Interrupt* mInterrupt;
}; // MergeInactiveOp
////////////////////////////////////////
class ScalarGridMerger
{
public:
using WarnFunc = std::function<void (const char*)>;
ScalarGridMerger(
const hvdb::Grid* x, const hvdb::Grid* y, const hvdb::Grid* z,
const std::string& outGridName, bool copyInactiveValues,
WarnFunc warn, UT_Interrupt* interrupt = nullptr):
mOutGridName(outGridName),
mCopyInactiveValues(copyInactiveValues),
mWarn(warn),
mInterrupt(interrupt)
{
mInGrid[0] = x; mInGrid[1] = y; mInGrid[2] = z;
}
const hvdb::GridPtr& getGrid() { return mOutGrid; }
template<typename ScalarGridT>
void operator()(const ScalarGridT& /*ignored*/)
{
if (!mInGrid[0] && !mInGrid[1] && !mInGrid[2]) return;
using ScalarTreeT = typename ScalarGridT::TreeType;
// Retrieve a scalar tree from each input grid.
const ScalarTreeT* inTree[3] = { nullptr, nullptr, nullptr };
if (mInGrid[0]) inTree[0] = &UTvdbGridCast<ScalarGridT>(mInGrid[0])->tree();
if (mInGrid[1]) inTree[1] = &UTvdbGridCast<ScalarGridT>(mInGrid[1])->tree();
if (mInGrid[2]) inTree[2] = &UTvdbGridCast<ScalarGridT>(mInGrid[2])->tree();
if (!inTree[0] && !inTree[1] && !inTree[2]) return;
// Get the type of the output vector tree.
// 1. ScalarT is the input scalar tree's value type.
using ScalarT = typename ScalarTreeT::ValueType;
// 2. VecT is Vec3<ScalarT>, provided that there is a registered Tree with that
// value type. If not, use the closest match (e.g., vec3i when ScalarT = bool).
using MappedVecT = VecValueTypeMap<ScalarT>;
using VecT = openvdb::math::Vec3<typename MappedVecT::Type>;
// 3. VecTreeT is the type of a tree with the same height and node dimensions
// as the input scalar tree, but with value type VecT instead of ScalarT.
using VecTreeT = typename ScalarTreeT::template ValueConverter<VecT>::Type;
using VecGridT = typename openvdb::Grid<VecTreeT>;
if (MappedVecT::Changed && mWarn) {
std::ostringstream ostr;
ostr << "grids of type vec3<" << openvdb::typeNameAsString<ScalarT>()
<< "> are not supported; using " << openvdb::typeNameAsString<VecT>()
<< " instead";
if (!mOutGridName.empty()) ostr << " for " << mOutGridName;
mWarn(ostr.str().c_str());
}
// Determine the background value and the transform.
VecT bkgd(0, 0, 0);
const openvdb::math::Transform* xform = nullptr;
for (int i = 0; i < 3; ++i) {
if (inTree[i]) bkgd[i] = inTree[i]->background();
if (mInGrid[i] && !xform) xform = &(mInGrid[i]->transform());
}
openvdb::math::Transform::Ptr outXform;
if (xform) outXform = xform->copy();
// Construct the output vector grid, with a background value whose
// components are the background values of the input scalar grids.
typename VecGridT::Ptr vecGrid = VecGridT::create(bkgd);
mOutGrid = vecGrid;
if (outXform) {
mOutGrid->setTransform(outXform);
// Check that all three input grids have the same transform.
bool xformMismatch = false;
for (int i = 0; i < 3 && !xformMismatch; ++i) {
if (mInGrid[i]) {
const openvdb::math::Transform* inXform = &(mInGrid[i]->transform());
if (*outXform != *inXform) xformMismatch = true;
}
}
if (xformMismatch && mWarn) {
mWarn("component grids have different transforms");
}
}
if (mCopyInactiveValues) {
try {
MergeInactiveOp<VecTreeT, ScalarTreeT>
op(inTree[0], inTree[1], inTree[2], vecGrid->tree(), mInterrupt);
// 1. For each non-background inactive value in each scalar tree,
// activate the corresponding region in the vector tree.
for (int i = 0; i < 3; ++i) {
if (mInterrupt && mInterrupt->opInterrupt()) { mOutGrid.reset(); return; }
if (!inTree[i]) continue;
// Because this is a topology-modifying operation, it must be done serially.
openvdb::tools::foreach(inTree[i]->cbeginValueOff(),
op, /*threaded=*/false, /*shareOp=*/false);
}
// 2. For each active value in the vector tree, set v = (x, y, z).
openvdb::tools::foreach(vecGrid->beginValueOn(),
op, /*threaded=*/true, /*shareOp=*/false);
// 3. Deactivate all values in the vector tree, by processing
// leaf nodes in parallel (which is safe) and tiles serially.
openvdb::tools::foreach(vecGrid->tree().beginLeaf(), op, /*threaded=*/true);
typename VecTreeT::ValueOnIter tileIt = vecGrid->beginValueOn();
tileIt.setMaxDepth(tileIt.getLeafDepth() - 1); // skip leaf nodes
for (int count = 0; tileIt; ++tileIt, ++count) {
if (count % 100 == 0 && mInterrupt && mInterrupt->opInterrupt()) {
mOutGrid.reset();
return;
}
tileIt.setValueOff();
}
} catch (InterruptException&) {
mOutGrid.reset();
return;
}
}
// Activate voxels (without setting their values) in the output vector grid so that
// its tree topology is the union of the topologies of the input scalar grids.
// Transferring voxel values from the scalar grids to the vector grid can then
// be done safely from multiple threads.
for (int i = 0; i < 3; ++i) {
if (mInterrupt && mInterrupt->opInterrupt()) { mOutGrid.reset(); return; }
if (!inTree[i]) continue;
vecGrid->tree().topologyUnion(*inTree[i]);
}
// Set a new value for each active tile or voxel in the output vector grid.
try {
MergeActiveOp<VecTreeT, ScalarTreeT>
op(inTree[0], inTree[1], inTree[2], mInterrupt);
openvdb::tools::foreach(vecGrid->beginValueOn(),
op, /*threaded=*/true, /*shareOp=*/false);
} catch (InterruptException&) {
mOutGrid.reset();
return;
}
openvdb::tools::prune(vecGrid->tree());
}
private:
const hvdb::Grid* mInGrid[3];
hvdb::GridPtr mOutGrid;
std::string mOutGridName;
bool mCopyInactiveValues;
WarnFunc mWarn;
UT_Interrupt* mInterrupt;
}; // class ScalarGridMerger
} // unnamed namespace
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Vector_Merge::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
const bool copyInactiveValues = evalInt("copyinactive", 0, time);
const bool removeSourceGrids = evalInt("remove_sources", 0, time);
#ifndef SESI_OPENVDB
const bool verbose = evalInt("verbose", 0, time);
#else
const bool verbose = false;
#endif
openvdb::VecType vecType = openvdb::VEC_INVARIANT;
{
const int vtype = static_cast<int>(evalInt("vectype", 0, time));
if (vtype >= 0 && vtype < openvdb::NUM_VEC_TYPES) {
vecType = static_cast<openvdb::VecType>(vtype);
}
}
// Get the name (or naming pattern) for merged grids.
UT_String mergeName;
evalString(mergeName, "merge_name", 0, time);
const bool useXName = evalInt("usexname", 0, time);
#if HAVE_MERGE_GROUP
// Get the group name for merged grids.
UT_String mergeGroupStr;
if (evalInt("enable_grouping", 0, time)) {
evalString(mergeGroupStr, "group", 0, time);
}
#endif
UT_AutoInterrupt progress("Merging VDB grids");
using PrimVDBSet = std::set<GEO_PrimVDB*>;
PrimVDBSet primsToRemove;
// Get the groups of x, y and z scalar grids to merge.
const GA_PrimitiveGroup *xGroup = nullptr, *yGroup = nullptr, *zGroup = nullptr;
{
UT_String groupStr;
evalString(groupStr, "xgroup", 0, time);
xGroup = matchGroup(*gdp, groupStr.toStdString());
evalString(groupStr, "ygroup", 0, time);
yGroup = matchGroup(*gdp, groupStr.toStdString());
evalString(groupStr, "zgroup", 0, time);
zGroup = matchGroup(*gdp, groupStr.toStdString());
}
using PrimVDBVec = std::vector<GEO_PrimVDB*>;
PrimVDBVec primsToGroup;
// Iterate over VDB primitives in the selected groups.
hvdb::VdbPrimIterator
xIt(xGroup ? gdp : nullptr, xGroup),
yIt(yGroup ? gdp : nullptr, yGroup),
zIt(zGroup ? gdp : nullptr, zGroup);
for (int i = 1; xIt || yIt || zIt; ++xIt, ++yIt, ++zIt, ++i) {
if (progress.wasInterrupted()) return error();
GU_PrimVDB *xVdb = *xIt, *yVdb = *yIt, *zVdb = *zIt, *nonNullVdb = nullptr;
// Extract grids from the VDB primitives and find one that is non-null.
// Process the primitives in ZYX order to ensure the X grid is preferred.
/// @todo nonNullGrid's ValueType determines the ValueType of the
/// output grid's vectors, so ideally nonNullGrid should be the
/// grid with the highest-precision ValueType.
const hvdb::Grid *xGrid = nullptr, *yGrid = nullptr, *zGrid = nullptr,
*nonNullGrid = nullptr;
if (zVdb) { zGrid = nonNullGrid = &zVdb->getGrid(); nonNullVdb = zVdb; }
if (yVdb) { yGrid = nonNullGrid = &yVdb->getGrid(); nonNullVdb = yVdb; }
if (xVdb) { xGrid = nonNullGrid = &xVdb->getGrid(); nonNullVdb = xVdb; }
if (!nonNullGrid) continue;
std::string outGridName;
if (mergeName.isstring()) {
UT_String s; s.itoa(i);
outGridName = hboost::regex_replace(
mergeName.toStdString(), hboost::regex("#+"), s.toStdString());
}
if (useXName && nonNullVdb) {
UT_String gridName(nonNullVdb->getGridName());
UT_String basename = gridName.pathUpToExtension();
if (basename.isstring()) {
outGridName = basename.toStdString();
}
}
// Merge the input grids into an output grid.
// This does not support a partial set so we quit early in that case.
ScalarGridMerger op(xGrid, yGrid, zGrid, outGridName, copyInactiveValues,
[this](const char* msg) { addWarning(SOP_MESSAGE, msg); });
nonNullGrid->apply<hvdb::NumericGridTypes>(op);
if (hvdb::GridPtr outGrid = op.getGrid()) {
outGrid->setName(outGridName);
outGrid->setVectorType(vecType);
if (verbose) {
std::ostringstream ostr;
ostr << "Merged ("
<< (xVdb ? xVdb->getGridName() : "0") << ", "
<< (yVdb ? yVdb->getGridName() : "0") << ", "
<< (zVdb ? zVdb->getGridName() : "0") << ")";
if (!outGridName.empty()) ostr << " into " << outGridName;
addMessage(SOP_MESSAGE, ostr.str().c_str());
}
if (GEO_PrimVDB* outVdb = GU_PrimVDB::buildFromGrid(*gdp, outGrid, nonNullVdb, outGridName.c_str())) {
primsToGroup.push_back(outVdb);
}
// Flag the input grids for removal.
primsToRemove.insert(xVdb);
primsToRemove.insert(yVdb);
primsToRemove.insert(zVdb);
}
}
#if HAVE_MERGE_GROUP
// Optionally, add the newly-created vector grids to a group.
if (!primsToGroup.empty() && mergeGroupStr.isstring()) {
GA_PrimitiveGroup* mergeGroup =
gdp->findPrimitiveGroup(mergeGroupStr.buffer());
if (mergeGroup == nullptr) {
mergeGroup = gdp->newPrimitiveGroup(mergeGroupStr.buffer());
}
if (mergeGroup != nullptr) {
for (PrimVDBVec::iterator i = primsToGroup.begin(), e = primsToGroup.end();
i != e; ++i)
{
mergeGroup->add(*i);
}
}
}
#endif
if (removeSourceGrids) {
// Remove scalar grids that were merged.
primsToRemove.erase(nullptr);
for (PrimVDBSet::iterator i = primsToRemove.begin(), e = primsToRemove.end();
i != e; ++i)
{
gdp->destroyPrimitive(*(*i), /*andPoints=*/true);
}
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 28,555 | C++ | 36.772487 | 118 | 0.608195 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Transform.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Transform.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/VectorTransformer.h> // for transformVectors()
#include <UT/UT_Interrupt.h>
#include <hboost/math/constants/constants.hpp>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Transform: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Transform(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Transform() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
};
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDBs to be transformed.")
.setDocumentation(
"A subset of the input VDBs to be transformed"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "xOrd", "Transform Order")
.setDefault("tsr") ///< @todo Houdini default is "srt"
.setChoiceList(&PRMtrsMenu)
.setTypeExtended(PRM_TYPE_JOIN_PAIR)
.setTooltip("The order in which transformations and rotations occur"));
parms.add(hutil::ParmFactory(
PRM_STRING | PRM_Type(PRM_Type::PRM_INTERFACE_LABEL_NONE), "rOrd", "")
.setDefault("zyx") ///< @todo Houdini default is "xyz"
.setChoiceList(&PRMxyzMenu));
parms.add(hutil::ParmFactory(PRM_XYZ_J, "t", "Translate")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setDocumentation("The amount of translation along the _x_, _y_ and _z_ axes"));
parms.add(hutil::ParmFactory(PRM_XYZ_J, "r", "Rotate")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setDocumentation("The amount of rotation about the _x_, _y_ and _z_ axes"));
parms.add(hutil::ParmFactory(PRM_XYZ_J, "s", "Scale")
.setVectorSize(3)
.setDefault(PRMoneDefaults)
.setDocumentation("Nonuniform scaling along the _x_, _y_ and _z_ axes"));
parms.add(hutil::ParmFactory(PRM_XYZ_J, "p", "Pivot")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setDocumentation("The pivot point for scaling and rotation"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "uniformScale", "Uniform Scale")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_FREE, 10)
.setDocumentation("Uniform scaling along all three axes"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "invert", "Invert Transformation")
.setDefault(PRMzeroDefaults)
.setDocumentation("Perform the inverse transformation."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "xformvectors", "Transform Vectors")
.setDefault(PRMzeroDefaults)
.setTooltip(
"Apply the transform to the voxel values of vector-valued VDBs,\n"
"in accordance with those VDBs' Vector Type attributes.\n")
.setDocumentation(
"Apply the transform to the voxel values of vector-valued VDBs,"
" in accordance with those VDBs' __Vector Type__ attributes (as set,"
" for example, with the [OpenVDB Create|Node:sop/DW_OpenVDBCreate] node)."));
hvdb::OpenVDBOpFactory("VDB Transform", SOP_OpenVDB_Transform::factory, parms, *table)
.setNativeName("")
.addInput("VDBs to transform")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Transform::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Modify the transforms of VDB volumes.\"\"\"\n\
\n\
@overview\n\
\n\
This node modifies the transform associated with each input VDB volume.\n\
It is usually preferable to use Houdini's native [Transform|Node:sop/xform] node,\n\
except if you want to also transform the _values_ of a vector-valued VDB.\n\
\n\
@related\n\
- [Node:sop/xform]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
OP_Node*
SOP_OpenVDB_Transform::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Transform(net, name, op);
}
SOP_OpenVDB_Transform::SOP_OpenVDB_Transform(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
namespace {
// Functor for use with GEOvdbApply() to apply a transform
// to the voxel values of vector-valued grids
struct VecXformOp
{
openvdb::Mat4d mat;
VecXformOp(const openvdb::Mat4d& _mat): mat(_mat) {}
template<typename GridT> void operator()(GridT& grid) const
{
openvdb::tools::transformVectors(grid, mat);
}
};
} // unnamed namespace
OP_ERROR
SOP_OpenVDB_Transform::Cache::cookVDBSop(OP_Context& context)
{
try {
using MapBase = openvdb::math::MapBase;
using AffineMap = openvdb::math::AffineMap;
using NonlinearFrustumMap = openvdb::math::NonlinearFrustumMap;
using Transform = openvdb::math::Transform;
const fpreal time = context.getTime();
// Get UI parameters
openvdb::Vec3R t(evalVec3R("t", time)), r(evalVec3R("r", time)),
s(evalVec3R("s", time)), p(evalVec3R("p", time));
s *= evalFloat("uniformScale", 0, time);
const auto xformOrder = evalStdString("xOrd", time);
const auto rotOrder = evalStdString("rOrd", time);
const bool flagInverse = evalInt("invert", 0, time);
const bool xformVec = evalInt("xformvectors", 0, time);
const auto isValidOrder = [](const std::string& expected, const std::string& actual) {
if (actual.size() != expected.size()) return false;
using CharSet = std::set<std::string::value_type>;
return (CharSet(actual.begin(), actual.end())
== CharSet(expected.begin(), expected.end()));
};
if (!isValidOrder("rst", xformOrder)) {
std::ostringstream mesg;
mesg << "Invalid transform order \"" << xformOrder
<< "\"; expected \"tsr\", \"rst\", etc.";
throw std::runtime_error(mesg.str());
}
if (!isValidOrder("xyz", rotOrder)) {
std::ostringstream mesg;
mesg << "Invalid rotation order \"" << rotOrder
<< "\"; expected \"xyz\", \"zyx\", etc.";
throw std::runtime_error(mesg.str());
}
// Get the group of grids to be transformed.
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
UT_AutoInterrupt progress("Transform");
// Build up the transform matrix from the UI parameters
const double deg2rad = hboost::math::constants::pi<double>() / 180.0;
openvdb::Mat4R mat(openvdb::Mat4R::identity());
const auto rotate = [&]() {
for (auto axis = rotOrder.rbegin(); axis != rotOrder.rend(); ++axis) {
switch (*axis) {
case 'x': mat.preRotate(openvdb::math::X_AXIS, deg2rad*r[0]); break;
case 'y': mat.preRotate(openvdb::math::Y_AXIS, deg2rad*r[1]); break;
case 'z': mat.preRotate(openvdb::math::Z_AXIS, deg2rad*r[2]); break;
}
}
};
if (xformOrder == "trs") {
mat.preTranslate(p);
mat.preScale(s);
rotate();
mat.preTranslate(-p);
mat.preTranslate(t);
} else if (xformOrder == "tsr") {
mat.preTranslate(p);
rotate();
mat.preScale(s);
mat.preTranslate(-p);
mat.preTranslate(t);
} else if (xformOrder == "rts") {
mat.preTranslate(p);
mat.preScale(s);
mat.preTranslate(-p);
mat.preTranslate(t);
mat.preTranslate(p);
rotate();
mat.preTranslate(-p);
} else if (xformOrder == "rst") {
mat.preTranslate(t);
mat.preTranslate(p);
mat.preScale(s);
rotate();
mat.preTranslate(-p);
} else if (xformOrder == "str") {
mat.preTranslate(p);
rotate();
mat.preTranslate(-p);
mat.preTranslate(t);
mat.preTranslate(p);
mat.preScale(s);
mat.preTranslate(-p);
} else /*if (xformOrder == "srt")*/ {
mat.preTranslate(t);
mat.preTranslate(p);
rotate();
mat.preScale(s);
mat.preTranslate(-p);
}
if (flagInverse) mat = mat.inverse();
const VecXformOp xformOp(mat);
// Construct an affine map.
AffineMap map(mat);
// For each VDB primitive in the given group...
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (progress.wasInterrupted()) throw std::runtime_error("Interrupted");
GU_PrimVDB* vdb = *it;
// No need to make the grid unique at this point, since we might not need
// to modify its voxel data.
hvdb::Grid& grid = vdb->getGrid();
const auto& transform = grid.constTransform();
// Merge the transform's current affine representation with the new affine map.
AffineMap::Ptr compound(
new AffineMap(*transform.baseMap()->getAffineMap(), map));
// Simplify the affine compound map
auto affineMap = openvdb::math::simplify(compound);
Transform::Ptr newTransform;
if (transform.isLinear()) {
newTransform.reset(new Transform(affineMap));
}
else {
auto frustumMap = transform.constMap<NonlinearFrustumMap>();
if (!frustumMap) {
throw std::runtime_error{"Unsupported non-linear map - " + transform.mapType()};
}
// Create a new NonlinearFrustumMap that replaces the affine map with the transformed one.
MapBase::Ptr newFrustumMap(new NonlinearFrustumMap(
frustumMap->getBBox(), frustumMap->getTaper(), frustumMap->getDepth(), affineMap));
newTransform.reset(new Transform(newFrustumMap));
}
// Replace the transform.
grid.setTransform(newTransform);
// Update the primitive's vertex position.
/// @todo Need a simpler way to do this.
hvdb::GridPtr copyOfGrid = grid.copyGrid();
copyOfGrid->setTransform(grid.constTransform().copy());
vdb->setGrid(*copyOfGrid);
if (xformVec && vdb->getConstGrid().isInWorldSpace()
&& vdb->getConstGrid().getVectorType() != openvdb::VEC_INVARIANT)
{
// If (and only if) the grid is vector-valued, deep copy it,
// then apply the transform to each voxel's value.
hvdb::GEOvdbApply<hvdb::Vec3GridTypes>(*vdb, xformOp);
}
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 11,597 | C++ | 34.907121 | 106 | 0.596189 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SHOP_OpenVDB_Points.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file SHOP_OpenVDB_Points.cc
///
/// @authors Dan Bailey, Richard Kwok
///
/// @brief The Delayed Load Procedural SHOP for OpenVDB Points.
#include <UT/UT_DSOVersion.h>
#include <UT/UT_Version.h>
#include <UT/UT_Ramp.h>
#include <OP/OP_OperatorTable.h>
#include <SHOP/SHOP_Node.h>
#include <SHOP/SHOP_Operator.h>
#include <PRM/PRM_Include.h>
#include <houdini_utils/ParmFactory.h>
#include <sstream>
namespace hutil = houdini_utils;
class SHOP_OpenVDB_Points : public SHOP_Node
{
public:
static const char* nodeName() { return "openvdb_points"; }
SHOP_OpenVDB_Points(OP_Network *parent, const char *name, OP_Operator *entry);
~SHOP_OpenVDB_Points() override = default;
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
bool buildShaderString(UT_String &result, fpreal now, const UT_Options *options,
OP_Node *obj=0, OP_Node *sop=0, SHOP_TYPE interpretType = SHOP_INVALID) override;
protected:
OP_ERROR cookMe(OP_Context&) override;
bool updateParmsFlags() override;
}; // class SHOP_OpenVDB_Points
////////////////////////////////////////
OP_Node*
SHOP_OpenVDB_Points::factory(OP_Network* net, const char* name, OP_Operator* op)
{
return new SHOP_OpenVDB_Points(net, name, op);
}
SHOP_OpenVDB_Points::SHOP_OpenVDB_Points(OP_Network *parent, const char *name, OP_Operator *entry)
: SHOP_Node(parent, name, entry, SHOP_GEOMETRY)
{
}
bool
SHOP_OpenVDB_Points::buildShaderString(UT_String &result, fpreal now,
const UT_Options*, OP_Node*, OP_Node*, SHOP_TYPE)
{
UT_String fileStr = "";
evalString(fileStr, "file", 0, now);
UT_String groupMaskStr = "";
evalString(groupMaskStr, "groupmask", 0, now);
UT_String attrMaskStr = "";
evalString(attrMaskStr, "attrmask", 0, now);
std::stringstream ss;
ss << SHOP_OpenVDB_Points::nodeName();
ss << " file \"" << fileStr.toStdString() << "\"";
ss << " streamdata " << evalInt("streamdata", 0, now);
ss << " groupmask \"" << groupMaskStr.toStdString() << "\"";
ss << " attrmask \"" << attrMaskStr.toStdString() << "\"";
ss << " speedtocolor " << evalInt("speedtocolor", 0, now);
ss << " maxspeed " << evalFloat("maxspeed", 0, now);
// write the speed/color ramp into the ifd
UT_Ramp ramp;
updateRampFromMultiParm(now, getParm("function"), ramp);
ss << " ramp \"";
for(int n = 0, N = ramp.getNodeCount(); n < N; n++){
const UT_ColorNode* rampNode = ramp.getNode(n);
ss << rampNode->t << " ";
ss << rampNode->rgba.r << " " << rampNode->rgba.g << " " << rampNode->rgba.b << " ";
ss << static_cast<int>(rampNode->basis) << " ";
}
ss << "\"";
result = ss.str();
return true;
}
OP_ERROR
SHOP_OpenVDB_Points::cookMe(OP_Context& context)
{
return SHOP_Node::cookMe(context);
}
bool
SHOP_OpenVDB_Points::updateParmsFlags()
{
bool changed = false;
const bool speedToColor = evalInt("speedtocolor", 0, 0);
changed |= enableParm("sep1", speedToColor);
changed |= setVisibleState("sep1", speedToColor);
changed |= enableParm("maxspeed", speedToColor);
changed |= setVisibleState("maxspeed", speedToColor);
changed |= enableParm("function", speedToColor);
changed |= setVisibleState("function", speedToColor);
return changed;
}
////////////////////////////////////////
// Build UI and register this operator.
void
newShopOperator(OP_OperatorTable *table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_FILE, "file", "File")
.setDefault("./filename.vdb")
.setHelpText("File path to the VDB to load."));
parms.add(hutil::ParmFactory(PRM_TOGGLE,
"streamdata", "Stream Data for Maximum Memory Efficiency")
.setDefault(PRMoneDefaults)
.setHelpText(
"Stream the data from disk to keep the memory footprint as small as possible."
" This will make the initial conversion marginally slower because the data"
" will be loaded twice, once for pre-computation to evaluate the bounding box"
" and once for the actual conversion."));
parms.add(hutil::ParmFactory(PRM_STRING, "groupmask", "Group Mask")
.setDefault("")
.setHelpText("Specify VDB Points Groups to use. (Default is all groups)"));
parms.add(hutil::ParmFactory(PRM_STRING, "attrmask", "Attribute Mask")
.setDefault("")
.setHelpText("Specify VDB Points Attributes to use. (Default is all attributes)"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "speedtocolor", "Map Speed To Color")
.setDefault(PRMzeroDefaults)
.setHelpText(
"Replaces the 'Cd' point attribute with colors mapped from the"
" 'v' point attribute using a ramp."));
parms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep1", ""));
parms.add(hutil::ParmFactory(PRM_FLT_J, "maxspeed", "Max Speed")
.setDefault(1.0f)
.setHelpText("Reference for 1.0 on the color gradient."));
parms.add(hutil::ParmFactory(PRM_MULTITYPE_RAMP_RGB, "function", "Speed to Color Function")
.setDefault(PRMtwoDefaults)
.setHelpText("Function mapping speeds between 0 and 1 to a color."));
//////////
// Register this operator.
SHOP_Operator* shop = new SHOP_Operator(SHOP_OpenVDB_Points::nodeName(), "OpenVDB Points",
SHOP_OpenVDB_Points::factory,
parms.get(),
/*child_table_name=*/nullptr,
/*min_sources=*/0, /*max_sources=*/0,
SHOP_Node::myVariableList,
OP_FLAG_GENERATOR,
SHOP_AUTOADD_NONE);
shop->setIconName("SHOP_geometry");
table->addOperator(shop);
//////////
// Set the SHOP-specific data
SHOP_OperatorInfo* info = UTverify_cast<SHOP_OperatorInfo*>(shop->getOpSpecificData());
info->setShaderType(SHOP_GEOMETRY);
// Set the rendermask to "*" and try to support *all* renderers.
info->setRenderMask("*");
}
| 6,057 | C++ | 30.226804 | 98 | 0.638105 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/PointUtils.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file PointUtils.cc
/// @authors Dan Bailey, Nick Avramoussis, Richard Kwok
#include "PointUtils.h"
#include "AttributeTransferUtil.h"
#include "Utils.h"
#include <openvdb/openvdb.h>
#include <openvdb/points/AttributeArrayString.h>
#include <openvdb/points/PointAttribute.h>
#include <openvdb/points/PointConversion.h>
#include <openvdb/points/PointDataGrid.h>
#include <GA/GA_AIFTuple.h>
#include <GA/GA_ElementGroup.h>
#include <GA/GA_Iterator.h>
#include <CH/CH_Manager.h> // for CHgetEvalTime
#include <PRM/PRM_SpareData.h>
#include <SOP/SOP_Node.h>
#include <UT/UT_UniquePtr.h>
#include <algorithm>
#include <map>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>
using namespace openvdb;
using namespace openvdb::points;
namespace hvdb = openvdb_houdini;
namespace {
inline GA_Storage
gaStorageFromAttrString(const openvdb::Name& type)
{
if (type == "string") return GA_STORE_STRING;
else if (type == "bool") return GA_STORE_BOOL;
else if (type == "int8") return GA_STORE_INT8;
else if (type == "int16") return GA_STORE_INT16;
else if (type == "int32") return GA_STORE_INT32;
else if (type == "int64") return GA_STORE_INT64;
else if (type == "float") return GA_STORE_REAL32;
else if (type == "double") return GA_STORE_REAL64;
else if (type == "vec3i") return GA_STORE_INT32;
else if (type == "vec3s") return GA_STORE_REAL32;
else if (type == "vec3d") return GA_STORE_REAL64;
else if (type == "quats") return GA_STORE_REAL32;
else if (type == "quatd") return GA_STORE_REAL64;
else if (type == "mat3s") return GA_STORE_REAL32;
else if (type == "mat3d") return GA_STORE_REAL64;
else if (type == "mat4s") return GA_STORE_REAL32;
else if (type == "mat4d") return GA_STORE_REAL64;
return GA_STORE_INVALID;
}
// @{
// Houdini GA Handle Traits
template<typename T> struct GAHandleTraits { using RW = GA_RWHandleF; using RO = GA_ROHandleF; };
template<> struct GAHandleTraits<bool> { using RW = GA_RWHandleI; using RO = GA_ROHandleI; };
template<> struct GAHandleTraits<int8_t> { using RW = GA_RWHandleI; using RO = GA_ROHandleI; };
template<> struct GAHandleTraits<int16_t> { using RW = GA_RWHandleI; using RO = GA_ROHandleI; };
template<> struct GAHandleTraits<int32_t> { using RW = GA_RWHandleI; using RO = GA_ROHandleI; };
template<> struct GAHandleTraits<int64_t> { using RW = GA_RWHandleID; using RO = GA_ROHandleID; };
template<> struct GAHandleTraits<half> { using RW = GA_RWHandleH; using RO = GA_ROHandleH; };
template<> struct GAHandleTraits<float> { using RW = GA_RWHandleF; using RO = GA_ROHandleF; };
template<> struct GAHandleTraits<double> { using RW = GA_RWHandleD; using RO = GA_ROHandleD; };
template<> struct GAHandleTraits<std::string> { using RW = GA_RWHandleS; using RO = GA_ROHandleS; };
template<>
struct GAHandleTraits<openvdb::math::Vec3<int>> { using RW=GA_RWHandleV3; using RO=GA_ROHandleV3; };
template<>
struct GAHandleTraits<openvdb::Vec3s> { using RW = GA_RWHandleV3; using RO = GA_ROHandleV3; };
template<>
struct GAHandleTraits<openvdb::Vec3d> { using RW = GA_RWHandleV3D; using RO = GA_ROHandleV3D; };
template<>
struct GAHandleTraits<openvdb::math::Mat3s> { using RW = GA_RWHandleM3; using RO = GA_ROHandleM3; };
template<>
struct GAHandleTraits<openvdb::math::Mat3d> { using RW = GA_RWHandleM3D; using RO = GA_ROHandleM3D; };
template<>
struct GAHandleTraits<openvdb::Mat4s> { using RW = GA_RWHandleM4; using RO = GA_ROHandleM4; };
template<>
struct GAHandleTraits<openvdb::Mat4d> { using RW = GA_RWHandleM4D; using RO = GA_ROHandleM4D; };
template<>
struct GAHandleTraits<openvdb::math::Quats> { using RW = GA_RWHandleQ; using RO = GA_ROHandleQ; };
template<>
struct GAHandleTraits<openvdb::math::Quatd> { using RW = GA_RWHandleQD; using RO = GA_ROHandleQD; };
// @}
template<typename HandleType, typename ValueType>
inline ValueType
readAttributeValue(const HandleType& handle, const GA_Offset offset,
const openvdb::Index component = 0)
{
return ValueType(handle.get(offset, component));
}
template<>
inline openvdb::math::Vec3<float>
readAttributeValue(const GA_ROHandleV3& handle, const GA_Offset offset,
const openvdb::Index component)
{
openvdb::math::Vec3<float> dstValue;
const UT_Vector3F value(handle.get(offset, component));
dstValue[0] = value[0]; dstValue[1] = value[1]; dstValue[2] = value[2];
return dstValue;
}
template<>
inline openvdb::math::Vec3<int>
readAttributeValue(const GA_ROHandleV3& handle, const GA_Offset offset,
const openvdb::Index component)
{
openvdb::math::Vec3<int> dstValue;
const UT_Vector3 value(handle.get(offset, component));
dstValue[0] = static_cast<int>(value[0]);
dstValue[1] = static_cast<int>(value[1]);
dstValue[2] = static_cast<int>(value[2]);
return dstValue;
}
template<>
inline openvdb::math::Vec3<double>
readAttributeValue(const GA_ROHandleV3D& handle, const GA_Offset offset,
const openvdb::Index component)
{
openvdb::math::Vec3<double> dstValue;
const UT_Vector3D value(handle.get(offset, component));
dstValue[0] = value[0]; dstValue[1] = value[1]; dstValue[2] = value[2];
return dstValue;
}
template<>
inline openvdb::math::Quat<float>
readAttributeValue(const GA_ROHandleQ& handle, const GA_Offset offset,
const openvdb::Index component)
{
openvdb::math::Quat<float> dstValue;
const UT_QuaternionF value(handle.get(offset, component));
dstValue[0] = value[0]; dstValue[1] = value[1]; dstValue[2] = value[2]; dstValue[3] = value[3];
return dstValue;
}
template<>
inline openvdb::math::Quat<double>
readAttributeValue(const GA_ROHandleQD& handle, const GA_Offset offset,
const openvdb::Index component)
{
openvdb::math::Quat<double> dstValue;
const UT_QuaternionD value(handle.get(offset, component));
dstValue[0] = value[0]; dstValue[1] = value[1]; dstValue[2] = value[2]; dstValue[3] = value[3];
return dstValue;
}
template<>
inline openvdb::math::Mat3<float>
readAttributeValue(const GA_ROHandleM3& handle, const GA_Offset offset,
const openvdb::Index component)
{
// read transposed matrix because Houdini uses column-major order so as
// to be compatible with OpenGL
const UT_Matrix3F value(handle.get(offset, component));
openvdb::math::Mat3<float> dstValue(value.data());
return dstValue.transpose();
}
template<>
inline openvdb::math::Mat3<double>
readAttributeValue(const GA_ROHandleM3D& handle, const GA_Offset offset,
const openvdb::Index component)
{
// read transposed matrix because Houdini uses column-major order so as
// to be compatible with OpenGL
const UT_Matrix3D value(handle.get(offset, component));
openvdb::math::Mat3<double> dstValue(value.data());
return dstValue.transpose();
}
template<>
inline openvdb::math::Mat4<float>
readAttributeValue(const GA_ROHandleM4& handle, const GA_Offset offset,
const openvdb::Index component)
{
// read transposed matrix because Houdini uses column-major order so as
// to be compatible with OpenGL
const UT_Matrix4F value(handle.get(offset, component));
openvdb::math::Mat4<float> dstValue(value.data());
return dstValue.transpose();
}
template<>
inline openvdb::math::Mat4<double>
readAttributeValue(const GA_ROHandleM4D& handle, const GA_Offset offset,
const openvdb::Index component)
{
// read transposed matrix because Houdini uses column-major order so as
// to be compatible with OpenGL
const UT_Matrix4D value(handle.get(offset, component));
openvdb::math::Mat4<double> dstValue(value.data());
return dstValue.transpose();
}
template<>
inline openvdb::Name
readAttributeValue(const GA_ROHandleS& handle, const GA_Offset offset,
const openvdb::Index component)
{
return openvdb::Name(UT_String(handle.get(offset, component)).toStdString());
}
template<typename HandleType, typename ValueType>
inline void
writeAttributeValue(const HandleType& handle, const GA_Offset offset,
const openvdb::Index component, const ValueType& value)
{
handle.set(offset, component, static_cast<typename HandleType::BASETYPE>(value));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleV3& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::math::Vec3<int>& value)
{
handle.set(offset, component, UT_Vector3F(
static_cast<float>(value.x()),
static_cast<float>(value.y()),
static_cast<float>(value.z())));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleV3& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::math::Vec3<float>& value)
{
handle.set(offset, component, UT_Vector3(value.x(), value.y(), value.z()));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleV3D& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::math::Vec3<double>& value)
{
handle.set(offset, component, UT_Vector3D(value.x(), value.y(), value.z()));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleQ& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::math::Quat<float>& value)
{
handle.set(offset, component, UT_QuaternionF(value.x(), value.y(), value.z(), value.w()));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleQD& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::math::Quat<double>& value)
{
handle.set(offset, component, UT_QuaternionD(value.x(), value.y(), value.z(), value.w()));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleM3& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::math::Mat3<float>& value)
{
// write transposed matrix because Houdini uses column-major order so as
// to be compatible with OpenGL
const float* data(value.asPointer());
handle.set(offset, component, UT_Matrix3F(data[0], data[3], data[6],
data[1], data[4], data[7],
data[2], data[5], data[8]));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleM3D& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::math::Mat3<double>& value)
{
// write transposed matrix because Houdini uses column-major order so as
// to be compatible with OpenGL
const double* data(value.asPointer());
handle.set(offset, component, UT_Matrix3D(data[0], data[3], data[6],
data[1], data[4], data[7],
data[2], data[5], data[8]));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleM4& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::math::Mat4<float>& value)
{
// write transposed matrix because Houdini uses column-major order so as
// to be compatible with OpenGL
const float* data(value.asPointer());
handle.set(offset, component, UT_Matrix4F(data[0], data[4], data[8], data[12],
data[1], data[5], data[9], data[13],
data[2], data[6], data[10], data[14],
data[3], data[7], data[11], data[15]));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleM4D& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::math::Mat4<double>& value)
{
// write transposed matrix because Houdini uses column-major order so as
// to be compatible with OpenGL
const double* data(value.asPointer());
handle.set(offset, component, UT_Matrix4D(data[0], data[4], data[8], data[12],
data[1], data[5], data[9], data[13],
data[2], data[6], data[10], data[14],
data[3], data[7], data[11], data[15]));
}
template<>
inline void
writeAttributeValue(const GA_RWHandleS& handle, const GA_Offset offset,
const openvdb::Index component, const openvdb::Name& value)
{
handle.set(offset, component, value.c_str());
}
/// @brief Writeable wrapper class around Houdini point attributes which hold
/// a reference to the GA Attribute to write
template <typename T>
struct HoudiniWriteAttribute
{
using ValueType = T;
struct Handle
{
explicit Handle(HoudiniWriteAttribute<T>& attribute)
: mHandle(&attribute.mAttribute) { }
template <typename ValueType>
void set(openvdb::Index offset, openvdb::Index stride, const ValueType& value) {
writeAttributeValue(mHandle, GA_Offset(offset), stride, T(value));
}
private:
typename GAHandleTraits<T>::RW mHandle;
}; // struct Handle
explicit HoudiniWriteAttribute(GA_Attribute& attribute)
: mAttribute(attribute) { }
void expand() {
mAttribute.hardenAllPages();
}
void compact() {
mAttribute.tryCompressAllPages();
}
private:
GA_Attribute& mAttribute;
}; // struct HoudiniWriteAttribute
/// @brief Readable wrapper class around Houdini point attributes which hold
/// a reference to the GA Attribute to access and optionally a list of offsets
template <typename T>
struct HoudiniReadAttribute
{
using value_type = T;
using PosType = T;
using ReadHandleType = typename GAHandleTraits<T>::RO;
explicit HoudiniReadAttribute(const GA_Attribute& attribute,
hvdb::OffsetListPtr offsets = hvdb::OffsetListPtr())
: mHandle(&attribute)
, mAttribute(attribute)
, mOffsets(offsets) { }
static void get(const GA_Attribute& attribute, T& value, const GA_Offset offset,
const openvdb::Index component)
{
const ReadHandleType handle(&attribute);
value = readAttributeValue<ReadHandleType, T>(handle, offset, component);
}
// Return the value of the nth point in the array (scalar type only)
void get(T& value, const size_t n, const openvdb::Index component = 0) const
{
value = readAttributeValue<ReadHandleType, T>(mHandle, getOffset(n), component);
}
// Only provided to match the required interface for the PointPartitioner
void getPos(size_t n, T& xyz) const { return this->get(xyz, n); }
size_t size() const
{
return mOffsets ? mOffsets->size() : size_t(mAttribute.getIndexMap().indexSize());
}
private:
GA_Offset getOffset(size_t n) const {
return mOffsets ? (*mOffsets)[n] : mAttribute.getIndexMap().offsetFromIndex(GA_Index(n));
}
const ReadHandleType mHandle;
const GA_Attribute& mAttribute;
hvdb::OffsetListPtr mOffsets;
}; // HoudiniReadAttribute
struct HoudiniGroup
{
explicit HoudiniGroup(GA_PointGroup& group,
openvdb::Index64 startOffset, openvdb::Index64 total)
: mGroup(group)
, mStartOffset(startOffset)
, mTotal(total)
{
mBackingArray.resize(total, 0);
}
HoudiniGroup(const HoudiniGroup &) = delete;
HoudiniGroup& operator=(const HoudiniGroup &) = delete;
void setOffsetOn(openvdb::Index index) { mBackingArray[index - mStartOffset] = 1; }
void finalize() {
for (openvdb::Index64 i = 0, n = mTotal; i < n; i++) {
if (mBackingArray[i]) {
mGroup.addOffset(GA_Offset(i + mStartOffset));
}
}
}
private:
GA_PointGroup& mGroup;
openvdb::Index64 mStartOffset;
openvdb::Index64 mTotal;
// This is not a bit field as we need to allow threadsafe updates:
std::vector<unsigned char> mBackingArray;
}; // HoudiniGroup
template <typename ValueType, typename CodecType = NullCodec>
inline void
convertAttributeFromHoudini(PointDataTree& tree, const tools::PointIndexTree& indexTree,
const Name& name, const GA_Attribute* const attribute,
const GA_Defaults& defaults, const Index stride = 1)
{
static_assert(!std::is_base_of<AttributeArray, ValueType>::value,
"ValueType must not be derived from AttributeArray");
static_assert(!std::is_same<ValueType, Name>::value,
"ValueType must not be Name/std::string");
using HoudiniAttribute = HoudiniReadAttribute<ValueType>;
ValueType value = hvdb::evalAttrDefault<ValueType>(defaults, 0);
// empty metadata if default is zero
if (!math::isZero<ValueType>(value)) {
TypedMetadata<ValueType> defaultValue(value);
appendAttribute<ValueType, CodecType>(tree, name, zeroVal<ValueType>(),
stride, /*constantstride=*/true, &defaultValue);
} else {
appendAttribute<ValueType, CodecType>(tree, name, zeroVal<ValueType>(),
stride, /*constantstride=*/true);
}
HoudiniAttribute houdiniAttribute(*attribute);
populateAttribute<PointDataTree, tools::PointIndexTree, HoudiniAttribute>(
tree, indexTree, name, houdiniAttribute, stride);
}
inline void
convertAttributeFromHoudini(PointDataTree& tree, const tools::PointIndexTree& indexTree,
const Name& name, const GA_Attribute* const attribute, const int compression = 0)
{
using namespace openvdb::math;
using HoudiniStringAttribute = HoudiniReadAttribute<Name>;
if (!attribute) {
std::stringstream ss; ss << "Invalid attribute - " << attribute->getName();
throw std::runtime_error(ss.str());
}
const GA_Storage storage(hvdb::attributeStorageType(attribute));
if (storage == GA_STORE_INVALID) {
std::stringstream ss; ss << "Invalid attribute type - " << attribute->getName();
throw std::runtime_error(ss.str());
}
const int16_t width(hvdb::attributeTupleSize(attribute));
UT_ASSERT(width > 0);
// explicitly handle string attributes
if (storage == GA_STORE_STRING) {
appendAttribute<Name>(tree, name);
HoudiniStringAttribute houdiniAttribute(*attribute);
populateAttribute<PointDataTree, tools::PointIndexTree, HoudiniStringAttribute>(
tree, indexTree, name, houdiniAttribute);
return;
}
const GA_AIFTuple* tupleAIF = attribute->getAIFTuple();
if (!tupleAIF) {
std::stringstream ss; ss << "Invalid attribute type - " << attribute->getName();
throw std::runtime_error(ss.str());
}
GA_Defaults defaults = tupleAIF->getDefaults(attribute);
const GA_TypeInfo typeInfo(attribute->getOptions().typeInfo());
const bool isVector = width == 3 && (typeInfo == GA_TYPE_VECTOR ||
typeInfo == GA_TYPE_NORMAL ||
typeInfo == GA_TYPE_COLOR);
const bool isQuaternion = width == 4 && (typeInfo == GA_TYPE_QUATERNION);
const bool isMatrix3 = width == 9 && (typeInfo == GA_TYPE_TRANSFORM);
const bool isMatrix4 = width == 16 && (typeInfo == GA_TYPE_TRANSFORM);
if (isVector)
{
if (storage == GA_STORE_INT32) {
convertAttributeFromHoudini<Vec3<int>>(tree, indexTree, name, attribute, defaults);
}
else if (storage == GA_STORE_REAL16)
{
// implicitly convert 16-bit float into truncated 32-bit float
convertAttributeFromHoudini<Vec3<float>, TruncateCodec>(
tree, indexTree, name, attribute, defaults);
}
else if (storage == GA_STORE_REAL32)
{
if (compression == hvdb::COMPRESSION_NONE) {
convertAttributeFromHoudini<Vec3<float>>(
tree, indexTree, name, attribute, defaults);
}
else if (compression == hvdb::COMPRESSION_TRUNCATE) {
convertAttributeFromHoudini<Vec3<float>, TruncateCodec>(
tree, indexTree, name, attribute, defaults);
}
else if (compression == hvdb::COMPRESSION_UNIT_VECTOR) {
convertAttributeFromHoudini<Vec3<float>, UnitVecCodec>(
tree, indexTree, name, attribute, defaults);
}
else if (compression == hvdb::COMPRESSION_UNIT_FIXED_POINT_8) {
convertAttributeFromHoudini<Vec3<float>, FixedPointCodec<true, UnitRange>>(
tree, indexTree, name, attribute, defaults);
}
else if (compression == hvdb::COMPRESSION_UNIT_FIXED_POINT_16) {
convertAttributeFromHoudini<Vec3<float>, FixedPointCodec<false, UnitRange>>(
tree, indexTree, name, attribute, defaults);
}
}
else if (storage == GA_STORE_REAL64) {
convertAttributeFromHoudini<Vec3<double>>(tree, indexTree, name, attribute, defaults);
}
else {
std::stringstream ss; ss << "Unknown vector attribute type - " << name;
throw std::runtime_error(ss.str());
}
}
else if (isQuaternion)
{
if (storage == GA_STORE_REAL16)
{
// implicitly convert 16-bit float into 32-bit float
convertAttributeFromHoudini<Quat<float>>(tree, indexTree, name, attribute, defaults);
}
else if (storage == GA_STORE_REAL32)
{
convertAttributeFromHoudini<Quat<float>>(tree, indexTree, name, attribute, defaults);
}
else if (storage == GA_STORE_REAL64) {
convertAttributeFromHoudini<Quat<double>>(tree, indexTree, name, attribute, defaults);
}
else {
std::stringstream ss; ss << "Unknown quaternion attribute type - " << name;
throw std::runtime_error(ss.str());
}
}
else if (isMatrix3)
{
if (storage == GA_STORE_REAL16)
{
// implicitly convert 16-bit float into 32-bit float
convertAttributeFromHoudini<Mat3<float>>(tree, indexTree, name, attribute, defaults);
}
else if (storage == GA_STORE_REAL32)
{
convertAttributeFromHoudini<Mat3<float>>(tree, indexTree, name, attribute, defaults);
}
else if (storage == GA_STORE_REAL64) {
convertAttributeFromHoudini<Mat3<double>>(tree, indexTree, name, attribute, defaults);
}
else {
std::stringstream ss; ss << "Unknown matrix3 attribute type - " << name;
throw std::runtime_error(ss.str());
}
}
else if (isMatrix4)
{
if (storage == GA_STORE_REAL16)
{
// implicitly convert 16-bit float into 32-bit float
convertAttributeFromHoudini<Mat4<float>>(tree, indexTree, name, attribute, defaults);
}
else if (storage == GA_STORE_REAL32)
{
convertAttributeFromHoudini<Mat4<float>>(tree, indexTree, name, attribute, defaults);
}
else if (storage == GA_STORE_REAL64) {
convertAttributeFromHoudini<Mat4<double>>(tree, indexTree, name, attribute, defaults);
}
else {
std::stringstream ss; ss << "Unknown matrix4 attribute type - " << name;
throw std::runtime_error(ss.str());
}
}
else {
if (storage == GA_STORE_BOOL) {
convertAttributeFromHoudini<bool>(tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_INT8) {
convertAttributeFromHoudini<int8_t>(tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_INT16) {
convertAttributeFromHoudini<int16_t>(tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_INT32) {
convertAttributeFromHoudini<int32_t>(tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_INT64) {
convertAttributeFromHoudini<int64_t>(tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_REAL16) {
convertAttributeFromHoudini<float, TruncateCodec>(
tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_REAL32 && compression == hvdb::COMPRESSION_NONE) {
convertAttributeFromHoudini<float>(tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_REAL32 && compression == hvdb::COMPRESSION_TRUNCATE) {
convertAttributeFromHoudini<float, TruncateCodec>(
tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_REAL32 && compression == hvdb::COMPRESSION_UNIT_FIXED_POINT_8) {
convertAttributeFromHoudini<float, FixedPointCodec<true, UnitRange>>(
tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_REAL32 && compression == hvdb::COMPRESSION_UNIT_FIXED_POINT_16) {
convertAttributeFromHoudini<float, FixedPointCodec<false, UnitRange>>(
tree, indexTree, name, attribute, defaults, width);
} else if (storage == GA_STORE_REAL64) {
convertAttributeFromHoudini<double>(tree, indexTree, name, attribute, defaults, width);
} else {
std::stringstream ss; ss << "Unknown attribute type - " << name;
throw std::runtime_error(ss.str());
}
}
}
template <typename ValueType>
void
populateHoudiniDetailAttribute(GA_RWAttributeRef& attrib, const openvdb::MetaMap& metaMap,
const Name& key, const int index)
{
using WriteHandleType = typename GAHandleTraits<ValueType>::RW;
using TypedMetadataT = TypedMetadata<ValueType>;
typename TypedMetadataT::ConstPtr typedMetadata = metaMap.getMetadata<TypedMetadataT>(key);
if (!typedMetadata) return;
const ValueType& value = typedMetadata->value();
WriteHandleType handle(attrib.getAttribute());
writeAttributeValue<WriteHandleType, ValueType>(handle, GA_Offset(0), index, value);
}
template<typename ValueType>
Metadata::Ptr
createTypedMetadataFromAttribute(const GA_Attribute* const attribute, const uint32_t component = 0)
{
using HoudiniAttribute = HoudiniReadAttribute<ValueType>;
ValueType value;
HoudiniAttribute::get(*attribute, value, GA_Offset(0), component);
return openvdb::TypedMetadata<ValueType>(value).copy();
}
template<typename HoudiniType, typename ValueType>
GA_Defaults
buildDefaults(const ValueType& value)
{
HoudiniType values[1];
values[0] = value;
return GA_Defaults(values, 1);
}
template<>
GA_Defaults
buildDefaults<int32>(const openvdb::math::Vec3<int>& value)
{
int32 values[3];
for (unsigned i = 0; i < 3; ++i) {
values[i] = value(i);
}
return GA_Defaults(values, 3);
}
template<>
GA_Defaults
buildDefaults<fpreal32>(const openvdb::math::Vec3<float>& value)
{
fpreal32 values[3];
for (unsigned i = 0; i < 3; ++i) {
values[i] = value(i);
}
return GA_Defaults(values, 3);
}
template<>
GA_Defaults
buildDefaults<fpreal64>(const openvdb::math::Vec3<double>& value)
{
fpreal64 values[3];
for (unsigned i = 0; i < 3; ++i) {
values[i] = value(i);
}
return GA_Defaults(values, 3);
}
template<>
GA_Defaults
buildDefaults<fpreal32>(const openvdb::math::Quat<float>& value)
{
fpreal32 values[4];
for (unsigned i = 0; i < 4; ++i) {
values[i] = value(i);
}
return GA_Defaults(values, 4);
}
template<>
GA_Defaults
buildDefaults<fpreal64>(const openvdb::math::Quat<double>& value)
{
fpreal64 values[4];
for (unsigned i = 0; i < 4; ++i) {
values[i] = value(i);
}
return GA_Defaults(values, 4);
}
template<>
GA_Defaults
buildDefaults<fpreal32>(const openvdb::math::Mat3<float>& value)
{
fpreal32 values[9];
const float* data = value.asPointer();
for (unsigned i = 0; i < 9; ++i) {
values[i] = data[i];
}
return GA_Defaults(values, 9);
}
template<>
GA_Defaults
buildDefaults<fpreal64>(const openvdb::math::Mat3<double>& value)
{
fpreal64 values[9];
const double* data = value.asPointer();
for (unsigned i = 0; i < 9; ++i) {
values[i] = data[i];
}
return GA_Defaults(values, 9);
}
template<>
GA_Defaults
buildDefaults<fpreal32>(const openvdb::math::Mat4<float>& value)
{
fpreal32 values[16];
const float* data = value.asPointer();
for (unsigned i = 0; i < 16; ++i) {
values[i] = data[i];
}
return GA_Defaults(values, 16);
}
template<>
GA_Defaults
buildDefaults<fpreal64>(const openvdb::math::Mat4<double>& value)
{
fpreal64 values[16];
const double* data = value.asPointer();
for (unsigned i = 0; i < 16; ++i) {
values[i] = data[i];
}
return GA_Defaults(values, 16);
}
template <typename ValueType, typename HoudiniType>
GA_Defaults
gaDefaultsFromDescriptorTyped(const openvdb::points::AttributeSet::Descriptor& descriptor,
const openvdb::Name& name)
{
ValueType defaultValue = descriptor.getDefaultValue<ValueType>(name);
return buildDefaults<HoudiniType, ValueType>(defaultValue);
}
inline GA_Defaults
gaDefaultsFromDescriptor(const openvdb::points::AttributeSet::Descriptor& descriptor,
const openvdb::Name& name)
{
const size_t pos = descriptor.find(name);
if (pos == openvdb::points::AttributeSet::INVALID_POS) return GA_Defaults(0);
const openvdb::Name type = descriptor.type(pos).first;
if (type == "bool") {
return gaDefaultsFromDescriptorTyped<bool, int32>(descriptor, name);
} else if (type == "int8") {
return gaDefaultsFromDescriptorTyped<int8_t, int32>(descriptor, name);
} else if (type == "int16") {
return gaDefaultsFromDescriptorTyped<int16_t, int32>(descriptor, name);
} else if (type == "int32") {
return gaDefaultsFromDescriptorTyped<int32_t, int32>(descriptor, name);
} else if (type == "int64") {
return gaDefaultsFromDescriptorTyped<int64_t, int64>(descriptor, name);
} else if (type == "float") {
return gaDefaultsFromDescriptorTyped<float, fpreal32>(descriptor, name);
} else if (type == "double") {
return gaDefaultsFromDescriptorTyped<double, fpreal64>(descriptor, name);
} else if (type == "vec3i") {
return gaDefaultsFromDescriptorTyped<openvdb::math::Vec3<int>, int32>(descriptor, name);
} else if (type == "vec3s") {
return gaDefaultsFromDescriptorTyped<openvdb::math::Vec3s, fpreal32>(descriptor, name);
} else if (type == "vec3d") {
return gaDefaultsFromDescriptorTyped<openvdb::math::Vec3d, fpreal64>(descriptor, name);
} else if (type == "quats") {
return gaDefaultsFromDescriptorTyped<openvdb::math::Quats, fpreal32>(descriptor, name);
} else if (type == "quatd") {
return gaDefaultsFromDescriptorTyped<openvdb::math::Quatd, fpreal64>(descriptor, name);
} else if (type == "mat3s") {
return gaDefaultsFromDescriptorTyped<openvdb::math::Mat3s, fpreal32>(descriptor, name);
} else if (type == "mat3d") {
return gaDefaultsFromDescriptorTyped<openvdb::math::Mat3d, fpreal64>(descriptor, name);
} else if (type == "mat4s") {
return gaDefaultsFromDescriptorTyped<openvdb::math::Mat4s, fpreal32>(descriptor, name);
} else if (type == "mat4d") {
return gaDefaultsFromDescriptorTyped<openvdb::math::Mat4d, fpreal64>(descriptor, name);
}
return GA_Defaults(0);
}
} // unnamed namespace
////////////////////////////////////////
namespace openvdb_houdini {
float
computeVoxelSizeFromHoudini(const GU_Detail& detail,
const uint32_t pointsPerVoxel,
const openvdb::math::Mat4d& matrix,
const Index decimalPlaces,
hvdb::Interrupter& interrupter)
{
HoudiniReadAttribute<openvdb::Vec3R> positions(*(detail.getP()));
return openvdb::points::computeVoxelSize(
positions, pointsPerVoxel, matrix, decimalPlaces, &interrupter);
}
PointDataGrid::Ptr
convertHoudiniToPointDataGrid(const GU_Detail& ptGeo,
const int compression,
const AttributeInfoMap& attributes,
const math::Transform& transform,
const WarnFunc& warnings)
{
using HoudiniPositionAttribute = HoudiniReadAttribute<Vec3d>;
// initialize primitive offsets
hvdb::OffsetListPtr offsets;
for (GA_Iterator primitiveIt(ptGeo.getPrimitiveRange()); !primitiveIt.atEnd(); ++primitiveIt) {
const GA_Primitive* primitive = ptGeo.getPrimitiveList().get(*primitiveIt);
if (primitive->getTypeId() != GA_PRIMNURBCURVE) continue;
const size_t vertexCount = primitive->getVertexCount();
if (vertexCount == 0) continue;
if (!offsets) offsets.reset(new hvdb::OffsetList);
const GA_Offset firstOffset = primitive->getPointOffset(0);
offsets->push_back(firstOffset);
}
// Create PointPartitioner compatible P attribute wrapper (for now no offset filtering)
const GA_Attribute& positionAttribute = *ptGeo.getP();
HoudiniPositionAttribute points(positionAttribute, offsets);
// Create PointIndexGrid used for consistent index ordering in all attribute conversion
const tools::PointIndexGrid::Ptr pointIndexGrid =
tools::createPointIndexGrid<tools::PointIndexGrid>(points, transform);
// Create PointDataGrid using position attribute
PointDataGrid::Ptr pointDataGrid;
if (compression == 1 /*FIXED_POSITION_16*/) {
pointDataGrid = createPointDataGrid<FixedPointCodec<false>, PointDataGrid>(
*pointIndexGrid, points, transform);
}
else if (compression == 2 /*FIXED_POSITION_8*/) {
pointDataGrid = createPointDataGrid<FixedPointCodec<true>, PointDataGrid>(
*pointIndexGrid, points, transform);
}
else /*NONE*/ {
pointDataGrid = createPointDataGrid<NullCodec, PointDataGrid>(
*pointIndexGrid, points, transform);
}
const tools::PointIndexTree& indexTree = pointIndexGrid->tree();
PointDataTree& tree = pointDataGrid->tree();
const GA_Size numHoudiniPoints = ptGeo.getNumPoints();
UT_ASSERT(numHoudiniPoints >= 0);
const Index64 numVDBPoints = pointCount(tree);
UT_ASSERT(numVDBPoints <= static_cast<Index64>(numHoudiniPoints));
if (numVDBPoints < static_cast<Index64>(numHoudiniPoints)) {
warnings("Points contain NAN positional values. These points will not be converted.");
}
if (!tree.cbeginLeaf()) return pointDataGrid;
// store point group information
const GA_ElementGroupTable& elementGroups = ptGeo.getElementGroupTable(GA_ATTRIB_POINT);
const int64_t numGroups = elementGroups.entries(); // including internal groups
if (numGroups > 0) {
// Append (empty) groups to tree
std::vector<Name> groupNames;
groupNames.reserve(numGroups);
for (auto it = elementGroups.beginTraverse(), itEnd = elementGroups.endTraverse();
it != itEnd; ++it) {
groupNames.emplace_back((*it)->getName().toStdString());
}
appendGroups(tree, groupNames);
// create the group membership vector at a multiple of 1024 for fast parallel resetting
const size_t groupVectorSize = numHoudiniPoints + (1024 - (numHoudiniPoints % 1024));
std::vector<short> inGroup(groupVectorSize, short(0));
// Set group membership in tree
for (auto it = elementGroups.beginTraverse(), itEnd = elementGroups.endTraverse();
it != itEnd; ++it) {
const GA_Range range(**it);
tbb::parallel_for(GA_SplittableRange(range),
[&ptGeo, &inGroup](const GA_SplittableRange& r) {
for (GA_PageIterator pit = r.beginPages(); !pit.atEnd(); ++pit) {
GA_Offset start, end;
for (GA_Iterator iter = pit.begin(); iter.blockAdvance(start, end);) {
for (GA_Offset off = start; off < end; ++off) {
const GA_Index idx = ptGeo.pointIndex(off);
UT_ASSERT(idx < GA_Index(inGroup.size()));
inGroup[idx] = short(1);
}
}
}
});
const Name groupName = (*it)->getName().toStdString();
setGroup(tree, indexTree, inGroup, groupName);
// reset groups to 0
tbb::parallel_for(tbb::blocked_range<size_t>(0, groupVectorSize / 1024),
[&inGroup](const tbb::blocked_range<size_t>& range) {
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
std::fill_n(inGroup.begin() + n*1024, 1024, 0);
}
});
}
}
// Add other attributes to PointDataGrid
for (const auto& attrInfo : attributes)
{
const Name& name = attrInfo.first;
// skip position as this has already been added
if (name == "P") continue;
GA_ROAttributeRef attrRef = ptGeo.findPointAttribute(name.c_str());
if (!attrRef.isValid()) continue;
GA_Attribute const * gaAttribute = attrRef.getAttribute();
if (!gaAttribute) continue;
const GA_AIFSharedStringTuple* sharedStringTupleAIF =
gaAttribute->getAIFSharedStringTuple();
const bool isString = bool(sharedStringTupleAIF);
// Extract all the string values from the string table and insert them
// into the Descriptor Metadata
if (isString)
{
// Iterate over the strings in the table and insert them into the Metadata
MetaMap& metadata = makeDescriptorUnique(tree)->getMetadata();
StringMetaInserter inserter(metadata);
for (auto it = sharedStringTupleAIF->begin(gaAttribute),
itEnd = sharedStringTupleAIF->end(); !(it == itEnd); ++it)
{
Name str(it.getString());
if (!str.empty()) inserter.insert(str);
}
}
convertAttributeFromHoudini(tree, indexTree, name, gaAttribute,
/*compression=*/attrInfo.second.first);
}
// Attempt to compact attributes
compactAttributes(tree);
return pointDataGrid;
}
void
convertPointDataGridToHoudini(
GU_Detail& detail,
const PointDataGrid& grid,
const std::vector<std::string>& attributes,
const std::vector<std::string>& includeGroups,
const std::vector<std::string>& excludeGroups,
const bool inCoreOnly)
{
using namespace openvdb::math;
const PointDataTree& tree = grid.tree();
auto leafIter = tree.cbeginLeaf();
if (!leafIter) return;
// position attribute is mandatory
const AttributeSet& attributeSet = leafIter->attributeSet();
const AttributeSet::Descriptor& descriptor = attributeSet.descriptor();
const bool hasPosition = descriptor.find("P") != AttributeSet::INVALID_POS;
if (!hasPosition) return;
// sort for binary search
std::vector<std::string> sortedAttributes(attributes);
std::sort(sortedAttributes.begin(), sortedAttributes.end());
// obtain cumulative point offsets and total points
std::vector<Index64> offsets;
MultiGroupFilter filter(includeGroups, excludeGroups, leafIter->attributeSet());
const Index64 total = pointOffsets(offsets, tree, filter, inCoreOnly);
// a block's global offset is needed to transform its point offsets to global offsets
const Index64 startOffset = detail.appendPointBlock(total);
HoudiniWriteAttribute<Vec3f> positionAttribute(*detail.getP());
convertPointDataGridPosition(positionAttribute, grid, offsets, startOffset,
filter, inCoreOnly);
// add other point attributes to the hdk detail
const AttributeSet::Descriptor::NameToPosMap& nameToPosMap = descriptor.map();
for (const auto& namePos : nameToPosMap) {
const Name& name = namePos.first;
// position handled explicitly
if (name == "P") continue;
// filter attributes
if (!sortedAttributes.empty() &&
!std::binary_search(sortedAttributes.begin(), sortedAttributes.end(), name)) {
continue;
}
const auto index = static_cast<unsigned>(namePos.second);
const AttributeArray& array = leafIter->constAttributeArray(index);
// don't convert group attributes
if (isGroup(array)) continue;
const unsigned stride = array.stride();
GA_RWAttributeRef attributeRef = detail.findPointAttribute(name.c_str());
const NamePair& type = descriptor.type(index);
const Name valueType(isString(array) ? "string" : type.first);
// create the attribute if it doesn't already exist in the detail
if (attributeRef.isInvalid()) {
const bool truncate(type.second == TruncateCodec::name());
GA_Storage storage(gaStorageFromAttrString(valueType));
if (storage == GA_STORE_INVALID) continue;
if (storage == GA_STORE_REAL32 && truncate) {
storage = GA_STORE_REAL16;
}
unsigned width = stride;
const bool isVector = valueType.compare(0, 4, "vec3") == 0;
const bool isQuaternion = valueType.compare(0, 4, "quat") == 0;
const bool isMatrix3 = valueType.compare(0, 4, "mat3") == 0;
const bool isMatrix4 = valueType.compare(0, 4, "mat4") == 0;
if (isVector) width = 3;
else if (isQuaternion) width = 4;
else if (isMatrix3) width = 9;
else if (isMatrix4) width = 16;
const GA_Defaults defaults = gaDefaultsFromDescriptor(descriptor, name);
attributeRef = detail.addTuple(storage, GA_ATTRIB_POINT, name.c_str(), width, defaults);
// apply type info to some recognised types
if (isVector) {
if (name == "Cd") attributeRef->getOptions().setTypeInfo(GA_TYPE_COLOR);
else if (name == "N") attributeRef->getOptions().setTypeInfo(GA_TYPE_NORMAL);
else attributeRef->getOptions().setTypeInfo(GA_TYPE_VECTOR);
}
if (isQuaternion) {
attributeRef->getOptions().setTypeInfo(GA_TYPE_QUATERNION);
}
if (isMatrix4 || isMatrix3) {
attributeRef->getOptions().setTypeInfo(GA_TYPE_TRANSFORM);
}
// '|' and ':' characters are valid in OpenVDB Points names but
// will make Houdini Attribute names invalid
if (attributeRef.isInvalid()) {
OPENVDB_THROW( RuntimeError,
"Unable to create Houdini Points Attribute with name '" + name +
"'. '|' and ':' characters are not supported by Houdini.");
}
}
if (valueType == "string") {
HoudiniWriteAttribute<Name> attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "bool") {
HoudiniWriteAttribute<bool> attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "int8") {
HoudiniWriteAttribute<int8_t> attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "int16") {
HoudiniWriteAttribute<int16_t> attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "int32") {
HoudiniWriteAttribute<int32_t> attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "int64") {
HoudiniWriteAttribute<int64_t> attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "float") {
HoudiniWriteAttribute<float> attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "double") {
HoudiniWriteAttribute<double> attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "vec3i") {
HoudiniWriteAttribute<Vec3<int> > attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "vec3s") {
HoudiniWriteAttribute<Vec3<float> > attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "vec3d") {
HoudiniWriteAttribute<Vec3<double> > attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "quats") {
HoudiniWriteAttribute<Quat<float> > attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "quatd") {
HoudiniWriteAttribute<Quat<double> > attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "mat3s") {
HoudiniWriteAttribute<Mat3<float> > attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "mat3d") {
HoudiniWriteAttribute<Mat3<double> > attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "mat4s") {
HoudiniWriteAttribute<Mat4<float> > attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else if (valueType == "mat4d") {
HoudiniWriteAttribute<Mat4<double> > attribute(*attributeRef.getAttribute());
convertPointDataGridAttribute(attribute, tree, offsets, startOffset, index, stride,
filter, inCoreOnly);
}
else {
throw std::runtime_error("Unknown Attribute Type for Conversion: " + valueType);
}
}
// add point groups to the hdk detail
const AttributeSet::Descriptor::NameToPosMap& groupMap = descriptor.groupMap();
for (const auto& namePos : groupMap) {
const Name& name = namePos.first;
UT_ASSERT(!name.empty());
GA_PointGroup* pointGroup = detail.findPointGroup(name.c_str());
if (!pointGroup) pointGroup = detail.newPointGroup(name.c_str());
const AttributeSet::Descriptor::GroupIndex index =
attributeSet.groupIndex(name);
HoudiniGroup group(*pointGroup, startOffset, total);
convertPointDataGridGroup(group, tree, offsets, startOffset, index, filter, inCoreOnly);
}
}
void
populateMetadataFromHoudini(openvdb::points::PointDataGrid& grid,
const GU_Detail& detail,
const WarnFunc& warnings)
{
using namespace openvdb::math;
for (GA_AttributeDict::iterator iter = detail.attribs().begin(GA_SCOPE_PUBLIC);
!iter.atEnd(); ++iter)
{
const GA_Attribute* const attribute = *iter;
if (!attribute) continue;
const Name name("global:" + Name(attribute->getName()));
Metadata::Ptr metadata = grid[name];
if (metadata) continue;
const GA_Storage storage(attributeStorageType(attribute));
const int16_t width(attributeTupleSize(attribute));
const GA_TypeInfo typeInfo(attribute->getOptions().typeInfo());
const bool isVector = width == 3 && (typeInfo == GA_TYPE_VECTOR ||
typeInfo == GA_TYPE_NORMAL ||
typeInfo == GA_TYPE_COLOR);
const bool isQuaternion = width == 4 && (typeInfo == GA_TYPE_QUATERNION);
const bool isMatrix3 = width == 9 && (typeInfo == GA_TYPE_TRANSFORM);
const bool isMatrix4 = width == 16 && (typeInfo == GA_TYPE_TRANSFORM);
if (isVector) {
if (storage == GA_STORE_REAL16) {
metadata = createTypedMetadataFromAttribute<Vec3<float> >(attribute);
} else if (storage == GA_STORE_REAL32) {
metadata = createTypedMetadataFromAttribute<Vec3<float> >(attribute);
} else if (storage == GA_STORE_REAL64) {
metadata = createTypedMetadataFromAttribute<Vec3<double> >(attribute);
} else {
std::stringstream ss;
ss << "Detail attribute \"" << attribute->getName() << "\" " <<
"unsupported vector type for metadata conversion.";
warnings(ss.str());
continue;
}
UT_ASSERT(metadata);
grid.insertMeta(name, *metadata);
} else if (isQuaternion) {
if (storage == GA_STORE_REAL16) {
metadata = createTypedMetadataFromAttribute<Quat<float>>(attribute);
} else if (storage == GA_STORE_REAL32) {
metadata = createTypedMetadataFromAttribute<Quat<float>>(attribute);
} else if (storage == GA_STORE_REAL64) {
metadata = createTypedMetadataFromAttribute<Quat<double>>(attribute);
} else {
std::stringstream ss;
ss << "Detail attribute \"" << attribute->getName() << "\" " <<
"unsupported quaternion type for metadata conversion.";
warnings(ss.str());
continue;
}
} else if (isMatrix3) {
if (storage == GA_STORE_REAL16) {
metadata = createTypedMetadataFromAttribute<Mat3<float>>(attribute);
} else if (storage == GA_STORE_REAL32) {
metadata = createTypedMetadataFromAttribute<Mat3<float>>(attribute);
} else if (storage == GA_STORE_REAL64) {
metadata = createTypedMetadataFromAttribute<Mat3<double>>(attribute);
} else {
std::stringstream ss;
ss << "Detail attribute \"" << attribute->getName() << "\" " <<
"unsupported matrix3 type for metadata conversion.";
warnings(ss.str());
continue;
}
} else if (isMatrix4) {
if (storage == GA_STORE_REAL16) {
metadata = createTypedMetadataFromAttribute<Mat4<float>>(attribute);
} else if (storage == GA_STORE_REAL32) {
metadata = createTypedMetadataFromAttribute<Mat4<float>>(attribute);
} else if (storage == GA_STORE_REAL64) {
metadata = createTypedMetadataFromAttribute<Mat4<double>>(attribute);
} else {
std::stringstream ss;
ss << "Detail attribute \"" << attribute->getName() << "\" " <<
"unsupported matrix4 type for metadata conversion.";
warnings(ss.str());
continue;
}
} else {
for (int i = 0; i < width; i++) {
if (storage == GA_STORE_BOOL) {
metadata = createTypedMetadataFromAttribute<bool>(attribute, i);
} else if (storage == GA_STORE_INT8) {
metadata = createTypedMetadataFromAttribute<int8_t>(attribute, i);
} else if (storage == GA_STORE_INT16) {
metadata = createTypedMetadataFromAttribute<int16_t>(attribute, i);
} else if (storage == GA_STORE_INT32) {
metadata = createTypedMetadataFromAttribute<int32_t>(attribute, i);
} else if (storage == GA_STORE_INT64) {
metadata = createTypedMetadataFromAttribute<int64_t>(attribute, i);
} else if (storage == GA_STORE_REAL16) {
metadata = createTypedMetadataFromAttribute<float>(attribute, i);
} else if (storage == GA_STORE_REAL32) {
metadata = createTypedMetadataFromAttribute<float>(attribute, i);
} else if (storage == GA_STORE_REAL64) {
metadata = createTypedMetadataFromAttribute<double>(attribute, i);
} else if (storage == GA_STORE_STRING) {
metadata = createTypedMetadataFromAttribute<openvdb::Name>(attribute, i);
} else {
std::stringstream ss;
ss << "Detail attribute \"" << attribute->getName() << "\" " <<
"unsupported type for metadata conversion.";
warnings(ss.str());
continue;
}
UT_ASSERT(metadata);
if (width > 1) {
const Name arrayName(name + Name("[") + std::to_string(i) + Name("]"));
grid.insertMeta(arrayName, *metadata);
}
else {
grid.insertMeta(name, *metadata);
}
}
}
}
}
void
convertMetadataToHoudini(GU_Detail& detail,
const openvdb::MetaMap& metaMap,
const WarnFunc& warnings)
{
struct Local {
static bool isGlobalMetadata(const Name& name) {
return name.compare(0, 7, "global:") == 0;
}
static Name toDetailName(const Name& name) {
Name detailName(name);
detailName.erase(0, 7);
const size_t open = detailName.find('[');
if (open != std::string::npos) {
detailName = detailName.substr(0, open);
}
return detailName;
}
static int toDetailIndex(const Name& name) {
const size_t open = name.find('[');
const size_t close = name.find(']');
int index = 0;
if (open != std::string::npos && close != std::string::npos &&
close == name.length()-1 && open > 0 && open+1 < close) {
try { // parse array index
index = std::stoi(name.substr(open+1, close-open-1));
}
catch (const std::exception&) {}
}
return index;
}
};
using namespace openvdb::math;
using DetailInfo = std::pair<Name, int>;
using DetailMap = std::map<Name, DetailInfo>;
DetailMap detailCreate;
DetailMap detailPopulate;
for(MetaMap::ConstMetaIterator iter = metaMap.beginMeta(); iter != metaMap.endMeta(); ++iter)
{
const Metadata::Ptr metadata = iter->second;
if (!metadata) continue;
const Name& key = iter->first;
if (!Local::isGlobalMetadata(key)) continue;
Name name = Local::toDetailName(key);
int index = Local::toDetailIndex(key);
// add to creation map
if (detailCreate.find(name) == detailCreate.end()) {
detailCreate[name] = DetailInfo(metadata->typeName(), index);
}
else {
if (index > detailCreate[name].second) detailCreate[name].second = index;
}
// add to populate map
detailPopulate[key] = DetailInfo(name, index);
}
// add all detail attributes
for (const auto& item : detailCreate) {
const Name& name = item.first;
const DetailInfo& info = item.second;
const Name& type = info.first;
const int size = info.second;
GA_RWAttributeRef attribute = detail.findGlobalAttribute(name);
if (attribute.isInvalid())
{
const GA_Storage storage = gaStorageFromAttrString(type);
if (storage == GA_STORE_INVALID) {
throw std::runtime_error("Invalid attribute storage type \"" + name + "\".");
}
if (type == "vec3s" || type == "vec3d") {
attribute = detail.addTuple(storage, GA_ATTRIB_GLOBAL, name.c_str(), 3);
attribute.setTypeInfo(GA_TYPE_VECTOR);
}
else {
attribute = detail.addTuple(storage, GA_ATTRIB_GLOBAL, name.c_str(), size+1);
}
if (!attribute.isValid()) {
throw std::runtime_error("Error creating attribute with name \"" + name + "\".");
}
}
}
// populate the values
for (const auto& item : detailPopulate) {
const Name& key = item.first;
const DetailInfo& info = item.second;
const Name& name = info.first;
const int index = info.second;
const Name& type = metaMap[key]->typeName();
GA_RWAttributeRef attrib = detail.findGlobalAttribute(name);
UT_ASSERT(!attrib.isInvalid());
if (type == openvdb::typeNameAsString<bool>()) populateHoudiniDetailAttribute<bool>(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<int8_t>()) populateHoudiniDetailAttribute<int8_t>(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<int16_t>()) populateHoudiniDetailAttribute<int16_t>(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<int32_t>()) populateHoudiniDetailAttribute<int32_t>(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<int64_t>()) populateHoudiniDetailAttribute<int64_t>(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<float>()) populateHoudiniDetailAttribute<float>(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<double>()) populateHoudiniDetailAttribute<double>(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<Vec3<int32_t> >()) populateHoudiniDetailAttribute<Vec3<int32_t> >(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<Vec3<float> >()) populateHoudiniDetailAttribute<Vec3<float> >(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<Vec3<double> >()) populateHoudiniDetailAttribute<Vec3<double> >(attrib, metaMap, key, index);
else if (type == openvdb::typeNameAsString<Name>()) populateHoudiniDetailAttribute<Name>(attrib, metaMap, key, index);
else {
std::stringstream ss;
ss << "Metadata value \"" << key
<< "\" unsupported type for detail attribute conversion.";
warnings(ss.str());
}
}
}
////////////////////////////////////////
int16_t
attributeTupleSize(const GA_Attribute* const attribute)
{
if (!attribute) return int16_t(0);
const GA_AIFTuple* tupleAIF = attribute->getAIFTuple();
if (!tupleAIF)
{
const GA_AIFStringTuple* tupleAIFString = attribute->getAIFStringTuple();
if (tupleAIFString)
{
return static_cast<int16_t>(tupleAIFString->getTupleSize(attribute));
}
}
else
{
return static_cast<int16_t>(tupleAIF->getTupleSize(attribute));
}
return int16_t(0);
}
GA_Storage
attributeStorageType(const GA_Attribute* const attribute)
{
if (!attribute) return GA_STORE_INVALID;
const GA_AIFTuple* tupleAIF = attribute->getAIFTuple();
if (!tupleAIF)
{
if (attribute->getAIFStringTuple())
{
return GA_STORE_STRING;
}
}
else
{
return tupleAIF->getStorage(attribute);
}
return GA_STORE_INVALID;
}
////////////////////////////////////////
void
collectPointInfo(const PointDataGrid& grid,
std::string& countStr,
std::string& groupStr,
std::string& attributeStr)
{
using AttributeSet = openvdb::points::AttributeSet;
using Descriptor = openvdb::points::AttributeSet::Descriptor;
const PointDataTree& tree = grid.constTree();
// iterate through all leaf nodes to find out if all are out-of-core
bool allOutOfCore = true;
for (auto iter = tree.cbeginLeaf(); iter; ++iter) {
if (!iter->buffer().isOutOfCore()) {
allOutOfCore = false;
break;
}
}
openvdb::Index64 totalPointCount = 0;
// it is more technically correct to rely on the voxel count as this may be
// out of sync with the attribute size, however for faster node preview when
// the voxel buffers are all out-of-core, count up the sizes of the first
// attribute array instead
if (allOutOfCore) {
for (auto iter = tree.cbeginLeaf(); iter; ++iter) {
if (iter->attributeSet().size() > 0) {
totalPointCount += iter->constAttributeArray(0).size();
}
}
}
else {
totalPointCount = openvdb::points::pointCount(tree);
}
std::ostringstream os;
os << openvdb::util::formattedInt(totalPointCount);
countStr = os.str();
os.clear();
os.str("");
const auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet& attributeSet = iter->attributeSet();
const Descriptor& descriptor = attributeSet.descriptor();
std::string viewportGroupName = "";
if (StringMetadata::ConstPtr stringMeta =
grid.getMetadata<StringMetadata>(META_GROUP_VIEWPORT)) {
viewportGroupName = stringMeta->value();
}
const Descriptor::NameToPosMap& groupMap = descriptor.groupMap();
bool first = true;
for (const auto& it : groupMap) {
if (first) first = false;
else os << ", ";
// add an asterisk as a viewport group indicator
if (it.first == viewportGroupName) os << "*";
os << it.first << "(";
// for faster node preview when all the voxel buffers are out-of-core,
// don't load the group arrays to display the group sizes, just print
// "out-of-core" instead @todo - put the group sizes into the grid
// metadata on write for this use case
if (allOutOfCore) os << "out-of-core";
else {
const openvdb::points::GroupFilter filter(it.first, attributeSet);
os << openvdb::util::formattedInt(pointCount(tree, filter));
}
os << ")";
}
groupStr = (os.str().empty() ? "none" : os.str());
os.clear();
os.str("");
const Descriptor::NameToPosMap& nameToPosMap = descriptor.map();
first = true;
for (const auto& it : nameToPosMap) {
const openvdb::points::AttributeArray& array = *(attributeSet.getConst(it.second));
if (isGroup(array)) continue;
if (first) first = false;
else os << ", ";
const openvdb::NamePair& type = descriptor.type(it.second);
const openvdb::Name& codecType = type.second;
if (isString(array)) {
os << it.first << "[str]";
}
else {
os << it.first << "[" << type.first;
// if no value compression, hide the codec
os << (codecType != "null" ? "_" + codecType : "");
os << "]";
}
if (!array.hasConstantStride()) os << " [dynamic]";
else if (array.stride() > 1) os << " [" << array.stride() << "]";
}
attributeStr = (os.str().empty() ? "none" : os.str());
}
void
pointDataGridSpecificInfoText(std::ostream& infoStr, const GridBase& grid)
{
const PointDataGrid* pointDataGrid =
dynamic_cast<const PointDataGrid*>(&grid);
if (!pointDataGrid) return;
// match native OpenVDB convention as much as possible
infoStr << " voxel size: " << pointDataGrid->transform().voxelSize()[0] << ",";
infoStr << " type: points,";
if (pointDataGrid->activeVoxelCount() != 0) {
const Coord dim = grid.evalActiveVoxelDim();
infoStr << " dim: " << dim[0] << "x" << dim[1] << "x" << dim[2] << ",";
} else {
infoStr <<" <empty>,";
}
std::string countStr, groupStr, attributeStr;
collectPointInfo(*pointDataGrid, countStr, groupStr, attributeStr);
infoStr << " count: " << countStr << ",";
infoStr << " groups: " << groupStr << ",";
infoStr << " attributes: " << attributeStr;
}
namespace {
inline int
lookupGroupInput(const PRM_SpareData* spare)
{
if (!spare) return 0;
const char* istring = spare->getValue("sop_input");
return istring ? atoi(istring) : 0;
}
void
sopBuildVDBPointsGroupMenu(void* data, PRM_Name* menuEntries, int /*themenusize*/,
const PRM_SpareData* spare, const PRM_Parm* /*parm*/)
{
SOP_Node* sop = CAST_SOPNODE(static_cast<OP_Node*>(data));
int inputIndex = lookupGroupInput(spare);
const GU_Detail* gdp = sop->getInputLastGeo(inputIndex, CHgetEvalTime());
// const cast as iterator requires non-const access, however data is not modified
VdbPrimIterator vdbIt(const_cast<GU_Detail*>(gdp));
int n_entries = 0;
for (; vdbIt; ++vdbIt) {
GU_PrimVDB* vdbPrim = *vdbIt;
PointDataGrid::ConstPtr grid =
gridConstPtrCast<PointDataGrid>(vdbPrim->getConstGridPtr());
// ignore all but point data grids
if (!grid) continue;
auto leafIter = grid->tree().cbeginLeaf();
if (!leafIter) continue;
const AttributeSet::Descriptor& descriptor =
leafIter->attributeSet().descriptor();
for (const auto& it : descriptor.groupMap()) {
// add each VDB Points group to the menu
menuEntries[n_entries].setToken(it.first.c_str());
menuEntries[n_entries].setLabel(it.first.c_str());
n_entries++;
}
}
// zero value ends the menu
menuEntries[n_entries].setToken(0);
menuEntries[n_entries].setLabel(0);
}
} // unnamed namespace
#ifdef _MSC_VER
OPENVDB_HOUDINI_API const PRM_ChoiceList
VDBPointsGroupMenuInput1(PRM_CHOICELIST_TOGGLE, sopBuildVDBPointsGroupMenu);
OPENVDB_HOUDINI_API const PRM_ChoiceList
VDBPointsGroupMenuInput2(PRM_CHOICELIST_TOGGLE, sopBuildVDBPointsGroupMenu);
OPENVDB_HOUDINI_API const PRM_ChoiceList
VDBPointsGroupMenuInput3(PRM_CHOICELIST_TOGGLE, sopBuildVDBPointsGroupMenu);
OPENVDB_HOUDINI_API const PRM_ChoiceList
VDBPointsGroupMenuInput4(PRM_CHOICELIST_TOGGLE, sopBuildVDBPointsGroupMenu);
OPENVDB_HOUDINI_API const PRM_ChoiceList VDBPointsGroupMenu(PRM_CHOICELIST_TOGGLE,
sopBuildVDBPointsGroupMenu);
#else
const PRM_ChoiceList
VDBPointsGroupMenuInput1(PRM_CHOICELIST_TOGGLE, sopBuildVDBPointsGroupMenu);
const PRM_ChoiceList
VDBPointsGroupMenuInput2(PRM_CHOICELIST_TOGGLE, sopBuildVDBPointsGroupMenu);
const PRM_ChoiceList
VDBPointsGroupMenuInput3(PRM_CHOICELIST_TOGGLE, sopBuildVDBPointsGroupMenu);
const PRM_ChoiceList
VDBPointsGroupMenuInput4(PRM_CHOICELIST_TOGGLE, sopBuildVDBPointsGroupMenu);
const PRM_ChoiceList VDBPointsGroupMenu(PRM_CHOICELIST_TOGGLE,
sopBuildVDBPointsGroupMenu);
#endif
} // namespace openvdb_houdini
| 68,670 | C++ | 36.361806 | 147 | 0.622892 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Points_Delete.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file SOP_OpenVDB_Points_Delete.cc
///
/// @author Francisco Gochez, Dan Bailey
///
/// @brief Delete points that are members of specific groups
#include <openvdb/openvdb.h>
#include <openvdb/points/PointDataGrid.h>
#include <openvdb/points/PointDelete.h>
#include <UT/UT_Version.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/PointUtils.h>
#include <openvdb_houdini/Utils.h>
#include <houdini_utils/geometry.h>
#include <houdini_utils/ParmFactory.h>
#include <algorithm>
#include <stdexcept>
#include <string>
#include <vector>
using namespace openvdb;
using namespace openvdb::points;
using namespace openvdb::math;
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
class SOP_OpenVDB_Points_Delete: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Points_Delete(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Points_Delete() override = default;
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
}; // class SOP_OpenVDB_Points_Delete
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
openvdb::initialize();
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setHelpText("Specify a subset of the input point data grids to delete from.")
.setChoiceList(&hutil::PrimGroupMenu));
parms.add(hutil::ParmFactory(PRM_STRING, "vdbpointsgroups", "VDB Points Groups")
.setHelpText("Specify VDB points groups to delete.")
.setChoiceList(&hvdb::VDBPointsGroupMenuInput1));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "invert", "Invert")
.setDefault(PRMzeroDefaults)
.setHelpText("Invert point deletion so that points not belonging to any of the "
"groups will be deleted."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "dropgroups", "Drop Points Groups")
.setDefault(PRMoneDefaults)
.setHelpText("Drop the VDB points groups that were used for deletion. This option is "
"ignored if \"invert\" is enabled."));
//////////
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Points Delete",
SOP_OpenVDB_Points_Delete::factory, parms, *table)
#if UT_VERSION_INT < 0x11050000 // earlier than 17.5.0
.setNativeName("")
#endif
.addInput("VDB Points")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Points_Delete::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Delete points that are members of specific groups.\"\"\"\n\
\n\
@overview\n\
\n\
The OpenVDB Points Delete SOP allows deletion of points that are members\n\
of a supplied group(s).\n\
An invert toggle may be enabled to allow deleting points that are not\n\
members of the supplied group(s).\n\
\n\
@related\n\
- [OpenVDB Points Convert|Node:sop/DW_OpenVDBPointsConvert]\n\
- [OpenVDB Points Group|Node:sop/DW_OpenVDBPointsGroup]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
bool
SOP_OpenVDB_Points_Delete::updateParmsFlags()
{
const bool invert = evalInt("invert", 0, 0) != 0;
return enableParm("dropgroups", !invert);
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Points_Delete::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Points_Delete(net, name, op);
}
SOP_OpenVDB_Points_Delete::SOP_OpenVDB_Points_Delete(OP_Network* net,
const char* name, OP_Operator* op)
: hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Points_Delete::Cache::cookVDBSop(OP_Context& context)
{
try {
const std::string groups = evalStdString("vdbpointsgroups", context.getTime());
// early exit if the VDB points group field is empty
if (groups.empty()) return error();
UT_AutoInterrupt progress("Processing points group deletion");
const bool invert = evalInt("invert", 0, context.getTime());
const bool drop = evalInt("dropgroups", 0, context.getTime());
// select Houdini primitive groups we wish to use
hvdb::VdbPrimIterator vdbIt(gdp,
matchGroup(*gdp, evalStdString("group", context.getTime())));
for (; vdbIt; ++vdbIt) {
if (progress.wasInterrupted()) {
throw std::runtime_error("processing was interrupted");
}
GU_PrimVDB* vdbPrim = *vdbIt;
// Limit the lifetime of our const shared copies so
// we don't have false-sharing when we go to make the
// grid unique.
std::vector<std::string> pointGroups;
{
PointDataGrid::ConstPtr inputGrid =
openvdb::gridConstPtrCast<PointDataGrid>(vdbPrim->getConstGridPtr());
// early exit if the grid is of the wrong type
if (!inputGrid) continue;
// early exit if the tree is empty
auto leafIter = inputGrid->tree().cbeginLeaf();
if (!leafIter) continue;
// extract names of all selected VDB groups
// the "exclude groups" parameter to parseNames is not used in this context,
// so we disregard it by storing it in a temporary variable
std::vector<std::string> tmp;
AttributeSet::Descriptor::parseNames(pointGroups, tmp, groups);
// determine in any of the requested groups are actually present in the tree
const AttributeSet::Descriptor& descriptor = leafIter->attributeSet().descriptor();
const bool hasPointsToDrop = std::any_of(pointGroups.begin(), pointGroups.end(),
[&descriptor](const std::string& group) { return descriptor.hasGroup(group); });
if (!hasPointsToDrop) continue;
}
// deep copy the VDB tree if it is not already unique
vdbPrim->makeGridUnique();
PointDataGrid& outputGrid = UTvdbGridCast<PointDataGrid>(vdbPrim->getGrid());
deleteFromGroups(outputGrid.tree(), pointGroups, invert, drop);
}
} catch (const std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 6,709 | C++ | 29.639269 | 100 | 0.636011 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_To_Polygons.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_To_Polygons.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief OpenVDB level set to polygon conversion
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/AttributeTransferUtil.h>
#include <openvdb_houdini/GeometryUtil.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/GeometryUtil.h>
#include <openvdb/tools/VolumeToMesh.h>
#include <openvdb/tools/Mask.h> // for tools::interiorMask()
#include <openvdb/tools/MeshToVolume.h>
#include <openvdb/tools/Morphology.h>
#include <openvdb/tools/LevelSetUtil.h>
#include <openvdb/tools/Prune.h>
#include <openvdb/math/Operators.h>
#include <openvdb/math/Mat3.h>
#include <CH/CH_Manager.h>
#include <GA/GA_PageIterator.h>
#include <GEO/GEO_PolyCounts.h>
#include <GU/GU_ConvertParms.h>
#include <GU/GU_Detail.h>
#include <GU/GU_PolyReduce.h>
#include <GU/GU_PrimPoly.h>
#include <GU/GU_PrimPolySoup.h>
#include <GU/GU_Surfacer.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_UniquePtr.h>
#include <hboost/algorithm/string/join.hpp>
#include <list>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
class SOP_OpenVDB_To_Polygons: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_To_Polygons(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_To_Polygons() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i > 0); }
class Cache: public SOP_VDBCacheOptions
{
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
template<class GridType>
void referenceMeshing(
std::list<openvdb::GridBase::ConstPtr>&,
openvdb::tools::VolumeToMesh&,
const GU_Detail* refGeo,
hvdb::Interrupter&,
const fpreal time);
};
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
};
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to surface.")
.setDocumentation(
"A subset of the input VDB grids to be surfaced"
" (see [specifying volumes|/model/volumes#group])"));
// Geometry Type
parms.add(hutil::ParmFactory(PRM_ORD, "geometrytype", "Geometry Type")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"polysoup", "Polygon Soup",
"poly", "Polygons"
})
.setTooltip(
"Specify the type of geometry to output. A polygon soup is a primitive"
" that stores polygons using a compact memory representation."
" Not all geometry nodes can operate directly on this primitive.")
.setDocumentation(
"The type of geometry to output, either polygons or a polygon soup\n\n"
"A [polygon soup|/model/primitives#polysoup] is a primitive"
" that stores polygons using a compact memory representation.\n\n"
"WARNING:\n"
" Not all geometry nodes can operate directly on polygon soups.\n"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "isovalue", "Isovalue")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_UI, -1.0, PRM_RANGE_UI, 1.0)
.setTooltip(
"The voxel value that determines the surface\n\n"
"Zero works for signed distance fields, while fog volumes require"
" a larger positive value (0.5 is a good initial guess)."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "adaptivity", "Adaptivity")
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_RESTRICTED, 1.0)
.setTooltip(
"The adaptivity threshold determines how closely the output mesh follows"
" the isosurface. A higher threshold enables more variation in polygon size,"
" allowing the surface to be represented with fewer polygons."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "computenormals", "Compute Vertex Normals")
.setTooltip("Compute edge-preserving vertex normals.")
.setDocumentation(
"Compute edge-preserving vertex normals."
" This uses the optional second input to help eliminate seams."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "keepvdbname", "Preserve VDB Name")
.setTooltip("Mark each primitive with the corresponding VDB name."));
//////////
parms.add(hutil::ParmFactory(PRM_HEADING,"sep1", "Reference Options"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "internaladaptivity", "Internal Adaptivity")
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_RESTRICTED, 1.0)
.setTooltip("Overrides the adaptivity threshold for all internal surfaces.")
.setDocumentation(
"When a reference surface is provided, this is the adaptivity threshold"
" for regions that are inside the surface."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "transferattributes", "Transfer Surface Attributes")
.setTooltip(
"Transfer all attributes (primitive, vertex and point) from the reference surface.")
.setDocumentation(
"When a reference surface is provided, this option transfers all attributes\n"
"(primitive, vertex and point) from the reference surface to the output geometry.\n"
"\n"
"NOTE:\n"
" Primitive attribute values can't meaningfully be transferred to a\n"
" polygon soup, because the entire polygon soup is a single primitive.\n"
"\n"
"NOTE:\n"
" Computed vertex normals for primitives in the surface group\n"
" will be overridden.\n"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "sharpenfeatures", "Sharpen Features")
.setDefault(PRMoneDefaults)
.setTooltip("Sharpen edges and corners."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "edgetolerance", "Edge Tolerance")
.setDefault(0.5)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_RESTRICTED, 1.0)
.setTooltip("Controls the edge adaptivity mask."));
parms.add(hutil::ParmFactory(PRM_STRING, "surfacegroup", "Surface Group")
.setDefault("surface_polygons")
.setTooltip(
"Specify a group for all polygons that are coincident with the reference surface.\n\n"
"The group is useful for transferring attributes such as UV coordinates,"
" normals, etc. from the reference surface."));
parms.add(hutil::ParmFactory(PRM_STRING, "interiorgroup", "Interior Group")
.setDefault("interior_polygons")
.setTooltip(
"Specify a group for all polygons that are interior to the reference surface.\n\n"
"The group can be used to identify surface regions that might require"
" projected UV coordinates or new materials."));
parms.add(hutil::ParmFactory(PRM_STRING, "seamlinegroup", "Seam Line Group")
.setDefault("seam_polygons")
.setTooltip(
"Specify a group for all polygons that are in proximity to the seam lines.\n\n"
"This group can be used to drive secondary elements such as debris and dust."));
parms.add(hutil::ParmFactory(PRM_STRING, "seampoints", "Seam Points")
.setDefault("seam_points")
.setTooltip(
"Specify a group of the fracture seam points.\n\n"
"This can be used to drive local pre-fracture dynamics,"
" e.g., local surface buckling."));
//////////
parms.add(hutil::ParmFactory(PRM_HEADING,"sep2", "Masking Options"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "surfacemask", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("Enable / disable the surface mask."));
parms.add(hutil::ParmFactory(PRM_STRING, "surfacemaskname", "Surface Mask")
.setChoiceList(&hutil::PrimGroupMenuInput3)
.setTooltip(
"A single VDB whose active voxels or (if the VDB is a level set or SDF)\n"
"interior voxels define the region to be meshed"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "surfacemaskoffset", "Offset")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_UI, -1.0, PRM_RANGE_UI, 1.0)
.setTooltip(
"Isovalue that determines the interior of the surface mask\n"
"when the mask is a level set or SDF"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "invertsurfacemask", "Invert Surface Mask")
.setTooltip("If enabled, mesh the complement of the mask."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "adaptivityfield", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("Enable / disable the the adaptivity field."));
parms.add(hutil::ParmFactory(PRM_STRING, "adaptivityfieldname", "Adaptivity Field")
.setChoiceList(&hutil::PrimGroupMenuInput3)
.setTooltip(
"A single scalar VDB to be used as a spatial multiplier"
" for the adaptivity threshold"));
//////////
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "smoothseams", "Smooth Seams"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "invertmask", "").setDefault(PRMoneDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "automaticpartitions", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "activepart", ""));
hvdb::OpenVDBOpFactory("VDB to Polygons", SOP_OpenVDB_To_Polygons::factory, parms, *table)
.setNativeName("")
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBToPolygons")
#endif
.setObsoleteParms(obsoleteParms)
.addInput("OpenVDB grids to surface")
.addOptionalInput("Optional reference surface. Can be used "
"to transfer attributes, sharpen features and to "
"eliminate seams from fractured pieces.")
.addOptionalInput("Optional VDB masks")
.setVerb(SOP_NodeVerb::COOK_GENERATOR, []() { return new SOP_OpenVDB_To_Polygons::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Convert VDB volumes into polygonal meshes.\"\"\"\n\
\n\
@overview\n\
\n\
This node converts the surfaces of VDB volumes, including level sets,\n\
into polygonal meshes.\n\
\n\
The second and third inputs are optional.\n\
The second input provides a reference polygon surface, which is useful\n\
for converting fractured VDBs back to polygons.\n\
The third input provides additional VDBs that can be used for masking\n\
(specifying which voxels to convert to polygons) and/or to specify\n\
an adaptivity multiplier.\n\
\n\
@related\n\
- [OpenVDB Convert|Node:sop/DW_OpenVDBConvert]\n\
- [OpenVDB Create|Node:sop/DW_OpenVDBCreate]\n\
- [OpenVDB From Particles|Node:sop/DW_OpenVDBFromParticles]\n\
- [Node:sop/convert]\n\
- [Node:sop/convertvolume]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
OP_Node*
SOP_OpenVDB_To_Polygons::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_To_Polygons(net, name, op);
}
SOP_OpenVDB_To_Polygons::SOP_OpenVDB_To_Polygons(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
void
SOP_OpenVDB_To_Polygons::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
// using the invertmask attribute to detect old houdini files that
// had the regular polygon representation.
PRM_Parm* parm = obsoleteParms->getParmPtr("invertmask");
if (parm && !parm->isFactoryDefault()) {
setInt("geometrytype", 0, 0, 1);
}
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
bool
SOP_OpenVDB_To_Polygons::updateParmsFlags()
{
bool changed = false;
const fpreal time = CHgetEvalTime();
const bool refexists = (nInputs() == 2);
bool usePolygonSoup = evalInt("geometrytype", 0, time) == 0;
changed |= enableParm("computenormals", !usePolygonSoup);
changed |= enableParm("internaladaptivity", refexists);
changed |= enableParm("surfacegroup", refexists);
changed |= enableParm("interiorgroup", refexists);
changed |= enableParm("seamlinegroup", refexists);
changed |= enableParm("seampoints", refexists);
changed |= enableParm("transferattributes", refexists);
changed |= enableParm("sharpenfeatures", refexists);
changed |= enableParm("edgetolerance", refexists);
const bool maskexists = (nInputs() == 3);
changed |= enableParm("surfacemask", maskexists);
changed |= enableParm("adaptivitymask", maskexists);
const bool surfacemask = bool(evalInt("surfacemask", 0, 0));
changed |= enableParm("surfacemaskname", maskexists && surfacemask);
changed |= enableParm("surfacemaskoffset", maskexists && surfacemask);
changed |= enableParm("invertsurfacemask", maskexists && surfacemask);
const bool adaptivitymask = bool(evalInt("adaptivityfield", 0, 0));
changed |= enableParm("adaptivityfieldname", maskexists && adaptivitymask);
return changed;
}
////////////////////////////////////////
void copyMesh(GU_Detail&, openvdb::tools::VolumeToMesh&, hvdb::Interrupter&,
const bool usePolygonSoup = true, const char* gridName = nullptr,
GA_PrimitiveGroup* surfaceGroup = nullptr, GA_PrimitiveGroup* interiorGroup = nullptr,
GA_PrimitiveGroup* seamGroup = nullptr, GA_PointGroup* seamPointGroup = nullptr);
void
copyMesh(
GU_Detail& detail,
openvdb::tools::VolumeToMesh& mesher,
hvdb::Interrupter&,
const bool usePolygonSoup,
const char* gridName,
GA_PrimitiveGroup* surfaceGroup,
GA_PrimitiveGroup* interiorGroup,
GA_PrimitiveGroup* seamGroup,
GA_PointGroup* seamPointGroup)
{
const openvdb::tools::PointList& points = mesher.pointList();
openvdb::tools::PolygonPoolList& polygonPoolList = mesher.polygonPoolList();
const char exteriorFlag = char(openvdb::tools::POLYFLAG_EXTERIOR);
const char seamLineFlag = char(openvdb::tools::POLYFLAG_FRACTURE_SEAM);
const GA_Index firstPrim = detail.getNumPrimitives();
GA_Size npoints = mesher.pointListSize();
const GA_Offset startpt = detail.appendPointBlock(npoints);
UT_ASSERT_COMPILETIME(sizeof(openvdb::tools::PointList::element_type) == sizeof(UT_Vector3));
GA_RWHandleV3 pthandle(detail.getP());
pthandle.setBlock(startpt, npoints, reinterpret_cast<UT_Vector3*>(points.get()));
// group fracture seam points
if (seamPointGroup && GA_Size(mesher.pointFlags().size()) == npoints) {
GA_Offset ptoff = startpt;
for (GA_Size i = 0; i < npoints; ++i) {
if (mesher.pointFlags()[i]) {
seamPointGroup->addOffset(ptoff);
}
++ptoff;
}
}
// index 0 --> interior, not on seam
// index 1 --> interior, on seam
// index 2 --> surface, not on seam
// index 3 --> surface, on seam
GA_Size nquads[4] = {0, 0, 0, 0};
GA_Size ntris[4] = {0, 0, 0, 0};
for (size_t n = 0, N = mesher.polygonPoolListSize(); n < N; ++n) {
const openvdb::tools::PolygonPool& polygons = polygonPoolList[n];
for (size_t i = 0, I = polygons.numQuads(); i < I; ++i) {
int flags = (((polygons.quadFlags(i) & exteriorFlag)!=0) << 1)
| ((polygons.quadFlags(i) & seamLineFlag)!=0);
++nquads[flags];
}
for (size_t i = 0, I = polygons.numTriangles(); i < I; ++i) {
int flags = (((polygons.triangleFlags(i) & exteriorFlag)!=0) << 1)
| ((polygons.triangleFlags(i) & seamLineFlag)!=0);
++ntris[flags];
}
}
GA_Size nverts[4] = {
nquads[0]*4 + ntris[0]*3,
nquads[1]*4 + ntris[1]*3,
nquads[2]*4 + ntris[2]*3,
nquads[3]*4 + ntris[3]*3
};
UT_IntArray verts[4];
for (int flags = 0; flags < 4; ++flags) {
verts[flags].setCapacity(nverts[flags]);
verts[flags].entries(nverts[flags]);
}
GA_Size iquad[4] = {0, 0, 0, 0};
GA_Size itri[4] = {nquads[0]*4, nquads[1]*4, nquads[2]*4, nquads[3]*4};
for (size_t n = 0, N = mesher.polygonPoolListSize(); n < N; ++n) {
const openvdb::tools::PolygonPool& polygons = polygonPoolList[n];
// Copy quads
for (size_t i = 0, I = polygons.numQuads(); i < I; ++i) {
const openvdb::Vec4I& quad = polygons.quad(i);
int flags = (((polygons.quadFlags(i) & exteriorFlag)!=0) << 1)
| ((polygons.quadFlags(i) & seamLineFlag)!=0);
verts[flags](iquad[flags]++) = quad[0];
verts[flags](iquad[flags]++) = quad[1];
verts[flags](iquad[flags]++) = quad[2];
verts[flags](iquad[flags]++) = quad[3];
}
// Copy triangles (adaptive mesh)
for (size_t i = 0, I = polygons.numTriangles(); i < I; ++i) {
const openvdb::Vec3I& triangle = polygons.triangle(i);
int flags = (((polygons.triangleFlags(i) & exteriorFlag)!=0) << 1)
| ((polygons.triangleFlags(i) & seamLineFlag)!=0);
verts[flags](itri[flags]++) = triangle[0];
verts[flags](itri[flags]++) = triangle[1];
verts[flags](itri[flags]++) = triangle[2];
}
}
bool shared_vertices = true;
if (usePolygonSoup) {
// NOTE: Since we could be using the same points for multiple
// polysoups, and the shared vertices option assumes that
// the points are only used by this polysoup, we have to
// use the unique vertices option.
int num_prims = 0;
for (int flags = 0; flags < 4; ++flags) {
if (!nquads[flags] && !ntris[flags]) continue;
num_prims++;
}
shared_vertices = (num_prims <= 1);
}
for (int flags = 0; flags < 4; ++flags) {
if (!nquads[flags] && !ntris[flags]) continue;
GEO_PolyCounts sizelist;
if (nquads[flags]) sizelist.append(4, nquads[flags]);
if (ntris[flags]) sizelist.append(3, ntris[flags]);
GA_Detail::OffsetMarker marker(detail);
if (usePolygonSoup) {
GU_PrimPolySoup::build(
&detail, startpt, npoints, sizelist, verts[flags].array(), shared_vertices);
} else {
GU_PrimPoly::buildBlock(&detail, startpt, npoints, sizelist, verts[flags].array());
}
GA_Range range(marker.primitiveRange());
//GA_Range pntRange(marker.pointRange());
/*GU_ConvertParms parms;
parms.preserveGroups = true;
GUconvertCopySingleVertexPrimAttribsAndGroups(parms,
*srcvdb->getParent(), srcvdb->getMapOffset(), detail,
range, pntRange);*/
//if (delgroup) delgroup->removeRange(range);
if (seamGroup && (flags & 1)) seamGroup->addRange(range);
if (surfaceGroup && (flags & 2)) surfaceGroup->addRange(range);
if (interiorGroup && !(flags & 2)) interiorGroup->addRange(range);
}
// Keep VDB grid name
const GA_Index lastPrim = detail.getNumPrimitives();
if (gridName != nullptr && firstPrim != lastPrim) {
GA_RWAttributeRef aRef = detail.findPrimitiveAttribute("name");
if (!aRef.isValid()) aRef = detail.addStringTuple(GA_ATTRIB_PRIMITIVE, "name", 1);
GA_Attribute * nameAttr = aRef.getAttribute();
if (nameAttr) {
const GA_AIFSharedStringTuple * stringAIF = nameAttr->getAIFSharedStringTuple();
if (stringAIF) {
GA_Range range(detail.getPrimitiveMap(),
detail.primitiveOffset(firstPrim), detail.primitiveOffset(lastPrim));
stringAIF->setString(nameAttr, range, gridName, 0);
}
}
}
}
////////////////////////////////////////
namespace {
struct InteriorMaskOp
{
InteriorMaskOp(double iso = 0.0): inIsovalue(iso) {}
template<typename GridType>
void operator()(const GridType& grid)
{
outGridPtr = openvdb::tools::interiorMask(grid, inIsovalue);
}
const double inIsovalue;
openvdb::BoolGrid::Ptr outGridPtr;
};
// Extract a boolean mask from a grid of any type.
inline hvdb::GridCPtr
getMaskFromGrid(const hvdb::GridCPtr& gridPtr, double isovalue = 0.0)
{
hvdb::GridCPtr maskGridPtr;
if (gridPtr) {
if (gridPtr->isType<openvdb::BoolGrid>()) {
// If the input grid is already boolean, return it.
maskGridPtr = gridPtr;
} else {
InteriorMaskOp op{isovalue};
gridPtr->apply<hvdb::AllGridTypes>(op);
maskGridPtr = op.outGridPtr;
}
}
return maskGridPtr;
}
} // unnamed namespace
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_To_Polygons::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
hvdb::Interrupter boss("Surfacing VDB primitives");
const GU_Detail* vdbGeo = inputGeo(0);
if (vdbGeo == nullptr) return error();
// Get the group of grids to surface.
const GA_PrimitiveGroup* group = matchGroup(*vdbGeo, evalStdString("group", time));
hvdb::VdbPrimCIterator vdbIt(vdbGeo, group);
if (!vdbIt) {
addWarning(SOP_MESSAGE, "No VDB primitives found.");
return error();
}
// Eval attributes
const bool usePolygonSoup = evalInt("geometrytype", 0, time) == 0;
const double adaptivity = double(evalFloat("adaptivity", 0, time));
const double iso = double(evalFloat("isovalue", 0, time));
const bool computeNormals = !usePolygonSoup && evalInt("computenormals", 0, time);
const bool keepVdbName = evalInt("keepvdbname", 0, time);
const float maskoffset = static_cast<float>(evalFloat("surfacemaskoffset", 0, time));
const bool invertmask = evalInt("invertsurfacemask", 0, time);
// Setup level set mesher
openvdb::tools::VolumeToMesh mesher(iso, adaptivity);
// Check mask input
const GU_Detail* maskGeo = inputGeo(2);
if (maskGeo) {
if (evalInt("surfacemask", 0, time)) {
const auto maskStr = evalStdString("surfacemaskname", time);
const GA_PrimitiveGroup* maskGroup =
parsePrimitiveGroups(maskStr.c_str(), GroupCreator(maskGeo));
if (!maskGroup && !maskStr.empty()) {
addWarning(SOP_MESSAGE, "Surface mask not found.");
} else {
hvdb::VdbPrimCIterator maskIt(maskGeo, maskGroup);
if (maskIt) {
if (auto maskGridPtr = getMaskFromGrid(maskIt->getGridPtr(), maskoffset)) {
mesher.setSurfaceMask(maskGridPtr, invertmask);
} else {
std::string mesg = "Surface mask "
+ maskIt.getPrimitiveNameOrIndex().toStdString()
+ " of type " + maskIt->getGrid().type() + " is not supported.";
addWarning(SOP_MESSAGE, mesg.c_str());
}
}
}
}
if (evalInt("adaptivityfield", 0, time)) {
const auto maskStr = evalStdString("adaptivityfieldname", time);
const GA_PrimitiveGroup* maskGroup = matchGroup(*maskGeo, maskStr);
if (!maskGroup && !maskStr.empty()) {
addWarning(SOP_MESSAGE, "Adaptivity field not found.");
} else {
hvdb::VdbPrimCIterator maskIt(maskGeo, maskGroup);
if (maskIt) {
openvdb::FloatGrid::ConstPtr grid =
openvdb::gridConstPtrCast<openvdb::FloatGrid>(maskIt->getGridPtr());
mesher.setSpatialAdaptivity(grid);
}
}
}
}
// Check reference input
const GU_Detail* refGeo = inputGeo(1);
if (refGeo) {
// Collect all level set grids.
std::list<openvdb::GridBase::ConstPtr> grids;
std::vector<std::string> nonLevelSetList, nonLinearList;
for (; vdbIt; ++vdbIt) {
if (boss.wasInterrupted()) break;
const openvdb::GridClass gridClass = vdbIt->getGrid().getGridClass();
if (gridClass != openvdb::GRID_LEVEL_SET) {
nonLevelSetList.push_back(vdbIt.getPrimitiveNameOrIndex().toStdString());
continue;
}
if (!vdbIt->getGrid().transform().isLinear()) {
nonLinearList.push_back(vdbIt.getPrimitiveNameOrIndex().toStdString());
continue;
}
// (We need a shallow copy to sync primitive & grid names).
grids.push_back(vdbIt->getGrid().copyGrid());
openvdb::ConstPtrCast<openvdb::GridBase>(grids.back())->setName(
vdbIt->getGridName());
}
if (!nonLevelSetList.empty()) {
std::string s = "Reference meshing is only supported for "
"Level Set grids, the following grids were skipped: '" +
hboost::algorithm::join(nonLevelSetList, ", ") + "'.";
addWarning(SOP_MESSAGE, s.c_str());
}
if (!nonLinearList.empty()) {
std::string s = "The following grids were skipped: '" +
hboost::algorithm::join(nonLinearList, ", ") +
"' because they don't have a linear/affine transform.";
addWarning(SOP_MESSAGE, s.c_str());
}
// Mesh using a reference surface
if (!grids.empty() && !boss.wasInterrupted()) {
if (grids.front()->isType<openvdb::FloatGrid>()) {
referenceMeshing<openvdb::FloatGrid>(grids, mesher, refGeo, boss, time);
} else if (grids.front()->isType<openvdb::DoubleGrid>()) {
referenceMeshing<openvdb::DoubleGrid>(grids, mesher, refGeo, boss, time);
} else {
addError(SOP_MESSAGE, "Unsupported grid type.");
}
}
} else {
// Mesh each VDB primitive independently
for (; vdbIt; ++vdbIt) {
if (boss.wasInterrupted()) break;
hvdb::GEOvdbApply<hvdb::ScalarGridTypes>(**vdbIt, mesher);
copyMesh(*gdp, mesher, boss, usePolygonSoup,
keepVdbName ? vdbIt.getPrimitive()->getGridName() : nullptr);
}
if (!boss.wasInterrupted() && computeNormals) {
UTparallelFor(GA_SplittableRange(gdp->getPrimitiveRange()),
hvdb::VertexNormalOp(*gdp));
}
}
if (boss.wasInterrupted()) {
addWarning(SOP_MESSAGE, "Process was interrupted");
}
boss.end();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
template<class GridType>
void
SOP_OpenVDB_To_Polygons::Cache::referenceMeshing(
std::list<openvdb::GridBase::ConstPtr>& grids,
openvdb::tools::VolumeToMesh& mesher,
const GU_Detail* refGeo,
hvdb::Interrupter& boss,
const fpreal time)
{
if (refGeo == nullptr) return;
const bool usePolygonSoup = evalInt("geometrytype", 0, time) == 0;
const bool computeNormals = !usePolygonSoup && evalInt("computenormals", 0, time);
const bool transferAttributes = evalInt("transferattributes", 0, time);
const bool keepVdbName = evalInt("keepvdbname", 0, time);
const bool sharpenFeatures = evalInt("sharpenfeatures", 0, time);
const float edgetolerance = static_cast<float>(evalFloat("edgetolerance", 0, time));
using TreeType = typename GridType::TreeType;
using ValueType = typename GridType::ValueType;
// Get the first grid's transform and background value.
openvdb::math::Transform::Ptr transform = grids.front()->transform().copy();
typename GridType::ConstPtr firstGrid = openvdb::gridConstPtrCast<GridType>(grids.front());
if (!firstGrid) {
addError(SOP_MESSAGE, "Unsupported grid type.");
return;
}
const ValueType backgroundValue = firstGrid->background();
const openvdb::GridClass gridClass = firstGrid->getGridClass();
typename GridType::ConstPtr refGrid;
using IntGridT = typename GridType::template ValueConverter<openvdb::Int32>::Type;
typename IntGridT::Ptr indexGrid; // replace
openvdb::tools::MeshToVoxelEdgeData edgeData;
# if 0
// Check for reference VDB
{
const GA_PrimitiveGroup *refGroup = matchGroup(*refGeo, "");
hvdb::VdbPrimCIterator refIt(refGeo, refGroup);
if (refIt) {
const openvdb::GridClass refClass = refIt->getGrid().getGridClass();
if (refIt && refClass == openvdb::GRID_LEVEL_SET) {
refGrid = openvdb::gridConstPtrCast<GridType>(refIt->getGridPtr());
}
}
}
#endif
// Check for reference mesh
UT_UniquePtr<GU_Detail> geoPtr;
if (!refGrid) {
std::string warningStr;
geoPtr = hvdb::convertGeometry(*refGeo, warningStr, &boss);
if (geoPtr) {
refGeo = geoPtr.get();
if (!warningStr.empty()) addWarning(SOP_MESSAGE, warningStr.c_str());
}
std::vector<openvdb::Vec3s> pointList;
std::vector<openvdb::Vec4I> primList;
pointList.resize(refGeo->getNumPoints());
primList.resize(refGeo->getNumPrimitives());
UTparallelFor(GA_SplittableRange(refGeo->getPointRange()),
hvdb::TransformOp(refGeo, *transform, pointList));
UTparallelFor(GA_SplittableRange(refGeo->getPrimitiveRange()),
hvdb::PrimCpyOp(refGeo, primList));
if (boss.wasInterrupted()) return;
openvdb::tools::QuadAndTriangleDataAdapter<openvdb::Vec3s, openvdb::Vec4I>
mesh(pointList, primList);
float bandWidth = 3.0;
if (gridClass != openvdb::GRID_LEVEL_SET) {
bandWidth = float(backgroundValue) / float(transform->voxelSize()[0]);
}
indexGrid.reset(new IntGridT(0));
refGrid = openvdb::tools::meshToVolume<GridType>(boss,
mesh, *transform, bandWidth, bandWidth, 0, indexGrid.get());
if (sharpenFeatures) edgeData.convert(pointList, primList);
}
if (boss.wasInterrupted()) return;
using BoolTreeType = typename TreeType::template ValueConverter<bool>::Type;
typename BoolTreeType::Ptr maskTree;
if (sharpenFeatures) {
maskTree = typename BoolTreeType::Ptr(new BoolTreeType(false));
maskTree->topologyUnion(indexGrid->tree());
openvdb::tree::LeafManager<BoolTreeType> maskLeafs(*maskTree);
hvdb::GenAdaptivityMaskOp<typename IntGridT::TreeType, BoolTreeType>
op(*refGeo, indexGrid->tree(), maskLeafs, edgetolerance);
op.run();
openvdb::tools::pruneInactive(*maskTree);
openvdb::tools::dilateVoxels(*maskTree, 2);
mesher.setAdaptivityMask(maskTree);
}
if (boss.wasInterrupted()) return;
const double iadaptivity = double(evalFloat("internaladaptivity", 0, time));
mesher.setRefGrid(refGrid, iadaptivity);
std::vector<std::string> badTransformList, badBackgroundList, badTypeList;
GA_PrimitiveGroup *surfaceGroup = nullptr, *interiorGroup = nullptr, *seamGroup = nullptr;
GA_PointGroup* seamPointGroup = nullptr;
{
UT_String newGroupStr;
evalString(newGroupStr, "surfacegroup", 0, time);
if(newGroupStr.length() > 0) {
surfaceGroup = gdp->findPrimitiveGroup(newGroupStr);
if (!surfaceGroup) surfaceGroup = gdp->newPrimitiveGroup(newGroupStr);
}
evalString(newGroupStr, "interiorgroup", 0, time);
if(newGroupStr.length() > 0) {
interiorGroup = gdp->findPrimitiveGroup(newGroupStr);
if (!interiorGroup) interiorGroup = gdp->newPrimitiveGroup(newGroupStr);
}
evalString(newGroupStr, "seamlinegroup", 0, time);
if(newGroupStr.length() > 0) {
seamGroup = gdp->findPrimitiveGroup(newGroupStr);
if (!seamGroup) seamGroup = gdp->newPrimitiveGroup(newGroupStr);
}
evalString(newGroupStr, "seampoints", 0, time);
if(newGroupStr.length() > 0) {
seamPointGroup = gdp->findPointGroup(newGroupStr);
if (!seamPointGroup) seamPointGroup = gdp->newPointGroup(newGroupStr);
}
}
for (auto it = grids.begin(); it != grids.end(); ++it) {
if (boss.wasInterrupted()) break;
typename GridType::ConstPtr grid = openvdb::gridConstPtrCast<GridType>(*it);
if (!grid) {
badTypeList.push_back(grid->getName());
continue;
}
if (grid->transform() != *transform) {
badTransformList.push_back(grid->getName());
continue;
}
if (!openvdb::math::isApproxEqual(grid->background(), backgroundValue)) {
badBackgroundList.push_back(grid->getName());
continue;
}
mesher(*grid);
copyMesh(*gdp, mesher, boss, usePolygonSoup,
keepVdbName ? grid->getName().c_str() : nullptr,
surfaceGroup, interiorGroup, seamGroup, seamPointGroup);
}
grids.clear();
// Sharpen Features
if (!boss.wasInterrupted() && sharpenFeatures) {
UTparallelFor(GA_SplittableRange(gdp->getPointRange()),
hvdb::SharpenFeaturesOp(
*gdp, *refGeo, edgeData, *transform, surfaceGroup, maskTree.get()));
}
// Compute vertex normals
if (!boss.wasInterrupted() && computeNormals) {
UTparallelFor(GA_SplittableRange(gdp->getPrimitiveRange()),
hvdb::VertexNormalOp(*gdp, interiorGroup, (transferAttributes ? -1.0f : 0.7f) ));
if (!interiorGroup) {
addWarning(SOP_MESSAGE, "More accurate vertex normals can be generated "
"if the interior polygon group is enabled.");
}
}
// Transfer primitive attributes
if (!boss.wasInterrupted() && transferAttributes && refGeo && indexGrid) {
hvdb::transferPrimitiveAttributes(*refGeo, *gdp, *indexGrid, boss, surfaceGroup);
}
if (!badTransformList.empty()) {
std::string s = "The following grids were skipped: '" +
hboost::algorithm::join(badTransformList, ", ") +
"' because they don't match the transform of the first grid.";
addWarning(SOP_MESSAGE, s.c_str());
}
if (!badBackgroundList.empty()) {
std::string s = "The following grids were skipped: '" +
hboost::algorithm::join(badBackgroundList, ", ") +
"' because they don't match the background value of the first grid.";
addWarning(SOP_MESSAGE, s.c_str());
}
if (!badTypeList.empty()) {
std::string s = "The following grids were skipped: '" +
hboost::algorithm::join(badTypeList, ", ") +
"' because they don't have the same data type as the first grid.";
addWarning(SOP_MESSAGE, s.c_str());
}
}
| 35,996 | C++ | 36.263975 | 99 | 0.613679 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Combine.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Combine.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/math/Math.h> // for isFinite()
#include <openvdb/tools/ChangeBackground.h>
#include <openvdb/tools/Composite.h>
#include <openvdb/tools/GridTransformer.h> // for resampleToMatch()
#include <openvdb/tools/LevelSetRebuild.h> // for levelSetRebuild()
#include <openvdb/tools/Morphology.h> // for deactivate()
#include <openvdb/tools/Prune.h>
#include <openvdb/tools/SignedFloodFill.h>
#include <openvdb/util/NullInterrupter.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_Interrupt.h>
#include <algorithm> // for std::min()
#include <cctype> // for isspace()
#include <iomanip>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace {
//
// Operations
//
enum Operation {
OP_COPY_A, // A
OP_COPY_B, // B
OP_INVERT, // 1 - A
OP_ADD, // A + B
OP_SUBTRACT, // A - B
OP_MULTIPLY, // A * B
OP_DIVIDE, // A / B
OP_MAXIMUM, // max(A, B)
OP_MINIMUM, // min(A, B)
OP_BLEND1, // (1 - A) * B
OP_BLEND2, // A + (1 - A) * B
OP_UNION, // CSG A u B
OP_INTERSECTION, // CSG A n B
OP_DIFFERENCE, // CSG A / B
OP_REPLACE, // replace A with B
OP_TOPO_UNION, // A u active(B)
OP_TOPO_INTERSECTION, // A n active(B)
OP_TOPO_DIFFERENCE // A / active(B)
};
enum { OP_FIRST = OP_COPY_A, OP_LAST = OP_TOPO_DIFFERENCE };
//#define TIMES " \xd7 " // ISO-8859 multiplication symbol
#define TIMES " * "
const char* const sOpMenuItems[] = {
"copya", "Copy A",
"copyb", "Copy B",
"inverta", "Invert A",
"add", "Add",
"subtract", "Subtract",
"multiply", "Multiply",
"divide", "Divide",
"maximum", "Maximum",
"minimum", "Minimum",
"compatimesb", "(1 - A)" TIMES "B",
"apluscompatimesb", "A + (1 - A)" TIMES "B",
"sdfunion", "SDF Union",
"sdfintersect", "SDF Intersection",
"sdfdifference", "SDF Difference",
"replacewithactive", "Replace A with Active B",
"topounion", "Activity Union",
"topointersect", "Activity Intersection",
"topodifference", "Activity Difference",
nullptr
};
#undef TIMES
inline Operation
asOp(int i, Operation defaultOp = OP_COPY_A)
{
return (i >= OP_FIRST && i <= OP_LAST)
? static_cast<Operation>(i) : defaultOp;
}
inline bool needAGrid(Operation op) { return (op != OP_COPY_B); }
inline bool needBGrid(Operation op) { return (op != OP_COPY_A && op != OP_INVERT); }
inline bool needLevelSets(Operation op)
{
return (op == OP_UNION || op == OP_INTERSECTION || op == OP_DIFFERENCE);
}
//
// Resampling options
//
enum ResampleMode {
RESAMPLE_OFF, // don't auto-resample grids
RESAMPLE_B, // resample B to match A
RESAMPLE_A, // resample A to match B
RESAMPLE_HI_RES, // resample higher-res grid to match lower-res
RESAMPLE_LO_RES // resample lower-res grid to match higher-res
};
enum { RESAMPLE_MODE_FIRST = RESAMPLE_OFF, RESAMPLE_MODE_LAST = RESAMPLE_LO_RES };
const char* const sResampleModeMenuItems[] = {
"off", "Off",
"btoa", "B to Match A",
"atob", "A to Match B",
"hitolo", "Higher-res to Match Lower-res",
"lotohi", "Lower-res to Match Higher-res",
nullptr
};
inline ResampleMode
asResampleMode(exint i, ResampleMode defaultMode = RESAMPLE_B)
{
return (i >= RESAMPLE_MODE_FIRST && i <= RESAMPLE_MODE_LAST)
? static_cast<ResampleMode>(i) : defaultMode;
}
//
// Collation options
//
enum CollationMode {
COLL_PAIRS = 0,
COLL_A_WITH_1ST_B,
COLL_FLATTEN_A,
COLL_FLATTEN_B_TO_A,
COLL_FLATTEN_A_GROUPS
};
inline CollationMode
asCollation(const std::string& str)
{
if (str == "pairs") return COLL_PAIRS;
if (str == "awithfirstb") return COLL_A_WITH_1ST_B;
if (str == "flattena") return COLL_FLATTEN_A;
if (str == "flattenbtoa") return COLL_FLATTEN_B_TO_A;
if (str == "flattenagroups") return COLL_FLATTEN_A_GROUPS;
throw std::runtime_error{"invalid collation mode \"" + str + "\""};
}
} // anonymous namespace
/// @brief SOP to combine two VDB grids via various arithmetic operations
class SOP_OpenVDB_Combine: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Combine(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Combine() override {}
static OP_Node* factory(OP_Network*, const char*, OP_Operator*);
class Cache: public SOP_VDBCacheOptions
{
public:
fpreal getTime() const { return mTime; }
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
private:
hvdb::GridPtr combineGrids(Operation,
hvdb::GridCPtr aGrid, hvdb::GridCPtr bGrid,
const UT_String& aGridName, const UT_String& bGridName,
ResampleMode resample);
fpreal mTime = 0.0;
}; // class Cache
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
private:
template<typename> struct DispatchOp;
struct CombineOp;
};
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Group A
parms.add(hutil::ParmFactory(PRM_STRING, "agroup", "Group A")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Use a subset of the first input as the A VDB(s).")
.setDocumentation(
"The VDBs to be used from the first input"
" (see [specifying volumes|/model/volumes#group])"));
// Group B
parms.add(hutil::ParmFactory(PRM_STRING, "bgroup", "Group B")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("Use a subset of the second input as the B VDB(s).")
.setDocumentation(
"The VDBs to be used from the second input"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "collation", "Collation")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"pairs", "Combine A/B Pairs",
"awithfirstb", "Combine Each A With First B",
"flattena", "Flatten All A",
"flattenbtoa", "Flatten All B Into First A",
"flattenagroups", "Flatten A Groups"
})
.setDefault("pairs")
.setTooltip("Specify the order in which to combine VDBs from the A and/or B groups.")
.setDocumentation("\
The order in which to combine VDBs from the _A_ and/or _B_ groups\n\
\n\
Combine _A_/_B_ Pairs:\n\
Combine pairs of _A_ and _B_ VDBs, in the order in which they appear\n\
in their respective groups.\n\
Combine Each _A_ With First _B_:\n\
Combine each _A_ VDB with the first _B_ VDB.\n\
Flatten All _A_:\n\
Collapse all of the _A_ VDBs into a single output VDB.\n\
Flatten All _B_ Into First _A_:\n\
Accumulate each _B_ VDB into the first _A_ VDB, producing a single output VDB.\n\
Flatten _A_ Groups:\n\
Collapse VDBs within each _A_ group, producing one output VDB for each group.\n\
\n\
Space-separated group patterns are treated as distinct groups in this mode.\n\
For example, \"`@name=x* @name=y*`\" results in two output VDBs\n\
(provided that there is at least one _A_ VDB whose name starts with `x`\n\
and at least one whose name starts with `y`).\n\
"));
// Menu of available operations
parms.add(hutil::ParmFactory(PRM_ORD, "operation", "Operation")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, sOpMenuItems)
.setDocumentation("\
Each voxel that is active in either of the input VDBs\n\
will be processed with this operation.\n\
\n\
Copy _A_:\n\
Use _A_, ignore _B_.\n\
\n\
Copy _B_:\n\
Use _B_, ignore _A_.\n\
\n\
Invert _A_:\n\
Use 0 − _A_.\n\
\n\
Add:\n\
Add the values of _A_ and _B_.\n\
\n\
NOTE:\n\
Using this for fog volumes, which have density values between 0 and 1,\n\
will push densities over 1 and cause a bright interface between the\n\
input volumes when rendered. To avoid this problem, try using the\n\
_A_ + (1 − _A_) × _B_\n\
operation.\n\
\n\
Subtract:\n\
Subtract the values of _B_ from the values of _A_.\n\
\n\
Multiply:\n\
Multiply the values of _A_ and _B_.\n\
\n\
Divide:\n\
Divide the values of _A_ by _B_.\n\
\n\
Maximum:\n\
Use the maximum of each corresponding value from _A_ and _B_.\n\
\n\
NOTE:\n\
Using this for fog volumes, which have density values between 0 and 1,\n\
can produce a dark interface between the inputs when rendered, due to\n\
the binary nature of choosing a value from either from _A_ or _B_.\n\
To avoid this problem, try using the\n\
(1 − _A_) × _B_ operation.\n\
\n\
Minimum:\n\
Use the minimum of each corresponding value from _A_ and _B_.\n\
\n\
(1 − _A_) × _B_:\n\
This is similar to SDF Difference, except for fog volumes,\n\
and can also be viewed as \"soft cutout\" operation.\n\
It is typically used to clear out an area around characters\n\
in a dust simulation or some other environmental volume.\n\
\n\
_A_ + (1 − _A_) × _B_:\n\
This is similar to SDF Union, except for fog volumes, and\n\
can also be viewed as a \"soft union\" or \"merge\" operation.\n\
Consider using this over the Maximum or Add operations\n\
for fog volumes.\n\
\n\
SDF Union:\n\
Generate the union of signed distance fields _A_ and _B_.\n\
\n\
SDF Intersection:\n\
Generate the intersection of signed distance fields _A_ and _B_.\n\
\n\
SDF Difference:\n\
Remove signed distance field _B_ from signed distance field _A_.\n\
\n\
Replace _A_ with Active _B_:\n\
Copy the active voxels of _B_ into _A_.\n\
\n\
Activity Union:\n\
Make voxels active if they are active in either _A_ or _B_.\n\
\n\
Activity Intersection:\n\
Make voxels active if they are active in both _A_ and _B_.\n\
\n\
It is recommended to enable pruning when using this operation.\n\
\n\
Activity Difference:\n\
Make voxels active if they are active in _A_ but not in _B_.\n\
\n\
It is recommended to enable pruning when using this operation.\n"));
// Scalar multiplier on the A grid
parms.add(hutil::ParmFactory(PRM_FLT_J, "amult", "A Multiplier")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_UI, -10, PRM_RANGE_UI, 10)
.setTooltip(
"Multiply voxel values in the A VDB by a scalar\n"
"before combining the A VDB with the B VDB."));
// Scalar multiplier on the B grid
parms.add(hutil::ParmFactory(PRM_FLT_J, "bmult", "B Multiplier")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_UI, -10, PRM_RANGE_UI, 10)
.setTooltip(
"Multiply voxel values in the B VDB by a scalar\n"
"before combining the A VDB with the B VDB."));
// Menu of resampling options
parms.add(hutil::ParmFactory(PRM_ORD, "resample", "Resample")
.setDefault(PRMoneDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, sResampleModeMenuItems)
.setTooltip(
"If the A and B VDBs have different transforms, one VDB should\n"
"be resampled to match the other before the two are combined.\n"
"Also, level set VDBs should have matching background values\n"
"(i.e., matching narrow band widths)."));
// Menu of resampling interpolation order options
parms.add(hutil::ParmFactory(PRM_ORD, "resampleinterp", "Interpolation")
.setDefault(PRMoneDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"point", "Nearest",
"linear", "Linear",
"quadratic", "Quadratic"
})
.setTooltip(
"Specify the type of interpolation to be used when\n"
"resampling one VDB to match the other's transform.")
.setDocumentation(
"The type of interpolation to be used when resampling one VDB"
" to match the other's transform\n\n"
"Nearest neighbor interpolation is fast but can introduce noticeable"
" sampling artifacts. Quadratic interpolation is slow but high-quality."
" Linear interpolation is intermediate in speed and quality."));
// Deactivate background value toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "deactivate", "Deactivate Background Voxels")
.setDefault(PRMzeroDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setDocumentation(
"Deactivate active output voxels whose values equal"
" the output VDB's background value."));
// Deactivation tolerance slider
parms.add(hutil::ParmFactory(PRM_FLT_J, "bgtolerance", "Deactivate Tolerance")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 1)
.setTooltip(
"Deactivate active output voxels whose values\n"
"equal the output VDB's background value.\n"
"Voxel values are considered equal if they differ\n"
"by less than the specified tolerance.")
.setDocumentation(
"When deactivation of background voxels is enabled,"
" voxel values are considered equal to the background"
" if they differ by less than this tolerance."));
// Prune toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "prune", "Prune")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setDocumentation(
"Reduce the memory footprint of output VDBs that have"
" (sufficiently large) regions of voxels with the same value.\n\n"
"NOTE:\n"
" Pruning affects only the memory usage of a VDB.\n"
" It does not remove voxels, apart from inactive voxels\n"
" whose value is equal to the background."));
// Pruning tolerance slider
parms.add(hutil::ParmFactory(PRM_FLT_J, "tolerance", "Prune Tolerance")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 1)
.setTooltip(
"Collapse regions of constant value in output VDBs.\n"
"Voxel values are considered equal if they differ\n"
"by less than the specified tolerance.")
.setDocumentation(
"When pruning is enabled, voxel values are considered equal"
" if they differ by less than the specified tolerance."));
// Flood fill toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "flood", "Signed-Flood-Fill Output SDFs")
.setDefault(PRMzeroDefaults)
.setTooltip(
"Reclassify inactive voxels of level set VDBs as either inside or outside.")
.setDocumentation(
"Test inactive voxels to determine if they are inside or outside of an SDF"
" and hence whether they should have negative or positive sign."));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "combination", "Operation")
.setDefault(-2));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep1", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep2", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "flatten", "Flatten All B into A")
.setDefault(PRMzeroDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "pairs", "Combine A/B Pairs")
.setDefault(PRMoneDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "groupA", "Group A"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "groupB", "Group B"));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "mult_a", "A Multiplier")
.setDefault(PRMoneDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "mult_b", "B Multiplier")
.setDefault(PRMoneDefaults));
// Register SOP
hvdb::OpenVDBOpFactory("VDB Combine", SOP_OpenVDB_Combine::factory, parms, *table)
.addInput("A VDBs")
.addOptionalInput("B VDBs")
.setObsoleteParms(obsoleteParms)
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Combine::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Combine the values of VDB volumes in various ways.\"\"\"\n\
\n\
@related\n\
\n\
- [Node:sop/vdbcombine]\n\
- [Node:sop/volumevop]\n\
- [Node:sop/volumemix]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Combine::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Combine(net, name, op);
}
SOP_OpenVDB_Combine::SOP_OpenVDB_Combine(OP_Network* net, const char* name, OP_Operator* op)
: SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
void
SOP_OpenVDB_Combine::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
const fpreal time = 0.0;
if (PRM_Parm* parm = obsoleteParms->getParmPtr("combination")) {
if (!parm->isFactoryDefault()) {
// The "combination" choices (union, intersection, difference) from
// the old CSG SOP were appended to this SOP's "operation" list.
switch (obsoleteParms->evalInt("combination", 0, time)) {
case 0: setInt("operation", 0, 0.0, OP_UNION); break;
case 1: setInt("operation", 0, 0.0, OP_INTERSECTION); break;
case 2: setInt("operation", 0, 0.0, OP_DIFFERENCE); break;
}
}
}
{
PRM_Parm
*flatten = obsoleteParms->getParmPtr("flatten"),
*pairs = obsoleteParms->getParmPtr("pairs");
if (flatten && !flatten->isFactoryDefault()) { // factory default was Off
setString("flattenbtoa", CH_STRING_LITERAL, "collation", 0, time);
} else if (pairs && !pairs->isFactoryDefault()) { // factory default was On
setString("awithfirstb", CH_STRING_LITERAL, "collation", 0, time);
}
}
resolveRenamedParm(*obsoleteParms, "groupA", "agroup");
resolveRenamedParm(*obsoleteParms, "groupB", "bgroup");
resolveRenamedParm(*obsoleteParms, "mult_a", "amult");
resolveRenamedParm(*obsoleteParms, "mult_b", "bmult");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
// Enable or disable parameters in the UI.
bool
SOP_OpenVDB_Combine::updateParmsFlags()
{
bool changed = false;
changed |= enableParm("resampleinterp", evalInt("resample", 0, 0) != 0);
changed |= enableParm("bgtolerance", evalInt("deactivate", 0, 0) != 0);
changed |= enableParm("tolerance", evalInt("prune", 0, 0) != 0);
return changed;
}
////////////////////////////////////////
namespace {
using StringVec = std::vector<std::string>;
// Split a string into group patterns separated by whitespace.
// For example, given '@name=d* @id="1 2" {grp1 grp2}', return
// ['@name=d*', '@id="1 2"', '{grp1 grp2}'].
// (This is nonstandard. Normally, multiple patterns are unioned
// to define a single group.)
// Nesting of quotes and braces is not supported.
inline StringVec
splitPatterns(const std::string& str)
{
StringVec patterns;
bool quoted = false, braced = false;
std::string pattern;
for (const auto c: str) {
if (isspace(c)) {
if (pattern.empty()) continue; // skip whitespace between patterns
if (quoted || braced) {
pattern.push_back(c); // keep whitespace within quotes or braces
} else {
// At the end of a pattern. Start a new pattern.
patterns.push_back(pattern);
pattern.clear();
quoted = braced = false;
}
} else {
switch (c) {
case '"': quoted = !quoted; break;
case '{': braced = true; break;
case '}': braced = false; break;
default: break;
}
pattern.push_back(c);
}
}
if (!pattern.empty()) { patterns.push_back(pattern); } // add the final pattern
// If no patterns were found, add an empty pattern, which matches everything.
if (patterns.empty()) { patterns.push_back(""); }
return patterns;
}
inline UT_String
getGridName(const GU_PrimVDB* vdb, const UT_String& defaultName = "")
{
UT_String name{UT_String::ALWAYS_DEEP};
if (vdb != nullptr) {
name = vdb->getGridName();
if (!name.isstring()) name = defaultName;
}
return name;
}
} // anonymous namespace
OP_ERROR
SOP_OpenVDB_Combine::Cache::cookVDBSop(OP_Context& context)
{
try {
UT_AutoInterrupt progress{"Combining VDBs"};
mTime = context.getTime();
const Operation op = asOp(static_cast<int>(evalInt("operation", 0, getTime())));
const ResampleMode resample = asResampleMode(evalInt("resample", 0, getTime()));
const CollationMode collation = asCollation(evalStdString("collation", getTime()));
const bool
flattenA = ((collation == COLL_FLATTEN_A) || (collation == COLL_FLATTEN_A_GROUPS)),
flatten = (flattenA || (collation == COLL_FLATTEN_B_TO_A)),
needA = needAGrid(op),
needB = (needBGrid(op) && !flattenA);
GU_Detail* aGdp = gdp;
const GU_Detail* bGdp = inputGeo(1, context);
const auto aGroupStr = evalStdString("agroup", getTime());
const auto bGroupStr = evalStdString("bgroup", getTime());
const auto* bGroup = (!bGdp ? nullptr : matchGroup(*bGdp, bGroupStr));
// In Flatten A Groups mode, treat space-separated subpatterns
// as specifying distinct groups to be processed independently.
// (In all other modes, subpatterns are unioned into a single group.)
std::vector<const GA_PrimitiveGroup*> aGroupVec;
if (collation != COLL_FLATTEN_A_GROUPS) {
aGroupVec.push_back(matchGroup(*aGdp, aGroupStr));
} else {
for (const auto& pattern: splitPatterns(aGroupStr)) {
aGroupVec.push_back(matchGroup(*aGdp, pattern));
}
}
// For diagnostic purposes, keep track of whether any input grids are left unused.
bool unusedA = false, unusedB = false;
// Iterate over one or more A groups.
for (const auto* aGroup: aGroupVec) {
hvdb::VdbPrimIterator aIt{aGdp, GA_Range::safedeletions{}, aGroup};
hvdb::VdbPrimCIterator bIt{bGdp, bGroup};
// Populate two vectors of primitives, one comprising the A grids
// and the other the B grids. (In the case of flattening operations,
// these grids might be taken from the same input.)
// Note: the following relies on exhausted iterators returning nullptr
// and on incrementing an exhausted iterator being a no-op.
std::vector<GU_PrimVDB*> aVdbVec;
std::vector<const GU_PrimVDB*> bVdbVec;
switch (collation) {
case COLL_PAIRS:
for ( ; (!needA || aIt) && (!needB || bIt); ++aIt, ++bIt) {
aVdbVec.push_back(*aIt);
bVdbVec.push_back(*bIt);
}
unusedA = unusedA || (needA && bool(aIt));
unusedB = unusedB || (needB && bool(bIt));
break;
case COLL_A_WITH_1ST_B:
for ( ; aIt && (!needB || bIt); ++aIt) {
aVdbVec.push_back(*aIt);
bVdbVec.push_back(*bIt);
}
break;
case COLL_FLATTEN_B_TO_A:
if (*bIt) {
aVdbVec.push_back(*aIt);
bVdbVec.push_back(*bIt);
}
for (++bIt; bIt; ++bIt) {
aVdbVec.push_back(nullptr);
bVdbVec.push_back(*bIt);
}
break;
case COLL_FLATTEN_A:
case COLL_FLATTEN_A_GROUPS:
aVdbVec.push_back(*aIt);
for (++aIt; aIt; ++aIt) { bVdbVec.push_back(*aIt); }
break;
}
if ((needA && aVdbVec.empty()) || (needB && bVdbVec.empty())) continue;
std::set<GU_PrimVDB*> vdbsToRemove;
// Combine grids.
if (!flatten) {
// Iterate over A and, optionally, B grids.
for (size_t i = 0, N = std::min(aVdbVec.size(), bVdbVec.size()); i < N; ++i) {
if (progress.wasInterrupted()) { throw std::runtime_error{"interrupted"}; }
// Note: even if needA is false, we still need to delete A grids.
GU_PrimVDB* aVdb = aVdbVec[i];
const GU_PrimVDB* bVdb = bVdbVec[i];
hvdb::GridPtr aGrid;
hvdb::GridCPtr bGrid;
if (aVdb) aGrid = aVdb->getGridPtr();
if (bVdb) bGrid = bVdb->getConstGridPtr();
// For error reporting, get the names of the A and B grids.
const UT_String
aGridName = getGridName(aVdb, /*default=*/"A"),
bGridName = getGridName(bVdb, /*default=*/"B");
if (hvdb::GridPtr outGrid =
combineGrids(op, aGrid, bGrid, aGridName, bGridName, resample))
{
// Name the output grid after the A grid if the A grid is used,
// or after the B grid otherwise.
UT_String outGridName = needA ? getGridName(aVdb) : getGridName(bVdb);
// Add a new VDB primitive for the output grid to the output gdp.
GU_PrimVDB::buildFromGrid(*gdp, outGrid,
/*copyAttrsFrom=*/needA ? aVdb : bVdb, outGridName);
vdbsToRemove.insert(aVdb);
}
}
// Flatten grids (i.e., combine all B grids into the first A grid).
} else {
GU_PrimVDB* aVdb = aVdbVec[0];
hvdb::GridPtr aGrid;
if (aVdb) aGrid = aVdb->getGridPtr();
hvdb::GridPtr outGrid;
UT_String outGridName;
// Iterate over B grids.
const GU_PrimVDB* bVdb = nullptr;
for (const GU_PrimVDB* theBVdb: bVdbVec) {
if (progress.wasInterrupted()) { throw std::runtime_error{"interrupted"}; }
bVdb = theBVdb;
hvdb::GridCPtr bGrid;
if (bVdb) {
bGrid = bVdb->getConstGridPtr();
if (flattenA) {
// When flattening within the A group, remove B grids,
// since they're actually copies of grids from input 0.
vdbsToRemove.insert(const_cast<GU_PrimVDB*>(bVdb));
}
}
const UT_String
aGridName = getGridName(aVdb, /*default=*/"A"),
bGridName = getGridName(bVdb, /*default=*/"B");
// Name the output grid after the A grid if the A grid is used,
// or after the B grid otherwise.
outGridName = (needA ? getGridName(aVdb) : getGridName(bVdb));
outGrid = combineGrids(op, aGrid, bGrid, aGridName, bGridName, resample);
aGrid = outGrid;
}
if (outGrid) {
// Add a new VDB primitive for the output grid to the output gdp.
GU_PrimVDB::buildFromGrid(*gdp, outGrid,
/*copyAttrsFrom=*/needA ? aVdb : bVdb, outGridName);
vdbsToRemove.insert(aVdb);
}
}
// Remove primitives that were copied from input 0.
for (GU_PrimVDB* vdb: vdbsToRemove) {
if (vdb)
gdp->destroyPrimitive(*vdb, /*andPoints=*/true);
}
} // for each A group
if (unusedA || unusedB) {
std::ostringstream ostr;
ostr << "some grids were not processed because there were more "
<< (unusedA ? "A" : "B") << " grids than "
<< (unusedA ? "B" : "A") << " grids";
addWarning(SOP_MESSAGE, ostr.str().c_str());
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
////////////////////////////////////////
namespace {
/// Functor to compute scale * grid + offset, for scalars scale and offset
template<typename GridT>
struct MulAdd
{
using ValueT = typename GridT::ValueType;
using GridPtrT = typename GridT::Ptr;
float scale, offset;
explicit MulAdd(float s, float t = 0.0): scale(s), offset(t) {}
void operator()(const ValueT& a, const ValueT&, ValueT& out) const
{
OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
out = ValueT(a * scale + offset);
OPENVDB_NO_TYPE_CONVERSION_WARNING_END
}
/// @return true if the scale is 1 and the offset is 0
bool isIdentity() const
{
return (openvdb::math::isApproxEqual(scale, 1.f, 1.0e-6f)
&& openvdb::math::isApproxEqual(offset, 0.f, 1.0e-6f));
}
/// Compute dest = src * scale + offset
void process(const GridT& src, GridPtrT& dest) const
{
if (isIdentity()) {
dest = src.deepCopy();
} else {
if (!dest) dest = GridT::create(src); // same transform, new tree
ValueT bg;
(*this)(src.background(), ValueT(), bg);
openvdb::tools::changeBackground(dest->tree(), bg);
dest->tree().combine2(src.tree(), src.tree(), *this, /*prune=*/false);
}
}
};
////////////////////////////////////////
/// Functor to compute (1 - A) * B for grids A and B
template<typename ValueT>
struct Blend1
{
float aMult, bMult;
const ValueT ONE;
explicit Blend1(float a = 1.0, float b = 1.0):
aMult(a), bMult(b), ONE(openvdb::zeroVal<ValueT>() + 1) {}
void operator()(const ValueT& a, const ValueT& b, ValueT& out) const
{
OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
out = ValueT((ONE - aMult * a) * bMult * b);
OPENVDB_NO_TYPE_CONVERSION_WARNING_END
}
};
////////////////////////////////////////
/// Functor to compute A + (1 - A) * B for grids A and B
template<typename ValueT>
struct Blend2
{
float aMult, bMult;
const ValueT ONE;
explicit Blend2(float a = 1.0, float b = 1.0):
aMult(a), bMult(b), ONE(openvdb::zeroVal<ValueT>() + 1) {}
void operator()(const ValueT& a, const ValueT& b, ValueT& out) const
{
OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
out = ValueT(a*aMult); out = out + ValueT((ONE - out) * bMult*b);
OPENVDB_NO_TYPE_CONVERSION_WARNING_END
}
};
////////////////////////////////////////
// Helper class to compare both scalar and vector values
template<typename ValueT>
struct ApproxEq
{
const ValueT &a, &b;
ApproxEq(const ValueT& _a, const ValueT& _b): a(_a), b(_b) {}
operator bool() const {
return openvdb::math::isRelOrApproxEqual(
a, b, /*rel*/ValueT(1e-6f), /*abs*/ValueT(1e-8f));
}
};
// Specialization for Vec2
template<typename T>
struct ApproxEq<openvdb::math::Vec2<T> >
{
using VecT = openvdb::math::Vec2<T>;
using ValueT = typename VecT::value_type;
const VecT &a, &b;
ApproxEq(const VecT& _a, const VecT& _b): a(_a), b(_b) {}
operator bool() const { return a.eq(b, /*abs=*/ValueT(1e-8f)); }
};
// Specialization for Vec3
template<typename T>
struct ApproxEq<openvdb::math::Vec3<T> >
{
using VecT = openvdb::math::Vec3<T>;
using ValueT = typename VecT::value_type;
const VecT &a, &b;
ApproxEq(const VecT& _a, const VecT& _b): a(_a), b(_b) {}
operator bool() const { return a.eq(b, /*abs=*/ValueT(1e-8f)); }
};
// Specialization for Vec4
template<typename T>
struct ApproxEq<openvdb::math::Vec4<T> >
{
using VecT = openvdb::math::Vec4<T>;
using ValueT = typename VecT::value_type;
const VecT &a, &b;
ApproxEq(const VecT& _a, const VecT& _b): a(_a), b(_b) {}
operator bool() const { return a.eq(b, /*abs=*/ValueT(1e-8f)); }
};
} // unnamed namespace
////////////////////////////////////////
template<typename AGridT>
struct SOP_OpenVDB_Combine::DispatchOp
{
SOP_OpenVDB_Combine::CombineOp* combineOp;
DispatchOp(SOP_OpenVDB_Combine::CombineOp& op): combineOp(&op) {}
template<typename BGridT> void operator()(const BGridT&);
}; // struct DispatchOp
// Helper class for use with GridBase::apply()
struct SOP_OpenVDB_Combine::CombineOp
{
SOP_OpenVDB_Combine::Cache* self;
Operation op;
ResampleMode resample;
UT_String aGridName, bGridName;
hvdb::GridCPtr aBaseGrid, bBaseGrid;
hvdb::GridPtr outGrid;
hvdb::Interrupter interrupt;
CombineOp(): self(nullptr) {}
// Functor for use with GridBase::apply() to return
// a scalar grid's background value as a floating-point quantity
struct BackgroundOp {
double value;
BackgroundOp(): value(0.0) {}
template<typename GridT> void operator()(const GridT& grid) {
value = static_cast<double>(grid.background());
}
};
static double getScalarBackgroundValue(const hvdb::Grid& baseGrid)
{
BackgroundOp bgOp;
baseGrid.apply<hvdb::NumericGridTypes>(bgOp);
return bgOp.value;
}
template<typename GridT>
typename GridT::Ptr resampleToMatch(const GridT& src, const hvdb::Grid& ref, int order)
{
using ValueT = typename GridT::ValueType;
const ValueT ZERO = openvdb::zeroVal<ValueT>();
const openvdb::math::Transform& refXform = ref.constTransform();
typename GridT::Ptr dest;
if (src.getGridClass() == openvdb::GRID_LEVEL_SET) {
// For level set grids, use the level set rebuild tool to both resample the
// source grid to match the reference grid and to rebuild the resulting level set.
const bool refIsLevelSet = ref.getGridClass() == openvdb::GRID_LEVEL_SET;
OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
const ValueT halfWidth = refIsLevelSet
? ValueT(ZERO + this->getScalarBackgroundValue(ref) * (1.0 / ref.voxelSize()[0]))
: ValueT(src.background() * (1.0 / src.voxelSize()[0]));
OPENVDB_NO_TYPE_CONVERSION_WARNING_END
if (!openvdb::math::isFinite(halfWidth)) {
std::stringstream msg;
msg << "Resample to match: Illegal narrow band width = " << halfWidth
<< ", caused by grid '" << src.getName() << "' with background "
<< this->getScalarBackgroundValue(ref);
throw std::invalid_argument(msg.str());
}
try {
dest = openvdb::tools::doLevelSetRebuild(src, /*iso=*/ZERO,
/*exWidth=*/halfWidth, /*inWidth=*/halfWidth, &refXform, &interrupt);
} catch (openvdb::TypeError&) {
self->addWarning(SOP_MESSAGE, ("skipped rebuild of level set grid "
+ src.getName() + " of type " + src.type()).c_str());
dest.reset();
}
}
if (!dest && src.constTransform() != refXform) {
// For non-level set grids or if level set rebuild failed due to an unsupported
// grid type, use the grid transformer tool to resample the source grid to match
// the reference grid.
dest = src.copyWithNewTree();
dest->setTransform(refXform.copy());
using namespace openvdb;
switch (order) {
case 0: tools::resampleToMatch<tools::PointSampler>(src, *dest, interrupt); break;
case 1: tools::resampleToMatch<tools::BoxSampler>(src, *dest, interrupt); break;
case 2: tools::resampleToMatch<tools::QuadraticSampler>(src, *dest, interrupt); break;
}
}
return dest;
}
// If necessary, resample one grid so that its index space registers
// with the other grid's.
// Note that one of the grid pointers might change as a result.
template<typename AGridT, typename BGridT>
void resampleGrids(const AGridT*& aGrid, const BGridT*& bGrid)
{
if (!aGrid || !bGrid) return;
const bool
needA = needAGrid(op),
needB = needBGrid(op),
needBoth = needA && needB;
const int samplingOrder = static_cast<int>(
self->evalInt("resampleinterp", 0, self->getTime()));
// One of RESAMPLE_A, RESAMPLE_B or RESAMPLE_OFF, specifying whether
// grid A, grid B or neither grid was resampled
int resampleWhich = RESAMPLE_OFF;
// Determine which of the two grids should be resampled.
if (resample == RESAMPLE_HI_RES || resample == RESAMPLE_LO_RES) {
const openvdb::Vec3d
aVoxSize = aGrid->voxelSize(),
bVoxSize = bGrid->voxelSize();
const double
aVoxVol = aVoxSize[0] * aVoxSize[1] * aVoxSize[2],
bVoxVol = bVoxSize[0] * bVoxSize[1] * bVoxSize[2];
resampleWhich = ((aVoxVol > bVoxVol && resample == RESAMPLE_LO_RES)
|| (aVoxVol < bVoxVol && resample == RESAMPLE_HI_RES))
? RESAMPLE_A : RESAMPLE_B;
} else {
resampleWhich = resample;
}
if (aGrid->constTransform() != bGrid->constTransform()) {
// If the A and B grid transforms don't match, one of the grids
// should be resampled into the other's index space.
if (resample == RESAMPLE_OFF) {
if (needBoth) {
// Resampling is disabled. Just log a warning.
std::ostringstream ostr;
ostr << aGridName << " and " << bGridName << " transforms don't match";
self->addWarning(SOP_MESSAGE, ostr.str().c_str());
}
} else {
if (needA && resampleWhich == RESAMPLE_A) {
// Resample grid A into grid B's index space.
aBaseGrid = this->resampleToMatch(*aGrid, *bGrid, samplingOrder);
aGrid = static_cast<const AGridT*>(aBaseGrid.get());
} else if (needB && resampleWhich == RESAMPLE_B) {
// Resample grid B into grid A's index space.
bBaseGrid = this->resampleToMatch(*bGrid, *aGrid, samplingOrder);
bGrid = static_cast<const BGridT*>(bBaseGrid.get());
}
}
}
if (aGrid->getGridClass() == openvdb::GRID_LEVEL_SET &&
bGrid->getGridClass() == openvdb::GRID_LEVEL_SET)
{
// If both grids are level sets, ensure that their background values match.
// (If one of the grids was resampled, then the background values should
// already match.)
const double
a = this->getScalarBackgroundValue(*aGrid),
b = this->getScalarBackgroundValue(*bGrid);
if (!ApproxEq<double>(a, b)) {
if (resample == RESAMPLE_OFF) {
if (needBoth) {
// Resampling/rebuilding is disabled. Just log a warning.
std::ostringstream ostr;
ostr << aGridName << " and " << bGridName
<< " background values don't match ("
<< std::setprecision(3) << a << " vs. " << b << ");\n"
<< " the output grid will not be a valid level set";
self->addWarning(SOP_MESSAGE, ostr.str().c_str());
}
} else {
// One of the two grids needs a level set rebuild.
if (needA && resampleWhich == RESAMPLE_A) {
// Rebuild A to match B's background value.
aBaseGrid = this->resampleToMatch(*aGrid, *bGrid, samplingOrder);
aGrid = static_cast<const AGridT*>(aBaseGrid.get());
} else if (needB && resampleWhich == RESAMPLE_B) {
// Rebuild B to match A's background value.
bBaseGrid = this->resampleToMatch(*bGrid, *aGrid, samplingOrder);
bGrid = static_cast<const BGridT*>(bBaseGrid.get());
}
}
}
}
}
void checkVectorTypes(const hvdb::Grid* aGrid, const hvdb::Grid* bGrid)
{
if (!aGrid || !bGrid || !needAGrid(op) || !needBGrid(op)) return;
switch (op) {
case OP_TOPO_UNION:
case OP_TOPO_INTERSECTION:
case OP_TOPO_DIFFERENCE:
// No need to warn about different vector types for topology-only operations.
break;
default:
{
const openvdb::VecType
aVecType = aGrid->getVectorType(),
bVecType = bGrid->getVectorType();
if (aVecType != bVecType) {
std::ostringstream ostr;
ostr << aGridName << " and " << bGridName
<< " have different vector types\n"
<< " (" << hvdb::Grid::vecTypeToString(aVecType)
<< " vs. " << hvdb::Grid::vecTypeToString(bVecType) << ")";
self->addWarning(SOP_MESSAGE, ostr.str().c_str());
}
break;
}
}
}
template <typename GridT>
void doUnion(GridT &result, GridT &temp)
{
openvdb::tools::csgUnion(result, temp);
}
template <typename GridT>
void doIntersection(GridT &result, GridT &temp)
{
openvdb::tools::csgIntersection(result, temp);
}
template <typename GridT>
void doDifference(GridT &result, GridT &temp)
{
openvdb::tools::csgDifference(result, temp);
}
// Combine two grids of the same type.
template<typename GridT>
void combineSameType()
{
using ValueT = typename GridT::ValueType;
const bool
needA = needAGrid(op),
needB = needBGrid(op);
const float
aMult = float(self->evalFloat("amult", 0, self->getTime())),
bMult = float(self->evalFloat("bmult", 0, self->getTime()));
const GridT *aGrid = nullptr, *bGrid = nullptr;
if (aBaseGrid) aGrid = UTvdbGridCast<GridT>(aBaseGrid).get();
if (bBaseGrid) bGrid = UTvdbGridCast<GridT>(bBaseGrid).get();
if (needA && !aGrid) throw std::runtime_error("missing A grid");
if (needB && !bGrid) throw std::runtime_error("missing B grid");
// Warn if combining vector grids with different vector types.
if (needA && needB && openvdb::VecTraits<ValueT>::IsVec) {
this->checkVectorTypes(aGrid, bGrid);
}
// If necessary, resample one grid so that its index space
// registers with the other grid's.
if (aGrid && bGrid) this->resampleGrids(aGrid, bGrid);
const ValueT ZERO = openvdb::zeroVal<ValueT>();
// A temporary grid is needed for binary operations, because they
// cannibalize the B grid.
typename GridT::Ptr resultGrid, tempGrid;
switch (op) {
case OP_COPY_A:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
break;
case OP_COPY_B:
MulAdd<GridT>(bMult).process(*bGrid, resultGrid);
break;
case OP_INVERT:
MulAdd<GridT>(-aMult, 1.0).process(*aGrid, resultGrid);
break;
case OP_ADD:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(bMult).process(*bGrid, tempGrid);
openvdb::tools::compSum(*resultGrid, *tempGrid);
break;
case OP_SUBTRACT:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(-bMult).process(*bGrid, tempGrid);
openvdb::tools::compSum(*resultGrid, *tempGrid);
break;
case OP_MULTIPLY:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(bMult).process(*bGrid, tempGrid);
openvdb::tools::compMul(*resultGrid, *tempGrid);
break;
case OP_DIVIDE:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(bMult).process(*bGrid, tempGrid);
openvdb::tools::compDiv(*resultGrid, *tempGrid);
break;
case OP_MAXIMUM:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(bMult).process(*bGrid, tempGrid);
openvdb::tools::compMax(*resultGrid, *tempGrid);
break;
case OP_MINIMUM:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(bMult).process(*bGrid, tempGrid);
openvdb::tools::compMin(*resultGrid, *tempGrid);
break;
case OP_BLEND1: // (1 - A) * B
{
const Blend1<ValueT> comp(aMult, bMult);
ValueT bg;
comp(aGrid->background(), ZERO, bg);
resultGrid = aGrid->copyWithNewTree();
openvdb::tools::changeBackground(resultGrid->tree(), bg);
resultGrid->tree().combine2(aGrid->tree(), bGrid->tree(), comp, /*prune=*/false);
break;
}
case OP_BLEND2: // A + (1 - A) * B
{
const Blend2<ValueT> comp(aMult, bMult);
ValueT bg;
comp(aGrid->background(), ZERO, bg);
resultGrid = aGrid->copyWithNewTree();
openvdb::tools::changeBackground(resultGrid->tree(), bg);
resultGrid->tree().combine2(aGrid->tree(), bGrid->tree(), comp, /*prune=*/false);
break;
}
case OP_UNION:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(bMult).process(*bGrid, tempGrid);
doUnion(*resultGrid, *tempGrid);
break;
case OP_INTERSECTION:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(bMult).process(*bGrid, tempGrid);
doIntersection(*resultGrid, *tempGrid);
break;
case OP_DIFFERENCE:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(bMult).process(*bGrid, tempGrid);
doDifference(*resultGrid, *tempGrid);
break;
case OP_REPLACE:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
MulAdd<GridT>(bMult).process(*bGrid, tempGrid);
openvdb::tools::compReplace(*resultGrid, *tempGrid);
break;
case OP_TOPO_UNION:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
// Note: no need to scale the B grid for topology-only operations.
resultGrid->topologyUnion(*bGrid);
break;
case OP_TOPO_INTERSECTION:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
resultGrid->topologyIntersection(*bGrid);
break;
case OP_TOPO_DIFFERENCE:
MulAdd<GridT>(aMult).process(*aGrid, resultGrid);
resultGrid->topologyDifference(*bGrid);
break;
}
outGrid = this->postprocess<GridT>(resultGrid);
}
// Combine two grids of different types.
/// @todo Currently, only topology operations can be performed on grids of different types.
template<typename AGridT, typename BGridT>
void combineDifferentTypes()
{
const bool
needA = needAGrid(op),
needB = needBGrid(op);
const AGridT* aGrid = nullptr;
const BGridT* bGrid = nullptr;
if (aBaseGrid) aGrid = UTvdbGridCast<AGridT>(aBaseGrid).get();
if (bBaseGrid) bGrid = UTvdbGridCast<BGridT>(bBaseGrid).get();
if (needA && !aGrid) throw std::runtime_error("missing A grid");
if (needB && !bGrid) throw std::runtime_error("missing B grid");
// Warn if combining vector grids with different vector types.
if (needA && needB && openvdb::VecTraits<typename AGridT::ValueType>::IsVec
&& openvdb::VecTraits<typename BGridT::ValueType>::IsVec)
{
this->checkVectorTypes(aGrid, bGrid);
}
// If necessary, resample one grid so that its index space
// registers with the other grid's.
if (aGrid && bGrid) this->resampleGrids(aGrid, bGrid);
const float aMult = float(self->evalFloat("amult", 0, self->getTime()));
typename AGridT::Ptr resultGrid;
switch (op) {
case OP_TOPO_UNION:
MulAdd<AGridT>(aMult).process(*aGrid, resultGrid);
// Note: no need to scale the B grid for topology-only operations.
resultGrid->topologyUnion(*bGrid);
break;
case OP_TOPO_INTERSECTION:
MulAdd<AGridT>(aMult).process(*aGrid, resultGrid);
resultGrid->topologyIntersection(*bGrid);
break;
case OP_TOPO_DIFFERENCE:
MulAdd<AGridT>(aMult).process(*aGrid, resultGrid);
resultGrid->topologyDifference(*bGrid);
break;
default:
{
std::ostringstream ostr;
ostr << "can't combine grid " << aGridName << " of type " << aGrid->type()
<< "\n with grid " << bGridName
<< " of type " << bGrid->type();
throw std::runtime_error(ostr.str());
break;
}
}
outGrid = this->postprocess<AGridT>(resultGrid);
}
template<typename GridT>
typename GridT::Ptr postprocess(typename GridT::Ptr resultGrid)
{
using ValueT = typename GridT::ValueType;
const ValueT ZERO = openvdb::zeroVal<ValueT>();
const bool
prune = self->evalInt("prune", 0, self->getTime()),
flood = self->evalInt("flood", 0, self->getTime()),
deactivate = self->evalInt("deactivate", 0, self->getTime());
if (deactivate) {
const float deactivationTolerance =
float(self->evalFloat("bgtolerance", 0, self->getTime()));
OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
const ValueT tolerance(ZERO + deactivationTolerance);
OPENVDB_NO_TYPE_CONVERSION_WARNING_END
// Mark active output tiles and voxels as inactive if their
// values match the output grid's background value.
// Do this first to facilitate pruning.
openvdb::tools::deactivate(*resultGrid, resultGrid->background(), tolerance);
}
if (flood && resultGrid->getGridClass() == openvdb::GRID_LEVEL_SET) {
openvdb::tools::signedFloodFill(resultGrid->tree());
}
if (prune) {
const float pruneTolerance = float(self->evalFloat("tolerance", 0, self->getTime()));
OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
const ValueT tolerance(ZERO + pruneTolerance);
OPENVDB_NO_TYPE_CONVERSION_WARNING_END
openvdb::tools::prune(resultGrid->tree(), tolerance);
}
return resultGrid;
}
template<typename AGridT>
void operator()(const AGridT&)
{
const bool
needA = needAGrid(op),
needB = needBGrid(op),
needBoth = needA && needB;
if (!needBoth || !aBaseGrid || !bBaseGrid || aBaseGrid->type() == bBaseGrid->type()) {
this->combineSameType<AGridT>();
} else {
DispatchOp<AGridT> dispatcher(*this);
// Dispatch on the B grid's type.
int success = bBaseGrid->apply<hvdb::VolumeGridTypes>(dispatcher);
if (!success) {
std::ostringstream ostr;
ostr << "grid " << bGridName << " has unsupported type " << bBaseGrid->type();
self->addWarning(SOP_MESSAGE, ostr.str().c_str());
}
}
}
}; // struct CombineOp
template <>
void SOP_OpenVDB_Combine::CombineOp::doUnion(openvdb::BoolGrid &result, openvdb::BoolGrid &temp)
{
}
template <>
void SOP_OpenVDB_Combine::CombineOp::doIntersection(openvdb::BoolGrid &result, openvdb::BoolGrid &temp)
{
}
template <>
void SOP_OpenVDB_Combine::CombineOp::doDifference(openvdb::BoolGrid &result, openvdb::BoolGrid &temp)
{
}
template<typename AGridT>
template<typename BGridT>
void
SOP_OpenVDB_Combine::DispatchOp<AGridT>::operator()(const BGridT&)
{
combineOp->combineDifferentTypes<AGridT, BGridT>();
}
////////////////////////////////////////
hvdb::GridPtr
SOP_OpenVDB_Combine::Cache::combineGrids(
Operation op,
hvdb::GridCPtr aGrid,
hvdb::GridCPtr bGrid,
const UT_String& aGridName,
const UT_String& bGridName,
ResampleMode resample)
{
hvdb::GridPtr outGrid;
const bool
needA = needAGrid(op),
needB = needBGrid(op),
needLS = needLevelSets(op);
if (!needA && !needB) throw std::runtime_error("nothing to do");
if (needA && !aGrid) throw std::runtime_error("missing A grid");
if (needB && !bGrid) throw std::runtime_error("missing B grid");
if (needLS &&
((aGrid && aGrid->getGridClass() != openvdb::GRID_LEVEL_SET) ||
(bGrid && bGrid->getGridClass() != openvdb::GRID_LEVEL_SET)))
{
std::ostringstream ostr;
ostr << "expected level set grids for the " << sOpMenuItems[op*2+1]
<< " operation,\n found "
<< hvdb::Grid::gridClassToString(aGrid->getGridClass()) << " (" << aGridName << ") and "
<< hvdb::Grid::gridClassToString(bGrid->getGridClass()) << " (" << bGridName
<< ");\n the output grid will not be a valid level set";
addWarning(SOP_MESSAGE, ostr.str().c_str());
}
if (needA && needB && aGrid->type() != bGrid->type()
&& op != OP_TOPO_UNION && op != OP_TOPO_INTERSECTION && op != OP_TOPO_DIFFERENCE)
{
std::ostringstream ostr;
ostr << "can't combine grid " << aGridName << " of type " << aGrid->type()
<< "\n with grid " << bGridName << " of type " << bGrid->type();
addWarning(SOP_MESSAGE, ostr.str().c_str());
return outGrid;
}
CombineOp compOp;
compOp.self = this;
compOp.op = op;
compOp.resample = resample;
compOp.aBaseGrid = aGrid;
compOp.bBaseGrid = bGrid;
compOp.aGridName = aGridName;
compOp.bGridName = bGridName;
compOp.interrupt = hvdb::Interrupter();
int success = false;
if (needA || UTvdbGetGridType(*aGrid) == UTvdbGetGridType(*bGrid)) {
success = aGrid->apply<hvdb::VolumeGridTypes>(compOp);
}
if (!success || !compOp.outGrid) {
std::ostringstream ostr;
if (aGrid->type() == bGrid->type()) {
ostr << "grids " << aGridName << " and " << bGridName
<< " have unsupported type " << aGrid->type();
} else {
ostr << "grid " << (needA ? aGridName : bGridName)
<< " has unsupported type " << (needA ? aGrid->type() : bGrid->type());
}
addWarning(SOP_MESSAGE, ostr.str().c_str());
}
return compOp.outGrid;
}
| 57,222 | C++ | 36.085548 | 103 | 0.566758 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Remove_Divergence.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Remove_Divergence.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/math/ConjGradient.h> // for JacobiPreconditioner
#include <openvdb/tools/GridOperators.h>
#include <openvdb/tools/LevelSetUtil.h> // for tools::sdfInteriorMask()
#include <openvdb/tools/PoissonSolver.h>
#include <openvdb/tools/Prune.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_StringArray.h>
#include <GU/GU_Detail.h>
#include <PRM/PRM_Parm.h>
#include <GA/GA_Handle.h>
#include <GA/GA_PageIterator.h>
#include <tbb/blocked_range.h>
#include <tbb/parallel_for.h>
#include <sstream>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace {
using ColliderMaskGrid = openvdb::BoolGrid; ///< @todo really should derive from velocity grid
using ColliderBBox = openvdb::BBoxd;
using Coord = openvdb::Coord;
enum ColliderType { CT_NONE, CT_BBOX, CT_STATIC, CT_DYNAMIC };
const int DEFAULT_MAX_ITERATIONS = 10000;
const double DEFAULT_MAX_ERROR = 1.0e-20;
}
////////////////////////////////////////
struct SOP_OpenVDB_Remove_Divergence: public hvdb::SOP_NodeVDB
{
SOP_OpenVDB_Remove_Divergence(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned input) const override { return (input > 0); }
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
};
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Names of vector-valued VDBs to be processed")
.setDocumentation(
"A subset of vector-valued input VDBs to be processed"
" (see [specifying volumes|/model/volumes#group])\n\n"
"VDBs with nonuniform voxels, including frustum grids, are not supported.\n"
"They should be [resampled|Node:sop/DW_OpenVDBResample]"
" to have a linear transform with uniform scale."));
{
std::ostringstream ostr;
ostr << "If disabled, limit the pressure solver to "
<< DEFAULT_MAX_ITERATIONS << " iterations.";
const std::string tooltip = ostr.str();
parms.add(hutil::ParmFactory(PRM_TOGGLE, "useiterations", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip(tooltip.c_str()));
parms.add(hutil::ParmFactory(PRM_INT_J, "iterations", "Iterations")
.setDefault(1000)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 2000)
.setTooltip("Maximum number of iterations of the pressure solver")
.setDocumentation(
("Maximum number of iterations of the pressure solver\n\n" + tooltip).c_str()));
}
{
std::ostringstream ostr;
ostr << "If disabled, limit the pressure solver error to "
<< std::setprecision(3) << DEFAULT_MAX_ERROR << ".";
const std::string tooltip = ostr.str();
parms.add(hutil::ParmFactory(PRM_TOGGLE, "usetolerance", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip(tooltip.c_str()));
ostr.str("");
ostr << "If disabled, limit the pressure solver error to 10<sup>"
<< int(std::log10(DEFAULT_MAX_ERROR)) << "</sup>.";
parms.add(hutil::ParmFactory(PRM_FLT_J, "tolerance", "Tolerance")
.setDefault(openvdb::math::Delta<float>::value())
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 0.01)
.setTooltip(
"The pressure solver is deemed to have converged when\n"
"the magnitude of the error is less than this tolerance.")
.setDocumentation(
("The pressure solver is deemed to have converged when"
" the magnitude of the error is less than this tolerance.\n\n"
+ ostr.str()).c_str()));
}
parms.add(hutil::ParmFactory(PRM_TOGGLE, "usecollider", "")
.setDefault(PRMzeroDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_STRING, "collidertype", "Collider Type")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"bbox", "Bounding Box",
"static", "Static VDB",
"dynamic", "Dynamic VDB"
})
.setDefault("bbox")
.setTooltip(
"Bounding Box:\n"
" Use the bounding box of any reference geometry as the collider.\n"
"Static VDB:\n"
" Treat the active voxels of the named VDB volume as solid, stationary obstacles."
"\nDynamic VDB:\n"
" If the named VDB volume is vector-valued, treat the values of active voxels\n"
" as velocities of moving obstacles; otherwise, treat the active voxels as\n"
" stationary obstacles."
));
parms.add(hutil::ParmFactory(PRM_STRING, "collider", "Collider")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip(
"Name of the reference VDB volume whose active voxels denote solid obstacles\n\n"
"If multiple volumes are selected, only the first one will be used."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "invertcollider", "Invert Collider")
.setDefault(PRMzeroDefaults)
.setTooltip(
"Invert the collider so that active voxels denote empty space\n"
"and inactive voxels denote solid obstacles."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "pressure", "Output Pressure")
.setDefault(PRMzeroDefaults)
.setTooltip(
"Output the computed pressure for each input VDB \"v\"\n"
"as a scalar VDB named \"v_pressure\"."));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Project Non-Divergent",
SOP_OpenVDB_Remove_Divergence::factory, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBRemoveDivergence")
#endif
.addInput("Velocity field VDBs")
.addOptionalInput("Optional collider VDB or geometry")
.setVerb(SOP_NodeVerb::COOK_INPLACE,
[]() { return new SOP_OpenVDB_Remove_Divergence::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Remove divergence from VDB velocity fields.\"\"\"\n\
\n\
@overview\n\
\n\
A vector-valued VDB volume can represent a velocity field.\n\
When particles flow through the field, they might either expand\n\
from a voxel or collapse into a voxel.\n\
These source/sink behaviors indicate divergence in the field.\n\
\n\
This node computes a new vector field that is close to the input\n\
but has no divergence.\n\
This can be used to condition velocity fields to limit particle creation,\n\
creating more realistic flows.\n\
\n\
If the optional collider volume is provided, the output velocity field\n\
will direct flow around obstacles (i.e., active voxels) in that volume.\n\
The collider itself may be a velocity field, in which case the obstacles\n\
are considered to be moving with the given velocities.\n\
\n\
Combined with the [OpenVDB Advect Points|Node:sop/DW_OpenVDBAdvectPoints]\n\
node and a [Solver|Node:sop/solver] node for feedback, this node\n\
can be used to build a simple FLIP solver.\n\
\n\
@related\n\
- [OpenVDB Advect Points|Node:sop/DW_OpenVDBAdvectPoints]\n\
- [Node:sop/solver]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
bool
SOP_OpenVDB_Remove_Divergence::updateParmsFlags()
{
bool changed = false;
const bool useCollider = evalInt("usecollider", 0, 0);
changed |= enableParm("collidertype", useCollider);
changed |= enableParm("invertcollider", useCollider);
changed |= enableParm("collider", useCollider && (evalStdString("collidertype", 0) != "bbox"));
changed |= enableParm("iterations", bool(evalInt("useiterations", 0, 0)));
changed |= enableParm("tolerance", bool(evalInt("usetolerance", 0, 0)));
return changed;
}
OP_Node*
SOP_OpenVDB_Remove_Divergence::factory(OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Remove_Divergence(net, name, op);
}
SOP_OpenVDB_Remove_Divergence::SOP_OpenVDB_Remove_Divergence(
OP_Network* net, const char* name, OP_Operator* op)
: hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
namespace {
struct SolverParms {
SolverParms()
: invertCollider(false)
, colliderType(CT_NONE)
, iterations(1)
, absoluteError(-1.0)
, outputState(openvdb::math::pcg::terminationDefaults<double>())
, interrupter(nullptr)
{}
hvdb::GridPtr velocityGrid;
hvdb::GridCPtr colliderGrid;
hvdb::GridPtr pressureGrid;
hvdb::GridCPtr domainMaskGrid;
ColliderBBox colliderBBox;
bool invertCollider;
ColliderType colliderType;
int iterations;
double absoluteError;
openvdb::math::pcg::State outputState;
hvdb::Interrupter* interrupter;
};
////////////////////////////////////////
/// @brief Functor to extract an interior mask from a level set grid
/// of arbitrary floating-point type
struct LevelSetMaskOp
{
template<typename GridType>
void operator()(const GridType& grid) { outputGrid = openvdb::tools::sdfInteriorMask(grid); }
hvdb::GridPtr outputGrid;
};
/// @brief Functor to extract a topology mask from a grid of arbitrary type
struct ColliderMaskOp
{
template<typename GridType>
void operator()(const GridType& grid)
{
if (mask) {
mask->topologyUnion(grid);
mask->setTransform(grid.transform().copy());
}
}
ColliderMaskGrid::Ptr mask;
};
////////////////////////////////////////
/// @brief Generic grid accessor
/// @details This just wraps a const accessor to a collider grid, but
/// it changes the behavior of the copy constructor for thread safety.
template<typename GridType>
class GridConstAccessor
{
public:
using ValueType = typename GridType::ValueType;
explicit GridConstAccessor(const SolverParms& parms):
mAcc(static_cast<const GridType&>(*parms.colliderGrid).getConstAccessor())
{}
explicit GridConstAccessor(const GridType& grid): mAcc(grid.getConstAccessor()) {}
// When copying, create a new, empty accessor, to avoid a data race
// with the existing accessor, which might be updating on another thread.
GridConstAccessor(const GridConstAccessor& other): mAcc(other.mAcc.tree()) {}
bool isValueOn(const Coord& ijk) const { return mAcc.isValueOn(ijk); }
const ValueType& getValue(const Coord& ijk) const { return mAcc.getValue(ijk); }
bool probeValue(const Coord& ijk, ValueType& val) const { return mAcc.probeValue(ijk, val); }
private:
GridConstAccessor& operator=(const GridConstAccessor&);
typename GridType::ConstAccessor mAcc;
}; // class GridConstAccessor
using ColliderMaskAccessor = GridConstAccessor<ColliderMaskGrid>;
/// @brief Bounding box accessor
class BBoxConstAccessor
{
public:
using ValueType = double;
explicit BBoxConstAccessor(const SolverParms& parms):
mBBox(parms.velocityGrid->transform().worldToIndexNodeCentered(parms.colliderBBox)) {}
BBoxConstAccessor(const BBoxConstAccessor& other): mBBox(other.mBBox) {}
// Voxels outside the bounding box are solid, i.e., active.
bool isValueOn(const Coord& ijk) const { return !mBBox.isInside(ijk); }
ValueType getValue(const Coord&) const { return ValueType(0); }
bool probeValue(const Coord& ijk, ValueType& v) const { v=ValueType(0); return isValueOn(ijk); }
private:
BBoxConstAccessor& operator=(const BBoxConstAccessor&);
const openvdb::CoordBBox mBBox;
}; // class BBoxConstAccessor
////////////////////////////////////////
/// @brief Functor to compute pressure projection in parallel over leaf nodes
template<typename TreeType>
struct PressureProjectionOp
{
using LeafNodeType = typename TreeType::LeafNodeType;
using ValueType = typename TreeType::ValueType;
PressureProjectionOp(SolverParms& parms, LeafNodeType** velNodes,
const LeafNodeType** gradPressureNodes, bool staggered)
: mVelocityNodes(velNodes)
, mGradientOfPressureNodes(gradPressureNodes)
, mVoxelSize(parms.velocityGrid->transform().voxelSize()[0])
, mStaggered(staggered)
{
}
void operator()(const tbb::blocked_range<size_t>& range) const
{
using ElementType = typename ValueType::value_type;
// Account for voxel size here, instead of in the Poisson solve.
const ElementType scale = ElementType((mStaggered ? 1.0 : 4.0) * mVoxelSize * mVoxelSize);
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
LeafNodeType& velocityNode = *mVelocityNodes[n];
ValueType* velocityData = velocityNode.buffer().data();
const ValueType* gradientOfPressureData = mGradientOfPressureNodes[n]->buffer().data();
for (typename LeafNodeType::ValueOnIter it = velocityNode.beginValueOn(); it; ++it) {
const openvdb::Index pos = it.pos();
velocityData[pos] -= scale * gradientOfPressureData[pos];
}
}
}
LeafNodeType* const * const mVelocityNodes;
LeafNodeType const * const * const mGradientOfPressureNodes;
const double mVoxelSize;
const bool mStaggered;
}; // class PressureProjectionOp
////////////////////////////////////////
/// @brief Functor for use with Tree::modifyValue() to set a single element
/// of a vector-valued voxel
template<typename VectorType>
struct SetVecElemOp
{
using ValueType = typename VectorType::ValueType;
SetVecElemOp(int axis_, ValueType value_): axis(axis_), value(value_) {}
void operator()(VectorType& v) const { v[axis] = value; }
const int axis;
const ValueType value;
};
/// @brief Functor to correct the velocities of voxels adjacent to solid obstacles
template<typename VelocityGridType>
class CorrectCollisionVelocityOp
{
public:
using VectorType = typename VelocityGridType::ValueType;
using VectorElementType = typename VectorType::ValueType;
using MaskGridType = typename VelocityGridType::template ValueConverter<bool>::Type;
using MaskTreeType = typename MaskGridType::TreeType;
explicit CorrectCollisionVelocityOp(SolverParms& parms): mParms(&parms)
{
const MaskGridType& domainMaskGrid =
static_cast<const MaskGridType&>(*mParms->domainMaskGrid);
typename MaskTreeType::Ptr interiorMask(
new MaskTreeType(domainMaskGrid.tree(), /*background=*/false, openvdb::TopologyCopy()));
mBorderMask.reset(new MaskTreeType(*interiorMask));
openvdb::tools::erodeVoxels(*interiorMask, /*iterations=*/1, openvdb::tools::NN_FACE);
mBorderMask->topologyDifference(*interiorMask);
}
template<typename ColliderGridType>
void operator()(const ColliderGridType&)
{
GridConstAccessor<ColliderGridType> collider(
static_cast<const ColliderGridType&>(*mParms->colliderGrid));
correctVelocity(collider);
}
template<typename ColliderAccessorType>
void correctVelocity(const ColliderAccessorType& collider)
{
using ColliderValueType = typename ColliderAccessorType::ValueType;
VelocityGridType& velocityGrid = static_cast<VelocityGridType&>(*mParms->velocityGrid);
typename VelocityGridType::Accessor velocity = velocityGrid.getAccessor();
const bool invert = mParms->invertCollider;
switch (mParms->colliderType) {
case CT_NONE:
break;
case CT_BBOX:
case CT_STATIC:
// For each border voxel of the velocity grid...
/// @todo parallelize
for (typename MaskTreeType::ValueOnCIter it = mBorderMask->cbeginValueOn(); it; ++it) {
const Coord ijk = it.getCoord();
// If the neighbor in a certain direction is a stationary obstacle,
// set the border voxel's velocity in that direction to zero.
// x direction
if ((collider.isValueOn(ijk.offsetBy(-1, 0, 0)) != invert)
|| (collider.isValueOn(ijk.offsetBy(1, 0, 0)) != invert))
{
velocity.modifyValue(ijk, SetVecElemOp<VectorType>(0, 0));
}
// y direction
if ((collider.isValueOn(ijk.offsetBy(0, -1, 0)) != invert)
|| (collider.isValueOn(ijk.offsetBy(0, 1, 0)) != invert))
{
velocity.modifyValue(ijk, SetVecElemOp<VectorType>(1, 0));
}
// z direction
if ((collider.isValueOn(ijk.offsetBy(0, 0, -1)) != invert)
|| (collider.isValueOn(ijk.offsetBy(0, 0, 1)) != invert))
{
velocity.modifyValue(ijk, SetVecElemOp<VectorType>(2, 0));
}
}
break;
case CT_DYNAMIC:
// For each border voxel of the velocity grid...
/// @todo parallelize
for (typename MaskTreeType::ValueOnCIter it = mBorderMask->cbeginValueOn(); it; ++it) {
const Coord ijk = it.getCoord();
ColliderValueType colliderVal;
// If the neighbor in a certain direction is a moving obstacle,
// set the border voxel's velocity in that direction to the
// obstacle's velocity in that direction.
for (int axis = 0; axis <= 2; ++axis) { // 0:x, 1:y, 2:z
Coord neighbor = ijk;
neighbor[axis] -= 1;
if (collider.probeValue(neighbor, colliderVal) != invert) {
// Copy or create a Vec3 from the collider value and extract one of
// its components.
// (Since the collider is dynamic, ColliderValueType must be a Vec3 type,
// but this code has to compile for all ColliderGridTypes.)
VectorElementType colliderVelocity = VectorType(colliderVal)[axis];
velocity.modifyValue(ijk,
SetVecElemOp<VectorType>(axis, colliderVelocity));
} else {
neighbor = ijk;
neighbor[axis] += 1;
if (collider.probeValue(neighbor, colliderVal) != invert) {
VectorElementType colliderVelocity = VectorType(colliderVal)[axis];
velocity.modifyValue(ijk,
SetVecElemOp<VectorType>(axis, colliderVelocity));
}
}
}
}
break;
} // switch (mParms->colliderType)
}
private:
SolverParms* mParms;
typename MaskTreeType::Ptr mBorderMask;
}; // class CorrectCollisionVelocityOp
////////////////////////////////////////
//{
// Boundary condition functors
/// @brief Functor specifying boundary conditions for the Poisson solver
/// when exterior voxels may be either solid (and possibly in motion) or empty
template<typename VelocityGridType, typename ColliderAccessorType>
class ColliderBoundaryOp
{
public:
using VectorType = typename VelocityGridType::ValueType;
explicit ColliderBoundaryOp(const SolverParms& parms)
: mVelocity(static_cast<VelocityGridType&>(*parms.velocityGrid).getConstAccessor())
, mCollider(parms)
, mInvert(parms.invertCollider)
, mDynamic(parms.colliderType == CT_DYNAMIC)
, mInvVoxelSize(0.5 / (parms.velocityGrid->voxelSize()[0])) // assumes uniform voxels
{}
ColliderBoundaryOp(const ColliderBoundaryOp& other)
// Give this op new, empty accessors, to avoid data races with
// the other op's accessors, which might be updating on another thread.
: mVelocity(other.mVelocity.tree())
, mCollider(other.mCollider)
, mInvert(other.mInvert)
, mDynamic(other.mDynamic)
, mInvVoxelSize(other.mInvVoxelSize)
{}
void operator()(const Coord& ijk, const Coord& ijkNeighbor, double& rhs, double& diag) const
{
// Voxels outside both the velocity field and the collider
// are considered to be empty (unless the collider is inverted).
// Voxels outside the velocity field and inside the collider
// are considered to be solid.
if (mCollider.isValueOn(ijkNeighbor) == mInvert) {
// The exterior neighbor is empty (i.e., zero), so just adjust the center weight.
diag -= 1;
} else {
const VectorType& velocity = mVelocity.getValue(ijkNeighbor);
double delta = 0.0;
if (mDynamic) { // exterior neighbor is a solid obstacle with nonzero velocity
const openvdb::Vec3d colliderVelocity(mCollider.getValue(ijkNeighbor));
if (ijkNeighbor[0] < ijk[0]) { delta += velocity[0] - colliderVelocity[0]; }
if (ijkNeighbor[0] > ijk[0]) { delta -= (velocity[0] - colliderVelocity[0]); }
if (ijkNeighbor[1] < ijk[1]) { delta += velocity[1] - colliderVelocity[1]; }
if (ijkNeighbor[1] > ijk[1]) { delta -= (velocity[1] - colliderVelocity[1]); }
if (ijkNeighbor[2] < ijk[2]) { delta += velocity[2] - colliderVelocity[2]; }
if (ijkNeighbor[2] > ijk[2]) { delta -= (velocity[2] - colliderVelocity[2]); }
} else { // exterior neighbor is a stationary solid obstacle
if (ijkNeighbor[0] < ijk[0]) { delta += velocity[0]; }
if (ijkNeighbor[0] > ijk[0]) { delta -= velocity[0]; }
if (ijkNeighbor[1] < ijk[1]) { delta += velocity[1]; }
if (ijkNeighbor[1] > ijk[1]) { delta -= velocity[1]; }
if (ijkNeighbor[2] < ijk[2]) { delta += velocity[2]; }
if (ijkNeighbor[2] > ijk[2]) { delta -= velocity[2]; }
}
rhs += delta * mInvVoxelSize;
// Note: no adjustment to the center weight (diag).
}
}
private:
// Disable assignment (due to const members).
ColliderBoundaryOp& operator=(const ColliderBoundaryOp&);
typename VelocityGridType::ConstAccessor mVelocity; // accessor to the velocity grid
ColliderAccessorType mCollider; // accessor to the collider
const bool mInvert; // invert the collider?
const bool mDynamic; // is the collider moving?
const double mInvVoxelSize;
}; // class ColliderBoundaryOp
//}
////////////////////////////////////////
/// @brief Main solver routine
template<typename VectorGridType, typename ColliderGridType, typename BoundaryOpType>
inline bool
removeDivergenceWithColliderGrid(SolverParms& parms, const BoundaryOpType& boundaryOp)
{
using VectorTreeType = typename VectorGridType::TreeType;
using VectorLeafNodeType = typename VectorTreeType::LeafNodeType;
using VectorType = typename VectorGridType::ValueType;
using VectorElementType = typename VectorType::ValueType;
using ScalarGrid = typename VectorGridType::template ValueConverter<VectorElementType>::Type;
using ScalarTree = typename ScalarGrid::TreeType;
using MaskGridType = typename VectorGridType::template ValueConverter<bool>::Type;
VectorGridType& velocityGrid = static_cast<VectorGridType&>(*parms.velocityGrid);
const bool staggered = ((velocityGrid.getGridClass() == openvdb::GRID_STAGGERED)
&& (openvdb::VecTraits<VectorType>::Size == 3));
// Compute the divergence of the incoming velocity field.
/// @todo Consider neighboring collider velocities at border voxels?
openvdb::tools::Divergence<VectorGridType> divergenceOp(velocityGrid);
typename ScalarGrid::ConstPtr divGrid = divergenceOp.process();
parms.outputState = openvdb::math::pcg::terminationDefaults<VectorElementType>();
parms.outputState.iterations = parms.iterations;
parms.outputState.absoluteError = (parms.absoluteError >= 0.0 ?
parms.absoluteError : DEFAULT_MAX_ERROR);
parms.outputState.relativeError = 0.0;
using PCT = openvdb::math::pcg::JacobiPreconditioner<openvdb::tools::poisson::LaplacianMatrix>;
// Solve for pressure using Poisson's equation.
typename ScalarTree::Ptr pressure;
if (parms.colliderType == CT_NONE) {
pressure = openvdb::tools::poisson::solveWithBoundaryConditionsAndPreconditioner<PCT>(
divGrid->tree(), boundaryOp, parms.outputState, *parms.interrupter, staggered);
} else {
// Create a domain mask by clipping the velocity grid's topology against the collider's.
// Pressure will be computed only where the domain mask is active.
MaskGridType* domainMaskGrid = new MaskGridType(*divGrid); // match input grid's topology
parms.domainMaskGrid.reset(domainMaskGrid);
if (parms.colliderType == CT_BBOX) {
if (parms.invertCollider) {
// Solve for pressure only outside the bounding box.
const openvdb::CoordBBox colliderISBBox =
velocityGrid.transform().worldToIndexNodeCentered(parms.colliderBBox);
domainMaskGrid->fill(colliderISBBox, false, false);
} else {
// Solve for pressure only inside the bounding box.
domainMaskGrid->clipGrid(parms.colliderBBox);
}
} else {
const ColliderGridType& colliderGrid =
static_cast<const ColliderGridType&>(*parms.colliderGrid);
if (parms.invertCollider) {
// Solve for pressure only inside the collider.
domainMaskGrid->topologyIntersection(colliderGrid);
} else {
// Solve for pressure only outside the collider.
domainMaskGrid->topologyDifference(colliderGrid);
}
}
pressure = openvdb::tools::poisson::solveWithBoundaryConditionsAndPreconditioner<PCT>(
divGrid->tree(), domainMaskGrid->tree(), boundaryOp, parms.outputState,
*parms.interrupter, staggered);
}
// Store the computed pressure grid.
parms.pressureGrid = ScalarGrid::create(pressure);
parms.pressureGrid->setTransform(velocityGrid.transform().copy());
{
std::string name = parms.velocityGrid->getName();
if (!name.empty()) name += "_";
name += "pressure";
parms.pressureGrid->setName(name);
}
// Compute the gradient of the pressure.
openvdb::tools::Gradient<ScalarGrid> gradientOp(static_cast<ScalarGrid&>(*parms.pressureGrid));
typename VectorGridType::Ptr gradientOfPressure = gradientOp.process();
// Compute pressure projection in parallel over leaf nodes.
{
// Pressure (and therefore the gradient of the pressure) is computed only where
// the domain mask is active, but the gradient and velocity grid topologies must match
// so that pressure projection can be computed in parallel over leaf nodes (see below).
velocityGrid.tree().voxelizeActiveTiles();
gradientOfPressure->topologyUnion(velocityGrid);
gradientOfPressure->topologyIntersection(velocityGrid);
openvdb::tools::pruneInactive(gradientOfPressure->tree());
std::vector<VectorLeafNodeType*> velNodes;
velocityGrid.tree().getNodes(velNodes);
std::vector<const VectorLeafNodeType*> gradNodes;
gradNodes.reserve(velNodes.size());
gradientOfPressure->tree().getNodes(gradNodes);
tbb::parallel_for(tbb::blocked_range<size_t>(0, velNodes.size()),
PressureProjectionOp<VectorTreeType>(parms, &velNodes[0], &gradNodes[0], staggered));
}
if (parms.colliderType != CT_NONE) {
// When obstacles are present, the Poisson solve returns a divergence-free
// velocity field in the interior of the input grid, but border voxels
// need to be adjusted manually to match neighboring collider velocities.
CorrectCollisionVelocityOp<VectorGridType> op(parms);
if (parms.colliderType == CT_BBOX) {
op.correctVelocity(BBoxConstAccessor(parms));
} else {
parms.colliderGrid->apply<hvdb::VolumeGridTypes>(op);
}
}
return parms.outputState.success;
}
/// @brief Main solver routine in the case of no collider or a bounding box collider
template<typename VectorGridType, typename BoundaryOpType>
inline bool
removeDivergence(SolverParms& parms, const BoundaryOpType& boundaryOp)
{
return removeDivergenceWithColliderGrid<VectorGridType, VectorGridType>(parms, boundaryOp);
}
/// @brief Functor to invoke the solver with a collider velocity grid of arbitrary vector type
template<typename VelocityGridType>
struct ColliderDispatchOp
{
SolverParms* parms;
bool success;
explicit ColliderDispatchOp(SolverParms& parms_): parms(&parms_) , success(false) {}
template<typename ColliderGridType>
void operator()(const ColliderGridType&)
{
using ColliderAccessorType = GridConstAccessor<ColliderGridType>;
ColliderBoundaryOp<VelocityGridType, ColliderAccessorType> boundaryOp(*parms);
success = removeDivergenceWithColliderGrid<VelocityGridType, ColliderGridType>(
*parms, boundaryOp);
}
}; // struct ColliderDispatchOp
/// @brief Invoke the solver for collider inputs of various types (or no collider).
template<typename VelocityGridType>
inline bool
processGrid(SolverParms& parms)
{
bool success = false;
switch (parms.colliderType) {
case CT_NONE:
// No collider
success = removeDivergence<VelocityGridType>(
parms, openvdb::tools::poisson::DirichletBoundaryOp<double>());
break;
case CT_BBOX:
// If collider geometry was supplied, the faces of its bounding box
// define solid obstacles.
success = removeDivergence<VelocityGridType>(parms,
ColliderBoundaryOp<VelocityGridType, BBoxConstAccessor>(parms));
break;
case CT_STATIC:
// If a static collider grid was supplied, its active voxels define solid obstacles.
success = removeDivergenceWithColliderGrid<VelocityGridType, ColliderMaskGrid>(
parms, ColliderBoundaryOp<VelocityGridType, ColliderMaskAccessor>(parms));
break;
case CT_DYNAMIC:
{
// If a dynamic collider grid was supplied, its active values define
// the velocities of solid obstacles.
ColliderDispatchOp<VelocityGridType> op(parms);
success = parms.colliderGrid->apply<hvdb::Vec3GridTypes>(op);
if (success) success = op.success;
break;
}
}
return success;
}
/// @brief Return the given VDB primitive's name in the form "N (NAME)",
/// where N is the primitive's index and NAME is the grid name.
/// @todo Use the VdbPrimCIterator method once it is adopted into the HDK.
inline UT_String
getPrimitiveIndexAndName(const GU_PrimVDB* prim)
{
UT_String result(UT_String::ALWAYS_DEEP);
if (prim != nullptr) {
result.itoa(prim->getMapIndex());
UT_String name = prim->getGridName();
result += (" (" + name.toStdString() + ")").c_str();
}
return result;
}
inline std::string
joinNames(UT_StringArray& names, const char* lastSep = " and ", const char* sep = ", ")
{
names.sort();
UT_String joined;
names.join(sep, lastSep, joined);
return "VDB" + (((names.size() == 1) ? " " : "s ") + joined.toStdString());
}
} // unnamed namespace
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Remove_Divergence::Cache::cookVDBSop(
OP_Context& context)
{
try {
const GU_Detail* colliderGeo = inputGeo(1);
const fpreal time = context.getTime();
hvdb::Interrupter interrupter("Removing divergence");
SolverParms parms;
parms.interrupter = &interrupter;
parms.iterations = (!evalInt("useiterations", 0, time) ?
DEFAULT_MAX_ITERATIONS : static_cast<int>(evalInt("iterations", 0, time)));
parms.absoluteError = (!evalInt("usetolerance", 0, time) ?
-1.0 : evalFloat("tolerance", 0, time));
parms.invertCollider = evalInt("invertcollider", 0, time);
UT_String groupStr;
evalString(groupStr, "group", 0, time);
const GA_PrimitiveGroup* group = matchGroup(*gdp, groupStr.toStdString());
const bool outputPressure = evalInt("pressure", 0, time);
const bool useCollider = evalInt("usecollider", 0, time);
const auto colliderTypeStr = evalStdString("collidertype", time);
UT_StringArray xformMismatchGridNames, nonuniformGridNames;
// Retrieve either a collider grid or a collider bounding box
// (or neither) from the reference input.
if (useCollider && colliderGeo) {
if (colliderTypeStr == "bbox") {
// Use the bounding box of the reference geometry as a collider.
UT_BoundingBox box;
colliderGeo->getBBox(&box);
parms.colliderBBox.min() = openvdb::Vec3d(box.xmin(), box.ymin(), box.zmin());
parms.colliderBBox.max() = openvdb::Vec3d(box.xmax(), box.ymax(), box.zmax());
parms.colliderType = CT_BBOX;
} else {
// Retrieve the collider grid.
UT_String colliderStr;
evalString(colliderStr, "collider", 0, time);
const GA_PrimitiveGroup* colliderGroup = parsePrimitiveGroups(
colliderStr.buffer(), GroupCreator(colliderGeo));
if (hvdb::VdbPrimCIterator colliderIt =
hvdb::VdbPrimCIterator(colliderGeo, colliderGroup))
{
if (colliderIt->getConstGrid().getGridClass() == openvdb::GRID_LEVEL_SET) {
// If the collider grid is a level set, extract an interior mask from it.
LevelSetMaskOp op;
if (hvdb::GEOvdbApply<hvdb::NumericGridTypes>(**colliderIt, op)) {
parms.colliderGrid = op.outputGrid;
}
}
if (!parms.colliderGrid) {
parms.colliderGrid = colliderIt->getConstGridPtr();
}
if (parms.colliderGrid
&& !parms.colliderGrid->constTransform().hasUniformScale())
{
nonuniformGridNames.append(getPrimitiveIndexAndName(*colliderIt));
}
if (++colliderIt) {
addWarning(SOP_MESSAGE, ("found multiple collider VDBs; using VDB "
+ getPrimitiveIndexAndName(*colliderIt).toStdString()).c_str());
}
}
if (!parms.colliderGrid) {
if (colliderStr.isstring()) {
addError(SOP_MESSAGE,
("collider \"" + colliderStr.toStdString() + "\" not found").c_str());
} else {
addError(SOP_MESSAGE, "collider VDB not found");
}
return error();
}
if (parms.colliderGrid->empty()) {
// An empty collider grid was found; ignore it.
parms.colliderGrid.reset();
}
if (parms.colliderGrid) {
const bool isVec3Grid =
(3 == UTvdbGetGridTupleSize(UTvdbGetGridType(*parms.colliderGrid)));
if (isVec3Grid && (colliderTypeStr == "dynamic")) {
// The collider grid is vector-valued. Its active values
// are the velocities of moving obstacles.
parms.colliderType = CT_DYNAMIC;
} else {
// The active voxels of the collider grid define stationary,
// solid obstacles. Extract a topology mask of those voxels.
parms.colliderType = CT_STATIC;
ColliderMaskOp op;
op.mask = ColliderMaskGrid::create();
parms.colliderGrid->apply<hvdb::AllGridTypes>(op);
parms.colliderGrid = op.mask;
}
}
}
}
int numGridsProcessed = 0;
std::ostringstream infoStrm;
// Main loop
for (hvdb::VdbPrimIterator vdbIt(gdp, group); vdbIt; ++vdbIt) {
if (interrupter.wasInterrupted()) break;
const UT_VDBType velocityType = vdbIt->getStorageType();
if (velocityType == UT_VDB_VEC3F || velocityType == UT_VDB_VEC3D) {
// Found a vector-valued input grid.
++numGridsProcessed;
vdbIt->makeGridUnique(); // ensure that the grid's tree is not shared
parms.velocityGrid = vdbIt->getGridPtr();
const openvdb::math::Transform& xform = parms.velocityGrid->constTransform();
if (!xform.hasUniformScale()) {
nonuniformGridNames.append(getPrimitiveIndexAndName(*vdbIt));
}
if (parms.colliderGrid && (parms.colliderGrid->constTransform() != xform)) {
// The velocity and collider grid transforms need to match.
xformMismatchGridNames.append(getPrimitiveIndexAndName(*vdbIt));
}
// Remove divergence.
bool success = false;
if (velocityType == UT_VDB_VEC3F) {
success = processGrid<openvdb::Vec3SGrid>(parms);
} else if (velocityType == UT_VDB_VEC3D) {
success = processGrid<openvdb::Vec3DGrid>(parms);
}
if (!success) {
std::ostringstream errStrm;
errStrm << "solver failed to converge for VDB "
<< getPrimitiveIndexAndName(*vdbIt).c_str()
<< " with error " << parms.outputState.absoluteError;
addWarning(SOP_MESSAGE, errStrm.str().c_str());
} else {
if (outputPressure && parms.pressureGrid) {
hvdb::createVdbPrimitive(*gdp, parms.pressureGrid);
}
if (numGridsProcessed > 1) infoStrm << "\n";
infoStrm << "solver converged for VDB "
<< getPrimitiveIndexAndName(*vdbIt).c_str()
<< " in " << parms.outputState.iterations << " iteration"
<< (parms.outputState.iterations == 1 ? "" : "s")
<< " with error " << parms.outputState.absoluteError;
}
}
parms.velocityGrid.reset();
}
if (!interrupter.wasInterrupted()) {
// Report various issues.
if (numGridsProcessed == 0) {
addWarning(SOP_MESSAGE, "found no floating-point vector VDBs");
} else {
if (nonuniformGridNames.size() > 0) {
const std::string names = joinNames(nonuniformGridNames);
addWarning(SOP_MESSAGE,
((names + ((nonuniformGridNames.size() == 1) ? " has" : " have"))
+ " nonuniform voxels and should be resampled").c_str());
}
if (xformMismatchGridNames.size() > 0) {
const std::string names = joinNames(xformMismatchGridNames, " or ");
addWarning(SOP_MESSAGE,
("vector field and collider transforms don't match for " + names).c_str());
}
const std::string info = infoStrm.str();
if (!info.empty()) {
addMessage(SOP_MESSAGE, info.c_str());
}
}
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 40,862 | C++ | 38.905273 | 100 | 0.616661 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/UT_VDBUtils.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c) Side Effects Software Inc.
*
* Produced by:
* Side Effects Software Inc
* 477 Richmond Street West
* Toronto, Ontario
* Canada M5V 3E7
* 416-504-9876
*
* NAME: UT_VDBUtils.h (UT Library, C++)
*
* COMMENTS:
*/
#include "UT_VDBUtils.h"
namespace openvdb_houdini {
// empty
}
| 427 | C++ | 16.833333 | 48 | 0.622951 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Remap.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Remap.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/math/Math.h> // Tolerance and isApproxEqual
#include <openvdb/tools/ValueTransformer.h>
#include <UT/UT_Ramp.h>
#include <GU/GU_Detail.h>
#include <PRM/PRM_Parm.h>
#include <tbb/blocked_range.h>
#include <tbb/parallel_for.h>
#include <tbb/parallel_reduce.h>
#include <algorithm>
#include <cmath>
#include <map>
#include <string>
#include <sstream>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
// Local Utility Methods
namespace {
template<typename T>
inline T minValue(const T a, const T b) { return std::min(a, b); }
template<typename T>
inline T maxValue(const T a, const T b) { return std::max(a, b); }
template<typename T>
inline openvdb::math::Vec3<T>
minValue(const openvdb::math::Vec3<T>& a, const openvdb::math::Vec3<T>& b) {
return openvdb::math::minComponent(a, b);
}
template<typename T>
inline openvdb::math::Vec3<T>
maxValue(const openvdb::math::Vec3<T>& a, const openvdb::math::Vec3<T>& b) {
return openvdb::math::maxComponent(a, b);
}
template<typename T>
inline T minComponent(const T s) { return s; }
template<typename T>
inline T maxComponent(const T s) { return s; }
template<typename T>
inline T
minComponent(const openvdb::math::Vec3<T>& v) {
return minValue(v[0], minValue(v[1], v[2]));
}
template<typename T>
inline T
maxComponent(const openvdb::math::Vec3<T>& v) {
return maxValue(v[0], maxValue(v[1], v[2]));
}
////////////////////////////////////////
template<typename NodeType>
struct NodeMinMax
{
using ValueType = typename NodeType::ValueType;
NodeMinMax(const std::vector<const NodeType*>& nodes, ValueType background)
: mNodes(&nodes[0]), mBackground(background), mMin(background), mMax(background)
{}
NodeMinMax(NodeMinMax& other, tbb::split)
: mNodes(other.mNodes), mBackground(other.mBackground), mMin(mBackground), mMax(mBackground)
{}
void join(NodeMinMax& other) {
mMin = minValue(other.mMin, mMin);
mMax = maxValue(other.mMax, mMax);
}
void operator()(const tbb::blocked_range<size_t>& range) {
ValueType minTmp(mMin), maxTmp(mMax);
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
const NodeType& node = *mNodes[n];
for (typename NodeType::ValueAllCIter it = node.cbeginValueAll(); it; ++it) {
if (node.isChildMaskOff(it.pos())) {
const ValueType val = *it;
minTmp = minValue(minTmp, val);
maxTmp = maxValue(maxTmp, val);
}
}
}
mMin = minValue(minTmp, mMin);
mMax = maxValue(maxTmp, mMax);
}
NodeType const * const * const mNodes;
ValueType mBackground, mMin, mMax;
};
template<typename NodeType>
struct Deactivate
{
using ValueType = typename NodeType::ValueType;
Deactivate(std::vector<NodeType*>& nodes, ValueType background)
: mNodes(&nodes[0]), mBackground(background)
{}
void operator()(const tbb::blocked_range<size_t>& range) const {
const ValueType
background(mBackground),
delta = openvdb::math::Tolerance<ValueType>::value();
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
for (typename NodeType::ValueOnIter it = mNodes[n]->beginValueOn(); it; ++it) {
if (openvdb::math::isApproxEqual(background, *it, delta)) {
it.setValueOff();
}
}
}
}
NodeType * const * const mNodes;
ValueType mBackground;
};
template<typename TreeType>
void
evalMinMax(const TreeType& tree,
typename TreeType::ValueType& minVal, typename TreeType::ValueType& maxVal)
{
minVal = tree.background();
maxVal = tree.background();
{ // eval voxels
using LeafNodeType = typename TreeType::LeafNodeType;
std::vector<const LeafNodeType*> nodes;
tree.getNodes(nodes);
NodeMinMax<LeafNodeType> op(nodes, tree.background());
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, nodes.size()), op);
minVal = minValue(minVal, op.mMin);
maxVal = maxValue(maxVal, op.mMax);
}
{ // eval first tiles
using RootNodeType = typename TreeType::RootNodeType;
using NodeChainType = typename RootNodeType::NodeChainType;
using InternalNodeType = typename NodeChainType::template Get<1>;
std::vector<const InternalNodeType*> nodes;
tree.getNodes(nodes);
NodeMinMax<InternalNodeType> op(nodes, tree.background());
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, nodes.size()), op);
minVal = minValue(minVal, op.mMin);
maxVal = maxValue(maxVal, op.mMax);
}
{ // eval remaining tiles
typename TreeType::ValueType minTmp(minVal), maxTmp(maxVal);
typename TreeType::ValueAllCIter it(tree);
it.setMaxDepth(TreeType::ValueAllCIter::LEAF_DEPTH - 2);
for ( ; it; ++it) {
const typename TreeType::ValueType val = *it;
minTmp = minValue(minTmp, val);
maxTmp = maxValue(maxTmp, val);
}
minVal = minValue(minVal, minTmp);
maxVal = maxValue(maxVal, maxTmp);
}
}
template<typename TreeType>
void
deactivateBackgroundValues(TreeType& tree)
{
{ // eval voxels
using LeafNodeType = typename TreeType::LeafNodeType;
std::vector<LeafNodeType*> nodes;
tree.getNodes(nodes);
Deactivate<LeafNodeType> op(nodes, tree.background());
tbb::parallel_for(tbb::blocked_range<size_t>(0, nodes.size()), op);
}
{ // eval first tiles
using RootNodeType = typename TreeType::RootNodeType;
using NodeChainType = typename RootNodeType::NodeChainType;
using InternalNodeType = typename NodeChainType::template Get<1>;
std::vector<InternalNodeType*> nodes;
tree.getNodes(nodes);
Deactivate<InternalNodeType> op(nodes, tree.background());
tbb::parallel_for(tbb::blocked_range<size_t>(0, nodes.size()), op);
}
{ // eval remaining tiles
using ValueType = typename TreeType::ValueType;
const ValueType
background(tree.background()),
delta = openvdb::math::Tolerance<ValueType>::value();
typename TreeType::ValueOnIter it(tree);
it.setMaxDepth(TreeType::ValueAllCIter::LEAF_DEPTH - 2);
for ( ; it; ++it) {
if (openvdb::math::isApproxEqual(background, *it, delta)) {
it.setValueOff();
}
}
}
}
////////////////////////////////////////
struct RemapGridValues {
enum Extrapolation { CLAMP, PRESERVE, EXTRAPOLATE };
RemapGridValues(Extrapolation belowExt, Extrapolation aboveExt, UT_Ramp& ramp,
const fpreal inMin, const fpreal inMax, const fpreal outMin, const fpreal outMax,
bool deactivate, UT_ErrorManager* errorManager = nullptr)
: mBelowExtrapolation(belowExt)
, mAboveExtrapolation(aboveExt)
, mRamp(&ramp)
, mErrorManager(errorManager)
, mPrimitiveIndex(0)
, mPrimitiveName()
, mInfo("Remapped grids: (first range shows actual min/max values)\n")
, mInMin(inMin)
, mInMax(inMax)
, mOutMin(outMin)
, mOutMax(outMax)
, mDeactivate(deactivate)
{
mRamp->ensureRampIsBuilt();
}
~RemapGridValues() {
if (mErrorManager) {
mErrorManager->addMessage(SOP_OPTYPE_NAME, SOP_MESSAGE, mInfo.c_str());
}
}
void setPrimitiveIndex(int i) { mPrimitiveIndex = i; }
void setPrimitiveName(const std::string& name) { mPrimitiveName = name; }
template<typename GridType>
void operator()(GridType& grid)
{
using ValueType = typename GridType::ValueType;
using LeafNodeType = typename GridType::TreeType::LeafNodeType;
std::vector<LeafNodeType*> leafnodes;
grid.tree().getNodes(leafnodes);
ValueType inputMin, inputMax;
evalMinMax(grid.tree(), inputMin, inputMax);
ValueTransform<GridType> op(*mRamp, leafnodes, mBelowExtrapolation, mAboveExtrapolation,
mInMin, mInMax, mOutMin, mOutMax);
// update voxels
tbb::parallel_for(tbb::blocked_range<size_t>(0, leafnodes.size()), op);
// update tiles
typename GridType::ValueAllIter it = grid.beginValueAll();
it.setMaxDepth(GridType::ValueAllIter::LEAF_DEPTH - 1);
openvdb::tools::foreach(it, op, true);
// update background value
grid.tree().root().setBackground(op.map(grid.background()), /*updateChildNodes=*/false);
grid.setGridClass(openvdb::GRID_UNKNOWN);
ValueType outputMin, outputMax;
evalMinMax(grid.tree(), outputMin, outputMax);
size_t activeVoxelDelta = size_t(grid.tree().activeVoxelCount());
if (mDeactivate) {
deactivateBackgroundValues(grid.tree());
activeVoxelDelta -= size_t(grid.tree().activeVoxelCount());
}
{ // log
std::stringstream msg;
msg << " (" << mPrimitiveIndex << ") '" << mPrimitiveName << "'"
<< " [" << minComponent(inputMin) << ", " << maxComponent(inputMax) << "]"
<< " -> [" << minComponent(outputMin) << ", " << maxComponent(outputMax) << "]";
if (mDeactivate && activeVoxelDelta > 0) {
msg << ", deactivated " << activeVoxelDelta << " voxels.";
}
msg << "\n";
mInfo += msg.str();
}
}
private:
template<typename GridType>
struct ValueTransform
{
using LeafNodeType = typename GridType::TreeType::LeafNodeType;
ValueTransform(const UT_Ramp& utramp, std::vector<LeafNodeType*>& leafnodes,
Extrapolation belowExt, Extrapolation aboveExt, const fpreal inMin,
const fpreal inMax, const fpreal outMin, const fpreal outMax)
: ramp(&utramp)
, nodes(&leafnodes[0])
, belowExtrapolation(belowExt)
, aboveExtrapolation(aboveExt)
, xMin(inMin)
, xScale((inMax - inMin))
, yMin(outMin)
, yScale((outMax - outMin))
{
xScale = std::abs(xScale) > fpreal(0.0) ? fpreal(1.0) / xScale : fpreal(0.0);
}
inline void operator()(const tbb::blocked_range<size_t>& range) const {
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
typename GridType::ValueType * data = nodes[n]->buffer().data();
for (size_t i = 0, I = LeafNodeType::SIZE; i < I; ++i) {
data[i] = map(data[i]);
}
}
}
inline void operator()(const typename GridType::ValueAllIter& it) const {
it.setValue(map(*it));
}
template<typename T>
inline T map(const T s) const {
fpreal pos = (fpreal(s) - xMin) * xScale;
if (pos < fpreal(0.0)) { // below (normalized) minimum
if (belowExtrapolation == PRESERVE) return s;
if (belowExtrapolation == EXTRAPOLATE) return T((pos * xScale) * yScale);
pos = std::max(pos, fpreal(0.0)); // clamp
}
if (pos > fpreal(1.0)) { // above (normalized) maximum
if (aboveExtrapolation == PRESERVE) return s;
if (aboveExtrapolation == EXTRAPOLATE) return T((pos * xScale) * yScale);
pos = std::min(pos, fpreal(1.0)); //clamp
}
float values[4] = { 0.0f };
ramp->rampLookup(pos, values);
return T(yMin + (values[0] * yScale));
}
template<typename T>
inline openvdb::math::Vec3<T> map(const openvdb::math::Vec3<T>& v) const {
openvdb::math::Vec3<T> out;
out[0] = map(v[0]);
out[1] = map(v[1]);
out[2] = map(v[2]);
return out;
}
UT_Ramp const * const ramp;
LeafNodeType * const * const nodes;
const Extrapolation belowExtrapolation, aboveExtrapolation;
fpreal xMin, xScale, yMin, yScale;
}; // struct ValueTransform
//////////
Extrapolation mBelowExtrapolation, mAboveExtrapolation;
UT_Ramp * const mRamp;
UT_ErrorManager * const mErrorManager;
int mPrimitiveIndex;
std::string mPrimitiveName, mInfo;
const fpreal mInMin, mInMax, mOutMin, mOutMax;
const bool mDeactivate;
}; // struct RemapGridValues
} // unnamed namespace
////////////////////////////////////////
// SOP Implementation
struct SOP_OpenVDB_Remap: public hvdb::SOP_NodeVDB
{
SOP_OpenVDB_Remap(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int sortInputRange();
int sortOutputRange();
class Cache: public SOP_VDBCacheOptions
{
public:
void evalRamp(UT_Ramp&, fpreal time);
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
}; // class Cache
};
int inputRangeCB(void*, int, float, const PRM_Template*);
int outputRangeCB(void*, int, float, const PRM_Template*);
int
inputRangeCB(void* data, int /*idx*/, float /*time*/, const PRM_Template*)
{
SOP_OpenVDB_Remap* sop = static_cast<SOP_OpenVDB_Remap*>(data);
if (sop == nullptr) return 0;
return sop->sortInputRange();
}
int
outputRangeCB(void* data, int /*idx*/, float /*time*/, const PRM_Template*)
{
SOP_OpenVDB_Remap* sop = static_cast<SOP_OpenVDB_Remap*>(data);
if (sop == nullptr) return 0;
return sop->sortOutputRange();
}
int
SOP_OpenVDB_Remap::sortInputRange()
{
const fpreal inMin = evalFloat("inrange", 0, 0);
const fpreal inMax = evalFloat("inrange", 1, 0);
if (inMin > inMax) {
setFloat("inrange", 0, 0, inMax);
setFloat("inrange", 1, 0, inMin);
}
return 1;
}
int
SOP_OpenVDB_Remap::sortOutputRange()
{
const fpreal outMin = evalFloat("outrange", 0, 0);
const fpreal outMax = evalFloat("outrange", 1, 0);
if (outMin > outMax) {
setFloat("outrange", 0, 0, outMax);
setFloat("outrange", 1, 0, outMin);
}
return 1;
}
void
SOP_OpenVDB_Remap::Cache::evalRamp(UT_Ramp& ramp, fpreal time)
{
const auto rampStr = evalStdString("function", time);
UT_IStream strm(rampStr.c_str(), rampStr.size(), UT_ISTREAM_ASCII);
ramp.load(strm);
}
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenu)
.setTooltip("Specify a subset of the input grids.")
.setDocumentation(
"A subset of the input VDBs to be processed"
" (see [specifying volumes|/model/volumes#group])"));
{ // Extrapolation
char const * const items[] = {
"clamp", "Clamp",
"preserve", "Preserve",
"extrapolate", "Extrapolate",
nullptr
};
parms.add(hutil::ParmFactory(PRM_ORD, "below", "Below Minimum")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip(
"Specify how to handle input values below the input range minimum:"
" either by clamping to the output minimum (Clamp),"
" leaving out-of-range values intact (Preserve),"
" or extrapolating linearly from the output minimum (Extrapolate).")
.setDocumentation(
"How to handle input values below the input range minimum\n\n"
"Clamp:\n"
" Clamp values to the output minimum.\n"
"Preserve:\n"
" Leave out-of-range values intact.\n"
"Extrapolate:\n"
" Extrapolate values linearly from the output minimum.\n"));
parms.add(hutil::ParmFactory(PRM_ORD, "above", "Above Maximum")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip(
"Specify how to handle input values above the input range maximum:"
" either by clamping to the input maximum (Clamp),"
" leaving out-of-range values intact (Preserve),"
" or extrapolating linearly from the input maximum (Extrapolate).")
.setDocumentation(
"How to handle output values above the input range maximum\n\n"
"Clamp:\n"
" Clamp values to the input maximum.\n"
"Preserve:\n"
" Leave out-of-range values intact.\n"
"Extrapolate:\n"
" Extrapolate values linearly from the input maximum.\n"));
}
std::vector<fpreal> defaultRange;
defaultRange.push_back(fpreal(0.0));
defaultRange.push_back(fpreal(1.0));
parms.add(hutil::ParmFactory(PRM_FLT_J, "inrange", "Input Range")
.setDefault(defaultRange)
.setVectorSize(2)
.setTooltip("Input min/max value range")
.setCallbackFunc(&inputRangeCB));
parms.add(hutil::ParmFactory(PRM_FLT_J, "outrange", "Output Range")
.setDefault(defaultRange)
.setVectorSize(2)
.setTooltip("Output min/max value range")
.setCallbackFunc(&outputRangeCB));
{
std::map<std::string, std::string> rampSpare;
rampSpare[PRM_SpareData::getFloatRampDefaultToken()] =
"1pos ( 0.0 ) 1value ( 0.0 ) 1interp ( linear ) "
"2pos ( 1.0 ) 2value ( 1.0 ) 2interp ( linear )";
rampSpare[PRM_SpareData::getRampShowControlsDefaultToken()] = "0";
parms.add(hutil::ParmFactory(PRM_MULTITYPE_RAMP_FLT, "function", "Transfer Function")
.setDefault(PRMtwoDefaults)
.setSpareData(rampSpare)
.setTooltip("X Axis: 0 = input range minimum, 1 = input range maximum.\n"
"Y Axis: 0 = output range minimum, 1 = output range maximum.\n")
.setDocumentation(
"Map values through a transfer function where _x_ = 0 corresponds to"
" the input range minimum, _x_ = 1 to the input range maximum,"
" _y_ = 0 to the output range minimum, and _y_ = 1 to the"
" output range maximum."));
}
parms.add(hutil::ParmFactory(PRM_TOGGLE, "deactivate", "Deactivate Background Voxels")
.setTooltip("Deactivate voxels with values equal to the remapped background value."));
hvdb::OpenVDBOpFactory("VDB Remap",
SOP_OpenVDB_Remap::factory, parms, *table)
.setNativeName("")
.addInput("VDB Grids")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Remap::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Perform a remapping of the voxel values in a VDB volume.\"\"\"\n\
\n\
@overview\n\
\n\
This node remaps voxel values to a new range, optionally through\n\
a user-specified transfer function.\n\
\n\
@related\n\
- [Node:sop/volumevop]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
OP_Node*
SOP_OpenVDB_Remap::factory(OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Remap(net, name, op);
}
SOP_OpenVDB_Remap::SOP_OpenVDB_Remap(OP_Network* net, const char* name, OP_Operator* op)
: hvdb::SOP_NodeVDB(net, name, op)
{
}
OP_ERROR
SOP_OpenVDB_Remap::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
hvdb::Interrupter boss("Remapping values");
const fpreal inMin = evalFloat("inrange", 0, time);
const fpreal inMax = evalFloat("inrange", 1, time);
const fpreal outMin = evalFloat("outrange", 0, time);
const fpreal outMax = evalFloat("outrange", 1, time);
const bool deactivate = bool(evalInt("deactivate", 0, time));
RemapGridValues::Extrapolation belowExtrapolation = RemapGridValues::CLAMP;
RemapGridValues::Extrapolation aboveExtrapolation = RemapGridValues::CLAMP;
auto extrapolation = evalInt("below", 0, time);
if (extrapolation == 1) belowExtrapolation = RemapGridValues::PRESERVE;
else if (extrapolation == 2) belowExtrapolation = RemapGridValues::EXTRAPOLATE;
extrapolation = evalInt("above", 0, time);
if (extrapolation == 1) aboveExtrapolation = RemapGridValues::PRESERVE;
else if (extrapolation == 2) aboveExtrapolation = RemapGridValues::EXTRAPOLATE;
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
size_t vdbPrimCount = 0;
UT_Ramp ramp;
evalRamp(ramp, time);
RemapGridValues remap(belowExtrapolation, aboveExtrapolation, ramp,
inMin, inMax, outMin, outMax, deactivate, UTgetErrorManager());
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (boss.wasInterrupted()) break;
remap.setPrimitiveName(it.getPrimitiveName().toStdString());
remap.setPrimitiveIndex(int(it.getIndex()));
hvdb::GEOvdbApply<hvdb::NumericGridTypes::Append<hvdb::Vec3GridTypes>>(**it, remap);
GU_PrimVDB* vdbPrim = *it;
const GEO_VolumeOptions& visOps = vdbPrim->getVisOptions();
vdbPrim->setVisualization(GEO_VOLUMEVIS_SMOKE , visOps.myIso, visOps.myDensity);
++vdbPrimCount;
}
if (vdbPrimCount == 0) {
addWarning(SOP_MESSAGE, "Did not find any VDBs.");
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 22,179 | C++ | 31.285298 | 100 | 0.603048 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GeometryUtil.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file GeometryUtil.h
/// @author FX R&D Simulation team
/// @brief Utility methods and tools for geometry processing
#ifndef OPENVDB_HOUDINI_GEOMETRY_UTIL_HAS_BEEN_INCLUDED
#define OPENVDB_HOUDINI_GEOMETRY_UTIL_HAS_BEEN_INCLUDED
#include <openvdb/openvdb.h>
#include <openvdb/tools/MeshToVolume.h> // for openvdb::tools::MeshToVoxelEdgeData
#include <openvdb/tree/LeafManager.h>
#include <openvdb/util/Util.h> // for openvdb::util::COORD_OFFSETS
#include <GU/GU_Detail.h>
#include <algorithm> // for std::max/min()
#include <memory>
#include <string>
#include <vector>
class GA_SplittableRange;
class OBJ_Camera;
class OP_Context;
class OP_Node;
#ifdef SESI_OPENVDB
#ifdef OPENVDB_HOUDINI_API
#undef OPENVDB_HOUDINI_API
#define OPENVDB_HOUDINI_API
#endif
#endif
namespace openvdb_houdini {
class Interrupter;
/// Add geometry to the given detail to indicate the extents of a frustum transform.
OPENVDB_HOUDINI_API
void
drawFrustum(GU_Detail&, const openvdb::math::Transform&,
const UT_Vector3* boxColor, const UT_Vector3* tickColor,
bool shaded, bool drawTicks = true);
/// Construct a frustum transform from a Houdini camera.
OPENVDB_HOUDINI_API
openvdb::math::Transform::Ptr
frustumTransformFromCamera(
OP_Node&, OP_Context&, OBJ_Camera&,
float offset, float nearPlaneDist, float farPlaneDist,
float voxelDepthSize = 1.0, int voxelCountX = 100);
////////////////////////////////////////
/// @brief Return @c true if the point at the given offset is referenced
/// by primitives from a certain primitive group.
OPENVDB_HOUDINI_API
bool
pointInPrimGroup(GA_Offset ptnOffset, GU_Detail&, const GA_PrimitiveGroup&);
////////////////////////////////////////
/// @brief Convert geometry to quads and triangles.
/// @return a pointer to a new GU_Detail object if the geometry was
/// converted or subdivided, otherwise a null pointer
OPENVDB_HOUDINI_API
std::unique_ptr<GU_Detail>
convertGeometry(const GU_Detail&, std::string& warning, Interrupter*);
////////////////////////////////////////
/// TBB body object for threaded world to voxel space transformation and copy of points
class OPENVDB_HOUDINI_API TransformOp
{
public:
TransformOp(GU_Detail const * const gdp,
const openvdb::math::Transform& transform,
std::vector<openvdb::Vec3s>& pointList);
void operator()(const GA_SplittableRange&) const;
private:
GU_Detail const * const mGdp;
const openvdb::math::Transform& mTransform;
std::vector<openvdb::Vec3s>* const mPointList;
};
////////////////////////////////////////
/// @brief TBB body object for threaded primitive copy
/// @details Produces a primitive-vertex index list.
class OPENVDB_HOUDINI_API PrimCpyOp
{
public:
PrimCpyOp(GU_Detail const * const gdp, std::vector<openvdb::Vec4I>& primList);
void operator()(const GA_SplittableRange&) const;
private:
GU_Detail const * const mGdp;
std::vector<openvdb::Vec4I>* const mPrimList;
};
////////////////////////////////////////
/// @brief TBB body object for threaded vertex normal generation
/// @details Averages face normals from all similarly oriented primitives,
/// that share the same vertex-point, to maintain sharp features.
class OPENVDB_HOUDINI_API VertexNormalOp
{
public:
VertexNormalOp(GU_Detail&, const GA_PrimitiveGroup* interiorPrims=nullptr, float angle=0.7f);
void operator()(const GA_SplittableRange&) const;
private:
bool isInteriorPrim(GA_Offset primOffset) const
{
return mInteriorPrims && mInteriorPrims->containsIndex(
mDetail.primitiveIndex(primOffset));
}
const GU_Detail& mDetail;
const GA_PrimitiveGroup* mInteriorPrims;
GA_RWHandleV3 mNormalHandle;
const float mAngle;
};
////////////////////////////////////////
/// TBB body object for threaded sharp feature construction
class OPENVDB_HOUDINI_API SharpenFeaturesOp
{
public:
using EdgeData = openvdb::tools::MeshToVoxelEdgeData;
SharpenFeaturesOp(GU_Detail& meshGeo, const GU_Detail& refGeo, EdgeData& edgeData,
const openvdb::math::Transform& xform, const GA_PrimitiveGroup* surfacePrims = nullptr,
const openvdb::BoolTree* mask = nullptr);
void operator()(const GA_SplittableRange&) const;
private:
GU_Detail& mMeshGeo;
const GU_Detail& mRefGeo;
EdgeData& mEdgeData;
const openvdb::math::Transform& mXForm;
const GA_PrimitiveGroup* mSurfacePrims;
const openvdb::BoolTree* mMaskTree;
};
////////////////////////////////////////
/// TBB body object for threaded sharp feature construction
template<typename IndexTreeType, typename BoolTreeType>
class GenAdaptivityMaskOp
{
public:
using BoolLeafManager = openvdb::tree::LeafManager<BoolTreeType>;
GenAdaptivityMaskOp(const GU_Detail& refGeo,
const IndexTreeType& indexTree, BoolLeafManager&, float edgetolerance = 0.0);
void run(bool threaded = true);
void operator()(const tbb::blocked_range<size_t>&) const;
private:
const GU_Detail& mRefGeo;
const IndexTreeType& mIndexTree;
BoolLeafManager& mLeafs;
float mEdgeTolerance;
};
template<typename IndexTreeType, typename BoolTreeType>
GenAdaptivityMaskOp<IndexTreeType, BoolTreeType>::GenAdaptivityMaskOp(const GU_Detail& refGeo,
const IndexTreeType& indexTree, BoolLeafManager& leafMgr, float edgetolerance)
: mRefGeo(refGeo)
, mIndexTree(indexTree)
, mLeafs(leafMgr)
, mEdgeTolerance(edgetolerance)
{
mEdgeTolerance = std::max(0.0f, mEdgeTolerance);
mEdgeTolerance = std::min(1.0f, mEdgeTolerance);
}
template<typename IndexTreeType, typename BoolTreeType>
void
GenAdaptivityMaskOp<IndexTreeType, BoolTreeType>::run(bool threaded)
{
if (threaded) {
tbb::parallel_for(mLeafs.getRange(), *this);
} else {
(*this)(mLeafs.getRange());
}
}
template<typename IndexTreeType, typename BoolTreeType>
void
GenAdaptivityMaskOp<IndexTreeType, BoolTreeType>::operator()(
const tbb::blocked_range<size_t>& range) const
{
using IndexAccessorType = typename openvdb::tree::ValueAccessor<const IndexTreeType>;
IndexAccessorType idxAcc(mIndexTree);
UT_Vector3 tmpN, normal;
GA_Offset primOffset;
int tmpIdx;
openvdb::Coord ijk, nijk;
typename BoolTreeType::LeafNodeType::ValueOnIter iter;
for (size_t n = range.begin(); n < range.end(); ++n) {
iter = mLeafs.leaf(n).beginValueOn();
for (; iter; ++iter) {
ijk = iter.getCoord();
bool edgeVoxel = false;
int idx = idxAcc.getValue(ijk);
primOffset = mRefGeo.primitiveOffset(idx);
normal = mRefGeo.getGEOPrimitive(primOffset)->computeNormal();
for (size_t i = 0; i < 18; ++i) {
nijk = ijk + openvdb::util::COORD_OFFSETS[i];
if (idxAcc.probeValue(nijk, tmpIdx) && tmpIdx != idx) {
primOffset = mRefGeo.primitiveOffset(tmpIdx);
tmpN = mRefGeo.getGEOPrimitive(primOffset)->computeNormal();
if (normal.dot(tmpN) < mEdgeTolerance) {
edgeVoxel = true;
break;
}
}
}
if (!edgeVoxel) iter.setValueOff();
}
}
}
} // namespace openvdb_houdini
////////////////////////////////////////
#endif // OPENVDB_HOUDINI_GEOMETRY_UTIL_HAS_BEEN_INCLUDED
| 7,516 | C | 26.636029 | 97 | 0.66711 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Vector_Split.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Vector_Split.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Split vector grids into component scalar grids.
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <UT/UT_Interrupt.h>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Vector_Split: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Vector_Split(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Vector_Split() override = default;
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
};
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Input vector grid group name
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip(
"Specify a subset of the input VDB grids to be split.\n"
"Vector-valued grids will be split into component scalar grids;\n"
"all other grids will be unchanged.")
.setDocumentation(
"A subset of the input VDBs to be split"
" (see [specifying volumes|/model/volumes#group])\n\n"
"Vector-valued VDBs are split into component scalar VDBs;"
" VDBs of other types are passed through unchanged."));
// Toggle to keep/remove source grids
parms.add(
hutil::ParmFactory(PRM_TOGGLE, "remove_sources", "Remove Source VDBs")
.setDefault(PRMoneDefaults)
.setTooltip("Remove vector grids that have been split.")
.setDocumentation("If enabled, delete vector grids that have been split."));
// Toggle to copy inactive values in addition to active values
parms.add(
hutil::ParmFactory(PRM_TOGGLE, "copyinactive", "Copy Inactive Values")
.setDefault(PRMzeroDefaults)
.setTooltip(
"If enabled, split the values of both active and inactive voxels.\n"
"If disabled, split the values of active voxels only."));
#ifndef SESI_OPENVDB
// Verbosity toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "verbose", "Verbose")
.setDocumentation("If enabled, print debugging information to the terminal."));
#endif
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Vector Split",
SOP_OpenVDB_Vector_Split::factory, parms, *table)
.addInput("Vector VDBs to split into scalar VDBs")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Vector_Split::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Split a vector VDB primitive into three scalar VDB primitives.\"\"\"\n\
\n\
@overview\n\
\n\
This node will create three new scalar primitives named `<<input>>.x`,\n\
`<<input>>.y`, and `<<input>>.z`.\n\
\n\
TIP:\n\
To reverse the split (i.e., to merge three scalar VDBs into a vector VDB),\n\
use the [OpenVDB Vector Merge node|Node:sop/DW_OpenVDBVectorMerge]\n\
and set the groups to `@name=*.x`, `@name=*.y`, and `@name=*.z`.\n\
\n\
@related\n\
- [OpenVDB Vector Merge|Node:sop/DW_OpenVDBVectorMerge]\n\
- [Node:sop/vdbvectorsplit]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
OP_Node*
SOP_OpenVDB_Vector_Split::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Vector_Split(net, name, op);
}
SOP_OpenVDB_Vector_Split::SOP_OpenVDB_Vector_Split(OP_Network* net,
const char* name, OP_Operator* op):
SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
namespace {
class VectorGridSplitter
{
private:
const GEO_PrimVDB& mInVdb;
hvdb::GridPtr mXGrid, mYGrid, mZGrid;
bool mCopyInactiveValues;
public:
VectorGridSplitter(const GEO_PrimVDB& _vdb, bool _inactive):
mInVdb(_vdb), mCopyInactiveValues(_inactive) {}
const hvdb::GridPtr& getXGrid() { return mXGrid; }
const hvdb::GridPtr& getYGrid() { return mYGrid; }
const hvdb::GridPtr& getZGrid() { return mZGrid; }
template<typename VecGridT>
void operator()(const VecGridT& vecGrid)
{
const std::string gridName = mInVdb.getGridName();
using VecT = typename VecGridT::ValueType;
using ScalarTreeT = typename VecGridT::TreeType::template
ValueConverter<typename VecT::value_type>::Type;
using ScalarGridT = typename openvdb::Grid<ScalarTreeT>;
using ScalarGridPtr = typename ScalarGridT::Ptr;
const VecT bkgd = vecGrid.background();
// Construct the output scalar grids, with background values taken from
// the components of the input vector grid's background value.
ScalarGridPtr
xGrid = ScalarGridT::create(bkgd.x()),
yGrid = ScalarGridT::create(bkgd.y()),
zGrid = ScalarGridT::create(bkgd.z());
mXGrid = xGrid; mYGrid = yGrid; mZGrid = zGrid;
// The output scalar grids share the input vector grid's transform.
if (openvdb::math::Transform::Ptr xform = vecGrid.transform().copy()) {
xGrid->setTransform(xform);
yGrid->setTransform(xform);
zGrid->setTransform(xform);
}
// Use accessors for fast sequential voxel access.
typename ScalarGridT::Accessor
xAccessor = xGrid->getAccessor(),
yAccessor = yGrid->getAccessor(),
zAccessor = zGrid->getAccessor();
// For each tile or voxel value in the input vector tree,
// set a corresponding value in each of the output scalar trees.
openvdb::CoordBBox bbox;
if (mCopyInactiveValues) {
for (typename VecGridT::ValueAllCIter it = vecGrid.cbeginValueAll(); it; ++it) {
if (!it.getBoundingBox(bbox)) continue;
const VecT& val = it.getValue();
const bool active = it.isValueOn();
if (it.isTileValue()) {
xGrid->fill(bbox, val.x(), active);
yGrid->fill(bbox, val.y(), active);
zGrid->fill(bbox, val.z(), active);
} else { // it.isVoxelValue()
xAccessor.setValue(bbox.min(), val.x());
yAccessor.setValue(bbox.min(), val.y());
zAccessor.setValue(bbox.min(), val.z());
if (!active) {
xAccessor.setValueOff(bbox.min());
yAccessor.setValueOff(bbox.min());
zAccessor.setValueOff(bbox.min());
}
}
}
} else {
for (typename VecGridT::ValueOnCIter it = vecGrid.cbeginValueOn(); it; ++it) {
if (!it.getBoundingBox(bbox)) continue;
const VecT& val = it.getValue();
if (it.isTileValue()) {
xGrid->fill(bbox, val.x());
yGrid->fill(bbox, val.y());
zGrid->fill(bbox, val.z());
} else { // it.isVoxelValue()
xAccessor.setValueOn(bbox.min(), val.x());
yAccessor.setValueOn(bbox.min(), val.y());
zAccessor.setValueOn(bbox.min(), val.z());
}
}
}
}
}; // class VectorGridSplitter
} // unnamed namespace
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Vector_Split::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
const bool copyInactiveValues = evalInt("copyinactive", 0, time);
const bool removeSourceGrids = evalInt("remove_sources", 0, time);
#ifndef SESI_OPENVDB
const bool verbose = evalInt("verbose", 0, time);
#else
const bool verbose = false;
#endif
UT_AutoInterrupt progress("Splitting VDB grids");
using PrimVDBSet = std::set<GEO_PrimVDB*>;
PrimVDBSet primsToRemove;
// Get the group of grids to split.
const GA_PrimitiveGroup* splitGroup = nullptr;
{
UT_String groupStr;
evalString(groupStr, "group", 0, time);
splitGroup = matchGroup(*gdp, groupStr.toStdString());
}
// Iterate over VDB primitives in the selected group.
for (hvdb::VdbPrimIterator it(gdp, splitGroup); it; ++it) {
if (progress.wasInterrupted()) return error();
GU_PrimVDB* vdb = *it;
const std::string gridName = vdb->getGridName();
VectorGridSplitter op(*vdb, copyInactiveValues);
if (!hvdb::GEOvdbApply<hvdb::Vec3GridTypes>(*vdb, op)) {
if (verbose && !gridName.empty()) {
addWarning(SOP_MESSAGE, (gridName + " is not a vector grid").c_str());
}
continue;
}
// Add the new scalar grids to the detail, copying attributes and
// group membership from the input vector grid.
const std::string
xGridName = gridName.empty() ? "x" : gridName + ".x",
yGridName = gridName.empty() ? "y" : gridName + ".y",
zGridName = gridName.empty() ? "z" : gridName + ".z";
GU_PrimVDB::buildFromGrid(*gdp, op.getXGrid(), vdb, xGridName.c_str());
GU_PrimVDB::buildFromGrid(*gdp, op.getYGrid(), vdb, yGridName.c_str());
GU_PrimVDB::buildFromGrid(*gdp, op.getZGrid(), vdb, zGridName.c_str());
if (verbose) {
std::ostringstream ostr;
ostr << "Split ";
if (!gridName.empty()) ostr << gridName << " ";
ostr << "into " << xGridName << ", " << yGridName << " and " << zGridName;
addMessage(SOP_MESSAGE, ostr.str().c_str());
}
primsToRemove.insert(vdb);
}
if (removeSourceGrids) {
// Remove vector grids that were split.
for (PrimVDBSet::iterator i = primsToRemove.begin(), e = primsToRemove.end();
i != e; ++i)
{
gdp->destroyPrimitive(*(*i), /*andPoints=*/true);
}
}
primsToRemove.clear();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 10,638 | C++ | 33.654723 | 98 | 0.586764 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Platonic.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Platonic.cc
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <UT/UT_Interrupt.h>
#include <openvdb/tools/LevelSetSphere.h>
#include <openvdb/tools/LevelSetPlatonic.h>
#include <openvdb/tools/LevelSetUtil.h>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Platonic: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Platonic(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Platonic() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
};
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Shapes
parms.add(hutil::ParmFactory(PRM_ORD, "solidType", "Solid Type")
.setTooltip("Select a sphere or one of the five platonic solids")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"sphere", "Sphere",
"tetrahedron", "Tetrahedron",
"cube", "Cube",
"octahedron", "Octahedron",
"dodecahedron", "Dodecahedron",
"icosahedron", "Icosahedron"
}));
{ // Grid Class
const std::vector<std::string> items{
openvdb::GridBase::gridClassToString(openvdb::GRID_LEVEL_SET), // token
openvdb::GridBase::gridClassToMenuName(openvdb::GRID_LEVEL_SET), // label
"sdf", "Signed Distance Field"
};
parms.add(hutil::ParmFactory(PRM_STRING, "gridclass", "Grid Class")
.setDefault(openvdb::GridBase::gridClassToString(openvdb::GRID_LEVEL_SET))
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDocumentation("\
The type of volume to generate\n\
\n\
Level Set:\n\
Generate a narrow-band signed distance field level set, in which\n\
the values define positive and negative distances to the surface\n\
of the solid up to a certain band width.\n\
\n\
Signed Distance Field:\n\
Generate a narrow-band unsigned distance field level set, in which\n\
the values define positive distances to the surface of the solid\n\
up to a certain band width.\n"));
}
// Radius
parms.add(hutil::ParmFactory(PRM_FLT_J, "scalarRadius", "Radius/Size")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_FREE, 10)
.setTooltip("The size of the platonic solid or the radius of the sphere"));
// Center
parms.add(hutil::ParmFactory(PRM_XYZ_J, "center", "Center")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setTooltip("The world-space center of the level set"));
// Voxel size
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxelSize", "Voxel Size")
.setDefault(0.1f)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_FREE, 10)
.setTooltip("The size of a voxel in world units"));
// Narrow-band half-width
parms.add(hutil::ParmFactory(PRM_FLT_J, "halfWidth", "Half-Band Width")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1.0, PRM_RANGE_UI, 10)
.setTooltip(
"Half the width of the narrow band in voxel units\n\n"
"For proper operation, many nodes expect this to be at least three."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fogVolume", "Convert to Fog Volume")
.setTooltip("If enabled, generate a fog volume instead of a level set"));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Platonic",
SOP_OpenVDB_Platonic::factory, parms, *table)
.setNativeName("")
.setVerb(SOP_NodeVerb::COOK_GENERATOR,
[]() { return new SOP_OpenVDB_Platonic::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Generate a platonic solid as a level set or a fog volume VDB.\"\"\"\n\
\n\
@overview\n\
\n\
This node generates a VDB representing a platonic solid as either a level set or fog volume.\n\
\n\
@related\n\
- [OpenVDB Create|Node:sop/DW_OpenVDBCreate]\n\
- [Node:sop/platonic]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
OP_Node*
SOP_OpenVDB_Platonic::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Platonic(net, name, op);
}
SOP_OpenVDB_Platonic::SOP_OpenVDB_Platonic(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
bool
SOP_OpenVDB_Platonic::updateParmsFlags()
{
bool changed = false;
const bool sdfGrid = (evalStdString("gridclass", 0) == "sdf");
changed |= enableParm("halfWidth", sdfGrid);
return changed;
}
OP_ERROR
SOP_OpenVDB_Platonic::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
hvdb::Interrupter boss("Creating VDB platonic solid");
// Read GUI parameters and generate narrow-band level set of sphere
const float radius = static_cast<float>(evalFloat("scalarRadius", 0, time));
const openvdb::Vec3f center = evalVec3f("center", time);
const float voxelSize = static_cast<float>(evalFloat("voxelSize", 0, time));
const float halfWidth = ((evalStdString("gridclass", 0) != "sdf") ?
3.0f : static_cast<float>(evalFloat("halfWidth", 0, time)));
openvdb::FloatGrid::Ptr grid;
switch (evalInt("solidType", 0, time)) {
case 0://Sphere
grid = openvdb::tools::createLevelSetSphere<openvdb::FloatGrid, hvdb::Interrupter>
(radius, center, voxelSize, halfWidth, &boss);
break;
case 1:// Tetrahedraon
grid = openvdb::tools::createLevelSetTetrahedron<openvdb::FloatGrid, hvdb::Interrupter>
(radius, center, voxelSize, halfWidth, &boss);
break;
case 2:// Cube
grid = openvdb::tools::createLevelSetCube<openvdb::FloatGrid, hvdb::Interrupter>
(radius, center, voxelSize, halfWidth, &boss);
break;
case 3:// Octahedron
grid = openvdb::tools::createLevelSetOctahedron<openvdb::FloatGrid, hvdb::Interrupter>
(radius, center, voxelSize, halfWidth, &boss);
break;
case 4:// Dodecahedron
grid = openvdb::tools::createLevelSetDodecahedron<openvdb::FloatGrid, hvdb::Interrupter>
(radius, center, voxelSize, halfWidth, &boss);
break;
case 5:// Icosahedron
grid = openvdb::tools::createLevelSetIcosahedron<openvdb::FloatGrid, hvdb::Interrupter>
(radius, center, voxelSize, halfWidth, &boss);
break;
default:
addError(SOP_MESSAGE, "Illegal shape.");
return error();
}
// Fog volume conversion
if (bool(evalInt("fogVolume", 0, time))) {
openvdb::tools::sdfToFogVolume(*grid);
}
// Store the grid in a new VDB primitive and add the primitive to the output gdp
hvdb::createVdbPrimitive(*gdp, grid, "PlatonicSolid");
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 7,504 | C++ | 32.959276 | 100 | 0.639126 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Occlusion_Mask.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Occlusion_Mask.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Masks the occluded regions behind objects in the camera frustum
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/GeometryUtil.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/LevelSetUtil.h>
#include <openvdb/tools/GridTransformer.h>
#include <openvdb/tools/Morphology.h>
#include <OBJ/OBJ_Camera.h>
#include <cmath> // for std::floor()
#include <stdexcept>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Occlusion_Mask: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Occlusion_Mask(OP_Network* net, const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op) {}
~SOP_OpenVDB_Occlusion_Mask() override = default;
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions
{
public:
openvdb::math::Transform::Ptr frustum() const { return mFrustum; }
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
private:
openvdb::math::Transform::Ptr mFrustum;
}; // class Cache
protected:
void resolveObsoleteParms(PRM_ParmList*) override;
OP_ERROR cookMyGuide1(OP_Context&) override;
}; // class SOP_OpenVDB_Occlusion_Mask
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Occlusion_Mask::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Occlusion_Mask(net, name, op);
}
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to be processed.")
.setDocumentation(
"A subset of the input VDBs to be processed"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "camera", "Camera")
.setTypeExtended(PRM_TYPE_DYNAMIC_PATH)
.setSpareData(&PRM_SpareData::objCameraPath)
.setTooltip("Reference camera path")
.setDocumentation("The path to the camera (e.g., `/obj/cam1`)"));
parms.add(hutil::ParmFactory(PRM_INT_J, "voxelcount", "Voxel Count")
.setDefault(PRM100Defaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 200)
.setTooltip("The desired width in voxels of the camera's near plane"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxeldepthsize", "Voxel Depth Size")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 5)
.setTooltip("The depth of a voxel in world units (all voxels have equal depth)"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "depth", "Mask Depth")
.setDefault(100)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_UI, 1000.0)
.setTooltip(
"The desired depth of the mask in world units"
" from the near plane to the far plane"));
parms.add(hutil::ParmFactory(PRM_INT_J, "erode", "Erode")
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10)
.setDefault(PRMzeroDefaults)
.setTooltip("The number of voxels by which to shrink the mask"));
parms.add(hutil::ParmFactory(PRM_INT_J, "zoffset", "Z Offset")
.setRange(PRM_RANGE_UI, -10, PRM_RANGE_UI, 10)
.setDefault(PRMzeroDefaults)
.setTooltip("The number of voxels by which to offset the near plane"));
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "voxelCount", "Voxel Count")
.setDefault(PRM100Defaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "voxelDepthSize", "Voxel Depth Size")
.setDefault(PRMoneDefaults));
hvdb::OpenVDBOpFactory("VDB Occlusion Mask",
SOP_OpenVDB_Occlusion_Mask::factory, parms, *table)
.addInput("VDBs")
.setObsoleteParms(obsoleteParms)
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Occlusion_Mask::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Identify voxels of a VDB volume that are in shadow from a given camera.\"\"\"\n\
\n\
@overview\n\
\n\
This node outputs a VDB volume whose active voxels denote the voxels\n\
of an input volume inside a camera frustum that would be occluded\n\
when viewed through the camera.\n\
\n\
@related\n\
- [OpenVDB Clip|Node:sop/DW_OpenVDBClip]\n\
- [OpenVDB Create|Node:sop/DW_OpenVDBCreate]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Occlusion_Mask::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
resolveRenamedParm(*obsoleteParms, "voxelCount", "voxelcount");
resolveRenamedParm(*obsoleteParms, "voxelDepthSize", "voxeldepthsize");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Occlusion_Mask::cookMyGuide1(OP_Context&)
{
myGuide1->clearAndDestroy();
openvdb::math::Transform::ConstPtr frustum;
// Attempt to extract the frustum from our cache.
if (auto* cache = dynamic_cast<SOP_OpenVDB_Occlusion_Mask::Cache*>(myNodeVerbCache)) {
frustum = cache->frustum();
}
if (frustum) {
UT_Vector3 color(0.9f, 0.0f, 0.0f);
hvdb::drawFrustum(*myGuide1, *frustum, &color, nullptr, false, false);
}
return error();
}
////////////////////////////////////////
namespace {
template<typename BoolTreeT>
class VoxelShadow
{
public:
using BoolLeafManagerT = openvdb::tree::LeafManager<const BoolTreeT>;
//////////
VoxelShadow(const BoolLeafManagerT& leafs, int zMax, int offset);
void run(bool threaded = true);
BoolTreeT& tree() const { return *mNewTree; }
//////////
VoxelShadow(VoxelShadow&, tbb::split);
void operator()(const tbb::blocked_range<size_t>&);
void join(const VoxelShadow& rhs)
{
mNewTree->merge(*rhs.mNewTree);
mNewTree->prune();
}
private:
typename BoolTreeT::Ptr mNewTree;
const BoolLeafManagerT* mLeafs;
const int mOffset, mZMax;
};
template<typename BoolTreeT>
VoxelShadow<BoolTreeT>::VoxelShadow(const BoolLeafManagerT& leafs, int zMax, int offset)
: mNewTree(new BoolTreeT(false))
, mLeafs(&leafs)
, mOffset(offset)
, mZMax(zMax)
{
}
template<typename BoolTreeT>
VoxelShadow<BoolTreeT>::VoxelShadow(VoxelShadow& rhs, tbb::split)
: mNewTree(new BoolTreeT(false))
, mLeafs(rhs.mLeafs)
, mOffset(rhs.mOffset)
, mZMax(rhs.mZMax)
{
}
template<typename BoolTreeT>
void
VoxelShadow<BoolTreeT>::run(bool threaded)
{
if (threaded) tbb::parallel_reduce(mLeafs->getRange(), *this);
else (*this)(mLeafs->getRange());
}
template<typename BoolTreeT>
void
VoxelShadow<BoolTreeT>::operator()(const tbb::blocked_range<size_t>& range)
{
typename BoolTreeT::LeafNodeType::ValueOnCIter it;
openvdb::CoordBBox bbox;
bbox.max()[2] = mZMax;
for (size_t n = range.begin(); n != range.end(); ++n) {
for (it = mLeafs->leaf(n).cbeginValueOn(); it; ++it) {
bbox.min() = it.getCoord();
bbox.min()[2] += mOffset;
bbox.max()[0] = bbox.min()[0];
bbox.max()[1] = bbox.min()[1];
mNewTree->fill(bbox, true, true);
}
mNewTree->prune();
}
}
struct BoolSampler
{
static const char* name() { return "bin"; }
static int radius() { return 2; }
static bool mipmap() { return false; }
static bool consistent() { return true; }
template<class TreeT>
static bool sample(const TreeT& inTree,
const openvdb::Vec3R& inCoord, typename TreeT::ValueType& result)
{
openvdb::Coord ijk;
ijk[0] = int(std::floor(inCoord[0]));
ijk[1] = int(std::floor(inCoord[1]));
ijk[2] = int(std::floor(inCoord[2]));
return inTree.probeValue(ijk, result);
}
};
struct ConstructShadow
{
ConstructShadow(const openvdb::math::Transform& frustum, int erode, int zoffset)
: mGrid(openvdb::BoolGrid::create(false))
, mFrustum(frustum)
, mErode(erode)
, mZOffset(zoffset)
{
}
template<typename GridType>
void operator()(const GridType& grid)
{
using TreeType = typename GridType::TreeType;
const TreeType& tree = grid.tree();
// Resample active tree topology into camera frustum space.
openvdb::BoolGrid frustumMask(false);
frustumMask.setTransform(mFrustum.copy());
{
openvdb::BoolGrid topologyMask(false);
topologyMask.setTransform(grid.transform().copy());
if (openvdb::GRID_LEVEL_SET == grid.getGridClass()) {
openvdb::BoolGrid::Ptr tmpGrid = openvdb::tools::sdfInteriorMask(grid);
topologyMask.tree().merge(tmpGrid->tree());
if (mErode > 3) {
openvdb::tools::erodeVoxels(topologyMask.tree(), (mErode - 3));
}
} else {
topologyMask.tree().topologyUnion(tree);
if (mErode > 0) {
openvdb::tools::erodeVoxels(topologyMask.tree(), mErode);
}
}
if (grid.transform().voxelSize()[0] < mFrustum.voxelSize()[0]) {
openvdb::tools::resampleToMatch<openvdb::tools::PointSampler>(
topologyMask, frustumMask);
} else {
openvdb::tools::resampleToMatch<BoolSampler>(topologyMask, frustumMask);
}
}
// Create shadow volume
mGrid = openvdb::BoolGrid::create(false);
mGrid->setTransform(mFrustum.copy());
openvdb::BoolTree& shadowTree = mGrid->tree();
const openvdb::math::NonlinearFrustumMap& map =
*mFrustum.map<openvdb::math::NonlinearFrustumMap>();
int zCoord = int(std::floor(map.getBBox().max()[2]));
// Voxel shadows
openvdb::tree::LeafManager<const openvdb::BoolTree> leafs(frustumMask.tree());
VoxelShadow<openvdb::BoolTree> shadowOp(leafs, zCoord, mZOffset);
shadowOp.run();
shadowTree.merge(shadowOp.tree());
// Tile shadows
openvdb::CoordBBox bbox;
openvdb::BoolTree::ValueOnIter it(frustumMask.tree());
it.setMaxDepth(openvdb::BoolTree::ValueAllIter::LEAF_DEPTH - 1);
for ( ; it; ++it) {
it.getBoundingBox(bbox);
bbox.min()[2] += mZOffset;
bbox.max()[2] = zCoord;
shadowTree.fill(bbox, true, true);
}
shadowTree.prune();
}
openvdb::BoolGrid::Ptr& grid() { return mGrid; }
private:
openvdb::BoolGrid::Ptr mGrid;
const openvdb::math::Transform mFrustum;
const int mErode, mZOffset;
};
} // unnamed namespace
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Occlusion_Mask::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
// Camera reference
mFrustum.reset();
UT_String cameraPath;
evalString(cameraPath, "camera", 0, time);
cameraPath.harden();
if (cameraPath.isstring()) {
OBJ_Node* camobj = cookparms()->getCwd()->findOBJNode(cameraPath);
OP_Node* self = cookparms()->getCwd();
if (!camobj) {
addError(SOP_MESSAGE, "Camera not found");
return error();
}
OBJ_Camera* cam = camobj->castToOBJCamera();
if (!cam) {
addError(SOP_MESSAGE, "Camera not found");
return error();
}
// Register
this->addExtraInput(cam, OP_INTEREST_DATA);
const float nearPlane = static_cast<float>(cam->getNEAR(time));
const float farPlane = static_cast<float>(nearPlane + evalFloat("depth", 0, time));
const float voxelDepthSize = static_cast<float>(evalFloat("voxeldepthsize", 0, time));
const int voxelCount = static_cast<int>(evalInt("voxelcount", 0, time));
mFrustum = hvdb::frustumTransformFromCamera(*self, context, *cam,
0, nearPlane, farPlane, voxelDepthSize, voxelCount);
} else {
addError(SOP_MESSAGE, "No camera referenced.");
return error();
}
ConstructShadow shadowOp(*mFrustum,
static_cast<int>(evalInt("erode", 0, time)),
static_cast<int>(evalInt("zoffset", 0, time)));
// Get the group of grids to surface.
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
hvdb::GEOvdbApply<hvdb::NumericGridTypes>(**it, shadowOp);
// Replace the original VDB primitive with a new primitive that contains
// the output grid and has the same attributes and group membership.
if (GU_PrimVDB* prim = hvdb::replaceVdbPrimitive(*gdp, shadowOp.grid(), **it, true)) {
// Visualize our bool grids as "smoke", not whatever the input
// grid was, which can be a levelset.
prim->setVisualization(GEO_VOLUMEVIS_SMOKE, prim->getVisIso(),
prim->getVisDensity());
}
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 13,792 | C++ | 28.535332 | 100 | 0.616734 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GT_GEOPrimCollectVDB.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c) Side Effects Software Inc.
*
* Produced by:
* Side Effects Software Inc
* 123 Front Street West, Suite 1401
* Toronto, Ontario
* Canada M5J 2M2
* 416-504-9876
*
* NAME: GT_GEOPrimCollectVDB.h (GT Library, C++)
*
* COMMENTS:
*/
#include "GT_GEOPrimCollectVDB.h"
#include "UT_VDBUtils.h"
#include <GT/GT_DANumeric.h>
#include <GT/GT_GEOPrimCollect.h>
#include <GT/GT_GEOPrimitive.h>
#include <GT/GT_Handles.h>
#include <GT/GT_PrimCurveMesh.h>
#include <GU/GU_DetailHandle.h>
#include "GEO_PrimVDB.h"
#include <UT/UT_ParallelUtil.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Version.h>
#include <openvdb/openvdb.h>
#include <openvdb/Grid.h>
using namespace openvdb_houdini;
void
GT_GEOPrimCollectVDB::registerPrimitive(const GA_PrimitiveTypeId &id)
{
new GT_GEOPrimCollectVDB(id);
}
namespace
{
class gt_RefineVDB
{
public:
gt_RefineVDB(
const GU_Detail &gdp,
const GT_GEOOffsetList &vdb_offsets)
: myGdp(gdp)
, myVDBOffsets(vdb_offsets)
, myPos(new GT_Real32Array(0, 3, GT_TYPE_POINT))
, myPosHandle(myPos)
{
}
gt_RefineVDB(
const gt_RefineVDB &task,
UT_Split)
: myGdp(task.myGdp)
, myVDBOffsets(task.myVDBOffsets)
, myPos(new GT_Real32Array(0, 3, GT_TYPE_POINT))
, myPosHandle(myPos)
{
}
enum { NPTS = 8 };
void
appendBox(openvdb::Vec3s corners[NPTS])
{
myVertexCounts.append(NPTS * 2);
myPos->append(corners[0].asPointer()); // 0
myPos->append(corners[1].asPointer()); // 1
myPos->append(corners[2].asPointer()); // 2
myPos->append(corners[3].asPointer()); // 3
myPos->append(corners[0].asPointer()); // 4
myPos->append(corners[4].asPointer()); // 5
myPos->append(corners[5].asPointer()); // 6
myPos->append(corners[6].asPointer()); // 7
myPos->append(corners[7].asPointer()); // 8
myPos->append(corners[4].asPointer()); // 9
myPos->append(corners[5].asPointer()); // 10
myPos->append(corners[1].asPointer()); // 11
myPos->append(corners[2].asPointer()); // 12
myPos->append(corners[6].asPointer()); // 13
myPos->append(corners[7].asPointer()); // 14
myPos->append(corners[3].asPointer()); // 15
}
template <typename GridT>
void
processGrid(const GridT &grid, int /*dummy*/)
{
using namespace openvdb;
typedef typename GridT::TreeType TreeT;
typedef typename TreeT::LeafCIter LeafCIter;
typedef typename TreeT::LeafNodeType LeafNodeType;
const openvdb::math::Transform &xform = grid.transform();
bool appended = false;
for (LeafCIter iter = grid.tree().cbeginLeaf(); iter; ++iter)
{
LeafNodeType const * const leaf = iter.getLeaf();
const Vec3d half(0.5);
Vec3d bbox_pos[2];
/// Nodes are rendered as cell-centered (0.5 voxel dilated)
/// AABBox in world space
bbox_pos[0] = leaf->origin() - half;
bbox_pos[1] = leaf->origin().offsetBy(leaf->dim() - 1) + half;
Vec3s corners[NPTS];
Coord lut[NPTS] = {
Coord(0, 0, 0),
Coord(0, 0, 1),
Coord(1, 0, 1),
Coord(1, 0, 0),
Coord(0, 1, 0),
Coord(0, 1, 1),
Coord(1, 1, 1),
Coord(1, 1, 0),
};
for (int i = 0; i < NPTS; i++)
{
Vec3d pt(bbox_pos[lut[i][0]].x(),
bbox_pos[lut[i][1]].y(),
bbox_pos[lut[i][2]].z());
corners[i] = xform.indexToWorld(pt);
}
appendBox(corners);
appended = true;
}
if (!appended)
{
const int NPTS = 6;
openvdb::Vec3s lines[NPTS];
lines[0].init(-0.5, 0.0, 0.0);
lines[1].init( 0.5, 0.0, 0.0);
lines[2].init( 0.0,-0.5, 0.0);
lines[3].init( 0.0, 0.5, 0.0);
lines[4].init( 0.0, 0.0,-0.5);
lines[5].init( 0.0, 0.0, 0.5);
for (int i = 0; i < NPTS; i++)
lines[i] = xform.indexToWorld(lines[i]);
for (int i = 0; i < NPTS; i += 2)
{
myVertexCounts.append(2);
myPos->append(lines[i].asPointer());
myPos->append(lines[i+1].asPointer());
}
}
}
void
operator()(const UT_BlockedRange<exint> &range)
{
using namespace openvdb;
for (exint i = range.begin(); i != range.end(); ++i)
{
const GEO_Primitive *prim = myGdp.getGEOPrimitive(myVDBOffsets(i));
const GEO_PrimVDB *vdb = static_cast<const GEO_PrimVDB *>(prim);
UTvdbCallAllType(vdb->getStorageType(), processGrid, vdb->getGrid(), 0);
}
}
void
join(const gt_RefineVDB &task)
{
myPos->concat(*task.myPos);
myVertexCounts.concat(task.myVertexCounts);
}
const GU_Detail & myGdp;
const GT_GEOOffsetList & myVDBOffsets;
GT_Real32Array * myPos;
GT_DataArrayHandle myPosHandle;
GT_GEOOffsetList myVertexCounts;
};
}
GT_GEOPrimCollectVDB::GT_GEOPrimCollectVDB(const GA_PrimitiveTypeId &id)
: myId(id)
{
bind(myId);
}
GT_GEOPrimCollectVDB::~GT_GEOPrimCollectVDB()
{
}
GT_GEOPrimCollectData *
GT_GEOPrimCollectVDB::beginCollecting(
const GT_GEODetailListHandle &,
const GT_RefineParms *) const
{
return new GT_GEOPrimCollectOffsets();
}
GT_PrimitiveHandle
GT_GEOPrimCollectVDB::collect(
const GT_GEODetailListHandle &/*geometry*/,
const GEO_Primitive *const* prim_list,
int /*nsegments*/,
GT_GEOPrimCollectData *data) const
{
data->asPointer<GT_GEOPrimCollectOffsets>()->append(prim_list[0]);
return GT_PrimitiveHandle();
}
GT_PrimitiveHandle
GT_GEOPrimCollectVDB::endCollecting(
const GT_GEODetailListHandle &g,
GT_GEOPrimCollectData *data) const
{
const GT_GEOPrimCollectOffsets &
offsets = *(data->asPointer<GT_GEOPrimCollectOffsets>());
const GT_GEOOffsetList & prims = offsets.getPrimitives();
if (!prims.entries())
return GT_PrimitiveHandle();
GU_DetailHandleAutoReadLock gdl(g->getGeometry(0));
const GU_Detail* detail = gdl.getGdp();
gt_RefineVDB task(*detail, prims);
UTparallelReduce(UT_BlockedRange<exint>(0, prims.entries()), task);
GT_DataArrayHandle vertex_counts = task.myVertexCounts.allocateArray();
GT_AttributeListHandle
vertices = GT_AttributeList::createAttributeList("P", task.myPos);
return GT_PrimitiveHandle(
new GT_PrimCurveMesh(
GT_BASIS_LINEAR,
vertex_counts,
vertices.get(),
GT_AttributeListHandle(), // uniform
GT_AttributeListHandle(), // detail
/*wrap*/false));
}
| 7,284 | C++ | 27.457031 | 84 | 0.55821 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Advect_Points.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Advect_Points.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief SOP to perform advection of points through a velocity field.
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/PointUtils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/PointAdvect.h>
#include <openvdb/points/PointAdvect.h>
#include <GA/GA_PageIterator.h>
#include <GU/GU_PrimPoly.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_UniquePtr.h>
#include <hboost/algorithm/string/case_conv.hpp>
#include <hboost/algorithm/string/trim.hpp>
#include <algorithm>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
// Utilities
namespace {
// Add new items to the *end* of this list, and update NUM_PROPAGATION_TYPES.
enum PropagationType {
PROPAGATION_TYPE_UNKNOWN = -1,
PROPAGATION_TYPE_ADVECTION = 0,
PROPAGATION_TYPE_PROJECTION,
PROPAGATION_TYPE_CONSTRAINED_ADVECTION
};
enum { NUM_PROPAGATION_TYPES = PROPAGATION_TYPE_CONSTRAINED_ADVECTION + 1 };
std::string
propagationTypeToString(PropagationType pt)
{
std::string ret;
switch (pt) {
case PROPAGATION_TYPE_ADVECTION: ret = "advection"; break;
case PROPAGATION_TYPE_PROJECTION: ret = "projection"; break;
case PROPAGATION_TYPE_CONSTRAINED_ADVECTION: ret = "cadvection"; break;
case PROPAGATION_TYPE_UNKNOWN: ret = "unknown"; break;
}
return ret;
}
std::string
propagationTypeToMenuName(PropagationType pt)
{
std::string ret;
switch (pt) {
case PROPAGATION_TYPE_ADVECTION: ret = "Advection"; break;
case PROPAGATION_TYPE_PROJECTION: ret = "Projection"; break;
case PROPAGATION_TYPE_CONSTRAINED_ADVECTION: ret = "Constrained Advection"; break;
case PROPAGATION_TYPE_UNKNOWN: ret = "Unknown"; break;
}
return ret;
}
PropagationType
stringToPropagationType(const std::string& s)
{
PropagationType ret = PROPAGATION_TYPE_UNKNOWN;
std::string str = s;
hboost::trim(str);
hboost::to_lower(str);
if (str == propagationTypeToString(PROPAGATION_TYPE_ADVECTION)) {
ret = PROPAGATION_TYPE_ADVECTION;
} else if (str == propagationTypeToString(PROPAGATION_TYPE_PROJECTION)) {
ret = PROPAGATION_TYPE_PROJECTION;
} else if (str == propagationTypeToString(PROPAGATION_TYPE_CONSTRAINED_ADVECTION)) {
ret = PROPAGATION_TYPE_CONSTRAINED_ADVECTION;
}
return ret;
}
// Add new items to the *end* of this list, and update NUM_INTEGRATION_TYPES.
enum IntegrationType {
INTEGRATION_TYPE_UNKNOWN = -1,
INTEGRATION_TYPE_FWD_EULER = 0,
INTEGRATION_TYPE_RK_2ND,
INTEGRATION_TYPE_RK_3RD,
INTEGRATION_TYPE_RK_4TH
};
enum { NUM_INTEGRATION_TYPES = INTEGRATION_TYPE_RK_4TH + 1 };
std::string
integrationTypeToString(IntegrationType it)
{
std::string ret;
switch (it) {
case INTEGRATION_TYPE_FWD_EULER: ret = "fwd euler"; break;
case INTEGRATION_TYPE_RK_2ND: ret = "2nd rk"; break;
case INTEGRATION_TYPE_RK_3RD: ret = "3rd rk"; break;
case INTEGRATION_TYPE_RK_4TH: ret = "4th rk"; break;
case INTEGRATION_TYPE_UNKNOWN: ret = "unknown"; break;
}
return ret;
}
std::string
integrationTypeToMenuName(IntegrationType it)
{
std::string ret;
switch (it) {
case INTEGRATION_TYPE_FWD_EULER: ret = "Forward Euler"; break;
case INTEGRATION_TYPE_RK_2ND: ret = "Second-Order Runge-Kutta"; break;
case INTEGRATION_TYPE_RK_3RD: ret = "Third-Order Runge-Kutta"; break;
case INTEGRATION_TYPE_RK_4TH: ret = "Fourth-Order Runge-Kutta"; break;
case INTEGRATION_TYPE_UNKNOWN: ret = "Unknown"; break;
}
return ret;
}
IntegrationType
stringToIntegrationType(const std::string& s)
{
IntegrationType ret = INTEGRATION_TYPE_UNKNOWN;
std::string str = s;
hboost::trim(str);
hboost::to_lower(str);
if (str == integrationTypeToString(INTEGRATION_TYPE_FWD_EULER)) {
ret = INTEGRATION_TYPE_FWD_EULER;
} else if (str == integrationTypeToString(INTEGRATION_TYPE_RK_2ND)) {
ret = INTEGRATION_TYPE_RK_2ND;
} else if (str == integrationTypeToString(INTEGRATION_TYPE_RK_3RD)) {
ret = INTEGRATION_TYPE_RK_3RD;
} else if (str == integrationTypeToString(INTEGRATION_TYPE_RK_4TH)) {
ret = INTEGRATION_TYPE_RK_4TH;
}
return ret;
}
struct AdvectionParms
{
AdvectionParms(GU_Detail *outputGeo)
: mOutputGeo(outputGeo)
, mPointGeo(nullptr)
, mPointGroup(nullptr)
, mOffsetsToSkip()
, mIncludeGroups()
, mExcludeGroups()
, mVelPrim(nullptr)
, mCptPrim(nullptr)
, mPropagationType(PROPAGATION_TYPE_ADVECTION)
, mIntegrationType(INTEGRATION_TYPE_FWD_EULER)
, mTimeStep(1.0)
, mIterations(1)
, mSteps(1)
, mStaggered(false)
, mStreamlines(false)
{
}
GU_Detail* mOutputGeo;
const GU_Detail* mPointGeo;
const GA_PointGroup* mPointGroup;
std::vector<GA_Offset> mOffsetsToSkip;
std::vector<std::string> mIncludeGroups;
std::vector<std::string> mExcludeGroups;
const GU_PrimVDB *mVelPrim;
const GU_PrimVDB *mCptPrim;
PropagationType mPropagationType;
IntegrationType mIntegrationType;
double mTimeStep;
int mIterations, mSteps;
bool mStaggered, mStreamlines;
};
/// @brief Creates a new line segment for each point in @c ptnGeo
/// @note The lines will only have one node.
void
createNewLines(GU_Detail& geo, const GA_PointGroup* group)
{
GA_SplittableRange ptnRange(geo.getPointRange(group));
GA_Offset start, end, pt;
for (GA_PageIterator pIt = ptnRange.beginPages(); !pIt.atEnd(); ++pIt) {
for (GA_Iterator it(pIt.begin()); it.blockAdvance(start, end); ) {
for (GA_Offset i = start; i < end; ++i) {
pt = geo.appendPointOffset();
geo.setPos3(pt, geo.getPos3(i));
GU_PrimPoly& prim = *GU_PrimPoly::build(&geo, 0, GU_POLY_OPEN, 0);
prim.appendVertex(pt);
}
}
}
}
/// @brief Append a new node to each line.
/// @note The numbers of lines and points have to match.
void
appendLineNodes(GU_Detail& geo, GA_Size firstline, const GU_Detail& ptnGeo)
{
GA_SplittableRange ptnRange(ptnGeo.getPointRange());
GA_Offset start, end, pt;
GA_Size n = firstline, N = geo.getNumPrimitives();
for (GA_PageIterator pIt = ptnRange.beginPages(); !pIt.atEnd(); ++pIt) {
for (GA_Iterator it(pIt.begin()); it.blockAdvance(start, end); ) {
for (GA_Offset i = start; i < end; ++i) {
pt = geo.appendPointOffset();
geo.setPos3(pt, ptnGeo.getPos3(i));
GA_Offset offset = geo.primitiveOffset(n);
GU_PrimPoly& prim = *static_cast<GU_PrimPoly*>(
geo.getPrimitiveList().get(offset));
prim.appendVertex(pt);
if (++n == N) break;
}
if (n == N) break;
}
if (n == N) break;
}
}
// Threaded closest point projection
template<typename GridType>
class ProjectionOp
{
using ProjectorType = openvdb::tools::ClosestPointProjector<GridType>;
using VectorType = typename GridType::ValueType;
using ElementType = typename VectorType::ValueType;
public:
ProjectionOp(const GridType& cptGrid, int cptIterations, GU_Detail& geo,
const std::vector<GA_Offset>& offsetsToSkip, hvdb::Interrupter& boss)
: mProjector(cptGrid, cptIterations)
, mGeo(geo)
, mOffsetsToSkip(offsetsToSkip)
, mBoss(boss)
{
}
void operator()(const GA_SplittableRange &range) const
{
GA_Offset start, end;
UT_Vector3 p;
VectorType w;
for (GA_PageIterator pIt = range.beginPages(); !pIt.atEnd(); ++pIt) {
if (mBoss.wasInterrupted()) return;
for (GA_Iterator it(pIt.begin()); it.blockAdvance(start, end); ) {
if (mBoss.wasInterrupted()) return;
for (GA_Offset i = start; i < end; ++i) {
// skip any offsets requested
if (std::binary_search(mOffsetsToSkip.begin(), mOffsetsToSkip.end(), i)) {
continue;
}
p = mGeo.getPos3(i);
w[0] = ElementType(p[0]);
w[1] = ElementType(p[1]);
w[2] = ElementType(p[2]);
mProjector.projectToConstraintSurface(w);
p[0] = UT_Vector3::value_type(w[0]);
p[1] = UT_Vector3::value_type(w[1]);
p[2] = UT_Vector3::value_type(w[2]);
mGeo.setPos3(i, p);
}
}
}
}
private:
ProjectorType mProjector;
GU_Detail& mGeo;
const std::vector<GA_Offset>& mOffsetsToSkip;
hvdb::Interrupter& mBoss;
};
class Projection
{
public:
Projection(AdvectionParms& parms, hvdb::Interrupter& boss)
: mParms(parms)
, mBoss(boss)
{
}
template<typename GridType>
void operator()(const GridType& grid)
{
if (mBoss.wasInterrupted()) return;
ProjectionOp<GridType> op(
grid, mParms.mIterations, *mParms.mOutputGeo, mParms.mOffsetsToSkip, mBoss);
UTparallelFor(GA_SplittableRange(mParms.mOutputGeo->getPointRange(mParms.mPointGroup)), op);
}
private:
AdvectionParms& mParms;
hvdb::Interrupter& mBoss;
};
// Threaded point advection
template<typename GridType, int IntegrationOrder, bool StaggeredVelocity, bool Constrained = false>
class AdvectionOp
{
using IntegrationType = openvdb::tools::VelocityIntegrator<GridType, StaggeredVelocity>;
using ProjectorType =
openvdb::tools::ClosestPointProjector<GridType>; // Used for constrained advection
using VectorType = typename GridType::ValueType;
using ElementType = typename VectorType::ValueType;
public:
AdvectionOp(const GridType& velocityGrid, GU_Detail& geo,
const std::vector<GA_Offset>& offsetsToSkip, hvdb::Interrupter& boss,
double timeStep, GA_ROHandleF traillen, int steps)
: mVelocityGrid(velocityGrid)
, mCptGrid(nullptr)
, mGeo(geo)
, mOffsetsToSkip(offsetsToSkip)
, mBoss(boss)
, mTimeStep(timeStep)
, mTrailLen(traillen)
, mSteps(steps)
, mCptIterations(0)
{
}
AdvectionOp(const GridType& velocityGrid, const GridType& cptGrid, GU_Detail& geo,
const std::vector<GA_Offset>& offsetsToSkip, hvdb::Interrupter& boss,
double timeStep, int steps, int cptIterations)
: mVelocityGrid(velocityGrid)
, mCptGrid(&cptGrid)
, mGeo(geo)
, mOffsetsToSkip(offsetsToSkip)
, mBoss(boss)
, mTimeStep(timeStep)
, mSteps(steps)
, mCptIterations(cptIterations)
{
}
void operator()(const GA_SplittableRange &range) const
{
GA_Offset start, end;
UT_Vector3 p;
VectorType w;
IntegrationType integrator(mVelocityGrid);
// Constrained-advection compiled out if Constrained == false
UT_UniquePtr<ProjectorType> projector;
if (Constrained && mCptGrid != nullptr) {
projector.reset(new ProjectorType(*mCptGrid, mCptIterations));
}
for (GA_PageIterator pIt = range.beginPages(); !pIt.atEnd(); ++pIt) {
if (mBoss.wasInterrupted()) return;
for (GA_Iterator it(pIt.begin()); it.blockAdvance(start, end); ) {
if (mBoss.wasInterrupted()) return;
for (GA_Offset i = start; i < end; ++i) {
// skip any point offsets requested
if (std::binary_search(mOffsetsToSkip.begin(), mOffsetsToSkip.end(), i)) {
continue;
}
p = mGeo.getPos3(i);
w[0] = ElementType(p[0]);
w[1] = ElementType(p[1]);
w[2] = ElementType(p[2]);
ElementType timestep = static_cast<ElementType>(mTimeStep);
if (mTrailLen.isValid()) {
timestep *= static_cast<ElementType>(mTrailLen.get(i));
}
for (int n = 0; n < mSteps; ++n) {
integrator.template rungeKutta<IntegrationOrder, VectorType>(timestep, w);
if (Constrained) projector->projectToConstraintSurface(w);
}
p[0] = UT_Vector3::value_type(w[0]);
p[1] = UT_Vector3::value_type(w[1]);
p[2] = UT_Vector3::value_type(w[2]);
mGeo.setPos3(i, p);
}
}
}
}
private:
const GridType& mVelocityGrid;
const GridType* mCptGrid;
GU_Detail& mGeo;
const std::vector<GA_Offset>& mOffsetsToSkip;
hvdb::Interrupter& mBoss;
double mTimeStep;
GA_ROHandleF mTrailLen;
const int mSteps, mCptIterations;
};
class Advection
{
public:
Advection(AdvectionParms& parms, hvdb::Interrupter& boss)
: mParms(parms)
, mBoss(boss)
{
}
template<typename GridType, int IntegrationOrder, bool StaggeredVelocity>
void advection(const GridType& velocityGrid)
{
if (mBoss.wasInterrupted()) return;
if (!mParms.mStreamlines) { // Advect points
GA_ROHandleF traillen_h(mParms.mOutputGeo, GA_ATTRIB_POINT, "traillen");
AdvectionOp<GridType, IntegrationOrder, StaggeredVelocity>
op(velocityGrid, *mParms.mOutputGeo, mParms.mOffsetsToSkip,
mBoss, mParms.mTimeStep, traillen_h, mParms.mSteps);
UTparallelFor(
GA_SplittableRange(mParms.mOutputGeo->getPointRange(mParms.mPointGroup)), op);
} else { // Advect points and generate streamlines.
GA_Index firstline = mParms.mOutputGeo->getNumPrimitives();
GU_Detail geo;
geo.mergePoints(*mParms.mOutputGeo, mParms.mPointGroup);
createNewLines(*mParms.mOutputGeo, mParms.mPointGroup);
for (int n = 0; n < mParms.mSteps; ++n) {
if (mBoss.wasInterrupted()) return;
GA_ROHandleF traillen_h(&geo, GA_ATTRIB_POINT, "traillen");
AdvectionOp<GridType, IntegrationOrder, StaggeredVelocity>
op(velocityGrid, geo, mParms.mOffsetsToSkip, mBoss,
mParms.mTimeStep, traillen_h, 1);
UTparallelFor(GA_SplittableRange(geo.getPointRange()), op);
appendLineNodes(*mParms.mOutputGeo, firstline, geo);
}
}
}
template<typename GridType, int IntegrationOrder, bool StaggeredVelocity>
void constrainedAdvection(const GridType& velocityGrid)
{
const GridType& cptGrid = static_cast<const GridType&>(mParms.mCptPrim->getGrid());
using AdvectionOp =
AdvectionOp<GridType, IntegrationOrder, StaggeredVelocity, /*Constrained*/true>;
if (mBoss.wasInterrupted()) return;
if (!mParms.mStreamlines) { // Advect points
AdvectionOp op(velocityGrid, cptGrid, *mParms.mOutputGeo, mParms.mOffsetsToSkip,
mBoss, mParms.mTimeStep, mParms.mSteps, mParms.mIterations);
UTparallelFor(
GA_SplittableRange(mParms.mOutputGeo->getPointRange(mParms.mPointGroup)), op);
} else { // Advect points and generate streamlines.
GA_Index firstline = mParms.mOutputGeo->getNumPrimitives();
GU_Detail geo;
geo.mergePoints(*mParms.mOutputGeo, mParms.mPointGroup);
createNewLines(*mParms.mOutputGeo, mParms.mPointGroup);
for (int n = 0; n < mParms.mSteps; ++n) {
if (mBoss.wasInterrupted()) return;
AdvectionOp op(velocityGrid, cptGrid, geo, mParms.mOffsetsToSkip,
mBoss, mParms.mTimeStep, 1, mParms.mIterations);
UTparallelFor(GA_SplittableRange(geo.getPointRange()), op);
appendLineNodes(*mParms.mOutputGeo, firstline, geo);
}
}
}
// Resolves velocity representation and advection type
template<typename GridType, int IntegrationOrder>
void resolveAdvection(const GridType& velocityGrid)
{
if (mBoss.wasInterrupted()) return;
if (mParms.mPropagationType == PROPAGATION_TYPE_ADVECTION) {
if (!mParms.mStaggered) advection<GridType, IntegrationOrder, false>(velocityGrid);
else advection<GridType, IntegrationOrder, true>(velocityGrid);
} else if (mParms.mCptPrim != nullptr) { // constrained
if (!mParms.mStaggered) {
constrainedAdvection<GridType, IntegrationOrder, false>(velocityGrid);
} else {
constrainedAdvection<GridType, IntegrationOrder, true>(velocityGrid);
}
}
}
template<typename GridType>
void operator()(const GridType& velocityGrid)
{
if (mBoss.wasInterrupted()) return;
// Resolve integration order
switch (mParms.mIntegrationType) {
case INTEGRATION_TYPE_FWD_EULER: resolveAdvection<GridType, 1>(velocityGrid); break;
case INTEGRATION_TYPE_RK_2ND: resolveAdvection<GridType, 2>(velocityGrid); break;
case INTEGRATION_TYPE_RK_3RD: resolveAdvection<GridType, 3>(velocityGrid); break;
case INTEGRATION_TYPE_RK_4TH: resolveAdvection<GridType, 4>(velocityGrid); break;
case INTEGRATION_TYPE_UNKNOWN: break;
}
}
private:
AdvectionParms& mParms;
hvdb::Interrupter& mBoss;
};
template <typename PointDataGridT>
class VDBPointsAdvection
{
public:
VDBPointsAdvection(PointDataGridT& outputGrid, AdvectionParms& parms, hvdb::Interrupter& boss)
: mOutputGrid(outputGrid)
, mParms(parms)
, mBoss(boss)
{
}
template<typename GridType>
void operator()(const GridType& velocityGrid)
{
if (mBoss.wasInterrupted()) return;
// note that streamlines are not implemented for VDB Points
if (mParms.mStreamlines) return;
auto leaf = mOutputGrid.constTree().cbeginLeaf();
if (!leaf) return;
openvdb::points::MultiGroupFilter filter(
mParms.mIncludeGroups, mParms.mExcludeGroups, leaf->attributeSet());
openvdb::points::advectPoints(mOutputGrid, velocityGrid,
mParms.mIntegrationType+1, mParms.mTimeStep, mParms.mSteps, filter);
}
private:
PointDataGridT& mOutputGrid;
AdvectionParms& mParms;
hvdb::Interrupter& mBoss;
};
} // namespace
////////////////////////////////////////
// SOP Declaration
class SOP_OpenVDB_Advect_Points: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Advect_Points(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Advect_Points() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i ) const override { return (i > 0); }
class Cache: public SOP_VDBCacheOptions
{
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
bool evalAdvectionParms(OP_Context&, AdvectionParms&);
}; // class Cache
protected:
void resolveObsoleteParms(PRM_ParmList*) override;
bool updateParmsFlags() override;
};
////////////////////////////////////////
// Build UI and register this operator
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Points to process
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Point Group")
.setChoiceList(&SOP_Node::pointGroupMenu)
.setTooltip("A subset of points in the first input to move using the velocity field."));
// VDB Points advection
parms.add(hutil::ParmFactory(PRM_TOGGLE, "advectvdbpoints", "Advect VDB Points")
.setDefault(PRMoneDefaults)
.setTooltip("Enable/disable advection of VDB Points.")
.setDocumentation(
"If enabled, advect the points in a VDB Points grid, otherwise apply advection"
" only to the Houdini point associated with the VDB primitive.\n\n"
"The latter is faster to compute but updates the VDB transform only"
" and not the relative positions of the points within the grid."
" It is useful primarily when instancing multiple static VDB point sets"
" onto a dynamically advected Houdini point set."));
parms.add(hutil::ParmFactory(PRM_STRING, "vdbgroup", "VDB Primitive Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("A subset of VDB Points primitives in the first input to move using the velocity field."));
parms.add(hutil::ParmFactory(PRM_STRING, "vdbpointsgroups", "VDB Points Groups")
.setHelpText("Specify VDB Points groups to advect.")
.setChoiceList(&hvdb::VDBPointsGroupMenuInput1));
// Velocity grid
parms.add(hutil::ParmFactory(PRM_STRING, "velgroup", "Velocity VDB")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("Velocity grid")
.setDocumentation(
"The name of a VDB primitive in the second input to use as"
" the velocity field (see [specifying volumes|/model/volumes#group])\n\n"
"This must be a vector-valued VDB primitive."
" You can use the [Vector Merge node|Node:sop/DW_OpenVDBVectorMerge]"
" to turn a `vel.[xyz]` triple into a single primitive."));
// Closest point grid
parms.add(hutil::ParmFactory(PRM_STRING, "cptgroup", "Closest-Point VDB")
.setChoiceList(&hutil::PrimGroupMenuInput3)
.setTooltip("Vector grid that in each voxel stores the closest point on a surface.")
.setDocumentation(
"The name of a VDB primitive in the third input to use for"
" the closest point values (see [specifying volumes|/model/volumes#group])"));
// Propagation scheme
{
std::vector<std::string> items;
for (int i = 0; i < NUM_PROPAGATION_TYPES; ++i) {
PropagationType pt = PropagationType(i);
items.push_back(propagationTypeToString(pt)); // token
items.push_back(propagationTypeToMenuName(pt)); // label
}
parms.add(hutil::ParmFactory(PRM_STRING, "operation", "Operation")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(items[0])
.setTooltip(
"Advection: Move the point along the velocity field.\n"
"Projection: Move the point to the nearest surface point.\n"
"Constrained Advection: Advect, then project to the nearest surface point.")
.setDocumentation(
"How to use the velocity field to move the points\n\n"
"Advection:\n"
" Move each point along the velocity field.\n"
"Projection:\n"
" Move each point to the nearest surface point using the closest point field.\n"
"Constrained Advection:\n"
" Move the along the velocity field, and then project using the"
" closest point field. This forces the particles to remain on a surface."));
}
// Integration scheme
{
std::vector<std::string> items;
for (int i = 0; i < NUM_INTEGRATION_TYPES; ++i) {
IntegrationType it = IntegrationType(i);
items.push_back(integrationTypeToString(it)); // token
items.push_back(integrationTypeToMenuName(it)); // label
}
parms.add(hutil::ParmFactory(PRM_STRING, "integration", "Integration")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setDefault(items[0])
.setTooltip("Lower order means faster performance, "
"but the points will not follow the velocity field closely.")
.setDocumentation("Algorithm to use to move the points\n\n"
"Later options in the list are slower but better follow the velocity field."));
}
// Closest point iterations
parms.add(hutil::ParmFactory(PRM_INT_J, "iterations", "Iterations")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip("The interpolation step when sampling nearest points introduces\n"
"error so that the result of a single sample may not lie exactly\n"
"on the surface. Multiple iterations help minimize this error.")
.setDocumentation(
"Number of times to try projecting to the nearest point on the surface\n\n"
"Projecting might not move exactly to the surface on the first try."
" More iterations are slower but give more accurate projection."));
// Time step
parms.add(hutil::ParmFactory(PRM_FLT, "timestep", "Timestep")
.setDefault(1, "1.0/$FPS")
.setRange(PRM_RANGE_UI, 0, PRM_RANGE_UI, 10)
.setDocumentation(
"Number of seconds of movement to apply to the input points\n\n"
"The default is `1/$FPS` (one frame's worth of time)."
" You can use negative values to move the points backwards through"
" the velocity field.\n\n"
"If the attribute `traillen` is present, it is multiplied by this"
" time step allowing per-particle variation in trail length."));
// Steps
parms.add(hutil::ParmFactory(PRM_INT_J, "steps", "Substeps")
.setDefault(1)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip("Number of timesteps to take per frame.")
.setDocumentation(
"How many times to repeat the advection step\n\n"
"This will produce a more accurate motion, especially if large"
" time steps or high velocities are present."));
// Output streamlines
parms.add(hutil::ParmFactory(PRM_TOGGLE, "outputstreamlines", "Output Streamlines")
.setDefault(PRMzeroDefaults)
.setTooltip("Output the particle path as line segments.")
.setDocumentation(
"Generate polylines instead of moving points.\n\n"
"This is useful for visualizing the effect of the node."
" It may also be useful for special effects (see also the"
" [Trail SOP|Node:sop/trail])."));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "staggered", "Staggered Velocities"));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep1", "Sep"));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep2", "Sep"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "ptnGroup", "Point Group"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "velGroup", "Velocity VDB"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "cptGroup", "Closest-Point VDB"));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "propagation", "Operation")
.setDefault("advection"));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "cptIterations", "Iterations")
.setDefault(PRMzeroDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT, "timeStep", "Time Step")
.setDefault(1, "1.0/$FPS"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "outputStreamlines", "Output Streamlines")
.setDefault(PRMzeroDefaults));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Advect Points",
SOP_OpenVDB_Advect_Points::factory, parms, *table)
.setObsoleteParms(obsoleteParms)
.addInput("Points to Advect")
.addOptionalInput("Velocity VDB")
.addOptionalInput("Closest Point VDB")
.setVerb(SOP_NodeVerb::COOK_DUPLICATE,
[]() { return new SOP_OpenVDB_Advect_Points::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Move points in the input geometry along a VDB velocity field.\"\"\"\n\
\n\
@overview\n\
\n\
This node has different functions based on the value of the __Operation__ parameter.\n\
* Move geometry points according to a VDB velocity field.\n\
* Move points onto a surface using a VDB field storing the nearest surface point at each voxel.\n\
# Convert the \"sticky\" surface to a VDB SDF using the\n\
[OpenVDB From Polygons node|Node:sop/DW_OpenVDBFromPolygons].\n\
# Generate a \"nearest point\" VDB using the \n\
[OpenVDB Analysis node|Node:sop/DW_OpenVDBAnalysis].\n\
# Connect the points you want to stick, and the \"nearest point\" field,\n\
into this node.\n\
* Move geometry points according to a VDB velocity field _and_ stick them\n\
to a surface using a \"nearest point\" field (combine the first two operations).\n\
This lets you advect points through a velocity field while keeping them\n\
stuck to a surface.\n\
\n\
NOTE:\n\
The `traillen` float attribute can be used to control how far particles\n\
move on a per-particle basis.\n\
\n\
@animation Animating advection\n\
\n\
*This node is not a feedback loop*.\n\
It moves the points it finds in the input geometry. It _cannot_ modify\n\
the point locations over time. (That is, if you hook this node up to do advection\n\
and press play, the points will not animate.)\n\
\n\
To set up a feedback loop, where the advection at each frame affects\n\
the advected point positions from the previous frame, do one of the following:\n\
\n\
* Do the advection inside a [SOP Solver|Node:sop/solver].\n\
* Set __Substeps__ to `$F` and the __Time Step__ to `$T`\n\
\n\
This will cause the node to recalculate, _at every frame_, the path\n\
of every particle through _every previous frame_ to get the current one.\n\
This is obviously not very practical, however the calculations are fast\n\
so it may be useful as a quick \"hack\" to animate the advection\n\
for small numbers of particles.\n\
\n\
@inputs\n\
Points to Advect:\n\
The points to advect are copied from this input.\n\
Velocity VDB:\n\
The VDB that stores the velocity at each location\n\
Closest Point VDB:\n\
The VDB that stores the closest point to each location\n\
\n\
@related\n\
- [OpenVDB Advect|Node:sop/DW_OpenVDBAdvect]\n\
- [OpenVDB From Particles|Node:sop/DW_OpenVDBFromParticles]\n\
- [Node:sop/vdbadvectpoints]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Advect_Points::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
resolveRenamedParm(*obsoleteParms, "cptGroup", "cptgroup");
resolveRenamedParm(*obsoleteParms, "cptIterations", "iterations");
resolveRenamedParm(*obsoleteParms, "outputStreamlines", "outputstreamlines");
resolveRenamedParm(*obsoleteParms, "propagation", "operation");
resolveRenamedParm(*obsoleteParms, "ptnGroup", "group");
resolveRenamedParm(*obsoleteParms, "timeStep", "timestep");
resolveRenamedParm(*obsoleteParms, "velGroup", "velgroup");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
// Enable/disable or show/hide parameters in the UI.
bool
SOP_OpenVDB_Advect_Points::updateParmsFlags()
{
bool changed = false;
const auto op = stringToPropagationType(evalStdString("operation", 0));
const bool advectVdbPoints = (0 != evalInt("advectvdbpoints", 0, 0));
changed |= enableParm("iterations", op != PROPAGATION_TYPE_ADVECTION);
changed |= enableParm("integration", op != PROPAGATION_TYPE_PROJECTION);
changed |= enableParm("timestep", op != PROPAGATION_TYPE_PROJECTION);
changed |= enableParm("steps", op != PROPAGATION_TYPE_PROJECTION);
changed |= enableParm("outputstreamlines", op != PROPAGATION_TYPE_PROJECTION);
changed |= enableParm("advectvdbpoints", op == PROPAGATION_TYPE_ADVECTION);
changed |= enableParm("vdbgroup", (op == PROPAGATION_TYPE_ADVECTION) && advectVdbPoints);
changed |= enableParm("vdbpointsgroups", (op == PROPAGATION_TYPE_ADVECTION) && advectVdbPoints);
changed |= setVisibleState("iterations", getEnableState("iterations"));
changed |= setVisibleState("integration", getEnableState("integration"));
changed |= setVisibleState("timestep", getEnableState("timestep"));
changed |= setVisibleState("steps", getEnableState("steps"));
changed |= setVisibleState("outputstreamlines", getEnableState("outputstreamlines"));
changed |= setVisibleState("advectvdbpoints", getEnableState("advectvdbpoints"));
changed |= setVisibleState("vdbgroup", getEnableState("advectvdbpoints"));
changed |= setVisibleState("vdbpointsgroups", getEnableState("advectvdbpoints"));
return changed;
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Advect_Points::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Advect_Points(net, name, op);
}
SOP_OpenVDB_Advect_Points::SOP_OpenVDB_Advect_Points(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Advect_Points::Cache::cookVDBSop(OP_Context& context)
{
try {
// Evaluate UI parameters
const fpreal now = context.getTime();
AdvectionParms parms(gdp);
if (!evalAdvectionParms(context, parms)) return error();
const bool advectVdbPoints = (0 != evalInt("advectvdbpoints", 0, now));
hvdb::Interrupter boss("Processing points");
if (advectVdbPoints) {
// build a list of point offsets to skip during Houdini point advection
for (hvdb::VdbPrimIterator vdbIt(gdp); vdbIt; ++vdbIt) {
GU_PrimVDB* vdbPrim = *vdbIt;
parms.mOffsetsToSkip.push_back(vdbPrim->getPointOffset(0));
}
// ensure the offsets to skip are sorted to make lookups faster
std::sort(parms.mOffsetsToSkip.begin(), parms.mOffsetsToSkip.end());
const std::string vdbGroupStr = evalStdString("vdbgroup", now);
const GA_PrimitiveGroup* vdbGroup = matchGroup(*parms.mPointGeo, vdbGroupStr);
for (hvdb::VdbPrimIterator vdbIt(gdp, vdbGroup); vdbIt; ++vdbIt) {
GU_PrimVDB* vdbPrim = *vdbIt;
// only process if grid is a PointDataGrid with leaves
if (!openvdb::gridConstPtrCast<openvdb::points::PointDataGrid>(
vdbPrim->getConstGridPtr())) continue;
auto&& pointDataGrid =
UTvdbGridCast<openvdb::points::PointDataGrid>(vdbPrim->getConstGrid());
auto leafIter = pointDataGrid.tree().cbeginLeaf();
if (!leafIter) continue;
// deep copy the VDB tree if it is not already unique
vdbPrim->makeGridUnique();
auto&& outputGrid =
UTvdbGridCast<openvdb::points::PointDataGrid>(vdbPrim->getGrid());
switch (parms.mPropagationType) {
case PROPAGATION_TYPE_ADVECTION:
case PROPAGATION_TYPE_CONSTRAINED_ADVECTION:
{
VDBPointsAdvection<openvdb::points::PointDataGrid> advection(
outputGrid, parms, boss);
hvdb::GEOvdbApply<hvdb::Vec3GridTypes>(*parms.mVelPrim, advection);
break;
}
case PROPAGATION_TYPE_PROJECTION: break; // not implemented
case PROPAGATION_TYPE_UNKNOWN: break;
}
}
}
switch (parms.mPropagationType) {
case PROPAGATION_TYPE_ADVECTION:
case PROPAGATION_TYPE_CONSTRAINED_ADVECTION:
{
Advection advection(parms, boss);
hvdb::GEOvdbApply<hvdb::Vec3GridTypes>(*parms.mVelPrim, advection);
break;
}
case PROPAGATION_TYPE_PROJECTION:
{
Projection projection(parms, boss);
hvdb::GEOvdbApply<hvdb::Vec3GridTypes>(*parms.mVelPrim, projection);
break;
}
case PROPAGATION_TYPE_UNKNOWN: break;
}
if (boss.wasInterrupted()) addWarning(SOP_MESSAGE, "processing was interrupted");
boss.end();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
////////////////////////////////////////
bool
SOP_OpenVDB_Advect_Points::Cache::evalAdvectionParms(
OP_Context& context, AdvectionParms& parms)
{
const fpreal now = context.getTime();
parms.mPointGeo = inputGeo(0);
if (!parms.mPointGeo) {
addError(SOP_MESSAGE, "Missing point input");
return false;
}
UT_String ptGroupStr;
evalString(ptGroupStr, "group", 0, now);
parms.mPointGroup = parsePointGroups(ptGroupStr, GroupCreator(gdp));
const bool advectVdbPoints = (0 != evalInt("advectvdbpoints", 0, now));
if (advectVdbPoints) {
const std::string groups = evalStdString("vdbpointsgroups", now);
// Get and parse the vdb points groups
openvdb::points::AttributeSet::Descriptor::parseNames(
parms.mIncludeGroups, parms.mExcludeGroups, groups);
}
if (!parms.mPointGroup && ptGroupStr.length() > 0) {
addWarning(SOP_MESSAGE, "Point group not found");
return false;
}
parms.mPropagationType = stringToPropagationType(evalStdString("operation", now));
if (parms.mPropagationType == PROPAGATION_TYPE_UNKNOWN) {
addError(SOP_MESSAGE, "Unknown propargation scheme");
return false;
}
if (parms.mPropagationType == PROPAGATION_TYPE_ADVECTION ||
parms.mPropagationType == PROPAGATION_TYPE_CONSTRAINED_ADVECTION) {
const GU_Detail* velGeo = inputGeo(1);
if (!velGeo) {
addError(SOP_MESSAGE, "Missing velocity grid input");
return false;
}
const GA_PrimitiveGroup* velGroup = matchGroup(*velGeo, evalStdString("velgroup", now));
hvdb::VdbPrimCIterator it(velGeo, velGroup);
parms.mVelPrim = *it;
if (!parms.mVelPrim) {
addError(SOP_MESSAGE, "Missing velocity grid");
return false;
}
if (parms.mVelPrim->getStorageType() != UT_VDB_VEC3F) {
addError(SOP_MESSAGE, "Expected velocity grid to be of type Vec3f");
return false;
}
// Check if the velocity grid uses a staggered representation.
parms.mStaggered =
parms.mVelPrim->getGrid().getGridClass() == openvdb::GRID_STAGGERED;
parms.mTimeStep = static_cast<float>(evalFloat("timestep", 0, now));
parms.mSteps = static_cast<int>(evalInt("steps", 0, now));
// The underlying code will accumulate, so to make it substeps
// we need to divide out.
parms.mTimeStep /= static_cast<float>(parms.mSteps);
parms.mStreamlines = bool(evalInt("outputstreamlines", 0, now));
parms.mIntegrationType = stringToIntegrationType(evalStdString("integration", now));
if (parms.mIntegrationType == INTEGRATION_TYPE_UNKNOWN) {
addError(SOP_MESSAGE, "Unknown integration scheme");
return false;
}
}
if (parms.mPropagationType == PROPAGATION_TYPE_PROJECTION ||
parms.mPropagationType == PROPAGATION_TYPE_CONSTRAINED_ADVECTION) {
const GU_Detail* cptGeo = inputGeo(2);
if (!cptGeo) {
addError(SOP_MESSAGE, "Missing closest point grid input");
return false;
}
const GA_PrimitiveGroup *cptGroup = matchGroup(*cptGeo, evalStdString("cptgroup", now));
hvdb::VdbPrimCIterator it(cptGeo, cptGroup);
parms.mCptPrim = *it;
if (!parms.mCptPrim) {
addError(SOP_MESSAGE, "Missing closest point grid");
return false;
}
if (parms.mCptPrim->getStorageType() != UT_VDB_VEC3F) {
addError(SOP_MESSAGE, "Expected closest point grid to be of type Vec3f");
return false;
}
parms.mIterations = static_cast<int>(evalInt("iterations", 0, now));
}
return true;
}
| 40,963 | C++ | 34.559028 | 111 | 0.626956 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/VRAY_OpenVDB_Points.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file VRAY_OpenVDB_Points.cc
///
/// @authors Dan Bailey, Richard Kwok
///
/// @brief The Delayed Load Mantra Procedural for OpenVDB Points.
#include <UT/UT_Version.h>
#include <UT/UT_DSOVersion.h>
#include <GU/GU_Detail.h>
#include <OP/OP_OperatorTable.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Ramp.h>
#include <VRAY/VRAY_Procedural.h>
#include <VRAY/VRAY_ProceduralFactory.h>
#include <openvdb/openvdb.h>
#include <openvdb/io/File.h>
#include <openvdb/openvdb.h>
#include <openvdb/points/PointDataGrid.h>
#include <openvdb/points/PointGroup.h>
#include <openvdb_houdini/PointUtils.h>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
using namespace openvdb;
using namespace openvdb::points;
namespace hvdb = openvdb_houdini;
// mantra renders points with a world-space radius of 0.05 by default
static const float DEFAULT_PSCALE = 0.05f;
class VRAY_OpenVDB_Points : public VRAY_Procedural {
public:
using GridVecPtr = std::vector<PointDataGrid::Ptr>;
VRAY_OpenVDB_Points();
~VRAY_OpenVDB_Points() override = default;
const char* className() const override;
int initialize(const UT_BoundingBox*) override;
void getBoundingBox(UT_BoundingBox&) override;
void render() override;
private:
UT_BoundingBox mBox;
UT_StringHolder mFilename;
std::vector<Name> mIncludeGroups;
std::vector<Name> mExcludeGroups;
UT_StringHolder mAttrStr;
GridVecPtr mGridPtrs;
float mPreBlur;
float mPostBlur;
bool mSpeedToColor;
float mMaxSpeed;
UT_Ramp mFunctionRamp;
}; // class VRAY_OpenVDB_Points
////////////////////////////////////////
template <typename PointDataTreeT>
struct GenerateBBoxOp {
using PointDataLeaf = typename PointDataTreeT::LeafNodeType;
using LeafRangeT = typename tree::LeafManager<const PointDataTreeT>::LeafRange;
GenerateBBoxOp( const math::Transform& transform,
const std::vector<Name>& includeGroups,
const std::vector<Name>& excludeGroups)
: mTransform(transform)
, mIncludeGroups(includeGroups)
, mExcludeGroups(excludeGroups) { }
GenerateBBoxOp(const GenerateBBoxOp& parent, tbb::split)
: mTransform(parent.mTransform)
, mBbox(parent.mBbox)
, mIncludeGroups(parent.mIncludeGroups)
, mExcludeGroups(parent.mExcludeGroups) { }
void operator()(const LeafRangeT& range) {
for (auto leafIter = range.begin(); leafIter; ++leafIter) {
const AttributeSet::Descriptor& descriptor = leafIter->attributeSet().descriptor();
size_t pscaleIndex = descriptor.find("pscale");
if (pscaleIndex != AttributeSet::INVALID_POS) {
std::string pscaleType = descriptor.type(pscaleIndex).first;
if (pscaleType == typeNameAsString<float>()) {
expandBBox<float>(*leafIter, pscaleIndex);
} else if (pscaleType == typeNameAsString<half>()) {
expandBBox<half>(*leafIter, pscaleIndex);
} else {
throw TypeError("Unsupported pscale type - " + pscaleType);
}
}
else {
// use default pscale value
expandBBox<float>(*leafIter, pscaleIndex);
}
}
}
void join(GenerateBBoxOp& rhs) {
mBbox.expand(rhs.mBbox);
}
template <typename PscaleType>
void expandBBox(const PointDataLeaf& leaf, size_t pscaleIndex) {
auto positionHandle =
points::AttributeHandle<Vec3f>::create(leaf.constAttributeArray("P"));
// expandBBox will not pick up a pscale handle unless
// the attribute type matches the template type
typename AttributeHandle<PscaleType>::Ptr pscaleHandle;
if (pscaleIndex != AttributeSet::INVALID_POS) {
if (leaf.attributeSet().descriptor().type(pscaleIndex).first
== typeNameAsString<PscaleType>())
{
pscaleHandle =
AttributeHandle<PscaleType>::create(leaf.constAttributeArray(pscaleIndex));
}
}
// uniform value is in world space
bool pscaleIsUniform = true;
PscaleType uniformPscale(DEFAULT_PSCALE);
if (pscaleHandle) {
pscaleIsUniform = pscaleHandle->isUniform();
uniformPscale = pscaleHandle->get(0);
}
// combine the bounds of every point on this leaf into an index-space bbox
if (!mIncludeGroups.empty() || !mExcludeGroups.empty()) {
points::MultiGroupFilter filter(mIncludeGroups, mExcludeGroups, leaf.attributeSet());
auto iter = leaf.beginIndexOn(filter);
for (; iter; ++iter) {
double pscale = double(pscaleIsUniform ? uniformPscale : pscaleHandle->get(*iter));
// pscale needs to be transformed to index space
Vec3d radius = mTransform.worldToIndex(Vec3d(pscale));
Vec3d position = iter.getCoord().asVec3d() + positionHandle->get(*iter);
mBbox.expand(position - radius);
mBbox.expand(position + radius);
}
}
else {
auto iter = leaf.beginIndexOn();
for (; iter; ++iter) {
double pscale = double(pscaleIsUniform ? uniformPscale : pscaleHandle->get(*iter));
// pscale needs to be transformed to index space
Vec3d radius = mTransform.worldToIndex(Vec3d(pscale));
Vec3d position = iter.getCoord().asVec3d() + positionHandle->get(*iter);
mBbox.expand(position - radius);
mBbox.expand(position + radius);
}
}
}
/////////////
const math::Transform& mTransform;
BBoxd mBbox;
const std::vector<Name>& mIncludeGroups;
const std::vector<Name>& mExcludeGroups;
}; // GenerateBBoxOp
//////////////////////////////////////
template <typename PointDataTreeT>
struct PopulateColorFromVelocityOp {
using LeafNode = typename PointDataTreeT::LeafNodeType;
using IndexOnIter = typename LeafNode::IndexOnIter;
using LeafManagerT = typename tree::LeafManager<PointDataTreeT>;
using LeafRangeT = typename LeafManagerT::LeafRange;
using MultiGroupFilter = points::MultiGroupFilter;
PopulateColorFromVelocityOp( const size_t colorIndex,
const size_t velocityIndex,
const UT_Ramp& ramp,
const float maxSpeed,
const std::vector<Name>& includeGroups,
const std::vector<Name>& excludeGroups)
: mColorIndex(colorIndex)
, mVelocityIndex(velocityIndex)
, mRamp(ramp)
, mMaxSpeed(maxSpeed)
, mIncludeGroups(includeGroups)
, mExcludeGroups(excludeGroups) { }
Vec3f getColorFromRamp(const Vec3f& velocity) const{
float proportionalSpeed = (mMaxSpeed == 0.0f ? 0.0f : velocity.length()/mMaxSpeed);
if (proportionalSpeed > 1.0f) proportionalSpeed = 1.0f;
if (proportionalSpeed < 0.0f) proportionalSpeed = 0.0f;
float rampVal[4];
mRamp.rampLookup(proportionalSpeed, rampVal);
return Vec3f(rampVal[0], rampVal[1], rampVal[2]);
}
void operator()(LeafRangeT& range) const{
for (auto leafIter = range.begin(); leafIter; ++leafIter) {
auto& leaf = *leafIter;
auto colorHandle =
points::AttributeWriteHandle<Vec3f>::create(leaf.attributeArray(mColorIndex));
auto velocityHandle =
points::AttributeHandle<Vec3f>::create(leaf.constAttributeArray(mVelocityIndex));
const bool uniform = velocityHandle->isUniform();
const Vec3f uniformColor = getColorFromRamp(velocityHandle->get(0));
MultiGroupFilter filter(mIncludeGroups, mExcludeGroups, leaf.attributeSet());
if (filter.state() == points::index::ALL) {
for (auto iter = leaf.beginIndexOn(); iter; ++iter) {
Vec3f color = uniform ?
uniformColor : getColorFromRamp(velocityHandle->get(*iter));
colorHandle->set(*iter, color);
}
}
else {
for (auto iter = leaf.beginIndexOn(filter); iter; ++iter) {
Vec3f color = uniform ?
uniformColor : getColorFromRamp(velocityHandle->get(*iter));
colorHandle->set(*iter, color);
}
}
}
}
//////////////////////////////////////////////
const size_t mColorIndex;
const size_t mVelocityIndex;
const UT_Ramp& mRamp;
const float mMaxSpeed;
const std::vector<Name>& mIncludeGroups;
const std::vector<Name>& mExcludeGroups;
};
////////////////////////////////////////////
namespace {
template <typename PointDataGridT>
inline BBoxd
getBoundingBox( const std::vector<typename PointDataGridT::Ptr>& gridPtrs,
const std::vector<Name>& includeGroups,
const std::vector<Name>& excludeGroups)
{
using PointDataTree = typename PointDataGridT::TreeType;
BBoxd worldBounds;
for (const auto& grid : gridPtrs) {
tree::LeafManager<const PointDataTree> leafManager(grid->tree());
// size and combine the boxes for each leaf in the tree via a reduction
GenerateBBoxOp<PointDataTree> generateBbox(grid->transform(), includeGroups, excludeGroups);
tbb::parallel_reduce(leafManager.leafRange(), generateBbox);
if (generateBbox.mBbox.empty()) continue;
// all the bounds must be unioned in world space
BBoxd gridBounds = grid->transform().indexToWorld(generateBbox.mBbox);
worldBounds.expand(gridBounds);
}
return worldBounds;
}
} // namespace
static VRAY_ProceduralArg theArgs[] = {
VRAY_ProceduralArg("file", "string", ""),
VRAY_ProceduralArg("streamdata", "int", "1"),
VRAY_ProceduralArg("groupmask", "string", ""),
VRAY_ProceduralArg("attrmask", "string", ""),
VRAY_ProceduralArg("speedtocolor", "int", "0"),
VRAY_ProceduralArg("maxspeed", "real", "1.0"),
VRAY_ProceduralArg("ramp", "string", ""),
VRAY_ProceduralArg()
};
class ProcDef : public VRAY_ProceduralFactory::ProcDefinition
{
public:
ProcDef()
: VRAY_ProceduralFactory::ProcDefinition("openvdb_points")
{
}
virtual VRAY_Procedural *create() const { return new VRAY_OpenVDB_Points(); }
virtual VRAY_ProceduralArg *arguments() const { return theArgs; }
};
void
registerProcedural(VRAY_ProceduralFactory *factory)
{
factory->insert(new ProcDef);
}
VRAY_OpenVDB_Points::VRAY_OpenVDB_Points()
{
openvdb::initialize();
}
const char *
VRAY_OpenVDB_Points::className() const
{
return "VRAY_OpenVDB_Points";
}
int
VRAY_OpenVDB_Points::initialize(const UT_BoundingBox *)
{
struct Local
{
static GridVecPtr loadGrids(const std::string& filename, const bool stream)
{
GridVecPtr grids;
// save the grids so that we only read the file once
try
{
io::File file(filename);
file.open();
for (auto iter=file.beginName(), endIter=file.endName(); iter != endIter; ++iter) {
GridBase::Ptr baseGrid = file.readGridMetadata(*iter);
if (baseGrid->isType<points::PointDataGrid>()) {
auto grid = StaticPtrCast<points::PointDataGrid>(file.readGrid(*iter));
assert(grid);
if (stream) {
// enable streaming mode to auto-collapse attributes
// on read for improved memory efficiency
points::setStreamingMode(grid->tree(), /*on=*/true);
}
grids.push_back(grid);
}
}
file.close();
}
catch (const IoError& e)
{
OPENVDB_LOG_ERROR(e.what() << " (" << filename << ")");
}
return grids;
}
};
import("file", mFilename);
int streamData;
import("streamdata", &streamData, 1);
import("attrmask", mAttrStr);
float fps;
import("global:fps", &fps, 1);
float shutter[2];
import("camera:shutter", shutter, 2);
int velocityBlur;
import("object:velocityblur", &velocityBlur, 1);
mPreBlur = velocityBlur ? -shutter[0]/fps : 0;
mPostBlur = velocityBlur ? shutter[1]/fps : 0;
int speedToColorInt = 0;
import("speedtocolor", &speedToColorInt, 1);
mSpeedToColor = bool(speedToColorInt);
// if speed-to-color is enabled we need to build a ramp object
if (mSpeedToColor) {
import("maxspeed", &mMaxSpeed, 1);
UT_StringHolder rampStr;
import("ramp", rampStr);
std::stringstream rampStream(rampStr.toStdString());
std::istream_iterator<float> begin(rampStream);
std::istream_iterator<float> end;
std::vector<float> rampVals(begin, end);
for (size_t n = 4, N = rampVals.size(); n < N; n += 5) {
const int basis = static_cast<int>(rampVals[n]);
mFunctionRamp.addNode(rampVals[n-4],
UT_FRGBA(rampVals[n-3], rampVals[n-2], rampVals[n-1], 1.0f),
static_cast<UT_SPLINE_BASIS>(basis));
}
}
mGridPtrs = Local::loadGrids(mFilename.toStdString(), streamData ? true : false);
// extract which groups to include and exclude
UT_StringHolder groupStr;
import("groupmask", groupStr);
AttributeSet::Descriptor::parseNames(mIncludeGroups, mExcludeGroups, groupStr.toStdString());
// get openvdb bounds and convert to houdini bounds
BBoxd vdbBox = ::getBoundingBox<PointDataGrid>(mGridPtrs, mIncludeGroups, mExcludeGroups);
mBox.setBounds(
static_cast<float>(vdbBox.min().x()),
static_cast<float>(vdbBox.min().y()),
static_cast<float>(vdbBox.min().z()),
static_cast<float>(vdbBox.max().x()),
static_cast<float>(vdbBox.max().y()),
static_cast<float>(vdbBox.max().z()));
// if streaming the data, re-open the file now that the bounding box has been computed
if (streamData) {
mGridPtrs = Local::loadGrids(mFilename.toStdString(), true);
}
return 1;
}
void
VRAY_OpenVDB_Points::getBoundingBox(UT_BoundingBox &box)
{
box = mBox;
}
void
VRAY_OpenVDB_Points::render()
{
using PointDataTree = points::PointDataGrid::TreeType;
using AttributeSet = points::AttributeSet;
using Descriptor = AttributeSet::Descriptor;
/// Allocate geometry and extract the GU_Detail
VRAY_ProceduralGeo geo = createGeometry();
GU_Detail* gdp = geo.get();
// extract which attributes to include and exclude
std::vector<Name> includeAttributes;
std::vector<Name> excludeAttributes;
AttributeSet::Descriptor::parseNames(
includeAttributes, excludeAttributes, mAttrStr.toStdString());
// if nothing was included or excluded: "all attributes" is implied with an empty vector
// if nothing was included but something was explicitly excluded:
// add all attributes but then remove the excluded
// if something was included:
// add only explicitly included attributes and then removed any excluded
if (includeAttributes.empty() && !excludeAttributes.empty()) {
// add all attributes
for (const auto& grid : mGridPtrs) {
auto leafIter = grid->tree().cbeginLeaf();
if (!leafIter) continue;
const AttributeSet& attributeSet = leafIter->attributeSet();
const Descriptor& descriptor = attributeSet.descriptor();
const Descriptor::NameToPosMap& nameToPosMap = descriptor.map();
for (const auto& namePos : nameToPosMap) {
includeAttributes.push_back(namePos.first);
}
}
}
// sort, and then remove any duplicates
std::sort(includeAttributes.begin(), includeAttributes.end());
std::sort(excludeAttributes.begin(), excludeAttributes.end());
includeAttributes.erase(
std::unique(includeAttributes.begin(), includeAttributes.end()), includeAttributes.end());
excludeAttributes.erase(
std::unique(excludeAttributes.begin(), excludeAttributes.end()), excludeAttributes.end());
// make a vector (validAttributes) of all elements that are in includeAttributes
// but are NOT in excludeAttributes
std::vector<Name> validAttributes(includeAttributes.size());
auto pastEndIter = std::set_difference(includeAttributes.begin(), includeAttributes.end(),
excludeAttributes.begin(), excludeAttributes.end(), validAttributes.begin());
validAttributes.resize(pastEndIter - validAttributes.begin());
// if any of the grids are going to add a pscale, set the default here
if (std::binary_search(validAttributes.begin(), validAttributes.end(), "pscale")) {
gdp->addTuple(GA_STORE_REAL32, GA_ATTRIB_POINT, "pscale", 1, GA_Defaults(DEFAULT_PSCALE));
}
// map speed to color if requested
if (mSpeedToColor) {
for (const auto& grid : mGridPtrs) {
PointDataTree& tree = grid->tree();
auto leafIter = tree.beginLeaf();
if (!leafIter) continue;
size_t velocityIndex = leafIter->attributeSet().find("v");
if (velocityIndex != AttributeSet::INVALID_POS) {
const std::string velocityType =
leafIter->attributeSet().descriptor().type(velocityIndex).first;
// keep existing Cd attribute only if it is a supported type (float or half)
size_t colorIndex = leafIter->attributeSet().find("Cd");
std::string colorType = "";
if (colorIndex != AttributeSet::INVALID_POS) {
colorType = leafIter->attributeSet().descriptor().type(colorIndex).first;
if (colorType != typeNameAsString<Vec3f>()
&& colorType != typeNameAsString<Vec3H>())
{
dropAttribute(tree, "Cd");
colorIndex = AttributeSet::INVALID_POS;
}
}
// create new Cd attribute if one did not previously exist
if (colorIndex == AttributeSet::INVALID_POS) {
openvdb::points::appendAttribute<Vec3f, FixedPointCodec<false, UnitRange>>(
tree, "Cd");
colorIndex = leafIter->attributeSet().find("Cd");
}
tree::LeafManager<PointDataTree> leafManager(tree);
PopulateColorFromVelocityOp<PointDataTree> populateColor(colorIndex, velocityIndex,
mFunctionRamp, mMaxSpeed, mIncludeGroups, mExcludeGroups);
tbb::parallel_for(leafManager.leafRange(), populateColor);
}
}
}
for (const auto& grid : mGridPtrs) {
hvdb::convertPointDataGridToHoudini(
*gdp, *grid, validAttributes, mIncludeGroups, mExcludeGroups);
}
geo.addVelocityBlur(mPreBlur, mPostBlur);
// Create a geometry object in mantra
VRAY_ProceduralChildPtr obj = createChild();
obj->addGeometry(geo);
// Override the renderpoints setting to always enable points only rendering
int one = 1;
obj->changeSetting("renderpoints", 1, &one);
}
| 20,152 | C++ | 33.273809 | 100 | 0.599444 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Noise.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Noise.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Applies noise to level sets represented by VDBs. The noise can
/// optionally be masked by another level set
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/math/Operators.h>
#include <openvdb/math/Stencils.h>
#include <openvdb/tools/Interpolation.h> // for box sampler
#include <UT/UT_PNoise.h>
#include <UT/UT_Interrupt.h>
#include <sstream>
#include <stdexcept>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace cvdb = openvdb;
namespace { // anon namespace
struct FractalBoltzmannGenerator
{
FractalBoltzmannGenerator(float freq, float amp, int octaves, float gain,
float lacunarity, float roughness, int mode):
mOctaves(octaves), mNoiseMode(mode), mFreq(freq), mAmp(amp), mGain(gain),
mLacunarity(lacunarity), mRoughness(roughness)
{}
// produce the noise as float
float noise(cvdb::Vec3R point, float freqMult = 1.0f) const
{
float signal;
float result = 0.0f;
float curamp = mAmp;
float curfreq = mFreq * freqMult;
for (int n = 0; n <= mOctaves; n++) {
point = (point * curfreq);
// convert to float for UT_PNoise
float location[3] = { float(point[0]), float(point[1]), float(point[2]) };
// generate noise in the [-1,1] range
signal = 2.0f*UT_PNoise::noise3D(location) - 1.0f;
if (mNoiseMode > 0) {
signal = cvdb::math::Pow(cvdb::math::Abs(signal), mGain);
}
result += (signal * curamp);
curfreq = mLacunarity;
curamp *= mRoughness;
}
if (mNoiseMode == 1) {
result = -result;
}
return result;
}
private:
// member data
int mOctaves;
int mNoiseMode;
float mFreq;
float mAmp;
float mGain;
float mLacunarity;
float mRoughness;
};
struct NoiseSettings
{
NoiseSettings() : mMaskMode(0), mOffset(0.0), mThreshold(0.0),
mFallOff(0.0), mNOffset(cvdb::Vec3R(0.0, 0.0, 0.0)) {}
int mMaskMode;
float mOffset, mThreshold, mFallOff;
cvdb::Vec3R mNOffset;
};
} // anon namespace
////////////////////////////////////////
class SOP_OpenVDB_Noise: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Noise(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Noise() override {}
static OP_Node* factory(OP_Network*, const char*, OP_Operator*);
int isRefInput(unsigned input) const override { return (input == 1); }
class Cache: public SOP_VDBCacheOptions
{
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
private:
// Process the given grid and return the output grid.
// Can be applied to FloatGrid or DoubleGrid
// this contains the majority of the work
template<typename GridType>
void applyNoise(hvdb::Grid& grid, const FractalBoltzmannGenerator&,
const NoiseSettings&, const hvdb::Grid* maskGrid) const;
}; // class Cache
protected:
bool updateParmsFlags() override;
};
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Define a string-valued group name pattern parameter and add it to the list.
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to be processed.")
.setDocumentation(
"A subset of the input VDBs to be processed"
" (see [specifying volumes|/model/volumes#group])"));
// amplitude
parms.add(hutil::ParmFactory(PRM_FLT_J, "amp", "Amplitude")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_FREE, 10.0)
.setTooltip("The amplitude of the noise"));
// frequency
parms.add(hutil::ParmFactory(PRM_FLT_J, "freq", "Frequency")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_FREE, 1.0)
.setTooltip("The frequency of the noise"));
// Octaves
parms.add(hutil::ParmFactory(PRM_INT_J, "oct", "Octaves")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_FREE, 10)
.setTooltip("The number of octaves for the noise"));
// Lacunarity
parms.add(hutil::ParmFactory(PRM_FLT_J, "lac", "Lacunarity")
.setDefault(PRMtwoDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_FREE, 10.0)
.setTooltip("The lacunarity of the noise"));
// Gain
parms.add(hutil::ParmFactory(PRM_FLT_J, "gain", "Gain")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_FREE, 1.0)
.setTooltip("The gain of the noise"));
// Roughness
parms.add(hutil::ParmFactory(PRM_FLT_J, "rough", "Roughness")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_RESTRICTED, 10.0)
.setTooltip("The roughness of the noise"));
// SurfaceOffset
parms.add(hutil::ParmFactory(PRM_FLT_J, "soff", "Surface Offset")
.setDefault(PRMzeroDefaults)
.setTooltip("An offset from the isosurface of the level set at which to apply the noise"));
// Noise Offset
parms.add(hutil::ParmFactory(PRM_XYZ_J, "noff", "Noise Offset")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setTooltip("An offset for the noise in world units"));
// Noise Mode
parms.add(hutil::ParmFactory(PRM_ORD, "mode", "Noise Mode")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"straight", "Straight",
"abs", "Absolute",
"invabs", "Inverse Absolute"
})
.setTooltip("The noise mode: either Straight, Absolute, or Inverse Absolute"));
// Mask {
parms.add(hutil::ParmFactory(PRM_HEADING, "maskHeading", "Mask"));
// Group
parms.add(hutil::ParmFactory(PRM_STRING, "maskGroup", "Mask Group")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setDocumentation(
"A scalar VDB from the second input to be used as a mask"
" (see [specifying volumes|/model/volumes#group])"));
// Use mask
parms.add(hutil::ParmFactory(PRM_ORD, "mask", "Mask")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"maskless", "No noise if mask < threshold",
"maskgreater", "No noise if mask > threshold",
"maskgreaternml", "No noise if mask > threshold & normals align",
"maskisfreqmult", "Use mask as frequency multiplier"
})
.setTooltip("How to interpret the mask")
.setDocumentation("\
How to interpret the mask\n\
\n\
No noise if mask < threshold:\n\
Don't add noise to a voxel if the mask value at that voxel\n\
is less than the __Mask Threshold__.\n\
No noise if mask > threshold:\n\
Don't add noise to a voxel if the mask value at that voxel\n\
is greater than the __Mask Threshold__.\n\
No noise if mask > threshold & normals align:\n\
Don't add noise to a voxel if the mask value at that voxel\n\
is greater than the __Mask Threshold__ and the surface normal\n\
of the level set at that voxel aligns with the gradient of the mask.\n\
Use mask as frequency multiplier:\n\
Add noise to every voxel, but multiply the noise frequency by the mask.\n"));
// mask threshold
parms.add(hutil::ParmFactory(PRM_FLT_J, "thres", "Mask Threshold")
.setDefault(PRMzeroDefaults)
.setTooltip("The threshold value for mask comparisons"));
// Fall off
parms.add(hutil::ParmFactory(PRM_FLT_J, "fall", "Falloff")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_FREE, 10.0)
.setTooltip("A falloff value for the threshold"));
// }
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Noise", SOP_OpenVDB_Noise::factory, parms, *table)
.setNativeName("")
.addInput("VDB grids to noise")
.addOptionalInput("Optional VDB grid to use as mask")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Noise::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Add noise to VDB level sets.\"\"\"\n\
\n\
@overview\n\
\n\
Using a fractal Boltzmann generator, this node adds surface noise\n\
to VDB level set volumes.\n\
An optional mask grid can be provided to control the amount of noise per voxel.\n\
\n\
@related\n\
- [Node:sop/cloudnoise]\n\
- [Node:sop/volumevop]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Noise::factory(OP_Network* net, const char* name, OP_Operator *op)
{
return new SOP_OpenVDB_Noise(net, name, op);
}
SOP_OpenVDB_Noise::SOP_OpenVDB_Noise(OP_Network* net, const char* name, OP_Operator* op):
SOP_NodeVDB(net, name, op)
{
UT_PNoise::initNoise();
}
////////////////////////////////////////
bool
SOP_OpenVDB_Noise::updateParmsFlags()
{
bool changed = false;
const GU_Detail* refGdp = this->getInputLastGeo(1, /*time=*/0.0);
const bool hasSecondInput = (refGdp != nullptr);
changed |= enableParm("maskGroup", hasSecondInput);
changed |= enableParm("mask", hasSecondInput);
changed |= enableParm("thres", hasSecondInput);
changed |= enableParm("fall", hasSecondInput);
return changed;
}
////////////////////////////////////////
template<typename GridType>
void
SOP_OpenVDB_Noise::Cache::applyNoise(
hvdb::Grid& grid,
const FractalBoltzmannGenerator& fbGenerator,
const NoiseSettings& settings,
const hvdb::Grid* mask) const
{
// Use second order finite difference.
using Gradient = cvdb::math::Gradient<cvdb::math::GenericMap, cvdb::math::CD_2ND>;
using CPT = cvdb::math::CPT<cvdb::math::GenericMap, cvdb::math::CD_2ND>;
using StencilType = cvdb::math::SecondOrderDenseStencil<GridType>;
using TreeType = typename GridType::TreeType;
using Vec3Type = cvdb::math::Vec3<typename TreeType::ValueType>;
// Down cast the generic pointer to the output grid.
GridType& outGrid = UTvdbGridCast<GridType>(grid);
const cvdb::math::Transform& xform = grid.transform();
// Create a stencil.
StencilType stencil(outGrid); // uses its own grid accessor
// scratch variables
typename GridType::ValueType result; // result - use mask as frequency multiplier
cvdb::Vec3R voxelPt; // voxel coordinates
cvdb::Vec3R worldPt; // world coordinates
float noise, alpha;
// The use of the GenericMap is a performance compromise
// because the GenericMap holdds a base class pointer.
// This should be optimized by resolving the acutal map type
cvdb::math::GenericMap map(grid);
if (!mask) {
alpha = 1.0f;
for (typename GridType::ValueOnIter v = outGrid.beginValueOn(); v; ++v) {
stencil.moveTo(v);
worldPt = xform.indexToWorld(CPT::result(map, stencil) + settings.mNOffset);
noise = fbGenerator.noise(worldPt);
v.setValue(*v + alpha * (noise - settings.mOffset));
}
return;
}
// Down cast the generic pointer to the mask grid.
const GridType* maskGrid = UTvdbGridCast<GridType>(mask);
const cvdb::math::Transform& maskXform = mask->transform();
switch (settings.mMaskMode) {
case 0: //No noise if mask < threshold
{
for (typename GridType::ValueOnIter v = outGrid.beginValueOn(); v; ++v) {
cvdb::Coord ijk = v.getCoord();
stencil.moveTo(ijk); // in voxel units
worldPt = xform.indexToWorld(ijk);
voxelPt = maskXform.worldToIndex(worldPt);
cvdb::tools::BoxSampler::sample<TreeType>(maskGrid->tree(), voxelPt, result);
// apply threshold
if (result < settings.mThreshold) {
continue; //next voxel
}
alpha = static_cast<float>(result >= settings.mThreshold + settings.mFallOff ?
1.0f : (result - settings.mThreshold) / settings.mFallOff);
worldPt = xform.indexToWorld(CPT::result(map, stencil) + settings.mNOffset);
noise = fbGenerator.noise(worldPt);
v.setValue(*v + alpha * (noise - settings.mOffset));
}
}
break;
case 1: //No noise if mask > threshold
{
for (typename GridType::ValueOnIter v = outGrid.beginValueOn(); v; ++v) {
cvdb::Coord ijk = v.getCoord();
stencil.moveTo(ijk); // in voxel units
worldPt = xform.indexToWorld(ijk);
voxelPt = maskXform.worldToIndex(worldPt);
cvdb::tools::BoxSampler::sample<TreeType>(maskGrid->tree(), voxelPt, result);
// apply threshold
if (result > settings.mThreshold) {
continue; //next voxel
}
alpha = static_cast<float>(result <= settings.mThreshold - settings.mFallOff ?
1.0f : (settings.mThreshold - result) / settings.mFallOff);
worldPt = xform.indexToWorld(CPT::result(map, stencil) + settings.mNOffset);
noise = fbGenerator.noise(worldPt);
v.setValue(*v + alpha * (noise - settings.mOffset));
}
}
break;
case 2: //No noise if mask < threshold & normals align
{
StencilType maskStencil(*maskGrid);
for (typename GridType::ValueOnIter v = outGrid.beginValueOn(); v; ++v) {
cvdb::Coord ijk = v.getCoord();
stencil.moveTo(ijk); // in voxel units
worldPt = xform.indexToWorld(ijk);
voxelPt = maskXform.worldToIndex(worldPt);
cvdb::tools::BoxSampler::sample<TreeType>(maskGrid->tree(), voxelPt, result);
// for the gradient of the maskGrid
cvdb::Coord mask_ijk(
static_cast<int>(voxelPt[0]),
static_cast<int>(voxelPt[1]),
static_cast<int>(voxelPt[2]));
maskStencil.moveTo(mask_ijk);
// normal alignment
Vec3Type grid_grad = Gradient::result(map, stencil);
Vec3Type mask_grad = Gradient::result(map, maskStencil);
const double c = cvdb::math::Abs(grid_grad.dot(mask_grad));
if (result > settings.mThreshold && c > 0.9) continue;//next voxel
alpha = static_cast<float>(result <= settings.mThreshold - settings.mFallOff ?
1.0f : (settings.mThreshold - result) / settings.mFallOff);
worldPt = xform.indexToWorld(CPT::result(map, stencil) + settings.mNOffset);
noise = fbGenerator.noise(worldPt);
v.setValue(*v + alpha * (noise - settings.mOffset));
}
}
break;
case 3: //Use mask as frequency multiplier
{
alpha = 1.0f;
for (typename GridType::ValueOnIter v = outGrid.beginValueOn(); v; ++v) {
cvdb::Coord ijk = v.getCoord();
stencil.moveTo(ijk); // in voxel units
worldPt = xform.indexToWorld(ijk);
voxelPt = maskXform.worldToIndex(worldPt);
cvdb::tools::BoxSampler::sample<TreeType>(maskGrid->tree(), voxelPt, result);
worldPt = xform.indexToWorld(CPT::result(map, stencil) + settings.mNOffset);
// Use result of sample as frequency multiplier.
noise = fbGenerator.noise(worldPt, static_cast<float>(result));
v.setValue(*v + alpha * (noise - settings.mOffset));
}
}
break;
default: // should never get here
throw std::runtime_error("internal error in mode selection");
}// end switch
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Noise::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
// Evaluate the FractalBoltzmann noise parameters from UI
FractalBoltzmannGenerator fbGenerator(
static_cast<float>(evalFloat("freq", 0, time)),
static_cast<float>(evalFloat("amp", 0, time)),
static_cast<int>(evalInt("oct", 0, time)),
static_cast<float>(evalFloat("gain", 0, time)),
static_cast<float>(evalFloat("lac", 0, time)),
static_cast<float>(evalFloat("rough", 0, time)),
static_cast<int>(evalInt("mode", 0, time)));
NoiseSettings settings;
// evaluate parameter for blending noise
settings.mOffset = static_cast<float>(evalFloat("soff", 0, time));
settings.mNOffset = cvdb::Vec3R(
evalFloat("noff", 0, time),
evalFloat("noff", 1, time),
evalFloat("noff", 2, time));
// Mask
const openvdb::GridBase* maskGrid = nullptr;
if (const GU_Detail* refGdp = inputGeo(1)) {
const GA_PrimitiveGroup* maskGroup =
matchGroup(*refGdp, evalStdString("maskGroup", time));
hvdb::VdbPrimCIterator gridIter(refGdp, maskGroup);
if (gridIter) {
settings.mMaskMode = static_cast<int>(evalInt("mask", 0, time));
settings.mThreshold = static_cast<float>(evalFloat("thres", 0, time));
settings.mFallOff = static_cast<float>(evalFloat("fall", 0, time));
maskGrid = &((*gridIter)->getGrid());
++gridIter;
}
if (gridIter) {
addWarning(SOP_MESSAGE,
"Found more than one grid in the mask group; the first grid will be used.");
}
}
// Do the work..
UT_AutoInterrupt progress("OpenVDB LS Noise");
// Get the group of grids to process.
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
// For each VDB primitive in the selected group.
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (progress.wasInterrupted()) {
throw std::runtime_error("processing was interrupted");
}
GU_PrimVDB* vdbPrim = *it;
if (vdbPrim->getStorageType() == UT_VDB_FLOAT) {
vdbPrim->makeGridUnique();
applyNoise<cvdb::ScalarGrid>(vdbPrim->getGrid(), fbGenerator, settings, maskGrid);
} else if (vdbPrim->getStorageType() == UT_VDB_DOUBLE) {
vdbPrim->makeGridUnique();
applyNoise<cvdb::DoubleGrid>(vdbPrim->getGrid(), fbGenerator, settings, maskGrid);
} else {
std::stringstream ss;
ss << "VDB primitive " << it.getPrimitiveNameOrIndex()
<< " was skipped because it is not a scalar grid.";
addWarning(SOP_MESSAGE, ss.str().c_str());
continue;
}
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 19,663 | C++ | 33.80354 | 99 | 0.595331 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Points_Group.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file SOP_OpenVDB_Points_Group.cc
///
/// @author Dan Bailey
///
/// @brief Add and remove point groups.
#include <openvdb/openvdb.h>
#include <openvdb/points/PointDataGrid.h>
#include <openvdb/points/PointGroup.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/PointUtils.h>
#include <openvdb_houdini/Utils.h>
#include <houdini_utils/geometry.h>
#include <houdini_utils/ParmFactory.h>
#include <algorithm> // for std::find()
#include <limits>
#include <random>
#include <stdexcept>
#include <string>
#include <vector>
using namespace openvdb;
using namespace openvdb::points;
using namespace openvdb::math;
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace {
struct GroupParms {
// global parms
bool mEnable = false;
std::string mGroupName = "";
const GA_PrimitiveGroup * mGroup = nullptr;
// operation flags
bool mOpGroup = false;
bool mOpLeaf = false;
bool mOpHashI = false;
bool mOpHashL = false;
bool mOpBBox = false;
bool mOpLS = false;
// group parms
std::vector<std::string> mIncludeGroups;
std::vector<std::string> mExcludeGroups;
// number parms
bool mCountMode = false;
bool mHashMode = false;
float mPercent = 0.0f;
long mCount = 0L;
std::string mHashAttribute = "";
size_t mHashAttributeIndex = openvdb::points::AttributeSet::INVALID_POS;
// bbox parms
openvdb::BBoxd mBBox;
// level set parms
openvdb::FloatGrid::ConstPtr mLevelSetGrid = FloatGrid::create(0);
float mSDFMin = 0.0f;
float mSDFMax = 0.0f;
// viewport parms
bool mEnableViewport = false;
bool mAddViewport = false;
std::string mViewportGroupName = "";
// drop groups
bool mDropAllGroups = false;
std::vector<std::string> mDropIncludeGroups;
std::vector<std::string> mDropExcludeGroups;
};
} // namespace
////////////////////////////////////////
class SOP_OpenVDB_Points_Group: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Points_Group(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Points_Group() override = default;
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i > 0); }
class Cache: public SOP_VDBCacheOptions
{
public:
OP_ERROR evalGroupParms(OP_Context&, GroupParms&);
OP_ERROR evalGridGroupParms(const PointDataGrid&, OP_Context&, GroupParms&);
void performGroupFiltering(PointDataGrid&, const GroupParms&);
void setViewportMetadata(PointDataGrid&, const GroupParms&);
void removeViewportMetadata(PointDataGrid&);
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
}; // class Cache
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
}; // class SOP_OpenVDB_Points_Group
////////////////////////////////////////
static PRM_Default negPointOneDefault(-0.1);
static PRM_Default fiveThousandDefault(5000);
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
openvdb::initialize();
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to be loaded.")
.setDocumentation(
"A subset of the input VDB Points primitives to be processed"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "vdbpointsgroup", "VDB Points Group")
.setChoiceList(&hvdb::VDBPointsGroupMenuInput1)
.setTooltip(
"Create a new VDB points group as a subset of an existing VDB points group(s)."));
parms.beginSwitcher("tabMenu1");
parms.addFolder("Create");
// Toggle to enable creation
parms.add(hutil::ParmFactory(PRM_TOGGLE, "enablecreate", "Enable")
.setDefault(PRMoneDefaults)
.setTooltip("Enable creation of the group."));
parms.add(hutil::ParmFactory(PRM_STRING, "groupname", "Group Name")
.setDefault(0, ::strdup("group1"))
.setTooltip("The name of the internal group to create"));
parms.beginSwitcher("tabMenu2");
parms.addFolder("Number");
parms.add(hutil::ParmFactory(PRM_TOGGLE, "enablenumber", "Enable")
.setDefault(PRMzeroDefaults)
.setTooltip("Enable filtering by number."));
parms.add(hutil::ParmFactory(PRM_ORD, "numbermode", "Mode")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"percentage", "Percentage",
"total", "Total"
})
.setTooltip("Specify how to filter out a subset of the points inside the VDB Points."));
parms.add(hutil::ParmFactory(PRM_FLT, "pointpercent", "Percent")
.setDefault(PRMtenDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_RESTRICTED, 100)
.setTooltip("The percentage of points to include in the group"));
parms.add(hutil::ParmFactory(PRM_INT, "pointcount", "Count")
.setDefault(&fiveThousandDefault)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 1000000)
.setTooltip("The total number of points to include in the group"));
parms.add(hutil::ParmFactory(PRM_TOGGLE_J, "enablepercentattribute", "")
.setDefault(PRMzeroDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_STRING, "percentattribute", "Attribute Seed")
.setDefault(0, ::strdup("id"))
.setTooltip("The point attribute to use as a seed for percent filtering"));
parms.endSwitcher();
parms.beginSwitcher("tabMenu3");
parms.addFolder("Bounding");
parms.add(hutil::ParmFactory(PRM_TOGGLE, "enableboundingbox", "Enable")
.setDefault(PRMzeroDefaults)
.setTooltip("Enable filtering by bounding box."));
parms.add(hutil::ParmFactory(PRM_ORD, "boundingmode", "Mode")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"boundingbox", "Bounding Box",
"boundingobject", "Bounding Object"
}));
parms.add(hutil::ParmFactory(PRM_STRING, "boundingname", "Name")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("The name of the bounding geometry"));
parms.add(hutil::ParmFactory(PRM_XYZ, "size", "Size")
.setDefault(PRMoneDefaults)
.setVectorSize(3)
.setTooltip("The size of the bounding box"));
parms.add(hutil::ParmFactory(PRM_XYZ, "center", "Center")
.setVectorSize(3)
.setTooltip("The center of the bounding box"));
parms.endSwitcher();
parms.beginSwitcher("tabMenu4");
parms.addFolder("SDF");
parms.add(hutil::ParmFactory(PRM_TOGGLE, "enablesdf", "Enable")
.setDefault(PRMzeroDefaults)
.setTooltip("Enable filtering by SDF."));
parms.add(hutil::ParmFactory(PRM_STRING, "sdfname", "Name")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("The name of the SDF"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "enablesdfmin", "Enable")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("Enable SDF minimum."));
parms.add(hutil::ParmFactory(PRM_FLT, "sdfmin", "SDF Minimum")
.setDefault(&negPointOneDefault)
.setRange(PRM_RANGE_UI, -1, PRM_RANGE_UI, 1)
.setTooltip("SDF minimum value"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "enablesdfmax", "Enable")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("Enable SDF maximum."));
parms.add(hutil::ParmFactory(PRM_FLT, "sdfmax", "SDF Maximum")
.setDefault(PRMpointOneDefaults)
.setRange(PRM_RANGE_UI, -1, PRM_RANGE_UI, 1)
.setTooltip("SDF maximum value"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "sdfinvert", "Invert")
.setDefault(PRMzeroDefaults)
.setTooltip("Invert SDF minimum and maximum."));
parms.endSwitcher();
parms.addFolder("Delete");
parms.add(hutil::ParmFactory(PRM_STRING, "deletegroups", "Point Groups")
.setDefault(0, "")
.setHelpText(
"A space-delimited list of groups to delete.\n\n"
"This will delete the selected groups but will not delete"
" the points contained in them.")
.setChoiceList(&hvdb::VDBPointsGroupMenuInput1));
parms.addFolder("Viewport");
parms.add(hutil::ParmFactory(PRM_TOGGLE, "enableviewport", "Enable")
.setDefault(PRMzeroDefaults)
.setTooltip("Toggle viewport group.")
.setDocumentation(
"Enable the viewport group.\n\n"
"This allows one to specify a subset of points to be displayed in the viewport.\n"
"This minimizes the data transfer to the viewport without removing the data.\n\n"
"NOTE:\n"
" Only one group can be tagged as a viewport group.\n"));
parms.add(hutil::ParmFactory(PRM_ORD, "viewportoperation", "Operation")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"addviewportgroup", "Add Viewport Group",
"removeviewportgroup", "Remove Viewport Group"
})
.setTooltip("Specify whether to add or remove the viewport group."));
parms.add(hutil::ParmFactory(PRM_STRING, "viewportgroupname", "Name")
.setDefault("chs(\"groupname\")", CH_OLD_EXPRESSION)
.setTooltip("Display only this group in the viewport."));
parms.endSwitcher();
hutil::ParmList obsoleteParms;
obsoleteParms.add(houdini_utils::ParmFactory(PRM_LABEL, "spacer1", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "enablelevelset", "Enable")
.setDefault(PRMzeroDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "levelsetname", "Name"));
//////////
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Points Group",
SOP_OpenVDB_Points_Group::factory, parms, *table)
.addInput("VDB Points")
.addOptionalInput("Optional bounding geometry or level set")
.setObsoleteParms(obsoleteParms)
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Points_Group::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Manipulate the internal groups of a VDB Points primitive.\"\"\"\n\
\n\
@overview\n\
\n\
This node acts like the [Node:sop/group] node, but for the points inside\n\
a VDB Points primitive.\n\
It can create and manipulate the primitive's internal groups.\n\
Generated groups can be used to selectively unpack a subset of the points\n\
with an [OpenVDB Points Convert node|Node:sop/DW_OpenVDBPointsConvert].\n\
\n\
@related\n\
- [OpenVDB Points Convert|Node:sop/DW_OpenVDBPointsConvert]\n\
- [OpenVDB Points Delete|Node:sop/DW_OpenVDBPointsDelete]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Points_Group::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
resolveRenamedParm(*obsoleteParms, "enablelevelset", "enablesdf");
resolveRenamedParm(*obsoleteParms, "levelsetname", "sdfname");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
bool
SOP_OpenVDB_Points_Group::updateParmsFlags()
{
bool changed = false;
const bool creation = evalInt("enablecreate", 0, 0) != 0;
const bool number = evalInt("enablenumber", 0, 0) != 0;
const bool total = evalInt("numbermode", 0, 0) == 1;
const bool percentattribute = evalInt("enablepercentattribute", 0, 0) != 0;
const bool bounding = evalInt("enableboundingbox", 0, 0) != 0;
const bool boundingobject = evalInt("boundingmode", 0, 0) == 1;
const bool viewport = evalInt("enableviewport", 0, 0) != 0;
const bool levelset = evalInt("enablesdf", 0, 0);
const bool sdfmin = evalInt("enablesdfmin", 0, 0);
const bool sdfmax = evalInt("enablesdfmax", 0, 0);
const bool viewportadd = evalInt("viewportoperation", 0, 0) == 0;
changed |= enableParm("vdbpointsgroup", creation);
changed |= enableParm("groupname", creation);
changed |= enableParm("enablenumber", creation);
changed |= enableParm("numbermode", creation && number);
changed |= enableParm("pointpercent", creation && number && !total);
changed |= enableParm("pointcount", creation && number && total);
changed |= enableParm("enablepercentattribute", creation && number && !total);
changed |= enableParm("percentattribute", creation && number && percentattribute && !total);
changed |= enableParm("enableboundingbox", creation);
changed |= enableParm("boundingmode", creation && bounding);
changed |= enableParm("boundingname", creation && bounding && boundingobject);
changed |= enableParm("size", creation && bounding && !boundingobject);
changed |= enableParm("center", creation && bounding && !boundingobject);
changed |= enableParm("viewportoperation", viewport);
changed |= enableParm("viewportgroupname", viewport && viewportadd);
changed |= enableParm("sdfname", levelset);
changed |= enableParm("enablesdfmin", levelset);
changed |= enableParm("enablesdfmax", levelset);
changed |= enableParm("sdfmin", levelset && sdfmin);
changed |= enableParm("sdfmax", levelset && sdfmax);
changed |= enableParm("sdfinvert", levelset && sdfmin && sdfmax);
return changed;
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Points_Group::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Points_Group(net, name, op);
}
SOP_OpenVDB_Points_Group::SOP_OpenVDB_Points_Group(OP_Network* net,
const char* name, OP_Operator* op)
: hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Points_Group::Cache::cookVDBSop(OP_Context& context)
{
try {
// Evaluate UI parameters
GroupParms parms;
if (evalGroupParms(context, parms) >= UT_ERROR_ABORT) return error();
UT_AutoInterrupt progress("Processing Points Group");
hvdb::VdbPrimIterator vdbIt(gdp, parms.mGroup);
for (; vdbIt; ++vdbIt) {
if (progress.wasInterrupted()) {
throw std::runtime_error("processing was interrupted");
}
GU_PrimVDB* vdbPrim = *vdbIt;
// only process if grid is a PointDataGrid with leaves
if(!openvdb::gridConstPtrCast<PointDataGrid>(vdbPrim->getConstGridPtr())) continue;
auto&& pointDataGrid = UTvdbGridCast<PointDataGrid>(vdbPrim->getConstGrid());
auto leafIter = pointDataGrid.tree().cbeginLeaf();
if (!leafIter) continue;
// Set viewport metadata if no group being created
// (copy grid first to ensure metadata is deep copied)
if (!parms.mEnable) {
if (parms.mEnableViewport) {
auto&& outputGrid = UTvdbGridCast<PointDataGrid>(vdbPrim->getGrid());
if (parms.mAddViewport) {
setViewportMetadata(outputGrid, parms);
} else {
removeViewportMetadata(outputGrid);
}
}
}
const AttributeSet::Descriptor& descriptor = leafIter->attributeSet().descriptor();
std::vector<std::string> groupsToDrop;
bool hasGroupsToDrop = !descriptor.groupMap().empty();
if (hasGroupsToDrop) {
// exclude groups mode
if (!parms.mDropExcludeGroups.empty()) {
// if any groups are to be excluded, ignore those to be included
// and rebuild them
for (const auto& it: descriptor.groupMap()) {
if (std::find( parms.mDropExcludeGroups.begin(),
parms.mDropExcludeGroups.end(), it.first) ==
parms.mDropExcludeGroups.end()) {
groupsToDrop.push_back(it.first);
}
}
}
else if (!parms.mDropAllGroups) {
// if any groups are to be included, intersect them with groups that exist
for (const auto& groupName : parms.mDropIncludeGroups) {
if (descriptor.hasGroup(groupName)) {
groupsToDrop.push_back(groupName);
}
}
}
}
if (hasGroupsToDrop) hasGroupsToDrop = parms.mDropAllGroups || !groupsToDrop.empty();
// If we are not creating groups and there are no groups to drop (due to an empty list or because none of
// the chosen ones were actually present), we can continue the loop early here
if(!parms.mEnable && !hasGroupsToDrop) {
continue;
}
// Evaluate grid-specific UI parameters
if (evalGridGroupParms(pointDataGrid, context, parms) >= UT_ERROR_ABORT)
return error();
// deep copy the VDB tree if it is not already unique
vdbPrim->makeGridUnique();
auto&& outputGrid = UTvdbGridCast<PointDataGrid>(vdbPrim->getGrid());
// filter and create the point group in the grid
if (parms.mEnable) {
performGroupFiltering(outputGrid, parms);
}
// drop groups
if (parms.mDropAllGroups) {
dropGroups(outputGrid.tree());
}
else if (!groupsToDrop.empty()) {
dropGroups(outputGrid.tree(), groupsToDrop);
}
// attach group viewport metadata to the grid
if (parms.mEnableViewport) {
if (parms.mAddViewport) setViewportMetadata(outputGrid, parms);
else removeViewportMetadata(outputGrid);
}
}
return error();
} catch (const std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Points_Group::Cache::evalGroupParms(
OP_Context& context, GroupParms& parms)
{
const fpreal time = context.getTime();
// evaluate filter mode
const bool number = evalInt("enablenumber", 0, time);
const bool countMode = evalInt("numbermode", 0, time) == 1;
const bool percentAttribute = evalInt("enablepercentattribute", 0, time);
const bool bounding = evalInt("enableboundingbox", 0, time);
const bool boundingObject = evalInt("boundingmode", 0, time) == 1;
const bool levelSet = evalInt("enablesdf", 0, time);
parms.mCountMode = countMode;
parms.mHashMode = number && !countMode && percentAttribute;
parms.mOpLeaf = number;
parms.mOpBBox = bounding;
parms.mOpLS = levelSet;
// Get the grids to group.
parms.mGroup = matchGroup(*gdp, evalStdString("group", time));
hvdb::VdbPrimIterator vdbIt(gdp, parms.mGroup);
// Handle no vdbs
if (!vdbIt) {
addError(SOP_MESSAGE, "No VDBs found.");
return error();
}
// Get and parse the vdb points groups
AttributeSet::Descriptor::parseNames(
parms.mIncludeGroups, parms.mExcludeGroups, evalStdString("vdbpointsgroup", time));
if (parms.mIncludeGroups.size() > 0 || parms.mExcludeGroups.size() > 0) {
parms.mOpGroup = true;
}
// reference geometry
const GU_Detail* refGdp = inputGeo(1);
// group creation
parms.mEnable = evalInt("enablecreate", 0, time);
std::string groupName = evalStdString("groupname", time);
if (groupName.empty()) {
addWarning(SOP_MESSAGE, "Cannot create a group with an empty name, changing to _");
groupName = "_";
} else if (!AttributeSet::Descriptor::validName(groupName)) {
addError(SOP_MESSAGE, ("Group name contains invalid characters - " + groupName).c_str());
return error();
}
parms.mGroupName = groupName;
// number
if (number) {
parms.mPercent = static_cast<float>(evalFloat("pointpercent", 0, time));
parms.mCount = evalInt("pointcount", 0, time);
parms.mHashAttribute = evalStdString("percentattribute", time);
}
// bounds
if (bounding) {
if (boundingObject) {
if (!refGdp) {
addError(SOP_MESSAGE, "Missing second input");
return error();
}
// retrieve bounding object
const GA_PrimitiveGroup* boundsGroup = parsePrimitiveGroups(
evalStdString("boundingname", time).c_str(), GroupCreator(refGdp));
// compute bounds of bounding object
UT_BoundingBox box;
box.initBounds();
if (boundsGroup) {
GA_Range range = refGdp->getPrimitiveRange(boundsGroup);
refGdp->enlargeBoundingBox(box, range);
}
else {
refGdp->getBBox(&box);
}
parms.mBBox.min()[0] = box.xmin();
parms.mBBox.min()[1] = box.ymin();
parms.mBBox.min()[2] = box.zmin();
parms.mBBox.max()[0] = box.xmax();
parms.mBBox.max()[1] = box.ymax();
parms.mBBox.max()[2] = box.zmax();
}
else {
// store bounding box
openvdb::BBoxd::ValueType size(
evalFloat("size", 0, time),
evalFloat("size", 1, time),
evalFloat("size", 2, time));
openvdb::BBoxd::ValueType center(
evalFloat("center", 0, time),
evalFloat("center", 1, time),
evalFloat("center", 2, time));
parms.mBBox = openvdb::BBoxd(center - size/2, center + size/2);
}
}
// level set
if (levelSet)
{
if (!refGdp) {
addError(SOP_MESSAGE, "Missing second input");
return error();
}
// retrieve level set grid
const GA_PrimitiveGroup* levelSetGroup = parsePrimitiveGroups(
evalStdString("sdfname", time).c_str(), GroupCreator(refGdp));
for (hvdb::VdbPrimCIterator vdbRefIt(refGdp, levelSetGroup); vdbRefIt; ++vdbRefIt) {
if (vdbRefIt->getStorageType() == UT_VDB_FLOAT &&
vdbRefIt->getGrid().getGridClass() == openvdb::GRID_LEVEL_SET) {
parms.mLevelSetGrid = gridConstPtrCast<FloatGrid>((*vdbRefIt)->getConstGridPtr());
break;
}
}
if (!parms.mLevelSetGrid) {
addError(SOP_MESSAGE, "Second input has no float VDB level set");
return error();
}
bool enableSDFMin = evalInt("enablesdfmin", 0, time);
bool enableSDFMax = evalInt("enablesdfmax", 0, time);
float sdfMin = enableSDFMin ?
static_cast<float>(evalFloat("sdfmin", 0, time)) : -std::numeric_limits<float>::max();
float sdfMax = enableSDFMax ?
static_cast<float>(evalFloat("sdfmax", 0, time)) : std::numeric_limits<float>::max();
// check level set min and max values
if ((enableSDFMin || enableSDFMax) && sdfMin > sdfMax) {
addWarning(SOP_MESSAGE, "SDF minimum is greater than SDF maximum,"
" suggest using the invert toggle instead");
}
const float background = parms.mLevelSetGrid->background();
if (enableSDFMin && sdfMin < -background) {
addWarning(SOP_MESSAGE,
"SDF minimum value is less than the background value of the level set");
}
if (enableSDFMax && sdfMax > background) {
addWarning(SOP_MESSAGE,
"SDF maximum value is greater than the background value of the level set");
}
const bool sdfInvert = evalInt("sdfinvert", 0, time);
parms.mSDFMin = sdfInvert ? -sdfMin : sdfMin;
parms.mSDFMax = sdfInvert ? -sdfMax : sdfMax;
}
// viewport
parms.mEnableViewport = evalInt("enableviewport", 0, time);
parms.mAddViewport = evalInt("viewportoperation", 0, time) == 0;
std::string viewportGroupName = evalStdString("viewportgroupname", time);
if (viewportGroupName == "") {
addWarning(SOP_MESSAGE, "Cannot create a viewport group with an empty name, changing to _");
viewportGroupName = "_";
}
parms.mViewportGroupName = viewportGroupName;
// group deletion
AttributeSet::Descriptor::parseNames(parms.mDropIncludeGroups, parms.mDropExcludeGroups,
parms.mDropAllGroups, evalStdString("deletegroups", time));
if (parms.mDropAllGroups) {
// include groups only apply if not also deleting all groups
parms.mDropIncludeGroups.clear();
// if exclude groups is not empty, don't delete all groups
if (!parms.mDropExcludeGroups.empty()) {
parms.mDropAllGroups = false;
}
}
else {
// exclude groups only apply if also deleting all groups
parms.mDropExcludeGroups.clear();
}
return error();
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Points_Group::Cache::evalGridGroupParms(
const PointDataGrid& grid, OP_Context&, GroupParms& parms)
{
auto leafIter = grid.tree().cbeginLeaf();
if (!leafIter) return error();
const AttributeSet::Descriptor& descriptor = leafIter->attributeSet().descriptor();
// check new group doesn't already exist
if (parms.mEnable) {
if (descriptor.hasGroup(parms.mGroupName)) {
addError(SOP_MESSAGE, ("Cannot create duplicate group - " + parms.mGroupName).c_str());
return error();
}
// group
if (parms.mOpGroup)
{
for (const std::string& name : parms.mIncludeGroups) {
if (!descriptor.hasGroup(name)) {
addError(SOP_MESSAGE, ("Unable to find VDB Points group - " + name).c_str());
return error();
}
}
for (const std::string& name : parms.mExcludeGroups) {
if (!descriptor.hasGroup(name)) {
addError(SOP_MESSAGE, ("Unable to find VDB Points group - " + name).c_str());
return error();
}
}
}
// number
if (parms.mHashMode)
{
// retrieve percent attribute type (if it exists)
const size_t index = descriptor.find(parms.mHashAttribute);
if (index == AttributeSet::INVALID_POS) {
addError(SOP_MESSAGE, ("Unable to find attribute - " + parms.mHashAttribute).c_str());
return error();
}
parms.mHashAttributeIndex = index;
const std::string attributeType = descriptor.valueType(index);
if (attributeType == "int32") parms.mOpHashI = true;
else if (attributeType == "int64") parms.mOpHashL = true;
else {
addError(SOP_MESSAGE, ("Unsupported attribute type for percent attribute filtering - "
+ attributeType).c_str());
return error();
}
}
}
return error();
}
////////////////////////////////////////
void
SOP_OpenVDB_Points_Group::Cache::performGroupFiltering(
PointDataGrid& outputGrid, const GroupParms& parms)
{
// filter typedefs
using HashIFilter = AttributeHashFilter<std::mt19937, int>;
using HashLFilter = AttributeHashFilter<std::mt19937_64, long>;
using LeafFilter = RandomLeafFilter<PointDataGrid::TreeType, std::mt19937>;
using LSFilter = LevelSetFilter<FloatGrid>;
// composite typedefs (a combination of the above five filters)
// the group filter is always included because it's cheap to execute
using GroupHashI = BinaryFilter<MultiGroupFilter, HashIFilter>;
using GroupHashL = BinaryFilter<MultiGroupFilter, HashLFilter>;
using GroupLeaf = BinaryFilter<MultiGroupFilter, LeafFilter>;
using GroupLS = BinaryFilter<MultiGroupFilter, LSFilter>;
using GroupBBox = BinaryFilter<MultiGroupFilter, BBoxFilter>;
using LSHashI = BinaryFilter<LSFilter, HashIFilter>;
using LSHashL = BinaryFilter<LSFilter, HashLFilter>;
using LSLeaf = BinaryFilter<LSFilter, LeafFilter>;
using GroupBBoxHashI = BinaryFilter<GroupBBox, HashIFilter>;
using GroupBBoxHashL = BinaryFilter<GroupBBox, HashLFilter>;
using GroupBBoxLS = BinaryFilter<GroupBBox, LSFilter>;
using GroupBBoxLeaf = BinaryFilter<GroupBBox, LeafFilter>;
using GroupLSHashI = BinaryFilter<GroupLS, HashIFilter>;
using GroupLSHashL = BinaryFilter<GroupLS, HashLFilter>;
using GroupLSLeaf = BinaryFilter<GroupLS, LeafFilter>;
using GroupBBoxLSHashI = BinaryFilter<GroupBBox, LSHashI>;
using GroupBBoxLSHashL = BinaryFilter<GroupBBox, LSHashL>;
using GroupBBoxLSLeaf = BinaryFilter<GroupBBox, LSLeaf>;
// grid data
PointDataTree& tree = outputGrid.tree();
if (!tree.beginLeaf()) {
return;
}
openvdb::math::Transform& transform = outputGrid.transform();
const std::string groupName = parms.mGroupName;
auto targetPoints = static_cast<int>(parms.mCount);
if (parms.mOpLeaf && !parms.mCountMode) {
targetPoints = int(math::Round(
(parms.mPercent * static_cast<double>(pointCount(tree))) / 100.0));
}
const AttributeSet& attributeSet = tree.beginLeaf()->attributeSet();
// build filter data
MultiGroupFilter groupFilter(parms.mIncludeGroups, parms.mExcludeGroups, attributeSet);
BBoxFilter bboxFilter(transform, parms.mBBox);
HashIFilter hashIFilter(parms.mHashAttributeIndex, parms.mPercent);
HashLFilter hashLFilter(parms.mHashAttributeIndex, parms.mPercent);
LeafFilter leafFilter(tree, targetPoints);
LSFilter lsFilter(*parms.mLevelSetGrid, transform, parms.mSDFMin, parms.mSDFMax);
// build composite filter data
GroupHashI groupHashIFilter(groupFilter, hashIFilter);
GroupHashL groupHashLFilter(groupFilter, hashLFilter);
GroupLeaf groupLeafFilter(groupFilter, leafFilter);
GroupLS groupLSFilter(groupFilter, lsFilter);
GroupBBox groupBBoxFilter(groupFilter, bboxFilter);
LSHashI lsHashIFilter(lsFilter, hashIFilter);
LSHashL lsHashLFilter(lsFilter, hashLFilter);
LSLeaf lsLeafFilter(lsFilter, leafFilter);
GroupBBoxHashI groupBBoxHashIFilter(groupBBoxFilter, hashIFilter);
GroupBBoxHashL groupBBoxHashLFilter(groupBBoxFilter, hashLFilter);
GroupBBoxLS groupBBoxLSFilter(groupBBoxFilter, lsFilter);
GroupBBoxLeaf groupBBoxLeafFilter(groupBBoxFilter, leafFilter);
GroupLSHashI groupLSHashIFilter(groupLSFilter, hashIFilter);
GroupLSHashL groupLSHashLFilter(groupLSFilter, hashLFilter);
GroupLSLeaf groupLSLeafFilter(groupLSFilter, leafFilter);
GroupBBoxLSHashI groupBBoxLSHashIFilter(groupBBoxFilter, lsHashIFilter);
GroupBBoxLSHashL groupBBoxLSHashLFilter(groupBBoxFilter, lsHashLFilter);
GroupBBoxLSLeaf groupBBoxLSLeafFilter(groupBBoxFilter, lsLeafFilter);
// append the group
appendGroup(tree, groupName);
// perform group filtering
const GroupParms& p = parms;
if (p.mOpBBox && p.mOpLS && p.mOpHashI) {
setGroupByFilter(tree, groupName, groupBBoxLSHashIFilter);
} else if (p.mOpBBox && p.mOpLS && p.mOpHashL) {
setGroupByFilter(tree, groupName, groupBBoxLSHashLFilter);
} else if (p.mOpBBox && p.mOpLS && p.mOpLeaf) {
setGroupByFilter(tree, groupName, groupBBoxLSLeafFilter);
} else if (p.mOpBBox && p.mOpHashI) {
setGroupByFilter(tree, groupName, groupBBoxHashIFilter);
} else if (p.mOpBBox && p.mOpHashL) {
setGroupByFilter(tree, groupName, groupBBoxHashLFilter);
} else if (p.mOpBBox && p.mOpLeaf) {
setGroupByFilter(tree, groupName, groupBBoxLeafFilter);
} else if (p.mOpBBox && p.mOpLS) {
setGroupByFilter(tree, groupName, groupBBoxLSFilter);
} else if (p.mOpLS && p.mOpHashI) {
setGroupByFilter(tree, groupName, groupLSHashIFilter);
} else if (p.mOpLS && p.mOpHashL) {
setGroupByFilter(tree, groupName, groupLSHashLFilter);
} else if (p.mOpLS && p.mOpLeaf) {
setGroupByFilter(tree, groupName, groupLSLeafFilter);
} else if (p.mOpBBox) {
setGroupByFilter(tree, groupName, groupBBoxFilter);
} else if (p.mOpLS) {
setGroupByFilter(tree, groupName, groupLSFilter);
} else if (p.mOpHashI) {
setGroupByFilter(tree, groupName, groupHashIFilter);
} else if (p.mOpHashL) {
setGroupByFilter(tree, groupName, groupHashLFilter);
} else if (p.mOpLeaf) {
setGroupByFilter(tree, groupName, groupLeafFilter);
} else if (p.mOpGroup) {
setGroupByFilter(tree, groupName, groupFilter);
} else {
setGroup<PointDataTree>(tree, groupName);
}
}
////////////////////////////////////////
void
SOP_OpenVDB_Points_Group::Cache::setViewportMetadata(
PointDataGrid& outputGrid, const GroupParms& parms)
{
outputGrid.insertMeta(openvdb_houdini::META_GROUP_VIEWPORT,
StringMetadata(parms.mViewportGroupName));
}
void
SOP_OpenVDB_Points_Group::Cache::removeViewportMetadata(
PointDataGrid& outputGrid)
{
outputGrid.removeMeta(openvdb_houdini::META_GROUP_VIEWPORT);
}
| 34,440 | C++ | 35.215563 | 117 | 0.61806 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Sort_Points.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Sort_Points.cc
///
/// @author Mihai Alden
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/GU_VDBPointTools.h>
#include <openvdb/tools/PointPartitioner.h>
#include <GA/GA_AttributeFilter.h>
#include <GA/GA_ElementWrangler.h>
#include <GA/GA_PageIterator.h>
#include <GA/GA_SplittableRange.h>
#include <GU/GU_Detail.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_UniquePtr.h>
#include <tbb/blocked_range.h>
#include <tbb/parallel_for.h>
#include <memory>
#include <stdexcept>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
// Local Utility Methods
namespace {
struct CopyElements {
CopyElements(GA_PointWrangler& wrangler, const GA_Offset* offsetArray)
: mWrangler(&wrangler), mOffsetArray(offsetArray) { }
void operator()(const GA_SplittableRange& range) const {
GA_Offset start, end;
for (GA_PageIterator pageIt = range.beginPages(); !pageIt.atEnd(); ++pageIt) {
for (GA_Iterator blockIt(pageIt.begin()); blockIt.blockAdvance(start, end); ) {
for (GA_Offset i = start; i < end; ++i) {
mWrangler->copyAttributeValues(i, mOffsetArray[i]);
}
}
}
}
GA_PointWrangler * const mWrangler;
GA_Offset const * const mOffsetArray;
}; // struct CopyElements
struct SetOffsets
{
using PointPartitioner = openvdb::tools::UInt32PointPartitioner;
SetOffsets(const GU_Detail& srcGeo, const PointPartitioner& partitioner, GA_Offset* offsetArray)
: mSrcGeo(&srcGeo), mPartitioner(&partitioner), mOffsetArray(offsetArray) { }
void operator()(const tbb::blocked_range<size_t>& range) const {
size_t idx = 0;
for (size_t n = 0, N = range.begin(); n != N; ++n) {
idx += mPartitioner->indices(n).size(); // increment to start index
}
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
for (PointPartitioner::IndexIterator it = mPartitioner->indices(n); it; ++it) {
mOffsetArray[idx++] = mSrcGeo->pointOffset(*it);
}
}
}
GU_Detail const * const mSrcGeo;
PointPartitioner const * const mPartitioner;
GA_Offset * const mOffsetArray;
}; // struct SetOffsets
} // unnamed namespace
////////////////////////////////////////
// SOP Implementation
struct SOP_OpenVDB_Sort_Points: public hvdb::SOP_NodeVDB
{
SOP_OpenVDB_Sort_Points(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
};
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "pointgroup", "Point Group")
.setChoiceList(&SOP_Node::pointGroupMenu)
.setTooltip("A group of points to rasterize."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "binsize", "Bin Size")
.setDefault(PRMpointOneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 5)
.setTooltip("The size (length of a side) of the cubic bin, in world units."));
hvdb::OpenVDBOpFactory("VDB Sort Points",
SOP_OpenVDB_Sort_Points::factory, parms, *table)
.setNativeName("")
.addInput("points")
.setVerb(SOP_NodeVerb::COOK_GENERATOR, []() { return new SOP_OpenVDB_Sort_Points::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Reorder points into spatially-organized bins.\"\"\"\n\
\n\
@overview\n\
\n\
This node reorders Houdini points so that they are sorted into\n\
three-dimensional spatial bins.\n\
By increasing CPU cache locality of point data, sorting can improve the\n\
performance of algorithms such as rasterization that rely on neighbor access.\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
OP_Node*
SOP_OpenVDB_Sort_Points::factory(OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Sort_Points(net, name, op);
}
SOP_OpenVDB_Sort_Points::SOP_OpenVDB_Sort_Points(OP_Network* net, const char* name, OP_Operator* op)
: hvdb::SOP_NodeVDB(net, name, op)
{
}
OP_ERROR
SOP_OpenVDB_Sort_Points::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
const GU_Detail* srcGeo = inputGeo(0);
UT_UniquePtr<GA_Offset[]> srcOffsetArray;
size_t numPoints = 0;
{ // partition points and construct ordered offset list
const GA_PointGroup* pointGroup = parsePointGroups(
evalStdString("pointgroup", time).c_str(), GroupCreator(srcGeo));
const fpreal voxelSize = evalFloat("binsize", 0, time);
const openvdb::math::Transform::Ptr transform =
openvdb::math::Transform::createLinearTransform(voxelSize);
GU_VDBPointList<openvdb::Vec3s> points(*srcGeo, pointGroup);
openvdb::tools::UInt32PointPartitioner partitioner;
partitioner.construct(points, *transform, /*voxel order=*/true);
numPoints = points.size();
srcOffsetArray.reset(new GA_Offset[numPoints]);
tbb::parallel_for(tbb::blocked_range<size_t>(0, partitioner.size()),
SetOffsets(*srcGeo, partitioner, srcOffsetArray.get()));
}
// order point attributes
gdp->appendPointBlock(numPoints);
gdp->cloneMissingAttributes(*srcGeo, GA_ATTRIB_POINT, GA_AttributeFilter::selectPublic());
GA_PointWrangler ptWrangler(*gdp, *srcGeo, GA_PointWrangler::INCLUDE_P);
UTparallelFor(GA_SplittableRange(gdp->getPointRange()),
CopyElements(ptWrangler, srcOffsetArray.get()));
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 6,179 | C++ | 29.294118 | 100 | 0.641528 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Densify.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Densify.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief SOP to replace active tiles with active voxels in OpenVDB grids
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <UT/UT_Interrupt.h>
#include <stdexcept>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Densify: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Densify(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
};
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDBs to be densified.")
.setDocumentation(
"A subset of the input VDBs to be densified"
" (see [specifying volumes|/model/volumes#group])"));
hvdb::OpenVDBOpFactory("VDB Densify", SOP_OpenVDB_Densify::factory, parms, *table)
.setNativeName("")
.addInput("VDBs to densify")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Densify::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Densify sparse VDB volumes.\"\"\"\n\
\n\
@overview\n\
\n\
This node replaces active\n\
[tiles|http://www.openvdb.org/documentation/doxygen/overview.html#secSparsity]\n\
in VDB [trees|http://www.openvdb.org/documentation/doxygen/overview.html#secTree]\n\
with dense, leaf-level voxels.\n\
This is useful for subsequent processing with nodes like [Node:sop/volumevop]\n\
that operate only on leaf voxels.\n\
\n\
WARNING:\n\
Densifying a sparse VDB can significantly increase its memory footprint.\n\
\n\
@related\n\
- [OpenVDB Fill|Node:sop/DW_OpenVDBFill]\n\
- [OpenVDB Prune|Node:sop/DW_OpenVDBPrune]\n\
- [Node:sop/vdbactivate]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Densify::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Densify(net, name, op);
}
SOP_OpenVDB_Densify::SOP_OpenVDB_Densify(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
namespace {
struct DensifyOp {
DensifyOp() {}
template<typename GridT>
void operator()(GridT& grid) const
{
grid.tree().voxelizeActiveTiles(/*threaded=*/true);
}
};
}
OP_ERROR
SOP_OpenVDB_Densify::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
// Get the group of grids to process.
const GA_PrimitiveGroup* group = this->matchGroup(*gdp, evalStdString("group", time));
// Construct a functor to process grids of arbitrary type.
const DensifyOp densifyOp;
UT_AutoInterrupt progress("Densifying VDBs");
// Process each VDB primitive that belongs to the selected group.
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (progress.wasInterrupted()) {
throw std::runtime_error("processing was interrupted");
}
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, densifyOp);
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 3,850 | C++ | 25.376712 | 94 | 0.648571 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_From_Polygons.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_From_Polygons.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Converts a closed mesh of trinagles and/or quads into different VDB volumes.
/// The supported volumes are: Signed distance field / level-set, closest primitive grid
/// and grids with different mesh attributes (closest UVW, Normal etc.)
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/AttributeTransferUtil.h>
#include <openvdb_houdini/GeometryUtil.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/MeshToVolume.h>
#include <openvdb/tools/LevelSetUtil.h>
#include <openvdb/util/Util.h>
#include <CH/CH_Manager.h>
#include <PRM/PRM_Parm.h>
#include <PRM/PRM_SharedFunc.h>
#include <algorithm> // for std::max()
#include <sstream>
#include <stdexcept>
#include <string>
#include <limits>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace {
enum AttributeClass { POINT_ATTR, VERTEX_ATTR, PRIMITIVE_ATTR };
inline bool
evalAttrType(const UT_String& attrStr, UT_String& attrName, int& attrClass)
{
std::string str = attrStr.toStdString();
const size_t idx = str.find_first_of('.');
if (idx == std::string::npos) return false;
attrName = str.substr(idx + 1, str.size() - 1);
str = str.substr(0, 2);
if (str == "po") attrClass = POINT_ATTR;
else if (str == "ve") attrClass = VERTEX_ATTR;
else if (str == "pr") attrClass = PRIMITIVE_ATTR;
else return false;
return true;
}
inline int
lookupAttrInput(const PRM_SpareData* spare)
{
const char *istring;
if (!spare) return 0;
istring = spare->getValue("sop_input");
return istring ? atoi(istring) : 0;
}
inline void
sopBuildAttrMenu(void* data, PRM_Name* menuEntries, int themenusize,
const PRM_SpareData* spare, const PRM_Parm*)
{
if (data == nullptr || menuEntries == nullptr || spare == nullptr) return;
size_t menuIdx = 0;
menuEntries[menuIdx].setToken("point.v");
menuEntries[menuIdx++].setLabel("point.v");
SOP_Node* sop = CAST_SOPNODE(static_cast<OP_Node*>(data));
if (sop == nullptr) {
// terminate and quit
menuEntries[menuIdx].setToken(0);
menuEntries[menuIdx].setLabel(0);
return;
}
int inputIndex = lookupAttrInput(spare);
const GU_Detail* gdp = sop->getInputLastGeo(inputIndex, CHgetEvalTime());
size_t menuEnd(themenusize - 2);
if (gdp) {
// point attribute names
GA_AttributeDict::iterator iter = gdp->pointAttribs().begin(GA_SCOPE_PUBLIC);
if(!iter.atEnd() && menuIdx != menuEnd) {
if (menuIdx > 0) {
menuEntries[menuIdx].setToken(PRM_Name::mySeparator);
menuEntries[menuIdx++].setLabel(PRM_Name::mySeparator);
}
for (; !iter.atEnd() && menuIdx != menuEnd; ++iter) {
std::ostringstream token;
token << "point." << (*iter)->getName();
menuEntries[menuIdx].setToken(token.str().c_str());
menuEntries[menuIdx++].setLabel(token.str().c_str());
}
}
// vertex attribute names
iter = gdp->vertexAttribs().begin(GA_SCOPE_PUBLIC);
if(!iter.atEnd() && menuIdx != menuEnd) {
if (menuIdx > 0) {
menuEntries[menuIdx].setToken(PRM_Name::mySeparator);
menuEntries[menuIdx++].setLabel(PRM_Name::mySeparator);
}
for (; !iter.atEnd() && menuIdx != menuEnd; ++iter) {
std::ostringstream token;
token << "vertex." << (*iter)->getName();
menuEntries[menuIdx].setToken(token.str().c_str());
menuEntries[menuIdx++].setLabel(token.str().c_str());
}
}
// primitive attribute names
iter = gdp->primitiveAttribs().begin(GA_SCOPE_PUBLIC);
if(menuIdx != menuEnd) {
if (menuIdx > 0) {
menuEntries[menuIdx].setToken(PRM_Name::mySeparator);
menuEntries[menuIdx++].setLabel(PRM_Name::mySeparator);
}
for (; !iter.atEnd() && menuIdx != menuEnd; ++iter) {
std::ostringstream token;
token << "primitive." << (*iter)->getName();
menuEntries[menuIdx].setToken(token.str().c_str());
menuEntries[menuIdx++].setLabel(token.str().c_str());
}
// Special case
menuEntries[menuIdx].setToken("primitive.primitive_list_index");
menuEntries[menuIdx++].setLabel("primitive.primitive_list_index");
}
}
// terminator
menuEntries[menuIdx].setToken(0);
menuEntries[menuIdx].setLabel(0);
}
const PRM_ChoiceList PrimAttrMenu(
PRM_ChoiceListType(PRM_CHOICELIST_REPLACE), sopBuildAttrMenu);
} // unnamed namespace
////////////////////////////////////////
class SOP_OpenVDB_From_Polygons: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_From_Polygons(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_From_Polygons() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i ) const override { return (i == 1); }
int convertUnits();
class Cache: public SOP_VDBCacheOptions
{
public:
float voxelSize() const { return mVoxelSize; }
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
private:
int constructGenericAtttributeLists(
hvdb::AttributeDetailList &pointAttributes,
hvdb::AttributeDetailList &vertexAttributes,
hvdb::AttributeDetailList &primitiveAttributes,
const GU_Detail&,
const openvdb::Int32Grid& closestPrimGrid,
const float time);
template <class ValueType>
void addAttributeDetails(
hvdb::AttributeDetailList &attributeList,
const GA_Attribute *attribute,
const GA_AIFTuple *tupleAIF,
const int attrTupleSize,
const openvdb::Int32Grid& closestPrimGrid,
std::string& customName,
int vecType = -1);
void transferAttributes(
hvdb::AttributeDetailList &pointAttributes,
hvdb::AttributeDetailList &vertexAttributes,
hvdb::AttributeDetailList &primitiveAttributes,
const openvdb::Int32Grid&,
openvdb::math::Transform::Ptr& transform,
const GU_Detail&);
float mVoxelSize = 0.1f;
}; // class Cache
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
};
////////////////////////////////////////
namespace
{
// Callback to convert from voxel to world space units
int
convertUnitsCB(void* data, int /*idx*/, float /*time*/, const PRM_Template*)
{
SOP_OpenVDB_From_Polygons* sop = static_cast<SOP_OpenVDB_From_Polygons*>(data);
if (sop == nullptr) return 0;
return sop->convertUnits();
}
} // unnamed namespace
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
//////////
// Output grids
// distance field
parms.add(hutil::ParmFactory(PRM_TOGGLE, "builddistance", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("Enable / disable the level set output.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_STRING, "distancename", "Distance VDB")
.setDefault("surface")
.setTooltip(
"Output a signed distance field VDB with the given name.\n\n"
"An SDF stores the distance to the surface in each voxel."
" If a voxel is inside the surface, the distance is negative."));
// fog volume
parms.add(hutil::ParmFactory(PRM_TOGGLE, "buildfog", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("Enable / disable the fog volume output.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_STRING, "fogname", "Fog VDB")
.setDefault("density")
.setTooltip(
"Output a fog volume VDB with the given name.\n\n"
"Voxels inside the surface have value one, and voxels outside"
" have value zero. Within a narrow band centered on the surface,"
" voxel values vary linearly from zero to one.\n\n"
"Turn on __Fill Interior__ to create a solid VDB"
" (from an airtight surface) instead of a narrow band."));
//////////
// Conversion settings
parms.add(hutil::ParmFactory(PRM_HEADING, "conversionheading", "Conversion settings"));
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Reference VDB")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip(
"Give the output VDB the same orientation and voxel size as the selected VDB,"
" and match the narrow band width if the reference VDB is a level set.")
.setDocumentation(
"Give the output VDB the same orientation and voxel size as"
" the selected VDB (see [specifying volumes|/model/volumes#group])"
" and match the narrow band width if the reference VDB is a level set."));
// Voxel size or voxel count menu
parms.add(hutil::ParmFactory(PRM_STRING, "sizeorcount", "Voxel")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"worldVoxelSize", "Size in World Units",
"countX", "Count Along X Axis",
"countY", "Count Along Y Axis",
"countZ", "Count Along Z Axis",
"countLongest", "Count Along Longest Axis"
})
.setDefault("worldVoxelSize")
.setTooltip(
"How to specify the voxel size: either in world units or as"
" a voxel count along one axis"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxelsize", "Voxel Size")
.setDefault(PRMpointOneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 5)
.setTooltip(
"The desired voxel size in world units\n\n"
"Surface features smaller than this will not be represented in the output VDB."));
parms.add(hutil::ParmFactory(PRM_INT_J, "voxelcount", "Voxel Count")
.setDefault(100)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 500)
.setTooltip(
"The desired voxel count along one axis\n\n"
"The resulting voxel count might be off by one voxel"
" due to roundoff errors during the conversion process."));
// Narrow-band width {
parms.add(hutil::ParmFactory(PRM_TOGGLE, "useworldspaceunits",
"Use World Space Units for Narrow Band")
.setCallbackFunc(&convertUnitsCB)
.setTooltip(
"If enabled, specify the narrow band width in world units,"
" otherwise in voxels."));
// voxel space units
parms.add(hutil::ParmFactory(PRM_INT_J, "exteriorbandvoxels", "Exterior Band Voxels")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip(
"The width of the exterior (distance >= 0) portion of the narrow band\n"
"Many level set operations require a minimum of three voxels.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_INT_J, "interiorbandvoxels", "Interior Band Voxels")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip(
"The width of the interior (distance < 0) portion of the narrow band\n"
"Many level set operations require a minimum of three voxels.")
.setDocumentation(nullptr));
// world space units
parms.add(hutil::ParmFactory(PRM_FLT_J, "exteriorband", "Exterior Band")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 10)
.setTooltip("The width of the exterior (distance >= 0) portion of the narrow band")
.setDocumentation(
"The width of the exterior (_distance_ => 0) portion of the narrow band"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "interiorband", "Interior Band")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 10)
.setTooltip("The width of the interior (distance < 0) portion of the narrow band")
.setDocumentation(
"The width of the interior (_distance_ < 0) portion of the narrow band"));
// }
// Options
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fillinterior", "Fill Interior")
.setTooltip(
"Extract signed distances for all interior voxels.\n\n"
"This operation densifies the interior of the model."
" It requires a closed, watertight surface."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "unsigneddist", "Unsigned Distance Field")
.setTooltip(
"Generate an unsigned distance field.\n"
"This operation will work on any surface, whether or not it is closed or watertight.")
.setDocumentation(
"Generate an unsigned distance field.\n\n"
"This operation will work on any surface, whether or not"
" it is closed or watertight. It is similar to the Minimum"
" function of the [Node:sop/isooffset] node."));
//////////
// Mesh attribute transfer {Point, Vertex & Primitive}
parms.add(hutil::ParmFactory(PRM_HEADING, "transferheading", "Attribute Transfer"));
hutil::ParmList attrParms;
// Attribute name
attrParms.add(hutil::ParmFactory(PRM_STRING, "attribute#", "Attribute")
.setChoiceList(&PrimAttrMenu)
.setSpareData(&SOP_Node::theFirstInput)
.setTooltip(
"A point, vertex, or primitive attribute from which to create a VDB\n\n"
"Supports integer and floating point attributes of arbitrary"
" precision and tuple size."));
attrParms.add(hutil::ParmFactory(PRM_STRING, "attributeGridName#", "VDB Name")
.setTooltip("The name for this VDB primitive (leave blank to use the attribute's name)"));
// Vec type menu
{
std::vector<std::string> items;
for (int i = 0; i < openvdb::NUM_VEC_TYPES ; ++i) {
items.push_back(openvdb::GridBase::vecTypeToString(openvdb::VecType(i)));
items.push_back(openvdb::GridBase::vecTypeExamples(openvdb::VecType(i)));
}
attrParms.add(hutil::ParmFactory(PRM_ORD, "vecType#", "Vector Type")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip("How vector values should be interpreted"));
}
// Add multi parm
parms.add(hutil::ParmFactory(PRM_MULTITYPE_LIST, "attrList", "Surface Attributes")
.setMultiparms(attrParms)
.setDefault(PRMzeroDefaults)
.setTooltip(
"Generate additional VDB primitives that store the values of"
" primitive (face), point, or vertex attributes.")
.setDocumentation(
"Generate additional VDB primitives that store the values of primitive"
" (face), point, or vertex [attributes|/model/attributes].\n\n"
"Only voxels in the narrow band around the surface will be set."));
//////////
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "optionsHeading", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "otherHeading", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "verbose", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "attrHeading", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "isoOffset", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "gradientWidth", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "customGradientWidth", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "sdfHeading", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "addSdfGridName", "")); // fix
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "sdfGridName", "")); // fix
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "outputClosestPrimGrid", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "closestPrimGridName", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "transformHeading", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "outputHeading", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "hermiteData", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "hermiteDataGridName", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "matchlevelset", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "distanceField", "")
.setDefault(PRMoneDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "distanceFieldGridName", "")
.setDefault("surface"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "fogVolume", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "fogVolumeGridName", "")
.setDefault("density"));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "conversionHeading", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_STRING, "sizeOrCount", "")
.setDefault("worldVoxelSize"));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "voxelSize", "")
.setDefault(PRMpointOneDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "voxelCount", "").setDefault(100));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "worldSpaceUnits", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "exteriorBandWidth", "")
.setDefault(PRMthreeDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "interiorBandWidth", "")
.setDefault(PRMthreeDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "exteriorBandWidthWS", "")
.setDefault(PRMoneDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "interiorBandWidthWS", "")
.setDefault(PRMoneDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "fillInterior", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "unsignedDist", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "transferHeading", ""));
//obsoleteParms.add(hutil::ParmFactory(PRM_MULTITYPE_LIST, "attrList", "")
// .setDefault(PRMzeroDefaults)); ///< @todo crashes in OP_Node::createObsoleteParmList()
/// @todo obsoleteAttrParms
//////////
// Register this operator.
hvdb::OpenVDBOpFactory("VDB from Polygons",
SOP_OpenVDB_From_Polygons::factory, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBFromPolygons")
#endif
.addInput("Polygons to Convert")
.addOptionalInput("Optional Reference VDB (for transform matching)")
.setObsoleteParms(obsoleteParms)
.setVerb(SOP_NodeVerb::COOK_GENERATOR,
[]() { return new SOP_OpenVDB_From_Polygons::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Convert polygonal surfaces and/or surface attributes into VDB volumes.\"\"\"\n\
\n\
@overview\n\
\n\
This node can create signed or unsigned distance fields\n\
and/or density fields (\"fog volumes\") from polygonal surfaces.\n\
\n\
When you create a fog volume you can choose either to fill the band of voxels\n\
on the surface or (if you have an airtight surface) to fill the interior\n\
of the surface (see the __Fill interior__ parameter).\n\
\n\
Since the resulting VDB volumes store only the voxels near the surface,\n\
they can have a much a higher effective resolution than a traditional volume\n\
created with [Node:sop/isooffset].\n\
\n\
You can connect a VDB to the second input to automatically use that VDB's\n\
orientation and voxel size (see the __Reference VDB__ parameter).\n\
\n\
NOTE:\n\
The input geometry must be a quad or triangle mesh.\n\
This node will convert the input surface into such a mesh if necessary.\n\
\n\
@inputs\n\
\n\
Polygonal mesh to convert:\n\
The polygonal surface to convert.\n\
Optional reference VDB:\n\
If connected, give the output VDB the same orientation and voxel size\n\
as a VDB from this input.\n\
\n\
@related\n\
- [OpenVDB Create|Node:sop/DW_OpenVDBCreate]\n\
- [OpenVDB From Particles|Node:sop/DW_OpenVDBFromParticles]\n\
- [Node:sop/isooffset]\n\
- [Node:sop/vdbfrompolygons]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_From_Polygons::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_From_Polygons(net, name, op);
}
SOP_OpenVDB_From_Polygons::SOP_OpenVDB_From_Polygons(OP_Network* net,
const char* name, OP_Operator* op)
: hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
int
SOP_OpenVDB_From_Polygons::convertUnits()
{
const bool toWSUnits = static_cast<bool>(evalInt("useworldspaceunits", 0, 0));
float width;
float voxSize = 0.1f;
// Attempt to extract the voxel size from our cache.
if (const auto* cache = dynamic_cast<SOP_OpenVDB_From_Polygons::Cache*>(myNodeVerbCache)) {
voxSize = cache->voxelSize();
}
if (toWSUnits) {
width = static_cast<float>(evalInt("exteriorbandvoxels", 0, 0));
setFloat("exteriorband", 0, 0, width * voxSize);
width = static_cast<float>(evalInt("interiorbandvoxels", 0, 0));
setFloat("interiorband", 0, 0, width * voxSize);
return 1;
}
width = static_cast<float>(evalFloat("exteriorband", 0, 0));
int voxelWidth = std::max(static_cast<int>(width / voxSize), 1);
setInt("exteriorbandvoxels", 0, 0, voxelWidth);
width = static_cast<float>(evalFloat("interiorband", 0, 0));
voxelWidth = std::max(static_cast<int>(width / voxSize), 1);
setInt("interiorbandvoxels", 0, 0, voxelWidth);
return 1;
}
////////////////////////////////////////
void
SOP_OpenVDB_From_Polygons::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
//resolveRenamedParm(*obsoleteParms, "attrList", "numattrib");
resolveRenamedParm(*obsoleteParms, "distanceField", "builddistance");
resolveRenamedParm(*obsoleteParms, "distanceFieldGridName", "distancename");
resolveRenamedParm(*obsoleteParms, "fogVolume", "buildfog");
resolveRenamedParm(*obsoleteParms, "fogVolumeGridName", "fogname");
resolveRenamedParm(*obsoleteParms, "sizeOrCount", "sizeorcount");
resolveRenamedParm(*obsoleteParms, "voxelSize", "voxelsize");
resolveRenamedParm(*obsoleteParms, "voxelCount", "voxelcount");
resolveRenamedParm(*obsoleteParms, "worldSpaceUnits", "useworldspaceunits");
resolveRenamedParm(*obsoleteParms, "exteriorBandWidth", "exteriorbandvoxels");
resolveRenamedParm(*obsoleteParms, "interiorBandWidth", "interiorbandvoxels");
resolveRenamedParm(*obsoleteParms, "exteriorBandWidthWS", "exteriorband");
resolveRenamedParm(*obsoleteParms, "interiorBandWidthWS", "interiorband");
resolveRenamedParm(*obsoleteParms, "fillInterior", "fillinterior");
resolveRenamedParm(*obsoleteParms, "unsignedDist", "unsigneddist");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
////////////////////////////////////////
// Enable or disable parameters in the UI.
bool
SOP_OpenVDB_From_Polygons::updateParmsFlags()
{
bool changed = false;
const fpreal time = 0; // No point using CHgetTime as that is unstable.
int refexists = (nInputs() == 2);
// Transform
changed |= enableParm("group", refexists);
// Conversion
const bool wsUnits = bool(evalInt("useworldspaceunits", 0, time));
const bool fillInterior = bool(evalInt("fillinterior", 0, time));
const bool unsignedDist = bool(evalInt("unsigneddist", 0, time));
// Voxel size or voxel count menu
const bool countMenu = (evalStdString("sizeorcount", time) != "worldVoxelSize");
changed |= setVisibleState("voxelsize", !countMenu);
changed |= setVisibleState("voxelcount", countMenu);
changed |= enableParm("voxelsize", !countMenu && !refexists);
changed |= enableParm("voxelcount", countMenu && !refexists);
changed |= enableParm("interiorbandvoxels", !wsUnits && !fillInterior && !unsignedDist);
changed |= enableParm("exteriorband", wsUnits && !fillInterior && !unsignedDist);
changed |= enableParm("exteriorbandvoxels", !wsUnits);
changed |= enableParm("exteriorband", wsUnits);
changed |= setVisibleState("interiorbandvoxels", !wsUnits);
changed |= setVisibleState("exteriorbandvoxels", !wsUnits);
changed |= setVisibleState("interiorband", wsUnits);
changed |= setVisibleState("exteriorband", wsUnits);
changed |= enableParm("fillinterior", !unsignedDist);
// Output
changed |= enableParm("distancename", bool(evalInt("builddistance", 0, time)));
changed |= enableParm("fogname", bool(evalInt("buildfog", 0, time)) && !unsignedDist);
changed |= enableParm("buildfog", !unsignedDist);
// enable / diable vector type menu
UT_String attrStr, attrName;
GA_ROAttributeRef attrRef;
int attrClass = POINT_ATTR;
const GU_Detail* meshGdp = this->getInputLastGeo(0, time);
for (int i = 1, N = static_cast<int>(evalInt("attrList", 0, time)); i <= N; ++i) {
bool isVector = true;
if (meshGdp) {
isVector = false;
evalStringInst("attribute#", &i, attrStr, 0, time);
if (attrStr.length() != 0 && evalAttrType(attrStr, attrName, attrClass)) {
if (attrClass == POINT_ATTR) {
attrRef = meshGdp->findPointAttribute(attrName);
} else if (attrClass == VERTEX_ATTR) {
attrRef = meshGdp->findVertexAttribute(attrName);
} else if (attrClass == PRIMITIVE_ATTR) {
attrRef = meshGdp->findPrimitiveAttribute(attrName);
}
if (attrRef.isValid()) {
const GA_Attribute *attr = attrRef.getAttribute();
if (attr) {
const GA_TypeInfo typeInfo = attr->getTypeInfo();
isVector = (typeInfo == GA_TYPE_HPOINT || typeInfo == GA_TYPE_POINT
|| typeInfo == GA_TYPE_VECTOR || typeInfo == GA_TYPE_NORMAL);
if (!isVector) {
const GA_AIFTuple *tupleAIF = attr->getAIFTuple();
if (tupleAIF) isVector = tupleAIF->getTupleSize(attr) == 3;
}
}
}
}
}
changed |= enableParmInst("vectype#", &i, isVector);
changed |= setVisibleStateInst("vectype#", &i, isVector);
}
return changed;
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_From_Polygons::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
hvdb::Interrupter boss("Converting geometry to volume");
//////////
// Validate the input
const GU_Detail* inputGdp = inputGeo(0);
if (!inputGdp || !inputGdp->getNumPrimitives()) {
addWarning(SOP_MESSAGE, "No mesh to convert");
// We still create the grids as later workflow
// may be able to handle an empty grid.
}
// Validate geometry
std::string warningStr;
auto geoPtr = hvdb::convertGeometry(*inputGdp, warningStr, &boss);
if (geoPtr) {
inputGdp = geoPtr.get();
if (!warningStr.empty()) addWarning(SOP_MESSAGE, warningStr.c_str());
}
//////////
// Evaluate the UI parameters.
const bool outputDistanceField = bool(evalInt("builddistance", 0, time));
const bool unsignedDistanceFieldConversion = bool(evalInt("unsigneddist", 0, time));
const bool outputFogVolumeGrid = bool(evalInt("buildfog", 0, time));
const bool outputAttributeGrid = bool(evalInt("attrList", 0, time) > 0);
if (!outputDistanceField && !outputFogVolumeGrid && !outputAttributeGrid) {
addWarning(SOP_MESSAGE, "No output selected");
return error();
}
openvdb::math::Transform::Ptr transform;
float inBand = std::numeric_limits<float>::max(), exBand = 0.0;
const GU_Detail* refGdp = inputGeo(1);
bool secondinput = refGdp != nullptr;
if (secondinput) {
// Get the first grid's transform
const GA_PrimitiveGroup *refGroup = matchGroup(*refGdp, evalStdString("group", time));
hvdb::VdbPrimCIterator gridIter(refGdp, refGroup);
if (gridIter) {
transform = (*gridIter)->getGrid().transform().copy();
mVoxelSize = static_cast<float>(transform->voxelSize()[0]);
++gridIter;
} else {
addError(SOP_MESSAGE, "Could not find a reference grid");
return error();
}
} else {// derive the voxel size and define output grid's transform
UT_String str;
evalString(str, "sizeorcount", 0, time);
if ( str == "worldVoxelSize" ) {
mVoxelSize = static_cast<float>(evalFloat("voxelsize", 0, time));
} else {
const float dim = static_cast<float>(evalInt("voxelcount", 0, time));
UT_BoundingBox bbox;
inputGdp->getCachedBounds(bbox);
const float size = str == "countX" ? bbox.xsize() : str == "countY" ? bbox.ysize() :
str == "countZ" ? bbox.ysize() : bbox.sizeMax();
if ( evalInt("useworldspaceunits", 0, time) ) {
const float w = static_cast<float>(evalFloat("exteriorband", 0, time));
mVoxelSize = (size + 2.0f*w)/dim;
} else {
const float w = static_cast<float>(evalInt("exteriorbandvoxels", 0, time));
mVoxelSize = size/std::max(1.0f, dim - 2.0f*w);
}
}
// Create a new transform
transform = openvdb::math::Transform::createLinearTransform(mVoxelSize);
}
if (mVoxelSize < 1e-5) {
std::ostringstream ostr;
ostr << "The voxel size ("<< mVoxelSize << ") is too small.";
addError(SOP_MESSAGE, ostr.str().c_str());
return error();
}
// Set the narrow-band parameters
{
const bool wsUnits = static_cast<bool>(evalInt("useworldspaceunits", 0, time));
if (wsUnits) {
exBand = static_cast<float>(evalFloat("exteriorband", 0, time) / mVoxelSize);
} else {
exBand = static_cast<float>(evalInt("exteriorbandvoxels", 0, time));
}
if (!bool(evalInt("fillinterior", 0, time))) {
if (wsUnits) {
inBand = static_cast<float>(evalFloat("interiorband", 0, time) / mVoxelSize);
} else {
inBand = static_cast<float>(evalInt("interiorbandvoxels", 0, time));
}
}
}
//////////
// Copy the input mesh and transform to local grid space.
std::vector<openvdb::Vec3s> pointList;
std::vector<openvdb::Vec4I> primList;
if (!boss.wasInterrupted()) {
pointList.resize(inputGdp->getNumPoints());
primList.resize(inputGdp->getNumPrimitives());
UTparallelFor(GA_SplittableRange(inputGdp->getPointRange()),
hvdb::TransformOp(inputGdp, *transform, pointList));
UTparallelFor(GA_SplittableRange(inputGdp->getPrimitiveRange()),
hvdb::PrimCpyOp(inputGdp, primList));
}
//////////
// Mesh to volume conversion
openvdb::tools::QuadAndTriangleDataAdapter<openvdb::Vec3s, openvdb::Vec4I>
mesh(pointList, primList);
int conversionFlags = unsignedDistanceFieldConversion ?
openvdb::tools::UNSIGNED_DISTANCE_FIELD : 0;
openvdb::Int32Grid::Ptr primitiveIndexGrid;
if (outputAttributeGrid) {
primitiveIndexGrid.reset(new openvdb::Int32Grid(0));
}
openvdb::FloatGrid::Ptr grid = openvdb::tools::meshToVolume<openvdb::FloatGrid>(
boss, mesh, *transform, exBand, inBand, conversionFlags, primitiveIndexGrid.get());
//////////
// Output
// Distance field / level set
if (!boss.wasInterrupted() && outputDistanceField) {
hvdb::createVdbPrimitive(*gdp, grid, evalStdString("distancename", time).c_str());
}
// Fog volume
if (!boss.wasInterrupted() && outputFogVolumeGrid && !unsignedDistanceFieldConversion) {
// If no level set grid is exported the original level set
// grid is modified in place.
openvdb::FloatGrid::Ptr outputGrid;
if (outputDistanceField) {
outputGrid = grid->deepCopy();
} else {
outputGrid = grid;
}
openvdb::tools::sdfToFogVolume(*outputGrid);
hvdb::createVdbPrimitive(*gdp, outputGrid, evalStdString("fogname", time).c_str());
}
// Transfer mesh attributes
if (!boss.wasInterrupted() && outputAttributeGrid) {
hvdb::AttributeDetailList pointAttributes;
hvdb::AttributeDetailList vertexAttributes;
hvdb::AttributeDetailList primitiveAttributes;
int closestPrimIndexInstance =
constructGenericAtttributeLists(pointAttributes, vertexAttributes,
primitiveAttributes, *inputGdp, *primitiveIndexGrid, float(time));
transferAttributes(pointAttributes, vertexAttributes, primitiveAttributes,
*primitiveIndexGrid, transform, *inputGdp);
// Export the closest prim idx grid.
if (!boss.wasInterrupted() && closestPrimIndexInstance > -1) {
UT_String gridNameStr;
evalStringInst("attributeGridName#", &closestPrimIndexInstance,
gridNameStr, 0, time);
if (gridNameStr.length() == 0) gridNameStr = "primitive_list_index";
hvdb::createVdbPrimitive(
*gdp, primitiveIndexGrid, gridNameStr.toStdString().c_str());
}
}
if (boss.wasInterrupted()) {
addWarning(SOP_MESSAGE, "Process was interrupted");
}
boss.end();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
////////////////////////////////////////
// Helper method constructs the attribute detail lists
int
SOP_OpenVDB_From_Polygons::Cache::constructGenericAtttributeLists(
hvdb::AttributeDetailList &pointAttributes,
hvdb::AttributeDetailList &vertexAttributes,
hvdb::AttributeDetailList &primitiveAttributes,
const GU_Detail& meshGdp,
const openvdb::Int32Grid& closestPrimGrid,
const float time)
{
UT_String attrStr, attrName;
GA_ROAttributeRef attrRef;
GA_Range range;
int attrClass = POINT_ATTR;
int closestPrimIndexInstance = -1;
// for each selected attribute
for (int i = 1, N = static_cast<int>(evalInt("attrList", 0, time)); i <= N; ++i) {
evalStringInst("attribute#", &i, attrStr, 0, time);
if (attrStr.length() == 0) continue;
if (!evalAttrType(attrStr, attrName, attrClass)) {
std::ostringstream ostr;
ostr << "Skipped attribute with unrecognized class {point/vertex/prim}: "<< attrStr;
addWarning(SOP_MESSAGE, ostr.str().c_str());
continue;
}
hvdb::AttributeDetailList* attributeList = nullptr;
if (attrClass == POINT_ATTR) {
attrRef = meshGdp.findPointAttribute(attrName);
attributeList = &pointAttributes;
} else if (attrClass == VERTEX_ATTR) {
attrRef = meshGdp.findVertexAttribute(attrName);
attributeList = &vertexAttributes;
} else if (attrClass == PRIMITIVE_ATTR) {
if (attrName == "primitive_list_index") {
// The closest prim idx grid is a special case,
// the converter has already generated it for us.
closestPrimIndexInstance = i;
continue;
}
attrRef = meshGdp.findPrimitiveAttribute(attrName);
attributeList = &primitiveAttributes;
}
if (attrName.length() == 0 || !attrRef.isValid()) {
std::ostringstream ostr;
ostr << "Skipped unrecognized attribute: "<< attrName;
addWarning(SOP_MESSAGE, ostr.str().c_str());
continue;
}
evalStringInst("attributeGridName#", &i, attrStr, 0, time);
std::string customName = attrStr.toStdString();
int vecType = static_cast<int>(evalIntInst("vecType#", &i, 0, time));
const GA_Attribute *attr = attrRef.getAttribute();
if (!attr) {
std::ostringstream ostr;
ostr << "Skipped unrecognized attribute type for: "<< attrName;
addWarning(SOP_MESSAGE, ostr.str().c_str());
continue;
}
const GA_AIFTuple *tupleAIF = attr->getAIFTuple();
if (!tupleAIF) {
std::ostringstream ostr;
ostr << "Skipped unrecognized attribute type for: "<< attrName;
addWarning(SOP_MESSAGE, ostr.str().c_str());
continue;
}
const GA_Storage attrStorage = tupleAIF->getStorage(attr);
const int attrTupleSize = tupleAIF->getTupleSize(attr);
const GA_TypeInfo typeInfo = attr->getTypeInfo();
const bool interpertAsVector = (typeInfo == GA_TYPE_HPOINT || typeInfo == GA_TYPE_POINT
|| typeInfo == GA_TYPE_VECTOR || typeInfo == GA_TYPE_NORMAL);
switch (attrStorage)
{
case GA_STORE_INT16:
case GA_STORE_INT32:
if (interpertAsVector || attrTupleSize == 3) {
addAttributeDetails<openvdb::Vec3i>(*attributeList, attr, tupleAIF,
attrTupleSize, closestPrimGrid, customName, vecType);
} else {
addAttributeDetails<openvdb::Int32>(*attributeList, attr, tupleAIF,
attrTupleSize, closestPrimGrid, customName);
}
break;
case GA_STORE_INT64:
addAttributeDetails<openvdb::Int64>
(*attributeList, attr, tupleAIF, attrTupleSize, closestPrimGrid, customName);
break;
case GA_STORE_REAL16:
case GA_STORE_REAL32:
if (interpertAsVector || attrTupleSize == 3) {
addAttributeDetails<openvdb::Vec3s>(*attributeList, attr, tupleAIF,
attrTupleSize, closestPrimGrid, customName, vecType);
} else {
addAttributeDetails<float>(*attributeList, attr, tupleAIF,
attrTupleSize, closestPrimGrid, customName);
}
break;
case GA_STORE_REAL64:
if (interpertAsVector || attrTupleSize == 3) {
addAttributeDetails<openvdb::Vec3d>(*attributeList, attr, tupleAIF,
attrTupleSize, closestPrimGrid, customName, vecType);
} else {
addAttributeDetails<double>(*attributeList, attr, tupleAIF,
attrTupleSize, closestPrimGrid, customName);
}
break;
default:
addWarning(SOP_MESSAGE, "Skipped unrecognized attribute type");
break;
}
}
return closestPrimIndexInstance;
}
////////////////////////////////////////
template<class ValueType>
void
SOP_OpenVDB_From_Polygons::Cache::addAttributeDetails(
hvdb::AttributeDetailList &attributeList,
const GA_Attribute *attribute,
const GA_AIFTuple *tupleAIF,
const int attrTupleSize,
const openvdb::Int32Grid& closestPrimGrid,
std::string& customName,
int vecType)
{
// Defines a new type of a tree having the same hierarchy as the incoming
// Int32Grid's tree but potentially a different value type.
using TreeType = typename openvdb::Int32Grid::TreeType::ValueConverter<ValueType>::Type;
using GridType = typename openvdb::Grid<TreeType>;
if (vecType != -1) { // Vector grid
// Get the attribute's default value.
ValueType defValue =
hvdb::evalAttrDefault<ValueType>(tupleAIF->getDefaults(attribute), 0);
// Construct a new tree that matches the closestPrimGrid's active voxel topology.
typename TreeType::Ptr tree(
new TreeType(closestPrimGrid.tree(), defValue, openvdb::TopologyCopy()));
typename GridType::Ptr grid(GridType::create(tree));
grid->setVectorType(openvdb::VecType(vecType));
attributeList.push_back(hvdb::AttributeDetailBase::Ptr(
new hvdb::AttributeDetail<GridType>(grid, attribute, tupleAIF, 0, true)));
if (customName.size() > 0) {
attributeList[attributeList.size()-1]->name() = customName;
}
} else {
for (int c = 0; c < attrTupleSize; ++c) {
// Get the attribute's default value.
ValueType defValue =
hvdb::evalAttrDefault<ValueType>(tupleAIF->getDefaults(attribute), c);
// Construct a new tree that matches the closestPrimGrid's active voxel topology.
typename TreeType::Ptr tree(
new TreeType(closestPrimGrid.tree(), defValue, openvdb::TopologyCopy()));
typename GridType::Ptr grid(GridType::create(tree));
attributeList.push_back(hvdb::AttributeDetailBase::Ptr(
new hvdb::AttributeDetail<GridType>(grid, attribute, tupleAIF, c)));
if (customName.size() > 0) {
std::ostringstream name;
name << customName;
if(attrTupleSize != 1) name << "_" << c;
attributeList[attributeList.size()-1]->name() = name.str();
}
}
}
}
////////////////////////////////////////
void
SOP_OpenVDB_From_Polygons::Cache::transferAttributes(
hvdb::AttributeDetailList &pointAttributes,
hvdb::AttributeDetailList &vertexAttributes,
hvdb::AttributeDetailList &primitiveAttributes,
const openvdb::Int32Grid& closestPrimGrid,
openvdb::math::Transform::Ptr& transform,
const GU_Detail& meshGdp)
{
// Threaded attribute transfer.
hvdb::MeshAttrTransfer transferOp(pointAttributes, vertexAttributes, primitiveAttributes,
closestPrimGrid, *transform, meshGdp);
transferOp.runParallel();
// Construct and add VDB primitives to the gdp
for (size_t i = 0, N = pointAttributes.size(); i < N; ++i) {
hvdb::AttributeDetailBase::Ptr& attrDetail = pointAttributes[i];
attrDetail->grid()->setTransform(transform);
hvdb::createVdbPrimitive(*gdp, attrDetail->grid(), attrDetail->name().c_str());
}
for (size_t i = 0, N = vertexAttributes.size(); i < N; ++i) {
hvdb::AttributeDetailBase::Ptr& attrDetail = vertexAttributes[i];
attrDetail->grid()->setTransform(transform);
hvdb::createVdbPrimitive(*gdp, attrDetail->grid(), attrDetail->name().c_str());
}
for (size_t i = 0, N = primitiveAttributes.size(); i < N; ++i) {
hvdb::AttributeDetailBase::Ptr& attrDetail = primitiveAttributes[i];
attrDetail->grid()->setTransform(transform);
hvdb::createVdbPrimitive(*gdp, attrDetail->grid(), attrDetail->name().c_str());
}
}
| 44,385 | C++ | 36.174204 | 100 | 0.613518 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Visualize.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Visualize.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Visualize VDB grids and their tree topology
#include <houdini_utils/ParmFactory.h>
#include <houdini_utils/geometry.h>
#include <openvdb_houdini/GeometryUtil.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/PointIndexGrid.h>
#include <openvdb/points/PointDataGrid.h>
#ifdef DWA_OPENVDB
#include <openvdb_houdini/DW_VDBUtils.h>
#endif
#include <GA/GA_Handle.h>
#include <GA/GA_Types.h>
#include <GU/GU_ConvertParms.h>
#include <GU/GU_Detail.h>
#include <GU/GU_PolyReduce.h>
#include <GU/GU_Surfacer.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_VectorTypes.h> // for UT_Vector3i
#include <UT/UT_UniquePtr.h>
#include <algorithm>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>
namespace {
template <typename T>
struct IsGridTypeIntegral
: std::conditional_t< std::is_integral<T>::value
|| std::is_same<T,openvdb::PointIndex32>::value
|| std::is_same<T,openvdb::PointIndex64>::value
|| std::is_same<T,openvdb::PointDataIndex32>::value
|| std::is_same<T,openvdb::PointDataIndex64>::value
, std::true_type
, std::false_type>
{
};
template <typename T>
struct IsGridTypeArithmetic
: std::conditional_t< IsGridTypeIntegral<T>::value
|| std::is_floating_point<T>::value
, std::true_type
, std::false_type>
{
};
} // anonymous namespace
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
// HAVE_SURFACING_PARM is disabled in H12.5
#ifdef SESI_OPENVDB
#define HAVE_SURFACING_PARM 0
#else
#define HAVE_SURFACING_PARM 1
#endif
enum RenderStyle { STYLE_NONE = 0, STYLE_POINTS, STYLE_WIRE_BOX, STYLE_SOLID_BOX };
enum MeshMode { MESH_NONE = 0, MESH_OPENVDB, MESH_HOUDINI };
class SOP_OpenVDB_Visualize: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Visualize(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Visualize() override = default;
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i == 1); }
static UT_Vector3 colorLevel(int level) { return sColors[std::max(3-level,0)]; }
static const UT_Vector3& colorSign(bool negative) { return sColors[negative ? 5 : 4]; }
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
private:
static const UT_Vector3 sColors[];
};
// Same color scheme as the VDB TOG paper.
const UT_Vector3 SOP_OpenVDB_Visualize::sColors[] = {
UT_Vector3(0.045f, 0.045f, 0.045f), // 0. Root
UT_Vector3(0.0432f, 0.33f, 0.0411023f), // 1. First internal node level
UT_Vector3(0.871f, 0.394f, 0.01916f), // 2. Intermediate internal node levels
UT_Vector3(0.00608299f, 0.279541f, 0.625f), // 3. Leaf level
UT_Vector3(0.523f, 0.0325175f, 0.0325175f), // 4. Value >= ZeroVal (for voxels or tiles)
UT_Vector3(0.92f, 0.92f, 0.92f) // 5. Value < ZeroVal (for voxels or tiles)
};
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Group pattern
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDBs to be processed.")
.setDocumentation(
"The VDBs to be visualized (see [specifying volumes|/model/volumes#group])"));
#if HAVE_SURFACING_PARM
// Surfacing
parms.add(hutil::ParmFactory(PRM_HEADING, "surfacing", "Surfacing"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "drawsurface", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
{ // Meshing scheme
char const * const items[] = {
"openvdb", "OpenVDB Mesher",
"houdini", "Houdini Surfacer",
nullptr
};
parms.add(hutil::ParmFactory(PRM_ORD, "mesher", "Mesher")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip("Select a meshing scheme.")
.setDocumentation("The meshing scheme to be used to visualize scalar volumes"));
}
parms.add(hutil::ParmFactory(PRM_FLT_J, "adaptivity", "Adaptivity")
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_RESTRICTED, 1.0)
.setDocumentation(
"How closely to match the surface\n\n"
"Higher adaptivity allows for more variation in polygon size,"
" so that fewer polygons are used to represent the surface."));
//parms.add(hutil::ParmFactory(PRM_TOGGLE, "computeNormals", "Compute Point Normals"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "isoValue", "Isovalue")
.setRange(PRM_RANGE_FREE, -2.0, PRM_RANGE_FREE, 2.0)
.setDocumentation("The isovalue of the surface to be meshed"));
parms.add(
hutil::ParmFactory(PRM_RGB_J, "surfaceColor", "Surface Color")
.setDefault(std::vector<PRM_Default>(3, PRM_Default(0.84))) // RGB = (0.84, 0.84, 0.84)
.setVectorSize(3)
.setDocumentation("The color of the surface mesh"));
// Tree Topology
parms.add(hutil::ParmFactory(PRM_HEADING,"treeTopology", "Tree Topology"));
#endif // HAVE_SURFACING_PARM
parms.add(hutil::ParmFactory(PRM_TOGGLE, "addcolor", "Color")
.setDefault(PRMoneDefaults)
.setTooltip("Specify whether to draw in color.")
.setDocumentation(
"Specify whether to generate geometry with the `Cd` color attribute."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "previewfrustum", "Frustum")
.setTooltip(
"Specify whether to draw the camera frustums\n"
"of VDBs with frustum transforms.")
.setDocumentation(
"For VDBs with [frustum transforms|http://www.openvdb.org/documentation/"
"doxygen/transformsAndMaps.html#sFrustumTransforms],"
" generate geometry representing the frustum bounding box."));
#ifdef DWA_OPENVDB
parms.add(hutil::ParmFactory(PRM_TOGGLE, "previewroi", "Region of Interest")
.setDocumentation(
"If enabled, generate geometry representing the region of interest"
" (for VDBs with ROI metadata)."));
#endif
char const * const boxItems[] = {
"wirebox", "Wireframe Boxes",
"box", "Solid Boxes",
nullptr
};
char const * const pointAndBoxItems[] = {
"points", "Points",
"wirebox", "Wireframe Boxes",
"box", "Solid Boxes",
nullptr
};
parms.add(hutil::ParmFactory(PRM_TOGGLE, "drawleafnodes", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_STRING, "leafstyle", "Leaf Nodes")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, pointAndBoxItems)
.setDefault("wirebox")
.setDocumentation(
"Specify whether to render the leaf nodes of VDB trees"
" as wireframe boxes, as solid boxes, or as a single point"
" in the middle of each node.\n\n"
"If __Color__ is enabled, leaf nodes will be blue."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "drawinternalnodes", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_STRING, "internalstyle", "Internal Nodes")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, boxItems)
.setDefault("wirebox")
.setDocumentation(
"Specify whether to render the internal nodes of VDB trees"
" as wireframe boxes or as solid boxes.\n\n"
"If __Color__ is enabled, the lowest-level internal nodes will be green"
" and higher-level internal nodes will be orange."));
// Active tiles
parms.add(hutil::ParmFactory(PRM_TOGGLE, "drawtiles", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_STRING, "tilestyle", "Active Tiles")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, pointAndBoxItems)
.setDefault("wirebox")
.setDocumentation(
"Specify whether to render the active tiles of VDB trees"
" as wireframe boxes, as solid boxes, or as a single point"
" in the middle of each tile.\n\n"
"If __Color__ is enabled, negative-valued tiles will be white"
" and nonnegative tiles will be red."));
// Active voxels
parms.add(hutil::ParmFactory(PRM_TOGGLE, "drawvoxels", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_ORD, "voxelstyle", "Active Voxels")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, pointAndBoxItems)
.setDefault("points")
.setDocumentation(
"Specify whether to render the active voxels of VDB trees"
" as wireframe boxes, as solid boxes, or as a single point"
" in the middle of each voxel.\n\n"
"If __Color__ is enabled, negative-valued voxels will be white"
" and nonnegative voxels will be red.\n\n"
"WARNING:\n"
" Rendering active voxels as boxes can generate large amounts of geometry."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "ignorestaggered", "Ignore Staggered Vectors")
.setTooltip("Draw staggered vectors as if they were collocated."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "addindexcoord", "Points with Index Coordinates")
.setTooltip("Add a voxel/tile index coordinate attribute to points.")
.setDocumentation(
"For voxels, tiles, and leaf nodes rendered as points, add an attribute to"
" the points that gives the coordinates of the points in the VDB's [index space|"
"http://www.openvdb.org/documentation/doxygen/overview.html#secSpaceAndTrans]."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "addvalue", "Points with Values")
.setTooltip("Add a voxel/tile value attribute to points.")
.setDocumentation(
"For voxels and tiles rendered as points, add an attribute to the points"
" that gives the voxel and tile values."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "usegridname", "Name Point Attributes After VDBs")
.setTooltip(
"If enabled, use the VDB name as the attribute name when\n"
"displaying points with values.\n"
"If disabled or if a VDB has no name, use either \"vdb_int\",\n"
"\"vdb_float\" or \"vdb_vec3f\" as the attribute name.")
.setDocumentation(
"If enabled, name the attribute added by __Points with Values__ after"
" the VDB primitive. If disabled or if a VDB has no name, name the point"
" attribute according to its type: `vdb_int`, `vdb_float`, `vdb_vec3f`, etc."));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.beginSwitcher("tabMenu");
obsoleteParms.addFolder("Tree Topology");
obsoleteParms.endSwitcher();
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING,"renderOptions", "Render Options"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "extractMesh", "Extract Mesh"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "computeNormals", "Compute Point Normals"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "reverse", "Reverse Faces"));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "optionsHeading", "Options"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "verbose", "Verbose"));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "Other", "Other"));
{
char const * const items[] = {
"none", "Disabled",
"opevdb", "OpenVDB Mesher", // note the misspelling
"houdini", "Houdini Surfacer",
nullptr
};
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "meshing", "Meshing")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items));
}
{
char const * const items[] = {
"none", "Disabled",
"leaf", "Leaf Nodes and Active Tiles",
"nonconst", "Leaf and Internal Nodes",
nullptr
};
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "nodes", "Tree Nodes")
.setDefault(PRMoneDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items));
}
{
char const * const items[] = {
"none", "Disabled",
"points", "Points",
"pvalue", "Points with Values",
"wirebox", "Wireframe Box",
"box", "Solid Box",
nullptr
};
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "tiles", "Active Constant Tiles")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items));
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "voxels", "Active Voxels")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items));
}
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "previewFrustum", "Frustum"));
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "leafmode", "Leaf Nodes")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, boxItems));
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "internalmode", "Internal Nodes")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, boxItems));
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "tilemode", "Active Tiles")
.setDefault(PRMoneDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, pointAndBoxItems));
obsoleteParms.add(hutil::ParmFactory(PRM_ORD, "voxelmode", "Active Voxels")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, pointAndBoxItems));
#ifndef DWA_OPENVDB
// We probably need this to share hip files.
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "previewroi", ""));
#endif
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Visualize Tree",
SOP_OpenVDB_Visualize::factory, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBVisualize")
#endif
.setObsoleteParms(obsoleteParms)
.addInput("Input with VDBs to visualize")
.setVerb(SOP_NodeVerb::COOK_GENERATOR, []() { return new SOP_OpenVDB_Visualize::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Generate geometry to visualize the internal\n\
[tree structure|http://www.openvdb.org/documentation/doxygen/overview.html#secTree]\n\
of a VDB volume.\"\"\"\n\
\n\
@overview\n\
\n\
This node can be a useful troubleshooting tool.\n\
Among other things, it allows one to evaluate the\n\
[sparseness|http://www.openvdb.org/documentation/doxygen/overview.html#secSparsity]\n\
of VDB volumes as well as to examine their extents and the values of individual voxels.\n\
\n\
@related\n\
- [Node:sop/vdbvisualizetree]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Visualize::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Visualize(net, name, op);
}
SOP_OpenVDB_Visualize::SOP_OpenVDB_Visualize(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
void
SOP_OpenVDB_Visualize::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
const fpreal time = 0.0;
// The "extractMesh" toggle switched Houdini surfacing on or off.
PRM_Parm* parm = obsoleteParms->getParmPtr("extractMesh");
if (parm && !parm->isFactoryDefault()) {
const bool extractMesh = obsoleteParms->evalInt("extractMesh", 0, time);
setInt("drawsurface", 0, time, extractMesh);
if (extractMesh) setString(UT_String("houdini"), CH_STRING_LITERAL, "mesher", 0, time);
}
// The "meshing" menu included a "Disabled" option, which is now handled with a toggle.
parm = obsoleteParms->getParmPtr("meshing");
if (parm && !parm->isFactoryDefault()) {
// 0: disabled, 1: OpenVDB mesher, 2: Houdini surfacer
const int meshing = obsoleteParms->evalInt("meshing", 0, time);
setInt("drawsurface", 0, time, meshing > 0);
if (meshing) {
setString(UT_String(meshing == 2 ? "houdini" : "openvdb"),
CH_STRING_LITERAL, "mesher", 0, time);
}
}
// The "nodes", "tiles" and "voxels" menus all included "Disabled" options,
// which are now handled with toggles. The old scheme also had two conflicting
// ways to enable display of tiles, which the following attempts to reconcile.
const UT_String pointStr("points"), boxStr("box"), wireStr("wirebox");
parm = obsoleteParms->getParmPtr("nodes");
if (parm && !parm->isFactoryDefault()) {
// 0: disabled, 1: leaf nodes and active tiles, 2: leaf and internal nodes
const int mode = obsoleteParms->evalInt("nodes", 0, time);
// Enable leaf nodes if the old mode was not "Disabled".
setInt("drawleafnodes", 0, time, mode > 0);
// Set the leaf style to wire box, but only if leaf nodes are displayed.
if (mode > 0) setString(wireStr, CH_STRING_LITERAL, "leafstyle", 0, time);
// Enable internal nodes if the old mode was "Leaf and Internal Nodes".
setInt("drawinternalnodes", 0, time, mode == 2);
// Set the internal node style to wire box, but only if internal nodes are displayed.
if (mode == 2) {
setString(wireStr, CH_STRING_LITERAL, "internalstyle", 0, time);
}
// Disable tiles if the old mode was not "Leaf Nodes and Active Tiles".
setInt("drawtiles", 0, time, mode == 1);
if (mode == 1) {
// Display tiles as wire boxes if the old mode was "Leaf Nodes and Active Tiles".
// (This setting took precedence over the tile mode, below.)
setString(wireStr, CH_STRING_LITERAL, "tilestyle", 0, time);
}
}
parm = obsoleteParms->getParmPtr("tiles");
if (parm && !parm->isFactoryDefault()) {
// 0: disabled, 1: points, 2: points with values, 3: wire boxes, 4: solid boxes
const int mode = obsoleteParms->evalInt("tiles", 0, time);
if (mode > 0) setInt("drawtiles", 0, time, true);
switch (mode) {
case 1:
setString(pointStr, CH_STRING_LITERAL, "tilestyle", 0, time);
setInt("addvalue", 0, time, false);
break;
case 2:
setString(pointStr, CH_STRING_LITERAL, "tilestyle", 0, time);
setInt("addvalue", 0, time, true);
break;
case 3: setString(wireStr, CH_STRING_LITERAL, "tilestyle", 0, time); break;
case 4: setString(boxStr, CH_STRING_LITERAL, "tilestyle", 0, time); break;
}
}
parm = obsoleteParms->getParmPtr("voxels");
if (parm && !parm->isFactoryDefault()) {
// 0: disabled, 1: points, 2: points with values, 3: wire boxes, 4: solid boxes
const int mode = obsoleteParms->evalInt("voxels", 0, time);
setInt("drawvoxels", 0, time, mode > 0);
switch (mode) {
case 1:
setString(pointStr, CH_STRING_LITERAL, "voxelstyle", 0, time);
setInt("addvalue", 0, time, false);
break;
case 2:
setString(pointStr, CH_STRING_LITERAL, "voxelstyle", 0, time);
setInt("addvalue", 0, time, true);
break;
case 3: setString(wireStr, CH_STRING_LITERAL, "voxelstyle", 0, time); break;
case 4: setString(boxStr, CH_STRING_LITERAL, "voxelstyle", 0, time); break;
}
}
for (const auto* name: {"leaf", "internal"}) {
const auto oldName = std::string(name) + "mode";
const auto newName = std::string(name) + "style";
parm = obsoleteParms->getParmPtr(oldName.c_str());
if (parm && !parm->isFactoryDefault()) {
const int mode = obsoleteParms->evalInt(oldName.c_str(), 0, time);
setString(mode == 0 ? wireStr : boxStr, CH_STRING_LITERAL, newName.c_str(), 0, time);
}
}
for (const auto* name: {"tile", "voxel"}) {
const auto oldName = std::string(name) + "mode";
const auto newName = std::string(name) + "style";
parm = obsoleteParms->getParmPtr(oldName.c_str());
if (parm && !parm->isFactoryDefault()) {
switch (obsoleteParms->evalInt(oldName.c_str(), 0, time)) {
case 0: setString(pointStr, CH_STRING_LITERAL, newName.c_str(), 0, time); break;
case 1: setString(wireStr, CH_STRING_LITERAL, newName.c_str(), 0, time); break;
case 2: setString(boxStr, CH_STRING_LITERAL, newName.c_str(), 0, time); break;
}
}
}
resolveRenamedParm(*obsoleteParms, "previewFrustum", "previewfrustum");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
// Update UI parm display
bool
SOP_OpenVDB_Visualize::updateParmsFlags()
{
bool changed = false;
const fpreal time = 0.0;
#if HAVE_SURFACING_PARM
const bool extractMesh = bool(evalInt("drawsurface", 0, time));
changed |= enableParm("mesher", extractMesh);
//changed += enableParm("computeNormals", extractMesh);
changed |= enableParm("adaptivity", extractMesh);
changed |= enableParm("surfaceColor", extractMesh);
changed |= enableParm("isoValue", extractMesh);
#endif
const std::string
leafMode = evalStdString("leafstyle", time),
tileMode = evalStdString("tilestyle", time),
voxelMode = evalStdString("voxelstyle", time);
const bool
drawLeafNodes = bool(evalInt("drawleafnodes", 0, time)),
drawVoxels = bool(evalInt("drawvoxels", 0, time)),
drawTiles = bool(evalInt("drawtiles", 0, time)),
drawPoints = (drawTiles && tileMode == "points") || (drawVoxels && voxelMode == "points");
changed |= enableParm("leafstyle", drawLeafNodes);
changed |= enableParm("internalstyle", bool(evalInt("drawinternalnodes", 0, time)));
changed |= enableParm("tilestyle", drawTiles);
changed |= enableParm("voxelstyle", drawVoxels);
changed |= enableParm("ignorestaggered", drawVoxels);
changed |= enableParm("addvalue", drawPoints);
changed |= enableParm("addindexcoord", drawPoints || (drawLeafNodes && leafMode == "points"));
changed |= enableParm("usegridname", drawPoints);
return changed;
}
////////////////////////////////////////
template<typename OpType>
inline RenderStyle
evalRenderStyle(OpType& op, const char* toggleName, const char* modeName, fpreal time)
{
RenderStyle style = STYLE_NONE;
if (op.evalInt(toggleName, 0, time)) {
const std::string mode = op.evalStdString(modeName, time);
if (mode == "points") {
style = STYLE_POINTS;
} else if (mode == "wirebox") {
style = STYLE_WIRE_BOX;
} else if (mode == "box") {
style = STYLE_SOLID_BOX;
}
}
return style;
}
////////////////////////////////////////
inline void
createBox(GU_Detail& geo, const openvdb::math::Transform& xform,
const openvdb::CoordBBox& bbox, const UT_Vector3* color = nullptr, bool solid = false)
{
struct Local {
static inline UT_Vector3 Vec3dToUTV3(const openvdb::Vec3d& v) {
return UT_Vector3(float(v.x()), float(v.y()), float(v.z()));
}
};
UT_Vector3 corners[8];
#if 1
// Nodes are rendered as cell-centered (0.5 voxel dilated) AABBox in world space
const openvdb::Vec3d min(bbox.min().x()-0.5, bbox.min().y()-0.5, bbox.min().z()-0.5);
const openvdb::Vec3d max(bbox.max().x()+0.5, bbox.max().y()+0.5, bbox.max().z()+0.5);
#else
// Render as node-centered (used for debugging)
const openvdb::Vec3d min(bbox.min().x(), bbox.min().y(), bbox.min().z());
const openvdb::Vec3d max(bbox.max().x()+1.0, bbox.max().y()+1.0, bbox.max().z()+1.0);
#endif
openvdb::Vec3d ptn = xform.indexToWorld(min);
corners[0] = Local::Vec3dToUTV3(ptn);
ptn = openvdb::Vec3d(min.x(), min.y(), max.z());
ptn = xform.indexToWorld(ptn);
corners[1] = Local::Vec3dToUTV3(ptn);
ptn = openvdb::Vec3d(max.x(), min.y(), max.z());
ptn = xform.indexToWorld(ptn);
corners[2] = Local::Vec3dToUTV3(ptn);
ptn = openvdb::Vec3d(max.x(), min.y(), min.z());
ptn = xform.indexToWorld(ptn);
corners[3] = Local::Vec3dToUTV3(ptn);
ptn = openvdb::Vec3d(min.x(), max.y(), min.z());
ptn = xform.indexToWorld(ptn);
corners[4] = Local::Vec3dToUTV3(ptn);
ptn = openvdb::Vec3d(min.x(), max.y(), max.z());
ptn = xform.indexToWorld(ptn);
corners[5] = Local::Vec3dToUTV3(ptn);
ptn = xform.indexToWorld(max);
corners[6] = Local::Vec3dToUTV3(ptn);
ptn = openvdb::Vec3d(max.x(), max.y(), min.z());
ptn = xform.indexToWorld(ptn);
corners[7] = Local::Vec3dToUTV3(ptn);
hutil::createBox(geo, corners, color, solid);
}
////////////////////////////////////////
struct TreeParms
{
RenderStyle internalStyle = STYLE_NONE;
RenderStyle tileStyle = STYLE_NONE;
RenderStyle leafStyle = STYLE_NONE;
RenderStyle voxelStyle = STYLE_NONE;
bool addColor = true;
bool ignoreStaggeredVectors = false;
bool addValue = false;
bool addIndexCoord = false;
bool useGridName = false;
};
class TreeVisualizer
{
public:
TreeVisualizer(GU_Detail&, const TreeParms&, hvdb::Interrupter* = nullptr);
template<typename GridType>
void operator()(const GridType&);
private:
/// @param pos position in index coordinates
GA_Offset createPoint(const openvdb::Vec3d& pos);
GA_Offset createPoint(const openvdb::CoordBBox&, const UT_Vector3& color);
template<typename ValType>
typename std::enable_if<IsGridTypeIntegral<ValType>::value>::type
addPoint(const openvdb::CoordBBox&, const UT_Vector3& color, ValType s, bool);
template<typename ValType>
typename std::enable_if<std::is_floating_point<ValType>::value>::type
addPoint(const openvdb::CoordBBox&, const UT_Vector3& color, ValType s, bool);
template<typename ValType>
typename std::enable_if<!IsGridTypeArithmetic<ValType>::value>::type
addPoint(const openvdb::CoordBBox&, const UT_Vector3& color, ValType v, bool staggered);
void addPoint(const openvdb::CoordBBox&, const UT_Vector3& color, bool staggered);
void addBox(const openvdb::CoordBBox&, const UT_Vector3& color, bool solid);
bool wasInterrupted(int percent = -1) const {
return mInterrupter && mInterrupter->wasInterrupted(percent);
}
TreeParms mParms;
GU_Detail* mGeo;
hvdb::Interrupter* mInterrupter;
const openvdb::math::Transform* mXform;
GA_RWHandleF mFloatHandle;
GA_RWHandleI mInt32Handle;
GA_RWHandleV3 mVec3fHandle;
GA_RWHandleV3 mCdHandle;
GA_RWHandleT<UT_Vector3i> mIndexCoordHandle;
};
////////////////////////////////////////
TreeVisualizer::TreeVisualizer(GU_Detail& geo, const TreeParms& parms,
hvdb::Interrupter* interrupter)
: mParms(parms)
, mGeo(&geo)
, mInterrupter(interrupter)
, mXform(nullptr)
{
}
template<typename GridType>
void
TreeVisualizer::operator()(const GridType& grid)
{
using TreeType = typename GridType::TreeType;
mXform = &grid.transform();
const bool staggered = !mParms.ignoreStaggeredVectors &&
(grid.getGridClass() == openvdb::GRID_STAGGERED);
//{
// Create point attributes.
if (mParms.addColor) {
mCdHandle.bind(mGeo->findDiffuseAttribute(GA_ATTRIB_POINT));
if (!mCdHandle.isValid()) {
mCdHandle.bind(mGeo->addDiffuseAttribute(GA_ATTRIB_POINT));
}
}
if (mParms.addIndexCoord &&
((mParms.tileStyle == STYLE_POINTS)
|| (mParms.voxelStyle == STYLE_POINTS)
|| (mParms.leafStyle == STYLE_POINTS)))
{
const UT_String attrName = "vdb_ijk";
GA_RWAttributeRef attribHandle = mGeo->findIntTuple(GA_ATTRIB_POINT, attrName, 3);
if (!attribHandle.isValid()) {
attribHandle = mGeo->addIntTuple(GA_ATTRIB_POINT, attrName, 3, GA_Defaults(0));
}
mIndexCoordHandle = attribHandle.getAttribute();
UT_String varName = attrName;
varName.toUpper();
mGeo->addVariableName(attrName, varName);
}
if (mParms.addValue &&
((mParms.tileStyle == STYLE_POINTS) || (mParms.voxelStyle == STYLE_POINTS)))
{
const std::string valueType = grid.valueType();
UT_String attrName;
if (mParms.useGridName) {
attrName = grid.getName();
attrName.forceValidVariableName();
}
if (valueType == openvdb::typeNameAsString<float>() ||
valueType == openvdb::typeNameAsString<double>())
{
if (!attrName.isstring()) attrName = "vdb_float";
UT_String varName = attrName;
varName.toUpper();
GA_RWAttributeRef attribHandle =
mGeo->findFloatTuple(GA_ATTRIB_POINT, attrName, 1);
if (!attribHandle.isValid()) {
attribHandle = mGeo->addFloatTuple(
GA_ATTRIB_POINT, attrName, 1, GA_Defaults(0));
}
mFloatHandle = attribHandle.getAttribute();
mGeo->addVariableName(attrName, varName);
} else if (valueType == openvdb::typeNameAsString<int32_t>() ||
valueType == openvdb::typeNameAsString<int64_t>() ||
valueType == openvdb::typeNameAsString<bool>())
{
if (!attrName.isstring()) attrName = "vdb_int";
UT_String varName = attrName;
varName.toUpper();
GA_RWAttributeRef attribHandle =
mGeo->findIntTuple(GA_ATTRIB_POINT, attrName, 1);
if (!attribHandle.isValid()) {
attribHandle = mGeo->addIntTuple(
GA_ATTRIB_POINT, attrName, 1, GA_Defaults(0));
}
mInt32Handle = attribHandle.getAttribute();
mGeo->addVariableName(attrName, varName);
} else if (valueType == openvdb::typeNameAsString<openvdb::Vec3s>() ||
valueType == openvdb::typeNameAsString<openvdb::Vec3d>())
{
if (!attrName.isstring()) attrName = "vdb_vec3f";
UT_String varName = attrName;
varName.toUpper();
GA_RWAttributeRef attribHandle =
mGeo->findFloatTuple(GA_ATTRIB_POINT, attrName, 3);
if (!attribHandle.isValid()) {
attribHandle = mGeo->addFloatTuple(
GA_ATTRIB_POINT, attrName, 3, GA_Defaults(0));
}
mVec3fHandle = attribHandle.getAttribute();
mGeo->addVariableName(attrName, varName);
} else {
throw std::runtime_error(
"value attributes are not supported for values of type " + valueType);
}
}
//}
// Render nodes.
if (mParms.internalStyle || mParms.leafStyle) {
openvdb::CoordBBox bbox;
for (typename TreeType::NodeCIter iter(grid.tree()); iter; ++iter) {
if (iter.getDepth() == 0) continue; // don't draw the root node
const bool isLeaf = (iter.getLevel() == 0);
if (isLeaf && !mParms.leafStyle) continue;
if (!isLeaf && !mParms.internalStyle) continue;
const bool solid = (isLeaf ? mParms.leafStyle == STYLE_SOLID_BOX
: mParms.internalStyle == STYLE_SOLID_BOX);
const auto color = SOP_OpenVDB_Visualize::colorLevel(iter.getLevel());
iter.getBoundingBox(bbox);
if (isLeaf && mParms.leafStyle == STYLE_POINTS) {
addPoint(bbox, color, staggered);
} else {
addBox(bbox, color, solid);
}
}
}
if (!mParms.tileStyle && !mParms.voxelStyle) return;
// Render tiles and voxels.
openvdb::CoordBBox bbox;
for (auto iter = grid.cbeginValueOn(); iter; ++iter) {
if (wasInterrupted()) break;
const int style = iter.isVoxelValue() ? mParms.voxelStyle : mParms.tileStyle;
if (style == STYLE_NONE) continue;
const bool negative = openvdb::math::isNegative(iter.getValue());
const UT_Vector3& color = SOP_OpenVDB_Visualize::colorSign(negative);
iter.getBoundingBox(bbox);
if (style == STYLE_POINTS) {
if (mParms.addValue) {
addPoint(bbox, color, iter.getValue(), staggered);
} else {
addPoint(bbox, color, staggered);
}
} else {
addBox(bbox, color, style == STYLE_SOLID_BOX);
}
}
}
inline GA_Offset
TreeVisualizer::createPoint(const openvdb::Vec3d& pos)
{
openvdb::Vec3d wpos = mXform->indexToWorld(pos);
GA_Offset offset = mGeo->appendPointOffset();
mGeo->setPos3(offset, wpos[0], wpos[1], wpos[2]);
if (mIndexCoordHandle.isValid()) {
// Attach the (integer) index coordinates of the voxel at the given pos.
openvdb::Coord idxPos = openvdb::Coord::floor(pos);
mIndexCoordHandle.set(offset, UT_Vector3i(idxPos[0], idxPos[1], idxPos[2]));
}
return offset;
}
inline GA_Offset
TreeVisualizer::createPoint(const openvdb::CoordBBox& bbox,
const UT_Vector3& color)
{
openvdb::Vec3d pos = openvdb::Vec3d(0.5*(bbox.min().x()+bbox.max().x()),
0.5*(bbox.min().y()+bbox.max().y()),
0.5*(bbox.min().z()+bbox.max().z()));
GA_Offset offset = createPoint(pos);
if (mCdHandle.isValid()) mCdHandle.set(offset, color);
return offset;
}
template<typename ValType>
typename std::enable_if<IsGridTypeIntegral<ValType>::value>::type
TreeVisualizer::addPoint(const openvdb::CoordBBox& bbox,
const UT_Vector3& color, ValType s, bool)
{
mInt32Handle.set(createPoint(bbox, color), int(s));
}
template<typename ValType>
typename std::enable_if<std::is_floating_point<ValType>::value>::type
TreeVisualizer::addPoint(const openvdb::CoordBBox& bbox,
const UT_Vector3& color, ValType s, bool)
{
mFloatHandle.set(createPoint(bbox, color), float(s));
}
template<typename ValType>
typename std::enable_if<!IsGridTypeArithmetic<ValType>::value>::type
TreeVisualizer::addPoint(const openvdb::CoordBBox& bbox,
const UT_Vector3& color, ValType v, bool staggered)
{
if (!staggered) {
mVec3fHandle.set(createPoint(bbox, color),
UT_Vector3(float(v[0]), float(v[1]), float(v[2])));
} else {
openvdb::Vec3d pos = openvdb::Vec3d(0.5*(bbox.min().x()+bbox.max().x()),
0.5*(bbox.min().y()+bbox.max().y()),
0.5*(bbox.min().z()+bbox.max().z()));
pos[0] -= 0.5; // -x
GA_Offset offset = createPoint(pos);
if (mCdHandle.isValid()) mCdHandle.set(offset, UT_Vector3(1.0, 0.0, 0.0)); // r
mVec3fHandle.set(offset, UT_Vector3(float(v[0]), 0.0, 0.0));
pos[0] += 0.5;
pos[1] -= 0.5; // -y
offset = createPoint(pos);
if (mCdHandle.isValid()) mCdHandle.set(offset, UT_Vector3(0.0, 1.0, 0.0)); // g
mVec3fHandle.set(offset, UT_Vector3(0.0, float(v[1]), 0.0));
pos[1] += 0.5;
pos[2] -= 0.5; // -z
offset = createPoint(pos);
if (mCdHandle.isValid()) mCdHandle.set(offset, UT_Vector3(0.0, 0.0, 1.0)); // b
mVec3fHandle.set(offset, UT_Vector3(0.0, 0.0, float(v[2])));
}
}
void
TreeVisualizer::addPoint(const openvdb::CoordBBox& bbox,
const UT_Vector3& color, bool staggered)
{
if (!staggered) {
createPoint(bbox, color);
} else {
openvdb::Vec3d pos = openvdb::Vec3d(0.5*(bbox.min().x()+bbox.max().x()),
0.5*(bbox.min().y()+bbox.max().y()),
0.5*(bbox.min().z()+bbox.max().z()));
pos[0] -= 0.5; // -x
GA_Offset offset = createPoint(pos);
if (mCdHandle.isValid()) mCdHandle.set(offset, color);
pos[0] += 0.5;
pos[1] -= 0.5; // -y
offset = createPoint(pos);
if (mCdHandle.isValid()) mCdHandle.set(offset, color);
pos[1] += 0.5;
pos[2] -= 0.5; // -z
offset = createPoint(pos);
if (mCdHandle.isValid()) mCdHandle.set(offset, color);
}
}
void
TreeVisualizer::addBox(const openvdb::CoordBBox& bbox,
const UT_Vector3& color, bool solid)
{
createBox(*mGeo, *mXform, bbox, mParms.addColor ? &color : nullptr, solid);
}
////////////////////////////////////////
#if HAVE_SURFACING_PARM
class GridSurfacer
{
public:
GridSurfacer(GU_Detail& geo, float iso = 0.0, float adaptivityThreshold = 0.0,
bool generateNormals = false, hvdb::Interrupter* interrupter = nullptr);
template<typename GridType>
void operator()(const GridType&);
private:
bool wasInterrupted(int percent = -1) const {
return mInterrupter && mInterrupter->wasInterrupted(percent);
}
GU_Detail* mGeo;
const float mIso, mAdaptivityThreshold;
const bool mGenerateNormals;
hvdb::Interrupter* mInterrupter;
};
GridSurfacer::GridSurfacer(GU_Detail& geo, float iso,
float adaptivityThreshold, bool generateNormals, hvdb::Interrupter* interrupter)
: mGeo(&geo)
, mIso(iso)
, mAdaptivityThreshold(adaptivityThreshold)
, mGenerateNormals(generateNormals)
, mInterrupter(interrupter)
{
}
template<typename GridType>
void
GridSurfacer::operator()(const GridType& grid)
{
using TreeType = typename GridType::TreeType;
using LeafNodeType = typename TreeType::LeafNodeType;
openvdb::CoordBBox bbox;
// Gets min & max and checks if the grid is empty
if (grid.tree().evalLeafBoundingBox(bbox)) {
openvdb::Coord dim(bbox.max() - bbox.min());
GU_Detail tmpGeo;
GU_Surfacer surfacer(tmpGeo,
UT_Vector3(float(bbox.min().x()), float(bbox.min().y()), float(bbox.min().z())),
UT_Vector3(float(dim[0]), float(dim[1]), float(dim[2])),
dim[0], dim[1], dim[2], mGenerateNormals);
typename GridType::ConstAccessor accessor = grid.getConstAccessor();
openvdb::Coord xyz;
fpreal density[8];
// for each leaf..
for (typename TreeType::LeafCIter iter = grid.tree().cbeginLeaf(); iter; iter.next()) {
if (wasInterrupted()) break;
bool isLess = false, isMore = false;
// for each active voxel..
typename LeafNodeType::ValueOnCIter it = iter.getLeaf()->cbeginValueOn();
for ( ; it; ++it) {
xyz = it.getCoord();
// Sample values at each corner of the voxel
for (unsigned int d = 0; d < 8; ++d) {
openvdb::Coord valueCoord(
xyz.x() + (d & 1),
xyz.y() + ((d & 2) >> 1),
xyz.z() + ((d & 4) >> 2));
// Houdini uses the inverse sign convention for level sets!
density[d] = mIso - float(accessor.getValue(valueCoord));
density[d] <= 0.0f ? isLess = true : isMore = true;
}
// If there is a crossing, surface this voxel
if (isLess && isMore) {
surfacer.addCell(
xyz.x() - bbox.min().x(),
xyz.y() - bbox.min().y(),
xyz.z() - bbox.min().z(),
density, 0);
}
} // end active voxel traversal
} // end leaf traversal
if (wasInterrupted()) return;
if (mAdaptivityThreshold > 1e-6) {
GU_PolyReduceParms parms;
parms.percentage =
static_cast<float>(100.0 * (1.0 - std::min(mAdaptivityThreshold, 0.99f)));
parms.usepercent = 1;
tmpGeo.polyReduce(parms);
}
// world space transform
for (GA_Iterator it(tmpGeo.getPointRange()); !it.atEnd(); it.advance()) {
GA_Offset ptOffset = it.getOffset();
UT_Vector3 pos = tmpGeo.getPos3(ptOffset);
openvdb::Vec3d vPos(pos.x(), pos.y(), pos.z());
openvdb::Vec3d wPos = grid.indexToWorld(vPos);
tmpGeo.setPos3(ptOffset, UT_Vector3(
static_cast<float>(wPos.x()),
static_cast<float>(wPos.y()),
static_cast<float>(wPos.z())));
}
mGeo->merge(tmpGeo);
}
}
#endif // HAVE_SURFACING_PARM
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Visualize::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
hvdb::Interrupter boss("Visualizing VDBs");
const GU_Detail* refGdp = inputGeo(0);
if (refGdp == nullptr) return error();
// Get the group of grids to visualize.
const GA_PrimitiveGroup* group = matchGroup(*refGdp, evalStdString("group", time));
// Evaluate the UI parameters.
MeshMode meshing = MESH_NONE;
#if HAVE_SURFACING_PARM
if (evalInt("drawsurface", 0, time)) {
std::string s = evalStdString("mesher", time);
meshing = (s == "houdini") ? MESH_HOUDINI : MESH_OPENVDB;
}
const double adaptivity = evalFloat("adaptivity", 0, time);
const double iso = double(evalFloat("isoValue", 0, time));
#endif
TreeParms treeParms;
treeParms.internalStyle =
evalRenderStyle(*this, "drawinternalnodes", "internalstyle", time);
treeParms.tileStyle = evalRenderStyle(*this, "drawtiles", "tilestyle", time);
treeParms.leafStyle = evalRenderStyle(*this, "drawleafnodes", "leafstyle", time);
treeParms.voxelStyle = evalRenderStyle(*this, "drawvoxels", "voxelstyle", time);
treeParms.addColor = bool(evalInt("addcolor", 0, time));
treeParms.addValue = bool(evalInt("addvalue", 0, time));
treeParms.addIndexCoord = bool(evalInt("addindexcoord", 0, time));
treeParms.useGridName = bool(evalInt("usegridname", 0, time));
treeParms.ignoreStaggeredVectors = bool(evalInt("ignorestaggered", 0, time));
const bool drawTree = (treeParms.internalStyle || treeParms.tileStyle
|| treeParms.leafStyle || treeParms.voxelStyle);
const bool showFrustum = bool(evalInt("previewfrustum", 0, time));
#ifdef DWA_OPENVDB
const bool showROI = bool(evalInt("previewroi", 0, time));
#else
const bool showROI = false;
#endif
#if HAVE_SURFACING_PARM
if (meshing != MESH_NONE) {
fpreal values[3] = {
evalFloat("surfaceColor", 0, time),
evalFloat("surfaceColor", 1, time),
evalFloat("surfaceColor", 2, time)};
GA_Defaults color;
color.set(values, 3);
gdp->addFloatTuple(GA_ATTRIB_POINT, "Cd", 3, color);
}
// mesh using OpenVDB mesher
if (meshing == MESH_OPENVDB) {
GU_ConvertParms parms;
parms.setToType(GEO_PrimTypeCompat::GEOPRIMPOLY);
parms.myOffset = static_cast<float>(iso);
parms.preserveGroups = false;
UT_UniquePtr<GA_PrimitiveGroup> groupDeleter;
if (!group) {
parms.primGroup = nullptr;
} else {
// parms.primGroup might be modified, so make a copy.
parms.primGroup = new GA_PrimitiveGroup(*refGdp);
groupDeleter.reset(parms.primGroup);
parms.primGroup->copyMembership(*group);
}
GU_PrimVDB::convertVDBs(*gdp, *refGdp, parms, adaptivity, /*keep_original*/true);
}
#endif // HAVE_SURFACING_PARM
if (!boss.wasInterrupted()
&& (meshing == MESH_HOUDINI || drawTree || showFrustum || showROI))
{
// for each VDB primitive...
for (hvdb::VdbPrimCIterator it(refGdp, group); it; ++it) {
if (boss.wasInterrupted()) break;
const GU_PrimVDB *vdb = *it;
#if HAVE_SURFACING_PARM
// mesh using houdini surfacer
if (meshing == MESH_HOUDINI) {
GridSurfacer surfacer(*gdp, static_cast<float>(iso),
static_cast<float>(adaptivity), false, &boss);
hvdb::GEOvdbApply<hvdb::NumericGridTypes>(*vdb, surfacer);
}
#endif
// draw tree topology
if (drawTree) {
TreeVisualizer draw(*gdp, treeParms, &boss);
hvdb::GEOvdbApply<hvdb::AllGridTypes>(*vdb, draw);
}
if (showFrustum) {
UT_Vector3 box_color(0.6f, 0.6f, 0.6f);
UT_Vector3 tick_color(0.0f, 0.0f, 0.0f);
hvdb::drawFrustum(*gdp, vdb->getGrid().transform(),
&box_color, &tick_color, /*shaded*/true);
}
#ifdef DWA_OPENVDB
if (showROI) {
const openvdb::GridBase& grid = vdb->getConstGrid();
openvdb::Vec3IMetadata::ConstPtr metaMin =
grid.getMetadata<openvdb::Vec3IMetadata>(
openvdb::Name(openvdb_houdini::METADATA_ROI_MIN));
openvdb::Vec3IMetadata::ConstPtr metaMax =
grid.getMetadata<openvdb::Vec3IMetadata>(
openvdb::Name(openvdb_houdini::METADATA_ROI_MAX));
if (metaMin && metaMax) {
const UT_Vector3 roiColor(1.0, 0.0, 0.0);
openvdb::CoordBBox roi(
openvdb::Coord(metaMin->value()), openvdb::Coord(metaMax->value()));
createBox(*gdp, grid.transform(), roi, &roiColor);
}
}
#endif
}
}
if (boss.wasInterrupted()) {
addWarning(SOP_MESSAGE, "Process was interrupted");
}
boss.end();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 46,858 | C++ | 35.551482 | 98 | 0.599898 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_NodeVDB.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_NodeVDB.cc
/// @author FX R&D OpenVDB team
#include "SOP_NodeVDB.h"
#include <houdini_utils/geometry.h>
#include <openvdb/points/PointDataGrid.h>
#include "PointUtils.h"
#include "Utils.h"
#include "GEO_PrimVDB.h"
#include "GU_PrimVDB.h"
#include <GU/GU_Detail.h>
#include <GU/GU_PrimPoly.h>
#include <OP/OP_NodeInfoParms.h>
#include <PRM/PRM_Parm.h>
#include <PRM/PRM_Type.h>
#include <SOP/SOP_Cache.h> // for stealable
#include <SYS/SYS_Version.h>
#include <UT/UT_InfoTree.h>
#include <UT/UT_SharedPtr.h>
#include <tbb/mutex.h>
#include <algorithm>
#include <cctype> // std::tolower
#include <iostream>
#include <map>
#include <memory>
#include <mutex> // std::call_once
#include <sstream>
#include <stdexcept>
/// Enables custom UT_InfoTree data from SOP_NodeVDB::fillInfoTreeNodeSpecific()
/// which is used to populate the mako templates in Houdini 16 and greater.
/// The templates are used to provide MMB information on Houdini primitives and
/// are installed as part of the Houdini toolkit $HH/config/NodeInfoTemplates.
/// This code has since been absorbed by SideFX, but we continue to keep
/// it around to demonstrate how to extend the templates in Houdini. Note
/// that the current implementation is a close duplicate of the data populated
/// by Houdini, so this will clash with native Houdini names. The templates
/// may also change in future Houdini versions, so do not expect this to
/// produce valid results out the box.
///
/// For users wishing to customize the .mako files, you can use python to
/// inspect the current mako structure.
///
/// @code
/// infoTree = hou.node('/obj/geo1/vdbfrompolygons1').infoTree()
/// sopInfo = infoTree.branches()['SOP Info']
/// sparseInfo = sopInfo.branches()['Sparse Volumes']
/// @endcode
///
/// These mako branches are the paths that are populated by UT_InfoTree. The
/// mako files responsible for producing VDB specific data are geometry.mako,
/// called by sop.mako.
///
//#define OPENVDB_CUSTOM_MAKO
namespace {
const std::string&
getOpHidePolicy()
{
static std::string sOpHidePolicy;
static std::once_flag once;
std::call_once(once, []()
{
const char* opHidePolicy = std::getenv("OPENVDB_OPHIDE_POLICY");
#ifdef OPENVDB_OPHIDE_POLICY
if (opHidePolicy == nullptr) {
opHidePolicy = OPENVDB_PREPROC_STRINGIFY(OPENVDB_OPHIDE_POLICY);
}
#endif
if (opHidePolicy != nullptr) {
std::string opHidePolicyStr(opHidePolicy);
// to lower-case
std::transform(opHidePolicyStr.begin(), opHidePolicyStr.end(),
opHidePolicyStr.begin(),
[](unsigned char c) { return std::tolower(c); });
sOpHidePolicy = opHidePolicy;
} else {
sOpHidePolicy = "";
}
});
return sOpHidePolicy;
}
} // anonymous namespace
namespace openvdb_houdini {
namespace node_info_text {
using Mutex = tbb::mutex;
using Lock = Mutex::scoped_lock;
// map of function callbacks to grid types
using ApplyGridSpecificInfoTextMap = std::map<openvdb::Name, ApplyGridSpecificInfoText>;
struct LockedInfoTextRegistry
{
LockedInfoTextRegistry() {}
~LockedInfoTextRegistry() {}
Mutex mMutex;
ApplyGridSpecificInfoTextMap mApplyGridSpecificInfoTextMap;
};
// Declare this at file scope to ensure thread-safe initialization
static Mutex theInitInfoTextRegistryMutex;
// Global function for accessing the regsitry
static LockedInfoTextRegistry*
getInfoTextRegistry()
{
Lock lock(theInitInfoTextRegistryMutex);
static LockedInfoTextRegistry *registry = nullptr;
if (registry == nullptr) {
#if defined(__ICC)
__pragma(warning(disable:1711)) // disable ICC "assignment to static variable" warnings
#endif
registry = new LockedInfoTextRegistry();
#if defined(__ICC)
__pragma(warning(default:1711))
#endif
}
return registry;
}
void registerGridSpecificInfoText(const std::string&, ApplyGridSpecificInfoText);
ApplyGridSpecificInfoText getGridSpecificInfoText(const std::string&);
void
registerGridSpecificInfoText(const std::string& gridType, ApplyGridSpecificInfoText callback)
{
LockedInfoTextRegistry *registry = getInfoTextRegistry();
Lock lock(registry->mMutex);
if(registry->mApplyGridSpecificInfoTextMap.find(gridType) !=
registry->mApplyGridSpecificInfoTextMap.end()) return;
registry->mApplyGridSpecificInfoTextMap[gridType] = callback;
}
/// @brief Return a pointer to a grid information function, or @c nullptr
/// if no specific function has been registered for the given grid type.
/// @note The defaultNodeSpecificInfoText() method is always returned prior to Houdini 14.
ApplyGridSpecificInfoText
getGridSpecificInfoText(const std::string& gridType)
{
LockedInfoTextRegistry *registry = getInfoTextRegistry();
Lock lock(registry->mMutex);
const ApplyGridSpecificInfoTextMap::const_iterator iter =
registry->mApplyGridSpecificInfoTextMap.find(gridType);
if (iter == registry->mApplyGridSpecificInfoTextMap.end() || iter->second == nullptr) {
return nullptr; // Native prim info is sufficient
}
return iter->second;
}
} // namespace node_info_text
////////////////////////////////////////
SOP_NodeVDB::SOP_NodeVDB(OP_Network* net, const char* name, OP_Operator* op):
SOP_Node(net, name, op)
{
#ifndef SESI_OPENVDB
// Initialize the OpenVDB library
openvdb::initialize();
// Forward OpenVDB log messages to the UT_ErrorManager (for all SOPs).
startLogForwarding(SOP_OPTYPE_ID);
#endif
// Register grid-specific info text for Point Data Grids
node_info_text::registerGridSpecificInfoText<openvdb::points::PointDataGrid>(
&pointDataGridSpecificInfoText);
// Set the flag to draw guide geometry
mySopFlags.setNeedGuide1(true);
}
////////////////////////////////////////
const GA_PrimitiveGroup*
SOP_NodeVDB::matchGroup(GU_Detail& aGdp, const std::string& pattern)
{
/// @internal Presumably, when a group name pattern matches multiple groups,
/// a new group must be created that is the union of the matching groups,
/// and therefore the detail must be non-const. Since inputGeo() returns
/// a const detail, we can't match groups in input details; however,
/// we usually copy input 0 to the output detail, so we can in effect
/// match groups from input 0 by matching them in the output instead.
const GA_PrimitiveGroup* group = nullptr;
if (!pattern.empty()) {
// If a pattern was provided, try to match it.
group = parsePrimitiveGroups(pattern.c_str(), GroupCreator(&aGdp, false));
if (!group) {
// Report an error if the pattern didn't match.
throw std::runtime_error(("Invalid group (" + pattern + ")").c_str());
}
}
return group;
}
const GA_PrimitiveGroup*
SOP_NodeVDB::matchGroup(const GU_Detail& aGdp, const std::string& pattern)
{
const GA_PrimitiveGroup* group = nullptr;
if (!pattern.empty()) {
// If a pattern was provided, try to match it.
group = parsePrimitiveGroups(pattern.c_str(), GroupCreator(&aGdp));
if (!group) {
// Report an error if the pattern didn't match.
throw std::runtime_error(("Invalid group (" + pattern + ")").c_str());
}
}
return group;
}
////////////////////////////////////////
void
SOP_NodeVDB::fillInfoTreeNodeSpecific(UT_InfoTree& tree, const OP_NodeInfoTreeParms& parms)
{
SOP_Node::fillInfoTreeNodeSpecific(tree, parms);
// Add the OpenVDB library version number to this node's
// extended operator information.
if (UT_InfoTree* child = tree.addChildMap("OpenVDB")) {
child->addProperties("OpenVDB Version", openvdb::getLibraryAbiVersionString());
}
#ifdef OPENVDB_CUSTOM_MAKO
UT_StringArray sparseVolumeTreePath({"SOP Info", "Sparse Volumes"});
if (UT_InfoTree* sparseVolumes = tree.getDescendentPtr(sparseVolumeTreePath)) {
if (UT_InfoTree* info = sparseVolumes->addChildBranch("OpenVDB Points")) {
OP_Context context(parms.getTime());
GU_DetailHandle gdHandle = getCookedGeoHandle(context);
if (gdHandle.isNull()) return;
GU_DetailHandleAutoReadLock gdLock(gdHandle);
const GU_Detail* tmpGdp = gdLock.getGdp();
if (!tmpGdp) return;
info->addColumnHeading("Point Count");
info->addColumnHeading("Point Groups");
info->addColumnHeading("Point Attributes");
for (VdbPrimCIterator it(tmpGdp); it; ++it) {
const openvdb::GridBase::ConstPtr grid = it->getConstGridPtr();
if (!grid) continue;
if (!grid->isType<openvdb::points::PointDataGrid>()) continue;
const openvdb::points::PointDataGrid& points =
*openvdb::gridConstPtrCast<openvdb::points::PointDataGrid>(grid);
std::string countStr, groupStr, attributeStr;
collectPointInfo(points, countStr, groupStr, attributeStr);
ut_PropertyRow* row = info->addProperties();
row->append(countStr);
row->append(groupStr);
row->append(attributeStr);
}
}
}
#endif
}
void
SOP_NodeVDB::getNodeSpecificInfoText(OP_Context &context, OP_NodeInfoParms &parms)
{
SOP_Node::getNodeSpecificInfoText(context, parms);
#ifdef SESI_OPENVDB
// Nothing needed since we will report it as part of native prim info
#else
// Get a handle to the geometry.
GU_DetailHandle gd_handle = getCookedGeoHandle(context);
// Check if we have a valid detail handle.
if(gd_handle.isNull()) return;
// Lock it for reading.
GU_DetailHandleAutoReadLock gd_lock(gd_handle);
// Finally, get at the actual GU_Detail.
const GU_Detail* tmp_gdp = gd_lock.getGdp();
std::ostringstream infoStr;
unsigned gridn = 0;
for (VdbPrimCIterator it(tmp_gdp); it; ++it) {
const openvdb::GridBase& grid = it->getGrid();
node_info_text::ApplyGridSpecificInfoText callback =
node_info_text::getGridSpecificInfoText(grid.type());
if (callback) {
// Note, the output string stream for every new grid is initialized with
// its index and houdini primitive name prior to executing the callback
const UT_String gridName = it.getPrimitiveName();
infoStr << " (" << it.getIndex() << ")";
if(gridName.isstring()) infoStr << " name: '" << gridName << "',";
(*callback)(infoStr, grid);
infoStr<<"\n";
++gridn;
}
}
if (gridn > 0) {
std::ostringstream headStr;
headStr << gridn << " Custom VDB grid" << (gridn == 1 ? "" : "s") << "\n";
parms.append(headStr.str().c_str());
parms.append(infoStr.str().c_str());
}
#endif
}
////////////////////////////////////////
OP_ERROR
SOP_NodeVDB::duplicateSourceStealable(const unsigned index,
OP_Context& context, GU_Detail **pgdp, GU_DetailHandle& gdh, bool clean)
{
OPENVDB_NO_DEPRECATION_WARNING_BEGIN
// traverse upstream nodes, if unload is not possible, duplicate the source
if (!isSourceStealable(index, context)) {
duplicateSource(index, context, *pgdp, clean);
unlockInput(index);
return error();
}
OPENVDB_NO_DEPRECATION_WARNING_END
// get the input GU_Detail handle and unlock the inputs
GU_DetailHandle inputgdh = inputGeoHandle(index);
unlockInput(index);
SOP_Node *input = CAST_SOPNODE(getInput(index));
if (!input) {
addError(SOP_MESSAGE, "Invalid input SOP Node when attempting to unload.");
return error();
}
// explicitly unload the data from the input SOP
const bool unloadSuccessful = input->unloadData();
// check if we only have one reference
const bool soleReference = (inputgdh.getRefCount() == 1);
// if the unload was unsuccessful or the reference count is not one, we fall back to
// explicitly copying the input onto the gdp
if (!(unloadSuccessful && soleReference)) {
const GU_Detail *src = inputgdh.readLock();
UT_ASSERT(src);
if (src) (*pgdp)->copy(*src);
inputgdh.unlock(src);
return error();
}
// release our old write lock on gdp (setup by cookMe())
gdh.unlock(*pgdp);
// point to the input's old gdp and setup a write lock
gdh = inputgdh;
*pgdp = gdh.writeLock();
return error();
}
bool
SOP_NodeVDB::isSourceStealable(const unsigned index, OP_Context& context) const
{
struct Local {
static inline OP_Node* nextStealableInput(
const unsigned idx, const fpreal now, const OP_Node* node)
{
OP_Node* input = node->getInput(idx);
while (input) {
OP_Node* passThrough = input->getPassThroughNode(now);
if (!passThrough) break;
input = passThrough;
}
return input;
}
}; // struct Local
const fpreal now = context.getTime();
for (OP_Node* node = Local::nextStealableInput(index, now, this); node != nullptr;
node = Local::nextStealableInput(index, now, node))
{
// cont'd if it is a SOP_NULL.
std::string opname = node->getName().toStdString().substr(0, 4);
if (opname == "null") continue;
// if the SOP is a cache SOP we don't want to try and alter its data without a deep copy
if (dynamic_cast<SOP_Cache*>(node)) return false;
if (node->getUnload() != 0)
return true;
else
return false;
}
return false;
}
OP_ERROR
SOP_NodeVDB::duplicateSourceStealable(const unsigned index, OP_Context& context)
{
OPENVDB_NO_DEPRECATION_WARNING_BEGIN
auto error = this->duplicateSourceStealable(index, context, &gdp, myGdpHandle, true);
OPENVDB_NO_DEPRECATION_WARNING_END
return error;
}
////////////////////////////////////////
const SOP_NodeVerb*
SOP_NodeVDB::cookVerb() const
{
if (const auto* verb = SOP_NodeVerb::lookupVerb(getOperator()->getName())) {
return verb; ///< @todo consider caching this
}
return SOP_Node::cookVerb();
}
OP_ERROR
SOP_NodeVDB::cookMySop(OP_Context& context)
{
if (cookVerb()) {
return cookMyselfAsVerb(context);
}
return cookVDBSop(context);
}
////////////////////////////////////////
namespace {
void
createEmptyGridGlyph(GU_Detail& gdp, GridCRef grid)
{
openvdb::Vec3R lines[6];
lines[0].init(-0.5, 0.0, 0.0);
lines[1].init( 0.5, 0.0, 0.0);
lines[2].init( 0.0,-0.5, 0.0);
lines[3].init( 0.0, 0.5, 0.0);
lines[4].init( 0.0, 0.0,-0.5);
lines[5].init( 0.0, 0.0, 0.5);
const openvdb::math::Transform &xform = grid.transform();
lines[0] = xform.indexToWorld(lines[0]);
lines[1] = xform.indexToWorld(lines[1]);
lines[2] = xform.indexToWorld(lines[2]);
lines[3] = xform.indexToWorld(lines[3]);
lines[4] = xform.indexToWorld(lines[4]);
lines[5] = xform.indexToWorld(lines[5]);
UT_SharedPtr<GU_Detail> tmpGDP(new GU_Detail);
UT_Vector3 color(0.1f, 1.0f, 0.1f);
tmpGDP->addFloatTuple(GA_ATTRIB_POINT, "Cd", 3, GA_Defaults(color.data(), 3));
GU_PrimPoly *poly;
for (int i = 0; i < 6; i += 2) {
poly = GU_PrimPoly::build(&*tmpGDP, 2, GU_POLY_OPEN);
tmpGDP->setPos3(poly->getPointOffset(i % 2),
UT_Vector3(float(lines[i][0]), float(lines[i][1]), float(lines[i][2])));
tmpGDP->setPos3(poly->getPointOffset(i % 2 + 1),
UT_Vector3(float(lines[i + 1][0]), float(lines[i + 1][1]), float(lines[i + 1][2])));
}
gdp.merge(*tmpGDP);
}
} // unnamed namespace
OP_ERROR
SOP_NodeVDB::cookMyGuide1(OP_Context& context)
{
#ifndef SESI_OPENVDB
myGuide1->clearAndDestroy();
UT_Vector3 color(0.1f, 0.1f, 1.0f);
UT_Vector3 corners[8];
// For each VDB primitive (with a non-null grid pointer) in the group...
for (VdbPrimIterator it(gdp); it; ++it) {
if (evalGridBBox(it->getGrid(), corners, /*expandHalfVoxel=*/true)) {
houdini_utils::createBox(*myGuide1, corners, &color);
} else {
createEmptyGridGlyph(*myGuide1, it->getGrid());
}
}
#endif
return SOP_Node::cookMyGuide1(context);
}
////////////////////////////////////////
openvdb::Vec3f
SOP_NodeVDB::evalVec3f(const char *name, fpreal time) const
{
return openvdb::Vec3f(float(evalFloat(name, 0, time)),
float(evalFloat(name, 1, time)),
float(evalFloat(name, 2, time)));
}
openvdb::Vec3R
SOP_NodeVDB::evalVec3R(const char *name, fpreal time) const
{
return openvdb::Vec3R(evalFloat(name, 0, time),
evalFloat(name, 1, time),
evalFloat(name, 2, time));
}
openvdb::Vec3i
SOP_NodeVDB::evalVec3i(const char *name, fpreal time) const
{
using ValueT = openvdb::Vec3i::value_type;
return openvdb::Vec3i(static_cast<ValueT>(evalInt(name, 0, time)),
static_cast<ValueT>(evalInt(name, 1, time)),
static_cast<ValueT>(evalInt(name, 2, time)));
}
openvdb::Vec2R
SOP_NodeVDB::evalVec2R(const char *name, fpreal time) const
{
return openvdb::Vec2R(evalFloat(name, 0, time),
evalFloat(name, 1, time));
}
openvdb::Vec2i
SOP_NodeVDB::evalVec2i(const char *name, fpreal time) const
{
using ValueT = openvdb::Vec2i::value_type;
return openvdb::Vec2i(static_cast<ValueT>(evalInt(name, 0, time)),
static_cast<ValueT>(evalInt(name, 1, time)));
}
std::string
SOP_NodeVDB::evalStdString(const char* name, fpreal time, int index) const
{
UT_String str;
evalString(str, name, index, time);
return str.toStdString();
}
////////////////////////////////////////
void
SOP_NodeVDB::resolveRenamedParm(PRM_ParmList& obsoleteParms,
const char* oldName, const char* newName)
{
PRM_Parm* parm = obsoleteParms.getParmPtr(oldName);
if (parm && !parm->isFactoryDefault()) {
if (this->hasParm(newName)) {
this->getParm(newName).copyParm(*parm);
}
}
}
////////////////////////////////////////
namespace {
/// @brief Default OpPolicy for OpenVDB operator types
class DefaultOpenVDBOpPolicy: public houdini_utils::OpPolicy
{
public:
std::string getValidName(const std::string& english)
{
UT_String s(english);
// Remove non-alphanumeric characters from the name.
s.forceValidVariableName();
std::string name = s.toStdString();
// Remove spaces and underscores.
name.erase(std::remove(name.begin(), name.end(), ' '), name.end());
name.erase(std::remove(name.begin(), name.end(), '_'), name.end());
return name;
}
std::string getLowercaseName(const std::string& english)
{
UT_String s(english);
// Lowercase
s.toLower();
return s.toStdString();
}
/// @brief OpenVDB operators of each flavor (SOP, POP, etc.) share
/// an icon named "SOP_OpenVDB", "POP_OpenVDB", etc.
std::string getIconName(const houdini_utils::OpFactory& factory) override
{
return factory.flavorString() + "_OpenVDB";
}
/// @brief Return the name of the equivalent native operator as shipped with Houdini.
/// @details An empty string indicates that there is no equivalent native operator.
virtual std::string getNativeName(const houdini_utils::OpFactory&)
{
return "";
}
};
/// @brief SideFX OpPolicy for OpenVDB operator types
class SESIOpenVDBOpPolicy: public DefaultOpenVDBOpPolicy
{
public:
std::string getName(const houdini_utils::OpFactory&, const std::string& english) override
{
return this->getLowercaseName(this->getValidName(english));
}
std::string getTabSubMenuPath(const houdini_utils::OpFactory&) override
{
return "VDB";
}
};
/// @brief ASWF OpPolicy for OpenVDB operator types
class ASWFOpenVDBOpPolicy: public DefaultOpenVDBOpPolicy
{
public:
std::string getName(const houdini_utils::OpFactory&, const std::string& english) override
{
return "DW_Open" + this->getValidName(english);
}
std::string getLabelName(const houdini_utils::OpFactory& factory) override
{
return factory.english();
}
std::string getFirstName(const houdini_utils::OpFactory& factory) override
{
return this->getLowercaseName(this->getValidName(this->getLabelName(factory)));
}
std::string getNativeName(const houdini_utils::OpFactory& factory) override
{
return this->getLowercaseName(this->getValidName(factory.english()));
}
std::string getTabSubMenuPath(const houdini_utils::OpFactory&) override
{
return "VDB/ASWF";
}
};
#ifdef SESI_OPENVDB
using OpenVDBOpPolicy = SESIOpenVDBOpPolicy;
#else
using OpenVDBOpPolicy = ASWFOpenVDBOpPolicy;
#endif // SESI_OPENVDB
} // unnamed namespace
OpenVDBOpFactory::OpenVDBOpFactory(
const std::string& english,
OP_Constructor ctor,
houdini_utils::ParmList& parms,
OP_OperatorTable& table,
houdini_utils::OpFactory::OpFlavor flavor):
houdini_utils::OpFactory(OpenVDBOpPolicy(), english, ctor, parms, table, flavor)
{
setNativeName(OpenVDBOpPolicy().getNativeName(*this));
std::stringstream ss;
ss << "vdb" << OPENVDB_LIBRARY_VERSION_STRING << " ";
ss << "houdini" << SYS_Version::full();
// Define an operator version of the format "vdb6.1.0 houdini18.0.222",
// which can be returned by OP_OperatorDW::getVersion() and used to
// handle compatibility between specific versions of VDB or Houdini
addSpareData({{"operatorversion", ss.str()}});
}
OpenVDBOpFactory&
OpenVDBOpFactory::setNativeName(const std::string& name)
{
// SideFX nodes have no native equivalent.
#ifndef SESI_OPENVDB
addSpareData({{"nativename", name}});
// if native name was previously defined and is present
// in the hidden table then remove it regardless of policy
if (!mNativeName.empty() &&
this->table().isOpHidden(mNativeName.c_str())) {
this->table().delOpHidden(mNativeName.c_str());
}
mNativeName = name;
if (!name.empty()) {
const std::string& opHidePolicy = getOpHidePolicy();
if (opHidePolicy == "aswf") {
// set this SOP to be hidden (if a native equivalent exists)
this->setInvisible();
} else if (opHidePolicy == "native") {
// mark the native equivalent SOP to be hidden
this->table().addOpHidden(name.c_str());
}
}
#endif
return *this;
}
} // namespace openvdb_houdini
| 22,919 | C++ | 28.727626 | 96 | 0.641084 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Prune.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Prune.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief SOP to prune tree branches from OpenVDB grids
#include <houdini_utils/ParmFactory.h>
#include <openvdb/tools/Prune.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <UT/UT_Interrupt.h>
#include <stdexcept>
#include <string>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Prune: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Prune(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Prune() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
};
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDBs to be pruned.")
.setDocumentation(
"A subset of the input VDBs to be pruned"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "mode", "Mode")
.setDefault("value")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"value", "Value",
"inactive", "Inactive",
"levelset", "Level Set"
})
.setTooltip(
"Value:\n"
" Collapse regions in which all voxels have the same\n"
" value and active state into tiles with those values\n"
" and active states.\n"
"Inactive:\n"
" Collapse regions in which all voxels are inactive\n"
" into inactive background tiles.\n"
"Level Set:\n"
" Collapse regions in which all voxels are inactive\n"
" into inactive tiles with either the inside or\n"
" the outside background value, depending on\n"
" the signs of the voxel values.\n"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "tolerance", "Tolerance")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 1)
.setTooltip(
"Voxel values are considered equal if they differ\n"
"by less than the specified threshold."));
hvdb::OpenVDBOpFactory("VDB Prune", SOP_OpenVDB_Prune::factory, parms, *table)
.setNativeName("")
.addInput("Grids to process")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Prune::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Reduce the memory footprint of VDB volumes.\"\"\"\n\
\n\
@overview\n\
\n\
This node prunes branches of VDB\n\
[trees|http://www.openvdb.org/documentation/doxygen/overview.html#secTree]\n\
where all voxels have the same or similar values.\n\
This can help to reduce the memory footprint of a VDB, without changing its topology.\n\
With a suitably high tolerance, pruning can function as a simple\n\
form of lossy compression.\n\
\n\
@related\n\
- [OpenVDB Densify|Node:sop/DW_OpenVDBDensify]\n\
- [Node:sop/vdbactivate]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Prune::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Prune(net, name, op);
}
SOP_OpenVDB_Prune::SOP_OpenVDB_Prune(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
// Enable/disable or show/hide parameters in the UI.
bool
SOP_OpenVDB_Prune::updateParmsFlags()
{
bool changed = false;
changed |= enableParm("tolerance", evalStdString("mode", 0) == "value");
return changed;
}
////////////////////////////////////////
namespace {
struct PruneOp {
PruneOp(const std::string m, fpreal tol = 0.0): mode(m), pruneTolerance(tol) {}
template<typename GridT>
void operator()(GridT& grid) const
{
using ValueT = typename GridT::ValueType;
if (mode == "value") {
OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
const ValueT tolerance(openvdb::zeroVal<ValueT>() + pruneTolerance);
OPENVDB_NO_TYPE_CONVERSION_WARNING_END
openvdb::tools::prune(grid.tree(), tolerance);
} else if (mode == "inactive") {
openvdb::tools::pruneInactive(grid.tree());
} else if (mode == "levelset") {
openvdb::tools::pruneLevelSet(grid.tree());
}
}
std::string mode;
fpreal pruneTolerance;
};
}
OP_ERROR
SOP_OpenVDB_Prune::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
// Get the group of grids to process.
const GA_PrimitiveGroup* group = this->matchGroup(*gdp, evalStdString("group", time));
// Get other UI parameters.
const fpreal tolerance = evalFloat("tolerance", 0, time);
// Construct a functor to process grids of arbitrary type.
const PruneOp pruneOp(evalStdString("mode", time), tolerance);
UT_AutoInterrupt progress("Pruning OpenVDB grids");
// Process each VDB primitive that belongs to the selected group.
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (progress.wasInterrupted()) {
throw std::runtime_error("processing was interrupted");
}
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, pruneOp);
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 6,046 | C++ | 28.354369 | 94 | 0.618095 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GU_VDBPointTools.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file GU_VDBPointTools.h
/// @author FX R&D OpenVDB team
///
/// @brief Collection of PointIndexGrid helpers for Houdini
#ifndef GU_VDBPOINTTOOLS_H_HAS_BEEN_INCLUDED
#define GU_VDBPOINTTOOLS_H_HAS_BEEN_INCLUDED
#if defined(SESI_OPENVDB)
#include "GU_Detail.h"
#include "GU_DetailHandle.h"
#include "GU_PackedContext.h"
#include "GU_PackedFragment.h"
#include "GU_PackedGeometry.h"
#include "GU_PrimPacked.h"
#else
#include <GU/GU_Detail.h>
#include <GU/GU_DetailHandle.h>
#include <GU/GU_PackedContext.h>
#include <GU/GU_PackedFragment.h>
#include <GU/GU_PackedGeometry.h>
#include <GU/GU_PrimPacked.h>
#endif
#include <GA/GA_ElementGroup.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_VectorTypes.h>
#include <openvdb/Platform.h>
#include <openvdb/tools/PointIndexGrid.h>
#include <openvdb/tools/ParticleAtlas.h>
#include <openvdb/tools/PointsToMask.h>
#include <vector>
/// @brief Houdini point attribute wrapper
template<typename VectorType>
struct GU_VDBPointList
{
using Ptr = UT_SharedPtr<GU_VDBPointList>;
using ConstPtr = UT_SharedPtr<const GU_VDBPointList>;
using PosType = VectorType;
using ScalarType = typename PosType::value_type;
GU_VDBPointList(const GU_Detail& detail, const GA_PointGroup* group = nullptr)
: mPositionHandle(detail.getP())
, mVelocityHandle()
, mRadiusHandle()
, mIndexMap(&detail.getP()->getIndexMap())
, mOffsets()
, mSize(mIndexMap->indexSize())
{
if (group) {
mSize = group->entries();
mOffsets.reserve(mSize);
GA_Offset start, end;
GA_Range range(*group);
for (GA_Iterator it = range.begin(); it.blockAdvance(start, end); ) {
for (GA_Offset off = start; off < end; ++off) {
mOffsets.push_back(off);
}
}
getOffset = &GU_VDBPointList::offsetFromGroupMap;
} else if (mIndexMap->isTrivialMap()) {
getOffset = &GU_VDBPointList::offsetFromIndexCast;
} else {
getOffset = &GU_VDBPointList::offsetFromGeoMap;
}
// Bind optional attributes
GA_ROAttributeRef velRef = detail.findFloatTuple(GA_ATTRIB_POINT, GEO_STD_ATTRIB_VELOCITY, 3);
if (velRef.isValid()) {
mVelocityHandle.bind(velRef.getAttribute());
}
GA_ROAttributeRef radRef = detail.findFloatTuple(GA_ATTRIB_POINT, GEO_STD_ATTRIB_PSCALE);
if (radRef.isValid()) {
mRadiusHandle.bind(radRef.getAttribute());
}
}
static Ptr create(const GU_Detail& detail, const GA_PointGroup* group = nullptr)
{
return Ptr(new GU_VDBPointList(detail, group));
}
size_t size() const { return mSize; }
bool hasVelocity() const { return mVelocityHandle.isValid(); }
bool hasRadius() const { return mRadiusHandle.isValid(); }
// Index access methods
void getPos(size_t n, PosType& xyz) const {
getPosFromOffset((this->*getOffset)(n), xyz);
}
void getVelocity(size_t n, PosType& v) const {
getVelocityFromOffset((this->*getOffset)(n), v);
}
void getRadius(size_t n, ScalarType& r) const {
getRadiusFromOffset((this->*getOffset)(n), r);
}
// Offset access methods
GA_Offset offsetFromIndex(size_t n) const {
return (this->*getOffset)(n);
}
void getPosFromOffset(const GA_Offset offset, PosType& xyz) const {
const UT_Vector3 data = mPositionHandle.get(offset);
xyz[0] = ScalarType(data[0]);
xyz[1] = ScalarType(data[1]);
xyz[2] = ScalarType(data[2]);
}
void getVelocityFromOffset(const GA_Offset offset, PosType& v) const {
const UT_Vector3 data = mVelocityHandle.get(offset);
v[0] = ScalarType(data[0]);
v[1] = ScalarType(data[1]);
v[2] = ScalarType(data[2]);
}
void getRadiusFromOffset(const GA_Offset offset, ScalarType& r) const {
r = ScalarType(mRadiusHandle.get(offset));
}
private:
// Disallow copying
GU_VDBPointList(const GU_VDBPointList&);
GU_VDBPointList& operator=(const GU_VDBPointList&);
GA_Offset (GU_VDBPointList::* getOffset)(const size_t) const;
GA_Offset offsetFromGeoMap(const size_t n) const {
return mIndexMap->offsetFromIndex(GA_Index(n));
}
GA_Offset offsetFromGroupMap(const size_t n) const {
return mOffsets[n];
}
GA_Offset offsetFromIndexCast(const size_t n) const {
return GA_Offset(n);
}
GA_ROHandleV3 mPositionHandle, mVelocityHandle;
GA_ROHandleF mRadiusHandle;
GA_IndexMap const * const mIndexMap;
std::vector<GA_Offset> mOffsets;
size_t mSize;
}; // GU_VDBPointList
////////////////////////////////////////
// PointIndexGrid utility methods
namespace GU_VDBPointToolsInternal {
template<typename PointArrayType>
struct IndexToOffsetOp {
IndexToOffsetOp(const PointArrayType& points): mPointList(&points) {}
template <typename LeafT>
void operator()(LeafT &leaf, size_t /*leafIndex*/) const {
typename LeafT::IndexArray& indices = leaf.indices();
for (size_t n = 0, N = indices.size(); n < N; ++n) {
indices[n] = static_cast<typename LeafT::ValueType::IntType>(
mPointList->offsetFromIndex(GA_Index{indices[n]}));
}
}
PointArrayType const * const mPointList;
};
struct PackedMaskConstructor
{
PackedMaskConstructor(const std::vector<const GA_Primitive*>& prims,
const openvdb::math::Transform& xform)
: mPrims(prims.empty() ? nullptr : &prims.front())
, mXForm(xform)
, mMaskGrid(new openvdb::MaskGrid(false))
{
mMaskGrid->setTransform(mXForm.copy());
}
PackedMaskConstructor(PackedMaskConstructor& rhs, tbb::split)
: mPrims(rhs.mPrims)
, mXForm(rhs.mXForm)
, mMaskGrid(new openvdb::MaskGrid(false))
{
mMaskGrid->setTransform(mXForm.copy());
}
openvdb::MaskGrid::Ptr getMaskGrid() { return mMaskGrid; }
void join(PackedMaskConstructor& rhs) { mMaskGrid->tree().topologyUnion(rhs.mMaskGrid->tree()); }
void operator()(const tbb::blocked_range<size_t>& range)
{
GU_PackedContext packedcontext;
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
const GA_Primitive *prim = mPrims[n];
if (!prim || !GU_PrimPacked::isPackedPrimitive(*prim)) continue;
const GU_PrimPacked * pprim = static_cast<const GU_PrimPacked*>(prim);
GU_Detail tmpdetail;
const GU_Detail *detailtouse;
GU_DetailHandleAutoReadLock readlock(pprim->getPackedDetail(packedcontext));
UT_Matrix4D mat;
pprim->getFullTransform4(mat);
if (mat.isIdentity() && readlock.isValid() && readlock.getGdp()) {
detailtouse = readlock.getGdp();
} else {
pprim->unpackWithContext(tmpdetail, packedcontext);
detailtouse = &tmpdetail;
}
GU_VDBPointList<openvdb::Vec3R> points(*detailtouse);
openvdb::MaskGrid::Ptr grid = openvdb::tools::createPointMask(points, mXForm);
mMaskGrid->tree().topologyUnion(grid->tree());
}
}
private:
GA_Primitive const * const * const mPrims;
openvdb::math::Transform mXForm;
openvdb::MaskGrid::Ptr mMaskGrid;
}; // struct PackedMaskConstructor
inline void
getPackedPrimitiveOffsets(const GU_Detail& detail, std::vector<const GA_Primitive*>& primitives)
{
const GA_Size numPacked = GU_PrimPacked::countPackedPrimitives(detail);
primitives.clear();
primitives.reserve(size_t(numPacked));
if (numPacked != GA_Size(0)) {
GA_Offset start, end;
GA_Range range = detail.getPrimitiveRange();
const GA_PrimitiveList& primList = detail.getPrimitiveList();
for (GA_Iterator it = range.begin(); it.blockAdvance(start, end); ) {
for (GA_Offset off = start; off < end; ++off) {
const GA_Primitive *prim = primList.get(off);
if (prim && GU_PrimPacked::isPackedPrimitive(*prim)) {
primitives.push_back(prim);
}
}
}
}
}
} // namespace GU_VDBPointToolsInternal
////////////////////////////////////////
/// @brief Utility method to construct a GU_VDBPointList.
/// @details The GU_VDBPointList is compatible with the PointIndexGrid and ParticleAtals structures.
inline GU_VDBPointList<openvdb::Vec3s>::Ptr
GUvdbCreatePointList(const GU_Detail& detail, const GA_PointGroup* pointGroup = nullptr)
{
return GU_VDBPointList<openvdb::Vec3s>::create(detail, pointGroup);
}
/// @brief Utility method to change point indices into Houdini geometry offsets.
/// @note PointIndexGrid's that store Houdini geometry offsets are not
/// safe to write to disk, offsets are not guaranteed to be immutable
/// under defragmentation operations or I/O.
template<typename PointIndexTreeType, typename PointArrayType>
inline void
GUvdbConvertIndexToOffset(PointIndexTreeType& tree, const PointArrayType& points)
{
openvdb::tree::LeafManager<PointIndexTreeType> leafnodes(tree);
leafnodes.foreach(GU_VDBPointToolsInternal::IndexToOffsetOp<PointArrayType>(points));
}
/// @brief Utility method to construct a PointIndexGrid.
/// @details The PointIndexGrid supports fast spatial queries for points.
inline openvdb::tools::PointIndexGrid::Ptr
GUvdbCreatePointIndexGrid(
const openvdb::math::Transform& xform,
const GU_Detail& detail,
const GA_PointGroup* pointGroup = nullptr)
{
GU_VDBPointList<openvdb::Vec3s> points(detail, pointGroup);
return openvdb::tools::createPointIndexGrid<openvdb::tools::PointIndexGrid>(points, xform);
}
/// @brief Utility method to construct a PointIndexGrid.
/// @details The PointIndexGrid supports fast spatial queries for points.
template<typename PointArrayType>
inline openvdb::tools::PointIndexGrid::Ptr
GUvdbCreatePointIndexGrid(const openvdb::math::Transform& xform, const PointArrayType& points)
{
return openvdb::tools::createPointIndexGrid<openvdb::tools::PointIndexGrid>(points, xform);
}
/// @brief Utility method to construct a ParticleAtals.
/// @details The ParticleAtals supports fast spatial queries for particles.
template<typename ParticleArrayType>
inline openvdb::tools::ParticleIndexAtlas::Ptr
GUvdbCreateParticleAtlas(const double minVoxelSize, const ParticleArrayType& particles)
{
using ParticleIndexAtlas = openvdb::tools::ParticleIndexAtlas;
ParticleIndexAtlas::Ptr atlas(new ParticleIndexAtlas());
if (particles.hasRadius()) {
atlas->construct(particles, minVoxelSize);
}
return atlas;
}
/// @brief Utility method to construct a boolean PointMaskGrid
/// @details This method supports packed points.
inline openvdb::MaskGrid::Ptr
GUvdbCreatePointMaskGrid(
const openvdb::math::Transform& xform,
const GU_Detail& detail,
const GA_PointGroup* pointGroup = nullptr)
{
std::vector<const GA_Primitive*> packed;
GU_VDBPointToolsInternal::getPackedPrimitiveOffsets(detail, packed);
if (!packed.empty()) {
GU_VDBPointToolsInternal::PackedMaskConstructor op(packed, xform);
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, packed.size()), op);
return op.getMaskGrid();
}
GU_VDBPointList<openvdb::Vec3R> points(detail, pointGroup);
return openvdb::tools::createPointMask(points, xform);
}
/// @brief Utility method to construct a PointIndexGrid that stores
/// Houdini geometry offsets.
///
/// @note PointIndexGrid's that store Houdini geometry offsets are not
/// safe to write to disk, offsets are not guaranteed to be immutable
/// under defragmentation operations or I/O.
inline openvdb::tools::PointIndexGrid::Ptr
GUvdbCreatePointOffsetGrid(
const openvdb::math::Transform& xform,
const GU_Detail& detail,
const GA_PointGroup* pointGroup = nullptr)
{
GU_VDBPointList<openvdb::Vec3s> points(detail, pointGroup);
openvdb::tools::PointIndexGrid::Ptr grid =
openvdb::tools::createPointIndexGrid<openvdb::tools::PointIndexGrid>(points, xform);
GUvdbConvertIndexToOffset(grid->tree(), points);
return grid;
}
#endif // GU_VDBPOINTTOOLS_H_HAS_BEEN_INCLUDED
| 12,546 | C | 31.337629 | 102 | 0.661326 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Scatter.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Scatter.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Scatter points on a VDB grid, either by fixed count or by
/// global or local point density.
#include <UT/UT_Assert.h>
#include <UT/UT_ParallelUtil.h> // for UTparallelForLightItems()
#include <GA/GA_SplittableRange.h>
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb/math/Math.h>
#include <openvdb/math/Stencils.h>
#include <openvdb/points/PointDelete.h>
#include <openvdb/points/PointGroup.h>
#include <openvdb/points/PointScatter.h>
#include <openvdb/tools/GridOperators.h> // for tools::cpt()
#include <openvdb/tools/Interpolation.h> // for tools::BoxSampler
#include <openvdb/tools/LevelSetRebuild.h>
#include <openvdb/tools/LevelSetUtil.h>
#include <openvdb/tools/Morphology.h> // for tools::dilateVoxels()
#include <openvdb/tools/PointScatter.h>
#include <openvdb/tree/LeafManager.h>
#include <hboost/algorithm/string/join.hpp>
#include <iostream>
#include <random>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Scatter: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Scatter(OP_Network* net, const char* name, OP_Operator* op);
~SOP_OpenVDB_Scatter() override {}
static OP_Node* factory(OP_Network*, const char*, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
void syncNodeVersion(const char* oldVersion, const char*, bool*) override;
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
};
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDBs over which to scatter points.")
.setDocumentation(
"A subset of the input VDBs over which to scatter points"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "keep", "Keep Original Geometry")
.setDefault(PRMzeroDefaults)
.setTooltip("If enabled, the incoming geometry will not be deleted."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "vdbpoints", "Scatter VDB Points")
.setDefault(PRMzeroDefaults)
.setTooltip("Generate VDB Points instead of Houdini Points."));
parms.add(hutil::ParmFactory(PRM_ORD, "outputname", "Output Name")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"keep", "Keep Original Name",
"append", "Add Suffix",
"replace", "Custom Name",
})
.setTooltip(
"Give the output VDB Points volumes the same names as the input VDBs,\n"
"or add a suffix to the input name, or use a custom name."));
parms.add(hutil::ParmFactory(PRM_STRING, "customname", "Custom Name")
.setDefault("points")
.setTooltip("The suffix or custom name to be used"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "dogroup", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setDefault(PRMzeroDefaults));
parms.add(hutil::ParmFactory(PRM_STRING, "sgroup", "Scatter Group")
.setDefault(0, "scatter")
.setTooltip("If enabled, add scattered points to the group with this name."));
parms.add(hutil::ParmFactory(PRM_INT_J, "seed", "Random Seed")
.setDefault(PRMzeroDefaults)
.setTooltip("The random number seed"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "spread", "Spread")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_RESTRICTED, 1.0)
.setTooltip(
"How far each point may be displaced from the center of its voxel or tile,\n"
"as a fraction of the voxel or tile size\n\n"
"A value of zero means that the point is placed exactly at the center."
" A value of one means that the point can be placed randomly anywhere"
" inside the voxel or tile.\n\n"
"When the __SDF Domain__ is an __Isosurface__, a value of zero means that the point"
" is placed exactly on the isosurface, and a value of one means that the point"
" can be placed randomly anywhere within one voxel of the isosurface.\n"
"Frustum grids are currently not properly supported, however."));
parms.add(hutil::ParmFactory(PRM_ORD, "pointmode", "Mode")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"count", "Point Total",
"density", "Point Density",
"pointspervoxel", "Points Per Voxel",
})
.setTooltip(
"How to determine the number of points to scatter\n\n"
"Point Total:\n"
" Specify a fixed, total point count.\n"
"Point Density:\n"
" Specify the number of points per unit volume.\n"
"Points Per Voxel:\n"
" Specify the number of points per voxel."));
parms.add(hutil::ParmFactory(PRM_INT_J, "count", "Point Total")
.setDefault(5000)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10000)
.setTooltip("The total number of points to scatter"));
parms.add(hutil::ParmFactory(PRM_FLT_J , "ppv", "Points Per Voxel")
.setDefault(8)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10)
.setTooltip("The number of points per voxel"));
parms.add(hutil::ParmFactory(PRM_FLT_LOG, "density", "Point Density")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 1000000)
.setTooltip("The number of points per unit volume"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "multiply", "Scale Density by Voxel Values")
.setDefault(PRMzeroDefaults)
.setTooltip(
"For scalar-valued VDBs other than signed distance fields,"
" use voxel values as local multipliers for point density."));
parms.add(hutil::ParmFactory(PRM_ORD, "poscompression", "Position Compression")
.setDefault(PRMoneDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"none", "None",
"int16", "16-bit Fixed Point",
"int8", "8-bit Fixed Point"
})
.setTooltip("The position attribute compression setting.")
.setDocumentation(
"The position can be stored relative to the center of the voxel.\n"
"This means it does not require the full 32-bit float representation,\n"
"but can be quantized to a smaller fixed-point value."));
parms.add(hutil::ParmFactory(PRM_STRING, "sdfdomain", "SDF Domain")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"interior", "Interior",
"surface", "Isosurface",
"band", "Narrow Band",
})
.setDefault("band")
.setTooltip(
"For signed distance field VDBs, the region over which to scatter points\n\n"
"Interior:\n"
" Scatter points inside the specified isosurface.\n"
"Isosurface:\n"
" Scatter points only on the specified isosurface.\n"
"Narrow Band:\n"
" Scatter points only in the narrow band surrounding the zero crossing."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "isovalue", "Isovalue")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_UI, -1.0, PRM_RANGE_UI, 1.0)
.setTooltip("The voxel value that determines the isosurface")
.setDocumentation(
"The voxel value that determines the isosurface\n\n"
"For fog volumes, use a value larger than zero."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "cliptoisosurface", "Clip to Isosurface")
.setDefault(PRMzeroDefaults)
.setTooltip("When scattering VDB Points, remove points outside the isosurface."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "verbose", "Verbose")
.setDefault(PRMzeroDefaults)
.setTooltip("Print the sequence of operations to the terminal."));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_ORD| PRM_TYPE_JOIN_NEXT, "pointMode", "Point"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "interior", "Scatter Points Inside Level Sets") .setDefault(PRMzeroDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep1", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep2", ""));
// Register the SOP.
hvdb::OpenVDBOpFactory("VDB Scatter", SOP_OpenVDB_Scatter::factory, parms, *table)
.setNativeName("")
.setObsoleteParms(obsoleteParms)
.addInput("VDBs on which points will be scattered")
.setVerb(SOP_NodeVerb::COOK_GENERIC, []() { return new SOP_OpenVDB_Scatter::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Scatter Houdini or VDB points on a VDB volume.\"\"\"\n\
\n\
@overview\n\
\n\
This node scatters points randomly on or inside VDB volumes.\n\
The number of points generated can be specified either by fixed count\n\
or by global or local point density.\n\
\n\
Output can be in the form of either Houdini points or VDB Points volumes.\n\
In the latter case, a VDB Points volume is created for each source VDB,\n\
with the same transform and topology as the source.\n\
\n\
For signed distance field or fog volume VDBs, points can be scattered\n\
either throughout the interior of the volume or only on an isosurface.\n\
For level sets, an additional option is to scatter points only in the\n\
[narrow band|http://www.openvdb.org/documentation/doxygen/overview.html#secGrid]\n\
surrounding the zero crossing.\n\
For all other volumes, points are scattered in active voxels.\n\
\n\
@related\n\
- [Node:sop/scatter]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Scatter::syncNodeVersion(const char* oldVersion, const char*, bool*)
{
// Since VDB 7.0.0, position compression is now set to 16-bit fixed point
// by default. Detect if the VDB version that this node was created with
// was earlier than 7.0.0 and revert back to null compression if so to
// prevent potentially breaking older scenes.
// VDB version string prior to 6.2.0 - "17.5.204"
// VDB version string since 6.2.0 - "vdb6.2.0 houdini17.5.204"
openvdb::Name oldVersionStr(oldVersion);
bool disableCompression = false;
size_t spacePos = oldVersionStr.find_first_of(' ');
if (spacePos == std::string::npos) {
// no space in VDB versions prior to 6.2.0
disableCompression = true;
} else if (oldVersionStr.size() > 3 && oldVersionStr.substr(0,3) == "vdb") {
std::string vdbVersion = oldVersionStr.substr(3,spacePos-3);
// disable compression in VDB version 6.2.1 or earlier
if (UT_String::compareVersionString(vdbVersion.c_str(), "6.2.1") <= 0) {
disableCompression = true;
}
}
if (disableCompression) {
setInt("poscompression", 0, 0, 0);
}
}
void
SOP_OpenVDB_Scatter::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
PRM_Parm* parm = obsoleteParms->getParmPtr("interior");
if (parm && !parm->isFactoryDefault()) { // default was to scatter in the narrow band
setString(UT_String("interior"), CH_STRING_LITERAL, "sdfdomain", 0, 0.0);
}
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
bool
SOP_OpenVDB_Scatter::updateParmsFlags()
{
bool changed = false;
const fpreal time = 0;
const auto vdbpoints = evalInt("vdbpoints", /*idx=*/0, time);
const auto pmode = evalInt("pointmode", /*idx=*/0, time);
const auto sdfdomain = evalStdString("sdfdomain", time);
changed |= setVisibleState("count", (0 == pmode));
changed |= setVisibleState("density", (1 == pmode));
changed |= setVisibleState("multiply", (1 == pmode));
changed |= setVisibleState("ppv", (2 == pmode));
changed |= setVisibleState("name", (1 == vdbpoints));
changed |= setVisibleState("outputname", (1 == vdbpoints));
changed |= setVisibleState("customname", (1 == vdbpoints));
changed |= setVisibleState("cliptoisosurface", (1 == vdbpoints));
changed |= setVisibleState("poscompression", (1 == vdbpoints));
changed |= enableParm("customname", (0 != evalInt("outputname", 0, time)));
changed |= enableParm("sgroup", (1 == evalInt("dogroup", 0, time)));
changed |= enableParm("isovalue", (sdfdomain != "band"));
changed |= enableParm("cliptoisosurface", (sdfdomain != "band"));
return changed;
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Scatter::factory(OP_Network* net, const char* name, OP_Operator *op)
{
return new SOP_OpenVDB_Scatter(net, name, op);
}
SOP_OpenVDB_Scatter::SOP_OpenVDB_Scatter(OP_Network* net, const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
// Simple wrapper class required by openvdb::tools::UniformPointScatter and
// NonUniformPointScatter
class PointAccessor
{
public:
PointAccessor(GEO_Detail* gdp): mGdp(gdp) {}
void add(const openvdb::Vec3R& pos)
{
const GA_Offset ptoff = mGdp->appendPointOffset();
mGdp->setPos3(ptoff, pos.x(), pos.y(), pos.z());
}
protected:
GEO_Detail* mGdp;
};
////////////////////////////////////////
/// @brief Functor to translate points toward an isosurface
class SnapPointsOp
{
public:
using Sampler = openvdb::tools::BoxSampler;
enum class PointType { kInvalid, kHoudini, kVDB };
// Constructor for Houdini points
SnapPointsOp(GEO_Detail& detail, const GA_Range& range, float spread, float isovalue,
bool rebuild, bool dilate, openvdb::BoolGrid::Ptr mask, hvdb::Interrupter* interrupter)
: mPointType(range.isValid() && !range.empty() ? PointType::kHoudini : PointType::kInvalid)
, mDetail(&detail)
, mRange(range)
, mSpread(spread)
, mIsovalue(isovalue)
, mRebuild(rebuild)
, mDilate(dilate)
, mMask(mask)
, mBoss(interrupter)
{
}
// Constructor for VDB points
SnapPointsOp(openvdb::points::PointDataGrid& vdbpts, float spread, float isovalue,
bool rebuild, bool dilate, openvdb::BoolGrid::Ptr mask, hvdb::Interrupter* interrupter)
: mVdbPoints(&vdbpts)
, mSpread(spread)
, mIsovalue(isovalue)
, mRebuild(rebuild)
, mDilate(dilate)
, mMask(mask)
, mBoss(interrupter)
{
const auto leafIter = vdbpts.tree().cbeginLeaf();
const auto descriptor = leafIter->attributeSet().descriptor();
mAttrIdx = descriptor.find("P");
mPointType = (mAttrIdx != openvdb::points::AttributeSet::INVALID_POS) ?
PointType::kVDB : PointType::kInvalid;
}
template<typename GridT>
void operator()(const GridT& aGrid)
{
if (mPointType == PointType::kInvalid) return;
const GridT* grid = &aGrid;
// Replace the input grid with a rebuilt narrow-band level set, if requested
// (typically because the isovalue is nonzero).
typename GridT::Ptr sdf;
if (mRebuild) {
const float width = openvdb::LEVEL_SET_HALF_WIDTH;
sdf = openvdb::tools::levelSetRebuild(*grid, mIsovalue,
/*exterior=*/width, /*interior=*/width, /*xform=*/nullptr, mBoss);
if (sdf) {
grid = sdf.get();
mMask.reset(); // no need for a mask now that the input is a narrow-band level set
}
}
// Compute the closest point transform of the SDF.
const auto cpt = [&]() {
if (!mMask) {
return openvdb::tools::cpt(*grid, /*threaded=*/true, mBoss);
} else {
if (mDilate) {
// Dilate the isosurface mask to produce a suitably large CPT mask,
// to avoid unnecessary work in case the input is a dense SDF.
const int iterations = static_cast<int>(openvdb::LEVEL_SET_HALF_WIDTH);
openvdb::tools::dilateVoxels(
mMask->tree(), iterations, openvdb::tools::NN_FACE_EDGE);
}
return openvdb::tools::cpt(*grid, *mMask, /*threaded=*/true, mBoss);
}
}();
const auto& xform = aGrid.transform();
if (mPointType == PointType::kHoudini) {
// Translate Houdini points toward the isosurface.
UTparallelForLightItems(GA_SplittableRange(mRange), [&](const GA_SplittableRange& r) {
const auto cptAcc = cpt->getConstAccessor();
auto start = GA_Offset(GA_INVALID_OFFSET), end = GA_Offset(GA_INVALID_OFFSET);
for (GA_Iterator it(r); it.blockAdvance(start, end); ) {
if (mBoss && mBoss->wasInterrupted()) break;
for (auto offset = start; offset < end; ++offset) {
openvdb::Vec3d p{UTvdbConvert(mDetail->getPos3(offset))};
// Compute the closest surface point by linear interpolation.
const auto surfaceP = Sampler::sample(cptAcc, xform.worldToIndex(p));
// Translate the input point toward the surface.
p = surfaceP + mSpread * (p - surfaceP); // (1-spread)*surfaceP + spread*p
mDetail->setPos3(offset, p.x(), p.y(), p.z());
}
}
});
} else /*if (mPointType == PointType::kVDB)*/ {
// Translate VDB points toward the isosurface.
using LeafMgr = openvdb::tree::LeafManager<openvdb::points::PointDataTree>;
LeafMgr leafMgr(mVdbPoints->tree());
UTparallelForLightItems(leafMgr.leafRange(), [&](const LeafMgr::LeafRange& range) {
const auto cptAcc = cpt->getConstAccessor();
for (auto leafIter = range.begin(); leafIter; ++leafIter) {
if (mBoss && mBoss->wasInterrupted()) break;
// Get a handle to this leaf node's point position array.
auto& posArray = leafIter->attributeArray(mAttrIdx);
openvdb::points::AttributeWriteHandle<openvdb::Vec3f> posHandle(posArray);
// For each point in this leaf node...
for (auto idxIter = leafIter->beginIndexOn(); idxIter; ++idxIter) {
// The point position is in index space and is relative to
// the center of the voxel.
const auto idxCenter = idxIter.getCoord().asVec3d();
const auto idxP = posHandle.get(*idxIter) + idxCenter;
// Compute the closest surface point by linear interpolation.
const openvdb::Vec3f surfaceP(Sampler::sample(cptAcc, idxP));
// Translate the input point toward the surface.
auto p = xform.indexToWorld(idxP);
p = surfaceP + mSpread * (p - surfaceP); // (1-spread)*surfaceP + spread*p
// Transform back to index space relative to the voxel center.
posHandle.set(*idxIter, xform.worldToIndex(p) - idxCenter);
}
}
});
}
}
private:
PointType mPointType = PointType::kInvalid;
openvdb::points::PointDataGrid* mVdbPoints = nullptr; // VDB points to be processed
openvdb::Index64 mAttrIdx = openvdb::points::AttributeSet::INVALID_POS;
GEO_Detail* mDetail = nullptr; // the detail containing Houdini points to be processed
GA_Range mRange; // the range of points to be processed
float mSpread = 1; // if 0, place points on the isosurface; if 1, don't move them
float mIsovalue = 0;
bool mRebuild = false; // if true, generate a new SDF from the input grid
bool mDilate = false; // if true, dilate the isosurface mask
openvdb::BoolGrid::Ptr mMask; // an optional isosurface mask
hvdb::Interrupter* mBoss = nullptr;
}; // class SnapPointsOp
////////////////////////////////////////
struct BaseScatter
{
using NullCodec = openvdb::points::NullCodec;
using FixedCodec16 = openvdb::points::FixedPointCodec<false>;
using FixedCodec8 = openvdb::points::FixedPointCodec<true>;
using PositionArray = openvdb::points::TypedAttributeArray<openvdb::Vec3f, NullCodec>;
using PositionArray16 = openvdb::points::TypedAttributeArray<openvdb::Vec3f, FixedCodec16>;
using PositionArray8 = openvdb::points::TypedAttributeArray<openvdb::Vec3f, FixedCodec8>;
BaseScatter(const unsigned int seed,
const float spread,
hvdb::Interrupter* interrupter)
: mPoints()
, mSeed(seed)
, mSpread(spread)
, mInterrupter(interrupter) {}
virtual ~BaseScatter() {}
/// @brief Print information about the scattered points
/// @parm name A name to insert into the printed info
/// @parm os The output stream
virtual void print(const std::string &name, std::ostream& os = std::cout) const
{
if (!mPoints) return;
const openvdb::Index64 points = openvdb::points::pointCount(mPoints->tree());
const openvdb::Index64 voxels = mPoints->activeVoxelCount();
os << points << " points into " << voxels << " active voxels in \""
<< name << "\" corresponding to " << (double(points) / double(voxels))
<< " points per voxel." << std::endl;
}
inline openvdb::points::PointDataGrid::Ptr points()
{
UT_ASSERT(mPoints);
return mPoints;
}
protected:
openvdb::points::PointDataGrid::Ptr mPoints;
const unsigned int mSeed;
const float mSpread;
hvdb::Interrupter* mInterrupter;
}; // BaseScatter
struct VDBUniformScatter : public BaseScatter
{
VDBUniformScatter(const openvdb::Index64 count,
const unsigned int seed,
const float spread,
const int compression,
hvdb::Interrupter* interrupter)
: BaseScatter(seed, spread, interrupter)
, mCount(count)
, mCompression(compression)
{}
template <typename PositionT, typename GridT>
inline void resolveCompression(const GridT& grid)
{
using namespace openvdb::points;
using PointDataGridT =
openvdb::Grid<typename TreeConverter<typename GridT::TreeType>::Type>;
mPoints = openvdb::points::uniformPointScatter<
GridT, std::mt19937, PositionT, PointDataGridT, hvdb::Interrupter>(
grid, mCount, mSeed, mSpread, mInterrupter);
}
template <typename GridT>
inline void operator()(const GridT& grid)
{
if (mCompression == 1) {
this->resolveCompression<PositionArray16>(grid);
} else if (mCompression == 2) {
this->resolveCompression<PositionArray8>(grid);
} else {
this->resolveCompression<PositionArray>(grid);
}
}
void print(const std::string &name, std::ostream& os = std::cout) const override
{
os << "Uniformly scattered ";
BaseScatter::print(name, os);
}
const openvdb::Index64 mCount;
const int mCompression;
}; // VDBUniformScatter
struct VDBDenseUniformScatter : public BaseScatter
{
VDBDenseUniformScatter(const float pointsPerVoxel,
const unsigned int seed,
const float spread,
const int compression,
hvdb::Interrupter* interrupter)
: BaseScatter(seed, spread, interrupter)
, mPointsPerVoxel(pointsPerVoxel)
, mCompression(compression)
{}
template <typename PositionT, typename GridT>
inline void resolveCompression(const GridT& grid)
{
using namespace openvdb::points;
using PointDataGridT =
openvdb::Grid<typename TreeConverter<typename GridT::TreeType>::Type>;
mPoints = denseUniformPointScatter<GridT, std::mt19937, PositionT, PointDataGridT,
hvdb::Interrupter>(grid, mPointsPerVoxel, mSeed, mSpread, mInterrupter);
}
template <typename GridT>
inline void operator()(const GridT& grid)
{
if (mCompression == 1) {
this->resolveCompression<PositionArray16>(grid);
} else if (mCompression == 2) {
this->resolveCompression<PositionArray8>(grid);
} else {
this->resolveCompression<PositionArray>(grid);
}
}
void print(const std::string &name, std::ostream& os = std::cout) const override
{
os << "Dense uniformly scattered ";
BaseScatter::print(name, os);
}
const float mPointsPerVoxel;
const int mCompression;
}; // VDBDenseUniformScatter
struct VDBNonUniformScatter : public BaseScatter
{
VDBNonUniformScatter(const float pointsPerVoxel,
const unsigned int seed,
const float spread,
const int compression,
hvdb::Interrupter* interrupter)
: BaseScatter(seed, spread, interrupter)
, mPointsPerVoxel(pointsPerVoxel)
, mCompression(compression)
{}
template <typename PositionT, typename GridT>
inline void resolveCompression(const GridT& grid)
{
using namespace openvdb::points;
using PointDataGridT =
openvdb::Grid<typename TreeConverter<typename GridT::TreeType>::Type>;
mPoints = nonUniformPointScatter<GridT, std::mt19937, PositionT, PointDataGridT,
hvdb::Interrupter>(grid, mPointsPerVoxel, mSeed, mSpread, mInterrupter);
}
template <typename GridT>
inline void operator()(const GridT& grid)
{
if (mCompression == 1) {
this->resolveCompression<PositionArray16>(grid);
} else if (mCompression == 2) {
this->resolveCompression<PositionArray8>(grid);
} else {
this->resolveCompression<PositionArray>(grid);
}
}
void print(const std::string &name, std::ostream& os = std::cout) const override
{
os << "Non-uniformly scattered ";
BaseScatter::print(name, os);
}
const float mPointsPerVoxel;
const int mCompression;
}; // VDBNonUniformScatter
template <typename SurfaceGridT>
struct MarkPointsOutsideIso
{
using GroupIndex = openvdb::points::AttributeSet::Descriptor::GroupIndex;
using LeafManagerT = openvdb::tree::LeafManager<openvdb::points::PointDataTree>;
using PositionHandleT =
openvdb::points::AttributeHandle<openvdb::Vec3f, openvdb::points::NullCodec>;
using SurfaceValueT = typename SurfaceGridT::ValueType;
MarkPointsOutsideIso(const SurfaceGridT& grid,
const GroupIndex& deadIndex)
: mGrid(grid)
, mDeadIndex(deadIndex) {}
void operator()(const LeafManagerT::LeafRange& range) const {
openvdb::math::BoxStencil<const SurfaceGridT> stencil(mGrid);
for (auto leaf = range.begin(); leaf; ++leaf) {
PositionHandleT::Ptr positionHandle =
PositionHandleT::create(leaf->constAttributeArray(0));
openvdb::points::GroupWriteHandle deadHandle =
leaf->groupWriteHandle(mDeadIndex);
for (auto voxel = leaf->cbeginValueOn(); voxel; ++voxel) {
const openvdb::Coord& ijk = voxel.getCoord();
const openvdb::Vec3d vec = ijk.asVec3d();
for (auto iter = leaf->beginIndexVoxel(ijk); iter; ++iter) {
const openvdb::Index index = *iter;
const openvdb::Vec3d pos = openvdb::Vec3d(positionHandle->get(index)) + vec;
stencil.moveTo(pos);
if (stencil.interpolation(pos) > openvdb::zeroVal<SurfaceValueT>()) {
deadHandle.set(index, true);
}
}
}
}
}
private:
const SurfaceGridT& mGrid;
const GroupIndex& mDeadIndex;
}; // MarkPointsOutsideIso
template<typename OpType>
inline bool
process(const UT_VDBType type, const openvdb::GridBase& grid, OpType& op, const std::string* name)
{
bool success = grid.apply<hvdb::AllGridTypes>(op);
if (name) op.print(*name);
return success;
}
// Extract an SDF interior mask in which to scatter points.
inline openvdb::BoolGrid::Ptr
extractInteriorMask(const openvdb::GridBase::ConstPtr grid, const float isovalue)
{
if (grid->isType<openvdb::FloatGrid>()) {
return openvdb::tools::sdfInteriorMask(
static_cast<const openvdb::FloatGrid&>(*grid), isovalue);
} else if (grid->isType<openvdb::DoubleGrid>()) {
return openvdb::tools::sdfInteriorMask(
static_cast<const openvdb::DoubleGrid&>(*grid), isovalue);
}
return nullptr;
}
// Extract an SDF isosurface mask in which to scatter points.
inline openvdb::BoolGrid::Ptr
extractIsosurfaceMask(const openvdb::GridBase::ConstPtr grid, const float isovalue)
{
if (grid->isType<openvdb::FloatGrid>()) {
return openvdb::tools::extractIsosurfaceMask(
static_cast<const openvdb::FloatGrid&>(*grid), isovalue);
} else if (grid->isType<openvdb::DoubleGrid>()) {
return openvdb::tools::extractIsosurfaceMask(
static_cast<const openvdb::DoubleGrid&>(*grid), double(isovalue));
}
return nullptr;
}
// Remove VDB Points scattered outside of a level set
inline void
cullVDBPoints(openvdb::points::PointDataTree& tree,
const openvdb::GridBase::ConstPtr grid)
{
const auto leaf = tree.cbeginLeaf();
if (leaf) {
using GroupIndex = openvdb::points::AttributeSet::Descriptor::GroupIndex;
openvdb::points::appendGroup(tree, "dead");
const GroupIndex idx = leaf->attributeSet().groupIndex("dead");
openvdb::tree::LeafManager<openvdb::points::PointDataTree>
leafManager(tree);
if (grid->isType<openvdb::FloatGrid>()) {
const openvdb::FloatGrid& typedGrid =
static_cast<const openvdb::FloatGrid&>(*grid);
MarkPointsOutsideIso<openvdb::FloatGrid> mark(typedGrid, idx);
tbb::parallel_for(leafManager.leafRange(), mark);
}
else if (grid->isType<openvdb::DoubleGrid>()) {
const openvdb::DoubleGrid& typedGrid =
static_cast<const openvdb::DoubleGrid&>(*grid);
MarkPointsOutsideIso<openvdb::DoubleGrid> mark(typedGrid, idx);
tbb::parallel_for(leafManager.leafRange(), mark);
}
openvdb::points::deleteFromGroup(tree, "dead");
}
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Scatter::Cache::cookVDBSop(OP_Context& context)
{
try {
hvdb::Interrupter boss("Scattering points on VDBs");
const fpreal time = context.getTime();
const bool keepGrids = (0 != evalInt("keep", 0, time));
const auto* vdbgeo = inputGeo(0);
if (keepGrids && vdbgeo) {
gdp->replaceWith(*vdbgeo);
} else {
gdp->stashAll();
}
const int seed = static_cast<int>(evalInt("seed", 0, time));
const auto theSpread = static_cast<float>(evalFloat("spread", 0, time));
const bool verbose = evalInt("verbose", 0, time) != 0;
const openvdb::Index64 pointCount = evalInt("count", 0, time);
const float ptsPerVox = static_cast<float>(evalFloat("ppv", 0, time));
const auto sdfdomain = evalStdString("sdfdomain", time);
const float density = static_cast<float>(evalFloat("density", 0, time));
const bool multiplyDensity = evalInt("multiply", 0, time) != 0;
const auto theIsovalue = static_cast<float>(evalFloat("isovalue", 0, time));
const int outputName = static_cast<int>(evalInt("outputname", 0, time));
const std::string customName = evalStdString("customname", time);
// Get the group of grids to process.
const GA_PrimitiveGroup* group = matchGroup(*vdbgeo, evalStdString("group", time));
// Choose a fast random generator with a long period. Drawback here for
// mt11213b is that it requires 352*sizeof(uint32) bytes.
using RandGen = std::mersenne_twister_engine<uint32_t, 32, 351, 175, 19,
0xccab8ee7, 11, 0xffffffff, 7, 0x31b6ab00, 15, 0xffe50000, 17, 1812433253>; // mt11213b
RandGen mtRand(seed);
const auto pmode = evalInt("pointmode", 0, time);
const bool vdbPoints = evalInt("vdbpoints", 0, time) == 1;
const bool clipPoints = vdbPoints && bool(evalInt("cliptoisosurface", 0, time));
const int posCompression = vdbPoints ?
static_cast<int>(evalInt("poscompression", 0, time)) : 0;
const bool snapPointsToSurface =
((sdfdomain == "surface") && !openvdb::math::isApproxEqual(theSpread, 1.0f));
// If the domain is the isosurface, set the spread to 1 while generating points
// so that each point ends up snapping to a unique point on the surface.
const float spread = (snapPointsToSurface ? 1.f : theSpread);
std::vector<std::string> emptyGrids;
std::vector<openvdb::points::PointDataGrid::Ptr> pointGrids;
PointAccessor pointAccessor(gdp);
const GA_Offset firstOffset = gdp->getNumPointOffsets();
// Process each VDB primitive (with a non-null grid pointer)
// that belongs to the selected group.
for (hvdb::VdbPrimCIterator primIter(vdbgeo, group); primIter; ++primIter) {
// Retrieve a read-only grid pointer.
UT_VDBType gridType = primIter->getStorageType();
openvdb::GridBase::ConstPtr grid = primIter->getConstGridPtr();
const std::string gridName = primIter.getPrimitiveName().toStdString();
if (grid->empty()) {
emptyGrids.push_back(gridName);
continue;
}
const std::string* const name = verbose ? &gridName : nullptr;
const openvdb::GridClass gridClass = grid->getGridClass();
const bool isSignedDistance = (gridClass == openvdb::GRID_LEVEL_SET);
bool performCull = false;
const auto isovalue = (gridClass != openvdb::GRID_FOG_VOLUME) ? theIsovalue
: openvdb::math::Clamp(theIsovalue, openvdb::math::Tolerance<float>::value(), 1.f);
openvdb::BoolGrid::Ptr mask;
if (sdfdomain != "band") {
auto iso = isovalue;
if (clipPoints) {
const openvdb::Vec3d voxelSize = grid->voxelSize();
const double maxVoxelSize =
openvdb::math::Max(voxelSize.x(), voxelSize.y(), voxelSize.z());
iso += static_cast<float>(maxVoxelSize / 2.0);
performCull = true;
}
if (sdfdomain == "interior") {
if (isSignedDistance) {
// If the input is an SDF, compute a mask of its interior.
// (Fog volumes are their own interior masks.)
mask = extractInteriorMask(grid, iso);
}
} else if (sdfdomain == "surface") {
mask = extractIsosurfaceMask(grid, iso);
}
if (mask) {
grid = mask;
gridType = UT_VDB_BOOL;
}
}
std::string vdbName;
if (vdbPoints) {
if (outputName == 0) vdbName = gridName;
else if (outputName == 1) vdbName = gridName + customName;
else vdbName = customName;
}
openvdb::points::PointDataGrid::Ptr pointGrid;
const auto postprocessVDBPoints = [&](BaseScatter& scatter, bool cull) {
pointGrid = scatter.points();
if (cull) { cullVDBPoints(pointGrid->tree(), primIter->getConstGridPtr()); }
pointGrid->setName(vdbName);
pointGrids.push_back(pointGrid);
if (verbose) scatter.print(gridName);
};
using DenseScatterer = openvdb::tools::DenseUniformPointScatter<
PointAccessor, RandGen, hvdb::Interrupter>;
using NonuniformScatterer = openvdb::tools::NonUniformPointScatter<
PointAccessor, RandGen, hvdb::Interrupter>;
using UniformScatterer = openvdb::tools::UniformPointScatter<
PointAccessor, RandGen, hvdb::Interrupter>;
const GA_Offset startOffset = gdp->getNumPointOffsets();
switch (pmode) {
case 0: // fixed point count
if (vdbPoints) { // VDB points
VDBUniformScatter scatter(pointCount, seed, spread, posCompression, &boss);
if (process(gridType, *grid, scatter, name)) {
postprocessVDBPoints(scatter, performCull);
}
} else { // Houdini points
UniformScatterer scatter(pointAccessor, pointCount, mtRand, spread, &boss);
process(gridType, *grid, scatter, name);
}
break;
case 1: // points per unit volume
if (multiplyDensity && !isSignedDistance) { // local density
if (vdbPoints) { // VDB points
const auto dim = grid->transform().voxelSize();
VDBNonUniformScatter scatter(static_cast<float>(density * dim.product()),
seed, spread, posCompression, &boss);
if (!grid->apply<hvdb::NumericGridTypes>(scatter)) {
throw std::runtime_error(
"Only scalar grids support voxel scaling of density");
}
postprocessVDBPoints(scatter, /*cull=*/false);
} else { // Houdini points
NonuniformScatterer scatter(pointAccessor, density, mtRand, spread, &boss);
if (!grid->apply<hvdb::NumericGridTypes>(scatter)) {
throw std::runtime_error(
"Only scalar grids support voxel scaling of density");
}
if (verbose) scatter.print(gridName);
}
} else { // global density
if (vdbPoints) { // VDB points
const auto dim = grid->transform().voxelSize();
const auto totalPointCount = openvdb::Index64(
density * dim.product() * double(grid->activeVoxelCount()));
VDBUniformScatter scatter(
totalPointCount, seed, spread, posCompression, &boss);
if (process(gridType, *grid, scatter, name)) {
postprocessVDBPoints(scatter, performCull);
}
} else { // Houdini points
UniformScatterer scatter(pointAccessor, density, mtRand, spread, &boss);
process(gridType, *grid, scatter, name);
}
}
break;
case 2: // points per voxel
if (vdbPoints) { // VDB points
VDBDenseUniformScatter scatter(
ptsPerVox, seed, spread, posCompression, &boss);
if (process(gridType, *grid, scatter, name)) {
postprocessVDBPoints(scatter, performCull);
}
} else { // Houdini points
DenseScatterer scatter(pointAccessor, ptsPerVox, mtRand, spread, &boss);
process(gridType, *grid, scatter, name);
}
break;
default:
throw std::runtime_error(
"Expected 0, 1 or 2 for \"pointmode\", got " + std::to_string(pmode));
} // switch pmode
if (snapPointsToSurface) {
// Dilate the mask if it is a single-voxel-wide isosurface mask.
const bool dilate = (mask && (sdfdomain == "surface"));
// Generate a new SDF if the input is a fog volume or if the isovalue is nonzero.
const bool rebuild = (!isSignedDistance || !openvdb::math::isApproxZero(isovalue));
if (!vdbPoints) {
const GA_Range range(gdp->getPointMap(),startOffset,gdp->getNumPointOffsets());
// Use the original spread value to control how close to the surface points lie.
SnapPointsOp op{*gdp, range, theSpread, isovalue, rebuild, dilate, mask, &boss};
hvdb::GEOvdbApply<hvdb::RealGridTypes>(**primIter, op); // process the original input grid
} else if (vdbPoints && pointGrid) {
SnapPointsOp op{*pointGrid, theSpread, isovalue, rebuild, dilate, mask, &boss};
hvdb::GEOvdbApply<hvdb::RealGridTypes>(**primIter, op);
}
}
} // for each grid
if (!emptyGrids.empty()) {
std::string s = "The following grids were empty: "
+ hboost::algorithm::join(emptyGrids, ", ");
addWarning(SOP_MESSAGE, s.c_str());
}
// add points to a group if requested
if (1 == evalInt("dogroup", 0, time)) {
const std::string groupName = evalStdString("sgroup", time);
GA_PointGroup* ptgroup = gdp->newPointGroup(groupName.c_str());
// add the scattered points to this group
const GA_Offset lastOffset = gdp->getNumPointOffsets();
ptgroup->addRange(GA_Range(gdp->getPointMap(), firstOffset, lastOffset));
for (auto& pointGrid: pointGrids) {
openvdb::points::appendGroup(pointGrid->tree(), groupName);
openvdb::points::setGroup(pointGrid->tree(), groupName);
}
}
for (auto& pointGrid: pointGrids) {
hvdb::createVdbPrimitive(*gdp, pointGrid, pointGrid->getName().c_str());
}
}
catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 43,299 | C++ | 39.810556 | 138 | 0.599621 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/pythonrc.py | # Copyright Contributors to the OpenVDB Project
# SPDX-License-Identifier: MPL-2.0
# Startup script to set the visibility of (and otherwise customize)
# open-source (ASWF) OpenVDB nodes and their native Houdini equivalents
#
# To be installed as <dir>/python2.7libs/pythonrc.py,
# where <dir> is a path in $HOUDINI_PATH.
import hou
import os
# Construct a mapping from ASWF SOP names to names of equivalent
# native Houdini SOPs.
sopcategory = hou.sopNodeTypeCategory()
namemap = {}
for name, sop in sopcategory.nodeTypes().items():
try:
nativename = sop.spareData('nativename')
if nativename:
namemap[name] = nativename
except AttributeError:
pass
# Print the list of correspondences.
#from pprint import pprint
#pprint(namemap)
# Determine which VDB SOPs should be visible in the Tab menu:
# - If $OPENVDB_OPHIDE_POLICY is set to 'aswf', hide AWSF SOPs for which
# a native Houdini equivalent exists.
# - If $OPENVDB_OPHIDE_POLICY is set to 'native', hide native Houdini SOPs
# for which an ASWF equivalent exists.
# - Otherwise, show both the ASWF and the native SOPs.
names = []
ophide = os.getenv('OPENVDB_OPHIDE_POLICY', 'none').strip().lower()
if ophide == 'aswf':
names = namemap.keys()
elif ophide == 'native':
names = namemap.values()
for name in names:
sop = sopcategory.nodeType(name)
if sop:
sop.setHidden(True)
# Customize SOP visibility with code like the following:
#
# # Hide the ASWF Clip SOP.
# sopcategory.nodeType('DW_OpenVDBClip').setHidden(True)
#
# # Show the native VDB Clip SOP.
# sopcategory.nodeType('vdbclip').setHidden(False)
#
# # Hide all ASWF advection SOPs for which a native equivalent exists.
# for name in namemap.keys():
# if 'Advect' in name:
# sopcategory.nodeType(name).setHidden(True)
| 1,853 | Python | 28.903225 | 74 | 0.697248 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Filter_Level_Set.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file SOP_OpenVDB_Filter_Level_Set.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Performs various types of level set deformations with
/// interface tracking. These unrestricted deformations include
/// surface smoothing (e.g., Laplacian flow), filtering (e.g., mean
/// value) and morphological operations (e.g., morphological opening).
/// All these operations can optionally be masked with another grid that
/// acts as an alpha-mask.
///
/// @note Works with level set grids of floating point type (float/double).
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/LevelSetFilter.h>
#include <OP/OP_AutoLockInputs.h>
#include <UT/UT_Interrupt.h>
#include <hboost/algorithm/string/case_conv.hpp>
#include <hboost/algorithm/string/trim.hpp>
#include <algorithm>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
#undef DWA_DEBUG_MODE
//#define DWA_DEBUG_MODE
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
// Utilities
namespace {
// Add new items to the *end* of this list, and update NUM_OPERATOR_TYPES.
enum OperatorType {
OP_TYPE_RENORM = 0,
OP_TYPE_RESHAPE,
OP_TYPE_SMOOTH,
OP_TYPE_RESIZE
};
enum { NUM_OPERATOR_TYPES = OP_TYPE_RESIZE + 1 };
// Add new items to the *end* of this list, and update NUM_FILTER_TYPES.
enum FilterType {
FILTER_TYPE_NONE = -1,
FILTER_TYPE_RENORMALIZE = 0,
FILTER_TYPE_MEAN_VALUE,
FILTER_TYPE_MEDIAN_VALUE,
FILTER_TYPE_MEAN_CURVATURE,
FILTER_TYPE_LAPLACIAN_FLOW,
FILTER_TYPE_DILATE,
FILTER_TYPE_ERODE,
FILTER_TYPE_OPEN,
FILTER_TYPE_CLOSE,
FILTER_TYPE_TRACK,
FILTER_TYPE_GAUSSIAN,
FILTER_TYPE_RESIZE
};
enum { NUM_FILTER_TYPES = FILTER_TYPE_RESIZE + 1 };
std::string
filterTypeToString(FilterType filter)
{
std::string ret;
switch (filter) {
case FILTER_TYPE_NONE: ret = "none"; break;
case FILTER_TYPE_RENORMALIZE: ret = "renormalize"; break;
case FILTER_TYPE_RESIZE: ret = "resize narrow band"; break;
case FILTER_TYPE_GAUSSIAN: ret = "gaussian"; break;
case FILTER_TYPE_DILATE: ret = "dilate"; break;
case FILTER_TYPE_ERODE: ret = "erode"; break;
case FILTER_TYPE_OPEN: ret = "open"; break;
case FILTER_TYPE_CLOSE: ret = "close"; break;
case FILTER_TYPE_TRACK: ret = "track"; break;
#ifndef SESI_OPENVDB
case FILTER_TYPE_MEAN_VALUE: ret = "mean value"; break;
case FILTER_TYPE_MEDIAN_VALUE: ret = "median value"; break;
case FILTER_TYPE_MEAN_CURVATURE: ret = "mean curvature"; break;
case FILTER_TYPE_LAPLACIAN_FLOW: ret = "laplacian flow"; break;
#else
case FILTER_TYPE_MEAN_VALUE: ret = "meanvalue"; break;
case FILTER_TYPE_MEDIAN_VALUE: ret = "medianvalue"; break;
case FILTER_TYPE_MEAN_CURVATURE: ret = "meancurvature"; break;
case FILTER_TYPE_LAPLACIAN_FLOW: ret = "laplacianflow"; break;
#endif
}
return ret;
}
std::string
filterTypeToMenuName(FilterType filter)
{
std::string ret;
switch (filter) {
case FILTER_TYPE_NONE: ret = "None"; break;
case FILTER_TYPE_RENORMALIZE: ret = "Renormalize"; break;
case FILTER_TYPE_RESIZE: ret = "Resize Narrow Band"; break;
case FILTER_TYPE_MEAN_VALUE: ret = "Mean Value"; break;
case FILTER_TYPE_GAUSSIAN: ret = "Gaussian"; break;
case FILTER_TYPE_MEDIAN_VALUE: ret = "Median Value"; break;
case FILTER_TYPE_MEAN_CURVATURE: ret = "Mean Curvature Flow"; break;
case FILTER_TYPE_LAPLACIAN_FLOW: ret = "Laplacian Flow"; break;
case FILTER_TYPE_DILATE: ret = "Dilate"; break;
case FILTER_TYPE_ERODE: ret = "Erode"; break;
case FILTER_TYPE_OPEN: ret = "Open"; break;
case FILTER_TYPE_CLOSE: ret = "Close"; break;
case FILTER_TYPE_TRACK: ret = "Track Narrow Band"; break;
}
return ret;
}
FilterType
stringToFilterType(const std::string& s)
{
FilterType ret = FILTER_TYPE_NONE;
std::string str = s;
hboost::trim(str);
hboost::to_lower(str);
if (str == filterTypeToString(FILTER_TYPE_RENORMALIZE)) {
ret = FILTER_TYPE_RENORMALIZE;
} else if (str == filterTypeToString(FILTER_TYPE_RESIZE)) {
ret = FILTER_TYPE_RESIZE;
} else if (str == filterTypeToString(FILTER_TYPE_MEAN_VALUE)) {
ret = FILTER_TYPE_MEAN_VALUE;
} else if (str == filterTypeToString(FILTER_TYPE_GAUSSIAN)) {
ret = FILTER_TYPE_GAUSSIAN;
} else if (str == filterTypeToString(FILTER_TYPE_MEDIAN_VALUE)) {
ret = FILTER_TYPE_MEDIAN_VALUE;
} else if (str == filterTypeToString(FILTER_TYPE_MEAN_CURVATURE)) {
ret = FILTER_TYPE_MEAN_CURVATURE;
} else if (str == filterTypeToString(FILTER_TYPE_LAPLACIAN_FLOW)) {
ret = FILTER_TYPE_LAPLACIAN_FLOW;
} else if (str == filterTypeToString(FILTER_TYPE_DILATE)) {
ret = FILTER_TYPE_DILATE;
} else if (str == filterTypeToString(FILTER_TYPE_ERODE)) {
ret = FILTER_TYPE_ERODE;
} else if (str == filterTypeToString(FILTER_TYPE_OPEN)) {
ret = FILTER_TYPE_OPEN;
} else if (str == filterTypeToString(FILTER_TYPE_CLOSE)) {
ret = FILTER_TYPE_CLOSE;
} else if (str == filterTypeToString(FILTER_TYPE_TRACK)) {
ret = FILTER_TYPE_TRACK;
}
return ret;
}
// Add new items to the *end* of this list, and update NUM_ACCURACY_TYPES.
enum Accuracy {
ACCURACY_UPWIND_FIRST = 0,
ACCURACY_UPWIND_SECOND,
ACCURACY_UPWIND_THIRD,
ACCURACY_WENO,
ACCURACY_HJ_WENO
};
enum { NUM_ACCURACY_TYPES = ACCURACY_HJ_WENO + 1 };
std::string
accuracyToString(Accuracy ac)
{
std::string ret;
switch (ac) {
case ACCURACY_UPWIND_FIRST: ret = "upwind first"; break;
case ACCURACY_UPWIND_SECOND: ret = "upwind second"; break;
case ACCURACY_UPWIND_THIRD: ret = "upwind third"; break;
case ACCURACY_WENO: ret = "weno"; break;
case ACCURACY_HJ_WENO: ret = "hj weno"; break;
}
return ret;
}
std::string
accuracyToMenuName(Accuracy ac)
{
std::string ret;
switch (ac) {
case ACCURACY_UPWIND_FIRST: ret = "First-order upwinding"; break;
case ACCURACY_UPWIND_SECOND: ret = "Second-order upwinding"; break;
case ACCURACY_UPWIND_THIRD: ret = "Third-order upwinding"; break;
case ACCURACY_WENO: ret = "Fifth-order WENO"; break;
case ACCURACY_HJ_WENO: ret = "Fifth-order HJ-WENO"; break;
}
return ret;
}
Accuracy
stringToAccuracy(const std::string& s)
{
Accuracy ret = ACCURACY_UPWIND_FIRST;
std::string str = s;
hboost::trim(str);
hboost::to_lower(str);
if (str == accuracyToString(ACCURACY_UPWIND_SECOND)) {
ret = ACCURACY_UPWIND_SECOND;
} else if (str == accuracyToString(ACCURACY_UPWIND_THIRD)) {
ret = ACCURACY_UPWIND_THIRD;
} else if (str == accuracyToString(ACCURACY_WENO)) {
ret = ACCURACY_WENO;
} else if (str == accuracyToString(ACCURACY_HJ_WENO)) {
ret = ACCURACY_HJ_WENO;
}
return ret;
}
void
buildFilterMenu(std::vector<std::string>& items, OperatorType op)
{
items.clear();
if (OP_TYPE_SMOOTH == op) {
items.push_back(filterTypeToString(FILTER_TYPE_MEAN_VALUE));
items.push_back(filterTypeToMenuName(FILTER_TYPE_MEAN_VALUE));
items.push_back(filterTypeToString(FILTER_TYPE_GAUSSIAN));
items.push_back(filterTypeToMenuName(FILTER_TYPE_GAUSSIAN));
items.push_back(filterTypeToString(FILTER_TYPE_MEDIAN_VALUE));
items.push_back(filterTypeToMenuName(FILTER_TYPE_MEDIAN_VALUE));
items.push_back(filterTypeToString(FILTER_TYPE_MEAN_CURVATURE));
items.push_back(filterTypeToMenuName(FILTER_TYPE_MEAN_CURVATURE));
items.push_back(filterTypeToString(FILTER_TYPE_LAPLACIAN_FLOW));
items.push_back(filterTypeToMenuName(FILTER_TYPE_LAPLACIAN_FLOW));
} else if (OP_TYPE_RESHAPE == op) {
items.push_back(filterTypeToString(FILTER_TYPE_DILATE));
items.push_back(filterTypeToMenuName(FILTER_TYPE_DILATE));
items.push_back(filterTypeToString(FILTER_TYPE_ERODE));
items.push_back(filterTypeToMenuName(FILTER_TYPE_ERODE));
items.push_back(filterTypeToString(FILTER_TYPE_OPEN));
items.push_back(filterTypeToMenuName(FILTER_TYPE_OPEN));
items.push_back(filterTypeToString(FILTER_TYPE_CLOSE));
items.push_back(filterTypeToMenuName(FILTER_TYPE_CLOSE));
#ifdef DWA_DEBUG_MODE
items.push_back(filterTypeToString(FILTER_TYPE_TRACK));
items.push_back(filterTypeToMenuName(FILTER_TYPE_TRACK));
#endif
}
}
struct FilterParms
{
using TrimMode = openvdb::tools::lstrack::TrimMode;
std::string mGroup;
std::string mMaskName;
bool mSecondInputConnected = false;
FilterType mFilterType = FILTER_TYPE_NONE;
int mIterations = 0;
int mHalfWidth = 3;
int mStencilWidth = 0;
float mVoxelOffset = 0.0f;
float mHalfWidthWorld = 0.1f;
float mStencilWidthWorld = 0.1f;
bool mWorldUnits = false;
float mMinMask = 0;
float mMaxMask = 1;
bool mInvertMask = false;
Accuracy mAccuracy = ACCURACY_UPWIND_FIRST;
TrimMode mTrimMode = TrimMode::kAll;
bool mMaskInputNode = false;
};
} // namespace
////////////////////////////////////////
// SOP Declaration
class SOP_OpenVDB_Filter_Level_Set: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Filter_Level_Set(OP_Network*, const char* name, OP_Operator*, OperatorType);
~SOP_OpenVDB_Filter_Level_Set() override {}
static OP_Node* factoryRenormalize(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factorySmooth(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factoryReshape(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factoryNarrowBand(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned input) const override { return (input == 1); }
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
public:
class Cache: public SOP_VDBCacheOptions
{
public:
Cache(OperatorType op): mOpType{op} {}
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
private:
using BossT = hvdb::Interrupter;
OP_ERROR evalFilterParms(OP_Context&, FilterParms&);
template<typename GridT>
bool applyFilters(GU_PrimVDB*, std::vector<FilterParms>&, BossT&,
OP_Context&, GU_Detail&, bool verbose);
template<typename FilterT>
void filterGrid(OP_Context&, FilterT&, const FilterParms&, BossT&, bool verbose);
template<typename FilterT>
void offset(const FilterParms&, FilterT&, const float offset, bool verbose,
const typename FilterT::MaskType* mask = nullptr);
template<typename FilterT>
void mean(const FilterParms&, FilterT&, BossT&, bool verbose,
const typename FilterT::MaskType* mask = nullptr);
template<typename FilterT>
void gaussian(const FilterParms&, FilterT&, BossT&, bool verbose,
const typename FilterT::MaskType* mask = nullptr);
template<typename FilterT>
void median(const FilterParms&, FilterT&, BossT&, bool verbose,
const typename FilterT::MaskType* mask = nullptr);
template<typename FilterT>
void meanCurvature(const FilterParms&, FilterT&, BossT&, bool verbose,
const typename FilterT::MaskType* mask = nullptr);
template<typename FilterT>
void laplacian(const FilterParms&, FilterT&, BossT&, bool verbose,
const typename FilterT::MaskType* mask = nullptr);
template<typename FilterT>
void renormalize(const FilterParms&, FilterT&, BossT&, bool verbose = false);
template<typename FilterT>
void resizeNarrowBand(const FilterParms&, FilterT&, BossT&, bool verbose = false);
template<typename FilterT>
void track(const FilterParms&, FilterT&, BossT&, bool verbose);
private:
const OperatorType mOpType;
};
private:
const OperatorType mOpType;
};//SOP_OpenVDB_Filter_Level_Set
////////////////////////////////////////
// Build UI
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
for (int n = 0; n < NUM_OPERATOR_TYPES; ++n) {
OperatorType op = OperatorType(n);
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to be processed.")
.setDocumentation(
"A subset of the input VDBs to be processed"
" (see [specifying volumes|/model/volumes#group])"));
if (OP_TYPE_RENORM != op && OP_TYPE_RESIZE != op) { // Filter menu
parms.add(hutil::ParmFactory(PRM_TOGGLE, "mask", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("Enable / disable the mask."));
parms.add(hutil::ParmFactory(PRM_STRING, "maskname", "Alpha Mask")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("Optional VDB used for alpha masking. Assumes values 0->1.")
.setDocumentation(
"If enabled, operate on the input VDBs using the given VDB"
" from the second input as an alpha mask.\n\n"
"The mask VDB is assumed to be scalar, with values between zero and one."
" Where the mask is zero, no processing occurs. Where the mask is one,"
" the operation is applied at full strength. For intermediate mask values,"
" the strength varies linearly."));
std::vector<std::string> items;
buildFilterMenu(items, op);
parms.add(hutil::ParmFactory(PRM_STRING, "operation", "Operation")
.setDefault(items[0])
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip("The operation to be applied"));
}
parms.add(hutil::ParmFactory(PRM_TOGGLE, "useworldspaceunits", "Use World Space Units")
.setTooltip("If enabled, use world-space units, otherwise use voxels."));
parms.add(hutil::ParmFactory(PRM_INT_J, "radius", "Filter Voxel Radius")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 5)
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_FLT_J, "radiusworld", "Filter Radius")
.setDefault(0.1)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 10)
.setDocumentation("The desired radius of the filter"));
parms.add(hutil::ParmFactory(PRM_INT_J, "iterations", "Iterations")
.setDefault(PRMfourDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10)
.setTooltip("The number of times to apply the operation"));
parms.add(hutil::ParmFactory(PRM_INT_J, "halfwidth", "Half Width")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip(
"Half the width of the narrow band, in voxels\n\n"
"(Many level set operations require this to be a minimum of three voxels.)"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "halfwidthworld", "Half Width")
.setDefault(0.1)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 10)
.setTooltip("Half the width of the narrow band, in world units")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxeloffset", "Offset")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_UI, 10.0)
.setTooltip(
"The distance in voxels by which to offset the level set surface"
" along its normals"));
{
std::vector<std::string> items;
for (int i = 0; i < NUM_ACCURACY_TYPES; ++i) {
Accuracy ac = Accuracy(i);
#ifndef DWA_DEBUG_MODE // Exclude some of the menu options
if (ac == ACCURACY_UPWIND_THIRD || ac == ACCURACY_WENO) continue;
#endif
items.push_back(accuracyToString(ac)); // token
items.push_back(accuracyToMenuName(ac)); // label
}
parms.add(hutil::ParmFactory(PRM_STRING, "accuracy", "Renorm Accuracy")
.setDefault(items[0])
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items));
}
parms.add(hutil::ParmFactory(PRM_TOGGLE, "invert", "Invert Alpha Mask")
.setTooltip("Invert the optional alpha mask, mapping 0 to 1 and 1 to 0."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "minmask", "Min Mask Cutoff")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_UI, 0.0, PRM_RANGE_UI, 1.0)
.setTooltip("Threshold below which voxel values in the mask map to zero"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "maxmask", "Max Mask Cutoff")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_UI, 0.0, PRM_RANGE_UI, 1.0)
.setTooltip("Threshold above which voxel values in the mask map to one"));
parms.add(hutil::ParmFactory(PRM_STRING, "trim", "Trim")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"none", "None",
"interior", "Interior",
"exterior", "Exterior",
"all", "All",
})
.setDefault("all")
.setTooltip("Set voxels that lie outside the narrow band to the background value.")
.setDocumentation(
"Optionally set interior, exterior, or all voxels that lie outside"
" the narrow band to the background value.\n\n"
"Trimming reduces memory usage, but it also reduces dense SDFs\n"
"to narrow-band level sets."));
#ifndef SESI_OPENVDB
parms.add(hutil::ParmFactory(PRM_TOGGLE, "verbose", "Verbose")
.setTooltip("If enabled, print the sequence of operations to the terminal."));
#endif
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep1", "Sep"));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep2", "Sep"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "worldSpaceUnits", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "stencilWidth", "Filter Voxel Radius")
.setDefault(PRMoneDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "stencilWidthWorld", "").setDefault(0.1));
obsoleteParms.add(hutil::ParmFactory(PRM_INT_J, "halfWidth", "Half-Width")
.setDefault(PRMthreeDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "halfWidthWorld", "").setDefault(0.1));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "voxelOffset", "Offset")
.setDefault(PRMoneDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "minMask", "").setDefault(PRMzeroDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "maxMask", "").setDefault(PRMoneDefaults));
auto cacheAllocator = [op]() { return new SOP_OpenVDB_Filter_Level_Set::Cache{op}; };
// Register operator
if (OP_TYPE_RENORM == op) {
hvdb::OpenVDBOpFactory("VDB Renormalize SDF",
SOP_OpenVDB_Filter_Level_Set::factoryRenormalize, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBRenormalizeLevelSet")
#endif
.setObsoleteParms(obsoleteParms)
.addInput("Input with VDB grids to process")
.setVerb(SOP_NodeVerb::COOK_INPLACE, cacheAllocator)
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Repair level sets represented by VDB volumes.\"\"\"\n\
\n\
@overview\n\
\n\
Certain operations on a level set volume can cause the signed distances\n\
to its zero crossing to become invalid.\n\
This node iteratively adjusts voxel values to restore proper distances.\n\
\n\
NOTE:\n\
If the level set departs significantly from a proper signed distance field,\n\
it might be necessary to rebuild it completely.\n\
That can be done with the\
[OpenVDB Rebuild Level Set node|Node:sop/DW_OpenVDBRebuildLevelSet],\n\
which converts an input level set to polygons and then back to a level set.\n\
\n\
@related\n\
- [OpenVDB Offset Level Set|Node:sop/DW_OpenVDBOffsetLevelSet]\n\
- [OpenVDB Rebuild Level Set|Node:sop/DW_OpenVDBRebuildLevelSet]\n\
- [OpenVDB Smooth Level Set|Node:sop/DW_OpenVDBSmoothLevelSet]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
} else if (OP_TYPE_RESHAPE == op) {
hvdb::OpenVDBOpFactory("VDB Reshape SDF",
SOP_OpenVDB_Filter_Level_Set::factoryReshape, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBOffsetLevelSet")
#endif
.setObsoleteParms(obsoleteParms)
.addInput("Input with VDBs to process")
.addOptionalInput("Optional VDB Alpha Mask")
.setVerb(SOP_NodeVerb::COOK_INPLACE, cacheAllocator)
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Offset level sets represented by VDB volumes.\"\"\"\n\
\n\
@overview\n\
\n\
This node changes the shape of a level set by moving the surface in or out\n\
along its normals.\n\
Unlike just adding an offset to a signed distance field, this node properly\n\
updates the active voxels to account for the transformation.\n\
\n\
@related\n\
- [OpenVDB Renormalize Level Set|Node:sop/DW_OpenVDBRenormalizeLevelSet]\n\
- [OpenVDB Smooth Level Set|Node:sop/DW_OpenVDBSmoothLevelSet]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
} else if (OP_TYPE_SMOOTH == op) {
hvdb::OpenVDBOpFactory("VDB Smooth SDF",
SOP_OpenVDB_Filter_Level_Set::factorySmooth, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBSmoothLevelSet")
#endif
.setObsoleteParms(obsoleteParms)
.addInput("Input with VDBs to process")
.addOptionalInput("Optional VDB Alpha Mask")
.setVerb(SOP_NodeVerb::COOK_INPLACE, cacheAllocator)
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Smooth the surface of a level set represented by a VDB volume.\"\"\"\n\
\n\
@overview\n\
\n\
This node applies a simulated flow operation, moving the surface of a\n\
signed distance field according to some local property.\n\
\n\
For example, if you move along the normal by an amount dependent on the curvature,\n\
you will flatten out dimples and hills and leave flat areas unchanged.\n\
\n\
Unlike the [OpenVDB Filter|Node:sop/DW_OpenVDBFilter] node,\n\
this node ensures that the level set remains a valid signed distance field.\n\
\n\
@related\n\
- [OpenVDB Filter|Node:sop/DW_OpenVDBFilter]\n\
- [OpenVDB Offset Level Set|Node:sop/DW_OpenVDBOffsetLevelSet]\n\
- [OpenVDB Renormalize Level Set|Node:sop/DW_OpenVDBRenormalizeLevelSet]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
} else if (OP_TYPE_RESIZE == op) {
hvdb::OpenVDBOpFactory("VDB Activate SDF",
SOP_OpenVDB_Filter_Level_Set::factoryNarrowBand, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBResizeNarrowBand")
#endif
.setObsoleteParms(obsoleteParms)
.addInput("Input with VDBs to process")
.setVerb(SOP_NodeVerb::COOK_INPLACE, cacheAllocator)
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Change the width of the narrow band of a VDB signed distance field.\"\"\"\n\
\n\
@overview\n\
\n\
This node adjusts the width of the narrow band of a signed distance field\n\
represented by a VDB volume.\n\
\n\
@related\n\
- [OpenVDB Offset Level Set|Node:sop/DW_OpenVDBOffsetLevelSet]\n\
- [OpenVDB Rebuild Level Set|Node:sop/DW_OpenVDBRebuildLevelSet]\n\
- [OpenVDB Renormalize Level Set|Node:sop/DW_OpenVDBRenormalizeLevelSet]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
}
}
void
SOP_OpenVDB_Filter_Level_Set::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
resolveRenamedParm(*obsoleteParms, "halfWidth", "halfwidth");
resolveRenamedParm(*obsoleteParms, "halfWidthWorld", "halfwidthworld");
resolveRenamedParm(*obsoleteParms, "maxMask", "maxmask");
resolveRenamedParm(*obsoleteParms, "minMask", "minmask");
resolveRenamedParm(*obsoleteParms, "stencilWidth", "radius");
resolveRenamedParm(*obsoleteParms, "stencilWidthWorld", "radiusworld");
resolveRenamedParm(*obsoleteParms, "voxelOffset", "voxeloffset");
resolveRenamedParm(*obsoleteParms, "worldSpaceUnits", "useworldspaceunits");
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
////////////////////////////////////////
// Operator registration
OP_Node*
SOP_OpenVDB_Filter_Level_Set::factoryRenormalize(
OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Filter_Level_Set(net, name, op, OP_TYPE_RENORM);
}
OP_Node*
SOP_OpenVDB_Filter_Level_Set::factoryReshape(
OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Filter_Level_Set(net, name, op, OP_TYPE_RESHAPE);
}
OP_Node*
SOP_OpenVDB_Filter_Level_Set::factorySmooth(
OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Filter_Level_Set(net, name, op, OP_TYPE_SMOOTH);
}
OP_Node*
SOP_OpenVDB_Filter_Level_Set::factoryNarrowBand(
OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Filter_Level_Set(net, name, op, OP_TYPE_RESIZE);
}
SOP_OpenVDB_Filter_Level_Set::SOP_OpenVDB_Filter_Level_Set(
OP_Network* net, const char* name, OP_Operator* op, OperatorType opType)
: hvdb::SOP_NodeVDB(net, name, op)
, mOpType(opType)
{
}
////////////////////////////////////////
// Disable UI Parms.
bool
SOP_OpenVDB_Filter_Level_Set::updateParmsFlags()
{
bool changed = false, stencil = false;
const bool renorm = mOpType == OP_TYPE_RENORM;
const bool smooth = mOpType == OP_TYPE_SMOOTH;
const bool reshape = mOpType == OP_TYPE_RESHAPE;
const bool resize = mOpType == OP_TYPE_RESIZE;
if (renorm || resize) {
changed |= setVisibleState("invert", false);
changed |= setVisibleState("minmask",false);
changed |= setVisibleState("maxmask",false);
} else {
const FilterType operation = stringToFilterType(evalStdString("operation", 0));
stencil = operation == FILTER_TYPE_MEAN_VALUE ||
operation == FILTER_TYPE_GAUSSIAN ||
operation == FILTER_TYPE_MEDIAN_VALUE;
const bool hasMask = (this->nInputs() == 2);
changed |= enableParm("mask", hasMask);
const bool useMask = hasMask && bool(evalInt("mask", 0, 0));
changed |= enableParm("invert", useMask);
changed |= enableParm("minmask", useMask);
changed |= enableParm("maxmask", useMask);
changed |= enableParm("maskname", useMask);
}
const bool worldUnits = bool(evalInt("useworldspaceunits", 0, 0));
changed |= setVisibleState("halfwidth", resize && !worldUnits);
changed |= setVisibleState("halfwidthworld", resize && worldUnits);
changed |= enableParm("iterations", smooth || renorm);
changed |= enableParm("radius", stencil && !worldUnits);
changed |= enableParm("radiusworld", stencil && worldUnits);
changed |= setVisibleState("radius", getEnableState("radius"));
changed |= setVisibleState("radiusworld", getEnableState("radiusworld"));
changed |= setVisibleState("iterations", getEnableState("iterations"));
changed |= setVisibleState("useworldspaceunits", !renorm);
changed |= setVisibleState("voxeloffset", reshape);
return changed;
}
////////////////////////////////////////
// Cook
OP_ERROR
SOP_OpenVDB_Filter_Level_Set::Cache::cookVDBSop(
OP_Context& context)
{
try {
BossT boss("Processing level sets");
const fpreal time = context.getTime();
#ifndef SESI_OPENVDB
const bool verbose = bool(evalInt("verbose", 0, time));
#else
const bool verbose = false;
#endif
// Collect filter parameters starting from the topmost node.
std::vector<FilterParms> filterParms;
filterParms.resize(1);
evalFilterParms(context, filterParms[0]);
// Filter grids
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
// Check grid class
const openvdb::GridClass gridClass = it->getGrid().getGridClass();
if (gridClass != openvdb::GRID_LEVEL_SET) {
std::string s = it.getPrimitiveNameOrIndex().toStdString();
s = "VDB primitive " + s + " was skipped because it is not a level-set grid.";
addWarning(SOP_MESSAGE, s.c_str());
continue;
}
// Appply filters
bool wasFiltered = applyFilters<openvdb::FloatGrid>(
*it, filterParms, boss, context, *gdp, verbose);
if (boss.wasInterrupted()) break;
if (!wasFiltered) {
wasFiltered = applyFilters<openvdb::DoubleGrid>(
*it, filterParms, boss, context, *gdp, verbose);
}
if (boss.wasInterrupted()) break;
if (!wasFiltered) {
std::string msg = "VDB primitive "
+ it.getPrimitiveNameOrIndex().toStdString()
+ " is not of floating point type.";
addWarning(SOP_MESSAGE, msg.c_str());
continue;
}
if (boss.wasInterrupted()) break;
}
if (boss.wasInterrupted()) addWarning(SOP_MESSAGE, "processing was interrupted");
boss.end();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Filter_Level_Set::Cache::evalFilterParms(
OP_Context& context, FilterParms& parms)
{
fpreal now = context.getTime();
parms.mIterations = static_cast<int>(evalInt("iterations", 0, now));
parms.mHalfWidth = static_cast<int>(evalInt("halfwidth", 0, now));
parms.mHalfWidthWorld = float(evalFloat("halfwidthworld", 0, now));
parms.mStencilWidth = static_cast<int>(evalInt("radius", 0, now));
parms.mStencilWidthWorld = float(evalFloat("radiusworld", 0, now));
parms.mVoxelOffset = static_cast<float>(evalFloat("voxeloffset", 0, now));
parms.mMinMask = static_cast<float>(evalFloat("minmask", 0, now));
parms.mMaxMask = static_cast<float>(evalFloat("maxmask", 0, now));
parms.mInvertMask = bool(evalInt("invert", 0, now));
parms.mWorldUnits = bool(evalInt("useworldspaceunits", 0, now));
parms.mAccuracy = stringToAccuracy(evalStdString("accuracy", now));
parms.mGroup = evalStdString("group", now);
{
const auto trimMode = evalStdString("trim", now);
if (trimMode == "none") { parms.mTrimMode = FilterParms::TrimMode::kNone; }
else if (trimMode == "interior") { parms.mTrimMode = FilterParms::TrimMode::kInterior; }
else if (trimMode == "exterior") { parms.mTrimMode = FilterParms::TrimMode::kExterior; }
else if (trimMode == "all") { parms.mTrimMode = FilterParms::TrimMode::kAll; }
else {
addError(SOP_MESSAGE,
("Expected \"none\", \"interior\", \"exterior\" or \"all\" for \"trim\", got \""
+ trimMode + "\".").c_str());
}
}
if (OP_TYPE_RENORM == mOpType) {
parms.mFilterType = FILTER_TYPE_RENORMALIZE;
} else if (OP_TYPE_RESIZE == mOpType) {
parms.mFilterType = FILTER_TYPE_RESIZE;
} else {
parms.mFilterType = stringToFilterType(evalStdString("operation", now));
}
if (OP_TYPE_SMOOTH == mOpType || OP_TYPE_RESHAPE == mOpType) {
if (evalInt("mask", 0, now)) {
parms.mMaskInputNode = hasInput(1);
parms.mMaskName = evalStdString("maskname", now);
}
}
return error();
}
////////////////////////////////////////
// Filter callers
template<typename GridT>
bool
SOP_OpenVDB_Filter_Level_Set::Cache::applyFilters(
GU_PrimVDB* vdbPrim,
std::vector<FilterParms>& filterParms,
BossT& boss,
OP_Context& context,
GU_Detail&,
bool verbose)
{
vdbPrim->makeGridUnique();
typename GridT::Ptr grid = openvdb::gridPtrCast<GridT>(vdbPrim->getGridPtr());
if (!grid) return false;
using ValueT = typename GridT::ValueType;
using MaskT = openvdb::FloatGrid;
using FilterT = openvdb::tools::LevelSetFilter<GridT, MaskT, BossT>;
const float voxelSize = static_cast<float>(grid->voxelSize()[0]);
FilterT filter(*grid, &boss);
filter.setTemporalScheme(openvdb::math::TVD_RK1);
if (grid->background() < ValueT(openvdb::LEVEL_SET_HALF_WIDTH * voxelSize)) {
std::string msg = "VDB primitive '"
+ std::string(vdbPrim->getGridName())
+ "' has a narrow band width that is less than 3 voxel units. ";
addWarning(SOP_MESSAGE, msg.c_str());
}
for (size_t n = 0, N = filterParms.size(); n < N; ++n) {
const GA_PrimitiveGroup *group = matchGroup(*gdp, filterParms[n].mGroup);
// Skip this node if it doesn't operate on this primitive
if (group && !group->containsOffset(vdbPrim->getMapOffset())) continue;
filterGrid(context, filter, filterParms[n], boss, verbose);
if (boss.wasInterrupted()) break;
}
return true;
}
template<typename FilterT>
void
SOP_OpenVDB_Filter_Level_Set::Cache::filterGrid(
OP_Context& /*context*/,
FilterT& filter,
const FilterParms& parms,
BossT& boss,
bool verbose)
{
// Alpha-masking
using MaskT = typename FilterT::MaskType;
typename MaskT::ConstPtr maskGrid;
if (parms.mMaskInputNode) {
const GU_Detail* maskGeo = inputGeo(1);
if (maskGeo) {
const GA_PrimitiveGroup* maskGroup =
parsePrimitiveGroups(parms.mMaskName.c_str(), GroupCreator(maskGeo));
if (!maskGroup && !parms.mMaskName.empty()) {
addWarning(SOP_MESSAGE, "Mask not found.");
} else {
hvdb::VdbPrimCIterator maskIt(maskGeo, maskGroup);
if (maskIt) {
if (maskIt->getStorageType() == UT_VDB_FLOAT) {
maskGrid = openvdb::gridConstPtrCast<MaskT>(maskIt->getGridPtr());
} else {
addWarning(SOP_MESSAGE, "The mask grid has to be a FloatGrid.");
}
} else {
addWarning(SOP_MESSAGE, "The mask input is empty.");
}
}
}
filter.setMaskRange(parms.mMinMask, parms.mMaxMask);
filter.invertMask(parms.mInvertMask);
}
filter.setTrimming(parms.mTrimMode);
switch (parms.mAccuracy) {
case ACCURACY_UPWIND_FIRST: filter.setSpatialScheme(openvdb::math::FIRST_BIAS); break;
case ACCURACY_UPWIND_SECOND: filter.setSpatialScheme(openvdb::math::SECOND_BIAS); break;
case ACCURACY_UPWIND_THIRD: filter.setSpatialScheme(openvdb::math::THIRD_BIAS); break;
case ACCURACY_WENO: filter.setSpatialScheme(openvdb::math::WENO5_BIAS); break;
case ACCURACY_HJ_WENO: filter.setSpatialScheme(openvdb::math::HJWENO5_BIAS); break;
}
const float voxelSize = float(filter.grid().voxelSize()[0]);
const float ds = (parms.mWorldUnits ? 1.0f : voxelSize) * parms.mVoxelOffset;
switch (parms.mFilterType) {
case FILTER_TYPE_NONE:
break;
case FILTER_TYPE_RENORMALIZE:
renormalize(parms, filter, boss, verbose);
break;
case FILTER_TYPE_RESIZE:
resizeNarrowBand(parms, filter, boss, verbose);
break;
case FILTER_TYPE_MEAN_VALUE:
mean(parms, filter, boss, verbose, maskGrid.get());
break;
case FILTER_TYPE_GAUSSIAN:
gaussian(parms, filter, boss, verbose, maskGrid.get());
break;
case FILTER_TYPE_MEDIAN_VALUE:
median(parms, filter, boss, verbose, maskGrid.get());
break;
case FILTER_TYPE_MEAN_CURVATURE:
meanCurvature(parms, filter, boss, verbose, maskGrid.get());
break;
case FILTER_TYPE_LAPLACIAN_FLOW:
laplacian(parms, filter, boss, verbose, maskGrid.get());
break;
case FILTER_TYPE_TRACK:
track(parms, filter, boss, verbose);
break;
case FILTER_TYPE_DILATE:
offset(parms, filter, -ds, verbose, maskGrid.get());
break;
case FILTER_TYPE_ERODE:
offset(parms, filter, ds, verbose, maskGrid.get());
break;
case FILTER_TYPE_OPEN:
offset(parms, filter, ds, verbose, maskGrid.get());
offset(parms, filter, -ds, verbose, maskGrid.get());
break;
case FILTER_TYPE_CLOSE:
offset(parms, filter, -ds, verbose, maskGrid.get());
offset(parms, filter, ds, verbose, maskGrid.get());
break;
}
}
////////////////////////////////////////
// Filter operations
template<typename FilterT>
inline void
SOP_OpenVDB_Filter_Level_Set::Cache::offset(
const FilterParms&,
FilterT& filter,
const float offset,
bool verbose,
const typename FilterT::MaskType* mask)
{
if (verbose) {
std::cout << "Morphological " << (offset>0 ? "erosion" : "dilation")
<< " by the offset " << offset << std::endl;
}
filter.offset(offset, mask);
}
template<typename FilterT>
void
SOP_OpenVDB_Filter_Level_Set::Cache::mean(
const FilterParms& parms,
FilterT& filter,
BossT& boss,
bool verbose,
const typename FilterT::MaskType* mask)
{
const double voxelScale = 1.0 / filter.grid().voxelSize()[0];
for (int n = 0, N = parms.mIterations; n < N && !boss.wasInterrupted(); ++n) {
int radius = parms.mStencilWidth;
if (parms.mWorldUnits) {
double voxelRadius = double(parms.mStencilWidthWorld) * voxelScale;
radius = std::max(1, int(voxelRadius));
}
if (verbose) {
std::cout << "Mean filter of radius " << radius << std::endl;
}
filter.mean(radius, mask);
}
}
template<typename FilterT>
void
SOP_OpenVDB_Filter_Level_Set::Cache::gaussian(
const FilterParms& parms,
FilterT& filter,
BossT& boss,
bool verbose,
const typename FilterT::MaskType* mask)
{
const double voxelScale = 1.0 / filter.grid().voxelSize()[0];
for (int n = 0, N = parms.mIterations; n < N && !boss.wasInterrupted(); ++n) {
int radius = parms.mStencilWidth;
if (parms.mWorldUnits) {
double voxelRadius = double(parms.mStencilWidthWorld) * voxelScale;
radius = std::max(1, int(voxelRadius));
}
if (verbose) {
std::cout << "Gaussian filter of radius " << radius << std::endl;
}
filter.gaussian(radius, mask);
}
}
template<typename FilterT>
void
SOP_OpenVDB_Filter_Level_Set::Cache::median(
const FilterParms& parms,
FilterT& filter,
BossT& boss,
bool verbose,
const typename FilterT::MaskType* mask)
{
const double voxelScale = 1.0 / filter.grid().voxelSize()[0];
for (int n = 0, N = parms.mIterations; n < N && !boss.wasInterrupted(); ++n) {
int radius = parms.mStencilWidth;
if (parms.mWorldUnits) {
double voxelRadius = double(parms.mStencilWidthWorld) * voxelScale;
radius = std::max(1, int(voxelRadius));
}
if (verbose) {
std::cout << "Median filter of radius " << radius << std::endl;
}
filter.median(radius, mask);
}
}
template<typename FilterT>
void
SOP_OpenVDB_Filter_Level_Set::Cache::meanCurvature(
const FilterParms& parms,
FilterT& filter,
BossT& boss,
bool verbose,
const typename FilterT::MaskType* mask)
{
for (int n = 0, N = parms.mIterations; n < N && !boss.wasInterrupted(); ++n) {
if (verbose) std::cout << "Mean-curvature flow" << (n+1) << std::endl;
filter.meanCurvature(mask);
}
}
template<typename FilterT>
void
SOP_OpenVDB_Filter_Level_Set::Cache::laplacian(
const FilterParms& parms,
FilterT& filter,
BossT& boss,
bool verbose,
const typename FilterT::MaskType* mask)
{
for (int n = 0, N = parms.mIterations; n < N && !boss.wasInterrupted(); ++n) {
if (verbose) std::cout << "Laplacian flow" << (n+1) << std::endl;
filter.laplacian(mask);
}
}
template<typename FilterT>
inline void
SOP_OpenVDB_Filter_Level_Set::Cache::renormalize(
const FilterParms& parms,
FilterT& filter,
BossT&,
bool verbose)
{
// We will restore the old state since it is important to level set tracking
const typename FilterT::State s = filter.getState();
filter.setNormCount(parms.mIterations);
filter.setTemporalScheme(openvdb::math::TVD_RK3);
if (verbose) std::cout << "Renormalize #" << parms.mIterations << std::endl;
filter.normalize();
filter.prune();
filter.setState(s);
}
template<typename FilterT>
inline void
SOP_OpenVDB_Filter_Level_Set::Cache::resizeNarrowBand(
const FilterParms& parms,
FilterT& filter,
BossT&,
bool /*verbose*/)
{
// The filter is a statemachine so we will restore the old
// state since it is important to subsequent level set tracking
const typename FilterT::State s = filter.getState();
filter.setNormCount(1); // only one normalization per iteration
int width = parms.mHalfWidth;
if (parms.mWorldUnits) {
double voxelWidth = double(parms.mHalfWidthWorld) / filter.grid().voxelSize()[0];
width = std::max(1, int(voxelWidth));
}
filter.resize(width);
filter.prune();
filter.setState(s);
}
template<typename FilterT>
inline void
SOP_OpenVDB_Filter_Level_Set::Cache::track(
const FilterParms& parms,
FilterT& filter,
BossT& boss,
bool verbose)
{
for (int n = 0, N = parms.mIterations; n < N && !boss.wasInterrupted(); ++n) {
if (verbose) std::cout << "Tracking #" << (n+1) << std::endl;
filter.track();
}
}
| 44,435 | C++ | 33.715625 | 100 | 0.617329 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Rasterize_Points.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Rasterize_Points.cc
///
/// @author Mihai Alden
///
/// @brief Rasterize points into density and attribute grids.
///
/// @note This SOP has a accompanying creation script that adds a default VOP
/// subnetwork and UI parameters for cloud and velocity field modeling.
/// See the creation script file header for installation details.
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/GU_VDBPointTools.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb/tools/GridTransformer.h>
#include <openvdb/tools/PointIndexGrid.h>
#include <openvdb/tools/Prune.h>
#include <CH/CH_Manager.h>
#include <CVEX/CVEX_Context.h>
#include <CVEX/CVEX_Value.h>
#include <GA/GA_Handle.h>
#include <GA/GA_PageIterator.h>
#include <GA/GA_Types.h>
#include <GU/GU_Detail.h>
#include <GU/GU_SopResolver.h>
#include <OP/OP_Caller.h>
#include <OP/OP_Channels.h>
#include <OP/OP_Director.h>
#include <OP/OP_NodeInfoParms.h>
#include <OP/OP_Operator.h>
#include <OP/OP_OperatorTable.h>
#include <OP/OP_VexFunction.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_WorkArgs.h>
#include <VEX/VEX_Error.h>
#include <VOP/VOP_CodeCompilerArgs.h>
#include <VOP/VOP_CodeGenerator.h>
#include <VOP/VOP_ExportedParmsManager.h>
#include <VOP/VOP_LanguageContextTypeList.h>
#include <tbb/atomic.h>
#include <tbb/blocked_range.h>
#include <tbb/enumerable_thread_specific.h>
#include <tbb/parallel_for.h>
#include <tbb/parallel_reduce.h>
#include <tbb/task_group.h>
#include <hboost/algorithm/string/classification.hpp> // is_any_of
#include <hboost/algorithm/string/join.hpp>
#include <hboost/algorithm/string/split.hpp>
#include <algorithm> // std::sort
#include <cmath> // trigonometric functions
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
// Local Utility Methods
namespace {
inline hvdb::GridCPtr
getMaskVDB(const GU_Detail * geoPt, const GA_PrimitiveGroup *group = nullptr)
{
if (geoPt) {
hvdb::VdbPrimCIterator vdbIt(geoPt, group);
if (vdbIt) {
return (*vdbIt)->getConstGridPtr();
}
}
return hvdb::GridCPtr();
}
inline UT_SharedPtr<openvdb::BBoxd>
getMaskGeoBBox(const GU_Detail * geoPt)
{
if (geoPt) {
UT_BoundingBox box;
geoPt->getBBox(&box);
UT_SharedPtr<openvdb::BBoxd> bbox(new openvdb::BBoxd());
bbox->min()[0] = box.xmin();
bbox->min()[1] = box.ymin();
bbox->min()[2] = box.zmin();
bbox->max()[0] = box.xmax();
bbox->max()[1] = box.ymax();
bbox->max()[2] = box.zmax();
return bbox;
}
return UT_SharedPtr<openvdb::BBoxd>();
}
struct BoolSampler
{
static const char* name() { return "bin"; }
static int radius() { return 2; }
static bool mipmap() { return false; }
static bool consistent() { return true; }
template<class TreeT>
static bool sample(const TreeT& inTree,
const openvdb::Vec3R& inCoord, typename TreeT::ValueType& result)
{
openvdb::Coord ijk;
ijk[0] = int(std::floor(inCoord[0]));
ijk[1] = int(std::floor(inCoord[1]));
ijk[2] = int(std::floor(inCoord[2]));
return inTree.probeValue(ijk, result);
}
}; // struct BoolSampler
/// z-coordinate comparison operator for std::sort.
template<typename LeafNodeType>
struct CompZCoord
{
bool operator()(const LeafNodeType* lhs, const LeafNodeType* rhs) const {
return lhs->origin().z() < rhs->origin().z();
}
}; // struct CompZCoord
/// returns the world space voxel size for the given frustum depth.
inline openvdb::Vec3d
computeFrustumVoxelSize(int zDepth, const openvdb::math::Transform& xform)
{
using MapType = openvdb::math::NonlinearFrustumMap;
MapType::ConstPtr map = xform.map<MapType>();
if (map) {
const openvdb::BBoxd& box = map->getBBox();
openvdb::CoordBBox bbox(
openvdb::Coord::floor(box.min()), openvdb::Coord::ceil(box.max()));
double nearPlaneX = 0.5 * double(bbox.min().x() + bbox.max().x());
double nearPlaneY = 0.5 * double(bbox.min().y() + bbox.max().y());
zDepth = std::max(zDepth, bbox.min().z());
openvdb::Vec3d xyz(nearPlaneX, nearPlaneY, double(zDepth));
return xform.voxelSize(xyz);
}
return xform.voxelSize();
}
inline double
linearBlend(double a, double b, double w) { return a * w + b * (1.0 - w); }
/// Inactivates the region defined by @a bbox in @a mask.
template <typename MaskTreeType>
inline void
bboxClip(MaskTreeType& mask, const openvdb::BBoxd& bbox, bool invertMask,
const openvdb::math::Transform& maskXform, const openvdb::math::Transform* srcXform = nullptr)
{
using ValueType = typename MaskTreeType::ValueType;
const ValueType offVal = ValueType(0);
const ValueType onVal = ValueType(1);
if (!srcXform) {
openvdb::Vec3d minIS, maxIS;
openvdb::math::calculateBounds(maskXform, bbox.min(), bbox.max(), minIS, maxIS);
openvdb::CoordBBox clipRegion;
clipRegion.min()[0] = int(std::floor(minIS[0]));
clipRegion.min()[1] = int(std::floor(minIS[1]));
clipRegion.min()[2] = int(std::floor(minIS[2]));
clipRegion.max()[0] = int(std::floor(maxIS[0]));
clipRegion.max()[1] = int(std::floor(maxIS[1]));
clipRegion.max()[2] = int(std::floor(maxIS[2]));
MaskTreeType clipMask(offVal);
clipMask.fill(clipRegion, onVal, true);
if (invertMask) {
mask.topologyDifference(clipMask);
} else {
mask.topologyIntersection(clipMask);
}
} else {
openvdb::Vec3d minIS, maxIS;
openvdb::math::calculateBounds(*srcXform, bbox.min(), bbox.max(), minIS, maxIS);
openvdb::CoordBBox clipRegion;
clipRegion.min()[0] = int(std::floor(minIS[0]));
clipRegion.min()[1] = int(std::floor(minIS[1]));
clipRegion.min()[2] = int(std::floor(minIS[2]));
clipRegion.max()[0] = int(std::floor(maxIS[0]));
clipRegion.max()[1] = int(std::floor(maxIS[1]));
clipRegion.max()[2] = int(std::floor(maxIS[2]));
using MaskGridType = openvdb::Grid<MaskTreeType>;
MaskGridType srcClipMask(offVal);
srcClipMask.setTransform(srcXform->copy());
srcClipMask.tree().fill(clipRegion, onVal, true);
MaskGridType dstClipMask(offVal);
dstClipMask.setTransform(maskXform.copy());
hvdb::Interrupter interrupter;
openvdb::tools::resampleToMatch<BoolSampler>(srcClipMask, dstClipMask, interrupter);
if (invertMask) {
mask.topologyDifference(dstClipMask.tree());
} else {
mask.topologyIntersection(dstClipMask.tree());
}
}
}
template <typename MaskTreeType>
struct GridTopologyClipOp
{
GridTopologyClipOp(
MaskTreeType& mask, const openvdb::math::Transform& maskXform, bool invertMask)
: mMask(&mask), mMaskXform(&maskXform), mInvertMask(invertMask)
{
}
/// Inactivates the region defined by @a grid in mMask.
template<typename GridType>
void operator()(const GridType& grid)
{
using MaskGridType = openvdb::Grid<MaskTreeType>;
using ValueType = typename MaskTreeType::ValueType;
const ValueType offVal = ValueType(0);
MaskGridType srcClipMask(offVal);
srcClipMask.setTransform(grid.transform().copy());
srcClipMask.tree().topologyUnion(grid.tree());
MaskGridType dstClipMask(offVal);
dstClipMask.setTransform(mMaskXform->copy());
hvdb::Interrupter interrupter;
openvdb::tools::resampleToMatch<BoolSampler>(srcClipMask, dstClipMask, interrupter);
if (mInvertMask) {
mMask->topologyDifference(dstClipMask.tree());
} else {
mMask->topologyIntersection(dstClipMask.tree());
}
}
private:
MaskTreeType * const mMask;
openvdb::math::Transform const * const mMaskXform;
bool mInvertMask;
}; // struct GridTopologyClipOp
////////////////////////////////////////
///@brief Utility structure that caches commonly used point attributes
struct PointCache
{
using Ptr = UT_SharedPtr<PointCache>;
using PosType = openvdb::Vec3s;
using ScalarType = PosType::value_type;
PointCache(const GU_Detail& detail, const float radiusScale,
const GA_PointGroup* group = nullptr)
: mIndexMap(&detail.getP()->getIndexMap())
, mSize(mIndexMap->indexSize())
, mOffsets()
, mRadius()
, mPos()
{
if (group) {
mSize = group->entries();
mOffsets.reset(new GA_Offset[mSize]);
GA_Offset start, end;
GA_Offset* offset = mOffsets.get();
GA_Range range(*group);
for (GA_Iterator it = range.begin(); it.blockAdvance(start, end); ) {
for (GA_Offset off = start; off < end; ++off, ++offset) {
*offset = off;
}
}
mRadius.reset(new float[mSize]);
mPos.reset(new openvdb::Vec3s[mSize]);
tbb::parallel_for(tbb::blocked_range<size_t>(0, mSize),
IFOCachePointGroupData(mOffsets, detail, mRadius, mPos, radiusScale));
getOffset = &PointCache::offsetFromGroupMap;
} else if (mIndexMap->isTrivialMap()) {
getOffset = &PointCache::offsetFromIndexCast;
} else {
getOffset = &PointCache::offsetFromGeoMap;
}
if (!group) {
mRadius.reset(new float[mSize]);
mPos.reset(new openvdb::Vec3s[mSize]);
UTparallelFor(GA_SplittableRange(detail.getPointRange(group)),
IFOCachePointData(detail, mRadius, mPos, radiusScale));
}
}
PointCache(const PointCache& rhs, const std::vector<unsigned>& indices)
: mIndexMap(rhs.mIndexMap)
, mSize(indices.size())
, mOffsets()
, mRadius()
, mPos()
{
mOffsets.reset(new GA_Offset[mSize]);
mRadius.reset(new float[mSize]);
mPos.reset(new openvdb::Vec3s[mSize]);
tbb::parallel_for(tbb::blocked_range<size_t>(0, mSize),
IFOCopyPointData(indices, mOffsets, mRadius, mPos, rhs));
getOffset = &PointCache::offsetFromGroupMap;
}
size_t size() const { return mSize; }
const float& radius(size_t n) const { return mRadius[n]; }
const openvdb::Vec3s& pos(size_t n) const { return mPos[n]; }
void getPos(size_t n, openvdb::Vec3s& xyz) const { xyz = mPos[n]; }
GA_Offset offsetFromIndex(size_t n) const { return (this->*getOffset)(n); }
const float* radiusData() const { return mRadius.get(); }
const openvdb::Vec3s* posData() const { return mPos.get(); }
float evalMaxRadius() const {
IFOEvalMaxRadius op(mRadius.get());
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, mSize), op);
return op.result;
}
float evalMinRadius() const {
IFOEvalMinRadius op(mRadius.get());
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, mSize), op);
return op.result;
}
private:
// Disallow copying
PointCache(const PointCache&);
PointCache& operator=(const PointCache&);
GA_Offset (PointCache::* getOffset)(const size_t) const;
GA_Offset offsetFromGeoMap(const size_t n) const {
return mIndexMap->offsetFromIndex(GA_Index(n));
}
GA_Offset offsetFromGroupMap(const size_t n) const {
return mOffsets[n];
}
GA_Offset offsetFromIndexCast(const size_t n) const {
return GA_Offset(n);
}
//////////
// Internal TBB function objects
struct IFOCopyPointData {
IFOCopyPointData(
const std::vector<unsigned>& indices,
UT_UniquePtr<GA_Offset[]>& offsets,
UT_UniquePtr<float[]>& radius,
UT_UniquePtr<openvdb::Vec3s[]>& pos,
const PointCache& PointCache)
: mIndices(&indices[0])
, mOffsets(offsets.get())
, mRadiusData(radius.get())
, mPosData(pos.get())
, mPointCache(&PointCache)
{
}
void operator()(const tbb::blocked_range<size_t>& range) const
{
const float* radiusData = mPointCache->radiusData();
const openvdb::Vec3s* posData = mPointCache->posData();
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
const size_t idx = size_t(mIndices[n]);
mOffsets[n] = mPointCache->offsetFromIndex(idx);
mRadiusData[n] = radiusData[idx];
mPosData[n] = posData[idx];
}
}
unsigned const * const mIndices;
GA_Offset * const mOffsets;
float * const mRadiusData;
openvdb::Vec3s * const mPosData;
PointCache const * const mPointCache;
}; // struct IFOCopyPointData
struct IFOCachePointData
{
IFOCachePointData(const GU_Detail& detail,
UT_UniquePtr<float[]>& radius,
UT_UniquePtr<openvdb::Vec3s[]>& pos,
float radiusScale = 1.0)
: mDetail(&detail)
, mRadiusData(radius.get())
, mPosData(pos.get())
, mRadiusScale(radiusScale)
{
}
void operator()(const GA_SplittableRange& range) const
{
GA_Offset start, end;
UT_Vector3 xyz;
GA_ROHandleV3 posHandle(mDetail->getP());
GA_ROHandleF scaleHandle;
GA_ROAttributeRef aRef =
mDetail->findFloatTuple(GA_ATTRIB_POINT, GEO_STD_ATTRIB_PSCALE);
bool hasScale = false;
if (aRef.isValid()) {
hasScale = true;
scaleHandle.bind(aRef.getAttribute());
}
const float scale = mRadiusScale;
for (GA_PageIterator pageIt = range.beginPages(); !pageIt.atEnd(); ++pageIt) {
for (GA_Iterator blockIt(pageIt.begin()); blockIt.blockAdvance(start, end); ) {
for (GA_Offset i = start; i < end; ++i) {
const GA_Index idx = mDetail->pointIndex(i);
mRadiusData[idx] = hasScale ? scaleHandle.get(i) * scale : scale;
xyz = posHandle.get(i);
openvdb::Vec3s& p = mPosData[idx];
p[0] = xyz[0];
p[1] = xyz[1];
p[2] = xyz[2];
}
}
}
}
GU_Detail const * const mDetail;
float * const mRadiusData;
openvdb::Vec3s * const mPosData;
float const mRadiusScale;
}; // struct IFOCachePointData
struct IFOCachePointGroupData
{
IFOCachePointGroupData(const UT_UniquePtr<GA_Offset[]>& offsets,
const GU_Detail& detail,
UT_UniquePtr<float[]>& radius,
UT_UniquePtr<openvdb::Vec3s[]>& pos,
float radiusScale = 1.0)
: mOffsets(offsets.get())
, mDetail(&detail)
, mRadiusData(radius.get())
, mPosData(pos.get())
, mRadiusScale(radiusScale)
{
}
void operator()(const tbb::blocked_range<size_t>& range) const
{
GA_ROHandleV3 posHandle(mDetail->getP());
bool hasScale = false;
GA_ROHandleF scaleHandle;
GA_ROAttributeRef aRef =
mDetail->findFloatTuple(GA_ATTRIB_POINT, GEO_STD_ATTRIB_PSCALE);
if (aRef.isValid()) {
hasScale = true;
scaleHandle.bind(aRef.getAttribute());
}
const float scale = mRadiusScale;
UT_Vector3 xyz;
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
const GA_Offset offset = mOffsets[n];
mRadiusData[n] = hasScale ? scaleHandle.get(offset) * scale : scale;
xyz = posHandle.get(offset);
openvdb::Vec3s& p = mPosData[n];
p[0] = xyz[0];
p[1] = xyz[1];
p[2] = xyz[2];
}
}
GA_Offset const * const mOffsets;
GU_Detail const * const mDetail;
float * const mRadiusData;
openvdb::Vec3s * const mPosData;
float const mRadiusScale;
}; // struct IFOCachePointGroupData
struct IFOEvalMaxRadius {
IFOEvalMaxRadius(float const * const radiusArray)
: mRadiusArray(radiusArray), result(-std::numeric_limits<float>::max()) {}
IFOEvalMaxRadius(IFOEvalMaxRadius& rhs, tbb::split) // thread safe copy constructor
: mRadiusArray(rhs.mRadiusArray), result(-std::numeric_limits<float>::max()){}
void operator()(const tbb::blocked_range<size_t>& range) {
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
result = std::max(mRadiusArray[n], result);
}
}
void join(const IFOEvalMaxRadius& rhs) { result = std::max(rhs.result, result); }
float const * const mRadiusArray;
float result;
}; // struct IFOEvalMaxRadius
struct IFOEvalMinRadius {
IFOEvalMinRadius(float const * const radiusArray)
: mRadiusArray(radiusArray), result(std::numeric_limits<float>::max()) {}
IFOEvalMinRadius(IFOEvalMinRadius& rhs, tbb::split) // thread safe copy constructor
: mRadiusArray(rhs.mRadiusArray), result(std::numeric_limits<float>::max()){}
void operator()(const tbb::blocked_range<size_t>& range) {
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
result = std::min(mRadiusArray[n], result);
}
}
void join(const IFOEvalMinRadius& rhs) { result = std::min(rhs.result, result); }
float const * const mRadiusArray;
float result;
}; // struct IFOEvalMinRadius
//////////
GA_IndexMap const * const mIndexMap;
size_t mSize;
UT_UniquePtr<GA_Offset[]> mOffsets;
UT_UniquePtr<float[]> mRadius;
UT_UniquePtr<openvdb::Vec3s[]> mPos;
}; // struct PointCache
///@brief Radius based partitioning of points into multiple @c openvdb::tools::PointIndexGrid
/// acceleration structures. Improves spatial query time for points with varying radius.
struct PointIndexGridCollection
{
using PointIndexGrid = openvdb::tools::PointIndexGrid;
using PointIndexTree = PointIndexGrid::TreeType;
using PointIndexLeafNode = PointIndexTree::LeafNodeType;
using BoolTreeType = PointIndexTree::ValueConverter<bool>::Type;
PointIndexGridCollection(const GU_Detail& detail, const float radiusScale,
const float minVoxelSize, const GA_PointGroup* group = nullptr,
hvdb::Interrupter* interrupter = nullptr)
: mPointCacheArray() , mIdxGridArray(), mMinRadiusArray(), mMaxRadiusArray()
{
mPointCacheArray.push_back(PointCache::Ptr(new PointCache(detail, radiusScale, group)));
std::vector<double> voxelSizeList;
voxelSizeList.push_back(std::max(minVoxelSize, mPointCacheArray.back()->evalMinRadius()));
for (size_t n = 0; n < 50; ++n) {
if (interrupter && interrupter->wasInterrupted()) break;
PointCache& pointCache = *mPointCacheArray.back();
const float maxRadius = pointCache.evalMaxRadius();
const float limit = float(voxelSizeList.back() * (n < 40 ? 2.0 : 8.0));
if (!(maxRadius > limit)) {
break;
}
std::vector<unsigned> lhsIdx, rhsIdx;
float minRadius = maxRadius;
const float* radiusData = pointCache.radiusData();
for (unsigned i = 0, I = unsigned(pointCache.size()); i < I; ++i) {
if (radiusData[i] > limit) {
rhsIdx.push_back(i);
minRadius = std::min(minRadius, radiusData[i]);
} else lhsIdx.push_back(i);
}
voxelSizeList.push_back(minRadius);
PointCache::Ptr lhsPointCache(new PointCache(pointCache, lhsIdx));
PointCache::Ptr rhsPointCache(new PointCache(pointCache, rhsIdx));
mPointCacheArray.back() = lhsPointCache;
mPointCacheArray.push_back(rhsPointCache);
}
const size_t collectionSize = mPointCacheArray.size();
mIdxGridArray.resize(collectionSize);
mMinRadiusArray.reset(new float[collectionSize]);
mMaxRadiusArray.reset(new float[collectionSize]);
tbb::task_group tasks;
for (size_t n = 0; n < collectionSize; ++n) {
if (interrupter && interrupter->wasInterrupted()) break;
tasks.run(IFOCreateAuxiliaryData(mIdxGridArray[n], *mPointCacheArray[n],
voxelSizeList[n], mMinRadiusArray[n], mMaxRadiusArray[n]));
}
tasks.wait();
}
//////////
size_t size() const { return mPointCacheArray.size(); }
float minRadius(size_t n) const { return mMinRadiusArray[n]; }
float maxRadius(size_t n) const { return mMaxRadiusArray[n]; }
float maxRadius() const {
float maxradius = mMaxRadiusArray[0];
for (size_t n = 0, N = mPointCacheArray.size(); n < N; ++n) {
maxradius = std::max(maxradius, mMaxRadiusArray[n]);
}
return maxradius;
}
const PointCache& pointCache(size_t n) const { return *mPointCacheArray[n]; }
const PointIndexGrid& idxGrid(size_t n) const { return *mIdxGridArray[n]; }
private:
// Disallow copying
PointIndexGridCollection(const PointIndexGridCollection&);
PointIndexGridCollection& operator=(const PointIndexGridCollection&);
//////////
// Internal TBB function objects
struct IFOCreateAuxiliaryData {
IFOCreateAuxiliaryData(PointIndexGrid::Ptr& idxGridPt, PointCache& points,
double voxelSize, float& minRadius, float& maxRadius)
: mIdxGrid(&idxGridPt), mPointCache(&points), mVoxelSize(voxelSize)
, mMinRadius(&minRadius), mMaxRadius(&maxRadius)
{}
void operator()() const {
const openvdb::math::Transform::Ptr transform =
openvdb::math::Transform::createLinearTransform(mVoxelSize);
*mIdxGrid =
openvdb::tools::createPointIndexGrid<PointIndexGrid>(*mPointCache, *transform);
*mMinRadius = mPointCache->evalMinRadius();
*mMaxRadius = mPointCache->evalMaxRadius();
}
PointIndexGrid::Ptr * const mIdxGrid;
PointCache const * const mPointCache;
double const mVoxelSize;
float * const mMinRadius;
float * const mMaxRadius;
}; // struct IFOCreateAuxiliaryData
//////////
std::vector<PointCache::Ptr> mPointCacheArray;
std::vector<PointIndexGrid::Ptr> mIdxGridArray;
UT_UniquePtr<float[]> mMinRadiusArray, mMaxRadiusArray;
}; // struct PointIndexGridCollection
///@brief TBB function object to construct a @c BoolTree region of interest
/// mask for the gather based rasterization step.
struct ConstructCandidateVoxelMask
{
using PosType = PointCache::PosType;
using ScalarType = PosType::value_type;
using PointIndexTree = openvdb::tools::PointIndexGrid::TreeType;
using PointIndexLeafNode = PointIndexTree::LeafNodeType;
using PointIndexType = PointIndexLeafNode::ValueType;
using BoolTreeType = PointIndexTree::ValueConverter<bool>::Type;
using BoolLeafNode = BoolTreeType::LeafNodeType;
/////
ConstructCandidateVoxelMask(BoolTreeType& maskTree, const PointCache& points,
const std::vector<const PointIndexLeafNode*>& pointIndexLeafNodes,
const openvdb::math::Transform& xform,
const openvdb::CoordBBox * clipBox = nullptr,
hvdb::Interrupter* interrupter = nullptr)
: mMaskTree(false)
, mMaskTreePt(&maskTree)
, mMaskAccessor(*mMaskTreePt)
, mPoints(&points)
, mPointIndexNodes(&pointIndexLeafNodes.front())
, mXform(xform)
, mClipBox(clipBox)
, mInterrupter(interrupter)
{
}
/// Thread safe copy constructor
ConstructCandidateVoxelMask(ConstructCandidateVoxelMask& rhs, tbb::split)
: mMaskTree(false)
, mMaskTreePt(&mMaskTree)
, mMaskAccessor(*mMaskTreePt)
, mPoints(rhs.mPoints)
, mPointIndexNodes(rhs.mPointIndexNodes)
, mXform(rhs.mXform)
, mClipBox(rhs.mClipBox)
, mInterrupter(rhs.mInterrupter)
{
}
void operator()(const tbb::blocked_range<size_t>& range) {
openvdb::CoordBBox box;
PosType pos, bboxMin, bboxMax, pMin, pMax;
ScalarType radius(0.0);
const PointIndexType *pointIdxPt = nullptr, *endIdxPt = nullptr;
std::vector<PointIndexType> largeParticleIndices;
double leafnodeSize = mXform.voxelSize()[0] * double(PointIndexLeafNode::DIM);
const bool isTransformLinear = mXform.isLinear();
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
if (this->wasInterrupted()) {
tbb::task::self().cancel_group_execution();
break;
}
const PointIndexLeafNode& node = *mPointIndexNodes[n];
for (PointIndexLeafNode::ValueOnCIter it = node.cbeginValueOn(); it; ++it) {
node.getIndices(it.pos(), pointIdxPt, endIdxPt);
bboxMin[0] = std::numeric_limits<ScalarType>::max();
bboxMin[1] = std::numeric_limits<ScalarType>::max();
bboxMin[2] = std::numeric_limits<ScalarType>::max();
bboxMax[0] = -bboxMin[0];
bboxMax[1] = -bboxMin[1];
bboxMax[2] = -bboxMin[2];
bool regionIsValid = false;
while (pointIdxPt < endIdxPt) {
radius = mPoints->radius(*pointIdxPt);
if (isTransformLinear && radius > leafnodeSize) {
largeParticleIndices.push_back(*pointIdxPt);
} else {
pos = mPoints->pos(*pointIdxPt);
pMin[0] = pos[0] - radius;
pMin[1] = pos[1] - radius;
pMin[2] = pos[2] - radius;
pMax[0] = pos[0] + radius;
pMax[1] = pos[1] + radius;
pMax[2] = pos[2] + radius;
bboxMin[0] = std::min(bboxMin[0], pMin[0]);
bboxMin[1] = std::min(bboxMin[1], pMin[1]);
bboxMin[2] = std::min(bboxMin[2], pMin[2]);
bboxMax[0] = std::max(bboxMax[0], pMax[0]);
bboxMax[1] = std::max(bboxMax[1], pMax[1]);
bboxMax[2] = std::max(bboxMax[2], pMax[2]);
regionIsValid = true;
}
++pointIdxPt;
}
if (regionIsValid) {
if (isTransformLinear) {
box.min() = mXform.worldToIndexCellCentered(bboxMin);
box.max() = mXform.worldToIndexCellCentered(bboxMax);
} else {
openvdb::math::Vec3d ijkMin, ijkMax;
openvdb::math::calculateBounds(mXform, bboxMin, bboxMax, ijkMin, ijkMax);
box.min() = openvdb::Coord::round(ijkMin);
box.max() = openvdb::Coord::round(ijkMax);
}
if (mClipBox) {
if (mClipBox->hasOverlap(box)) {
// Intersect bbox with the region of interest.
box.min() = openvdb::Coord::maxComponent(box.min(), mClipBox->min());
box.max() = openvdb::Coord::minComponent(box.max(), mClipBox->max());
activateRegion(box);
}
} else {
activateRegion(box);
}
}
}
}
for (size_t n = 0, N = largeParticleIndices.size(); n != N; ++n) {
radius = mPoints->radius(largeParticleIndices[n]);
pos = mPoints->pos(largeParticleIndices[n]);
bboxMin[0] = std::numeric_limits<ScalarType>::max();
bboxMin[1] = std::numeric_limits<ScalarType>::max();
bboxMin[2] = std::numeric_limits<ScalarType>::max();
bboxMax[0] = -bboxMin[0];
bboxMax[1] = -bboxMin[1];
bboxMax[2] = -bboxMin[2];
pMin[0] = pos[0] - radius;
pMin[1] = pos[1] - radius;
pMin[2] = pos[2] - radius;
pMax[0] = pos[0] + radius;
pMax[1] = pos[1] + radius;
pMax[2] = pos[2] + radius;
bboxMin[0] = std::min(bboxMin[0], pMin[0]);
bboxMin[1] = std::min(bboxMin[1], pMin[1]);
bboxMin[2] = std::min(bboxMin[2], pMin[2]);
bboxMax[0] = std::max(bboxMax[0], pMax[0]);
bboxMax[1] = std::max(bboxMax[1], pMax[1]);
bboxMax[2] = std::max(bboxMax[2], pMax[2]);
box.min() = mXform.worldToIndexCellCentered(bboxMin);
box.max() = mXform.worldToIndexCellCentered(bboxMax);
if (mClipBox) {
if (mClipBox->hasOverlap(box)) {
// Intersect bbox with the region of interest.
box.min() = openvdb::Coord::maxComponent(box.min(), mClipBox->min());
box.max() = openvdb::Coord::minComponent(box.max(), mClipBox->max());
activateRegion(box);
}
} else {
activateRadialRegion(box);
}
}
}
void join(ConstructCandidateVoxelMask& rhs) {
std::vector<BoolLeafNode*> rhsLeafNodes, overlappingLeafNodes;
rhsLeafNodes.reserve(rhs.mMaskTreePt->leafCount());
rhs.mMaskTreePt->getNodes(rhsLeafNodes);
// Steal unique leafnodes
openvdb::tree::ValueAccessor<BoolTreeType> lhsAcc(*mMaskTreePt);
openvdb::tree::ValueAccessor<BoolTreeType> rhsAcc(*rhs.mMaskTreePt);
using BoolRootNodeType = BoolTreeType::RootNodeType;
using BoolNodeChainType = BoolRootNodeType::NodeChainType;
using BoolInternalNodeType = BoolNodeChainType::Get<1>;
for (size_t n = 0, N = rhsLeafNodes.size(); n < N; ++n) {
const openvdb::Coord& ijk = rhsLeafNodes[n]->origin();
if (!lhsAcc.probeLeaf(ijk)) {
// add node to lhs tree
lhsAcc.addLeaf(rhsLeafNodes[n]);
// remove leaf node from rhs tree
BoolInternalNodeType* internalNode = rhsAcc.probeNode<BoolInternalNodeType>(ijk);
if (internalNode) {
internalNode->stealNode<BoolLeafNode>(ijk, false, false);
} else {
rhs.mMaskTreePt->stealNode<BoolLeafNode>(ijk, false, false);
}
} else {
overlappingLeafNodes.push_back(rhsLeafNodes[n]);
}
}
// Combine overlapping leaf nodes
tbb::parallel_for(tbb::blocked_range<size_t>(0, overlappingLeafNodes.size()),
IFOTopologyUnion(*mMaskTreePt, &overlappingLeafNodes[0]));
}
private:
bool wasInterrupted() const { return mInterrupter && mInterrupter->wasInterrupted(); }
// just a rough estimate, but more accurate than activateRegion(...) for large spheres.
void activateRadialRegion(const openvdb::CoordBBox& bbox)
{
using LeafNodeType = BoolTreeType::LeafNodeType;
const openvdb::Vec3d center = bbox.getCenter();
const double radius = double(bbox.dim()[0]) * 0.5;
// inscribed box
const double iRadius = radius * double(1.0 / std::sqrt(3.0));
openvdb::CoordBBox ibox(
openvdb::Coord::round(openvdb::Vec3d(
center[0] - iRadius, center[1] - iRadius, center[2] - iRadius)),
openvdb::Coord::round(openvdb::Vec3d(
center[0] + iRadius, center[1] + iRadius, center[2] + iRadius)));
ibox.min() &= ~(LeafNodeType::DIM - 1);
ibox.max() &= ~(LeafNodeType::DIM - 1);
openvdb::Coord ijk(0);
for (ijk[0] = ibox.min()[0]; ijk[0] <= ibox.max()[0]; ijk[0] += LeafNodeType::DIM) {
for (ijk[1] = ibox.min()[1]; ijk[1] <= ibox.max()[1]; ijk[1] += LeafNodeType::DIM) {
for (ijk[2] = ibox.min()[2]; ijk[2] <= ibox.max()[2]; ijk[2] += LeafNodeType::DIM) {
mMaskAccessor.touchLeaf(ijk)->setValuesOn();
}
}
}
const openvdb::Coord leafMin = bbox.min() & ~(LeafNodeType::DIM - 1);
const openvdb::Coord leafMax = bbox.max() & ~(LeafNodeType::DIM - 1);
openvdb::Vec3d xyz;
const double leafNodeRadius = double(LeafNodeType::DIM) * std::sqrt(3.0) * 0.5;
double distSqr = radius + leafNodeRadius;
distSqr *= distSqr;
for (ijk[0] = leafMin[0]; ijk[0] <= leafMax[0]; ijk[0] += LeafNodeType::DIM) {
for (ijk[1] = leafMin[1]; ijk[1] <= leafMax[1]; ijk[1] += LeafNodeType::DIM) {
for (ijk[2] = leafMin[2]; ijk[2] <= leafMax[2]; ijk[2] += LeafNodeType::DIM) {
if (!ibox.isInside(ijk)) {
xyz[0] = double(ijk[0]);
xyz[1] = double(ijk[1]);
xyz[2] = double(ijk[2]);
xyz += double(LeafNodeType::DIM - 1) * 0.5;
xyz -= center;
if (!(xyz.lengthSqr() > distSqr)) {
activateLeafNodeRegion(bbox, *mMaskAccessor.touchLeaf(ijk));
}
}
}
}
}
}
void activateRegion(const openvdb::CoordBBox& bbox)
{
using LeafNodeType = BoolTreeType::LeafNodeType;
const openvdb::Coord leafMin = bbox.min() & ~(LeafNodeType::DIM - 1);
const openvdb::Coord leafMax = bbox.max() & ~(LeafNodeType::DIM - 1);
openvdb::Coord ijk(0);
for (ijk[0] = leafMin[0]; ijk[0] <= leafMax[0]; ijk[0] += LeafNodeType::DIM) {
for (ijk[1] = leafMin[1]; ijk[1] <= leafMax[1]; ijk[1] += LeafNodeType::DIM) {
for (ijk[2] = leafMin[2]; ijk[2] <= leafMax[2]; ijk[2] += LeafNodeType::DIM) {
activateLeafNodeRegion(bbox, *mMaskAccessor.touchLeaf(ijk));
}
}
}
}
template <typename LeafNodeType>
void activateLeafNodeRegion(const openvdb::CoordBBox& bbox, LeafNodeType& node) const
{
const openvdb::Coord& origin = node.origin();
openvdb::Coord ijk = origin;
ijk.offset(LeafNodeType::DIM - 1);
if (bbox.isInside(origin) && bbox.isInside(ijk)) {
node.setValuesOn();
} else if (!node.isValueMaskOn()) {
const openvdb::Coord ijkMin = openvdb::Coord::maxComponent(bbox.min(), origin);
const openvdb::Coord ijkMax = openvdb::Coord::minComponent(bbox.max(), ijk);
openvdb::Index xPos(0), yPos(0);
for (ijk[0] = ijkMin[0]; ijk[0] <= ijkMax[0]; ++ijk[0]) {
xPos = (ijk[0] & (LeafNodeType::DIM - 1u)) << (2 * LeafNodeType::LOG2DIM);
for (ijk[1] = ijkMin[1]; ijk[1] <= ijkMax[1]; ++ijk[1]) {
yPos = xPos + ((ijk[1] & (LeafNodeType::DIM - 1u)) << LeafNodeType::LOG2DIM);
for (ijk[2] = ijkMin[2]; ijk[2] <= ijkMax[2]; ++ijk[2]) {
node.setValueOn(yPos + (ijk[2] & (LeafNodeType::DIM - 1u)));
}
}
}
}
}
//////////
// Internal TBB function objects
struct IFOTopologyUnion {
IFOTopologyUnion(BoolTreeType& tree, BoolLeafNode ** nodes)
: mTree(&tree), mNodes(nodes) { }
void operator()(const tbb::blocked_range<size_t>& range) const {
openvdb::tree::ValueAccessor<BoolTreeType> acc(*mTree);
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
acc.probeLeaf(mNodes[n]->origin())->topologyUnion(*mNodes[n]);
}
}
BoolTreeType * const mTree;
BoolLeafNode * const * const mNodes;
}; // struct IFOTopologyUnion
//////////
BoolTreeType mMaskTree;
BoolTreeType * const mMaskTreePt;
openvdb::tree::ValueAccessor<BoolTreeType> mMaskAccessor;
PointCache const * const mPoints;
PointIndexLeafNode const * const * const mPointIndexNodes;
openvdb::math::Transform const mXform;
openvdb::CoordBBox const * const mClipBox;
hvdb::Interrupter * const mInterrupter;
}; // struct ConstructCandidateVoxelMask
/// Inactivates candidate leafnodes that have no particle overlap.
/// (The ConstructCandidateVoxelMask scheme is overestimating the region
/// of intrest when frustum transforms are used, this culls the regions.)
template <typename MaskLeafNodeType>
struct CullFrustumLeafNodes
{
CullFrustumLeafNodes(
const PointIndexGridCollection& idxGridCollection,
std::vector<MaskLeafNodeType*>& nodes,
const openvdb::math::Transform& xform)
: mIdxGridCollection(&idxGridCollection)
, mNodes(nodes.empty() ? nullptr : &nodes.front())
, mXform(xform)
{
}
void operator()(const tbb::blocked_range<size_t>& range) const {
using PointIndexTree = openvdb::tools::PointIndexGrid::TreeType;
using IndexTreeAccessor = openvdb::tree::ValueAccessor<const PointIndexTree>;
using IndexTreeAccessorPtr = UT_SharedPtr<IndexTreeAccessor>;
UT_UniquePtr<IndexTreeAccessorPtr[]> accessorList(
new IndexTreeAccessorPtr[mIdxGridCollection->size()]);
for (size_t i = 0; i < mIdxGridCollection->size(); ++i) {
const PointIndexTree& tree = mIdxGridCollection->idxGrid(i).tree();
accessorList[i].reset(new IndexTreeAccessor(tree));
}
openvdb::tools::PointIndexIterator<PointIndexTree> pointIndexIter;
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
MaskLeafNodeType& maskNode = *mNodes[n];
if (maskNode.isEmpty()) continue;
const openvdb::CoordBBox nodeBounds = getInclusiveNodeBounds(maskNode);
const openvdb::Vec3d tmpMin = mXform.indexToWorld(nodeBounds.min());
const openvdb::Vec3d tmpMax = mXform.indexToWorld(nodeBounds.max());
const openvdb::Vec3d bMin = openvdb::math::minComponent(tmpMin, tmpMax);
const openvdb::Vec3d bMax = openvdb::math::maxComponent(tmpMin, tmpMax);
bool hasOverlap = false;
for (size_t i = 0; i < mIdxGridCollection->size(); ++i) {
const double sarchRadius = double(mIdxGridCollection->maxRadius(i));
const openvdb::math::Transform& idxGridTransform =
mIdxGridCollection->idxGrid(i).transform();
const openvdb::CoordBBox searchRegion(
idxGridTransform.worldToIndexCellCentered(bMin - sarchRadius),
idxGridTransform.worldToIndexCellCentered(bMax + sarchRadius));
pointIndexIter.searchAndUpdate(searchRegion, *accessorList[i]);
if (pointIndexIter) {
hasOverlap = true;
break;
}
}
if (!hasOverlap) {
maskNode.setValuesOff();
}
}
}
private:
template <typename NodeType>
static inline openvdb::CoordBBox getInclusiveNodeBounds(const NodeType& node)
{
const openvdb::Coord& origin = node.origin();
return openvdb::CoordBBox(origin, origin.offsetBy(NodeType::DIM - 1));
}
PointIndexGridCollection const * const mIdxGridCollection;
MaskLeafNodeType * * const mNodes;
openvdb::math::Transform mXform;
}; // struct CullFrustumLeafNodes
////////////////////////////////////////
///@brief Constructs a region of interest mask for the gather based rasterization.
inline void
maskRegionOfInterest(PointIndexGridCollection::BoolTreeType& mask,
const PointIndexGridCollection& idxGridCollection,
const openvdb::math::Transform& volumeTransform,
bool clipToFrustum = false,
hvdb::Interrupter* interrupter = nullptr)
{
using BoolLeafNodeType = PointIndexGridCollection::BoolTreeType::LeafNodeType;
UT_SharedPtr<openvdb::CoordBBox> frustumClipBox;
if (clipToFrustum && !volumeTransform.isLinear()) {
using MapType = openvdb::math::NonlinearFrustumMap;
MapType::ConstPtr map = volumeTransform.map<MapType>();
if (map) {
const openvdb::BBoxd& bbox = map->getBBox();
frustumClipBox.reset(new openvdb::CoordBBox(
openvdb::Coord::floor(bbox.min()), openvdb::Coord::ceil(bbox.max())));
}
}
for (size_t n = 0; n < idxGridCollection.size(); ++n) {
if (interrupter && interrupter->wasInterrupted()) break;
const PointCache& pointCache = idxGridCollection.pointCache(n);
const PointIndexGridCollection::PointIndexGrid& idxGrid = idxGridCollection.idxGrid(n);
const double voxelSize = idxGrid.transform().voxelSize()[0];
PointIndexGridCollection::PointIndexGrid::Ptr regionPointGridPtr; // optionally used
const PointIndexGridCollection::PointIndexTree* regionPointIndexTree = &idxGrid.tree();
const double maxPointRadius = idxGridCollection.maxRadius(n);
if (maxPointRadius * 1.5 > voxelSize) {
const openvdb::math::Transform::Ptr xform =
openvdb::math::Transform::createLinearTransform(maxPointRadius);
regionPointGridPtr =
openvdb::tools::createPointIndexGrid<PointIndexGridCollection::PointIndexGrid>(
pointCache, *xform);
regionPointIndexTree = ®ionPointGridPtr->tree();
}
std::vector<const PointIndexGridCollection::PointIndexLeafNode*> pointIndexLeafNodes;
pointIndexLeafNodes.reserve(regionPointIndexTree->leafCount());
regionPointIndexTree->getNodes(pointIndexLeafNodes);
ConstructCandidateVoxelMask op(mask, pointCache,
pointIndexLeafNodes, volumeTransform, frustumClipBox.get(), interrupter);
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, pointIndexLeafNodes.size()), op);
}
if (interrupter && interrupter->wasInterrupted()) return;
if (!volumeTransform.isLinear()) {
std::vector<BoolLeafNodeType*> maskNodes;
mask.getNodes(maskNodes);
tbb::parallel_for(tbb::blocked_range<size_t>(0, maskNodes.size()),
CullFrustumLeafNodes<BoolLeafNodeType>(idxGridCollection, maskNodes, volumeTransform));
openvdb::tools::pruneInactive(mask);
}
}
template<typename NodeType>
struct FillActiveValues
{
using ValueType = typename NodeType::ValueType;
FillActiveValues(std::vector<NodeType*>& nodes, ValueType val)
: mNodes(nodes.empty() ? nullptr : &nodes.front()), mValue(val)
{
}
void operator()(const tbb::blocked_range<size_t>& range) const {
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
NodeType& node = *mNodes[n];
for (typename NodeType::ValueOnIter it = node.beginValueOn(); it; ++it) {
it.setValue(mValue);
}
}
}
NodeType * const * const mNodes;
ValueType const mValue;
}; // struct FillActiveValues
/// Fills the @a bbox region with leafnode level tiles.
/// (Partially overlapped leafnode tiles are included)
template<typename TreeAccessorType>
inline void
fillWithLeafLevelTiles(TreeAccessorType& treeAcc, const openvdb::CoordBBox& bbox)
{
using LeafNodeType = typename TreeAccessorType::TreeType::LeafNodeType;
openvdb::Coord imin = bbox.min() & ~(LeafNodeType::DIM - 1);
openvdb::Coord imax = bbox.max() & ~(LeafNodeType::DIM - 1);
openvdb::Coord ijk(0);
for (ijk[0] = imin[0]; ijk[0] <= imax[0]; ijk[0] += LeafNodeType::DIM) {
for (ijk[1] = imin[1]; ijk[1] <= imax[1]; ijk[1] += LeafNodeType::DIM) {
for (ijk[2] = imin[2]; ijk[2] <= imax[2]; ijk[2] += LeafNodeType::DIM) {
treeAcc.addTile(LeafNodeType::LEVEL+1, ijk, true, true);
}
}
}
}
/// Transforms the input @a bbox from an axis-aligned box in @a srcTransform
/// world space to an axis-aligned box i @a targetTransform world space.
openvdb::CoordBBox
remapBBox(openvdb::CoordBBox& bbox, const openvdb::math::Transform& srcTransform,
const openvdb::math::Transform& targetTransform)
{
openvdb::CoordBBox output;
// corner 1
openvdb::Coord ijk = bbox.min();
output.expand(targetTransform.worldToIndexNodeCentered(srcTransform.indexToWorld(ijk)));
// corner 2
ijk = openvdb::Coord(bbox.min().x(), bbox.min().y(), bbox.max().z());
output.expand(targetTransform.worldToIndexNodeCentered(srcTransform.indexToWorld(ijk)));
// corner 3
ijk = openvdb::Coord(bbox.max().x(), bbox.min().y(), bbox.max().z());
output.expand(targetTransform.worldToIndexNodeCentered(srcTransform.indexToWorld(ijk)));
// corner 4
ijk = openvdb::Coord(bbox.max().x(), bbox.min().y(), bbox.min().z());
output.expand(targetTransform.worldToIndexNodeCentered(srcTransform.indexToWorld(ijk)));
// corner 5
ijk = openvdb::Coord(bbox.min().x(), bbox.max().y(), bbox.min().z());
output.expand(targetTransform.worldToIndexNodeCentered(srcTransform.indexToWorld(ijk)));
// corner 6
ijk = openvdb::Coord(bbox.min().x(), bbox.max().y(), bbox.max().z());
output.expand(targetTransform.worldToIndexNodeCentered(srcTransform.indexToWorld(ijk)));
// corner 7
ijk = bbox.max();
output.expand(targetTransform.worldToIndexNodeCentered(srcTransform.indexToWorld(ijk)));
// corner 8
ijk = openvdb::Coord(bbox.max().x(), bbox.max().y(), bbox.min().z());
output.expand(targetTransform.worldToIndexNodeCentered(srcTransform.indexToWorld(ijk)));
return output;
}
////////////////////////////////////////
// Type traits
template<typename T> struct ValueTypeTraits {
static const bool IsVec = false;
static const int TupleSize = 1;
using ScalarType = T;
using HoudiniType = T;
static void convert(T& lhs, const HoudiniType rhs) {
lhs = rhs;
}
};
template<typename T> struct ValueTypeTraits<openvdb::math::Vec3<T> > {
static const bool IsVec = true;
static const int TupleSize = 3;
using ScalarType = T;
using HoudiniType = UT_Vector3T<T>;
static void convert(openvdb::math::Vec3<T>& lhs, const HoudiniType& rhs) {
lhs[0] = rhs[0];
lhs[1] = rhs[1];
lhs[2] = rhs[2];
}
};
////////////////////////////////////////
///@brief Composites point attributes into voxel data using a weighted average approach.
template<typename _ValueType>
struct WeightedAverageOp
{
enum { LOG2DIM = openvdb::tools::PointIndexTree::LeafNodeType::LOG2DIM };
using Ptr = UT_SharedPtr<WeightedAverageOp>;
using ConstPtr = UT_SharedPtr<const WeightedAverageOp>;
using ValueType = _ValueType;
using LeafNodeType = openvdb::tree::LeafNode<ValueType, LOG2DIM>;
using ScalarType = typename ValueTypeTraits<ValueType>::ScalarType;
using HoudiniType = typename ValueTypeTraits<ValueType>::HoudiniType;
/////
WeightedAverageOp(const GA_Attribute& attrib, UT_UniquePtr<LeafNodeType*[]>& nodes)
: mHandle(&attrib), mNodes(nodes.get()), mNode(nullptr), mNodeVoxelData(nullptr)
, mNodeOffset(0), mValue(ScalarType(0.0)), mVaryingDataBuffer(nullptr), mVaryingData(false)
{
}
~WeightedAverageOp() { if (mNode) delete mNode; }
const char* getName() const { return mHandle.getAttribute()->getName(); }
void beginNodeProcessing(const openvdb::Coord& origin, size_t nodeOffset)
{
mVaryingData = false;
mNodeOffset = nodeOffset;
if (mNode) mNode->setOrigin(origin);
else mNode = new LeafNodeType(origin, openvdb::zeroVal<ValueType>());
mNodeVoxelData = const_cast<ValueType*>(&mNode->getValue(0));//mNode->buffer().data();
}
void updateValue(const GA_Offset pointOffset) {
const HoudiniType val = mHandle.get(pointOffset);
ValueTypeTraits<ValueType>::convert(mValue, val);
}
void updateVoxelData(const std::vector<std::pair<float, openvdb::Index> >& densitySamples) {
using DensitySample = std::pair<float, openvdb::Index>;
for (size_t n = 0, N = densitySamples.size(); n < N; ++n) {
const DensitySample& sample = densitySamples[n];
ValueType& value = mNodeVoxelData[sample.second];
if (mVaryingData) {
ValueTypeTraits<ValueType>::convert(mValue, mVaryingDataBuffer[n]);
}
value += mValue * sample.first;
}
}
template<typename LeafNodeT>
void endNodeProcessing(const LeafNodeT& maskNode, float *voxelWeightArray)
{
mNode->topologyUnion(maskNode);
ValueType* values = const_cast<ValueType*>(&mNode->getValue(0));
for (size_t n = 0; n < LeafNodeType::SIZE; ++n) {
values[n] *= voxelWeightArray[n];
}
mNodes[mNodeOffset] = mNode;
mNode = nullptr;
}
HoudiniType* varyingData()
{
mVaryingData = true;
if (!mVaryingDataBuffer) {
mVaryingDataBuffer.reset(new HoudiniType[LeafNodeType::SIZE]);
}
return mVaryingDataBuffer.get();
}
private:
GA_ROHandleT<HoudiniType> mHandle;
LeafNodeType ** const mNodes;
LeafNodeType * mNode;
ValueType * mNodeVoxelData;
size_t mNodeOffset;
ValueType mValue;
UT_UniquePtr<HoudiniType[]> mVaryingDataBuffer;
bool mVaryingData;
}; // struct WeightedAverageOp
///@brief Composites point density into voxel data.
template<typename _ValueType>
struct DensityOp
{
enum { LOG2DIM = openvdb::tools::PointIndexTree::LeafNodeType::LOG2DIM };
using Ptr = UT_SharedPtr<DensityOp>;
using ConstPtr = UT_SharedPtr<const DensityOp>;
using ValueType = _ValueType;
using LeafNodeType = openvdb::tree::LeafNode<ValueType, LOG2DIM>;
/////
DensityOp(const GA_Attribute& attrib, UT_UniquePtr<LeafNodeType*[]>& nodes)
: mPosHandle(&attrib), mNodes(nodes.get()), mNode(nullptr), mNodeOffset(0)
{
}
~DensityOp() { delete mNode; }
void beginNodeProcessing(const openvdb::Coord& origin, size_t nodeOffset)
{
mNodeOffset = nodeOffset;
if (mNode) mNode->setOrigin(origin);
else mNode = new LeafNodeType(origin, openvdb::zeroVal<ValueType>());
}
ValueType* data() {
return const_cast<ValueType*>(&mNode->getValue(0)); /*mNode->buffer().data();*/
}
template<typename LeafNodeT>
void endNodeProcessing(const LeafNodeT& maskNode)
{
mNode->topologyUnion(maskNode);
mNodes[mNodeOffset] = mNode;
mNode = nullptr;
}
private:
GA_ROHandleV3 mPosHandle;
LeafNodeType * * const mNodes;
LeafNodeType * mNode;
size_t mNodeOffset;
}; // struct DensityOp
template<typename ValueType>
inline bool
isValidAttribute(const std::string& name, const GU_Detail& detail)
{
GA_ROAttributeRef ref =
detail.findFloatTuple(GA_ATTRIB_POINT, name.c_str(), ValueTypeTraits<ValueType>::TupleSize);
return ref.isValid();
}
///@brief Wrapper object for Houdini point attributes.
template<typename _ValueType, typename _OperatorType = WeightedAverageOp<_ValueType> >
struct Attribute
{
enum { LOG2DIM = openvdb::tools::PointIndexTree::LeafNodeType::LOG2DIM };
using Ptr = UT_SharedPtr<Attribute>;
using ConstPtr = UT_SharedPtr<const Attribute>;
using OperatorType = _OperatorType;
using ValueType = _ValueType;
using LeafNodeType = openvdb::tree::LeafNode<ValueType, LOG2DIM>;
using BoolLeafNodeType = openvdb::tree::LeafNode<bool, LOG2DIM>;
using Transform = openvdb::math::Transform;
using PointIndexTreeType = openvdb::tools::PointIndexTree;
using TreeType = typename PointIndexTreeType::template ValueConverter<ValueType>::Type;
using GridType = typename openvdb::Grid<TreeType>;
/////
static Ptr create(const std::string& name, const GU_Detail& detail, const Transform& transform)
{
GA_ROAttributeRef ref;
std::string gridName;
if (name == std::string(GEO_STD_ATTRIB_POSITION)) {
ref = detail.getP();
gridName = "density";
} else {
ref = detail.findFloatTuple(
GA_ATTRIB_POINT, name.c_str(), ValueTypeTraits<ValueType>::TupleSize);
gridName = name;
}
if (ref.isValid()) {
return Ptr(new Attribute<ValueType, OperatorType>(
*ref.getAttribute(), gridName, transform));
}
return Ptr();
}
typename OperatorType::Ptr getAccessor()
{
return typename OperatorType::Ptr(new OperatorType(*mAttrib, mNodes));
}
void initNodeBuffer(size_t nodeCount)
{
clearNodes();
if (nodeCount > mNodeCount) {
mNodes.reset(new LeafNodeType*[nodeCount]);
for (size_t n = 0; n < nodeCount; ++n) mNodes[n] = nullptr;
}
mNodeCount = nodeCount;
}
void cacheNodes()
{
mOutputNodes.reserve(std::max(mOutputNodes.size() + 1, mNodeCount));
for (size_t n = 0; n < mNodeCount; ++n) {
if (mNodes[n]) {
mOutputNodes.push_back(mNodes[n]);
mNodes[n] = nullptr;
}
}
}
void cacheFrustumNodes(std::vector<const BoolLeafNodeType*>& nodes, double voxelSize)
{
mOutputNodes.reserve(std::max(mOutputNodes.size() + 1, mNodeCount));
typename GridType::Ptr grid = GridType::create();
IFOPopulateTree op(grid->tree(), mNodes.get());
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, mNodeCount), op);
grid->setTransform(
openvdb::math::Transform::createLinearTransform(voxelSize));
typename GridType::Ptr frustumGrid = GridType::create();
frustumGrid->setTransform(mTransform.copy());
hvdb::Interrupter interrupter;
openvdb::tools::resampleToMatch<openvdb::tools::BoxSampler>(
*grid, *frustumGrid, interrupter);
TreeType& frustumTree = frustumGrid->tree();
for (size_t n = 0, N = nodes.size(); n < N; ++n) {
const BoolLeafNodeType& maskNode = *nodes[n];
LeafNodeType * node = frustumTree.template stealNode<LeafNodeType>(
maskNode.origin(), frustumTree.background(), false);
if (node) {
if (node->getValueMask() != maskNode.getValueMask()) {
typename BoolLeafNodeType::ValueOffCIter it = maskNode.cbeginValueOff();
for (; it; ++it) {
node->setValueOff(it.pos(), frustumTree.background());
}
}
if (node->isEmpty()) {
delete node;
} else {
mOutputNodes.push_back(node);
}
}
} // end node loop
}
void exportGrid(std::vector<openvdb::GridBase::Ptr>& outputGrids)
{
typename GridType::Ptr grid= GridType::create();
IFOPopulateTree op(grid->tree(), mOutputNodes.empty() ? nullptr : &mOutputNodes.front());
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, mOutputNodes.size()), op);
if (!grid->tree().empty()) {
grid->setTransform(mTransform.copy());
grid->setName(mName);
if (mName == std::string("density")) {
grid->setGridClass(openvdb::GRID_FOG_VOLUME);
}
if (ValueTypeTraits<ValueType>::IsVec) {
if (mName == std::string(GEO_STD_ATTRIB_VELOCITY)) {
grid->setVectorType(openvdb::VEC_CONTRAVARIANT_RELATIVE);
} else if (mName == std::string(GEO_STD_ATTRIB_NORMAL)) {
grid->setVectorType(openvdb::VEC_COVARIANT_NORMALIZE);
} else if (mName == std::string(GEO_STD_ATTRIB_POSITION)) {
grid->setVectorType(openvdb::VEC_CONTRAVARIANT_ABSOLUTE);
}
}
outputGrids.push_back(grid);
}
mOutputNodes.clear();
}
~Attribute()
{
clearNodes();
for (size_t n = 0, N = mOutputNodes.size(); n < N; ++n) {
if (mOutputNodes[n] != nullptr) delete mOutputNodes[n];
}
}
private:
void clearNodes()
{
for (size_t n = 0; n < mNodeCount; ++n) {
if (mNodes[n] != nullptr) delete mNodes[n];
}
}
Attribute(const GA_Attribute& attrib, const std::string& name, const Transform& transform)
: mAttrib(&attrib), mName(name), mNodeCount(0), mNodes(nullptr)
, mOutputNodes(), mTransform(transform)
{
}
//////////
// Internal TBB function objects
struct IFOPopulateTree {
IFOPopulateTree(TreeType& tree, LeafNodeType ** nodes)
: mTree(), mAccessor(tree) , mNodes(nodes) {}
IFOPopulateTree(IFOPopulateTree& rhs, tbb::split) // Thread safe copy constructor
: mTree(rhs.mAccessor.tree().background()), mAccessor(mTree), mNodes(rhs.mNodes) {}
void operator()(const tbb::blocked_range<size_t>& range) {
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
if (mNodes[n]) {
mAccessor.addLeaf(mNodes[n]);
mNodes[n] = nullptr;
}
}
}
void join(const IFOPopulateTree& rhs) {
mAccessor.tree().merge(rhs.mAccessor.tree());
}
TreeType mTree;
openvdb::tree::ValueAccessor<TreeType> mAccessor;
LeafNodeType * * const mNodes;
}; // struct IFOPopulateTree
//////////
GA_Attribute const * const mAttrib;
const std::string mName;
size_t mNodeCount;
UT_UniquePtr<LeafNodeType*[]> mNodes;
std::vector<LeafNodeType*> mOutputNodes;
openvdb::math::Transform mTransform;
}; // struct Attribute
// Attribute utility methods
template<typename AttributeType>
inline void
initializeAttributeBuffers(UT_SharedPtr<AttributeType>& attr, size_t nodeCount)
{
if (attr) attr->initNodeBuffer(nodeCount);
}
template<typename AttributeType>
inline void
initializeAttributeBuffers(std::vector<UT_SharedPtr<AttributeType> >& attr, size_t nodeCount)
{
for (size_t n = 0, N = attr.size(); n < N; ++n) {
attr[n]->initNodeBuffer(nodeCount);
}
}
template<typename AttributeType>
inline void
cacheAttributeBuffers(UT_SharedPtr<AttributeType>& attr)
{
if (attr) attr->cacheNodes();
}
template<typename AttributeType>
inline void
cacheAttributeBuffers(std::vector<UT_SharedPtr<AttributeType> >& attr)
{
for (size_t n = 0, N = attr.size(); n < N; ++n) {
attr[n]->cacheNodes();
}
}
template<typename AttributeType, typename LeafNodeType>
inline void
cacheFrustumAttributeBuffers(UT_SharedPtr<AttributeType>& attr,
std::vector<const LeafNodeType*>& nodes, double voxelSize)
{
if (attr) attr->cacheFrustumNodes(nodes, voxelSize);
}
template<typename AttributeType, typename LeafNodeType>
inline void
cacheFrustumAttributeBuffers(std::vector<UT_SharedPtr<AttributeType> >& attr,
std::vector<const LeafNodeType*>& nodes, double voxelSize)
{
for (size_t n = 0, N = attr.size(); n < N; ++n) {
attr[n]->cacheFrustumNodes(nodes, voxelSize);
}
}
template<typename AttributeType>
inline void
exportAttributeGrid(UT_SharedPtr<AttributeType>& attr,
std::vector<openvdb::GridBase::Ptr>& outputGrids)
{
if (attr) attr->exportGrid(outputGrids);
}
template<typename AttributeType>
inline void
exportAttributeGrid(std::vector<UT_SharedPtr<AttributeType> >& attr,
std::vector<openvdb::GridBase::Ptr>& outputGrids)
{
for (size_t n = 0, N = attr.size(); n < N; ++n) {
attr[n]->exportGrid(outputGrids);
}
}
////////////////////////////////////////
// VEX Utilities
struct VEXProgram {
using Ptr = UT_SharedPtr<VEXProgram>;
VEXProgram(OP_Caller& opcaller, const UT_WorkArgs& vexArgs,
fpreal time, size_t maxArraySize, GU_VexGeoInputs& geoinputs)
: mCVEX()
, mRunData()
, mMaxArraySize(maxArraySize)
, mWorldCoordBuffer()
, mNoiseBuffer()
, mVEXLoaded(false)
, mIsTimeDependant(false)
{
mRunData.setOpCaller(&opcaller);
mRunData.setTime(time);
mRunData.setGeoInputs(&geoinputs);
// array attributes
mCVEX.addInput("voxelpos", CVEX_TYPE_VECTOR3, true);
mCVEX.addInput("Time", CVEX_TYPE_FLOAT, false);
mCVEX.addInput("TimeInc", CVEX_TYPE_FLOAT, false);
mCVEX.addInput("Frame", CVEX_TYPE_FLOAT, false);
// uniform attributes
mCVEX.addInput("voxelsize", CVEX_TYPE_FLOAT, false);
mCVEX.addInput("pcenter", CVEX_TYPE_VECTOR3, false);
mCVEX.addInput("pradius", CVEX_TYPE_FLOAT, false);
mCVEX.addInput("pindex", CVEX_TYPE_INTEGER, false);
mVEXLoaded = mCVEX.load(vexArgs.getArgc(), vexArgs.getArgv());
}
void run(size_t arraySize) {
if (mVEXLoaded) {
mRunData.setTimeDependent(false);
mCVEX.run(int(arraySize), false, &mRunData);
mIsTimeDependant = mRunData.isTimeDependent();
}
}
bool isTimeDependant() const { return mIsTimeDependant; }
CVEX_Value* findInput(const char *name, CVEX_Type type) {
return mVEXLoaded ? mCVEX.findInput(name, type) : nullptr;
}
CVEX_Value* findOutput(const char *name, CVEX_Type type) {
return mVEXLoaded ? mCVEX.findOutput(name, type) : nullptr;
}
//////////
// Array buffers
UT_Vector3* getWorldCoordBuffer() {
if (!mWorldCoordBuffer) mWorldCoordBuffer.reset(new UT_Vector3[mMaxArraySize]);
return mWorldCoordBuffer.get();
}
fpreal32* getNoiseBuffer() {
if (!mNoiseBuffer) mNoiseBuffer.reset(new fpreal32[mMaxArraySize]);
return mNoiseBuffer.get();
}
private:
CVEX_Context mCVEX;
CVEX_RunData mRunData;
const size_t mMaxArraySize;
UT_UniquePtr<UT_Vector3[]> mWorldCoordBuffer;
UT_UniquePtr<fpreal32[]> mNoiseBuffer;
bool mVEXLoaded, mIsTimeDependant;
}; // struct VEXProgram
struct VEXContext {
VEXContext(OP_Caller& opcaller, const UT_String& script, size_t maxArraySize)
: mThreadLocalTable()
, mCaller(&opcaller)
, mVexScript(script)
, mVexArgs()
, mMaxArraySize(maxArraySize)
, mTime(0.0f)
, mTimeInc(0.0f)
, mFrame(0.0f)
, mIsTimeDependant()
, mVexInputs()
{
mIsTimeDependant = 0;
mVexScript.parse(mVexArgs);
}
void setTime(fpreal time, fpreal timeinc, fpreal frame) {
mTime = time; mTimeInc = timeinc; mFrame = frame;
}
void setInput(int idx, const GU_Detail *geo) { mVexInputs.setInput(idx, geo); }
VEXProgram& getThereadLocalVEXProgram() {
VEXProgram::Ptr& ptr = mThreadLocalTable.local();
if (!ptr) {
ptr.reset(new VEXProgram(*mCaller, mVexArgs, mTime, mMaxArraySize, mVexInputs));
}
return *ptr;
}
fpreal time() const { return mTime; }
fpreal timeInc() const { return mTimeInc; }
fpreal frame() const { return mFrame; }
void setTimeDependantFlag() { mIsTimeDependant = 1; }
bool isTimeDependant() const { return mIsTimeDependant == 1; }
private:
tbb::enumerable_thread_specific<VEXProgram::Ptr> mThreadLocalTable;
OP_Caller* mCaller;
UT_String mVexScript;
UT_WorkArgs mVexArgs;
const size_t mMaxArraySize;
fpreal mTime, mTimeInc, mFrame;
tbb::atomic<int> mIsTimeDependant;
GU_VexGeoInputs mVexInputs;
};
////////////////////////////////////////
///@brief Gather based point rasterization.
struct RasterizePoints
{
using PosType = PointCache::PosType;
using ScalarType = PosType::value_type;
using PointIndexTree = openvdb::tools::PointIndexGrid::TreeType;
using PointIndexLeafNode = PointIndexTree::LeafNodeType;
using PointIndexType = PointIndexLeafNode::ValueType;
using BoolLeafNodeType = openvdb::tree::LeafNode<bool, PointIndexLeafNode::LOG2DIM>;
using DensityAttribute = Attribute<float, DensityOp<float> >;
using Vec3sAttribute = Attribute<openvdb::Vec3s>;
using FloatAttribute = Attribute<float>;
using DensitySample = std::pair<float, openvdb::Index>;
enum DensityTreatment { ACCUMULATE = 0, MAXIMUM, MINIMUM };
/////
RasterizePoints(const GU_Detail& detail,
const PointIndexGridCollection& idxGridCollection,
std::vector<const BoolLeafNodeType*>& regionMaskLeafNodes,
const openvdb::math::Transform& volumeXform,
DensityTreatment treatment,
const float densityScale = 1.0,
const float solidRatio = 0.0,
hvdb::Interrupter* interrupter = nullptr)
: mDetail(&detail)
, mIdxGridCollection(&idxGridCollection)
, mRegionMaskNodes(®ionMaskLeafNodes.front())
, mInterrupter(interrupter)
, mDensityAttribute(nullptr)
, mVectorAttributes(nullptr)
, mFloatAttributes(nullptr)
, mVEXContext(nullptr)
, mVolumeXform(volumeXform)
, mDensityScale(densityScale)
, mSolidRatio(solidRatio)
, mDensityTreatment(treatment)
{
}
void setDensityAttribute(DensityAttribute * a) { mDensityAttribute = a; }
void setVectorAttributes(std::vector<Vec3sAttribute::Ptr>& v) {
if(!v.empty()) mVectorAttributes = &v;
}
void setFloatAttributes(std::vector<FloatAttribute::Ptr>& v) {
if (!v.empty()) mFloatAttributes = &v;
}
void setVEXContext(VEXContext * v) { mVEXContext = v; }
/////
/// Thread safe copy constructor
RasterizePoints(const RasterizePoints& rhs)
: mDetail(rhs.mDetail)
, mIdxGridCollection(rhs.mIdxGridCollection)
, mRegionMaskNodes(rhs.mRegionMaskNodes)
, mInterrupter(rhs.mInterrupter)
, mDensityAttribute(rhs.mDensityAttribute)
, mVectorAttributes(rhs.mVectorAttributes)
, mFloatAttributes(rhs.mFloatAttributes)
, mVEXContext(rhs.mVEXContext)
, mVolumeXform(rhs.mVolumeXform)
, mDensityScale(rhs.mDensityScale)
, mSolidRatio(rhs.mSolidRatio)
, mDensityTreatment(rhs.mDensityTreatment)
{
}
void operator()(const tbb::blocked_range<size_t>& range) const {
// Setup attribute operators
DensityAttribute::OperatorType::Ptr densityAttribute;
if (mDensityAttribute) densityAttribute = mDensityAttribute->getAccessor();
std::vector<Vec3sAttribute::OperatorType::Ptr> vecAttributes;
if (mVectorAttributes && !mVectorAttributes->empty()) {
vecAttributes.reserve(mVectorAttributes->size());
for (size_t n = 0, N = mVectorAttributes->size(); n < N; ++n) {
vecAttributes.push_back((*mVectorAttributes)[n]->getAccessor());
}
}
std::vector<FloatAttribute::OperatorType::Ptr> floatAttributes;
if (mFloatAttributes && !mFloatAttributes->empty()) {
floatAttributes.reserve(mFloatAttributes->size());
for (size_t n = 0, N = mFloatAttributes->size(); n < N; ++n) {
floatAttributes.push_back((*mFloatAttributes)[n]->getAccessor());
}
}
const bool transferAttributes = !vecAttributes.empty() || !floatAttributes.empty();
// Bind optional density attribute
GA_ROHandleF densityHandle;
GA_ROAttributeRef densityRef = mDetail->findFloatTuple(GA_ATTRIB_POINT, "density", 1);
if (densityRef.isValid()) densityHandle.bind(densityRef.getAttribute());
openvdb::tools::PointIndexIterator<PointIndexTree> pointIndexIter;
using IndexTreeAccessor = openvdb::tree::ValueAccessor<const PointIndexTree>;
using IndexTreeAccessorPtr = UT_SharedPtr<IndexTreeAccessor>;
UT_UniquePtr<IndexTreeAccessorPtr[]> accessorList(
new IndexTreeAccessorPtr[mIdxGridCollection->size()]);
for (size_t i = 0; i < mIdxGridCollection->size(); ++i) {
const PointIndexTree& tree = mIdxGridCollection->idxGrid(i).tree();
accessorList[i].reset(new IndexTreeAccessor(tree));
}
// scratch space
UT_UniquePtr<float[]> voxelWeightArray(new float[BoolLeafNodeType::SIZE]);
std::vector<DensitySample> densitySamples;
densitySamples.reserve(BoolLeafNodeType::SIZE);
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
if (this->wasInterrupted()) {
tbb::task::self().cancel_group_execution();
break;
}
const BoolLeafNodeType& maskNode = *mRegionMaskNodes[n];
if (maskNode.isEmpty()) continue;
const openvdb::Coord& origin = maskNode.origin();
if (transferAttributes) {
memset(voxelWeightArray.get(), 0, BoolLeafNodeType::SIZE * sizeof(float));
}
if (densityAttribute) {
densityAttribute->beginNodeProcessing(origin, n);
}
for (size_t i = 0, I = vecAttributes.size(); i < I; ++i) {
vecAttributes[i]->beginNodeProcessing(origin, n);
}
for (size_t i = 0, I = floatAttributes.size(); i < I; ++i) {
floatAttributes[i]->beginNodeProcessing(origin, n);
}
const openvdb::CoordBBox nodeBoundingBox(
origin, origin.offsetBy(BoolLeafNodeType::DIM - 1));
const openvdb::Vec3d bMin = mVolumeXform.indexToWorld(nodeBoundingBox.min());
const openvdb::Vec3d bMax = mVolumeXform.indexToWorld(nodeBoundingBox.max());
bool transferData = false;
for (size_t i = 0; i < mIdxGridCollection->size(); ++i) {
if (this->wasInterrupted()) break;
const double sarchRadius = double(mIdxGridCollection->maxRadius(i));
const PointCache& pointCache = mIdxGridCollection->pointCache(i);
const openvdb::math::Transform& idxGridTransform =
mIdxGridCollection->idxGrid(i).transform();
const openvdb::CoordBBox searchRegion(
idxGridTransform.worldToIndexCellCentered(bMin - sarchRadius),
idxGridTransform.worldToIndexCellCentered(bMax + sarchRadius));
pointIndexIter.searchAndUpdate(searchRegion, *accessorList[i]);
transferData |= gatherDensityAndAttributes(densityHandle, pointIndexIter,
sarchRadius, pointCache, nodeBoundingBox, densityAttribute, vecAttributes,
floatAttributes, voxelWeightArray, densitySamples);
}
if (transferData && !this->wasInterrupted()) {
if (densityAttribute) densityAttribute->endNodeProcessing(maskNode);
if (transferAttributes) {
for (size_t nn = 0; nn < BoolLeafNodeType::SIZE; ++nn) {
const float weight = (voxelWeightArray[nn] > 0.0f) ?
(1.0f / voxelWeightArray[nn]) : 0.0f;
// Subnormal input values are nonzero but can result in infinite weights.
voxelWeightArray[nn] = openvdb::math::isFinite(weight) ? weight : 0.0f;
}
for (size_t i = 0, I = vecAttributes.size(); i < I; ++i) {
vecAttributes[i]->endNodeProcessing(maskNode, voxelWeightArray.get());
}
for (size_t i = 0, I = floatAttributes.size(); i < I; ++i) {
floatAttributes[i]->endNodeProcessing(maskNode, voxelWeightArray.get());
}
}
}
} // end node loop
} // operator::()
private:
bool wasInterrupted() const { return mInterrupter && mInterrupter->wasInterrupted(); }
bool gatherDensityAndAttributes(
GA_ROHandleF& densityHandle,
openvdb::tools::PointIndexIterator<PointIndexTree>& pointIndexIter,
double sarchRadius,
const PointCache& pointCache,
const openvdb::CoordBBox& nodeBoundingBox,
DensityAttribute::OperatorType::Ptr& densityAttribute,
std::vector<Vec3sAttribute::OperatorType::Ptr>& vecAttributes,
std::vector<FloatAttribute::OperatorType::Ptr>& floatAttributes,
UT_UniquePtr<float[]>& voxelWeightArray,
std::vector<DensitySample>& densitySamples) const
{
const bool hasPointDensity = densityHandle.isValid();
const bool transferVec3sAttributes = !vecAttributes.empty();
const bool transferFloatAttributes = !floatAttributes.empty();
const bool transferAttributes = transferVec3sAttributes || transferFloatAttributes;
bool hasNonzeroDensityValues = false;
VEXProgram * cvex = mVEXContext ? &mVEXContext->getThereadLocalVEXProgram() : nullptr;
ScalarType * const densityData = densityAttribute ? densityAttribute->data() : nullptr;
const bool exportDensity = densityData != nullptr;
const float * pointRadiusData = pointCache.radiusData();
const openvdb::Vec3s * pointPosData = pointCache.posData();
const double dx = mVolumeXform.voxelSize()[0];
const double dxSqr = dx * dx;
openvdb::Coord ijk, pMin, pMax;
PosType xyz;
for (; pointIndexIter; ++pointIndexIter) {
if (this->wasInterrupted()) break;
// Get attribute values for the given point offset
const GA_Offset pointOffset = pointCache.offsetFromIndex(*pointIndexIter);
if (transferVec3sAttributes) {
for (size_t i = 0, I = vecAttributes.size(); i < I; ++i) {
vecAttributes[i]->updateValue(pointOffset);
}
}
if (transferFloatAttributes) {
for (size_t i = 0, I = floatAttributes.size(); i < I; ++i) {
floatAttributes[i]->updateValue(pointOffset);
}
}
// Compute point properties
xyz = pointPosData[*pointIndexIter];
openvdb::Vec3d localPos = mVolumeXform.worldToIndex(xyz);
ScalarType radius = pointRadiusData[*pointIndexIter];
const float radiusSqr = radius * radius;
const ScalarType densityScale =
mDensityScale * (hasPointDensity ? densityHandle.get(pointOffset) : 1.0f);
const ScalarType solidRadius = std::min(radius * mSolidRatio, radius);
const ScalarType residualRadius = std::max(ScalarType(0.0), radius - solidRadius);
const ScalarType invResidualRadius =
residualRadius > 0.0f ? 1.0f / residualRadius : 0.0f;
openvdb::Index xPos(0), yPos(0), pos(0);
double xSqr, ySqr, zSqr;
densitySamples.clear();
// Intersect (point + radius) bbox with leafnode bbox to
// define the overlapping voxel region.
pMin = mVolumeXform.worldToIndexCellCentered(xyz - sarchRadius);
pMax = mVolumeXform.worldToIndexCellCentered(xyz + sarchRadius);
pMin = openvdb::Coord::maxComponent(nodeBoundingBox.min(), pMin);
pMax = openvdb::Coord::minComponent(nodeBoundingBox.max(), pMax);
for (ijk[0] = pMin[0]; ijk[0] <= pMax[0]; ++ijk[0]) {
if (this->wasInterrupted()) break;
xPos = (ijk[0] & (BoolLeafNodeType::DIM - 1u)) << (2 * BoolLeafNodeType::LOG2DIM);
xSqr = localPos[0] - double(ijk[0]);
xSqr *= xSqr;
for (ijk[1] = pMin[1]; ijk[1] <= pMax[1]; ++ijk[1]) {
yPos = xPos + ((ijk[1] & (BoolLeafNodeType::DIM - 1u))
<< BoolLeafNodeType::LOG2DIM);
ySqr = localPos[1] - double(ijk[1]);
ySqr *= ySqr;
for (ijk[2] = pMin[2]; ijk[2] <= pMax[2]; ++ijk[2]) {
pos = yPos + (ijk[2] & (BoolLeafNodeType::DIM - 1u));
zSqr = localPos[2] - double(ijk[2]);
zSqr *= zSqr;
const float distSqr = float( (xSqr + ySqr + zSqr) * dxSqr );
if (distSqr < radiusSqr) {
const float dist = std::sqrt(distSqr) - solidRadius;
const float weight = dist > 0.0f ?
densityScale * (1.0f - invResidualRadius * dist) : densityScale;
if (weight > 0.0f) densitySamples.push_back(DensitySample(weight, pos));
}
}
}
} // end overlapping voxel region loop
hasNonzeroDensityValues |= !densitySamples.empty();
// Apply VEX shader program to density samples
if (cvex && !densitySamples.empty()) {
hasNonzeroDensityValues |= executeVEXShader(*cvex, densitySamples,
exportDensity, vecAttributes, floatAttributes, nodeBoundingBox.min(),
xyz, radius, pointOffset);
}
// Transfer density data to leafnode buffer
if (densityData && mDensityTreatment == MAXIMUM) { // max
for (size_t n = 0, N = densitySamples.size(); n < N; ++n) {
const DensitySample& sample = densitySamples[n];
ScalarType& value = densityData[sample.second];
value = std::max(value, sample.first);
}
} else if (densityData && mDensityTreatment == ACCUMULATE) { // add
for (size_t n = 0, N = densitySamples.size(); n < N; ++n) {
const DensitySample& sample = densitySamples[n];
densityData[sample.second] += sample.first;
}
} else if (densityData && mDensityTreatment == MINIMUM) { // min
for (size_t n = 0, N = densitySamples.size(); n < N; ++n) {
const DensitySample& sample = densitySamples[n];
ScalarType& value = densityData[sample.second];
value = std::min(value, sample.first);
}
}
// Transfer attribute data to leafnode buffers
if (transferAttributes && hasNonzeroDensityValues) {
for (size_t n = 0, N = densitySamples.size(); n < N; ++n) {
const DensitySample& sample = densitySamples[n];
voxelWeightArray[sample.second] += sample.first;
}
for (size_t i = 0, I = vecAttributes.size(); i < I; ++i) {
vecAttributes[i]->updateVoxelData(densitySamples);
}
for (size_t i = 0, I = floatAttributes.size(); i < I; ++i) {
floatAttributes[i]->updateVoxelData(densitySamples);
}
}
} // end point loop
return hasNonzeroDensityValues;
} // end gatherDensityAndAttributes method
bool executeVEXShader(VEXProgram& cvex,
std::vector<DensitySample>& densitySamples,
bool exportDensity,
std::vector<Vec3sAttribute::OperatorType::Ptr>& vecAttributes,
std::vector<FloatAttribute::OperatorType::Ptr>& floatAttributes,
const openvdb::Coord& nodeOrigin,
const PosType& point,
ScalarType radius,
GA_Offset pointOffset) const
{
bool timeDependantVEX = false;
const int numValues = int(densitySamples.size());
if (CVEX_Value* val = cvex.findInput("voxelpos", CVEX_TYPE_VECTOR3)) {
UT_Vector3* data = cvex.getWorldCoordBuffer();
openvdb::Coord coord;
openvdb::Vec3d ws;
for (int n = 0; n < numValues; ++n) {
coord = BoolLeafNodeType::offsetToLocalCoord(densitySamples[n].second);
coord += nodeOrigin;
ws = mVolumeXform.indexToWorld(coord);
UT_Vector3& pointRef = data[n];
pointRef[0] = float(ws[0]);
pointRef[1] = float(ws[1]);
pointRef[2] = float(ws[2]);
}
val->setTypedData(data, numValues);
}
UT_Vector3 particleCenter(point[0], point[1], point[2]);
if (CVEX_Value* val = cvex.findInput("pcenter", CVEX_TYPE_VECTOR3)) {
val->setTypedData(&particleCenter, 1);
}
fpreal32 particleRadius(radius);
if (CVEX_Value* val = cvex.findInput("pradius", CVEX_TYPE_FLOAT)) {
val->setTypedData(&particleRadius, 1);
}
int particleIndex = 0;
if (CVEX_Value* val = cvex.findInput("pindex", CVEX_TYPE_INTEGER)) {
particleIndex = int(mDetail->pointIndex(pointOffset));
val->setTypedData(&particleIndex, 1);
}
fpreal32 voxelSize(1.0f);
if (CVEX_Value* val = cvex.findInput("voxelsize", CVEX_TYPE_FLOAT)) {
voxelSize = fpreal32(mVolumeXform.voxelSize()[0]);
val->setTypedData(&voxelSize, 1);
}
fpreal32 time = fpreal32(mVEXContext->time());
if (CVEX_Value* val = cvex.findInput("Time", CVEX_TYPE_FLOAT)) {
val->setTypedData(&time, 1);
timeDependantVEX = true;
}
fpreal32 timeInc = fpreal32(mVEXContext->timeInc());
if (CVEX_Value* val = cvex.findInput("TimeInc", CVEX_TYPE_FLOAT)) {
val->setTypedData(&timeInc, 1);
timeDependantVEX = true;
}
fpreal32 frame = fpreal32(mVEXContext->frame());
if (CVEX_Value* val = cvex.findInput("Frame", CVEX_TYPE_FLOAT)) {
val->setTypedData(&frame, 1);
timeDependantVEX = true;
}
bool hasNonzeroDensityValues = false, runProcess = false;
fpreal32* densityScales = nullptr;
if (exportDensity) {
if (CVEX_Value* val = cvex.findOutput("output", CVEX_TYPE_FLOAT)) {
runProcess = true;
densityScales = cvex.getNoiseBuffer();
for (int n = 0; n < numValues; ++n) densityScales[n] = 1.0f;
val->setTypedData(densityScales, numValues);
}
}
for (size_t i = 0, I = vecAttributes.size(); i < I; ++i) {
if (CVEX_Value* val = cvex.findOutput(vecAttributes[i]->getName(), CVEX_TYPE_VECTOR3)) {
runProcess = true;
val->setTypedData(vecAttributes[i]->varyingData(), numValues);
}
}
for (size_t i = 0, I = floatAttributes.size(); i < I; ++i) {
if (CVEX_Value* val = cvex.findOutput(floatAttributes[i]->getName(), CVEX_TYPE_FLOAT)) {
runProcess = true;
val->setTypedData(floatAttributes[i]->varyingData(), numValues);
}
}
if (runProcess) {
cvex.run(numValues);
timeDependantVEX |= cvex.isTimeDependant();
if (densityScales) {
for (int n = 0; n < numValues; ++n) {
densitySamples[n].first *= densityScales[n];
hasNonzeroDensityValues |= densitySamples[n].first > 0.0f;
}
}
}
if (timeDependantVEX) mVEXContext->setTimeDependantFlag();
return hasNonzeroDensityValues;
} // end executeVEXShader method
//////////
GU_Detail const * const mDetail;
PointIndexGridCollection const * const mIdxGridCollection;
BoolLeafNodeType const * const * const mRegionMaskNodes;
hvdb::Interrupter * const mInterrupter;
DensityAttribute * mDensityAttribute;
std::vector<Vec3sAttribute::Ptr> * mVectorAttributes;
std::vector<FloatAttribute::Ptr> * mFloatAttributes;
VEXContext * mVEXContext;
openvdb::math::Transform const mVolumeXform;
ScalarType const mDensityScale, mSolidRatio;
DensityTreatment const mDensityTreatment;
}; // struct RasterizePoints
////////////////////////////////////////
/// Collection of rasterization settings
struct RasterizationSettings
{
RasterizationSettings(const GU_Detail& geo, const GA_PointGroup* group, hvdb::Interrupter& in)
: createDensity(true)
, clipToFrustum(true)
, invertMask(false)
, exportPointMask(false)
, densityScale(1.0f)
, particleScale(1.0f)
, solidRatio(0.0f)
, treatment(RasterizePoints::MAXIMUM)
, transform(openvdb::math::Transform::createLinearTransform(0.1))
, pointsGeo(&geo)
, pointGroup(group)
, interrupter(&in)
, vexContext(nullptr)
, scalarAttributeNames()
, vectorAttributeNames()
, maskGrid()
, maskBBox()
, frustumQuality(0.0f)
{
}
inline bool wasInterrupted() { return interrupter->wasInterrupted(); }
// the input value is clipped to [0, 1] range.
void setFrustumQuality(float val) {
frustumQuality = std::max(std::min(val, 1.0f), 0.0f);
}
float getFrustumQuality() const { return frustumQuality; }
bool createDensity, clipToFrustum, invertMask, exportPointMask;
float densityScale, particleScale, solidRatio;
RasterizePoints::DensityTreatment treatment;
openvdb::math::Transform::Ptr transform;
GU_Detail const * const pointsGeo;
GA_PointGroup const * const pointGroup;
hvdb::Interrupter * const interrupter;
VEXContext * vexContext;
std::vector<std::string> scalarAttributeNames;
std::vector<std::string> vectorAttributeNames;
hvdb::GridCPtr maskGrid;
UT_SharedPtr<openvdb::BBoxd> maskBBox;
private:
float frustumQuality;
}; // RasterizationSettings
/// Culls the @a mask region using a user supplied bbox or another grids active voxel topology.
inline void
applyClippingMask(PointIndexGridCollection::BoolTreeType& mask, RasterizationSettings& settings)
{
if (settings.maskBBox) {
if (settings.transform->isLinear()) {
bboxClip(mask, *settings.maskBBox, settings.invertMask, *settings.transform);
} else {
openvdb::CoordBBox maskBBox;
mask.evalActiveVoxelBoundingBox(maskBBox);
openvdb::Vec3d locVoxelSize = computeFrustumVoxelSize(
maskBBox.min().z(), *settings.transform);
openvdb::Vec3d nearPlaneVoxelSize = settings.transform->voxelSize();
const double weight = double(settings.getFrustumQuality());
double voxelSize = linearBlend(nearPlaneVoxelSize.x(), locVoxelSize.x(), weight);
openvdb::math::Transform::Ptr xform =
openvdb::math::Transform::createLinearTransform(voxelSize);
bboxClip(mask, *settings.maskBBox, settings.invertMask,
*settings.transform, xform.get());
}
} else if (settings.maskGrid) {
GridTopologyClipOp<PointIndexGridCollection::BoolTreeType>
op(mask, *settings.transform, settings.invertMask);
settings.maskGrid->apply<hvdb::AllGridTypes>(op);
}
}
inline void
rasterize(RasterizationSettings& settings, std::vector<openvdb::GridBase::Ptr>& outputGrids)
{
using BoolTreeType = PointIndexGridCollection::BoolTreeType;
using BoolLeafNodeType = BoolTreeType::LeafNodeType;
using DensityAttributeType = Attribute<float, DensityOp<float> >;
using Vec3sAttribute = Attribute<openvdb::Vec3s>;
using FloatAttribute = Attribute<float>;
//////////
float partitioningVoxelSize = float(std::max(
settings.transform->voxelSize().x(), settings.transform->voxelSize().z()));
PointIndexGridCollection idxGridCollection(*settings.pointsGeo,
settings.particleScale, partitioningVoxelSize, settings.pointGroup, settings.interrupter);
// setup selected point attributes
DensityAttributeType::Ptr densityAttribute;
if (settings.createDensity) {
densityAttribute = DensityAttributeType::create(
GEO_STD_ATTRIB_POSITION, *settings.pointsGeo, *settings.transform);
}
std::vector<Vec3sAttribute::Ptr> vectorAttributes;
vectorAttributes.reserve(settings.vectorAttributeNames.size());
for (size_t n = 0; n < settings.vectorAttributeNames.size(); ++n) {
Vec3sAttribute::Ptr a = Vec3sAttribute::create(
settings.vectorAttributeNames[n], *settings.pointsGeo, *settings.transform);
if (a) vectorAttributes.push_back(a);
}
std::vector<FloatAttribute::Ptr> scalarAttributes;
scalarAttributes.reserve(settings.scalarAttributeNames.size());
for (size_t n = 0; n < settings.scalarAttributeNames.size(); ++n) {
FloatAttribute::Ptr a = FloatAttribute::create(
settings.scalarAttributeNames[n], *settings.pointsGeo, *settings.transform);
if (a) scalarAttributes.push_back(a);
}
const bool doTransfer = (densityAttribute || !vectorAttributes.empty()
|| !scalarAttributes.empty());
if (!(doTransfer || settings.exportPointMask) || settings.wasInterrupted()) return;
// create region of interest mask
BoolTreeType roiMask;
maskRegionOfInterest(roiMask,
idxGridCollection, *settings.transform, settings.clipToFrustum, settings.interrupter);
applyClippingMask(roiMask, settings);
if (settings.exportPointMask) {
using BoolGridType = openvdb::Grid<BoolTreeType>;
BoolGridType::Ptr exportMask = BoolGridType::create();
exportMask->setTransform(settings.transform->copy());
exportMask->setName("pointmask");
exportMask->tree().topologyUnion(roiMask);
std::vector<BoolLeafNodeType*> maskNodes;
exportMask->tree().getNodes(maskNodes);
tbb::parallel_for(tbb::blocked_range<size_t>(0, maskNodes.size()),
FillActiveValues<BoolLeafNodeType>(maskNodes, true));
outputGrids.push_back(exportMask);
}
if (!doTransfer || settings.wasInterrupted()) return;
std::vector<const BoolLeafNodeType*> maskNodes;
roiMask.getNodes(maskNodes);
if (settings.transform->isLinear()) { // ortho grid rasterization
initializeAttributeBuffers(densityAttribute, maskNodes.size());
initializeAttributeBuffers(vectorAttributes, maskNodes.size());
initializeAttributeBuffers(scalarAttributes, maskNodes.size());
RasterizePoints op(
*settings.pointsGeo,
idxGridCollection,
maskNodes,
*settings.transform,
settings.treatment,
settings.densityScale,
settings.solidRatio,
settings.interrupter);
op.setDensityAttribute(densityAttribute.get());
op.setVectorAttributes(vectorAttributes);
op.setFloatAttributes(scalarAttributes);
op.setVEXContext(settings.vexContext);
tbb::parallel_for(tbb::blocked_range<size_t>(0, maskNodes.size()), op);
cacheAttributeBuffers(densityAttribute);
cacheAttributeBuffers(vectorAttributes);
cacheAttributeBuffers(scalarAttributes);
} else { // frustum grid rasterization
openvdb::Vec3d nearPlaneVoxelSize = settings.transform->voxelSize();
const double sizeWeight = double(settings.getFrustumQuality());
std::sort(maskNodes.begin(), maskNodes.end(), CompZCoord<BoolLeafNodeType>());
size_t nodeIdx = 0;
while (nodeIdx < maskNodes.size()) {
int progress = int(double(nodeIdx) / double(maskNodes.size()) * 100.0);
if (settings.interrupter->wasInterrupted(progress)) {
return;
}
int zCoord = maskNodes[nodeIdx]->origin().z();
openvdb::Vec3d locVoxelSize = computeFrustumVoxelSize(zCoord, *settings.transform);
double voxelSize = linearBlend(nearPlaneVoxelSize.x(), locVoxelSize.x(), sizeWeight);
openvdb::math::Transform::Ptr xform =
openvdb::math::Transform::createLinearTransform(voxelSize);
std::vector<const BoolLeafNodeType*> frustumNodeQueue;
// create subregion mask
BoolTreeType subregionMask(false);
openvdb::tree::ValueAccessor<BoolTreeType> maskAcc(subregionMask);
for (; nodeIdx < maskNodes.size(); ++nodeIdx) {
if (settings.interrupter->wasInterrupted(progress)) {
return;
}
const BoolLeafNodeType& node = *maskNodes[nodeIdx];
openvdb::Vec3d tmpVoxelSize =
computeFrustumVoxelSize(node.origin().z(), *settings.transform);
if (tmpVoxelSize.x() > (locVoxelSize.x() * 2.0)) break;
openvdb::CoordBBox bbox;
node.evalActiveBoundingBox(bbox);
bbox = remapBBox(bbox, *settings.transform, *xform);
bbox.expand(1);
fillWithLeafLevelTiles(maskAcc, bbox);
frustumNodeQueue.push_back(maskNodes[nodeIdx]);
if (subregionMask.activeTileCount() >= 1000000) break;
}
if (subregionMask.empty()) continue;
subregionMask.voxelizeActiveTiles();
std::vector<const BoolLeafNodeType*> subregionNodes;
subregionMask.getNodes(subregionNodes);
size_t subregionNodeCount = subregionNodes.size();
if (subregionNodeCount == 0) continue;
// do subregion rasterization
initializeAttributeBuffers(densityAttribute, subregionNodeCount);
initializeAttributeBuffers(vectorAttributes, subregionNodeCount);
initializeAttributeBuffers(scalarAttributes, subregionNodeCount);
RasterizePoints op(
*settings.pointsGeo,
idxGridCollection,
subregionNodes,
*xform,
settings.treatment,
settings.densityScale,
settings.solidRatio,
settings.interrupter);
op.setDensityAttribute(densityAttribute.get());
op.setVectorAttributes(vectorAttributes);
op.setFloatAttributes(scalarAttributes);
op.setVEXContext(settings.vexContext);
tbb::parallel_for(tbb::blocked_range<size_t>(0, subregionNodeCount), op);
cacheFrustumAttributeBuffers(densityAttribute, frustumNodeQueue, voxelSize);
cacheFrustumAttributeBuffers(vectorAttributes, frustumNodeQueue, voxelSize);
cacheFrustumAttributeBuffers(scalarAttributes, frustumNodeQueue, voxelSize);
}
}
if (!settings.wasInterrupted()) {
exportAttributeGrid(densityAttribute, outputGrids);
exportAttributeGrid(vectorAttributes, outputGrids);
exportAttributeGrid(scalarAttributes, outputGrids);
}
}
////////////////////////////////////////
/// Populates the @a scalarAttribNames and @a vectorAttribNames lists.
inline void
getAttributeNames(
const std::string& attributeNames,
const GU_Detail& geo,
std::vector<std::string>& scalarAttribNames,
std::vector<std::string>& vectorAttribNames,
bool createVelocityAttribute,
UT_ErrorManager* log = nullptr)
{
if (attributeNames.empty() && !createVelocityAttribute) {
return;
}
std::vector<std::string> allNames;
hboost::algorithm::split(allNames, attributeNames, hboost::is_any_of(", "));
std::set<std::string> uniqueNames(allNames.begin(), allNames.end());
if (createVelocityAttribute) {
uniqueNames.insert("v");
}
std::vector<std::string> skipped;
for (const std::string& name: uniqueNames) {
GA_ROAttributeRef attr = geo.findFloatTuple(GA_ATTRIB_POINT, name.c_str(), 1, 1);
if (attr.isValid()) {
scalarAttribNames.push_back(name);
} else {
attr = geo.findFloatTuple(GA_ATTRIB_POINT, name.c_str(), 3);
if (attr.isValid()) {
vectorAttribNames.push_back(name);
} else {
skipped.push_back(name);
}
}
}
if (!skipped.empty() && log) {
log->addWarning(SOP_OPTYPE_NAME, SOP_MESSAGE, ("Unable to rasterize attribute(s): " +
hboost::algorithm::join(skipped, ", ")).c_str());
log->addWarning(SOP_OPTYPE_NAME, SOP_MESSAGE, "Only supporting point-rate attributes "
"of scalar or vector type with floating-point values.");
}
}
/// Returns a null pointer if geoPt is null or if no reference vdb is found.
inline openvdb::math::Transform::Ptr
getReferenceTransform(const GU_Detail* geoPt, const GA_PrimitiveGroup* group = nullptr,
UT_ErrorManager* log = nullptr)
{
if (geoPt) {
hvdb::VdbPrimCIterator vdbIt(geoPt, group);
if (vdbIt) {
return (*vdbIt)->getGrid().transform().copy();
} else if (log) {
log->addWarning(SOP_OPTYPE_NAME, SOP_MESSAGE, "Could not find a reference VDB grid");
}
}
return openvdb::math::Transform::Ptr();
}
////////////////////////////////////////
inline int
lookupAttrInput(const PRM_SpareData* spare)
{
const char *istring;
if (!spare) return 0;
istring = spare->getValue("sop_input");
return istring ? atoi(istring) : 0;
}
inline void
populateMeshMenu(void* data, PRM_Name* choicenames, int themenusize,
const PRM_SpareData* spare, const PRM_Parm*)
{
choicenames[0].setToken(0);
choicenames[0].setLabel(0);
SOP_Node* sop = CAST_SOPNODE(static_cast<OP_Node*>(data));
if (sop == nullptr) return;
size_t count = 0;
try {
const int inputIndex = lookupAttrInput(spare);
const GU_Detail* gdp = sop->getInputLastGeo(inputIndex, CHgetEvalTime());
if (gdp) {
GA_AttributeDict::iterator iter = gdp->pointAttribs().begin(GA_SCOPE_PUBLIC);
size_t maxSize(themenusize - 1);
std::vector<std::string> scalarNames, vectorNames;
scalarNames.reserve(gdp->pointAttribs().entries(GA_SCOPE_PUBLIC));
vectorNames.reserve(scalarNames.capacity());
for (; !iter.atEnd(); ++iter) {
GA_Attribute const * const attrib = iter.attrib();
if (attrib->getStorageClass() == GA_STORECLASS_FLOAT) {
const int tupleSize = attrib->getTupleSize();
const UT_StringHolder& attribName = attrib->getName();
if (tupleSize == 1) scalarNames.push_back(attribName.buffer());
else if (tupleSize == 3) vectorNames.push_back(attribName.buffer());
}
}
std::sort(scalarNames.begin(), scalarNames.end());
for (size_t n = 0, N = scalarNames.size(); n < N && count < maxSize; ++n) {
const char * str = scalarNames[n].c_str();
if (std::strcmp(str, "density") != 0) {
choicenames[count].setToken(str);
choicenames[count++].setLabel(str);
}
}
if (!scalarNames.empty() && !vectorNames.empty() && count < maxSize) {
choicenames[count].setToken(PRM_Name::mySeparator);
choicenames[count++].setLabel(PRM_Name::mySeparator);
}
std::sort(vectorNames.begin(), vectorNames.end());
for (size_t n = 0, N = vectorNames.size(); n < N && count < maxSize; ++n) {
choicenames[count].setToken(vectorNames[n].c_str());
choicenames[count++].setLabel(vectorNames[n].c_str());
}
}
} catch (...) {}
// Terminate the list.
choicenames[count].setToken(0);
choicenames[count].setLabel(0);
}
} // unnamed namespace
////////////////////////////////////////
// SOP Implementation
struct SOP_OpenVDB_Rasterize_Points: public hvdb::SOP_NodeVDB
{
SOP_OpenVDB_Rasterize_Points(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
// Overriding these are what allow us to contain VOPs
using hvdb::SOP_NodeVDB::evalVariableValue;
bool evalVariableValue(UT_String &value, int index, int thread) override;
OP_OperatorFilter* getOperatorFilter() override { return mCodeGenerator.getOperatorFilter(); }
const char* getChildType() const override { return VOP_OPTYPE_NAME; }
OP_OpTypeId getChildTypeID() const override { return VOP_OPTYPE_ID; }
VOP_CodeGenerator* getVopCodeGenerator() override { return &mCodeGenerator; }
void opChanged(OP_EventType reason, void *data = 0) override;
bool hasVexShaderParameter(const char* name) override {
return mCodeGenerator.hasShaderParameter(name);
}
int isRefInput(unsigned i) const override { return i > 0; }
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
bool updateParmsFlags() override;
/// VOP and VEX functions
void finishedLoadingNetwork(bool is_child_call = false) override;
void addNode(OP_Node *node, int notify = 1, int explicitly = 1) override;
void ensureSpareParmsAreUpdatedSubclass() override;
VOP_CodeGenerator mCodeGenerator;
int mInitialParmNum;
}; // struct SOP_OpenVDB_Rasterize_Points
////////////////////////////////////////
// VEX related methods
bool
SOP_OpenVDB_Rasterize_Points::evalVariableValue(UT_String &value, int index, int thread)
{
if (mCodeGenerator.getVariableString(index, value)) return true;
// else delegate to base class
return SOP_Node::evalVariableValue(value, index, thread);
}
void
SOP_OpenVDB_Rasterize_Points::opChanged(OP_EventType reason, void *data)
{
int update_id = mCodeGenerator.beginUpdate();
SOP_Node::opChanged(reason, data);
mCodeGenerator.ownerChanged(reason, data);
mCodeGenerator.endUpdate(update_id);
}
void
SOP_OpenVDB_Rasterize_Points::finishedLoadingNetwork(bool is_child_call)
{
mCodeGenerator.ownerFinishedLoadingNetwork();
SOP_Node::finishedLoadingNetwork(is_child_call);
}
void
SOP_OpenVDB_Rasterize_Points::addNode(OP_Node *node, int notify, int explicitly)
{
mCodeGenerator.beforeAddNode(node);
SOP_Node::addNode(node, notify, explicitly);
mCodeGenerator.afterAddNode(node);
}
void
SOP_OpenVDB_Rasterize_Points::ensureSpareParmsAreUpdatedSubclass()
{
// Check if the spare parameter templates are out-of-date.
if (getVopCodeGenerator() && eventMicroNode(OP_SPAREPARM_MODIFIED).requiresUpdate(0.0)) {
// Call into the code generator to update the spare parameter templates.
getVopCodeGenerator()->exportedParmsManager()->updateOwnerSpareParmLayout();
}
}
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "pointgroup", "Point Group")
.setChoiceList(&SOP_Node::pointGroupMenu)
.setTooltip("A group of points to rasterize."));
parms.add(hutil::ParmFactory(PRM_STRING, "transformvdb", "Transform VDB")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("VDB grid that defines the output transform"));
parms.add(hutil::ParmFactory(PRM_STRING, "maskvdb", "Mask VDB")
.setChoiceList(&hutil::PrimGroupMenuInput3)
.setTooltip("VDB grid whose active topology defines what region to rasterize into"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "invertmask", "Invert Mask")
.setDefault(PRMzeroDefaults)
.setTooltip("Toggle to rasterize in the region outside the mask."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxelsize", "Voxel Size")
.setDefault(PRMpointOneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 5)
.setTooltip("Uniform voxel edge length in world units. "
"Decrease the voxel size to increase the volume resolution."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "frustumquality", "Frustum Quality")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_RESTRICTED, 10)
.setTooltip(
"1 is the standard quality and is fast. 10 is the highest quality;"
" everything is rasterized at the frustum near-plane resolution "
" and filtered down to frustum resolution, which can be slow."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "cliptofrustum", "Clip to Frustum")
.setDefault(PRMoneDefaults)
.setTooltip(
"When using a frustum transform, only rasterize data inside the frustum region."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "createdensity", "Create Density Volume")
.setDefault(PRMoneDefaults)
.setTooltip("Toggle to enable or disable the density volume generation. "
"Attribute volumes are still constructed as usual."));
{ // density compositing
char const * const items[] = {
"add", "Add",
"max", "Maximum",
nullptr
};
parms.add(hutil::ParmFactory(PRM_ORD, "compositing", "Density Merge")
.setDefault(PRMoneDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip("How to blend point densities in the density volume")
.setDocumentation(
"How to blend point densities in the density volume\n\n"
"Add:\n"
" Sum densities at each voxel.\n"
"Maximum:\n"
" Choose the maximum density at each voxel.\n"));
}
parms.add(hutil::ParmFactory(PRM_FLT_J, "densityscale", "Density Scale")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10)
.setTooltip("Scale the density attribute by this amount."
" If the density attribute is missing, use a value of one as the reference.")
.setDocumentation("Scale the `density` attribute by this amount."
" If the `density` attribute is missing, use a value of one as the reference."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "particlescale", "Particle Scale")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10)
.setTooltip(
"Scale the pscale point attribute, which defines the world-space"
" particle radius, by this amount. If the pscale attribute is missing,"
" use a value of one.")
.setDocumentation(
"Scale the `pscale` point attribute, which defines the world-space"
" particle radius, by this amount. If the `pscale` attribute is missing,"
" use a value of one."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "solidratio", "Solid Ratio")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_RESTRICTED, 1)
.setTooltip("Specify the amount of the particle that gets full density. "
"0 means only the very center of the particle will have full density. "
"1 means the entire particle out to the radius will have full density."));
parms.add(hutil::ParmFactory(PRM_STRING, "attributes", "Attributes")
.setChoiceList(new PRM_ChoiceList(PRM_CHOICELIST_TOGGLE, populateMeshMenu))
.setTooltip(
"Specify a list of floating-point or vector point attributes"
" to be rasterized using weighted-average blending."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "exportpointmask", "Export Point Mask")
.setDefault(PRMzeroDefaults)
.setDocumentation(
"If enabled, output the point mask used in the rasterization operation."));
/////
parms.add(hutil::ParmFactory(PRM_HEADING,"noiseheading", ""));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "modeling", "Enable VEX Processing")
.setDefault(PRMzeroDefaults)
.setTooltip("Use the contained VOP network to define a VEX procedure that "
"determines density and attribute values."));
hvdb::OpenVDBOpFactory("VDB Rasterize Points",
SOP_OpenVDB_Rasterize_Points::factory, parms, *table)
.setNativeName("")
.setOperatorTable(VOP_TABLE_NAME)
.setLocalVariables(VOP_CodeGenerator::theLocalVariables)
.addInput("Points to rasterize")
.addOptionalInput("Optional VDB grid that defines the output transform.")
.addOptionalInput("Optional VDB or bounding box mask.")
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Rasterize points into density and attribute volumes.\"\"\"\n\
\n\
@overview\n\
\n\
This node rasterizes points into density and attribute grids.\n\
It has an accompanying creation script that adds a default VOP subnetwork\n\
and UI parameters for cloud and velocity field modeling.\n\
\n\
@related\n\
- [Node:sop/cloud]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
bool
SOP_OpenVDB_Rasterize_Points::updateParmsFlags()
{
bool changed = false;
const bool refexists = getInput(1) != nullptr;
changed |= enableParm("voxelsize", !refexists);
changed |= enableParm("transformvdb", refexists);
changed |= enableParm("cliptofrustum", refexists);
changed |= enableParm("frustumquality", refexists);
const bool maskexists = getInput(2) != nullptr;
changed |= enableParm("maskvdb", maskexists);
changed |= enableParm("invertmask", maskexists);
changed |= enableParm("compositing", bool(evalInt("createdensity", 0, 0)));
const bool createDensity = evalInt("createdensity", 0, 0) != 0;
const bool transferAttributes = !evalStdString("attributes", 0).empty();
const bool enableVEX = createDensity || transferAttributes;
changed |= enableParm("modeling", enableVEX);
/*const bool proceduralModeling = evalInt("modeling", 0, 0) != 0 && enableVEX;
for (int i = mInitialParmNum; i < this->getParmList()->getEntries(); ++i) {
changed |= enableParm(i, proceduralModeling);
}*/
return changed;
}
OP_Node*
SOP_OpenVDB_Rasterize_Points::factory(OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Rasterize_Points(net, name, op);
}
SOP_OpenVDB_Rasterize_Points::SOP_OpenVDB_Rasterize_Points(OP_Network* net,
const char* name, OP_Operator* op)
: hvdb::SOP_NodeVDB(net, name, op)
, mCodeGenerator(this, new VOP_LanguageContextTypeList(VOP_LANGUAGE_VEX, VOP_CVEX_SHADER), 1, 1)
, mInitialParmNum(this->getParmList()->getEntries())
{
}
OP_ERROR
SOP_OpenVDB_Rasterize_Points::cookVDBSop(OP_Context& context)
{
try {
hutil::ScopedInputLock lock(*this, context);
gdp->clearAndDestroy();
UT_ErrorManager* log = UTgetErrorManager();
// Get UI parameters
const fpreal time = context.getTime();
const fpreal samplesPerSec = OPgetDirector()->getChannelManager()->getSamplesPerSec();
const fpreal timeinc = samplesPerSec > 0.0f ? 1.0f / samplesPerSec : 0.0f;
const fpreal frame = OPgetDirector()->getChannelManager()->getSample(time);
const fpreal densityScale = evalFloat("densityscale", 0, time);
const fpreal particleScale = evalFloat("particlescale", 0, time);
const fpreal solidRatio = evalFloat("solidratio", 0, time);
const exint compositing = evalInt("compositing", 0, time);
float voxelSize = float(evalFloat("voxelsize", 0, time));
const bool clipToFrustum = evalInt("cliptofrustum", 0, time) == 1;
const bool invertMask = evalInt("invertmask", 0, time) == 1;
// Remap the frustum quality control from [1, 10] range to [0, 1] range.
// (The [0, 1] range is perceived poorly in the UI. Base quality 0 looks bad.)
const fpreal frustumQuality = (evalFloat("frustumquality", 0, time) - 1.0) / 9.0;
const GU_Detail* pointsGeo = inputGeo(0);
const GA_PointGroup* pointGroup = parsePointGroups(
evalStdString("pointgroup", time).c_str(), GroupCreator(pointsGeo));
const GU_Detail* refGeo = inputGeo(1);
const GA_PrimitiveGroup* refGroup = nullptr;
if (refGeo) {
refGroup = parsePrimitiveGroups(
evalStdString("transformvdb", time).c_str(), GroupCreator(refGeo));
}
const GU_Detail* maskGeo = inputGeo(2);
const GA_PrimitiveGroup* maskGroup = nullptr;
bool expectingVDBMask = false;
if (maskGeo) {
const auto groupStr = evalStdString("maskvdb", time);
if (!groupStr.empty()) {
expectingVDBMask = true;
}
maskGroup = parsePrimitiveGroups(groupStr.c_str(), GroupCreator(maskGeo));
}
const bool exportPointMask = 0 != evalInt("exportpointmask", 0, time);
const bool createDensity = 0 != evalInt("createdensity", 0, time);
const bool applyVEX = evalInt("modeling", 0, time);
const bool createVelocityAttribute = applyVEX &&
hasParm("process_velocity") && evalInt("process_velocity", 0, time) == 1;
// Get selected point attribute names
std::vector<std::string> scalarAttribNames;
std::vector<std::string> vectorAttribNames;
getAttributeNames(evalStdString("attributes", time), *pointsGeo,
scalarAttribNames, vectorAttribNames, createVelocityAttribute, log);
if (exportPointMask || createDensity || !scalarAttribNames.empty()
|| !vectorAttribNames.empty())
{
hvdb::Interrupter boss("Rasterizing points");
// Set rasterization settings
openvdb::math::Transform::Ptr xform = getReferenceTransform(refGeo, refGroup, log);
if (xform) voxelSize = float(xform->voxelSize().x());
UT_SharedPtr<openvdb::BBoxd> maskBBox;
hvdb::GridCPtr maskGrid = getMaskVDB(maskGeo, maskGroup);
if (!maskGrid) {
if (expectingVDBMask) {
addWarning(SOP_MESSAGE, "VDB mask not found.");
} else {
maskBBox = getMaskGeoBBox(maskGeo);
}
}
RasterizationSettings settings(*pointsGeo, pointGroup, boss);
settings.createDensity = createDensity;
settings.exportPointMask = exportPointMask;
settings.densityScale = float(densityScale);
settings.particleScale = float(particleScale);
settings.solidRatio = float(solidRatio);
settings.transform = xform ?
xform : openvdb::math::Transform::createLinearTransform(double(voxelSize));
settings.vectorAttributeNames.swap(vectorAttribNames);
settings.scalarAttributeNames.swap(scalarAttribNames);
settings.treatment = compositing == 0 ?
RasterizePoints::ACCUMULATE : RasterizePoints::MAXIMUM;
settings.setFrustumQuality(float(frustumQuality));
settings.clipToFrustum = clipToFrustum;
settings.maskBBox = maskBBox;
settings.maskGrid = maskGrid;
settings.invertMask = invertMask;
// Setup VEX context
OP_Caller caller(this, context.getContextOptionsStack(),
context.getContextOptions());
UT_SharedPtr<VEXContext> vexContextPtr;
if (applyVEX) {
UT_String shoppath = "", script = "op:";
getFullPath(shoppath);
script += shoppath;
buildVexCommand(script, getSpareParmTemplates(), time);
vexContextPtr.reset(new VEXContext(caller, script,
PointIndexGridCollection::BoolTreeType::LeafNodeType::SIZE));
vexContextPtr->setTime(time, timeinc, frame);
vexContextPtr->setInput(0, pointsGeo);
}
settings.vexContext = vexContextPtr.get();
// Rasterize attributes and export VDB grids
std::vector<openvdb::GridBase::Ptr> outputGrids;
rasterize(settings, outputGrids);
if (vexContextPtr && vexContextPtr->isTimeDependant()) {
OP_Node::flags().setTimeDep(true);
}
for (size_t n = 0, N = outputGrids.size(); n < N && !boss.wasInterrupted(); ++n) {
hvdb::createVdbPrimitive(*gdp, outputGrids[n]);
}
} else {
addWarning(SOP_MESSAGE, "No output selected");
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 118,964 | C++ | 34.186335 | 100 | 0.600442 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Sample_Points.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Sample_Points.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Samples OpenVDB grid values as attributes on spatially located particles.
/// Currently the grid values can be scalar (float, double) or vec3 (float, double)
/// but the attributes on the particles are single precision scalar or vec3
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/PointUtils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/Interpolation.h> // for box sampler
#include <openvdb/points/PointCount.h>
#include <openvdb/points/PointSample.h>
#include <openvdb/points/IndexFilter.h> // for MultiGroupFilter
#include <tbb/tick_count.h> // for timing
#include <tbb/task.h> // for cancel
#include <UT/UT_Interrupt.h>
#include <GA/GA_PageHandle.h>
#include <GA/GA_PageIterator.h>
#include <hboost/algorithm/string/join.hpp>
#include <algorithm>
#include <iostream>
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace cvdb = openvdb;
class SOP_OpenVDB_Sample_Points: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Sample_Points(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Sample_Points() override {}
static OP_Node* factory(OP_Network*, const char*, OP_Operator*);
// The VDB port holds read-only VDBs.
int isRefInput(unsigned input) const override { return (input == 1); }
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
};
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("A subset of the input VDBs to sample")
.setDocumentation("A subset of the input VDBs to sample"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "vdbpointsgroups", "VDB Points Groups")
.setTooltip("Subsets of VDB points to sample onto")
.setDocumentation(
"Subsets of VDB points to sample onto\n\n"
"See [Node:sop/vdbpointsgroup] for details on grouping VDB points.\n\n"
"This parameter has no effect if there are no input VDB point data primitives.")
.setChoiceList(&hvdb::VDBPointsGroupMenuInput1));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "renamevel", "Rename Vel to V")
.setDefault(PRMzeroDefaults)
.setDocumentation("If an input VDB's name is \"`vel`\", name the point attribute \"`v`\".")
.setTooltip("If an input VDB's name is \"vel\", name the point attribute \"v\"."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "attributeexists", "Report Existing Attributes")
.setDefault(PRMzeroDefaults)
.setTooltip("Display a warning if a point attribute being sampled into already exists."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "verbose", "Verbose")
.setDefault(PRMzeroDefaults)
.setTooltip("Print the sequence of operations to the terminal."));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "threaded", "Multi-threading"));
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep2", "Separator"));
// Register the SOP
hvdb::OpenVDBOpFactory("VDB Sample Points",
SOP_OpenVDB_Sample_Points::factory, parms, *table)
.setNativeName("")
.setObsoleteParms(obsoleteParms)
.addInput("Points")
.addInput("VDBs")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Sample_Points::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Sample VDB voxel values onto points.\"\"\"\n\
\n\
@overview\n\
\n\
This node samples VDB voxel values into point attributes, where the points\n\
may be either standard Houdini points or points stored in VDB point data grids.\n\
Currently, the voxel values can be single- or double-precision scalars or vectors,\n\
but the attributes on the points will be single-precision only.\n\
\n\
Point attributes are given the same names as the VDBs from which they are sampled.\n\
\n\
@related\n\
- [OpenVDB From Particles|Node:sop/DW_OpenVDBFromParticles]\n\
- [Node:sop/vdbfromparticles]\n\
- [Node:sop/convertvdbpoints]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Sample_Points::factory(OP_Network* net, const char* name, OP_Operator *op)
{
return new SOP_OpenVDB_Sample_Points(net, name, op);
}
SOP_OpenVDB_Sample_Points::SOP_OpenVDB_Sample_Points(
OP_Network* net, const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
namespace {
using StringSet = std::set<std::string>;
using StringVec = std::vector<std::string>;
using AttrNameMap = std::map<std::string /*gridName*/, StringSet /*attrNames*/>;
using PointGridPtrVec = std::vector<openvdb::points::PointDataGrid::Ptr>;
struct VDBPointsSampler
{
VDBPointsSampler(PointGridPtrVec& points,
const StringVec& includeGroups,
const StringVec& excludeGroups,
AttrNameMap& existingAttrs)
: mPointGrids(points)
, mIncludeGroups(includeGroups)
, mExcludeGroups(excludeGroups)
, mExistingAttrs(existingAttrs) {}
template <typename GridType>
inline void
pointSample(const hvdb::Grid& sourceGrid,
const std::string& attributeName,
hvdb::Interrupter* interrupter)
{
warnOnExisting(attributeName);
const GridType& grid = UTvdbGridCast<GridType>(sourceGrid);
for (auto& pointGrid : mPointGrids) {
auto leaf = pointGrid->tree().cbeginLeaf();
if (!leaf) continue;
cvdb::points::MultiGroupFilter filter(
mIncludeGroups, mExcludeGroups, leaf->attributeSet());
cvdb::points::pointSample(*pointGrid, grid, attributeName, filter, interrupter);
}
}
template <typename GridType>
inline void
boxSample(const hvdb::Grid& sourceGrid,
const std::string& attributeName,
hvdb::Interrupter* interrupter)
{
warnOnExisting(attributeName);
const GridType& grid = UTvdbGridCast<GridType>(sourceGrid);
for (auto& pointGrid : mPointGrids) {
auto leaf = pointGrid->tree().cbeginLeaf();
if (!leaf) continue;
cvdb::points::MultiGroupFilter filter(
mIncludeGroups, mExcludeGroups, leaf->attributeSet());
cvdb::points::boxSample(*pointGrid, grid, attributeName, filter, interrupter);
}
}
private:
inline void
warnOnExisting(const std::string& attributeName) const
{
for (const auto& pointGrid : mPointGrids) {
assert(pointGrid);
const auto leaf = pointGrid->tree().cbeginLeaf();
if (!leaf) continue;
if (leaf->hasAttribute(attributeName)) {
mExistingAttrs[pointGrid->getName()].insert(attributeName);
}
}
}
const PointGridPtrVec& mPointGrids;
const StringVec& mIncludeGroups;
const StringVec& mExcludeGroups;
AttrNameMap& mExistingAttrs;
};
template <bool staggered = false>
struct BoxSampler {
template <class Accessor>
static bool sample(const Accessor& in, const cvdb::Vec3R& inCoord,
typename Accessor::ValueType& result)
{
return cvdb::tools::BoxSampler::sample<Accessor>(in, inCoord, result);
}
};
template<>
struct BoxSampler<true> {
template <class Accessor>
static bool sample(const Accessor& in, const cvdb::Vec3R& inCoord,
typename Accessor::ValueType& result)
{
return cvdb::tools::StaggeredBoxSampler::sample<Accessor>(in, inCoord, result);
}
};
template <bool staggered = false>
struct NearestNeighborSampler {
template <class Accessor>
static bool sample(const Accessor& in, const cvdb::Vec3R& inCoord,
typename Accessor::ValueType& result)
{
return cvdb::tools::PointSampler::sample<Accessor>(in, inCoord, result);
}
};
template<>
struct NearestNeighborSampler<true> {
template <class Accessor>
static bool sample(const Accessor& in, const cvdb::Vec3R& inCoord,
typename Accessor::ValueType& result)
{
return cvdb::tools::StaggeredPointSampler::sample<Accessor>(in, inCoord, result);
}
};
template<
typename GridType,
typename GA_RWPageHandleType,
bool staggered = false,
bool NearestNeighbor = false>
class PointSampler
{
public:
using Accessor = typename GridType::ConstAccessor;
// constructor. from grid and GU_Detail*
PointSampler(const hvdb::Grid& grid, const bool threaded,
GU_Detail* gdp, GA_RWAttributeRef& handle,
hvdb::Interrupter* interrupter):
mGrid(grid),
mThreaded(threaded),
mGdp(gdp),
mAttribPageHandle(handle.getAttribute()),
mInterrupter(interrupter)
{
}
// constructor. from other
PointSampler(const PointSampler<GridType, GA_RWPageHandleType, staggered>& other):
mGrid(other.mGrid),
mThreaded(other.mThreaded),
mGdp(other.mGdp),
mAttribPageHandle(other.mAttribPageHandle),
mInterrupter(other.mInterrupter)
{
}
void sample()
{
mInterrupter->start();
if (mThreaded) {
// multi-threaded
UTparallelFor(GA_SplittableRange(mGdp->getPointRange()), *this);
} else {
// single-threaded
(*this)(GA_SplittableRange(mGdp->getPointRange()));
}
mInterrupter->end();
}
// only the supported versions don't throw
void operator() (const GA_SplittableRange& range) const
{
if (mInterrupter->wasInterrupted()) {
tbb::task::self().cancel_group_execution();
}
const GridType& grid = UTvdbGridCast<GridType>(mGrid);
// task local grid accessor
Accessor accessor = grid.getAccessor();
// sample scalar data onto points
typename GridType::ValueType value;
cvdb::Vec3R point;
GA_ROPageHandleV3 p_ph(mGdp->getP());
GA_RWPageHandleType v_ph = mAttribPageHandle;
if(!v_ph.isValid()) {
throw std::runtime_error("new attribute not valid");
}
// iterate over pages in the range
for (GA_PageIterator pit = range.beginPages(); !pit.atEnd(); ++pit) {
GA_Offset start;
GA_Offset end;
// per-page setup
p_ph.setPage(*pit);
v_ph.setPage(*pit);
// iterate over elements in the page
for (GA_Iterator it(pit.begin()); it.blockAdvance(start, end); ) {
for (GA_Offset offset = start; offset < end; ++offset ) {
// get the pos.
UT_Vector3 pos = p_ph.get(offset);
// find the interpolated value
point = mGrid.worldToIndex(cvdb::Vec3R(pos[0], pos[1], pos[2]));
if (NearestNeighbor) {
NearestNeighborSampler<staggered>::template sample<Accessor>(
accessor, point, value);
} else {
BoxSampler<staggered>::template sample<Accessor>(accessor, point, value);
}
// set the value
v_ph.value(offset) = translateValue(value);
}
}
}
}
template<typename T> inline static float translateValue(const T& vdb_value) {
return static_cast<float>(vdb_value);
}
inline static UT_Vector3 translateValue(cvdb::Vec3f& vdb_value) {
return UT_Vector3(vdb_value[0], vdb_value[1], vdb_value[2]);
}
inline static UT_Vector3 translateValue(cvdb::Vec3d& vdb_value) {
return UT_Vector3(
static_cast<float>(vdb_value[0]),
static_cast<float>(vdb_value[1]),
static_cast<float>(vdb_value[2]));
}
private:
// member data
const hvdb::Grid& mGrid;
bool mThreaded;
GU_Detail* mGdp;
GA_RWPageHandleType mAttribPageHandle;
hvdb::Interrupter* mInterrupter;
}; // class PointSampler
} // anonymous namespace
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Sample_Points::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
GU_Detail* aGdp = gdp; // where the points live
const GU_Detail* bGdp = inputGeo(1, context); // where the grids live
// extract UI data
const bool verbose = evalInt("verbose", 0, time) != 0;
const bool threaded = true; /*evalInt("threaded", 0, time);*/
// total number of points in vdb grids - this is used when verbose execution is
// requested, but will otherwise remain 0
size_t nVDBPoints = 0;
StringVec includeGroups, excludeGroups;
UT_String vdbPointsGroups;
// obtain names of vdb point groups to include / exclude
evalString(vdbPointsGroups, "vdbpointsgroups", 0, time);
cvdb::points::AttributeSet::Descriptor::parseNames(includeGroups, excludeGroups,
vdbPointsGroups.toStdString());
// extract VDB points grids
PointGridPtrVec pointGrids;
for (openvdb_houdini::VdbPrimIterator it(gdp); it; ++it) {
GU_PrimVDB* vdb = *it;
if (!vdb || !vdb->getConstGridPtr()->isType<cvdb::points::PointDataGrid>()) continue;
vdb->makeGridUnique();
cvdb::GridBase::Ptr grid = vdb->getGridPtr();
cvdb::points::PointDataGrid::Ptr pointDataGrid =
cvdb::gridPtrCast<cvdb::points::PointDataGrid>(grid);
if (verbose) {
if (auto leaf = pointDataGrid->tree().cbeginLeaf()) {
cvdb::points::MultiGroupFilter filter(includeGroups, excludeGroups,
leaf->attributeSet());
nVDBPoints += cvdb::points::pointCount<cvdb::points::PointDataTree,
cvdb::points::MultiGroupFilter>(pointDataGrid->tree(), filter);
}
}
pointGrids.emplace_back(pointDataGrid);
}
const GA_Size nPoints = aGdp->getNumPoints();
// sanity checks - warn if there are no points on first input port. Note that
// each VDB primitive should have a single point associated with it so that we could
// theoretically only check if nPoints == 0, but we explictly check for 0 pointGrids
// for the sake of clarity
if (nPoints == 0 && pointGrids.empty()) {
const std::string msg = "Input 1 contains no points.";
addWarning(SOP_MESSAGE, msg.c_str());
if (verbose) std::cout << msg << std::endl;
}
// Get the group of grids to process
const GA_PrimitiveGroup* group = matchGroup(*bGdp, evalStdString("group", time));
// These lists are used to keep track of names of already-existing point attributes.
StringSet existingPointAttrs;
AttrNameMap existingVdbPointAttrs;
VDBPointsSampler vdbPointsSampler(pointGrids, includeGroups, excludeGroups,
existingVdbPointAttrs);
// scratch variables used in the loop
GA_Defaults defaultFloat(0.0), defaultInt(0);
int numScalarGrids = 0;
int numVectorGrids = 0;
int numUnnamedGrids = 0;
// start time
tbb::tick_count time_start = tbb::tick_count::now();
UT_AutoInterrupt progress("Sampling from VDB grids");
for (hvdb::VdbPrimCIterator it(bGdp, group); it; ++it) {
if (progress.wasInterrupted()) {
throw std::runtime_error("was interrupted");
}
const GU_PrimVDB* vdb = *it;
UT_VDBType gridType = vdb->getStorageType();
const hvdb::Grid& grid = vdb->getGrid();
std::string gridName = it.getPrimitiveName().toStdString();
if (gridName.empty()) {
std::stringstream ss;
ss << "VDB_" << numUnnamedGrids++;
gridName = ss.str();
}
// remove any dot "." characters, attribute names can't contain this.
std::replace(gridName.begin(), gridName.end(), '.', '_');
std::string attributeName;
if (gridName == "vel" && evalInt("renamevel", 0, time)) {
attributeName = "v";
} else {
attributeName = gridName;
}
//convert gridName to uppercase so we can use it as a local variable name
std::string attributeVariableName = attributeName;
std::transform(attributeVariableName.begin(), attributeVariableName.end(),
attributeVariableName.begin(), ::toupper);
if (gridType == UT_VDB_FLOAT || gridType == UT_VDB_DOUBLE) {
// a grid that holds a scalar field (as either float or double type)
// count
numScalarGrids++;
//find or create float attribute
GA_RWAttributeRef attribHandle =
aGdp->findFloatTuple(GA_ATTRIB_POINT, attributeName.c_str(), 1);
if (!attribHandle.isValid()) {
attribHandle = aGdp->addFloatTuple(
GA_ATTRIB_POINT, attributeName.c_str(), 1, defaultFloat);
} else {
existingPointAttrs.insert(attributeName);
}
aGdp->addVariableName(attributeName.c_str(), attributeVariableName.c_str());
// user feedback
if (verbose) {
std::cout << "Sampling grid " << gridName << " of type "
<< grid.valueType() << std::endl;
}
hvdb::Interrupter scalarInterrupt("Sampling from VDB floating-type grids");
// do the sampling
if (gridType == UT_VDB_FLOAT) {
// float scalar
PointSampler<cvdb::FloatGrid, GA_RWPageHandleF> theSampler(
grid, threaded, aGdp, attribHandle, &scalarInterrupt);
theSampler.sample();
vdbPointsSampler.boxSample<cvdb::FloatGrid>(
grid, attributeName, &scalarInterrupt);
} else {
// double scalar
PointSampler<cvdb::DoubleGrid, GA_RWPageHandleF> theSampler(
grid, threaded, aGdp, attribHandle, &scalarInterrupt);
theSampler.sample();
vdbPointsSampler.boxSample<cvdb::DoubleGrid>(
grid, attributeName, &scalarInterrupt);
}
} else if (gridType == UT_VDB_INT32 || gridType == UT_VDB_INT64) {
numScalarGrids++;
//find or create integer attribute
GA_RWAttributeRef attribHandle =
aGdp->findIntTuple(GA_ATTRIB_POINT, attributeName.c_str(), 1);
if (!attribHandle.isValid()) {
attribHandle =
aGdp->addIntTuple(GA_ATTRIB_POINT, attributeName.c_str(), 1, defaultInt);
} else {
existingPointAttrs.insert(attributeName);
}
aGdp->addVariableName(attributeName.c_str(), attributeVariableName.c_str());
// user feedback
if (verbose) {
std::cout << "Sampling grid " << gridName << " of type "
<< grid.valueType() << std::endl;
}
hvdb::Interrupter scalarInterrupt("Sampling from VDB integer-type grids");
if (gridType == UT_VDB_INT32) {
PointSampler<cvdb::Int32Grid, GA_RWPageHandleF, false, true>
theSampler(grid, threaded, aGdp, attribHandle, &scalarInterrupt);
theSampler.sample();
vdbPointsSampler.pointSample<cvdb::Int32Grid>(
grid, attributeName, &scalarInterrupt);
} else {
PointSampler<cvdb::Int64Grid, GA_RWPageHandleF, false, true>
theSampler(grid, threaded, aGdp, attribHandle, &scalarInterrupt);
theSampler.sample();
vdbPointsSampler.pointSample<cvdb::Int64Grid>(
grid, attributeName, &scalarInterrupt);
}
} else if (gridType == UT_VDB_VEC3F || gridType == UT_VDB_VEC3D) {
// a grid that holds Vec3 data (as either float or double)
// count
numVectorGrids++;
// find or create create vector attribute
GA_RWAttributeRef attribHandle =
aGdp->findFloatTuple(GA_ATTRIB_POINT, attributeName.c_str(), 3);
if (!attribHandle.isValid()) {
attribHandle = aGdp->addFloatTuple(
GA_ATTRIB_POINT, attributeName.c_str(), 3, defaultFloat);
} else {
existingPointAttrs.insert(attributeName);
}
aGdp->addVariableName(attributeName.c_str(), attributeVariableName.c_str());
std::unique_ptr<hvdb::Interrupter> interrupter;
// user feedback
if (grid.getGridClass() != cvdb::GRID_STAGGERED) {
// regular (non-staggered) vec3 grid
if (verbose) {
std::cout << "Sampling grid " << gridName << " of type "
<< grid.valueType() << std::endl;
}
interrupter.reset(new hvdb::Interrupter("Sampling from VDB vector-type grids"));
// do the sampling
if (gridType == UT_VDB_VEC3F) {
// Vec3f
PointSampler<cvdb::Vec3fGrid, GA_RWPageHandleV3> theSampler(
grid, threaded, aGdp, attribHandle, interrupter.get());
theSampler.sample();
} else {
// Vec3d
PointSampler<cvdb::Vec3dGrid, GA_RWPageHandleV3> theSampler(
grid, threaded, aGdp, attribHandle, interrupter.get());
theSampler.sample();
}
} else {
// staggered grid case
if (verbose) {
std::cout << "Sampling staggered grid " << gridName << " of type "
<< grid.valueType() << std::endl;
}
interrupter.reset(new hvdb::Interrupter(
"Sampling from VDB vector-type staggered grids"));
// do the sampling
if (grid.isType<cvdb::Vec3fGrid>()) {
// Vec3f
PointSampler<cvdb::Vec3fGrid, GA_RWPageHandleV3, true> theSampler(
grid, threaded, aGdp, attribHandle, interrupter.get());
theSampler.sample();
} else {
// Vec3d
PointSampler<cvdb::Vec3dGrid, GA_RWPageHandleV3, true> theSampler(
grid, threaded, aGdp, attribHandle, interrupter.get());
theSampler.sample();
}
}
// staggered vector sampling is handled within the core library for vdb points
if (gridType == UT_VDB_VEC3F) {
vdbPointsSampler.boxSample<cvdb::Vec3fGrid>(
grid, attributeName, interrupter.get());
} else {
vdbPointsSampler.boxSample<cvdb::Vec3dGrid>(
grid, attributeName, interrupter.get());
}
} else {
addWarning(SOP_MESSAGE, ("Skipped VDB \"" + gridName
+ "\" of unsupported type " + grid.valueType()).c_str());
}
}//end iter
if (0 != evalInt("attributeexists", 0, time)) {
// Report existing Houdini point attributes.
existingPointAttrs.erase("");
if (existingPointAttrs.size() == 1) {
addWarning(SOP_MESSAGE, ("Point attribute \"" + *existingPointAttrs.begin()
+ "\" already exists").c_str());
} else if (!existingPointAttrs.empty()) {
const StringVec attrNames(existingPointAttrs.begin(), existingPointAttrs.end());
const std::string s = "These point attributes already exist: " +
hboost::algorithm::join(attrNames, ", ");
addWarning(SOP_MESSAGE, s.c_str());
}
// Report existing VDB Points attributes and the grids in which they appear.
for (auto& attrs: existingVdbPointAttrs) {
auto& attrSet = attrs.second;
attrSet.erase("");
if (attrSet.size() == 1) {
addWarning(SOP_MESSAGE, ("Attribute \"" + *attrSet.begin()
+ "\" already exists in VDB point data grid \""
+ attrs.first + "\".").c_str());
} else if (!attrSet.empty()) {
const StringVec attrNames(attrSet.begin(), attrSet.end());
const std::string s = "These attributes already exist in VDB point data grid \""
+ attrs.first + "\": " + hboost::algorithm::join(attrNames, ", ");
addWarning(SOP_MESSAGE, s.c_str());
}
}
}
// timing: end time
tbb::tick_count time_end = tbb::tick_count::now();
if (verbose) {
std::cout << "Sampling " << nPoints + nVDBPoints << " points in "
<< numVectorGrids << " vector grid" << (numVectorGrids == 1 ? "" : "s")
<< " and " << numScalarGrids << " scalar grid"
<< (numScalarGrids == 1 ? "" : "s")
<< " took " << (time_end - time_start).seconds() << " seconds\n "
<< (threaded ? "threaded" : "non-threaded") << std::endl;
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 27,270 | C++ | 36.511692 | 100 | 0.56729 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Ray.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Ray.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Performs geometry projections using level set ray intersections or closest point queries.
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb/tools/RayIntersector.h>
#include <openvdb/tools/VolumeToSpheres.h> // for ClosestSurfacePoint
#include <GA/GA_PageHandle.h>
#include <GA/GA_SplittableRange.h>
#include <GU/GU_Detail.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_Interrupt.h>
#include <hboost/algorithm/string/join.hpp>
#include <limits>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
class SOP_OpenVDB_Ray: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Ray(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Ray() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i > 0); }
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
};
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to process.")
.setDocumentation(
"A subset of VDBs to process (see [specifying volumes|/model/volumes#group])"));
// Method
parms.add(hutil::ParmFactory(PRM_ORD, "method", "Method")
.setDefault(PRMzeroDefaults)
.setTooltip("Projection method")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"rayintersection", "Ray Intersection",
"closestpoint", "Closest Surface Point"
}));
parms.add(hutil::ParmFactory(PRM_FLT_J, "isovalue", "Isovalue")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_UI, -1.0, PRM_RANGE_UI, 1.0)
.setTooltip(
"The voxel value that defines the surface\n\n"
"Zero works for signed distance fields, while fog volumes require"
" a larger positive value (0.5 is a good initial guess)."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "dotrans", "Transform")
.setDefault(PRMoneDefaults)
.setTooltip("If enabled, transform the intersected geometry."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "scale", "Scale")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_UI, 0, PRM_RANGE_UI, 1)
.setTooltip("Specify the amount by which to scale the intersected geometry."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "putdist", "Store Distances")
.setTooltip(
"Create a point attribute giving the distance to the"
" collision surface or to the closest surface point."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "lookfar", "Intersect Farthest Surface")
.setTooltip("Use the farthest intersection point instead of the closest."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "reverserays", "Reverse Rays")
.setTooltip("Make rays fire in the direction opposite to the normals."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "bias", "Bias")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_UI, 0, PRM_RANGE_UI, 1)
.setTooltip("Offset the starting position of the rays."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "creategroup", "Create Ray Hit Group")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("If enabled, create a point group to hold all successful intersections"));
parms.add(hutil::ParmFactory(PRM_STRING, "hitgrp", "Ray Hit Group")
.setDefault("rayHitGroup")
.setTooltip("Point group name"));
//////////
hvdb::OpenVDBOpFactory("VDB Ray", SOP_OpenVDB_Ray::factory, parms, *table)
.addInput("points")
.addInput("level set grids")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Ray::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Project geometry onto a level set VDB volume.\"\"\"\n\
\n\
@overview\n\
\n\
This node performs geometry projections using level set ray intersections\n\
or closest point queries.\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
OP_Node*
SOP_OpenVDB_Ray::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Ray(net, name, op);
}
SOP_OpenVDB_Ray::SOP_OpenVDB_Ray(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
bool
SOP_OpenVDB_Ray::updateParmsFlags()
{
bool changed = false;
bool rayintersection = evalInt("method", 0, 0) == 0;
changed |= enableParm("isovalue", !rayintersection);
changed |= enableParm("lookfar", rayintersection);
changed |= enableParm("reverserays", rayintersection);
changed |= enableParm("creategroup", rayintersection);
changed |= enableParm("bias", rayintersection);
changed |= enableParm("scale", bool(evalInt("dotrans", 0, 0)));
bool creategroup = evalInt("creategroup", 0, 0);
changed |= enableParm("hitgrp", creategroup && rayintersection);
return changed;
}
////////////////////////////////////////
template<typename GridType>
class IntersectPoints
{
public:
IntersectPoints(
const GU_Detail& gdp,
const UT_Vector3Array& pointNormals,
const GridType& grid,
UT_Vector3Array& positions,
UT_FloatArray& distances,
std::vector<char>& intersections,
bool keepMaxDist = false,
bool reverseRays = false,
double scale = 1.0,
double bias = 0.0)
: mGdp(gdp)
, mPointNormals(pointNormals)
, mIntersector(grid)
, mPositions(positions)
, mDistances(distances)
, mIntersections(intersections)
, mKeepMaxDist(keepMaxDist)
, mReverseRays(reverseRays)
, mScale(scale)
, mBias(bias)
{
}
void operator()(const GA_SplittableRange &range) const
{
GA_Offset start, end;
GA_Index pointIndex;
using RayT = openvdb::math::Ray<double>;
openvdb::Vec3d eye, dir, intersection;
const bool doScaling = !openvdb::math::isApproxEqual(mScale, 1.0);
const bool offsetRay = !openvdb::math::isApproxEqual(mBias, 0.0);
GA_ROPageHandleV3 points(mGdp.getP());
// Iterate over blocks
for (GA_Iterator it(range); it.blockAdvance(start, end); ) {
points.setPage(start);
// Point Offsets
for (GA_Offset pointOffset = start; pointOffset < end; ++pointOffset) {
const UT_Vector3& pos = points.value(pointOffset);
eye[0] = double(pos.x());
eye[1] = double(pos.y());
eye[2] = double(pos.z());
pointIndex = mGdp.pointIndex(pointOffset);
const UT_Vector3& normal = mPointNormals(pointIndex);
dir[0] = double(normal.x());
dir[1] = double(normal.y());
dir[2] = double(normal.z());
if (mReverseRays) dir = -dir;
RayT ray((offsetRay ? (eye + dir * mBias) : eye), dir);
if (!mIntersector.intersectsWS(ray, intersection)) {
if (!mIntersections[pointIndex]) mPositions(pointIndex) = pos;
continue;
}
float distance = float((intersection - eye).length());
if ((!mKeepMaxDist && mDistances(pointIndex) > distance) ||
(mKeepMaxDist && mDistances(pointIndex) < distance)) {
mDistances(pointIndex) = distance;
UT_Vector3& position = mPositions(pointIndex);
if (doScaling) intersection = eye + dir * mScale * double(distance);
position.x() = float(intersection[0]);
position.y() = float(intersection[1]);
position.z() = float(intersection[2]);
}
mIntersections[pointIndex] = 1;
}
}
}
private:
const GU_Detail& mGdp;
const UT_Vector3Array& mPointNormals;
openvdb::tools::LevelSetRayIntersector<GridType> mIntersector;
UT_Vector3Array& mPositions;
UT_FloatArray& mDistances;
std::vector<char>& mIntersections;
const bool mKeepMaxDist, mReverseRays;
const double mScale, mBias;
};
template<typename GridT, typename InterrupterT>
inline void
closestPoints(const GridT& grid, float isovalue, const GU_Detail& gdp,
UT_FloatArray& distances, UT_Vector3Array* positions, InterrupterT& boss)
{
std::vector<openvdb::Vec3R> tmpPoints(distances.entries());
GA_ROHandleV3 points = GA_ROHandleV3(gdp.getP());
for (size_t n = 0, N = tmpPoints.size(); n < N; ++n) {
const UT_Vector3 pos = points.get(gdp.pointOffset(n));
tmpPoints[n][0] = pos.x();
tmpPoints[n][1] = pos.y();
tmpPoints[n][2] = pos.z();
}
std::vector<float> tmpDistances;
const bool transformPoints = (positions != nullptr);
auto closestPoint = openvdb::tools::ClosestSurfacePoint<GridT>::create(grid, isovalue, &boss);
if (!closestPoint) return;
if (transformPoints) closestPoint->searchAndReplace(tmpPoints, tmpDistances);
else closestPoint->search(tmpPoints, tmpDistances);
for (size_t n = 0, N = tmpDistances.size(); n < N; ++n) {
if (tmpDistances[n] < distances(n)) {
distances(n) = tmpDistances[n];
if (transformPoints) {
UT_Vector3& pos = (*positions)(n);
pos.x() = float(tmpPoints[n].x());
pos.y() = float(tmpPoints[n].y());
pos.z() = float(tmpPoints[n].z());
}
}
}
}
class ScalePositions
{
public:
ScalePositions(
const GU_Detail& gdp,
UT_Vector3Array& positions,
UT_FloatArray& distances,
double scale = 1.0)
: mGdp(gdp)
, mPositions(positions)
, mDistances(distances)
, mScale(scale)
{
}
void operator()(const GA_SplittableRange &range) const
{
GA_Offset start, end;
GA_Index pointIndex;
UT_Vector3 dir;
GA_ROPageHandleV3 points(mGdp.getP());
// Iterate over blocks
for (GA_Iterator it(range); it.blockAdvance(start, end); ) {
points.setPage(start);
// Point Offsets
for (GA_Offset pointOffset = start; pointOffset < end; ++pointOffset) {
pointIndex = mGdp.pointIndex(pointOffset);
const UT_Vector3& point = points.value(pointOffset);
UT_Vector3& pos = mPositions(pointIndex);
dir = pos - point;
dir.normalize();
pos = point + dir * mDistances(pointIndex) * mScale;
}
}
}
private:
const GU_Detail& mGdp;
UT_Vector3Array& mPositions;
UT_FloatArray& mDistances;
const double mScale;
};
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Ray::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
hvdb::Interrupter boss("Computing VDB ray intersections");
const GU_Detail* vdbGeo = inputGeo(1);
if (vdbGeo == nullptr) return error();
// Get the group of grids to surface.
const GA_PrimitiveGroup* group = matchGroup(*vdbGeo, evalStdString("group", time));
hvdb::VdbPrimCIterator vdbIt(vdbGeo, group);
if (!vdbIt) {
addWarning(SOP_MESSAGE, "No VDB grids found.");
return error();
}
// Eval attributes
const bool keepMaxDist = bool(evalInt("lookfar", 0, time));
const bool reverseRays = bool(evalInt("reverserays", 0, time));
const bool rayIntersection = evalInt("method", 0, time) == 0;
const double scale = double(evalFloat("scale", 0, time));
const double bias = double(evalFloat("bias", 0, time));
const float isovalue = float(evalFloat("isovalue", 0, time));
UT_Vector3Array pointNormals;
GA_ROAttributeRef attributeRef = gdp->findPointAttribute("N");
if (attributeRef.isValid()) {
gdp->getAttributeAsArray(
attributeRef.getAttribute(), gdp->getPointRange(), pointNormals);
} else {
gdp->normal(pointNormals, /*use_internaln=*/false);
}
const size_t numPoints = gdp->getNumPoints();
UT_Vector3Array positions(numPoints);
std::vector<char> intersections(numPoints);
const double limit = std::numeric_limits<double>::max();
UT_FloatArray distances;
distances.appendMultiple(
float((keepMaxDist && rayIntersection) ? -limit : limit), numPoints);
std::vector<std::string> skippedGrids;
for (; vdbIt; ++vdbIt) {
if (boss.wasInterrupted()) break;
if (vdbIt->getGrid().getGridClass() == openvdb::GRID_LEVEL_SET &&
vdbIt->getGrid().type() == openvdb::FloatGrid::gridType()) {
openvdb::FloatGrid::ConstPtr gridPtr =
openvdb::gridConstPtrCast<openvdb::FloatGrid>(vdbIt->getGridPtr());
if (rayIntersection) {
IntersectPoints<openvdb::FloatGrid> op(
*gdp, pointNormals, *gridPtr, positions, distances,
intersections, keepMaxDist, reverseRays, scale, bias);
UTparallelFor(GA_SplittableRange(gdp->getPointRange()), op);
} else {
closestPoints(*gridPtr, isovalue, *gdp, distances, &positions, boss);
}
} else {
skippedGrids.push_back(vdbIt.getPrimitiveNameOrIndex().toStdString());
continue;
}
}
if (bool(evalInt("dotrans", 0, time))) { // update point positions
if (!rayIntersection && !openvdb::math::isApproxEqual(scale, 1.0)) {
UTparallelFor(GA_SplittableRange(gdp->getPointRange()),
ScalePositions(*gdp, positions, distances, scale));
}
gdp->setPos3FromArray(gdp->getPointRange(), positions);
}
if (bool(evalInt("putdist", 0, time))) { // add distance attribute
GA_RWAttributeRef aRef = gdp->findPointAttribute("dist");
if (!aRef.isValid()) {
aRef = gdp->addFloatTuple(GA_ATTRIB_POINT, "dist", 1, GA_Defaults(0.0));
}
gdp->setAttributeFromArray(aRef.getAttribute(), gdp->getPointRange(), distances);
}
if (rayIntersection && bool(evalInt("creategroup", 0, time))) { // group intersecting points
const auto groupStr = evalStdString("hitgrp", time);
if (!groupStr.empty()) {
GA_PointGroup *pointGroup = gdp->findPointGroup(groupStr.c_str());
if (!pointGroup) pointGroup = gdp->newPointGroup(groupStr.c_str());
for (size_t n = 0; n < numPoints; ++n) {
if (intersections[n]) pointGroup->addIndex(n);
}
}
}
if (!skippedGrids.empty()) {
std::string s = "Only level set grids are supported, the following "
"were skipped: '" + hboost::algorithm::join(skippedGrids, ", ") + "'.";
addWarning(SOP_MESSAGE, s.c_str());
}
if (boss.wasInterrupted()) {
addWarning(SOP_MESSAGE, "Process was interrupted");
}
boss.end();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 16,126 | C++ | 30.436647 | 100 | 0.595932 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/AttributeTransferUtil.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file AttributeTransferUtil.h
/// @author FX R&D Simulation team
/// @brief Utility methods used by the From/To Polygons and From Particles SOPs
#ifndef OPENVDB_HOUDINI_ATTRIBUTE_TRANSFER_UTIL_HAS_BEEN_INCLUDED
#define OPENVDB_HOUDINI_ATTRIBUTE_TRANSFER_UTIL_HAS_BEEN_INCLUDED
#include "Utils.h"
#include <openvdb/openvdb.h>
#include <openvdb/math/Proximity.h>
#include <openvdb/util/Util.h>
#include <GA/GA_PageIterator.h>
#include <GA/GA_SplittableRange.h>
#include <GEO/GEO_PrimPolySoup.h>
#include <SYS/SYS_Types.h>
#include <algorithm> // for std::sort()
#include <cmath> // for std::floor()
#include <limits>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
namespace openvdb_houdini {
////////////////////////////////////////
/// Get OpenVDB specific value, by calling GA_AIFTuple::get()
/// with appropriate arguments.
template <typename ValueType> inline ValueType
evalAttr(const GA_Attribute* atr, const GA_AIFTuple* aif,
GA_Offset off, int idx)
{
fpreal64 value;
aif->get(atr, off, value, idx);
return ValueType(value);
}
template <> inline float
evalAttr<float>(const GA_Attribute* atr, const GA_AIFTuple* aif,
GA_Offset off, int idx)
{
fpreal32 value;
aif->get(atr, off, value, idx);
return float(value);
}
template <> inline openvdb::Int32
evalAttr<openvdb::Int32>(const GA_Attribute* atr, const GA_AIFTuple* aif,
GA_Offset off, int idx)
{
int32 value;
aif->get(atr, off, value, idx);
return openvdb::Int32(value);
}
template <> inline openvdb::Int64
evalAttr<openvdb::Int64>(const GA_Attribute* atr, const GA_AIFTuple* aif,
GA_Offset off, int idx)
{
int64 value;
aif->get(atr, off, value, idx);
return openvdb::Int64(value);
}
template <> inline openvdb::Vec3i
evalAttr<openvdb::Vec3i>(const GA_Attribute* atr, const GA_AIFTuple* aif,
GA_Offset off, int)
{
openvdb::Vec3i vec;
int32 comp;
aif->get(atr, off, comp, 0);
vec[0] = openvdb::Int32(comp);
aif->get(atr, off, comp, 1);
vec[1] = openvdb::Int32(comp);
aif->get(atr, off, comp, 2);
vec[2] = openvdb::Int32(comp);
return vec;
}
template <> inline openvdb::Vec3s
evalAttr<openvdb::Vec3s>(const GA_Attribute* atr, const GA_AIFTuple* aif,
GA_Offset off, int)
{
openvdb::Vec3s vec;
fpreal32 comp;
aif->get(atr, off, comp, 0);
vec[0] = float(comp);
aif->get(atr, off, comp, 1);
vec[1] = float(comp);
aif->get(atr, off, comp, 2);
vec[2] = float(comp);
return vec;
}
template <> inline openvdb::Vec3d
evalAttr<openvdb::Vec3d>(const GA_Attribute* atr, const GA_AIFTuple* aif,
GA_Offset off, int)
{
openvdb::Vec3d vec;
fpreal64 comp;
aif->get(atr, off, comp, 0);
vec[0] = double(comp);
aif->get(atr, off, comp, 1);
vec[1] = double(comp);
aif->get(atr, off, comp, 2);
vec[2] = double(comp);
return vec;
}
////////////////////////////////////////
/// Combine different value types.
template <typename ValueType> inline ValueType
combine(const ValueType& v0, const ValueType& v1, const ValueType& v2,
const openvdb::Vec3d& w)
{
return ValueType(v0 * w[0] + v1 * w[1] + v2 * w[2]);
}
template <> inline openvdb::Int32
combine(const openvdb::Int32& v0, const openvdb::Int32& v1,
const openvdb::Int32& v2, const openvdb::Vec3d& w)
{
if (w[2] > w[0] && w[2] > w[1]) return v2;
if (w[1] > w[0] && w[1] > w[2]) return v1;
return v0;
}
template <> inline openvdb::Int64
combine(const openvdb::Int64& v0, const openvdb::Int64& v1,
const openvdb::Int64& v2, const openvdb::Vec3d& w)
{
if (w[2] > w[0] && w[2] > w[1]) return v2;
if (w[1] > w[0] && w[1] > w[2]) return v1;
return v0;
}
template <> inline openvdb::Vec3i
combine(const openvdb::Vec3i& v0, const openvdb::Vec3i& v1,
const openvdb::Vec3i& v2, const openvdb::Vec3d& w)
{
if (w[2] > w[0] && w[2] > w[1]) return v2;
if (w[1] > w[0] && w[1] > w[2]) return v1;
return v0;
}
template <> inline openvdb::Vec3s
combine(const openvdb::Vec3s& v0, const openvdb::Vec3s& v1,
const openvdb::Vec3s& v2, const openvdb::Vec3d& w)
{
openvdb::Vec3s vec;
vec[0] = float(v0[0] * w[0] + v1[0] * w[1] + v2[0] * w[2]);
vec[1] = float(v0[1] * w[0] + v1[1] * w[1] + v2[1] * w[2]);
vec[2] = float(v0[2] * w[0] + v1[2] * w[1] + v2[2] * w[2]);
return vec;
}
template <> inline openvdb::Vec3d
combine(const openvdb::Vec3d& v0, const openvdb::Vec3d& v1,
const openvdb::Vec3d& v2, const openvdb::Vec3d& w)
{
openvdb::Vec3d vec;
vec[0] = v0[0] * w[0] + v1[0] * w[1] + v2[0] * w[2];
vec[1] = v0[1] * w[0] + v1[1] * w[1] + v2[1] * w[2];
vec[2] = v0[2] * w[0] + v1[2] * w[1] + v2[2] * w[2];
return vec;
}
////////////////////////////////////////
/// @brief Get an OpenVDB-specific value by evaluating GA_Default::get()
/// with appropriate arguments.
template <typename ValueType> inline ValueType
evalAttrDefault(const GA_Defaults& defaults, int idx)
{
fpreal64 value;
defaults.get(idx, value);
return ValueType(value);
}
template <> inline float
evalAttrDefault<float>(const GA_Defaults& defaults, int /*idx*/)
{
fpreal32 value;
defaults.get(0, value);
return float(value);
}
template <> inline openvdb::Int32
evalAttrDefault<openvdb::Int32>(const GA_Defaults& defaults, int idx)
{
int32 value;
defaults.get(idx, value);
return openvdb::Int32(value);
}
template <> inline openvdb::Int64
evalAttrDefault<openvdb::Int64>(const GA_Defaults& defaults, int idx)
{
int64 value;
defaults.get(idx, value);
return openvdb::Int64(value);
}
template <> inline openvdb::Vec3i
evalAttrDefault<openvdb::Vec3i>(const GA_Defaults& defaults, int)
{
openvdb::Vec3i vec;
int32 value;
defaults.get(0, value);
vec[0] = openvdb::Int32(value);
defaults.get(1, value);
vec[1] = openvdb::Int32(value);
defaults.get(2, value);
vec[2] = openvdb::Int32(value);
return vec;
}
template <> inline openvdb::Vec3s
evalAttrDefault<openvdb::Vec3s>(const GA_Defaults& defaults, int)
{
openvdb::Vec3s vec;
fpreal32 value;
defaults.get(0, value);
vec[0] = float(value);
defaults.get(1, value);
vec[1] = float(value);
defaults.get(2, value);
vec[2] = float(value);
return vec;
}
template <> inline openvdb::Vec3d
evalAttrDefault<openvdb::Vec3d>(const GA_Defaults& defaults, int)
{
openvdb::Vec3d vec;
fpreal64 value;
defaults.get(0, value);
vec[0] = double(value);
defaults.get(1, value);
vec[1] = double(value);
defaults.get(2, value);
vec[2] = double(value);
return vec;
}
template <> inline openvdb::math::Quat<float>
evalAttrDefault<openvdb::math::Quat<float>>(const GA_Defaults& defaults, int)
{
openvdb::math::Quat<float> quat;
fpreal32 value;
for (int i = 0; i < 4; i++) {
defaults.get(i, value);
quat[i] = float(value);
}
return quat;
}
template <> inline openvdb::math::Quat<double>
evalAttrDefault<openvdb::math::Quat<double>>(const GA_Defaults& defaults, int)
{
openvdb::math::Quat<double> quat;
fpreal64 value;
for (int i = 0; i < 4; i++) {
defaults.get(i, value);
quat[i] = double(value);
}
return quat;
}
template <> inline openvdb::math::Mat3<float>
evalAttrDefault<openvdb::math::Mat3<float>>(const GA_Defaults& defaults, int)
{
openvdb::math::Mat3<float> mat;
fpreal64 value;
float* data = mat.asPointer();
for (int i = 0; i < 9; i++) {
defaults.get(i, value);
data[i] = float(value);
}
return mat;
}
template <> inline openvdb::math::Mat3<double>
evalAttrDefault<openvdb::math::Mat3<double>>(const GA_Defaults& defaults, int)
{
openvdb::math::Mat3<double> mat;
fpreal64 value;
double* data = mat.asPointer();
for (int i = 0; i < 9; i++) {
defaults.get(i, value);
data[i] = double(value);
}
return mat;
}
template <> inline openvdb::math::Mat4<float>
evalAttrDefault<openvdb::math::Mat4<float>>(const GA_Defaults& defaults, int)
{
openvdb::math::Mat4<float> mat;
fpreal64 value;
float* data = mat.asPointer();
for (int i = 0; i < 16; i++) {
defaults.get(i, value);
data[i] = float(value);
}
return mat;
}
template <> inline openvdb::math::Mat4<double>
evalAttrDefault<openvdb::math::Mat4<double>>(const GA_Defaults& defaults, int)
{
openvdb::math::Mat4<double> mat;
fpreal64 value;
double* data = mat.asPointer();
for (int i = 0; i < 16; i++) {
defaults.get(i, value);
data[i] = double(value);
}
return mat;
}
////////////////////////////////////////
class AttributeDetailBase
{
public:
using Ptr = std::shared_ptr<AttributeDetailBase>;
virtual ~AttributeDetailBase() = default;
AttributeDetailBase(const AttributeDetailBase&) = default;
AttributeDetailBase& operator=(const AttributeDetailBase&) = default;
virtual void set(const openvdb::Coord& ijk, const GA_Offset (&offsets)[3],
const openvdb::Vec3d& weights) = 0;
virtual void set(const openvdb::Coord& ijk, GA_Offset offset) = 0;
virtual openvdb::GridBase::Ptr& grid() = 0;
virtual std::string& name() = 0;
virtual AttributeDetailBase::Ptr copy() = 0;
protected:
AttributeDetailBase() {}
};
using AttributeDetailList = std::vector<AttributeDetailBase::Ptr>;
////////////////////////////////////////
template <class VDBGridType>
class AttributeDetail: public AttributeDetailBase
{
public:
using ValueType = typename VDBGridType::ValueType;
AttributeDetail(
openvdb::GridBase::Ptr grid,
const GA_Attribute* attribute,
const GA_AIFTuple* tupleAIF,
const int tupleIndex,
const bool isVector = false);
void set(const openvdb::Coord& ijk, const GA_Offset (&offsets)[3],
const openvdb::Vec3d& weights) override;
void set(const openvdb::Coord& ijk, GA_Offset offset) override;
openvdb::GridBase::Ptr& grid() override { return mGrid; }
std::string& name() override { return mName; }
AttributeDetailBase::Ptr copy() override;
protected:
AttributeDetail();
private:
openvdb::GridBase::Ptr mGrid;
typename VDBGridType::Accessor mAccessor;
const GA_Attribute* mAttribute;
const GA_AIFTuple* mTupleAIF;
const int mTupleIndex;
std::string mName;
};
template <class VDBGridType>
AttributeDetail<VDBGridType>::AttributeDetail():
mAttribute(nullptr),
mTupleAIF(nullptr),
mTupleIndex(0)
{
}
template <class VDBGridType>
AttributeDetail<VDBGridType>::AttributeDetail(
openvdb::GridBase::Ptr grid,
const GA_Attribute* attribute,
const GA_AIFTuple* tupleAIF,
const int tupleIndex,
const bool isVector):
mGrid(grid),
mAccessor(openvdb::GridBase::grid<VDBGridType>(mGrid)->getAccessor()),
mAttribute(attribute),
mTupleAIF(tupleAIF),
mTupleIndex(tupleIndex)
{
std::ostringstream name;
name << mAttribute->getName();
const int tupleSize = mTupleAIF->getTupleSize(mAttribute);
if(!isVector && tupleSize != 1) {
name << "_" << mTupleIndex;
}
mName = name.str();
}
template <class VDBGridType>
void
AttributeDetail<VDBGridType>::set(const openvdb::Coord& ijk,
const GA_Offset (&offsets)[3], const openvdb::Vec3d& weights)
{
ValueType v0 = evalAttr<ValueType>(
mAttribute, mTupleAIF, offsets[0], mTupleIndex);
ValueType v1 = evalAttr<ValueType>(
mAttribute, mTupleAIF, offsets[1], mTupleIndex);
ValueType v2 = evalAttr<ValueType>(
mAttribute, mTupleAIF, offsets[2], mTupleIndex);
mAccessor.setValue(ijk, combine<ValueType>(v0, v1, v2, weights));
}
template <class VDBGridType>
void
AttributeDetail<VDBGridType>::set(const openvdb::Coord& ijk, GA_Offset offset)
{
mAccessor.setValue(ijk,
evalAttr<ValueType>(mAttribute, mTupleAIF, offset, mTupleIndex));
}
template <class VDBGridType>
AttributeDetailBase::Ptr
AttributeDetail<VDBGridType>::copy()
{
return AttributeDetailBase::Ptr(new AttributeDetail<VDBGridType>(*this));
}
////////////////////////////////////////
// TBB object to transfer mesh attributes.
// Only quads and/or triangles are supported
// NOTE: This class has all code in the header and so it cannot have OPENVDB_HOUDINI_API.
class MeshAttrTransfer
{
public:
using IterRange = openvdb::tree::IteratorRange<openvdb::Int32Tree::LeafCIter>;
inline
MeshAttrTransfer(
AttributeDetailList &pointAttributes,
AttributeDetailList &vertexAttributes,
AttributeDetailList &primitiveAttributes,
const openvdb::Int32Grid& closestPrimGrid,
const openvdb::math::Transform& transform,
const GU_Detail& meshGdp);
inline
MeshAttrTransfer(const MeshAttrTransfer &other);
inline
~MeshAttrTransfer() {}
/// Main calls
inline void runParallel();
inline void runSerial();
inline void operator()(IterRange &range) const;
private:
AttributeDetailList mPointAttributes, mVertexAttributes, mPrimitiveAttributes;
const openvdb::Int32Grid& mClosestPrimGrid;
const openvdb::math::Transform& mTransform;
const GA_Detail &mMeshGdp;
};
MeshAttrTransfer::MeshAttrTransfer(
AttributeDetailList& pointAttributes,
AttributeDetailList& vertexAttributes,
AttributeDetailList& primitiveAttributes,
const openvdb::Int32Grid& closestPrimGrid,
const openvdb::math::Transform& transform,
const GU_Detail& meshGdp):
mPointAttributes(pointAttributes),
mVertexAttributes(vertexAttributes),
mPrimitiveAttributes(primitiveAttributes),
mClosestPrimGrid(closestPrimGrid),
mTransform(transform),
mMeshGdp(meshGdp)
{
}
MeshAttrTransfer::MeshAttrTransfer(const MeshAttrTransfer &other):
mPointAttributes(other.mPointAttributes.size()),
mVertexAttributes(other.mVertexAttributes.size()),
mPrimitiveAttributes(other.mPrimitiveAttributes.size()),
mClosestPrimGrid(other.mClosestPrimGrid),
mTransform(other.mTransform),
mMeshGdp(other.mMeshGdp)
{
// Deep-copy the AttributeDetail arrays, to construct unique tree
// accessors per thread.
for (size_t i = 0, N = other.mPointAttributes.size(); i < N; ++i) {
mPointAttributes[i] = other.mPointAttributes[i]->copy();
}
for (size_t i = 0, N = other.mVertexAttributes.size(); i < N; ++i) {
mVertexAttributes[i] = other.mVertexAttributes[i]->copy();
}
for (size_t i = 0, N = other.mPrimitiveAttributes.size(); i < N; ++i) {
mPrimitiveAttributes[i] = other.mPrimitiveAttributes[i]->copy();
}
}
void
MeshAttrTransfer::runParallel()
{
IterRange range(mClosestPrimGrid.tree().beginLeaf());
tbb::parallel_for(range, *this);
}
void
MeshAttrTransfer::runSerial()
{
IterRange range(mClosestPrimGrid.tree().beginLeaf());
(*this)(range);
}
void
MeshAttrTransfer::operator()(IterRange &range) const
{
openvdb::Int32Tree::LeafNodeType::ValueOnCIter iter;
openvdb::Coord ijk;
const bool ptnAttrTransfer = mPointAttributes.size() > 0;
const bool vtxAttrTransfer = mVertexAttributes.size() > 0;
GA_Offset vtxOffsetList[4], ptnOffsetList[4], vtxOffsets[3], ptnOffsets[3], prmOffset;
openvdb::Vec3d ptnList[4], xyz, cpt, cpt2, uvw, uvw2;
for ( ; range; ++range) {
iter = range.iterator()->beginValueOn();
for ( ; iter; ++iter) {
ijk = iter.getCoord();
const GA_Index prmIndex = iter.getValue();
prmOffset = mMeshGdp.primitiveOffset(prmIndex);
// Transfer primitive attributes
for (size_t i = 0, N = mPrimitiveAttributes.size(); i < N; ++i) {
mPrimitiveAttributes[i]->set(ijk, prmOffset);
}
if (!ptnAttrTransfer && !vtxAttrTransfer) continue;
// Transfer vertex and point attributes
const GA_Primitive * primRef = mMeshGdp.getPrimitiveList().get(prmOffset);
const GA_Size vtxn = primRef->getVertexCount();
// Get vertex and point offests
for (GA_Size vtx = 0; vtx < vtxn; ++vtx) {
const GA_Offset vtxoff = primRef->getVertexOffset(vtx);
ptnOffsetList[vtx] = mMeshGdp.vertexPoint(vtxoff);
vtxOffsetList[vtx] = vtxoff;
UT_Vector3 p = mMeshGdp.getPos3(ptnOffsetList[vtx]);
ptnList[vtx][0] = double(p[0]);
ptnList[vtx][1] = double(p[1]);
ptnList[vtx][2] = double(p[2]);
}
xyz = mTransform.indexToWorld(ijk);
// Compute barycentric coordinates
cpt = closestPointOnTriangleToPoint(
ptnList[0], ptnList[2], ptnList[1], xyz, uvw);
vtxOffsets[0] = vtxOffsetList[0]; // cpt offsets
ptnOffsets[0] = ptnOffsetList[0];
vtxOffsets[1] = vtxOffsetList[2];
ptnOffsets[1] = ptnOffsetList[2];
vtxOffsets[2] = vtxOffsetList[1];
ptnOffsets[2] = ptnOffsetList[1];
if (4 == vtxn) {
cpt2 = closestPointOnTriangleToPoint(
ptnList[0], ptnList[3], ptnList[2], xyz, uvw2);
if ((cpt2 - xyz).lengthSqr() < (cpt - xyz).lengthSqr()) {
uvw = uvw2;
vtxOffsets[1] = vtxOffsetList[3];
ptnOffsets[1] = ptnOffsetList[3];
vtxOffsets[2] = vtxOffsetList[2];
ptnOffsets[2] = ptnOffsetList[2];
}
}
// Transfer vertex attributes
for (size_t i = 0, N = mVertexAttributes.size(); i < N; ++i) {
mVertexAttributes[i]->set(ijk, vtxOffsets, uvw);
}
// Transfer point attributes
for (size_t i = 0, N = mPointAttributes.size(); i < N; ++i) {
mPointAttributes[i]->set(ijk, ptnOffsets, uvw);
}
} // end sparse voxel iteration.
} // end leaf-node iteration
}
////////////////////////////////////////
// TBB object to transfer mesh attributes.
// Only quads and/or triangles are supported
// NOTE: This class has all code in the header and so it cannot have OPENVDB_HOUDINI_API.
class PointAttrTransfer
{
public:
using IterRange = openvdb::tree::IteratorRange<openvdb::Int32Tree::LeafCIter>;
inline PointAttrTransfer(
AttributeDetailList &pointAttributes,
const openvdb::Int32Grid& closestPtnIdxGrid,
const GU_Detail& ptGeop);
inline PointAttrTransfer(const PointAttrTransfer &other);
inline ~PointAttrTransfer() {}
/// Main calls
inline void runParallel();
inline void runSerial();
inline void operator()(IterRange &range) const;
private:
AttributeDetailList mPointAttributes;
const openvdb::Int32Grid& mClosestPtnIdxGrid;
const GA_Detail &mPtGeo;
};
PointAttrTransfer::PointAttrTransfer(
AttributeDetailList& pointAttributes,
const openvdb::Int32Grid& closestPtnIdxGrid,
const GU_Detail& ptGeop):
mPointAttributes(pointAttributes),
mClosestPtnIdxGrid(closestPtnIdxGrid),
mPtGeo(ptGeop)
{
}
PointAttrTransfer::PointAttrTransfer(const PointAttrTransfer &other):
mPointAttributes(other.mPointAttributes.size()),
mClosestPtnIdxGrid(other.mClosestPtnIdxGrid),
mPtGeo(other.mPtGeo)
{
// Deep-copy the AttributeDetail arrays, to construct unique tree
// accessors per thread.
for (size_t i = 0, N = other.mPointAttributes.size(); i < N; ++i) {
mPointAttributes[i] = other.mPointAttributes[i]->copy();
}
}
void
PointAttrTransfer::runParallel()
{
IterRange range(mClosestPtnIdxGrid.tree().beginLeaf());
tbb::parallel_for(range, *this);
}
void
PointAttrTransfer::runSerial()
{
IterRange range(mClosestPtnIdxGrid.tree().beginLeaf());
(*this)(range);
}
void
PointAttrTransfer::operator()(IterRange &range) const
{
openvdb::Int32Tree::LeafNodeType::ValueOnCIter iter;
openvdb::Coord ijk;
for ( ; range; ++range) {
iter = range.iterator()->beginValueOn();
for ( ; iter; ++iter) {
ijk = iter.getCoord();
const GA_Index pointIndex = iter.getValue();
const GA_Offset pointOffset = mPtGeo.pointOffset(pointIndex);
// Transfer point attributes
for (size_t i = 0, N = mPointAttributes.size(); i < N; ++i) {
mPointAttributes[i]->set(ijk, pointOffset);
}
} // end sparse voxel iteration.
} // end leaf-node iteration
}
////////////////////////////////////////
// Mesh to Mesh Attribute Transfer Utils
struct AttributeCopyBase
{
using Ptr = std::shared_ptr<AttributeCopyBase>;
virtual ~AttributeCopyBase() {}
virtual void copy(GA_Offset /*source*/, GA_Offset /*target*/) = 0;
virtual void copy(GA_Offset&, GA_Offset&, GA_Offset&, GA_Offset /*target*/,
const openvdb::Vec3d& /*uvw*/) = 0;
protected:
AttributeCopyBase() {}
};
template<class ValueType>
struct AttributeCopy: public AttributeCopyBase
{
public:
AttributeCopy(const GA_Attribute& sourceAttr, GA_Attribute& targetAttr)
: mSourceAttr(sourceAttr)
, mTargetAttr(targetAttr)
, mAIFTuple(*mSourceAttr.getAIFTuple())
, mTupleSize(mAIFTuple.getTupleSize(&mSourceAttr))
{
}
void copy(GA_Offset source, GA_Offset target) override
{
ValueType data;
for (int i = 0; i < mTupleSize; ++i) {
mAIFTuple.get(&mSourceAttr, source, data, i);
mAIFTuple.set(&mTargetAttr, target, data, i);
}
}
void copy(GA_Offset& v0, GA_Offset& v1, GA_Offset& v2, GA_Offset target,
const openvdb::Vec3d& uvw) override
{
doCopy<ValueType>(v0, v1, v2, target, uvw);
}
private:
template<typename T>
typename std::enable_if<std::is_integral<T>::value>::type
doCopy(GA_Offset& v0, GA_Offset& v1, GA_Offset& v2, GA_Offset target, const openvdb::Vec3d& uvw)
{
GA_Offset source = v0;
double min = uvw[0];
if (uvw[1] < min) {
min = uvw[1];
source = v1;
}
if (uvw[2] < min) source = v2;
ValueType data;
for (int i = 0; i < mTupleSize; ++i) {
mAIFTuple.get(&mSourceAttr, source, data, i);
mAIFTuple.set(&mTargetAttr, target, data, i);
}
}
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value>::type
doCopy(GA_Offset& v0, GA_Offset& v1, GA_Offset& v2, GA_Offset target, const openvdb::Vec3d& uvw)
{
ValueType a, b, c;
for (int i = 0; i < mTupleSize; ++i) {
mAIFTuple.get(&mSourceAttr, v0, a, i);
mAIFTuple.get(&mSourceAttr, v1, b, i);
mAIFTuple.get(&mSourceAttr, v2, c, i);
mAIFTuple.set(&mTargetAttr, target, a*uvw[0] + b*uvw[1] + c*uvw[2], i);
}
}
const GA_Attribute& mSourceAttr;
GA_Attribute& mTargetAttr;
const GA_AIFTuple& mAIFTuple;
int mTupleSize;
};
struct StrAttributeCopy: public AttributeCopyBase
{
public:
StrAttributeCopy(const GA_Attribute& sourceAttr, GA_Attribute& targetAttr)
: mSourceAttr(sourceAttr)
, mTargetAttr(targetAttr)
, mAIF(*mSourceAttr.getAIFSharedStringTuple())
, mTupleSize(mAIF.getTupleSize(&mSourceAttr))
{
}
void copy(GA_Offset source, GA_Offset target) override
{
for (int i = 0; i < mTupleSize; ++i) {
mAIF.setString(&mTargetAttr, target, mAIF.getString(&mSourceAttr, source, i), i);
}
}
void copy(GA_Offset& v0, GA_Offset& v1, GA_Offset& v2, GA_Offset target,
const openvdb::Vec3d& uvw) override
{
GA_Offset source = v0;
double min = uvw[0];
if (uvw[1] < min) {
min = uvw[1];
source = v1;
}
if (uvw[2] < min) source = v2;
for (int i = 0; i < mTupleSize; ++i) {
mAIF.setString(&mTargetAttr, target, mAIF.getString(&mSourceAttr, source, i), i);
}
}
protected:
const GA_Attribute& mSourceAttr;
GA_Attribute& mTargetAttr;
const GA_AIFSharedStringTuple& mAIF;
int mTupleSize;
};
////////////////////////////////////////
inline AttributeCopyBase::Ptr
createAttributeCopier(const GA_Attribute& sourceAttr, GA_Attribute& targetAttr)
{
const GA_AIFTuple * aifTuple = sourceAttr.getAIFTuple();
AttributeCopyBase::Ptr attr;
if (aifTuple) {
const GA_Storage sourceStorage = aifTuple->getStorage(&sourceAttr);
const GA_Storage targetStorage = aifTuple->getStorage(&targetAttr);
const int sourceTupleSize = aifTuple->getTupleSize(&sourceAttr);
const int targetTupleSize = aifTuple->getTupleSize(&targetAttr);
if (sourceStorage == targetStorage && sourceTupleSize == targetTupleSize) {
switch (sourceStorage)
{
case GA_STORE_INT16:
case GA_STORE_INT32:
attr = AttributeCopyBase::Ptr(
new AttributeCopy<int32>(sourceAttr, targetAttr));
break;
case GA_STORE_INT64:
attr = AttributeCopyBase::Ptr(
new AttributeCopy<int64>(sourceAttr, targetAttr));
break;
case GA_STORE_REAL16:
case GA_STORE_REAL32:
attr = AttributeCopyBase::Ptr(
new AttributeCopy<fpreal32>(sourceAttr, targetAttr));
break;
case GA_STORE_REAL64:
attr = AttributeCopyBase::Ptr(
new AttributeCopy<fpreal64>(sourceAttr, targetAttr));
break;
default:
break;
}
}
} else {
const GA_AIFSharedStringTuple * aifString = sourceAttr.getAIFSharedStringTuple();
if (aifString) {
attr = AttributeCopyBase::Ptr(new StrAttributeCopy(sourceAttr, targetAttr));
}
}
return attr;
}
////////////////////////////////////////
inline GA_Offset
findClosestPrimitiveToPoint(
const GU_Detail& geo, const std::set<GA_Index>& primitives, const openvdb::Vec3d& p,
GA_Offset& vert0, GA_Offset& vert1, GA_Offset& vert2, openvdb::Vec3d& uvw)
{
std::set<GA_Index>::const_iterator it = primitives.begin();
GA_Offset primOffset = GA_INVALID_OFFSET;
const GA_Primitive * primRef = nullptr;
double minDist = std::numeric_limits<double>::max();
openvdb::Vec3d a, b, c, d, tmpUVW;
UT_Vector3 tmpPoint;
for (; it != primitives.end(); ++it) {
const GA_Offset offset = geo.primitiveOffset(*it);
primRef = geo.getPrimitiveList().get(offset);
const GA_Size vertexCount = primRef->getVertexCount();
if (vertexCount == 3 || vertexCount == 4) {
tmpPoint = geo.getPos3(primRef->getPointOffset(0));
a[0] = tmpPoint.x();
a[1] = tmpPoint.y();
a[2] = tmpPoint.z();
tmpPoint = geo.getPos3(primRef->getPointOffset(1));
b[0] = tmpPoint.x();
b[1] = tmpPoint.y();
b[2] = tmpPoint.z();
tmpPoint = geo.getPos3(primRef->getPointOffset(2));
c[0] = tmpPoint.x();
c[1] = tmpPoint.y();
c[2] = tmpPoint.z();
double tmpDist =
(p - openvdb::math::closestPointOnTriangleToPoint(a, c, b, p, tmpUVW)).lengthSqr();
if (tmpDist < minDist) {
minDist = tmpDist;
primOffset = offset;
uvw = tmpUVW;
vert0 = primRef->getVertexOffset(0);
vert1 = primRef->getVertexOffset(2);
vert2 = primRef->getVertexOffset(1);
}
if (vertexCount == 4) {
tmpPoint = geo.getPos3(primRef->getPointOffset(3));
d[0] = tmpPoint.x();
d[1] = tmpPoint.y();
d[2] = tmpPoint.z();
tmpDist = (p - openvdb::math::closestPointOnTriangleToPoint(
a, d, c, p, tmpUVW)).lengthSqr();
if (tmpDist < minDist) {
minDist = tmpDist;
primOffset = offset;
uvw = tmpUVW;
vert0 = primRef->getVertexOffset(0);
vert1 = primRef->getVertexOffset(3);
vert2 = primRef->getVertexOffset(2);
}
}
}
}
return primOffset;
}
// Faster for small primitive counts
inline GA_Offset
findClosestPrimitiveToPoint(
const GU_Detail& geo, std::vector<GA_Index>& primitives, const openvdb::Vec3d& p,
GA_Offset& vert0, GA_Offset& vert1, GA_Offset& vert2, openvdb::Vec3d& uvw)
{
GA_Offset primOffset = GA_INVALID_OFFSET;
const GA_Primitive * primRef = nullptr;
double minDist = std::numeric_limits<double>::max();
openvdb::Vec3d a, b, c, d, tmpUVW;
UT_Vector3 tmpPoint;
std::sort(primitives.begin(), primitives.end());
GA_Index lastPrim = -1;
for (size_t n = 0, N = primitives.size(); n < N; ++n) {
if (primitives[n] == lastPrim) continue;
lastPrim = primitives[n];
const GA_Offset offset = geo.primitiveOffset(lastPrim);
primRef = geo.getPrimitiveList().get(offset);
const GA_Size vertexCount = primRef->getVertexCount();
if (vertexCount == 3 || vertexCount == 4) {
tmpPoint = geo.getPos3(primRef->getPointOffset(0));
a[0] = tmpPoint.x();
a[1] = tmpPoint.y();
a[2] = tmpPoint.z();
tmpPoint = geo.getPos3(primRef->getPointOffset(1));
b[0] = tmpPoint.x();
b[1] = tmpPoint.y();
b[2] = tmpPoint.z();
tmpPoint = geo.getPos3(primRef->getPointOffset(2));
c[0] = tmpPoint.x();
c[1] = tmpPoint.y();
c[2] = tmpPoint.z();
double tmpDist =
(p - openvdb::math::closestPointOnTriangleToPoint(a, c, b, p, tmpUVW)).lengthSqr();
if (tmpDist < minDist) {
minDist = tmpDist;
primOffset = offset;
uvw = tmpUVW;
vert0 = primRef->getVertexOffset(0);
vert1 = primRef->getVertexOffset(2);
vert2 = primRef->getVertexOffset(1);
}
if (vertexCount == 4) {
tmpPoint = geo.getPos3(primRef->getPointOffset(3));
d[0] = tmpPoint.x();
d[1] = tmpPoint.y();
d[2] = tmpPoint.z();
tmpDist = (p - openvdb::math::closestPointOnTriangleToPoint(
a, d, c, p, tmpUVW)).lengthSqr();
if (tmpDist < minDist) {
minDist = tmpDist;
primOffset = offset;
uvw = tmpUVW;
vert0 = primRef->getVertexOffset(0);
vert1 = primRef->getVertexOffset(3);
vert2 = primRef->getVertexOffset(2);
}
}
}
}
return primOffset;
}
////////////////////////////////////////
template<class GridType>
class TransferPrimitiveAttributesOp
{
public:
using IndexT = typename GridType::ValueType;
using IndexAccT = typename GridType::ConstAccessor;
using AttrCopyPtrVec = std::vector<AttributeCopyBase::Ptr>;
TransferPrimitiveAttributesOp(
const GU_Detail& sourceGeo,
GU_Detail& targetGeo,
const GridType& indexGrid,
AttrCopyPtrVec& primAttributes,
AttrCopyPtrVec& vertAttributes)
: mSourceGeo(sourceGeo)
, mTargetGeo(targetGeo)
, mIndexGrid(indexGrid)
, mPrimAttributes(primAttributes)
, mVertAttributes(vertAttributes)
{
}
inline void operator()(const GA_SplittableRange&) const;
private:
inline void copyPrimAttrs(const GA_Primitive&, const UT_Vector3&, IndexAccT&) const;
template<typename PrimT>
inline void copyVertAttrs(const PrimT&, const UT_Vector3&, IndexAccT&) const;
const GU_Detail& mSourceGeo;
GU_Detail& mTargetGeo;
const GridType& mIndexGrid;
AttrCopyPtrVec& mPrimAttributes;
AttrCopyPtrVec& mVertAttributes;
};
template<class GridType>
inline void
TransferPrimitiveAttributesOp<GridType>::operator()(const GA_SplittableRange& range) const
{
if (mPrimAttributes.empty() && mVertAttributes.empty()) return;
auto polyIdxAcc = mIndexGrid.getConstAccessor();
for (GA_PageIterator pageIt = range.beginPages(); !pageIt.atEnd(); ++pageIt) {
auto start = GA_Offset(), end = GA_Offset();
for (GA_Iterator blockIt(pageIt.begin()); blockIt.blockAdvance(start, end); ) {
for (auto targetOffset = start; targetOffset < end; ++targetOffset) {
const auto* target = mTargetGeo.getPrimitiveList().get(targetOffset);
if (!target) continue;
const auto targetN = mTargetGeo.getGEOPrimitive(targetOffset)->computeNormal();
if (!mPrimAttributes.empty()) {
// Transfer primitive attributes.
copyPrimAttrs(*target, targetN, polyIdxAcc);
}
if (!mVertAttributes.empty()) {
if (target->getTypeId() != GA_PRIMPOLYSOUP) {
copyVertAttrs(*target, targetN, polyIdxAcc);
} else {
if (const auto* soup = UTverify_cast<const GEO_PrimPolySoup*>(target)) {
// Iterate in parallel over the member polygons of a polygon soup.
using SizeRange = UT_BlockedRange<GA_Size>;
const auto processPolyRange = [&](const SizeRange& range) {
auto threadLocalPolyIdxAcc = mIndexGrid.getConstAccessor();
for (GEO_PrimPolySoup::PolygonIterator it(*soup, range.begin());
!it.atEnd() && (it.polygon() < range.end()); ++it)
{
copyVertAttrs(it, it.computeNormal(), threadLocalPolyIdxAcc);
}
};
UTparallelFor(SizeRange(0, soup->getPolygonCount()), processPolyRange);
}
}
}
}
}
}
}
/// @brief Find the closest match to the target primitive from among the source primitives
/// and copy primitive attributes from that primitive to the target primitive.
/// @note This isn't a particularly useful operation when the target is a polygon soup,
/// because the entire soup is a single primitive, whereas the source primitives
/// are likely to be individual polygons.
template<class GridType>
inline void
TransferPrimitiveAttributesOp<GridType>::copyPrimAttrs(
const GA_Primitive& targetPrim,
const UT_Vector3& targetNormal,
IndexAccT& polyIdxAcc) const
{
const auto& transform = mIndexGrid.transform();
UT_Vector3 sourceN, targetN = targetNormal;
const bool isPolySoup = (targetPrim.getTypeId() == GA_PRIMPOLYSOUP);
// Compute avg. vertex position.
openvdb::Vec3d pos(0, 0, 0);
int count = static_cast<int>(targetPrim.getVertexCount());
for (int vtx = 0; vtx < count; ++vtx) {
pos += UTvdbConvert(targetPrim.getPos3(vtx));
}
if (count > 1) pos /= double(count);
// Find closest source primitive to current avg. vertex position.
const auto coord = openvdb::Coord::floor(transform.worldToIndex(pos));
std::vector<GA_Index> primitives(8), similarPrimitives(8);
IndexT primIndex;
openvdb::Coord ijk;
for (int d = 0; d < 8; ++d) {
ijk[0] = coord[0] + (((d & 0x02) >> 1) ^ (d & 0x01));
ijk[1] = coord[1] + ((d & 0x02) >> 1);
ijk[2] = coord[2] + ((d & 0x04) >> 2);
if (polyIdxAcc.probeValue(ijk, primIndex) &&
openvdb::Index32(primIndex) != openvdb::util::INVALID_IDX) {
GA_Offset tmpOffset = mSourceGeo.primitiveOffset(primIndex);
sourceN = mSourceGeo.getGEOPrimitive(tmpOffset)->computeNormal();
// Skip the normal test when the target is a polygon soup, because
// the entire soup is a single primitive, whose normal is unlikely
// to coincide with any of the source primitives.
if (isPolySoup || sourceN.dot(targetN) > 0.5) {
similarPrimitives.push_back(primIndex);
} else {
primitives.push_back(primIndex);
}
}
}
if (!primitives.empty() || !similarPrimitives.empty()) {
GA_Offset source, v0, v1, v2;
openvdb::Vec3d uvw;
if (!similarPrimitives.empty()) {
source = findClosestPrimitiveToPoint(
mSourceGeo, similarPrimitives, pos, v0, v1, v2, uvw);
} else {
source = findClosestPrimitiveToPoint(
mSourceGeo, primitives, pos, v0, v1, v2, uvw);
}
// Transfer attributes
const auto targetOffset = targetPrim.getMapOffset();
for (size_t n = 0, N = mPrimAttributes.size(); n < N; ++n) {
mPrimAttributes[n]->copy(source, targetOffset);
}
}
}
/// @brief Find the closest match to the target primitive from among the source primitives
/// (using slightly different criteria than copyPrimAttrs()) and copy vertex attributes
/// from that primitive's vertices to the target primitive's vertices.
/// @note When the target is a polygon soup, @a targetPrim should be a
/// @b GEO_PrimPolySoup::PolygonIterator that points to one of the member polygons of the soup.
template<typename GridType>
template<typename PrimT>
inline void
TransferPrimitiveAttributesOp<GridType>::copyVertAttrs(
const PrimT& targetPrim,
const UT_Vector3& targetNormal,
IndexAccT& polyIdxAcc) const
{
const auto& transform = mIndexGrid.transform();
openvdb::Vec3d pos, uvw;
openvdb::Coord ijk;
UT_Vector3 sourceNormal;
std::vector<GA_Index> primitives(8), similarPrimitives(8);
for (GA_Size vtx = 0, vtxN = targetPrim.getVertexCount(); vtx < vtxN; ++vtx) {
pos = UTvdbConvert(targetPrim.getPos3(vtx));
const auto coord = openvdb::Coord::floor(transform.worldToIndex(pos));
primitives.clear();
similarPrimitives.clear();
int primIndex;
for (int d = 0; d < 8; ++d) {
ijk[0] = coord[0] + (((d & 0x02) >> 1) ^ (d & 0x01));
ijk[1] = coord[1] + ((d & 0x02) >> 1);
ijk[2] = coord[2] + ((d & 0x04) >> 2);
if (polyIdxAcc.probeValue(ijk, primIndex) &&
(openvdb::Index32(primIndex) != openvdb::util::INVALID_IDX))
{
GA_Offset tmpOffset = mSourceGeo.primitiveOffset(primIndex);
sourceNormal = mSourceGeo.getGEOPrimitive(tmpOffset)->computeNormal();
if (sourceNormal.dot(targetNormal) > 0.5) {
primitives.push_back(primIndex);
}
}
}
if (!primitives.empty() || !similarPrimitives.empty()) {
GA_Offset v0, v1, v2;
if (!similarPrimitives.empty()) {
findClosestPrimitiveToPoint(mSourceGeo, similarPrimitives, pos, v0, v1, v2, uvw);
} else {
findClosestPrimitiveToPoint(mSourceGeo, primitives, pos, v0, v1, v2, uvw);
}
for (size_t n = 0, N = mVertAttributes.size(); n < N; ++n) {
mVertAttributes[n]->copy(v0, v1, v2, targetPrim.getVertexOffset(vtx), uvw);
}
}
}
}
////////////////////////////////////////
template<class GridType>
class TransferPointAttributesOp
{
public:
TransferPointAttributesOp(
const GU_Detail& sourceGeo, GU_Detail& targetGeo, const GridType& indexGrid,
std::vector<AttributeCopyBase::Ptr>& pointAttributes,
const GA_PrimitiveGroup* surfacePrims = nullptr);
void operator()(const GA_SplittableRange&) const;
private:
const GU_Detail& mSourceGeo;
GU_Detail& mTargetGeo;
const GridType& mIndexGrid;
std::vector<AttributeCopyBase::Ptr>& mPointAttributes;
const GA_PrimitiveGroup* mSurfacePrims;
};
template<class GridType>
TransferPointAttributesOp<GridType>::TransferPointAttributesOp(
const GU_Detail& sourceGeo, GU_Detail& targetGeo, const GridType& indexGrid,
std::vector<AttributeCopyBase::Ptr>& pointAttributes,
const GA_PrimitiveGroup* surfacePrims)
: mSourceGeo(sourceGeo)
, mTargetGeo(targetGeo)
, mIndexGrid(indexGrid)
, mPointAttributes(pointAttributes)
, mSurfacePrims(surfacePrims)
{
}
template<class GridType>
void
TransferPointAttributesOp<GridType>::operator()(const GA_SplittableRange& range) const
{
using IndexT = typename GridType::ValueType;
GA_Offset start, end, vtxOffset, primOffset, target, v0, v1, v2;
typename GridType::ConstAccessor polyIdxAcc = mIndexGrid.getConstAccessor();
const openvdb::math::Transform& transform = mIndexGrid.transform();
openvdb::Vec3d pos, indexPos, uvw;
std::vector<GA_Index> primitives(8);
openvdb::Coord ijk, coord;
for (GA_PageIterator pageIt = range.beginPages(); !pageIt.atEnd(); ++pageIt) {
for (GA_Iterator blockIt(pageIt.begin()); blockIt.blockAdvance(start, end); ) {
for (target = start; target < end; ++target) {
vtxOffset = mTargetGeo.pointVertex(target);
// Check if point is referenced by a surface primitive.
if (mSurfacePrims) {
bool surfacePrim = false;
while (GAisValid(vtxOffset)) {
primOffset = mTargetGeo.vertexPrimitive(vtxOffset);
if (mSurfacePrims->containsIndex(mTargetGeo.primitiveIndex(primOffset))) {
surfacePrim = true;
break;
}
vtxOffset = mTargetGeo.vertexToNextVertex(vtxOffset);
}
if (!surfacePrim) continue;
}
const UT_Vector3 p = mTargetGeo.getPos3(target);
pos[0] = p.x();
pos[1] = p.y();
pos[2] = p.z();
indexPos = transform.worldToIndex(pos);
coord[0] = int(std::floor(indexPos[0]));
coord[1] = int(std::floor(indexPos[1]));
coord[2] = int(std::floor(indexPos[2]));
primitives.clear();
IndexT primIndex;
for (int d = 0; d < 8; ++d) {
ijk[0] = coord[0] + (((d & 0x02) >> 1) ^ (d & 0x01));
ijk[1] = coord[1] + ((d & 0x02) >> 1);
ijk[2] = coord[2] + ((d & 0x04) >> 2);
if (polyIdxAcc.probeValue(ijk, primIndex) &&
openvdb::Index32(primIndex) != openvdb::util::INVALID_IDX) {
primitives.push_back(primIndex);
}
}
if (!primitives.empty()) {
findClosestPrimitiveToPoint(mSourceGeo, primitives, pos, v0, v1, v2, uvw);
v0 = mSourceGeo.vertexPoint(v0);
v1 = mSourceGeo.vertexPoint(v1);
v2 = mSourceGeo.vertexPoint(v2);
for (size_t n = 0, N = mPointAttributes.size(); n < N; ++n) {
mPointAttributes[n]->copy(v0, v1, v2, target, uvw);
}
}
}
}
}
}
////////////////////////////////////////
template<class GridType>
inline void
transferPrimitiveAttributes(
const GU_Detail& sourceGeo,
GU_Detail& targetGeo,
GridType& indexGrid,
Interrupter& boss,
const GA_PrimitiveGroup* primitives = nullptr)
{
// Match public primitive attributes
GA_AttributeDict::iterator it = sourceGeo.primitiveAttribs().begin(GA_SCOPE_PUBLIC);
if (indexGrid.activeVoxelCount() == 0) return;
std::vector<AttributeCopyBase::Ptr> primAttributeList;
// Primitive attributes
for (; !it.atEnd(); ++it) {
const GA_Attribute* sourceAttr = it.attrib();
if (nullptr == targetGeo.findPrimitiveAttribute(it.name())) {
targetGeo.addPrimAttrib(sourceAttr);
}
GA_Attribute* targetAttr = targetGeo.findPrimitiveAttribute(it.name());
if (sourceAttr && targetAttr) {
AttributeCopyBase::Ptr att = createAttributeCopier(*sourceAttr, *targetAttr);
if(att) primAttributeList.push_back(att);
}
}
if (boss.wasInterrupted()) return;
std::vector<AttributeCopyBase::Ptr> vertAttributeList;
it = sourceGeo.vertexAttribs().begin(GA_SCOPE_PUBLIC);
// Vertex attributes
for (; !it.atEnd(); ++it) {
const GA_Attribute* sourceAttr = it.attrib();
if (nullptr == targetGeo.findVertexAttribute(it.name())) {
targetGeo.addVertexAttrib(sourceAttr);
}
GA_Attribute* targetAttr = targetGeo.findVertexAttribute(it.name());
if (sourceAttr && targetAttr) {
targetAttr->hardenAllPages();
AttributeCopyBase::Ptr att = createAttributeCopier(*sourceAttr, *targetAttr);
if(att) vertAttributeList.push_back(att);
}
}
if (!boss.wasInterrupted() && (!primAttributeList.empty() || !vertAttributeList.empty())) {
UTparallelFor(GA_SplittableRange(targetGeo.getPrimitiveRange(primitives)),
TransferPrimitiveAttributesOp<GridType>(sourceGeo, targetGeo, indexGrid,
primAttributeList, vertAttributeList));
}
if (!boss.wasInterrupted()) {
std::vector<AttributeCopyBase::Ptr> pointAttributeList;
it = sourceGeo.pointAttribs().begin(GA_SCOPE_PUBLIC);
// Point attributes
for (; !it.atEnd(); ++it) {
if (std::string(it.name()) == "P") continue; // Ignore previous point positions.
const GA_Attribute* sourceAttr = it.attrib();
if (nullptr == targetGeo.findPointAttribute(it.name())) {
targetGeo.addPointAttrib(sourceAttr);
}
GA_Attribute* targetAttr = targetGeo.findPointAttribute(it.name());
if (sourceAttr && targetAttr) {
AttributeCopyBase::Ptr att = createAttributeCopier(*sourceAttr, *targetAttr);
if(att) pointAttributeList.push_back(att);
}
}
if (!boss.wasInterrupted() && !pointAttributeList.empty()) {
UTparallelFor(GA_SplittableRange(targetGeo.getPointRange()),
TransferPointAttributesOp<GridType>(sourceGeo, targetGeo, indexGrid,
pointAttributeList, primitives));
}
}
}
} // namespace openvdb_houdini
#endif // OPENVDB_HOUDINI_ATTRIBUTE_TRANSFER_UTIL_HAS_BEEN_INCLUDED
| 47,264 | C | 29.04768 | 100 | 0.597558 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Read.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Read.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/GEO_PrimVDB.h>
#include <openvdb_houdini/GU_PrimVDB.h>
#include <UT/UT_Interrupt.h>
#include <cctype>
#include <stdexcept>
#include <string>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Read: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Read(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Read() override {}
void getDescriptiveParmName(UT_String& s) const override { s = "file_name"; }
static void registerSop(OP_OperatorTable*);
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned input) const override { return (input == 0); }
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
bool updateParmsFlags() override;
};
////////////////////////////////////////
namespace {
// Populate a choice list with grid names read from a VDB file.
void
populateGridMenu(void* data, PRM_Name* choicenames, int listsize,
const PRM_SpareData*, const PRM_Parm*)
{
choicenames[0].setToken(0);
choicenames[0].setLabel(0);
hvdb::SOP_NodeVDB* sop = static_cast<hvdb::SOP_NodeVDB*>(data);
if (sop == nullptr) return;
// Get the parameters from the GUI
// The file name of the vdb we would like to load
const auto file_name = sop->evalStdString("file_name", 0);
// Keep track of how many names we have entered
int count = 0;
// Add the star token to the menu
choicenames[0].setTokenAndLabel("*", "*");
++count;
try {
// Open the file and read the header, but don't read in any grids.
// An exception is thrown if the file is not a valid VDB file.
openvdb::io::File file(file_name);
file.open();
// Loop over the names of all of the grids in the file.
for (openvdb::io::File::NameIterator nameIter = file.beginName();
nameIter != file.endName(); ++nameIter)
{
// Make sure we don't write more than the listsize,
// and reserve a spot for the terminating 0.
if (count > listsize - 2) break;
std::string gridName = nameIter.gridName(), tokenName = gridName;
// When a file contains multiple grids with the same name, the names are
// distinguished with a trailing array index ("grid[0]", "grid[1]", etc.).
// Escape such names as "grid\[0]", "grid\[1]", etc. to inhibit UT_String's
// pattern matching.
if (tokenName.back() == ']') {
auto start = tokenName.find_last_of('[');
if (start != std::string::npos && tokenName[start + 1] != ']') {
for (auto i = start + 1; i < tokenName.size() - 1; ++i) {
// Only digits should appear between the last '[' and the trailing ']'.
if (!std::isdigit(tokenName[i])) { start = std::string::npos; break; }
}
if (start != std::string::npos) tokenName.replace(start, 1, "\\[");
}
}
// Add the grid's name to the list.
choicenames[count].setTokenAndLabel(tokenName.c_str(), gridName.c_str());
++count;
}
file.close();
} catch (...) {}
// Terminate the list.
choicenames[count].setTokenAndLabel(nullptr, nullptr);
}
// Callback to trigger a file reload
int
reloadCB(void* data, int /*idx*/, float /*time*/, const PRM_Template*)
{
SOP_OpenVDB_Read* sop = static_cast<SOP_OpenVDB_Read*>(data);
if (nullptr != sop) {
sop->forceRecook();
return 1; // request a refresh of the parameter pane
}
return 0; // no refresh
}
} // unnamed namespace
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Metadata-only toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "metadata_only", "Read Metadata Only")
.setDefault(PRMzeroDefaults)
.setTooltip(
"If enabled, output empty VDBs populated with their metadata and transforms only."));
// Clipping toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "clip", "Clip to Reference Bounds")
.setDefault(PRMzeroDefaults)
.setTooltip("Clip VDBs to the bounding box of the reference geometry."));
// Filename
parms.add(hutil::ParmFactory(PRM_FILE, "file_name", "File Name")
.setDefault(0, "./filename.vdb")
.setTooltip("Select a VDB file."));
// Grid name mask
parms.add(hutil::ParmFactory(PRM_STRING, "grids", "VDB(s)")
.setDefault(0, "*")
.setChoiceList(new PRM_ChoiceList(PRM_CHOICELIST_TOGGLE, populateGridMenu))
.setTooltip("VDB names separated by white space (wildcards allowed)")
.setDocumentation(
"VDB names separated by white space (wildcards allowed)\n\n"
"NOTE:\n"
" To distinguish between multiple VDBs with the same name,\n"
" append an array index to the name: `density\\[0]`, `density\\[1]`, etc.\n"
" Escape the index with a backslash to inhibit wildcard pattern matching.\n"));
// Toggle to enable/disable grouping
parms.add(hutil::ParmFactory(PRM_TOGGLE, "enable_grouping", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setDefault(PRMoneDefaults)
.setTooltip(
"If enabled, create a group with the given name that comprises the selected VDBs.\n"
"If disabled, do not group the selected VDBs."));
// Name for the output group
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setDefault(0,
"import os.path\n"
"return os.path.splitext(os.path.basename(ch('file_name')))[0]",
CH_PYTHON_EXPRESSION)
.setTooltip("Specify a name for this group of VDBs."));
// Missing Frame menu
{
char const * const items[] = {
"error", "Report Error",
"empty", "No Geometry",
nullptr
};
parms.add(hutil::ParmFactory(PRM_ORD, "missingframe", "Missing Frame")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip(
"If the specified file does not exist on disk, either report an error"
" (Report Error) or warn and continue (No Geometry)."));
}
// Reload button
parms.add(hutil::ParmFactory(PRM_CALLBACK, "reload", "Reload File")
.setCallbackFunc(&reloadCB)
.setTooltip("Reread the VDB file."));
parms.add(hutil::ParmFactory(PRM_SEPARATOR, "sep1", "Sep"));
// Delayed loading
parms.add(hutil::ParmFactory(PRM_TOGGLE, "delayload", "Delay Loading")
.setDefault(PRMoneDefaults)
.setTooltip(
"Don't allocate memory for or read voxel values until the values"
" are actually accessed.\n\n"
"Delayed loading can significantly lower memory usage, but\n"
"note that viewport visualization of a volume usually requires\n"
"the entire volume to be loaded into memory."));
// Localization file size slider
parms.add(hutil::ParmFactory(PRM_FLT_J, "copylimit", "Copy If Smaller Than")
.setTypeExtended(PRM_TYPE_JOIN_PAIR)
.setDefault(0.5f)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10)
.setTooltip(
"When delayed loading is enabled, a file must not be modified on disk before\n"
"it has been fully read. For safety, files smaller than the given size (in GB)\n"
"will be copied to a private, temporary location (either $OPENVDB_TEMP_DIR,\n"
"$TMPDIR or a system default temp directory).")
.setDocumentation(
"When delayed loading is enabled, a file must not be modified on disk before"
" it has been fully read. For safety, files smaller than the given size (in GB)"
" will be copied to a private, temporary location (either `$OPENVDB_TEMP_DIR`,"
" `$TMPDIR` or a system default temp directory)."));
parms.add(hutil::ParmFactory(PRM_LABEL, "copylimitlabel", "GB")
.setDocumentation(nullptr));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Read", SOP_OpenVDB_Read::factory, parms, *table)
.setNativeName("")
.addOptionalInput("Optional Bounding Geometry")
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Read a `.vdb` file from disk.\"\"\"\n\
\n\
@overview\n\
\n\
This node reads VDB volumes from a `.vdb` file.\n\
It is usually preferable to use Houdini's native [File|Node:sop/file] node,\n\
however unlike the native node, this node allows one to take advantage of\n\
delayed loading, meaning that only those portions of a volume that are\n\
actually accessed in a scene get loaded into memory.\n\
Delayed loading can significantly reduce memory usage when working\n\
with large volumes (but note that viewport visualization of a volume\n\
usually requires the entire volume to be loaded into memory).\n\
\n\
@related\n\
- [OpenVDB Write|Node:sop/DW_OpenVDBWrite]\n\
- [Node:sop/file]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Read::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Read(net, name, op);
}
SOP_OpenVDB_Read::SOP_OpenVDB_Read(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
// Disable parms in the UI.
bool
SOP_OpenVDB_Read::updateParmsFlags()
{
bool changed = false;
float t = 0.0;
changed |= enableParm("group", bool(evalInt("enable_grouping", 0, t)));
const bool delayedLoad = evalInt("delayload", 0, t);
changed |= enableParm("copylimit", delayedLoad);
changed |= enableParm("copylimitlabel", delayedLoad);
return changed;
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Read::cookVDBSop(OP_Context& context)
{
try {
hutil::ScopedInputLock lock(*this, context);
gdp->clearAndDestroy();
const fpreal t = context.getTime();
const bool
readMetadataOnly = evalInt("metadata_only", 0, t),
missingFrameIsError = (0 == evalInt("missingframe", 0, t));
// Get the file name string from the UI.
const std::string filename = evalStdString("file_name", t);
// Get the grid mask string.
UT_String gridStr;
evalString(gridStr, "grids", 0, t);
// Get the group name string.
UT_String groupStr;
if (evalInt("enable_grouping", 0, t)) {
evalString(groupStr, "group", 0, t);
// If grouping is enabled but no group name was given, derive the group name
// from the filename (e.g., "bar", given filename "/foo/bar.vdb").
/// @internal Currently this is done with an expression on the parameter,
/// but it could alternatively be done as follows:
//if (!groupStr.isstring()) {
// groupStr = filename;
// groupStr = UT_String(groupStr.fileName());
// groupStr = groupStr.pathUpToExtension();
//}
}
const bool delayedLoad = evalInt("delayload", 0, t);
const openvdb::Index64 copyMaxBytes =
openvdb::Index64(1.0e9 * evalFloat("copylimit", 0, t));
openvdb::BBoxd clipBBox;
bool clip = evalInt("clip", 0, t);
if (clip) {
if (const GU_Detail* clipGeo = inputGeo(0)) {
UT_BoundingBox box;
clipGeo->getBBox(&box);
clipBBox.min()[0] = box.xmin();
clipBBox.min()[1] = box.ymin();
clipBBox.min()[2] = box.zmin();
clipBBox.max()[0] = box.xmax();
clipBBox.max()[1] = box.ymax();
clipBBox.max()[2] = box.zmax();
}
clip = clipBBox.isSorted();
}
UT_AutoInterrupt progress(("Reading " + filename).c_str());
openvdb::io::File file(filename);
openvdb::MetaMap::Ptr fileMetadata;
try {
// Open the VDB file, but don't read any grids yet.
file.setCopyMaxBytes(copyMaxBytes);
file.open(delayedLoad);
// Read the file-level metadata.
fileMetadata = file.getMetadata();
if (!fileMetadata) fileMetadata.reset(new openvdb::MetaMap);
} catch (std::exception& e) { ///< @todo consider catching only openvdb::IoError
std::string mesg;
if (const char* s = e.what()) mesg = s;
// Strip off the exception name from an openvdb::IoError.
if (mesg.substr(0, 9) == "IoError: ") mesg = mesg.substr(9);
if (missingFrameIsError) {
addError(SOP_MESSAGE, mesg.c_str());
} else {
addWarning(SOP_MESSAGE, mesg.c_str());
}
return error();
}
// Create a group for the grid primitives.
GA_PrimitiveGroup* group = nullptr;
if (groupStr.isstring()) {
group = gdp->newPrimitiveGroup(groupStr.buffer());
}
// Loop over all grids in the file.
for (openvdb::io::File::NameIterator nameIter = file.beginName();
nameIter != file.endName(); ++nameIter)
{
if (progress.wasInterrupted()) throw std::runtime_error("Was Interrupted");
// Skip grids whose names don't match the user-supplied mask.
const std::string& gridName = nameIter.gridName();
if (!UT_String(gridName).multiMatch(gridStr.buffer(), 1, " ")) continue;
hvdb::GridPtr grid;
if (readMetadataOnly) {
grid = file.readGridMetadata(gridName);
} else if (clip) {
grid = file.readGrid(gridName, clipBBox);
} else {
grid = file.readGrid(gridName);
}
if (grid) {
// Copy file-level metadata into the grid, then create (if necessary)
// and set a primitive attribute for each metadata item.
for (openvdb::MetaMap::ConstMetaIterator fileMetaIt = fileMetadata->beginMeta(),
end = fileMetadata->endMeta(); fileMetaIt != end; ++fileMetaIt)
{
// Resolve file- and grid-level metadata name conflicts
// in favor of the grid-level metadata.
if (openvdb::Metadata::Ptr meta = fileMetaIt->second) {
const std::string name = fileMetaIt->first;
if (!(*grid)[name]) {
grid->insertMeta(name, *meta);
}
}
}
// Add a new VDB primitive for this grid.
// Note: this clears the grid's metadata.
GEO_PrimVDB* vdb = hvdb::createVdbPrimitive(*gdp, grid);
// Add the primitive to the group.
if (group) group->add(vdb);
}
}
file.close();
// If a group was created but no grids were added to it, delete the group.
if (group && group->isEmpty()) gdp->destroyPrimitiveGroup(group);
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 15,956 | C++ | 34.618303 | 97 | 0.583918 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Activate.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Activate.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Activate VDBs according to various rules
// OpenVDB and Houdini use different relative directories, but SESI_OPENVDB
// is not yet defined at this point.
#if 1
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#else
#include "Utils.h"
#include "ParmFactory.h"
#include "SOP_NodeVDB.h"
#endif
#include <GU/GU_PrimVDB.h>
#include <OP/OP_Node.h>
#include <OP/OP_Operator.h>
#include <OP/OP_OperatorTable.h>
#include <PRM/PRM_Parm.h>
#include <openvdb/openvdb.h>
#include <openvdb/Types.h>
#include <openvdb/tools/Morphology.h>
#include <openvdb/tools/Prune.h>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
using namespace openvdb_houdini;
enum REGIONTYPE_NAMES
{
REGIONTYPE_POSITION,
REGIONTYPE_VOXEL,
REGIONTYPE_EXPAND,
REGIONTYPE_REFERENCE,
REGIONTYPE_DEACTIVATE,
REGIONTYPE_FILL
};
enum OPERATION_NAMES
{
OPERATION_UNION,
OPERATION_INTERSECT,
OPERATION_SUBTRACT,
OPERATION_COPY
};
class SOP_VDBActivate : public hvdb::SOP_NodeVDB
{
public:
const char *inputLabel(unsigned idx) const override;
int isRefInput(unsigned i) const override;
bool updateParmsFlags() override;
static OP_Node *factory(OP_Network*, const char *, OP_Operator*);
class Cache: public SOP_VDBCacheOptions
{
OP_ERROR cookVDBSop(OP_Context&) override;
openvdb::CoordBBox getIndexSpaceBounds(OP_Context &context,
const GEO_PrimVDB &vdb);
UT_BoundingBox getWorldBBox(fpreal t);
protected:
REGIONTYPE_NAMES REGIONTYPE(double t) { return (REGIONTYPE_NAMES) evalInt("regiontype", 0, t); }
OPERATION_NAMES OPERATION(fpreal t) { return (OPERATION_NAMES) evalInt("operation", 0, t); }
UT_Vector3D CENTER(fpreal t)
{ return UT_Vector3D(evalFloat("center", 0, t),
evalFloat("center", 1, t),
evalFloat("center", 2, t)); }
UT_Vector3D SIZE(fpreal t)
{ return UT_Vector3D(evalFloat("size", 0, t),
evalFloat("size", 1, t),
evalFloat("size", 2, t)); }
openvdb::Coord MINPOS(fpreal t)
{ return openvdb::Coord(evalVec3i("min", t)); }
openvdb::Coord MAXPOS(fpreal t)
{ return openvdb::Coord(evalVec3i("max", t)); }
};
protected:
SOP_VDBActivate(OP_Network *net, const char *name, OP_Operator *entry);
~SOP_VDBActivate() override {}
REGIONTYPE_NAMES REGIONTYPE(double t) { return (REGIONTYPE_NAMES) evalInt("regiontype", 0, t); }
OPERATION_NAMES OPERATION(fpreal t) { return (OPERATION_NAMES) evalInt("operation", 0, t); }
};
void
#ifdef SESI_OPENVDB
new_SOP_VDBActivate(OP_OperatorTable *table)
#else
newSopOperator(OP_OperatorTable *table)
#endif
{
if (table == NULL) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Source Group")
.setHelpText("Specify a subset of the input VDB grids to be processed.")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("The vdb primitives to change the active region in.")
.setDocumentation("The vdb primitives to change the active region in."));
// Match OPERATION
const char* operations[] = {
"union", "Union",
"intersect", "Intersect",
"subtract", "A - B",
"copy", "Copy",
NULL
};
parms.add(hutil::ParmFactory(PRM_ORD, "operation", "Operation")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, operations)
.setTooltip("The vdb's current region is combined with the specified region in one of several ways.")
.setDocumentation(
R"(The vdb's current region is combined with the specified region
in one of several ways.
Union:
All voxels that lie in the specified region will
be activated. Other voxels will retain their original
activation states.
Intersect:
Any voxel not in the specified region will be deactivated
and set to the background value.
A - B:
Any voxel that is in the specified region will be deactivated
and set to the background value.
Copy:
If a voxel is outside the specified region, it is set
to inactive and the background value. If it is inside,
it is marked as active.)"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setvalue", "Write Value")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setDefault(PRMoneDefaults));
parms.add(hutil::ParmFactory(PRM_FLT, "value", "Value")
.setDefault(PRMoneDefaults)
.setTooltip("In the Union and Copy modes, when voxels are marked active they can also be initialized to a constant value.")
.setDocumentation(
R"(In the Union and Copy modes, when voxels are marked active they can also be
initialized to a constant value. This will be done to all voxels that are
made active by the specification - including those that were already
active.
Thus, the Voxel Coordinats option will have the effect of setting a cube
area to a constant value.)"));
// Match REGIONTYPE
parms.beginExclusiveSwitcher("regiontype", "Region Type");
parms.addFolder("Position");
/*
This defines a cube in SOP space. Any voxel that touches this
cube will be part of the selected region.
*/
parms.add(hutil::ParmFactory(PRM_XYZ, "center", "Center")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setTooltip("This defines a cube in SOP space.")
.setDocumentation(
R"(This defines a cube in SOP space. Any voxel that touches this cube will be part of the selected region.)"));
parms.add(hutil::ParmFactory(PRM_XYZ, "size", "Size")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setTooltip("This defines a cube in SOP space.")
.setDocumentation(
R"(This defines a cube in SOP space. Any voxel that touches this cube will be part of the selected region.)"));
parms.addFolder("Voxel");
/*
Defines minimum and maximum values of a box in voxel-coordinates. This is
an inclusive range, so includes the maximum voxel.
*/
parms.add(hutil::ParmFactory(PRM_XYZ, "min", "Min")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setTooltip("Defines minimum and maximum values of a box in voxel-coordinates.")
.setDocumentation(
R"(Defines minimum values of a box in voxel-coordinates. This is
an inclusive range, so includes the maximum voxel.)"));
parms.add(hutil::ParmFactory(PRM_XYZ, "max", "Max")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setTooltip("Defines minimum and maximum values of a box in voxel-coordinates.")
.setDocumentation(
R"(Defines maximum values of a box in voxel-coordinates. This is
an inclusive range, so includes the maximum voxel.)"));
parms.addFolder("Expand");
/*
Expand the active area by the specified number of voxels. Does not support
operation or setting of values.
*/
parms.add(hutil::ParmFactory(PRM_INT, "expand", "Voxels to Expand")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_FREE, -5, PRM_RANGE_FREE, 5)
.setTooltip("Expand the active area by the specified number of voxels.")
.setDocumentation(
R"(Expand the active area by the specified number of voxels. Does not support
operation or setting of values.)"));
parms.addFolder("Reference");
/*
Uses the second input to determine the selected region.
*/
parms.add(hutil::ParmFactory(PRM_STRING, "boundgroup", "Bound Group")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("Which primitives of the second input contribute to the bounding box computation.")
.setDocumentation(
R"(Which primitives of the second input contribute to the bounding box
computation.)"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "usevdb", "Activate Using VDBs")
.setDefault(PRMzeroDefaults)
.setTooltip("If turned on, only VDBs are used for activation.")
.setDocumentation(
R"(If turned on, only VDBs are used for activation. They will activate
wherever they themselves are already active. This can be used to
transfer the active region from one VDB to another, even if they are
not aligned.
If turned off, the bounding box of the chosen primitives are used
instead and activated as if they were specified as World Positions.)"));
parms.addFolder("Deactivate");
/*
Any voxels that have the background value will be deactivated. This
is useful for cleaning up the result of an operation that may
have speculatively activated a large band of voxels, but may
not have placed non-background values in all of them.
For example, you may have a VDB Activate before a Volume VOP
with Expand turned on to ensure you have room to displace the volume.
Then when you are done, you can use one with Deactivate to free
up the voxels you didn't need to use.
*/
parms.addFolder("Fill SDF");
/*
Any voxels that are inside the SDF will be marked active. If they
were previously inactive, they will be set to the negative-background
values. Tiles will remain sparse in this process.
*/
parms.endSwitcher();
// Prune toggle
parms.add(hutil::ParmFactory(PRM_TOGGLE, "prune", "Prune Tolerance")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("This tolerance is used to detect constant regions and collapse them.")
.setDocumentation(
R"(After building the VDB grid there may be undetected constant tiles.
This tolerance is used to detect constant regions and collapse them.
Such areas that are within the background value will also be marked
inactive.)"));
// Pruning tolerance slider
parms.add(hutil::ParmFactory(
PRM_FLT_J, "tolerance", "Prune Tolerance")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 1)
.setTooltip("This tolerance is used to detect constant regions and collapse them.")
.setDocumentation(
R"(After building the VDB grid there may be undetected constant tiles.
This tolerance is used to detect constant regions and collapse them.
Such areas that are within the background value will also be marked
inactive.)"));
hvdb::OpenVDBOpFactory("VDB Activate",
SOP_VDBActivate::factory, parms, *table)
.addInput("VDBs to Activate")
.addOptionalInput("Bounds to Activate")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_VDBActivate::Cache; })
.setDocumentation(
R"(#icon: COMMON/openvdb
#tags: vdb
= OpenVDB Activate =
"""Activates voxel regions of a VDB for further processing."""
[Include:volume_types]
Many volume operations, such as Volume Mix and Volume VOP, only process
active voxels in the sparse volume. This can be a problem if you know a
certain area in space will evaluate to a non-zero value, but it is
inactive in your original volume.
The VDB Activate SOP provides tools for manipulating this active region.
It can also fill the newly added regions to a constant value, useful
for interactively determining what is changing.
TIP: To see the current active region, you can use the VDB Visualize SOP
and set it to Tree Nodes, Disabled; Active Constant Tiles, Wireframe Box;
and Active Voxels, Wireframe Box.
@related
- [Node:sop/vdb]
- [Node:sop/vdbactivatesdf]
- [Node:sop/volumevop]
- [Node:sop/volumemix]
)");
}
bool
SOP_VDBActivate::updateParmsFlags()
{
bool has_bounds = (nInputs() > 1);
REGIONTYPE_NAMES regiontype = REGIONTYPE(0.0f);
OPERATION_NAMES operation = OPERATION(0.0f);
bool regionusesvalue = (regiontype != REGIONTYPE_EXPAND) && (regiontype != REGIONTYPE_DEACTIVATE);
bool operationusesvalue = (operation == OPERATION_UNION) || (operation == OPERATION_COPY);
if (regiontype == REGIONTYPE_FILL)
regionusesvalue = false;
// Disable the region type switcher
int changed = 0;
changed += enableParm("boundgroup", has_bounds);
changed += enableParm("usevdb", has_bounds);
changed += enableParm("operation", regionusesvalue);
// Only union supports writing values.
changed += enableParm("setvalue", regionusesvalue && operationusesvalue);
changed += enableParm("value", regionusesvalue && operationusesvalue && evalInt("setvalue", 0, 0.0));
changed += enableParm("tolerance", (evalInt("prune", 0, 0.0f) != 0));
return changed > 0;
}
SOP_VDBActivate::SOP_VDBActivate(OP_Network *net,
const char *name,
OP_Operator *entry)
: SOP_NodeVDB(net, name, entry)
{}
OP_Node *
SOP_VDBActivate::factory(OP_Network *net,
const char *name,
OP_Operator *entry)
{
return new SOP_VDBActivate(net, name, entry);
}
UT_BoundingBox
SOP_VDBActivate::Cache::getWorldBBox(fpreal t)
{
UT_Vector3D center = CENTER(t);
UT_Vector3D size = SIZE(t);
return UT_BoundingBox(center - 0.5*size, center + 0.5*size);
}
// Get a bounding box around the world space bbox in index space
static
openvdb::CoordBBox
sopSopToIndexBBox(UT_BoundingBoxD sop_bbox, const GEO_PrimVDB &vdb)
{
UT_Vector3D corners[8];
sop_bbox.getBBoxPoints(corners);
openvdb::CoordBBox index_bbox;
for (int i=0; i<8; i++)
{
int x, y, z;
vdb.posToIndex(corners[i], x, y, z);
openvdb::Coord coord(x,y,z);
if (i == 0)
index_bbox = openvdb::CoordBBox(coord, coord);
else
index_bbox.expand(openvdb::Coord(x, y, z));
}
return index_bbox;
}
template <typename GridType>
void
sopDoPrune(GridType &grid, bool doprune, double tolerance)
{
typedef typename GridType::ValueType ValueT;
// No matter what, axe inactive voxels.
openvdb::tools::pruneInactive(grid.tree());
// Optionally prune live tiles
if (doprune) {
OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
const auto value = openvdb::zeroVal<ValueT>() + tolerance;
OPENVDB_NO_TYPE_CONVERSION_WARNING_END
grid.tree().prune(static_cast<ValueT>(value));
}
}
// The result of the union of active regions goes into grid_a
template <typename GridType>
static void
sopDeactivate(GridType &grid, int dummy)
{
typename GridType::Accessor access = grid.getAccessor();
typedef typename GridType::ValueType ValueT;
ValueT background = grid.background();
ValueT value;
UT_Interrupt *boss = UTgetInterrupt();
for (typename GridType::ValueOnCIter
iter = grid.cbeginValueOn(); iter; ++iter)
{
if (boss->opInterrupt())
break;
openvdb::CoordBBox bbox = iter.getBoundingBox();
for (int k=bbox.min().z(); k<=bbox.max().z(); k++)
{
for (int j=bbox.min().y(); j<=bbox.max().y(); j++)
{
for (int i=bbox.min().x(); i<=bbox.max().x(); i++)
{
openvdb::Coord coord(i, j, k);
// If it is on...
if (access.probeValue(coord, value))
{
if (value == background)
{
access.setValueOff(coord);
}
}
}
}
}
}
}
template <typename GridType>
static void
sopFillSDF(GridType &grid, int dummy)
{
typename GridType::Accessor access = grid.getAccessor();
typedef typename GridType::ValueType ValueT;
ValueT value;
UT_Interrupt *boss = UTgetInterrupt();
ValueT background = grid.background();
for (typename GridType::ValueOffCIter
iter = grid.cbeginValueOff(); iter; ++iter)
{
if (boss->opInterrupt())
break;
openvdb::CoordBBox bbox = iter.getBoundingBox();
// Assuming the SDF is at all well-formed, any crossing
// of sign must have a crossing of inactive->active.
openvdb::Coord coord(bbox.min().x(), bbox.min().y(), bbox.min().z());
// We do not care about the active state as it is hopefully inactive
access.probeValue(coord, value);
if (value < 0)
{
// Fill the region to negative background.
grid.fill(bbox, -background, /*active=*/true);
}
}
}
template <typename GridType>
static void
sopDilateVoxels(GridType& grid, int count)
{
openvdb::tools::dilateVoxels(grid.tree(), count);
}
template <typename GridType>
static void
sopErodeVoxels(GridType& grid, int count)
{
openvdb::tools::erodeVoxels(grid.tree(), count);
}
// Based on mode the parameters imply, get an index space bounds for this vdb
openvdb::CoordBBox
SOP_VDBActivate::Cache::getIndexSpaceBounds(OP_Context &context,
const GEO_PrimVDB &vdb)
{
fpreal t = context.getTime();
using namespace openvdb;
CoordBBox index_bbox;
// Get the bbox
switch(REGIONTYPE(t))
{
case REGIONTYPE_POSITION: // world
index_bbox = sopSopToIndexBBox(getWorldBBox(t), vdb);
break;
case REGIONTYPE_VOXEL: // index
index_bbox = CoordBBox(MINPOS(t), MAXPOS(t));
break;
default:
UT_ASSERT("Invalid region type" == nullptr);
break;
}
return index_bbox;
}
GEO_PrimVDB::ActivateOperation
sopXlateOperation(OPERATION_NAMES operation)
{
switch (operation)
{
case OPERATION_UNION:
return GEO_PrimVDB::ACTIVATE_UNION;
case OPERATION_INTERSECT:
return GEO_PrimVDB::ACTIVATE_INTERSECT;
case OPERATION_SUBTRACT:
return GEO_PrimVDB::ACTIVATE_SUBTRACT;
case OPERATION_COPY:
return GEO_PrimVDB::ACTIVATE_COPY;
}
UT_ASSERT("Unhandled operation" == nullptr);
return GEO_PrimVDB::ACTIVATE_UNION;
}
OP_ERROR
SOP_VDBActivate::Cache::cookVDBSop(OP_Context &context)
{
using namespace openvdb;
using namespace openvdb::math;
try
{
fpreal t = context.getTime();
UT_Interrupt *boss = UTgetInterrupt();
// Get the group
UT_String group_name;
evalString(group_name, "group", 0, t);
const GA_PrimitiveGroup* group = 0;
if (group_name.isstring())
{
bool success;
group = gop.parseOrderedPrimitiveDetached((const char *) group_name, gdp, false, success);
}
// A group was specified but not found
if (!group && group_name.isstring())
{
addError(SOP_ERR_BADGROUP, group_name);
return error();
}
UT_AutoInterrupt progress("Activating VDB grids");
// For each primitive in the group, go through the primitives in the
// second input's group and
GEO_Primitive *prim;
GA_FOR_ALL_GROUP_PRIMITIVES(gdp, group, prim)
{
if (!(prim->getPrimitiveId() & GEO_PrimTypeCompat::GEOPRIMVDB))
break;
GEO_PrimVDB *vdb = UTverify_cast<GEO_PrimVDB *>(prim);
vdb->makeGridUnique();
// Apply the operation for all VDB primitives on input 2
const GU_Detail *bounds_src = inputGeo(1, context);
switch (REGIONTYPE(t))
{
case REGIONTYPE_REFERENCE: // Second input!
{
if (bounds_src)
{
UT_String boundgroupname;
evalString(boundgroupname, "boundgroup", 0, t);
const GA_PrimitiveGroup *boundgroup = 0;
if (boundgroupname.isstring())
{
bool success;
boundgroup = gop.parseOrderedPrimitiveDetached((const char *) boundgroupname, bounds_src, true, success);
if (!success)
addWarning(SOP_ERR_BADGROUP, boundgroupname);
}
if (evalInt("usevdb", 0, t))
{
bool foundvdb = false;
const GEO_Primitive *input_prim;
GA_FOR_ALL_GROUP_PRIMITIVES(bounds_src, boundgroup, input_prim)
{
if (!(input_prim->getPrimitiveId() & GEO_PrimTypeCompat::GEOPRIMVDB))
break;
const GEO_PrimVDB *input_vdb =
UTverify_cast<const GEO_PrimVDB *>(input_prim);
vdb->activateByVDB(input_vdb,
sopXlateOperation(OPERATION(t)),
evalInt("setvalue", 0, t),
evalFloat("value", 0, t));
foundvdb = true;
}
if (!foundvdb)
{
addWarning(SOP_MESSAGE, "No VDB primitives found in second input");
}
}
else
{
// Activate by bounding box.
UT_BoundingBox bbox;
bounds_src->getBBox(&bbox, boundgroup);
vdb->activateIndexBBox(sopSopToIndexBBox(bbox, *vdb), sopXlateOperation(OPERATION(t)), evalInt("setvalue", 0, t), evalFloat("value", 0, t));
}
}
else
{
addError(SOP_MESSAGE, "Not enough inputs.");
}
break;
}
case REGIONTYPE_POSITION: // World space
case REGIONTYPE_VOXEL: // Coord Space
{
vdb->activateIndexBBox(getIndexSpaceBounds(context, *vdb), sopXlateOperation(OPERATION(t)), evalInt("setvalue", 0, t), evalFloat("value", 0, t));
break;
}
case REGIONTYPE_EXPAND: // Dilate
{
int dilation = static_cast<int>(evalInt("expand", 0, t));
if (dilation > 0)
{
if (boss->opInterrupt())
break;
UTvdbCallAllTopology(vdb->getStorageType(),
sopDilateVoxels,
vdb->getGrid(), dilation);
}
if (dilation < 0)
{
if (boss->opInterrupt())
break;
UTvdbCallAllTopology(vdb->getStorageType(),
sopErodeVoxels,
vdb->getGrid(), -dilation);
}
break;
}
case REGIONTYPE_DEACTIVATE: // Deactivate
{
if (boss->opInterrupt())
break;
UTvdbCallAllTopology(vdb->getStorageType(),
sopDeactivate,
vdb->getGrid(), 1);
break;
}
case REGIONTYPE_FILL: // Fill interior of SDF.
{
if (boss->opInterrupt())
break;
UTvdbCallRealType(vdb->getStorageType(),
sopFillSDF,
vdb->getGrid(), 1);
break;
}
}
UTvdbCallAllTopology(vdb->getStorageType(),
sopDoPrune,
vdb->getGrid(),
evalInt("prune", 0, t),
evalFloat("tolerance", 0, t));
}
}
catch (std::exception& e)
{
addError(SOP_MESSAGE, e.what());
}
return error();
}
const char *
SOP_VDBActivate::inputLabel(unsigned index) const
{
switch (index)
{
case 0:
return "VDBs to activate";
case 1:
return "Region to activate";
}
return NULL;
}
int
SOP_VDBActivate::isRefInput(unsigned i) const
{
switch (i)
{
case 0:
return false;
case 1:
return true;
default:
return true;
}
}
| 25,557 | C++ | 33.168449 | 168 | 0.57722 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/geometry.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file geometry.cc
/// @author FX R&D OpenVDB team
#include "geometry.h"
#include <GU/GU_PrimPoly.h>
namespace houdini_utils {
void
createBox(GU_Detail& gdp, UT_Vector3 corners[8],
const UT_Vector3* color, bool shaded, float alpha)
{
// Create points
GA_Offset ptoff[8];
for (size_t i = 0; i < 8; ++i) {
ptoff[i] = gdp.appendPointOffset();
gdp.setPos3(ptoff[i], corners[i].x(), corners[i].y(), corners[i].z());
}
if (color != NULL) {
GA_RWHandleV3 cd(gdp.addDiffuseAttribute(GA_ATTRIB_POINT));
for (size_t i = 0; i < 8; ++i) {
cd.set(ptoff[i], *color);
}
}
if (alpha < 0.99) {
GA_RWHandleF A(gdp.addAlphaAttribute(GA_ATTRIB_POINT));
for (size_t i = 0; i < 8; ++i) {
A.set(ptoff[i], alpha);
}
}
GEO_PrimPoly *poly;
if (shaded) {
// Bottom
poly = GU_PrimPoly::build(&gdp, 0);
poly->appendVertex(ptoff[0]);
poly->appendVertex(ptoff[1]);
poly->appendVertex(ptoff[2]);
poly->appendVertex(ptoff[3]);
poly->close();
// Top
poly = GU_PrimPoly::build(&gdp, 0);
poly->appendVertex(ptoff[7]);
poly->appendVertex(ptoff[6]);
poly->appendVertex(ptoff[5]);
poly->appendVertex(ptoff[4]);
poly->close();
// Front
poly = GU_PrimPoly::build(&gdp, 0);
poly->appendVertex(ptoff[4]);
poly->appendVertex(ptoff[5]);
poly->appendVertex(ptoff[1]);
poly->appendVertex(ptoff[0]);
poly->close();
// Back
poly = GU_PrimPoly::build(&gdp, 0);
poly->appendVertex(ptoff[6]);
poly->appendVertex(ptoff[7]);
poly->appendVertex(ptoff[3]);
poly->appendVertex(ptoff[2]);
poly->close();
// Left
poly = GU_PrimPoly::build(&gdp, 0);
poly->appendVertex(ptoff[0]);
poly->appendVertex(ptoff[3]);
poly->appendVertex(ptoff[7]);
poly->appendVertex(ptoff[4]);
poly->close();
// Right
poly = GU_PrimPoly::build(&gdp, 0);
poly->appendVertex(ptoff[1]);
poly->appendVertex(ptoff[5]);
poly->appendVertex(ptoff[6]);
poly->appendVertex(ptoff[2]);
poly->close();
} else {
// 12 Edges as one line
poly = GU_PrimPoly::build(&gdp, 0, GU_POLY_OPEN);
poly->appendVertex(ptoff[0]);
poly->appendVertex(ptoff[1]);
poly->appendVertex(ptoff[2]);
poly->appendVertex(ptoff[3]);
poly->appendVertex(ptoff[0]);
poly->appendVertex(ptoff[4]);
poly->appendVertex(ptoff[5]);
poly->appendVertex(ptoff[6]);
poly->appendVertex(ptoff[7]);
poly->appendVertex(ptoff[4]);
poly->appendVertex(ptoff[5]);
poly->appendVertex(ptoff[1]);
poly->appendVertex(ptoff[2]);
poly->appendVertex(ptoff[6]);
poly->appendVertex(ptoff[7]);
poly->appendVertex(ptoff[3]);
}
} // createBox
} // namespace houdini_utils
| 3,141 | C++ | 26.805309 | 78 | 0.548551 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Fill.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Fill.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_UniquePtr.h>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
namespace hutil = houdini_utils;
namespace hvdb = openvdb_houdini;
class SOP_OpenVDB_Fill: public hvdb::SOP_NodeVDB
{
public:
enum Mode { MODE_INDEX = 0, MODE_WORLD, MODE_GEOM };
SOP_OpenVDB_Fill(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Fill() override;
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned input) const override { return (input == 1); }
static Mode getMode(const std::string& modeStr)
{
if (modeStr == "index") return MODE_INDEX;
if (modeStr == "world") return MODE_WORLD;
if (modeStr == "geom") return MODE_GEOM;
throw std::runtime_error{"unrecognized mode \"" + modeStr + "\""};
}
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
};
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDBs to be processed.")
.setDocumentation(
"A subset of the input VDBs to be processed"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_STRING, "mode", "Bounds")
.setDefault("index")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"index", "Min and Max in Index Space",
"world", "Min and Max in World Space",
"geom", "Reference Geometry"
})
.setTooltip(
"Index Space:\n"
" Interpret the given min and max coordinates in index-space units.\n"
"World Space:\n"
" Interpret the given min and max coordinates in world-space units.\n"
"Reference Geometry:\n"
" Use the world-space bounds of the reference input geometry.")
.setDocumentation(
"How to specify the bounding box to be filled\n\n"
"Index Space:\n"
" Interpret the given min and max coordinates in"
" [index-space|http://www.openvdb.org/documentation/doxygen/overview.html#subsecVoxSpace] units.\n"
"World Space:\n"
" Interpret the given min and max coordinates in"
" [world-space|http://www.openvdb.org/documentation/doxygen/overview.html#subsecWorSpace] units.\n"
"Reference Geometry:\n"
" Use the world-space bounds of the reference input geometry.\n"));
parms.add(hutil::ParmFactory(PRM_INT_XYZ, "min", "Min Coord")
.setVectorSize(3)
.setTooltip("The minimum coordinate of the bounding box to be filled"));
parms.add(hutil::ParmFactory(PRM_INT_XYZ, "max", "Max Coord")
.setVectorSize(3)
.setTooltip("The maximum coordinate of the bounding box to be filled"));
parms.add(hutil::ParmFactory(PRM_XYZ, "worldmin", "Min Coord")
.setVectorSize(3)
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_XYZ, "worldmax", "Max Coord")
.setVectorSize(3)
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_XYZ, "val", "Value").setVectorSize(3)
.setTypeExtended(PRM_TYPE_JOIN_PAIR)
.setTooltip(
"The value with which to fill voxels\n"
"(y and z are ignored when filling scalar grids)"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "active", "Active")
.setDefault(PRMoneDefaults)
.setTooltip("If enabled, activate voxels in the fill region, otherwise deactivate them."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "sparse", "Sparse")
.setDefault(PRMoneDefaults)
.setTooltip("If enabled, represent the filled region sparsely (if possible)."));
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "value", "Value"));
hvdb::OpenVDBOpFactory("VDB Fill", SOP_OpenVDB_Fill::factory, parms, *table)
.setNativeName("")
.setObsoleteParms(obsoleteParms)
.addInput("Input with VDB grids to operate on")
.addOptionalInput("Optional bounding geometry")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Fill::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Fill and activate/deactivate regions of voxels within a VDB volume.\"\"\"\n\
\n\
@overview\n\
\n\
This node sets all voxels within an axis-aligned bounding box of a VDB volume\n\
to a given value and active state.\n\
By default, the operation uses a sparse voxel representation to reduce\n\
the memory footprint of the output volume.\n\
\n\
@related\n\
- [Node:sop/vdbactivate]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Fill::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
PRM_Parm* parm = obsoleteParms->getParmPtr("value");
if (parm && !parm->isFactoryDefault()) {
// Transfer the scalar value of the obsolete parameter "value"
// to the new, vector-valued parameter "val".
const fpreal val = obsoleteParms->evalFloat("value", 0, /*time=*/0.0);
setFloat("val", 0, 0.0, val);
setFloat("val", 1, 0.0, val);
setFloat("val", 2, 0.0, val);
}
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
bool
SOP_OpenVDB_Fill::updateParmsFlags()
{
bool changed = false;
const fpreal time = 0;
//int refExists = (nInputs() == 2);
Mode mode = MODE_INDEX;
try { mode = getMode(evalStdString("mode", time)); } catch (std::runtime_error&) {}
switch (mode) {
case MODE_INDEX:
changed |= enableParm("min", true);
changed |= enableParm("max", true);
changed |= setVisibleState("min", true);
changed |= setVisibleState("max", true);
changed |= setVisibleState("worldmin", false);
changed |= setVisibleState("worldmax", false);
break;
case MODE_WORLD:
changed |= enableParm("worldmin", true);
changed |= enableParm("worldmax", true);
changed |= setVisibleState("min", false);
changed |= setVisibleState("max", false);
changed |= setVisibleState("worldmin", true);
changed |= setVisibleState("worldmax", true);
break;
case MODE_GEOM:
changed |= enableParm("min", false);
changed |= enableParm("max", false);
changed |= enableParm("worldmin", false);
changed |= enableParm("worldmax", false);
break;
}
return changed;
}
OP_Node*
SOP_OpenVDB_Fill::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Fill(net, name, op);
}
SOP_OpenVDB_Fill::SOP_OpenVDB_Fill(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
SOP_OpenVDB_Fill::~SOP_OpenVDB_Fill()
{
}
namespace {
// Convert a Vec3 value to a vector of another value type or to a scalar value
// Overload for scalar types (discards all but the first vector component)
template<typename ValueType>
inline typename std::enable_if<!openvdb::VecTraits<ValueType>::IsVec, ValueType>::type
convertValue(const openvdb::Vec3R& val)
{
return ValueType(val[0]);
}
// Overload for Vec2 types (not currently used)
template<typename ValueType>
inline typename std::enable_if<openvdb::VecTraits<ValueType>::IsVec
&& openvdb::VecTraits<ValueType>::Size == 2, ValueType>::type
convertValue(const openvdb::Vec3R& val)
{
using ElemType = typename openvdb::VecTraits<ValueType>::ElementType;
return ValueType(ElemType(val[0]), ElemType(val[1]));
}
// Overload for Vec3 types
template<typename ValueType>
inline typename std::enable_if<openvdb::VecTraits<ValueType>::IsVec
&& openvdb::VecTraits<ValueType>::Size == 3, ValueType>::type
convertValue(const openvdb::Vec3R& val)
{
using ElemType = typename openvdb::VecTraits<ValueType>::ElementType;
return ValueType(ElemType(val[0]), ElemType(val[1]), ElemType(val[2]));
}
// Overload for Vec4 types (not currently used)
template<typename ValueType>
inline typename std::enable_if<openvdb::VecTraits<ValueType>::IsVec
&& openvdb::VecTraits<ValueType>::Size == 4, ValueType>::type
convertValue(const openvdb::Vec3R& val)
{
using ElemType = typename openvdb::VecTraits<ValueType>::ElementType;
return ValueType(ElemType(val[0]), ElemType(val[1]), ElemType(val[2]), ElemType(1.0));
}
////////////////////////////////////////
struct FillOp
{
const openvdb::CoordBBox indexBBox;
const openvdb::BBoxd worldBBox;
const openvdb::Vec3R value;
const bool active, sparse;
FillOp(const openvdb::CoordBBox& b, const openvdb::Vec3R& val, bool on, bool sparse_):
indexBBox(b), value(val), active(on), sparse(sparse_)
{}
FillOp(const openvdb::BBoxd& b, const openvdb::Vec3R& val, bool on, bool sparse_):
worldBBox(b), value(val), active(on), sparse(sparse_)
{}
template<typename GridT>
void operator()(GridT& grid) const
{
openvdb::CoordBBox bbox = indexBBox;
if (worldBBox) {
openvdb::math::Vec3d imin, imax;
openvdb::math::calculateBounds(grid.constTransform(),
worldBBox.min(), worldBBox.max(), imin, imax);
bbox.reset(openvdb::Coord::floor(imin), openvdb::Coord::ceil(imax));
}
using ValueT = typename GridT::ValueType;
if (sparse) {
grid.sparseFill(bbox, convertValue<ValueT>(value), active);
} else {
grid.denseFill(bbox, convertValue<ValueT>(value), active);
}
}
};
} // unnamed namespace
OP_ERROR
SOP_OpenVDB_Fill::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal t = context.getTime();
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", t));
const openvdb::Vec3R value = evalVec3R("val", t);
const bool
active = evalInt("active", 0, t),
sparse = evalInt("sparse", 0, t);
UT_UniquePtr<const FillOp> fillOp;
switch (SOP_OpenVDB_Fill::getMode(evalStdString("mode", t))) {
case MODE_INDEX:
{
const openvdb::CoordBBox bbox(
openvdb::Coord(
static_cast<openvdb::Int32>(evalInt("min", 0, t)),
static_cast<openvdb::Int32>(evalInt("min", 1, t)),
static_cast<openvdb::Int32>(evalInt("min", 2, t))),
openvdb::Coord(
static_cast<openvdb::Int32>(evalInt("max", 0, t)),
static_cast<openvdb::Int32>(evalInt("max", 1, t)),
static_cast<openvdb::Int32>(evalInt("max", 2, t))));
fillOp.reset(new FillOp(bbox, value, active, sparse));
break;
}
case MODE_WORLD:
{
const openvdb::BBoxd bbox(
openvdb::BBoxd::ValueType(
evalFloat("worldmin", 0, t),
evalFloat("worldmin", 1, t),
evalFloat("worldmin", 2, t)),
openvdb::BBoxd::ValueType(
evalFloat("worldmax", 0, t),
evalFloat("worldmax", 1, t),
evalFloat("worldmax", 2, t)));
fillOp.reset(new FillOp(bbox, value, active, sparse));
break;
}
case MODE_GEOM:
{
openvdb::BBoxd bbox;
if (const GU_Detail* refGeo = inputGeo(1)) {
UT_BoundingBox b;
refGeo->getBBox(&b);
if (!b.isValid()) {
throw std::runtime_error("no reference geometry found");
}
bbox.min()[0] = b.xmin();
bbox.min()[1] = b.ymin();
bbox.min()[2] = b.zmin();
bbox.max()[0] = b.xmax();
bbox.max()[1] = b.ymax();
bbox.max()[2] = b.zmax();
} else {
throw std::runtime_error("reference input is unconnected");
}
fillOp.reset(new FillOp(bbox, value, active, sparse));
break;
}
}
UT_AutoInterrupt progress("Filling VDB grids");
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (progress.wasInterrupted()) {
throw std::runtime_error("processing was interrupted");
}
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, *fillOp);
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 13,453 | C++ | 32.80402 | 99 | 0.60113 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Filter.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Filter.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Filtering operations for non-level-set grids
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/Filter.h>
#include <OP/OP_AutoLockInputs.h>
#include <UT/UT_Interrupt.h>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace {
// Operations should be numbered sequentially starting from 0.
// When adding an item to the end of this list, be sure to update NUM_OPERATIONS.
enum Operation {
OP_MEAN = 0,
OP_GAUSS,
OP_MEDIAN,
#ifndef SESI_OPENVDB
OP_OFFSET,
#endif
NUM_OPERATIONS
};
inline Operation
intToOp(int i)
{
switch (i) {
#ifndef SESI_OPENVDB
case OP_OFFSET: return OP_OFFSET;
#endif
case OP_MEAN: return OP_MEAN;
case OP_GAUSS: return OP_GAUSS;
case OP_MEDIAN: return OP_MEDIAN;
case NUM_OPERATIONS: break;
}
throw std::runtime_error{"unknown operation (" + std::to_string(i) + ")"};
}
inline Operation
stringToOp(const std::string& s)
{
if (s == "mean") return OP_MEAN;
if (s == "gauss") return OP_GAUSS;
if (s == "median") return OP_MEDIAN;
#ifndef SESI_OPENVDB
if (s == "offset") return OP_OFFSET;
#endif
throw std::runtime_error{"unknown operation \"" + s + "\""};
}
inline std::string
opToString(Operation op)
{
switch (op) {
#ifndef SESI_OPENVDB
case OP_OFFSET: return "offset";
#endif
case OP_MEAN: return "mean";
case OP_GAUSS: return "gauss";
case OP_MEDIAN: return "median";
case NUM_OPERATIONS: break;
}
throw std::runtime_error{"unknown operation (" + std::to_string(int(op)) + ")"};
}
inline std::string
opToMenuName(Operation op)
{
switch (op) {
#ifndef SESI_OPENVDB
case OP_OFFSET: return "Offset";
#endif
case OP_MEAN: return "Mean Value";
case OP_GAUSS: return "Gaussian";
case OP_MEDIAN: return "Median Value";
case NUM_OPERATIONS: break;
}
throw std::runtime_error{"unknown operation (" + std::to_string(int(op)) + ")"};
}
struct FilterParms {
FilterParms(Operation _op): op(_op) {}
Operation op;
int iterations = 1;
int radius = 1;
float worldRadius = 0.1f;
float minMask = 0.0f;
float maxMask = 0.0f;
bool invertMask = false;
bool useWorldRadius = false;
const openvdb::FloatGrid* mask = nullptr;
#ifndef SESI_OPENVDB
float offset = 0.0f;
bool verbose = false;
#endif
};
using FilterParmVec = std::vector<FilterParms>;
} // anonymous namespace
////////////////////////////////////////
class SOP_OpenVDB_Filter: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Filter(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Filter() override = default;
static void registerSop(OP_OperatorTable*);
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned input) const override { return (input == 1); }
protected:
void resolveObsoleteParms(PRM_ParmList*) override;
bool updateParmsFlags() override;
public:
class Cache: public SOP_VDBCacheOptions
{
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
OP_ERROR evalFilterParms(OP_Context&, GU_Detail&, FilterParmVec&);
}; // class Cache
private:
struct FilterOp;
};
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Filter::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Filter(net, name, op);
}
SOP_OpenVDB_Filter::SOP_OpenVDB_Filter(OP_Network* net, const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
void
newSopOperator(OP_OperatorTable* table)
{
SOP_OpenVDB_Filter::registerSop(table);
}
void
SOP_OpenVDB_Filter::registerSop(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Input group
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to be processed.")
.setDocumentation(
"A subset of the input VDBs to be processed"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "mask", "")
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setTooltip("Enable / disable the mask."));
parms.add(hutil::ParmFactory(PRM_STRING, "maskname", "Alpha Mask")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("Optional scalar VDB used for alpha masking\n\n"
"Values are assumed to be between 0 and 1."));
// Menu of operations
{
std::vector<std::string> items;
for (int i = 0; i < NUM_OPERATIONS; ++i) {
const Operation op = intToOp(i);
items.push_back(opToString(op)); // token
items.push_back(opToMenuName(op)); // label
}
parms.add(hutil::ParmFactory(PRM_STRING, "operation", "Operation")
.setDefault(opToString(OP_MEAN))
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip("The operation to be applied to input volumes")
.setDocumentation("\
The operation to be applied to input volumes\n\n\
Gaussian:\n\
Set the value of each active voxel to a Gaussian-weighted sum\n\
over the voxel's neighborhood.\n\n\
This is equivalent to a Gaussian blur.\n\
Mean Value:\n\
Set the value of each active voxel to the average value over\n\
the voxel's neighborhood.\n\n\
One iteration is equivalent to a box blur. For a cone blur,\n\
multiply the radius by 0.454545 and use two iterations.\n\
Median Value:\n\
Set the value of each active voxel to the median value over\n\
the voxel's neighborhood.\n\n\
This is useful for suppressing outlier values.\n\
Offset:\n\
Add a given offset to each active voxel's value.\n\
"));
}
// Filter radius
parms.add(hutil::ParmFactory(PRM_TOGGLE, "worldunits", "Use World Space Radius Units")
.setTooltip(
"If enabled, specify the filter neighborhood size in world units,\n"
"otherwise specify the size in voxels."));
parms.add(hutil::ParmFactory(PRM_INT_J, "radius", "Filter Voxel Radius")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 5)
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_FLT_J, "worldradius", "Filter Radius")
.setDefault(0.1)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 10)
.setTooltip("Half the width of a side of the cubic filter neighborhood"));
// Number of iterations
parms.add(hutil::ParmFactory(PRM_INT_J, "iterations", "Iterations")
.setDefault(PRMfourDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_UI, 10)
.setTooltip("The number of times to apply the operation"));
#ifndef SESI_OPENVDB
// Offset
parms.add(hutil::ParmFactory(PRM_FLT_J, "offset", "Offset")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_UI, -10.0, PRM_RANGE_UI, 10.0)
.setTooltip("When the operation is Offset, add this value to all active voxels."));
#endif
//Invert mask.
parms.add(hutil::ParmFactory(PRM_TOGGLE, "invert", "Invert Alpha Mask")
.setTooltip("Invert the mask so that alpha value 0 maps to 1 and 1 to 0."));
// Min mask range
parms.add(hutil::ParmFactory(PRM_FLT_J, "minmask", "Min Mask Cutoff")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_UI, 0.0, PRM_RANGE_UI, 1.0)
.setTooltip("Threshold below which mask values are clamped to zero"));
// Max mask range
parms.add(hutil::ParmFactory(PRM_FLT_J, "maxmask", "Max Mask Cutoff")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_UI, 0.0, PRM_RANGE_UI, 1.0)
.setTooltip("Threshold above which mask values are clamped to one"));
#ifndef SESI_OPENVDB
// Verbosity toggle.
parms.add(hutil::ParmFactory(PRM_TOGGLE, "verbose", "Verbose")
.setTooltip("Print the sequence of operations to the terminal."));
#endif
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_SEPARATOR,"sep1", ""));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "minMask", "Min Mask Cutoff")
.setDefault(PRMzeroDefaults));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "maxMask", "Max Mask Cutoff")
.setDefault(PRMoneDefaults));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Smooth", SOP_OpenVDB_Filter::factory, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBFilter")
.addAliasVerbatim("DW_OpenVDBSmooth")
#endif
.setObsoleteParms(obsoleteParms)
.addInput("VDBs to Smooth")
.addOptionalInput("Optional VDB Alpha Mask")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Filter::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Filters/smooths the values in a VDB volume.\"\"\"\n\
\n\
@overview\n\
\n\
This node assigns to each active voxel in a VDB volume a value,\n\
such as the mean or median, that is representative of the voxel's neighborhood,\n\
where the neighborhood is a cube centered on the voxel.\n\
This has the effect of reducing high-frequency content and suppressing noise.\n\
\n\
If the optional scalar mask volume is provided, the output value of\n\
each voxel is a linear blend between its input value and the neighborhood value.\n\
A mask value of zero leaves the input value unchanged.\n\
\n\
NOTE:\n\
To filter a level set, use the\n\
[OpenVDB Smooth Level Set|Node:sop/DW_OpenVDBSmoothLevelSet] node.\n\
\n\
@related\n\
- [OpenVDB Noise|Node:sop/DW_OpenVDBNoise]\n\
- [OpenVDB Smooth Level Set|Node:sop/DW_OpenVDBSmoothLevelSet]\n\
- [Node:sop/vdbsmooth]\n\
- [Node:sop/vdbsmoothsdf]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
void
SOP_OpenVDB_Filter::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
resolveRenamedParm(*obsoleteParms, "minMask", "minmask");
resolveRenamedParm(*obsoleteParms, "maxMask", "maxmask");
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
// Disable UI Parms.
bool
SOP_OpenVDB_Filter::updateParmsFlags()
{
bool changed = false, hasMask = (this->nInputs() == 2);
changed |= enableParm("mask", hasMask);
bool useMask = bool(evalInt("mask", 0, 0)) && hasMask;
changed |= enableParm("invert", useMask);
changed |= enableParm("minmask", useMask);
changed |= enableParm("maxmask", useMask);
changed |= enableParm("maskname", useMask);
const bool worldUnits = bool(evalInt("worldunits", 0, 0));
Operation op = OP_MEAN;
bool gotOp = false;
try { op = stringToOp(evalStdString("operation", 0)); gotOp = true; }
catch (std::runtime_error&) {}
// Disable and hide unused parameters.
if (gotOp) {
bool enable = (op == OP_MEAN || op == OP_GAUSS || op == OP_MEDIAN);
changed |= enableParm("iterations", enable);
changed |= enableParm("radius", enable);
changed |= enableParm("worldradius", enable);
changed |= setVisibleState("iterations", enable);
changed |= setVisibleState("worldunits", enable);
changed |= setVisibleState("radius", enable && !worldUnits);
changed |= setVisibleState("worldradius", enable && worldUnits);
#ifndef SESI_OPENVDB
enable = (op == OP_OFFSET);
changed |= enableParm("offset", enable);
changed |= setVisibleState("offset", enable);
#endif
}
return changed;
}
////////////////////////////////////////
// Helper class for use with GridBase::apply()
struct SOP_OpenVDB_Filter::FilterOp
{
FilterParmVec opSequence;
hvdb::Interrupter* interrupt;
template<typename GridT>
void operator()(GridT& grid)
{
using ValueT = typename GridT::ValueType;
using MaskT = openvdb::FloatGrid;
openvdb::tools::Filter<GridT, MaskT, hvdb::Interrupter> filter(grid, interrupt);
for (size_t i = 0, N = opSequence.size(); i < N; ++i) {
if (interrupt && interrupt->wasInterrupted()) return;
const FilterParms& parms = opSequence[i];
int radius = parms.radius;
if (parms.useWorldRadius) {
double voxelRadius = double(parms.worldRadius) / grid.voxelSize()[0];
radius = std::max(1, int(voxelRadius));
}
filter.setMaskRange(parms.minMask, parms.maxMask);
filter.invertMask(parms.invertMask);
switch (parms.op) {
#ifndef SESI_OPENVDB
case OP_OFFSET:
{
const ValueT offset = static_cast<ValueT>(parms.offset);
if (parms.verbose) std::cout << "Applying Offset by " << offset << std::endl;
filter.offset(offset, parms.mask);
}
break;
#endif
case OP_MEAN:
#ifndef SESI_OPENVDB
if (parms.verbose) {
std::cout << "Applying " << parms.iterations << " iterations of mean value"
" filtering with a radius of " << radius << std::endl;
}
#endif
filter.mean(radius, parms.iterations, parms.mask);
break;
case OP_GAUSS:
#ifndef SESI_OPENVDB
if (parms.verbose) {
std::cout << "Applying " << parms.iterations << " iterations of gaussian"
" filtering with a radius of " <<radius << std::endl;
}
#endif
filter.gaussian(radius, parms.iterations, parms.mask);
break;
case OP_MEDIAN:
#ifndef SESI_OPENVDB
if (parms.verbose) {
std::cout << "Applying " << parms.iterations << " iterations of median value"
" filtering with a radius of " << radius << std::endl;
}
#endif
filter.median(radius, parms.iterations, parms.mask);
break;
case NUM_OPERATIONS:
break;
}
}
}
};
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Filter::Cache::evalFilterParms(
OP_Context& context, GU_Detail&, FilterParmVec& parmVec)
{
const fpreal now = context.getTime();
const Operation op = stringToOp(evalStdString("operation", 0));
FilterParms parms(op);
parms.radius = static_cast<int>(evalInt("radius", 0, now));
parms.worldRadius = float(evalFloat("worldradius", 0, now));
parms.useWorldRadius = bool(evalInt("worldunits", 0, now));
parms.iterations = static_cast<int>(evalInt("iterations", 0, now));
#ifndef SESI_OPENVDB
parms.offset = static_cast<float>(evalFloat("offset", 0, now));
parms.verbose = bool(evalInt("verbose", 0, now));
#endif
openvdb::FloatGrid::ConstPtr maskGrid;
if (this->nInputs() == 2 && evalInt("mask", 0, now)) {
const GU_Detail* maskGeo = inputGeo(1);
const auto maskName = evalStdString("maskname", now);
if (maskGeo) {
const GA_PrimitiveGroup* maskGroup =
parsePrimitiveGroups(maskName.c_str(), GroupCreator(maskGeo));
if (!maskGroup && !maskName.empty()) {
addWarning(SOP_MESSAGE, "Mask not found.");
} else {
hvdb::VdbPrimCIterator maskIt(maskGeo, maskGroup);
if (maskIt) {
if (maskIt->getStorageType() == UT_VDB_FLOAT) {
maskGrid = openvdb::gridConstPtrCast<openvdb::FloatGrid>(
maskIt->getGridPtr());
} else {
addWarning(SOP_MESSAGE, "The mask grid has to be a FloatGrid.");
}
} else {
addWarning(SOP_MESSAGE, "The mask input is empty.");
}
}
}
}
parms.mask = maskGrid.get();
parms.minMask = static_cast<float>(evalFloat("minmask", 0, now));
parms.maxMask = static_cast<float>(evalFloat("maxmask", 0, now));
parms.invertMask = evalInt("invert", 0, now);
parmVec.push_back(parms);
return error();
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Filter::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal now = context.getTime();
FilterOp filterOp;
evalFilterParms(context, *gdp, filterOp.opSequence);
// Get the group of grids to process.
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", now));
hvdb::Interrupter progress("Filtering VDB grids");
filterOp.interrupt = &progress;
// Process each VDB primitive in the selected group.
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (progress.wasInterrupted()) {
throw std::runtime_error("processing was interrupted");
}
GU_PrimVDB* vdbPrim = *it;
UT_String name = it.getPrimitiveNameOrIndex();
#ifndef SESI_OPENVDB
if (evalInt("verbose", 0, now)) {
std::cout << "\nFiltering \"" << name << "\"" << std::endl;
}
#endif
if (!hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(*vdbPrim, filterOp)) {
std::stringstream ss;
ss << "VDB grid " << name << " of type "
<< vdbPrim->getConstGrid().valueType() << " was skipped";
addWarning(SOP_MESSAGE, ss.str().c_str());
continue;
}
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 18,230 | C++ | 30.217466 | 97 | 0.614098 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GR_PrimVDBPoints.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file GR_PrimVDBPoints.cc
///
/// @author Dan Bailey, Nick Avramoussis
///
/// @brief GR Render Hook and Primitive for VDB PointDataGrid
#include <UT/UT_Version.h>
#include <openvdb/Grid.h>
#include <openvdb/Platform.h>
#include <openvdb/Types.h>
#include <openvdb/points/PointDataGrid.h>
#include <openvdb/points/PointCount.h>
#include <openvdb/points/PointConversion.h>
#include <openvdb_houdini/PointUtils.h>
#include <DM/DM_RenderTable.h>
#include <GEO/GEO_PrimVDB.h>
#include <GR/GR_Primitive.h>
#include <GR/GR_Utils.h> // inViewFrustum
#include <GT/GT_PrimitiveTypes.h>
#include <GT/GT_PrimVDB.h>
#include <GUI/GUI_PrimitiveHook.h>
#include <RE/RE_Geometry.h>
#include <RE/RE_Render.h>
#include <RE/RE_ShaderHandle.h>
#include <RE/RE_VertexArray.h>
#include <UT/UT_DSOVersion.h>
#include <UT/UT_UniquePtr.h>
#include <tbb/mutex.h>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
////////////////////////////////////////
static RE_ShaderHandle theMarkerDecorShader("decor/GL32/point_marker.prog");
static RE_ShaderHandle theNormalDecorShader("decor/GL32/point_normal.prog");
static RE_ShaderHandle theVelocityDecorShader("decor/GL32/user_point_vector3.prog");
static RE_ShaderHandle theLineShader("basic/GL32/wire_color.prog");
static RE_ShaderHandle thePixelShader("particle/GL32/pixel.prog");
static RE_ShaderHandle thePointShader("particle/GL32/point.prog");
/// @note An additional scale for velocity trails to accurately match
/// the visualization of velocity for Houdini points
#define VELOCITY_DECOR_SCALE -0.041f;
namespace {
/// @note The render hook guard should not be required..
// Declare this at file scope to ensure thread-safe initialization.
tbb::mutex sRenderHookRegistryMutex;
bool renderHookRegistered = false;
} // anonymous namespace
using namespace openvdb;
using namespace openvdb::points;
////////////////////////////////////////
/// Primitive Render Hook for VDB Points
class GUI_PrimVDBPointsHook : public GUI_PrimitiveHook
{
public:
GUI_PrimVDBPointsHook() : GUI_PrimitiveHook("DWA VDB Points") { }
~GUI_PrimVDBPointsHook() override = default;
/// This is called when a new GR_Primitive is required for a VDB Points primitive.
GR_Primitive* createPrimitive(
const GT_PrimitiveHandle& gt_prim,
const GEO_Primitive* geo_prim,
const GR_RenderInfo* info,
const char* cache_name,
GR_PrimAcceptResult& processed) override;
}; // class GUI_PrimVDBPointsHook
/// Primitive object that is created by GUI_PrimVDBPointsHook whenever a
/// VDB Points primitive is found. This object can be persistent between
/// renders, though display flag changes or navigating though SOPs can cause
/// it to be deleted and recreated later.
class GR_PrimVDBPoints : public GR_Primitive
{
public:
GR_PrimVDBPoints(const GR_RenderInfo *info,
const char *cache_name,
const GEO_Primitive* geo_prim);
~GR_PrimVDBPoints() override = default;
const char *className() const override { return "GR_PrimVDBPoints"; }
/// See if the tetra primitive can be consumed by this primitive.
GR_PrimAcceptResult acceptPrimitive(GT_PrimitiveType, int geo_type,
const GT_PrimitiveHandle&, const GEO_Primitive*) override;
/// This should reset any lists of primitives.
void resetPrimitives() override {}
/// Called whenever the parent detail is changed, draw modes are changed,
/// selection is changed, or certain volatile display options are changed
/// (such as level of detail).
void update(RE_Render*, const GT_PrimitiveHandle&, const GR_UpdateParms&) override;
/// return true if the primitive is in or overlaps the view frustum.
/// always returning true will effectively disable frustum culling.
bool inViewFrustum(const UT_Matrix4D &objviewproj
#if (UT_VERSION_INT >= 0x1105014e) // 17.5.334 or later
, const UT_BoundingBoxD *bbox
#endif
) override;
/// Called whenever the primitive is required to render, which may be more
/// than one time per viewport redraw (beauty, shadow passes, wireframe-over)
/// It also may be called outside of a viewport redraw to do picking of the
/// geometry.
void render(RE_Render*, GR_RenderMode, GR_RenderFlags, GR_DrawParms) override;
int renderPick(RE_Render*, const GR_DisplayOption*, unsigned int,
GR_PickStyle, bool) override { return 0; }
void renderDecoration(RE_Render*, GR_Decoration, const GR_DecorationParms&) override;
protected:
void computeCentroid(const openvdb::points::PointDataGrid& grid);
void computeBbox(const openvdb::points::PointDataGrid& grid);
void updatePosBuffer(RE_Render* r,
const openvdb::points::PointDataGrid& grid,
const RE_CacheVersion& version);
void updateWireBuffer(RE_Render* r,
const openvdb::points::PointDataGrid& grid,
const RE_CacheVersion& version);
bool updateVec3Buffer(RE_Render* r,
const openvdb::points::PointDataGrid& grid,
const std::string& attributeName,
const std::string& bufferName,
const RE_CacheVersion& version);
bool updateVec3Buffer(RE_Render* r,
const std::string& attributeName,
const std::string& bufferName,
const RE_CacheVersion& version);
void removeBuffer(const std::string& name);
private:
UT_UniquePtr<RE_Geometry> myGeo;
UT_UniquePtr<RE_Geometry> myWire;
bool mDefaultPointColor = true;
openvdb::Vec3f mCentroid{0, 0, 0};
openvdb::BBoxd mBbox;
};
////////////////////////////////////////
void
newRenderHook(DM_RenderTable* table)
{
tbb::mutex::scoped_lock lock(sRenderHookRegistryMutex);
if (!renderHookRegistered) {
static_cast<DM_RenderTable*>(table)->registerGTHook(
new GUI_PrimVDBPointsHook(),
GT_PRIM_VDB_VOLUME,
/*hook_priority=*/1,
GUI_HOOK_FLAG_AUGMENT_PRIM);
OPENVDB_START_THREADSAFE_STATIC_WRITE
renderHookRegistered = true; // mutex-protected
OPENVDB_FINISH_THREADSAFE_STATIC_WRITE
}
}
static inline bool
grIsPointDataGrid(const GT_PrimitiveHandle& gt_prim)
{
if (gt_prim->getPrimitiveType() != GT_PRIM_VDB_VOLUME)
return false;
const GT_PrimVDB* gt_vdb = static_cast<const GT_PrimVDB*>(gt_prim.get());
const GEO_PrimVDB* gr_vdb = gt_vdb->getGeoPrimitive();
return (gr_vdb->getStorageType() == UT_VDB_POINTDATA);
}
GR_Primitive*
GUI_PrimVDBPointsHook::createPrimitive(
const GT_PrimitiveHandle& gt_prim,
const GEO_Primitive* geo_prim,
const GR_RenderInfo* info,
const char* cache_name,
GR_PrimAcceptResult& processed)
{
if (grIsPointDataGrid(gt_prim)) {
processed = GR_PROCESSED;
return new GR_PrimVDBPoints(info, cache_name, geo_prim);
}
processed = GR_NOT_PROCESSED;
return nullptr;
}
////////////////////////////////////////
namespace {
using StringPair = std::pair<std::string, std::string>;
bool patchShader(RE_Render* r, RE_ShaderHandle& shader, RE_ShaderType type,
const std::vector<StringPair>& stringReplacements,
const std::vector<std::string>& stringInsertions = {})
{
// check if the point shader has already been patched
r->pushShader();
r->bindShader(shader);
const RE_ShaderStage* const patchedShader = shader->getShader("pointOffset", type);
if (patchedShader) {
r->popShader();
return false;
}
// retrieve the shader source and version
UT_String source;
shader->getShaderSource(r, source, type);
const int version = shader->getCodeVersion();
// patch the shader to replace the strings
for (const auto& stringPair : stringReplacements) {
source.substitute(stringPair.first.c_str(), stringPair.second.c_str(), /*all=*/true);
}
// patch the shader to insert the strings
for (const auto& str: stringInsertions) {
source.insert(0, str.c_str());
}
// move the version up to the top of the file
source.substitute("#version ", "// #version");
std::stringstream ss;
ss << "#version " << version << "\n";
source.insert(0, ss.str().c_str());
// remove the existing shader and add the patched one
shader->clearShaders(r, type);
UT_String message;
const bool success = shader->addShader(r, type, source, "pointOffset", version, &message);
r->popShader();
if (!success) {
if (type == RE_SHADER_VERTEX) std::cerr << "Vertex Shader (";
else if (type == RE_SHADER_GEOMETRY) std::cerr << "Geometry Shader (";
else if (type == RE_SHADER_FRAGMENT) std::cerr << "Fragment Shader (";
std::cerr << shader->getName();
std::cerr << ") Compile Failure: " << message.toStdString() << std::endl;
}
assert(success);
return true;
}
void patchShaderVertexOffset(RE_Render* r, RE_ShaderHandle& shader)
{
// patch the shader to add a uniform offset to the position
static const std::vector<StringPair> stringReplacements
{
StringPair("void main()", "uniform vec3 offset;\n\nvoid main()"),
StringPair("vec4(P, 1.0)", "vec4(P + offset, 1.0)"),
StringPair("vec4(P,1.0)", "vec4(P + offset, 1.0)")
};
patchShader(r, shader, RE_SHADER_VERTEX, stringReplacements);
}
void patchShaderNoRedeclarations(RE_Render* r, RE_ShaderHandle& shader)
{
static const std::vector<StringPair> stringReplacements
{
StringPair("\t", " "),
StringPair(" ", " "),
StringPair(" ", " "),
StringPair("uniform vec2 glH_DepthProject;", "//uniform vec2 glH_DepthProject;"),
StringPair("uniform vec2 glH_ScreenSize", "//uniform vec2 glH_ScreenSize")
};
static const std::vector<std::string> stringInsertions
{
"uniform vec2 glH_DepthProject;",
"uniform vec2 glH_ScreenSize;"
};
patchShader(r, shader, RE_SHADER_GEOMETRY, stringReplacements, stringInsertions);
}
} // namespace
////////////////////////////////////////
GR_PrimVDBPoints::GR_PrimVDBPoints(
const GR_RenderInfo *info,
const char *cache_name,
const GEO_Primitive*)
: GR_Primitive(info, cache_name, GA_PrimCompat::TypeMask(0))
{
}
GR_PrimAcceptResult
GR_PrimVDBPoints::acceptPrimitive(GT_PrimitiveType,
int geo_type,
const GT_PrimitiveHandle& gt_prim,
const GEO_Primitive*)
{
if (geo_type == GT_PRIM_VDB_VOLUME && grIsPointDataGrid(gt_prim))
return GR_PROCESSED;
return GR_NOT_PROCESSED;
}
namespace gr_primitive_internal
{
struct FillGPUBuffersLeafBoxes
{
FillGPUBuffersLeafBoxes(UT_Vector3H* buffer,
const std::vector<openvdb::Coord>& coords,
const openvdb::math::Transform& transform,
const openvdb::Vec3f& positionOffset)
: mBuffer(buffer)
, mCoords(coords)
, mTransform(transform)
, mPositionOffset(positionOffset) { }
void operator()(const tbb::blocked_range<size_t>& range) const
{
std::vector<UT_Vector3H> corners;
corners.reserve(8);
for (size_t n = range.begin(), N = range.end(); n != N; ++n) {
const openvdb::Coord& origin = mCoords[n];
// define 8 corners
corners.clear();
const openvdb::Vec3f pos000 = mTransform.indexToWorld(origin.asVec3d() + openvdb::Vec3f(0.0, 0.0, 0.0)) - mPositionOffset;
corners.emplace_back(pos000.x(), pos000.y(), pos000.z());
const openvdb::Vec3f pos001 = mTransform.indexToWorld(origin.asVec3d() + openvdb::Vec3f(0.0, 0.0, 8.0)) - mPositionOffset;
corners.emplace_back(pos001.x(), pos001.y(), pos001.z());
const openvdb::Vec3f pos010 = mTransform.indexToWorld(origin.asVec3d() + openvdb::Vec3f(0.0, 8.0, 0.0)) - mPositionOffset;
corners.emplace_back(pos010.x(), pos010.y(), pos010.z());
const openvdb::Vec3f pos011 = mTransform.indexToWorld(origin.asVec3d() + openvdb::Vec3f(0.0, 8.0, 8.0)) - mPositionOffset;
corners.emplace_back(pos011.x(), pos011.y(), pos011.z());
const openvdb::Vec3f pos100 = mTransform.indexToWorld(origin.asVec3d() + openvdb::Vec3f(8.0, 0.0, 0.0)) - mPositionOffset;
corners.emplace_back(pos100.x(), pos100.y(), pos100.z());
const openvdb::Vec3f pos101 = mTransform.indexToWorld(origin.asVec3d() + openvdb::Vec3f(8.0, 0.0, 8.0)) - mPositionOffset;
corners.emplace_back(pos101.x(), pos101.y(), pos101.z());
const openvdb::Vec3f pos110 = mTransform.indexToWorld(origin.asVec3d() + openvdb::Vec3f(8.0, 8.0, 0.0)) - mPositionOffset;
corners.emplace_back(pos110.x(), pos110.y(), pos110.z());
const openvdb::Vec3f pos111 = mTransform.indexToWorld(origin.asVec3d() + openvdb::Vec3f(8.0, 8.0, 8.0)) - mPositionOffset;
corners.emplace_back(pos111.x(), pos111.y(), pos111.z());
openvdb::Index64 offset = n*8*3;
// Z axis
mBuffer[offset++] = corners[0]; mBuffer[offset++] = corners[1];
mBuffer[offset++] = corners[2]; mBuffer[offset++] = corners[3];
mBuffer[offset++] = corners[4]; mBuffer[offset++] = corners[5];
mBuffer[offset++] = corners[6]; mBuffer[offset++] = corners[7];
// Y axis
mBuffer[offset++] = corners[0]; mBuffer[offset++] = corners[2];
mBuffer[offset++] = corners[1]; mBuffer[offset++] = corners[3];
mBuffer[offset++] = corners[4]; mBuffer[offset++] = corners[6];
mBuffer[offset++] = corners[5]; mBuffer[offset++] = corners[7];
// X axis
mBuffer[offset++] = corners[0]; mBuffer[offset++] = corners[4];
mBuffer[offset++] = corners[1]; mBuffer[offset++] = corners[5];
mBuffer[offset++] = corners[2]; mBuffer[offset++] = corners[6];
mBuffer[offset++] = corners[3]; mBuffer[offset++] = corners[7];
}
}
//////////
UT_Vector3H* mBuffer;
const std::vector<openvdb::Coord>& mCoords;
const openvdb::math::Transform& mTransform;
const openvdb::Vec3f mPositionOffset;
}; // class FillGPUBuffersLeafBoxes
} // namespace gr_primitive_internal
void
GR_PrimVDBPoints::computeCentroid(const openvdb::points::PointDataGrid& grid)
{
// compute the leaf bounding box in index space
openvdb::CoordBBox coordBBox;
if (!grid.tree().evalLeafBoundingBox(coordBBox)) {
mCentroid.init(0.0f, 0.0f, 0.0f);
}
else {
// get the centroid and convert to world space
mCentroid = openvdb::Vec3f(grid.transform().indexToWorld(coordBBox.getCenter()));
}
}
void
GR_PrimVDBPoints::computeBbox(const openvdb::points::PointDataGrid& grid)
{
// compute and store the world-space bounding box of the grid
const CoordBBox bbox = grid.evalActiveVoxelBoundingBox();
const BBoxd bboxIndex(bbox.min().asVec3d(), bbox.max().asVec3d());
mBbox = bboxIndex.applyMap(*(grid.transform().baseMap()));
}
struct PositionAttribute
{
using ValueType = Vec3f;
struct Handle
{
Handle(PositionAttribute& attribute)
: mBuffer(attribute.mBuffer)
, mPositionOffset(attribute.mPositionOffset)
, mStride(attribute.mStride) { }
void set(openvdb::Index offset,
openvdb::Index /*stride*/,
const ValueType& value)
{
const ValueType transformedValue = value - mPositionOffset;
mBuffer[offset * mStride] = UT_Vector3F(transformedValue.x(), transformedValue.y(), transformedValue.z());
}
private:
UT_Vector3F* mBuffer;
const ValueType& mPositionOffset;
const Index mStride;
}; // struct Handle
PositionAttribute(UT_Vector3F* buffer,
const ValueType& positionOffset,
Index stride = 1)
: mBuffer(buffer)
, mPositionOffset(positionOffset)
, mStride(stride) { }
void expand() { }
void compact() { }
private:
UT_Vector3F* mBuffer;
const ValueType mPositionOffset;
const Index mStride;
}; // struct PositionAttribute
template <typename T>
struct VectorAttribute
{
using ValueType = T;
struct Handle
{
Handle(VectorAttribute& attribute)
: mBuffer(attribute.mBuffer) { }
template <typename ValueType>
void set(openvdb::Index offset,
openvdb::Index /*stride*/,
const openvdb::math::Vec3<ValueType>& value)
{
mBuffer[offset] = UT_Vector3H(float(value.x()), float(value.y()), float(value.z()));
}
private:
UT_Vector3H* mBuffer;
}; // struct Handle
VectorAttribute(UT_Vector3H* buffer)
: mBuffer(buffer) { }
void expand() { }
void compact() { }
private:
UT_Vector3H* mBuffer;
}; // struct VectorAttribute
void
GR_PrimVDBPoints::updatePosBuffer(RE_Render* r,
const openvdb::points::PointDataGrid& grid,
const RE_CacheVersion& version)
{
const bool gl3 = (getRenderVersion() >= GR_RENDER_GL3);
// Initialize the geometry with the proper name for the GL cache
if (!myGeo) myGeo.reset(new RE_Geometry);
myGeo->cacheBuffers(getCacheName());
using GridType = openvdb::points::PointDataGrid;
using TreeType = GridType::TreeType;
using AttributeSet = openvdb::points::AttributeSet;
const TreeType& tree = grid.tree();
auto iter = tree.cbeginLeaf();
if (!iter) return;
const AttributeSet::Descriptor& descriptor = iter->attributeSet().descriptor();
// check if group viewport is in use
const openvdb::StringMetadata::ConstPtr s =
grid.getMetadata<openvdb::StringMetadata>(openvdb_houdini::META_GROUP_VIEWPORT);
const std::string groupName = s ? s->value() : "";
const bool useGroup = !groupName.empty() && descriptor.hasGroup(groupName);
// count up total points ignoring any leaf nodes that are out of core
int numPoints = 0;
if (useGroup) {
GroupFilter filter(groupName, iter->attributeSet());
numPoints = static_cast<int>(pointCount(tree, filter, /*inCoreOnly=*/true));
} else {
NullFilter filter;
numPoints = static_cast<int>(pointCount(tree, filter, /*inCoreOnly=*/true));
}
if (numPoints == 0) return;
// Initialize the number of points in the geometry.
myGeo->setNumPoints(numPoints);
const size_t positionIndex = descriptor.find("P");
// determine whether position exists
if (positionIndex == AttributeSet::INVALID_POS) return;
// fetch point position attribute, if its cache version matches, no upload is required.
RE_VertexArray* posGeo = myGeo->findCachedAttrib(r, "P", RE_GPU_FLOAT32, 3, RE_ARRAY_POINT, true);
if (posGeo->getCacheVersion() != version)
{
std::vector<Name> includeGroups, excludeGroups;
if (useGroup) includeGroups.emplace_back(groupName);
// @note We've tried using UT_Vector3H here but we get serious aliasing in
// leaf nodes which are a small distance away from the origin of the VDB
// primitive (~5-6 nodes away)
MultiGroupFilter filter(includeGroups, excludeGroups, iter->attributeSet());
std::vector<Index64> offsets;
pointOffsets(offsets, grid.tree(), filter, /*inCoreOnly=*/true);
UT_UniquePtr<UT_Vector3F[]> pdata(new UT_Vector3F[numPoints]);
PositionAttribute positionAttribute(pdata.get(), mCentroid);
convertPointDataGridPosition(positionAttribute, grid, offsets,
/*startOffset=*/ 0, filter, /*inCoreOnly=*/true);
posGeo->setArray(r, pdata.get());
posGeo->setCacheVersion(version);
}
if (gl3)
{
// Extra constant inputs for the GL3 default shaders we are using.
fpreal32 uv[2] = { 0.0, 0.0 };
fpreal32 alpha = 1.0;
fpreal32 pnt = 0.0;
UT_Matrix4F instance;
instance.identity();
// TODO: point scale !?
myGeo->createConstAttribute(r, "uv", RE_GPU_FLOAT32, 2, uv);
myGeo->createConstAttribute(r, "Alpha", RE_GPU_FLOAT32, 1, &alpha);
myGeo->createConstAttribute(r, "pointSelection", RE_GPU_FLOAT32, 1,&pnt);
myGeo->createConstAttribute(r, "instmat", RE_GPU_MATRIX4, 1, instance.data());
}
RE_PrimType primType = RE_PRIM_POINTS;
myGeo->connectAllPrims(r, RE_GEO_WIRE_IDX, primType, nullptr, true);
}
void
GR_PrimVDBPoints::updateWireBuffer(RE_Render *r,
const openvdb::points::PointDataGrid& grid,
const RE_CacheVersion& version)
{
const bool gl3 = (getRenderVersion() >= GR_RENDER_GL3);
// Initialize the geometry with the proper name for the GL cache
if (!myWire) myWire.reset(new RE_Geometry);
myWire->cacheBuffers(getCacheName());
using GridType = openvdb::points::PointDataGrid;
using TreeType = GridType::TreeType;
using LeafNode = TreeType::LeafNodeType;
const TreeType& tree = grid.tree();
if (tree.leafCount() == 0) return;
// count up total points ignoring any leaf nodes that are out of core
size_t outOfCoreLeaves = 0;
for (auto iter = tree.cbeginLeaf(); iter; ++iter) {
if (iter->buffer().isOutOfCore()) outOfCoreLeaves++;
}
if (outOfCoreLeaves == 0) return;
// Initialize the number of points for the wireframe box per leaf.
int numPoints = static_cast<int>(outOfCoreLeaves*8*3);
myWire->setNumPoints(numPoints);
// fetch wireframe position, if its cache version matches, no upload is required.
RE_VertexArray* posWire = myWire->findCachedAttrib(r, "P", RE_GPU_FLOAT16, 3, RE_ARRAY_POINT, true);
if (posWire->getCacheVersion() != version)
{
using gr_primitive_internal::FillGPUBuffersLeafBoxes;
// fill the wire data
UT_UniquePtr<UT_Vector3H[]> data(new UT_Vector3H[numPoints]);
std::vector<openvdb::Coord> coords;
for (auto iter = tree.cbeginLeaf(); iter; ++iter) {
const LeafNode& leaf = *iter;
// skip in-core leaf nodes (for use when delay loading VDBs)
if (!leaf.buffer().isOutOfCore()) continue;
coords.push_back(leaf.origin());
}
FillGPUBuffersLeafBoxes fill(data.get(), coords, grid.transform(), mCentroid);
const tbb::blocked_range<size_t> range(0, coords.size());
tbb::parallel_for(range, fill);
posWire->setArray(r, data.get());
posWire->setCacheVersion(version);
}
if (gl3)
{
// Extra constant inputs for the GL3 default shaders we are using.
fpreal32 uv[2] = { 0.0, 0.0 };
fpreal32 alpha = 1.0;
fpreal32 pnt = 0.0;
UT_Matrix4F instance;
instance.identity();
myWire->createConstAttribute(r, "uv", RE_GPU_FLOAT32, 2, uv);
myWire->createConstAttribute(r, "Alpha", RE_GPU_FLOAT32, 1, &alpha);
myWire->createConstAttribute(r, "pointSelection", RE_GPU_FLOAT32, 1,&pnt);
myWire->createConstAttribute(r, "instmat", RE_GPU_MATRIX4, 1,
instance.data());
}
myWire->connectAllPrims(r, RE_GEO_WIRE_IDX, RE_PRIM_LINES, nullptr, true);
}
void
GR_PrimVDBPoints::update(RE_Render *r,
const GT_PrimitiveHandle &primh,
const GR_UpdateParms &p)
{
// patch the point shaders at run-time to add an offset (does nothing if already patched)
patchShaderVertexOffset(r, theLineShader);
patchShaderVertexOffset(r, thePixelShader);
patchShaderVertexOffset(r, thePointShader);
// patch the decor shaders at run-time to add an offset etc (does nothing if already patched)
patchShaderVertexOffset(r, theNormalDecorShader);
patchShaderVertexOffset(r, theVelocityDecorShader);
patchShaderVertexOffset(r, theMarkerDecorShader);
patchShaderNoRedeclarations(r, theMarkerDecorShader);
// geometry itself changed. GR_GEO_TOPOLOGY changed indicates a large
// change, such as changes in the point, primitive or vertex counts
// GR_GEO_CHANGED indicates that some attribute data may have changed.
if (p.reason & (GR_GEO_CHANGED | GR_GEO_TOPOLOGY_CHANGED))
{
const GT_PrimVDB& gt_primVDB = static_cast<const GT_PrimVDB&>(*primh);
const openvdb::GridBase* grid =
const_cast<GT_PrimVDB&>((static_cast<const GT_PrimVDB&>(gt_primVDB))).getGrid();
const openvdb::points::PointDataGrid& pointDataGrid =
static_cast<const openvdb::points::PointDataGrid&>(*grid);
computeCentroid(pointDataGrid);
computeBbox(pointDataGrid);
updatePosBuffer(r, pointDataGrid, p.geo_version);
updateWireBuffer(r, pointDataGrid, p.geo_version);
mDefaultPointColor = !updateVec3Buffer(r, pointDataGrid, "Cd", "Cd", p.geo_version);
}
}
bool
GR_PrimVDBPoints::inViewFrustum(const UT_Matrix4D& objviewproj
#if (UT_VERSION_INT >= 0x1105014e) // 17.5.334 or later
, const UT_BoundingBoxD *passed_bbox
#endif
)
{
const UT_BoundingBoxD bbox( mBbox.min().x(), mBbox.min().y(), mBbox.min().z(),
mBbox.max().x(), mBbox.max().y(), mBbox.max().z());
#if (UT_VERSION_INT >= 0x1105014e) // 17.5.334 or later
return GR_Utils::inViewFrustum(passed_bbox ? *passed_bbox :bbox,
objviewproj);
#else
return GR_Utils::inViewFrustum(bbox, objviewproj);
#endif
}
bool
GR_PrimVDBPoints::updateVec3Buffer(RE_Render* r,
const openvdb::points::PointDataGrid& grid,
const std::string& attributeName,
const std::string& bufferName,
const RE_CacheVersion& version)
{
// Initialize the geometry with the proper name for the GL cache
if (!myGeo) return false;
using GridType = openvdb::points::PointDataGrid;
using TreeType = GridType::TreeType;
using AttributeSet = openvdb::points::AttributeSet;
const TreeType& tree = grid.tree();
auto iter = tree.cbeginLeaf();
if (!iter) return false;
const int numPoints = myGeo->getNumPoints();
if (numPoints == 0) return false;
const AttributeSet::Descriptor& descriptor = iter->attributeSet().descriptor();
const size_t index = descriptor.find(attributeName);
// early exit if attribute does not exist
if (index == AttributeSet::INVALID_POS) return false;
// fetch vector attribute, if its cache version matches, no upload is required.
RE_VertexArray* bufferGeo = myGeo->findCachedAttrib(r, bufferName.c_str(), RE_GPU_FLOAT16, 3, RE_ARRAY_POINT, true);
if (bufferGeo->getCacheVersion() != version)
{
UT_UniquePtr<UT_Vector3H[]> data(new UT_Vector3H[numPoints]);
const openvdb::Name& type = descriptor.type(index).first;
if (type == "vec3s") {
// check if group viewport is in use
const openvdb::StringMetadata::ConstPtr s =
grid.getMetadata<openvdb::StringMetadata>(openvdb_houdini::META_GROUP_VIEWPORT);
const std::string groupName = s ? s->value() : "";
const bool useGroup = !groupName.empty() && descriptor.hasGroup(groupName);
std::vector<Name> includeGroups, excludeGroups;
if (useGroup) includeGroups.emplace_back(groupName);
MultiGroupFilter filter(includeGroups, excludeGroups, iter->attributeSet());
std::vector<Index64> offsets;
pointOffsets(offsets, grid.tree(), filter, /*inCoreOnly=*/true);
VectorAttribute<Vec3f> typedAttribute(data.get());
convertPointDataGridAttribute(typedAttribute, grid.tree(), offsets,
/*startOffset=*/ 0, static_cast<unsigned>(index), /*stride=*/1,
filter, /*inCoreOnly=*/true);
}
bufferGeo->setArray(r, data.get());
bufferGeo->setCacheVersion(version);
}
return true;
}
bool
GR_PrimVDBPoints::updateVec3Buffer(RE_Render* r,
const std::string& attributeName,
const std::string& bufferName,
const RE_CacheVersion& version)
{
const GT_PrimVDB& gt_primVDB = static_cast<const GT_PrimVDB&>(*getCachedGTPrimitive());
const openvdb::GridBase* grid =
const_cast<GT_PrimVDB&>((static_cast<const GT_PrimVDB&>(gt_primVDB))).getGrid();
using PointDataGrid = openvdb::points::PointDataGrid;
const PointDataGrid& pointDataGrid = static_cast<const PointDataGrid&>(*grid);
return updateVec3Buffer(r, pointDataGrid, attributeName, bufferName, version);
}
void
GR_PrimVDBPoints::removeBuffer(const std::string& name)
{
myGeo->clearAttribute(name.c_str());
}
void
GR_PrimVDBPoints::render(RE_Render *r, GR_RenderMode, GR_RenderFlags, GR_DrawParms dp)
{
if (!myGeo && !myWire) return;
const bool gl3 = (getRenderVersion() >= GR_RENDER_GL3);
if (!gl3) return;
const GR_CommonDispOption& commonOpts = dp.opts->common();
// draw points
if (myGeo) {
const bool pointDisplay = commonOpts.particleDisplayType() == GR_PARTICLE_POINTS;
RE_ShaderHandle* const shader = pointDisplay ? &thePointShader : &thePixelShader;
// bind the shader
r->pushShader();
r->bindShader(*shader);
// bind the position offset
UT_Vector3F positionOffset(mCentroid.x(), mCentroid.y(), mCentroid.z());
(*shader)->bindVector(r, "offset", positionOffset);
// for default point colors, use white if dark viewport background, black otherwise
if (mDefaultPointColor) {
const bool darkBackground = (commonOpts.color(GR_BACKGROUND_COLOR) == UT_Color(0));
fpreal32 white[3] = { 0.6f, 0.6f, 0.5f };
fpreal32 black[3] = { 0.01f, 0.01f, 0.01f };
myGeo->createConstAttribute(r, "Cd", RE_GPU_FLOAT32, 3,
(darkBackground ? white : black));
}
if (pointDisplay) r->pushPointSize(commonOpts.pointSize());
myGeo->draw(r, RE_GEO_WIRE_IDX);
if (pointDisplay) r->popPointSize();
r->popShader();
}
// draw leaf bboxes
if (myWire && myWire->getNumPoints() > 0) {
// bind the shader
r->pushShader();
r->bindShader(theLineShader);
// bind the position offset
UT_Vector3F positionOffset(mCentroid.x(), mCentroid.y(), mCentroid.z());
theLineShader->bindVector(r, "offset", positionOffset);
fpreal32 constcol[3] = { 0.6f, 0.6f, 0.6f };
myWire->createConstAttribute(r, "Cd", RE_GPU_FLOAT32, 3, constcol);
r->pushLineWidth(commonOpts.wireWidth());
myWire->draw(r, RE_GEO_WIRE_IDX);
r->popLineWidth();
r->popShader();
}
}
void
GR_PrimVDBPoints::renderDecoration(RE_Render* r, GR_Decoration decor, const GR_DecorationParms& p)
{
// just render native GR_Primitive decorations if position not available
const RE_VertexArray* const position = myGeo->getAttribute("P");
if (!position) {
GR_Primitive::renderDecoration(r, decor, p);
return;
}
const GR_CommonDispOption& commonOpts = p.opts->common();
const RE_CacheVersion version = position->getCacheVersion();
// update normal buffer
GR_Decoration normalMarkers[2] = {GR_POINT_NORMAL, GR_NO_DECORATION};
const bool normalMarkerChanged = standardMarkersChanged(*p.opts, normalMarkers, false);
if (normalMarkerChanged) {
const bool drawNormals = p.opts->drawPointNmls() && updateVec3Buffer(r, "N", "N", version);
if (!drawNormals) {
removeBuffer("N");
}
}
// update velocity buffer
GR_Decoration velocityMarkers[2] = {GR_POINT_VELOCITY, GR_NO_DECORATION};
const bool velocityMarkerChanged = standardMarkersChanged(*p.opts, velocityMarkers, false);
if (velocityMarkerChanged) {
const bool drawVelocity = p.opts->drawPointVelocity() && updateVec3Buffer(r, "v", "V", version);
if (!drawVelocity) {
removeBuffer("V");
}
}
// setup shader and scale
RE_ShaderHandle* shader = nullptr;
float scale = 1.0f;
UT_Color color;
if (decor == GR_POINT_MARKER) {
shader = &theMarkerDecorShader;
scale = static_cast<float>(commonOpts.markerSize());
color = commonOpts.getColor(GR_POINT_COLOR);
}
else if (decor == GR_POINT_NORMAL) {
if (static_cast<bool>(myGeo->getAttribute("N"))) {
shader = &theNormalDecorShader;
scale = commonOpts.normalScale();
color = commonOpts.getColor(GR_POINT_COLOR); // No normal enum, use GR_POINT_COLOR
}
}
else if (decor == GR_POINT_VELOCITY) {
if (static_cast<bool>(myGeo->getAttribute("V"))) {
shader = &theVelocityDecorShader;
scale = static_cast<float>(commonOpts.vectorScale()) * VELOCITY_DECOR_SCALE;
color = commonOpts.getColor(GR_POINT_TRAIL_COLOR);
}
}
else if (decor == GR_POINT_NUMBER ||
decor == GR_POINT_POSITION) {
// not currently supported
return;
}
if (shader) {
// bind the shader
r->pushShader();
r->bindShader(*shader);
// enable alpha usage in the fragment shader
r->pushBlendState();
r->blendAlpha(/*onoff=*/1);
// bind the position offset
const UT_Vector3F positionOffset(mCentroid.x(), mCentroid.y(), mCentroid.z());
(*shader)->bindVector(r, "offset", positionOffset);
r->pushUniformColor(RE_UNIFORM_WIRE_COLOR, color);
r->pushUniformData(RE_UNIFORM_DECORATION_SCALE, &scale);
// render
myGeo->draw(r, RE_GEO_WIRE_IDX);
// pop uniforms, blend state and the shader
r->popUniform(RE_UNIFORM_WIRE_COLOR);
r->popUniform(RE_UNIFORM_DECORATION_SCALE);
r->popBlendState();
r->popShader();
}
else {
// fall back on default rendering
GR_Primitive::renderDecoration(r, decor, p);
}
}
| 34,753 | C++ | 32.321189 | 134 | 0.630852 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/geometry.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file geoemetry.h
/// @author FX R&D OpenVDB team
///
/// @brief A collection of Houdini geometry related methods and helper functions.
#ifndef HOUDINI_UTILS_GEOMETRY_HAS_BEEN_INCLUDED
#define HOUDINI_UTILS_GEOMETRY_HAS_BEEN_INCLUDED
#include <UT/UT_VectorTypes.h>
#include <GU/GU_Detail.h>
#if defined(PRODDEV_BUILD) || defined(DWREAL_IS_DOUBLE) || defined(SESI_OPENVDB)
// OPENVDB_HOUDINI_API, which has no meaning in a DWA build environment but
// must at least exist, is normally defined by including openvdb/Platform.h.
// For DWA builds (i.e., if either PRODDEV_BUILD or DWREAL_IS_DOUBLE exists),
// that introduces an unwanted and unnecessary library dependency.
#ifndef OPENVDB_HOUDINI_API
#define OPENVDB_HOUDINI_API
#endif
#else
#include <openvdb/Platform.h>
#endif
namespace houdini_utils {
/// @brief Add geometry to the given GU_Detail to create a box with the given corners.
/// @param corners the eight corners of the box
/// @param color an optional color for the added geometry
/// @param shaded if false, generate a wireframe box; otherwise, generate a solid box
/// @param alpha an optional opacity for the added geometry
OPENVDB_HOUDINI_API void createBox(GU_Detail&, UT_Vector3 corners[8],
const UT_Vector3* color = nullptr, bool shaded = false, float alpha = 1.0);
} // namespace houdini_utils
#endif // HOUDINI_UTILS_GEOMETRY_HAS_BEEN_INCLUDED
| 1,497 | C | 36.449999 | 87 | 0.739479 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GeometryUtil.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file GeometryUtil.cc
/// @author FX R&D Simulation team
/// @brief Utility methods and tools for geometry processing
#include "GeometryUtil.h"
#include "Utils.h"
#include <houdini_utils/geometry.h> // for createBox()
#include <openvdb/tools/VolumeToMesh.h>
#include <GA/GA_ElementWrangler.h>
#include <GA/GA_PageIterator.h>
#include <GA/GA_SplittableRange.h>
#include <GA/GA_Types.h>
#include <GU/GU_ConvertParms.h>
#include <GU/GU_PrimPoly.h>
#include <OBJ/OBJ_Camera.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_String.h>
#include <UT/UT_UniquePtr.h>
#include <cmath>
#include <stdexcept>
#include <vector>
namespace openvdb_houdini {
void
drawFrustum(
GU_Detail& geo, const openvdb::math::Transform& transform,
const UT_Vector3* boxColor, const UT_Vector3* tickColor,
bool shaded, bool drawTicks)
{
if (transform.mapType() != openvdb::math::NonlinearFrustumMap::mapType()) {
return;
}
const openvdb::math::NonlinearFrustumMap& frustum =
*transform.map<openvdb::math::NonlinearFrustumMap>();
const openvdb::BBoxd bbox = frustum.getBBox();
UT_Vector3 corners[8];
struct Local{
static inline void floatVecFromDoubles(UT_Vector3& v, double x, double y, double z) {
v[0] = static_cast<float>(x);
v[1] = static_cast<float>(y);
v[2] = static_cast<float>(z);
}
};
openvdb::Vec3d wp = frustum.applyMap(bbox.min());
Local::floatVecFromDoubles(corners[0], wp[0], wp[1], wp[2]);
wp[0] = bbox.min()[0];
wp[1] = bbox.min()[1];
wp[2] = bbox.max()[2];
wp = frustum.applyMap(wp);
Local::floatVecFromDoubles(corners[1], wp[0], wp[1], wp[2]);
wp[0] = bbox.max()[0];
wp[1] = bbox.min()[1];
wp[2] = bbox.max()[2];
wp = frustum.applyMap(wp);
Local::floatVecFromDoubles(corners[2], wp[0], wp[1], wp[2]);
wp[0] = bbox.max()[0];
wp[1] = bbox.min()[1];
wp[2] = bbox.min()[2];
wp = frustum.applyMap(wp);
Local::floatVecFromDoubles(corners[3], wp[0], wp[1], wp[2]);
wp[0] = bbox.min()[0];
wp[1] = bbox.max()[1];
wp[2] = bbox.min()[2];
wp = frustum.applyMap(wp);
Local::floatVecFromDoubles(corners[4], wp[0], wp[1], wp[2]);
wp[0] = bbox.min()[0];
wp[1] = bbox.max()[1];
wp[2] = bbox.max()[2];
wp = frustum.applyMap(wp);
Local::floatVecFromDoubles(corners[5], wp[0], wp[1], wp[2]);
wp = frustum.applyMap(bbox.max());
Local::floatVecFromDoubles(corners[6], wp[0], wp[1], wp[2]);
wp[0] = bbox.max()[0];
wp[1] = bbox.max()[1];
wp[2] = bbox.min()[2];
wp = frustum.applyMap(wp);
Local::floatVecFromDoubles(corners[7], wp[0], wp[1], wp[2]);
float alpha = shaded ? 0.3f : 1.0f;
houdini_utils::createBox(geo, corners, boxColor, shaded, alpha);
// Add voxel ticks
if (drawTicks) {
GA_RWHandleV3 cd;
int count = 0;
double length = 4, maxLength = (bbox.max()[1] - bbox.min()[1]);
size_t total_count = 0;
if (tickColor) {
cd.bind(geo.addDiffuseAttribute(GA_ATTRIB_POINT));
}
for (double z = bbox.min()[2] + 1, Z = bbox.max()[2]; z < Z; ++z) {
GA_Offset v0 = geo.appendPointOffset();
GA_Offset v1 = geo.appendPointOffset();
if (tickColor) {
cd.set(v0, *tickColor);
cd.set(v1, *tickColor);
}
length = 4;
++count;
if (count == 5) {
length = 8;
count = 0;
}
length = std::min(length, maxLength);
wp[0] = bbox.max()[0];
wp[1] = bbox.max()[1]-length;
wp[2] = z;
wp = frustum.applyMap(wp);
geo.setPos3(v0, wp[0], wp[1], wp[2]);
wp[0] = bbox.max()[0];
wp[1] = bbox.max()[1];
wp[2] = z;
wp = frustum.applyMap(wp);
geo.setPos3(v1, wp[0], wp[1], wp[2]);
GEO_PrimPoly& prim = *GU_PrimPoly::build(&geo, 0, GU_POLY_OPEN, 0);
prim.appendVertex(v0);
prim.appendVertex(v1);
if (++total_count > 999) break;
}
count = 0;
total_count = 0;
maxLength = (bbox.max()[2] - bbox.min()[2]);
for (double x = bbox.min()[0] + 1, X = bbox.max()[0]; x < X; ++x) {
GA_Offset v0 = geo.appendPointOffset();
GA_Offset v1 = geo.appendPointOffset();
if (tickColor) {
cd.set(v0, *tickColor);
cd.set(v1, *tickColor);
}
length = 1;
++count;
if (count == 5) {
length = 2;
count = 0;
}
length = std::min(length, maxLength);
wp[0] = x;
wp[1] = bbox.max()[1];
wp[2] = bbox.max()[2]-length;
wp = frustum.applyMap(wp);
geo.setPos3(v0, wp[0], wp[1], wp[2]);
wp[0] = x;
wp[1] = bbox.max()[1];
wp[2] = bbox.max()[2];
wp = frustum.applyMap(wp);
geo.setPos3(v1, wp[0], wp[1], wp[2]);
GEO_PrimPoly& prim = *GU_PrimPoly::build(&geo, 0, GU_POLY_OPEN, 0);
prim.appendVertex(v0);
prim.appendVertex(v1);
if (++total_count > 999) break;
}
}
}
////////////////////////////////////////
openvdb::math::Transform::Ptr
frustumTransformFromCamera(
OP_Node& node, OP_Context& context, OBJ_Camera& cam,
float offset, float nearPlaneDist, float farPlaneDist,
float voxelDepthSize, int voxelCountX)
{
cam.addInterestOnCameraParms(&node);
const fpreal time = context.getTime();
// Eval camera parms
const fpreal camAspect = cam.ASPECT(time);
const fpreal camFocal = cam.FOCAL(time);
const fpreal camAperture = cam.APERTURE(time);
const fpreal camXRes = cam.RESX(time);
const fpreal camYRes = cam.RESY(time);
nearPlaneDist += offset;
farPlaneDist += offset;
const fpreal depth = farPlaneDist - nearPlaneDist;
const fpreal zoom = camAperture / camFocal;
const fpreal aspectRatio = camYRes / (camXRes * camAspect);
openvdb::Vec2d nearPlaneSize;
nearPlaneSize.x() = nearPlaneDist * zoom;
nearPlaneSize.y() = nearPlaneSize.x() * aspectRatio;
openvdb::Vec2d farPlaneSize;
farPlaneSize.x() = farPlaneDist * zoom;
farPlaneSize.y() = farPlaneSize.x() * aspectRatio;
// Create the linear map
openvdb::math::Mat4d xform(openvdb::math::Mat4d::identity());
xform.setToTranslation(openvdb::Vec3d(0, 0, -(nearPlaneDist - offset)));
/// this will be used to scale the frust to the correct size, and orient the
/// into the frustum as the negative z-direction
xform.preScale(openvdb::Vec3d(nearPlaneSize.x(), nearPlaneSize.x(), -nearPlaneSize.x()));
openvdb::math::Mat4d camxform(openvdb::math::Mat4d::identity());
{
UT_Matrix4 M;
OBJ_Node *meobj = node.getCreator()->castToOBJNode();
if (meobj) {
node.addExtraInput(meobj, OP_INTEREST_DATA);
if (!cam.getRelativeTransform(*meobj, M, context)) {
node.addTransformError(cam, "relative");
}
} else {
if (!static_cast<OP_Node*>(&cam)->getWorldTransform(M, context)) {
node.addTransformError(cam, "world");
}
}
for (unsigned i = 0; i < 4; ++i) {
for (unsigned j = 0; j < 4; ++j) {
camxform(i,j) = M(i,j);
}
}
}
openvdb::math::MapBase::Ptr linearMap(openvdb::math::simplify(
openvdb::math::AffineMap(xform * camxform).getAffineMap()));
// Create the non linear map
const int voxelCountY = int(std::ceil(float(voxelCountX) * aspectRatio));
const int voxelCountZ = int(std::ceil(depth / voxelDepthSize));
// the frustum will be the image of the coordinate in this bounding box
openvdb::BBoxd bbox(openvdb::Vec3d(0, 0, 0),
openvdb::Vec3d(voxelCountX, voxelCountY, voxelCountZ));
// define the taper
const fpreal taper = nearPlaneSize.x() / farPlaneSize.x();
// note that the depth is scaled on the nearPlaneSize.
// the linearMap will uniformly scale the frustum to the correct size
// and rotate to align with the camera
return openvdb::math::Transform::Ptr(new openvdb::math::Transform(
openvdb::math::MapBase::Ptr(new openvdb::math::NonlinearFrustumMap(
bbox, taper, depth/nearPlaneSize.x(), linearMap))));
}
////////////////////////////////////////
bool
pointInPrimGroup(GA_Offset ptnOffset, GU_Detail& geo, const GA_PrimitiveGroup& group)
{
bool surfacePrim = false;
GA_Offset primOffset, vtxOffset = geo.pointVertex(ptnOffset);
while (GAisValid(vtxOffset)) {
primOffset = geo.vertexPrimitive(vtxOffset);
if (group.containsIndex(geo.primitiveIndex(primOffset))) {
surfacePrim = true;
break;
}
vtxOffset = geo.vertexToNextVertex(vtxOffset);
}
return surfacePrim;
}
////////////////////////////////////////
std::unique_ptr<GU_Detail>
convertGeometry(const GU_Detail& geometry, std::string& warning, Interrupter* boss)
{
const GU_Detail* geo = &geometry;
std::unique_ptr<GU_Detail> geoPtr;
const GEO_Primitive *prim;
bool needconvert = false, needdivide = false, needclean = false;
GA_FOR_ALL_PRIMITIVES(geo, prim)
{
if (boss && boss->wasInterrupted()) return geoPtr;
if (prim->getTypeId() == GA_PRIMPOLY) {
const GEO_PrimPoly *poly = static_cast<const GEO_PrimPoly*>(prim);
if (poly->getVertexCount() > 4) needdivide = true;
if (poly->getVertexCount() < 3) needclean = true;
} else {
needconvert = true;
// Some conversions will break division requirements,
// like polysoup -> polygon.
needdivide = true;
break;
}
}
if (needconvert || needdivide || needclean) {
geoPtr.reset(new GU_Detail());
geoPtr->duplicate(*geo);
geo = geoPtr.get();
}
if (boss && boss->wasInterrupted()) return geoPtr;
if (needconvert) {
GU_ConvertParms parms;
parms.setFromType(GEO_PrimTypeCompat::GEOPRIMALL);
parms.setToType(GEO_PrimTypeCompat::GEOPRIMPOLY);
// We don't want interior tetrahedron faces as they will just
// distract us and fill up the vdb.
parms.setSharedFaces(false);
geoPtr->convert(parms);
}
if (boss && boss->wasInterrupted()) return geoPtr;
if (needdivide) {
geoPtr->convex(4);
}
if (needclean || needdivide || needconvert) {
// Final pass to delete anything illegal.
// There could be little fligs left over that
// we don't want confusing the mesher.
GEO_Primitive *delprim;
GA_PrimitiveGroup *delgrp = 0;
GA_FOR_ALL_PRIMITIVES(geoPtr.get(), delprim) {
if (boss && boss->wasInterrupted()) return geoPtr;
bool kill = false;
if (delprim->getPrimitiveId() & GEO_PrimTypeCompat::GEOPRIMPOLY) {
GEO_PrimPoly *poly = static_cast<GEO_PrimPoly*>(delprim);
if (poly->getVertexCount() > 4) kill = true;
if (poly->getVertexCount() < 3) kill = true;
} else {
kill = true;
}
if (kill) {
if (!delgrp) {
delgrp = geoPtr->newPrimitiveGroup("__delete_group__", 1);
}
delgrp->add(delprim);
}
}
if (delgrp) {
geoPtr->deletePrimitives(*delgrp, 1);
geoPtr->destroyPrimitiveGroup(delgrp);
delgrp = 0;
}
}
if (geoPtr && needconvert) {
warning = "Geometry has been converted to quads and triangles.";
}
return geoPtr;
}
////////////////////////////////////////
TransformOp::TransformOp(GU_Detail const * const gdp,
const openvdb::math::Transform& transform,
std::vector<openvdb::Vec3s>& pointList)
: mGdp(gdp)
, mTransform(transform)
, mPointList(&pointList)
{
}
void
TransformOp::operator()(const GA_SplittableRange &r) const
{
GA_Offset start, end;
UT_Vector3 pos;
openvdb::Vec3d ipos;
// Iterate over pages in the range
for (GA_PageIterator pit = r.beginPages(); !pit.atEnd(); ++pit) {
// Iterate over block
for (GA_Iterator it(pit.begin()); it.blockAdvance(start, end); ) {
// Element
for (GA_Offset i = start; i < end; ++i) {
pos = mGdp->getPos3(i);
ipos = mTransform.worldToIndex(openvdb::Vec3d(pos.x(), pos.y(), pos.z()));
(*mPointList)[mGdp->pointIndex(i)] = openvdb::Vec3s(ipos);
}
}
}
}
////////////////////////////////////////
PrimCpyOp::PrimCpyOp(GU_Detail const * const gdp, std::vector<openvdb::Vec4I>& primList)
: mGdp(gdp)
, mPrimList(&primList)
{
}
void
PrimCpyOp::operator()(const GA_SplittableRange &r) const
{
openvdb::Vec4I prim;
GA_Offset start, end;
// Iterate over pages in the range
for (GA_PageIterator pit = r.beginPages(); !pit.atEnd(); ++pit) {
// Iterate over the elements in the page.
for (GA_Iterator it(pit.begin()); it.blockAdvance(start, end); ) {
for (GA_Offset i = start; i < end; ++i) {
const GA_Primitive* primRef = mGdp->getPrimitiveList().get(i);
const GA_Size vtxn = primRef->getVertexCount();
if (primRef->getTypeId() == GEO_PRIMPOLY && (3 == vtxn || 4 == vtxn)) {
for (int vtx = 0; vtx < int(vtxn); ++vtx) {
prim[vtx] = static_cast<openvdb::Vec4I::ValueType>(
primRef->getPointIndex(vtx));
}
if (vtxn != 4) prim[3] = openvdb::util::INVALID_IDX;
(*mPrimList)[mGdp->primitiveIndex(i)] = prim;
} else {
throw std::runtime_error(
"Invalid geometry; only quads and triangles are supported.");
}
}
}
}
}
////////////////////////////////////////
VertexNormalOp::VertexNormalOp(GU_Detail& detail,
const GA_PrimitiveGroup *interiorPrims, float angle)
: mDetail(detail)
, mInteriorPrims(interiorPrims)
, mAngle(angle)
{
GA_RWAttributeRef attributeRef =
detail.findFloatTuple(GA_ATTRIB_VERTEX, "N", 3);
if (!attributeRef.isValid()) {
attributeRef = detail.addFloatTuple(
GA_ATTRIB_VERTEX, "N", 3, GA_Defaults(0));
}
mNormalHandle = attributeRef.getAttribute();
}
void
VertexNormalOp::operator()(const GA_SplittableRange& range) const
{
GA_Offset start, end, primOffset;
UT_Vector3 primN, avgN, tmpN;
bool interiorPrim = false;
const GA_Primitive* primRef = nullptr;
for (GA_PageIterator pageIt = range.beginPages(); !pageIt.atEnd(); ++pageIt) {
for (GA_Iterator blockIt(pageIt.begin()); blockIt.blockAdvance(start, end); ) {
for (GA_Offset i = start; i < end; ++i) {
primRef = mDetail.getPrimitiveList().get(i);
primN = mDetail.getGEOPrimitive(i)->computeNormal();
interiorPrim = isInteriorPrim(i);
for (GA_Size vtx = 0, vtxN = primRef->getVertexCount(); vtx < vtxN; ++vtx) {
avgN = primN;
const GA_Offset vtxoff = primRef->getVertexOffset(vtx);
GA_Offset vtxOffset = mDetail.pointVertex(mDetail.vertexPoint(vtxoff));
while (GAisValid(vtxOffset)) {
primOffset = mDetail.vertexPrimitive(vtxOffset);
if (interiorPrim == isInteriorPrim(primOffset)) {
tmpN = mDetail.getGEOPrimitive(primOffset)->computeNormal();
if (tmpN.dot(primN) > mAngle) avgN += tmpN;
}
vtxOffset = mDetail.vertexToNextVertex(vtxOffset);
}
avgN.normalize();
mNormalHandle.set(vtxoff, avgN);
}
}
}
}
}
////////////////////////////////////////
SharpenFeaturesOp::SharpenFeaturesOp(
GU_Detail& meshGeo, const GU_Detail& refGeo, EdgeData& edgeData,
const openvdb::math::Transform& xform,
const GA_PrimitiveGroup * surfacePrims,
const openvdb::BoolTree * mask)
: mMeshGeo(meshGeo)
, mRefGeo(refGeo)
, mEdgeData(edgeData)
, mXForm(xform)
, mSurfacePrims(surfacePrims)
, mMaskTree(mask)
{
}
void
SharpenFeaturesOp::operator()(const GA_SplittableRange& range) const
{
openvdb::tools::MeshToVoxelEdgeData::Accessor acc = mEdgeData.getAccessor();
using BoolAccessor = openvdb::tree::ValueAccessor<const openvdb::BoolTree>;
UT_UniquePtr<BoolAccessor> maskAcc;
if (mMaskTree) {
maskAcc.reset(new BoolAccessor(*mMaskTree));
}
GA_Offset start, end, ptnOffset, primOffset;
UT_Vector3 tmpN, tmpP, avgP;
UT_BoundingBoxD cell;
openvdb::Vec3d pos, normal;
openvdb::Coord ijk;
std::vector<openvdb::Vec3d> points(12), normals(12);
std::vector<openvdb::Index32> primitives(12);
for (GA_PageIterator pageIt = range.beginPages(); !pageIt.atEnd(); ++pageIt) {
for (GA_Iterator blockIt(pageIt.begin()); blockIt.blockAdvance(start, end); ) {
for (ptnOffset = start; ptnOffset < end; ++ptnOffset) {
// Check if this point is referenced by a surface primitive.
if (mSurfacePrims && !pointInPrimGroup(ptnOffset, mMeshGeo, *mSurfacePrims))
continue;
tmpP = mMeshGeo.getPos3(ptnOffset);
pos[0] = tmpP.x();
pos[1] = tmpP.y();
pos[2] = tmpP.z();
pos = mXForm.worldToIndex(pos);
ijk[0] = int(std::floor(pos[0]));
ijk[1] = int(std::floor(pos[1]));
ijk[2] = int(std::floor(pos[2]));
if (maskAcc && !maskAcc->isValueOn(ijk)) continue;
points.clear();
normals.clear();
primitives.clear();
// get voxel-edge intersections
mEdgeData.getEdgeData(acc, ijk, points, primitives);
avgP.assign(0.0, 0.0, 0.0);
// get normal list
for (size_t n = 0, N = points.size(); n < N; ++n) {
avgP.x() = static_cast<float>(avgP.x() + points[n].x());
avgP.y() = static_cast<float>(avgP.y() + points[n].y());
avgP.z() = static_cast<float>(avgP.z() + points[n].z());
primOffset = mRefGeo.primitiveOffset(primitives[n]);
tmpN = mRefGeo.getGEOPrimitive(primOffset)->computeNormal();
normal[0] = tmpN.x();
normal[1] = tmpN.y();
normal[2] = tmpN.z();
normals.push_back(normal);
}
// Calculate feature point position
if (points.size() > 1) {
pos = openvdb::tools::findFeaturePoint(points, normals);
// Constrain points to stay inside their initial
// coordinate cell.
cell.setBounds(double(ijk[0]), double(ijk[1]), double(ijk[2]),
double(ijk[0]+1), double(ijk[1]+1), double(ijk[2]+1));
cell.expandBounds(0.3, 0.3, 0.3);
if (!cell.isInside(pos[0], pos[1], pos[2])) {
UT_Vector3 org(
static_cast<float>(pos[0]),
static_cast<float>(pos[1]),
static_cast<float>(pos[2]));
avgP *= 1.f / float(points.size());
UT_Vector3 dir = avgP - org;
dir.normalize();
double distance;
if(cell.intersectRay(org, dir, 1E17F, &distance) > 0) {
tmpP = org + dir * distance;
pos[0] = tmpP.x();
pos[1] = tmpP.y();
pos[2] = tmpP.z();
}
}
pos = mXForm.indexToWorld(pos);
tmpP.x() = static_cast<float>(pos[0]);
tmpP.y() = static_cast<float>(pos[1]);
tmpP.z() = static_cast<float>(pos[2]);
mMeshGeo.setPos3(ptnOffset, tmpP);
}
}
}
}
}
} // namespace openvdb_houdini
| 21,036 | C++ | 29.31268 | 93 | 0.535843 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/Utils.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file Utils.cc
/// @author FX R&D Simulation team
/// @brief Utility classes and functions for OpenVDB plugins
#include "Utils.h"
#include <houdini_utils/ParmFactory.h>
#include "GEO_PrimVDB.h"
#include <GU/GU_Detail.h>
#include <UT/UT_String.h>
#include <UT/UT_Version.h>
#ifdef OPENVDB_USE_LOG4CPLUS
#include <openvdb/util/logging.h>
#include <UT/UT_ErrorManager.h>
#include <CHOP/CHOP_Error.h> // for CHOP_ERROR_MESSAGE
#include <DOP/DOP_Error.h> // for DOP_MESSAGE
#if UT_VERSION_INT < 0x11050000 // earlier than 17.5.0
#include <POP/POP_Error.h> // for POP_MESSAGE
#endif
#include <ROP/ROP_Error.h> // for ROP_MESSAGE
#include <VOP/VOP_Error.h> // for VOP_MESSAGE
#include <VOPNET/VOPNET_Error.h> // for VOPNET_MESSAGE
#include <string>
#endif
namespace openvdb_houdini {
VdbPrimCIterator::VdbPrimCIterator(const GEO_Detail* gdp, const GA_PrimitiveGroup* group,
FilterFunc filter):
mIter(gdp ? new GA_GBPrimitiveIterator(*gdp, group) : nullptr),
mFilter(filter)
{
// Ensure that, after construction, this iterator points to
// a valid VDB primitive (if there is one).
if (nullptr == getPrimitive()) advance();
}
VdbPrimCIterator::VdbPrimCIterator(const GEO_Detail* gdp, GA_Range::safedeletions,
const GA_PrimitiveGroup* group, FilterFunc filter):
mIter(gdp ? new GA_GBPrimitiveIterator(*gdp, group, GA_Range::safedeletions()) : nullptr),
mFilter(filter)
{
// Ensure that, after construction, this iterator points to
// a valid VDB primitive (if there is one).
if (nullptr == getPrimitive()) advance();
}
VdbPrimCIterator::VdbPrimCIterator(const VdbPrimCIterator& other):
mIter(other.mIter ? new GA_GBPrimitiveIterator(*other.mIter) : nullptr),
mFilter(other.mFilter)
{
}
VdbPrimCIterator&
VdbPrimCIterator::operator=(const VdbPrimCIterator& other)
{
if (&other != this) {
mIter.reset(other.mIter ? new GA_GBPrimitiveIterator(*other.mIter) : nullptr);
mFilter = other.mFilter;
}
return *this;
}
void
VdbPrimCIterator::advance()
{
if (mIter) {
GA_GBPrimitiveIterator& iter = *mIter;
for (++iter; iter.getPrimitive() != nullptr && getPrimitive() == nullptr; ++iter) {}
}
}
const GU_PrimVDB*
VdbPrimCIterator::getPrimitive() const
{
if (mIter) {
if (GA_Primitive* prim = mIter->getPrimitive()) {
const GA_PrimitiveTypeId primVdbTypeId = GA_PRIMVDB;
if (prim->getTypeId() == primVdbTypeId) {
GU_PrimVDB* vdb = UTverify_cast<GU_PrimVDB*>(prim);
if (mFilter && !mFilter(*vdb)) return nullptr;
return vdb;
}
}
}
return nullptr;
}
UT_String
VdbPrimCIterator::getPrimitiveName(const UT_String& defaultName) const
{
// We must have ALWAYS_DEEP enabled on returned UT_String objects to avoid
// having it deleted before the caller has a chance to use it.
UT_String name(UT_String::ALWAYS_DEEP);
if (const GU_PrimVDB* vdb = getPrimitive()) {
name = vdb->getGridName();
if (!name.isstring()) name = defaultName;
}
return name;
}
UT_String
VdbPrimCIterator::getPrimitiveNameOrIndex() const
{
UT_String name;
name.itoa(this->getIndex());
return this->getPrimitiveName(/*defaultName=*/name);
}
UT_String
VdbPrimCIterator::getPrimitiveIndexAndName(bool keepEmptyName) const
{
// We must have ALWAYS_DEEP enabled on returned UT_String objects to avoid
// having it deleted before the caller has a chance to use it.
UT_String result(UT_String::ALWAYS_DEEP);
if (const GU_PrimVDB* vdb = getPrimitive()) {
result.itoa(this->getIndex());
UT_String name = vdb->getGridName();
if (keepEmptyName || name.isstring()) {
result += (" (" + name.toStdString() + ")").c_str();
}
}
return result;
}
////////////////////////////////////////
VdbPrimIterator::VdbPrimIterator(const VdbPrimIterator& other): VdbPrimCIterator(other)
{
}
VdbPrimIterator&
VdbPrimIterator::operator=(const VdbPrimIterator& other)
{
if (&other != this) VdbPrimCIterator::operator=(other);
return *this;
}
////////////////////////////////////////
GU_PrimVDB*
createVdbPrimitive(GU_Detail& gdp, GridPtr grid, const char* name)
{
return (!grid ? nullptr : GU_PrimVDB::buildFromGrid(gdp, grid, /*src=*/nullptr, name));
}
GU_PrimVDB*
replaceVdbPrimitive(GU_Detail& gdp, GridPtr grid, GEO_PrimVDB& src,
const bool copyAttrs, const char* name)
{
GU_PrimVDB* vdb = nullptr;
if (grid) {
vdb = GU_PrimVDB::buildFromGrid(gdp, grid, (copyAttrs ? &src : nullptr), name);
gdp.destroyPrimitive(src, /*andPoints=*/true);
}
return vdb;
}
////////////////////////////////////////
bool
evalGridBBox(GridCRef grid, UT_Vector3 corners[8], bool expandHalfVoxel)
{
if (grid.activeVoxelCount() == 0) return false;
openvdb::CoordBBox activeBBox = grid.evalActiveVoxelBoundingBox();
if (!activeBBox) return false;
openvdb::BBoxd voxelBBox(activeBBox.min().asVec3d(), activeBBox.max().asVec3d());
if (expandHalfVoxel) {
voxelBBox.min() -= openvdb::Vec3d(0.5);
voxelBBox.max() += openvdb::Vec3d(0.5);
}
openvdb::Vec3R bbox[8];
bbox[0] = voxelBBox.min();
bbox[1].init(voxelBBox.min()[0], voxelBBox.min()[1], voxelBBox.max()[2]);
bbox[2].init(voxelBBox.max()[0], voxelBBox.min()[1], voxelBBox.max()[2]);
bbox[3].init(voxelBBox.max()[0], voxelBBox.min()[1], voxelBBox.min()[2]);
bbox[4].init(voxelBBox.min()[0], voxelBBox.max()[1], voxelBBox.min()[2]);
bbox[5].init(voxelBBox.min()[0], voxelBBox.max()[1], voxelBBox.max()[2]);
bbox[6] = voxelBBox.max();
bbox[7].init(voxelBBox.max()[0], voxelBBox.max()[1], voxelBBox.min()[2]);
const openvdb::math::Transform& xform = grid.transform();
bbox[0] = xform.indexToWorld(bbox[0]);
bbox[1] = xform.indexToWorld(bbox[1]);
bbox[2] = xform.indexToWorld(bbox[2]);
bbox[3] = xform.indexToWorld(bbox[3]);
bbox[4] = xform.indexToWorld(bbox[4]);
bbox[5] = xform.indexToWorld(bbox[5]);
bbox[6] = xform.indexToWorld(bbox[6]);
bbox[7] = xform.indexToWorld(bbox[7]);
for (size_t i = 0; i < 8; ++i) {
corners[i].assign(float(bbox[i][0]), float(bbox[i][1]), float(bbox[i][2]));
}
return true;
}
////////////////////////////////////////
openvdb::CoordBBox
makeCoordBBox(const UT_BoundingBox& b, const openvdb::math::Transform& t)
{
openvdb::Vec3d minWS, maxWS, minIS, maxIS;
minWS[0] = double(b.xmin());
minWS[1] = double(b.ymin());
minWS[2] = double(b.zmin());
maxWS[0] = double(b.xmax());
maxWS[1] = double(b.ymax());
maxWS[2] = double(b.zmax());
openvdb::math::calculateBounds(t, minWS, maxWS, minIS, maxIS);
openvdb::CoordBBox box;
box.min() = openvdb::Coord::floor(minIS);
box.max() = openvdb::Coord::ceil(maxIS);
return box;
}
////////////////////////////////////////
#ifndef OPENVDB_USE_LOG4CPLUS
void startLogForwarding(OP_OpTypeId) {}
void stopLogForwarding(OP_OpTypeId) {}
bool isLogForwarding(OP_OpTypeId) { return false; }
#else
namespace {
namespace l4c = log4cplus;
/// @brief log4cplus appender that directs log messages to UT_ErrorManager
class HoudiniAppender: public l4c::Appender
{
public:
/// @param opType SOP_OPTYPE_NAME, ROP_OPTYPE_NAME, etc. (see OP_Node.h)
/// @param code SOP_MESSAGE, SOP_VEX_ERROR, ROP_MESSAGE, etc.
/// (see SOP_Error.h, ROP_Error.h, etc.)
HoudiniAppender(const char* opType, int code): mOpType(opType), mCode(code) {}
~HoudiniAppender() override
{
close();
destructorImpl(); // must be called by Appender subclasses
}
void append(const l4c::spi::InternalLoggingEvent& event) override
{
if (mClosed) return;
auto* errMgr = UTgetErrorManager();
if (!errMgr || errMgr->isDisabled()) return;
const l4c::LogLevel level = event.getLogLevel();
const std::string& msg = event.getMessage();
const std::string& file = event.getFile();
const int line = event.getLine();
const UT_SourceLocation
loc{file.c_str(), line},
*locPtr = (file.empty() ? nullptr : &loc);
UT_ErrorSeverity severity = UT_ERROR_NONE;
switch (level) {
case l4c::DEBUG_LOG_LEVEL: severity = UT_ERROR_MESSAGE; break;
case l4c::INFO_LOG_LEVEL: severity = UT_ERROR_MESSAGE; break;
case l4c::WARN_LOG_LEVEL: severity = UT_ERROR_WARNING; break;
case l4c::ERROR_LOG_LEVEL: severity = UT_ERROR_ABORT; break;
case l4c::FATAL_LOG_LEVEL: severity = UT_ERROR_FATAL; break;
}
errMgr->addGeneric(mOpType.c_str(), mCode, msg.c_str(), severity, locPtr);
}
void close() override { mClosed = true; }
private:
std::string mOpType = INVALID_OPTYPE_NAME;
int mCode = 0;
bool mClosed = false;
};
inline l4c::tstring
getAppenderName(const OP_TypeInfo& opInfo)
{
return LOG4CPLUS_STRING_TO_TSTRING(
std::string{"HOUDINI_"} + static_cast<const char*>(opInfo.myOptypeName));
}
/// @brief Return the error code for user-supplied messages in operators of the given type.
inline int
getGenericMessageCode(OP_OpTypeId opId)
{
switch (opId) {
case CHOP_OPTYPE_ID: return CHOP_ERROR_MESSAGE;
case DOP_OPTYPE_ID: return DOP_MESSAGE;
#if UT_VERSION_INT < 0x11050000 // earlier than 17.5.0
case POP_OPTYPE_ID: return POP_MESSAGE;
#endif
case ROP_OPTYPE_ID: return ROP_MESSAGE;
case SOP_OPTYPE_ID: return SOP_MESSAGE;
case VOP_OPTYPE_ID: return VOP_MESSAGE;
case VOPNET_OPTYPE_ID: return VOPNET_MESSAGE;
default: break;
}
return 0;
}
inline void
setLogForwarding(OP_OpTypeId opId, bool enable)
{
const auto* opInfo = OP_Node::getOpInfoFromOpTypeID(opId);
if (!opInfo) return;
const auto appenderName = getAppenderName(*opInfo);
auto logger = openvdb::logging::internal::getLogger();
auto appender = logger.getAppender(appenderName);
if (appender && !enable) {
// If an appender for the given operator type exists, remove it.
logger.removeAppender(appender);
} else if (!appender && enable) {
// If an appender for the given operator type doesn't already exist, create one.
// Otherwise, do nothing: operators of the same type can share a single appender.
appender = log4cplus::SharedAppenderPtr{
new HoudiniAppender{opInfo->myOptypeName, getGenericMessageCode(opId)}};
appender->setName(appenderName);
// Don't forward debug or lower-level messages.
appender->setThreshold(log4cplus::INFO_LOG_LEVEL);
logger.addAppender(appender);
}
}
} // anonymous namespace
void
startLogForwarding(OP_OpTypeId opId)
{
setLogForwarding(opId, true);
}
void
stopLogForwarding(OP_OpTypeId opId)
{
setLogForwarding(opId, false);
}
bool
isLogForwarding(OP_OpTypeId opId)
{
if (const auto* opInfo = OP_Node::getOpInfoFromOpTypeID(opId)) {
return openvdb::logging::internal::getLogger().getAppender(
getAppenderName(*opInfo));
}
return false;
}
#endif // OPENVDB_USE_LOG4CPLUS
} // namespace openvdb_houdini
| 11,380 | C++ | 27.381546 | 94 | 0.641916 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Rebuild_Level_Set.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Rebuild_Level_Set.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Rebuild level sets or fog volumes.
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/tools/LevelSetRebuild.h>
#include <UT/UT_Interrupt.h>
#include <CH/CH_Manager.h>
#include <PRM/PRM_Parm.h>
#include <PRM/PRM_SharedFunc.h>
#include <algorithm>
#include <limits>
#include <stdexcept>
#include <string>
#include <vector>
#include <hboost/algorithm/string/join.hpp>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
class SOP_OpenVDB_Rebuild_Level_Set: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Rebuild_Level_Set(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Rebuild_Level_Set() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
};
////////////////////////////////////////
// Build UI and register this operator.
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
//////////
// Conversion settings
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Specify a subset of the input VDB grids to be processed\n"
"(scalar, floating-point grids only)")
.setDocumentation(
"A subset of the scalar, floating-point input VDBs to be processed"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "isovalue", "Isovalue")
.setRange(PRM_RANGE_UI, -1, PRM_RANGE_UI, 1)
.setTooltip("The isovalue that defines the implicit surface"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "worldunits", "Use World Space Units")
.setTooltip("If enabled, specify the width of the narrow band in world units."));
// Voxel unit narrow-band width {
parms.add(hutil::ParmFactory(PRM_FLT_J, "exteriorBandWidth", "Exterior Band Voxels")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip("Specify the width of the exterior (distance >= 0) portion of the narrow band. "
"(3 voxel units is optimal for level set operations.)")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_FLT_J, "interiorBandWidth", "Interior Band Voxels")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 10)
.setTooltip("Specify the width of the interior (distance < 0) portion of the narrow band. "
"(3 voxel units is optimal for level set operations.)")
.setDocumentation(nullptr));
// }
// World unit narrow-band width {
parms.add(hutil::ParmFactory(PRM_FLT_J, "exteriorBandWidthWS", "Exterior Band")
.setDefault(0.1)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 10)
.setTooltip("Specify the width of the exterior (distance >= 0) portion of the narrow band.")
.setDocumentation(
"Specify the width of the exterior (_distance_ => 0) portion of the narrow band."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "interiorBandWidthWS", "Interior Band")
.setDefault(0.1)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 10)
.setTooltip("Specify the width of the interior (distance < 0) portion of the narrow band.")
.setDocumentation(
"Specify the width of the interior (_distance_ < 0) portion of the narrow band."));
// }
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fillinterior", "Fill Interior")
.setTooltip(
"If enabled, extract signed distances for all interior voxels.\n\n"
"This operation densifies the interior of the surface and requires"
" a closed, watertight surface."));
//////////
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "halfbandwidth", "Half-Band Width")
.setDefault(PRMthreeDefaults));
//////////
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Rebuild SDF",
SOP_OpenVDB_Rebuild_Level_Set::factory, parms, *table)
.setNativeName("")
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBRebuildLevelSet")
#endif
.setObsoleteParms(obsoleteParms)
.addInput("VDB grids to process")
.setVerb(SOP_NodeVerb::COOK_INPLACE,
[]() { return new SOP_OpenVDB_Rebuild_Level_Set::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Repair level sets represented by VDB volumes.\"\"\"\n\
\n\
@overview\n\
\n\
Certain operations on a level set volume can cause the signed distances\n\
to its zero crossing to become invalid.\n\
This node restores proper distances by surfacing the level set with\n\
a polygon mesh and then converting the mesh back to a level set.\n\
As such, it can repair more badly damaged level sets than can the\n\
[OpenVDB Renormalize Level Set|Node:sop/DW_OpenVDBRenormalizeLevelSet] node.\n\
\n\
@related\n\
- [OpenVDB Offset Level Set|Node:sop/DW_OpenVDBOffsetLevelSet]\n\
- [OpenVDB Renormalize Level Set|Node:sop/DW_OpenVDBRenormalizeLevelSet]\n\
- [OpenVDB Smooth Level Set|Node:sop/DW_OpenVDBSmoothLevelSet]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Rebuild_Level_Set::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Rebuild_Level_Set(net, name, op);
}
SOP_OpenVDB_Rebuild_Level_Set::SOP_OpenVDB_Rebuild_Level_Set(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
void
SOP_OpenVDB_Rebuild_Level_Set::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
const fpreal time = CHgetEvalTime();
PRM_Parm* parm = obsoleteParms->getParmPtr("halfbandwidth");
if (parm && !parm->isFactoryDefault()) {
const fpreal voxelWidth = obsoleteParms->evalFloat("halfbandwidth", 0, time);
setFloat("exteriorBandWidth", 0, time, voxelWidth);
setFloat("interiorBandWidth", 0, time, voxelWidth);
}
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
////////////////////////////////////////
// Enable/disable or show/hide parameters in the UI.
bool
SOP_OpenVDB_Rebuild_Level_Set::updateParmsFlags()
{
bool changed = false;
const bool fillInterior = bool(evalInt("fillinterior", 0, 0));
changed |= enableParm("interiorBandWidth", !fillInterior);
changed |= enableParm("interiorBandWidthWS", !fillInterior);
const bool worldUnits = bool(evalInt("worldunits", 0, 0));
changed |= setVisibleState("interiorBandWidth", !worldUnits);
changed |= setVisibleState("interiorBandWidthWS", worldUnits);
changed |= setVisibleState("exteriorBandWidth", !worldUnits);
changed |= setVisibleState("exteriorBandWidthWS", worldUnits);
return changed;
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Rebuild_Level_Set::Cache::cookVDBSop(
OP_Context& context)
{
try {
const fpreal time = context.getTime();
// Get the group of grids to process.
const GA_PrimitiveGroup* group = this->matchGroup(*gdp, evalStdString("group", time));
// Get other UI parameters.
const bool fillInterior = bool(evalInt("fillinterior", 0, time));
const bool worldUnits = bool(evalInt("worldunits", 0, time));
float exBandWidthVoxels = float(evalFloat("exteriorBandWidth", 0, time));
float inBandWidthVoxels = fillInterior ? std::numeric_limits<float>::max() :
float(evalFloat("interiorBandWidth", 0, time));
float exBandWidthWorld = float(evalFloat("exteriorBandWidthWS", 0, time));
float inBandWidthWorld = fillInterior ? std::numeric_limits<float>::max() :
float(evalFloat("interiorBandWidthWS", 0, time));
const float iso = float(evalFloat("isovalue", 0, time));
hvdb::Interrupter boss("Rebuilding Level Set Grids");
std::vector<std::string> skippedGrids;
// Process each VDB primitive that belongs to the selected group.
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (boss.wasInterrupted()) break;
GU_PrimVDB* vdbPrim = *it;
float exWidth = exBandWidthVoxels, inWidth = inBandWidthVoxels;
if (worldUnits) {
const float voxelSize = float(vdbPrim->getGrid().voxelSize()[0]);
exWidth = exBandWidthWorld / voxelSize;
if (!fillInterior) inWidth = inBandWidthWorld / voxelSize;
if (exWidth < 1.0f || inWidth < 1.0f) {
exWidth = std::max(exWidth, 1.0f);
inWidth = std::max(inWidth, 1.0f);
std::string s = it.getPrimitiveNameOrIndex().toStdString();
s += " - band width is smaller than one voxel.";
addWarning(SOP_MESSAGE, s.c_str());
}
}
// Process floating point grids.
if (vdbPrim->getStorageType() == UT_VDB_FLOAT) {
openvdb::FloatGrid& grid = UTvdbGridCast<openvdb::FloatGrid>(vdbPrim->getGrid());
vdbPrim->setGrid(*openvdb::tools::levelSetRebuild(
grid, iso, exWidth, inWidth, /*xform=*/nullptr, &boss));
const GEO_VolumeOptions& visOps = vdbPrim->getVisOptions();
vdbPrim->setVisualization(GEO_VOLUMEVIS_ISO, visOps.myIso, visOps.myDensity);
} else if (vdbPrim->getStorageType() == UT_VDB_DOUBLE) {
openvdb::DoubleGrid& grid = UTvdbGridCast<openvdb::DoubleGrid>(vdbPrim->getGrid());
vdbPrim->setGrid(*openvdb::tools::levelSetRebuild(
grid, iso, exWidth, inWidth, /*xform=*/nullptr, &boss));
const GEO_VolumeOptions& visOps = vdbPrim->getVisOptions();
vdbPrim->setVisualization(GEO_VOLUMEVIS_ISO, visOps.myIso, visOps.myDensity);
} else {
skippedGrids.push_back(it.getPrimitiveNameOrIndex().toStdString());
}
}
if (!skippedGrids.empty()) {
std::string s = "The following non-floating-point grids were skipped: " +
hboost::algorithm::join(skippedGrids, ", ") + ".";
addWarning(SOP_MESSAGE, s.c_str());
}
if (boss.wasInterrupted()) {
addWarning(SOP_MESSAGE, "Process was interrupted.");
}
boss.end();
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 11,321 | C++ | 33.10241 | 100 | 0.631305 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/PointUtils.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file PointUtils.h
///
/// @authors Dan Bailey, Nick Avramoussis, Richard Kwok
///
/// @brief Utility classes and functions for OpenVDB Points Houdini plugins
#ifndef OPENVDB_HOUDINI_POINT_UTILS_HAS_BEEN_INCLUDED
#define OPENVDB_HOUDINI_POINT_UTILS_HAS_BEEN_INCLUDED
#include <openvdb/math/Vec3.h>
#include <openvdb/Types.h>
#include <openvdb/points/PointDataGrid.h>
#include <GA/GA_Attribute.h>
#include <GU/GU_Detail.h>
#include <PRM/PRM_ChoiceList.h>
#include <iosfwd>
#include <map>
#include <memory>
#include <string>
#include <vector>
#ifdef SESI_OPENVDB
#ifdef OPENVDB_HOUDINI_API
#undef OPENVDB_HOUDINI_API
#define OPENVDB_HOUDINI_API
#endif
#endif
namespace openvdb_houdini {
using OffsetList = std::vector<GA_Offset>;
using OffsetListPtr = std::shared_ptr<OffsetList>;
using OffsetPair = std::pair<GA_Offset, GA_Offset>;
using OffsetPairList = std::vector<OffsetPair>;
using OffsetPairListPtr = std::shared_ptr<OffsetPairList>;
// note that the bool parameter here for toggling in-memory compression is now deprecated
using AttributeInfoMap = std::map<openvdb::Name, std::pair<int, bool>>;
using WarnFunc = std::function<void (const std::string&)>;
/// Metadata name for viewport groups
const std::string META_GROUP_VIEWPORT = "group_viewport";
/// Enum to store available compression types for point grids
enum POINT_COMPRESSION_TYPE
{
COMPRESSION_NONE = 0,
COMPRESSION_TRUNCATE,
COMPRESSION_UNIT_VECTOR,
COMPRESSION_UNIT_FIXED_POINT_8,
COMPRESSION_UNIT_FIXED_POINT_16,
};
// forward declaration
class Interrupter;
/// @brief Compute a voxel size from a Houdini detail
///
/// @param detail GU_Detail to compute the voxel size from
/// @param pointsPerVoxel the target number of points per voxel, must be positive and non-zero
/// @param matrix voxel size will be computed using this transform
/// @param decimalPlaces for readability, truncate voxel size to this number of decimals
/// @param interrupter a Houdini interrupter
OPENVDB_HOUDINI_API
float
computeVoxelSizeFromHoudini(
const GU_Detail& detail,
const openvdb::Index pointsPerVoxel,
const openvdb::math::Mat4d& matrix,
const openvdb::Index decimalPlaces,
Interrupter& interrupter);
/// @brief Convert a Houdini detail into a VDB Points grid
///
/// @param detail GU_Detail to convert the points and attributes from
/// @param compression position compression to use
/// @param attributes a vector of VDB Points attributes to be included
/// (empty vector defaults to all)
/// @param transform transform to use for the new point grid
/// @param warnings list of warnings to be added to the SOP
OPENVDB_HOUDINI_API
openvdb::points::PointDataGrid::Ptr
convertHoudiniToPointDataGrid(
const GU_Detail& detail,
const int compression,
const AttributeInfoMap& attributes,
const openvdb::math::Transform& transform,
const WarnFunc& warnings = [](const std::string&){});
/// @brief Convert a VDB Points grid into Houdini points and append them to a Houdini Detail
///
/// @param detail GU_Detail to append the converted points and attributes to
/// @param grid grid containing the points that will be converted
/// @param attributes a vector of VDB Points attributes to be included
/// (empty vector defaults to all)
/// @param includeGroups a vector of VDB Points groups to be included
/// (empty vector defaults to all)
/// @param excludeGroups a vector of VDB Points groups to be excluded
/// (empty vector defaults to none)
/// @param inCoreOnly true if out-of-core leaf nodes are to be ignored
OPENVDB_HOUDINI_API
void
convertPointDataGridToHoudini(
GU_Detail& detail,
const openvdb::points::PointDataGrid& grid,
const std::vector<std::string>& attributes = {},
const std::vector<std::string>& includeGroups = {},
const std::vector<std::string>& excludeGroups = {},
const bool inCoreOnly = false);
/// @brief Populate VDB Points grid metadata from Houdini detail attributes
///
/// @param grid grid to be populated with metadata
/// @param detail GU_Detail to extract the detail attributes from
/// @param warnings list of warnings to be added to the SOP
OPENVDB_HOUDINI_API
void
populateMetadataFromHoudini(
openvdb::points::PointDataGrid& grid,
const GU_Detail& detail,
const WarnFunc& warnings = [](const std::string&){});
/// @brief Convert VDB Points grid metadata into Houdini detail attributes
///
/// @param detail GU_Detail to add the Houdini detail attributes
/// @param metaMap the metamap to create the Houdini detail attributes from
/// @param warnings list of warnings to be added to the SOP
OPENVDB_HOUDINI_API
void
convertMetadataToHoudini(
GU_Detail& detail,
const openvdb::MetaMap& metaMap,
const WarnFunc& warnings = [](const std::string&){});
/// @brief Returns supported tuple sizes for conversion from GA_Attribute
OPENVDB_HOUDINI_API
int16_t
attributeTupleSize(const GA_Attribute* const attribute);
/// @brief Returns supported Storage types for conversion from GA_Attribute
OPENVDB_HOUDINI_API
GA_Storage
attributeStorageType(const GA_Attribute* const attribute);
///////////////////////////////////////
/// @brief If the given grid is a PointDataGrid, add node specific info text to
/// the stream provided. This is used to populate the MMB window in Houdini
/// versions 15 and earlier, as well as the Operator Information Window.
OPENVDB_HOUDINI_API
void
pointDataGridSpecificInfoText(std::ostream&, const openvdb::GridBase&);
/// @brief Populates string data with information about the provided OpenVDB
/// Points grid.
/// @param grid The OpenVDB Points grid to retrieve information from.
/// @param countStr The total point count as a formatted integer.
/// @param groupStr The list of comma separated groups (or "none" if no
/// groups exist). Enclosed by parentheses.
/// @param attributeStr The list of comma separated attributes (or "none" if
/// no attributes exist). Enclosed by parentheses.
/// Each attribute takes the form "name [type] [code]
/// [stride]" where code and stride are added for non
/// default attributes.
OPENVDB_HOUDINI_API
void
collectPointInfo(const openvdb::points::PointDataGrid& grid,
std::string& countStr,
std::string& groupStr,
std::string& attributeStr);
///////////////////////////////////////
// VDB Points group name drop-down menu
OPENVDB_HOUDINI_API extern const PRM_ChoiceList VDBPointsGroupMenuInput1;
OPENVDB_HOUDINI_API extern const PRM_ChoiceList VDBPointsGroupMenuInput2;
OPENVDB_HOUDINI_API extern const PRM_ChoiceList VDBPointsGroupMenuInput3;
OPENVDB_HOUDINI_API extern const PRM_ChoiceList VDBPointsGroupMenuInput4;
/// @note Use this if you have more than 4 inputs, otherwise use
/// the input specific menus instead which automatically
/// handle the appropriate spare data settings.
OPENVDB_HOUDINI_API extern const PRM_ChoiceList VDBPointsGroupMenu;
} // namespace openvdb_houdini
#endif // OPENVDB_HOUDINI_POINT_UTILS_HAS_BEEN_INCLUDED
| 7,485 | C | 34.478673 | 97 | 0.702739 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/UT_VDBUtils.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c) Side Effects Software Inc.
*
* Produced by:
* Side Effects Software Inc.
* 123 Front Street West, Suite 1401
* Toronto, Ontario
* Canada M5J 2M2
* 416-366-4607
*/
#include <UT/UT_Version.h>
#if !defined(SESI_OPENVDB) && !defined(SESI_OPENVDB_PRIM)
#include <UT/UT_VDBUtils.h>
#else
#ifndef __HDK_UT_VDBUtils__
#define __HDK_UT_VDBUtils__
enum UT_VDBType
{
UT_VDB_INVALID,
UT_VDB_FLOAT,
UT_VDB_DOUBLE,
UT_VDB_INT32,
UT_VDB_INT64,
UT_VDB_BOOL,
UT_VDB_VEC3F,
UT_VDB_VEC3D,
UT_VDB_VEC3I,
UT_VDB_POINTINDEX,
UT_VDB_POINTDATA,
};
#include <openvdb/openvdb.h>
#include <openvdb/tools/PointIndexGrid.h>
#include <openvdb/points/PointDataGrid.h>
#include <UT/UT_Assert.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Matrix2.h>
#include <SYS/SYS_Math.h>
/// Calls openvdb::initialize()
inline void UTvdbInitialize() { openvdb::initialize(); }
/// Find the UT_VDBType from a grid
inline UT_VDBType
UTvdbGetGridType(const openvdb::GridBase &grid)
{
using namespace openvdb;
using namespace openvdb::tools;
using namespace openvdb::points;
if (grid.isType<FloatGrid>())
return UT_VDB_FLOAT;
if (grid.isType<DoubleGrid>())
return UT_VDB_DOUBLE;
if (grid.isType<Int32Grid>())
return UT_VDB_INT32;
if (grid.isType<Int64Grid>())
return UT_VDB_INT64;
if (grid.isType<BoolGrid>())
return UT_VDB_BOOL;
if (grid.isType<Vec3fGrid>())
return UT_VDB_VEC3F;
if (grid.isType<Vec3dGrid>())
return UT_VDB_VEC3D;
if (grid.isType<Vec3IGrid>())
return UT_VDB_VEC3I;
if (grid.isType<Vec3IGrid>())
return UT_VDB_VEC3I;
if (grid.isType<PointIndexGrid>())
return UT_VDB_POINTINDEX;
if (grid.isType<PointDataGrid>())
return UT_VDB_POINTDATA;
return UT_VDB_INVALID;
}
/// Return the string representation of a grid's underlying value type
inline const char *
UTvdbGetGridTypeString(const openvdb::GridBase &grid)
{
switch(UTvdbGetGridType(grid))
{
case UT_VDB_FLOAT:
return "float";
case UT_VDB_DOUBLE:
return "double";
case UT_VDB_INT32:
return "int32";
case UT_VDB_INT64:
return "int64";
case UT_VDB_BOOL:
return "bool";
case UT_VDB_VEC3F:
return "Vec3f";
case UT_VDB_VEC3D:
return "Vec3d";
case UT_VDB_VEC3I:
return "Vec3i";
case UT_VDB_POINTINDEX:
return "PointIndex";
case UT_VDB_POINTDATA:
return "PointData";
default:
return "invalid type";
}
}
/// Returns the tuple size of a grid given its value type.
inline int
UTvdbGetGridTupleSize(UT_VDBType type)
{
switch(type)
{
case UT_VDB_FLOAT:
case UT_VDB_DOUBLE:
case UT_VDB_INT32:
case UT_VDB_INT64:
case UT_VDB_BOOL:
return 1;
case UT_VDB_VEC3F:
case UT_VDB_VEC3D:
case UT_VDB_VEC3I:
return 3;
case UT_VDB_POINTINDEX:
case UT_VDB_POINTDATA:
case UT_VDB_INVALID:
default:
break;
}
return 0;
}
/// Returns the tuple size of a grid
inline int
UTvdbGetGridTupleSize(const openvdb::GridBase &grid)
{
return UTvdbGetGridTupleSize(UTvdbGetGridType(grid));
}
/// Special plusEqual class to avoid bool warnings
/// @{
template <typename T>
struct UT_VDBMath
{
static void plusEqual(T &lhs, const T &rhs)
{ lhs += rhs; }
};
template <>
struct UT_VDBMath<bool>
{
static void plusEqual(bool &lhs, const bool &rhs)
{ lhs = lhs | rhs; }
};
/// @}
/// Helpers for downcasting to a specific grid type
/// @{
template <typename GridType>
inline const GridType *
UTvdbGridCast(const openvdb::GridBase *grid)
{ return UTverify_cast<const GridType *>(grid); }
template <typename GridType>
inline GridType *
UTvdbGridCast(openvdb::GridBase *grid)
{ return UTverify_cast<GridType *>(grid); }
template <typename GridType>
inline const GridType &
UTvdbGridCast(const openvdb::GridBase &grid)
{ return *UTverify_cast<const GridType *>(&grid); }
template <typename GridType>
inline GridType &
UTvdbGridCast(openvdb::GridBase &grid)
{ return *UTverify_cast<GridType *>(&grid); }
template <typename GridType>
inline typename GridType::ConstPtr
UTvdbGridCast(openvdb::GridBase::ConstPtr grid)
{ return openvdb::gridConstPtrCast<GridType>(grid); }
template <typename GridType>
inline typename GridType::Ptr
UTvdbGridCast(openvdb::GridBase::Ptr grid)
{ return openvdb::gridPtrCast<GridType>(grid); }
/// @}
////////////////////////////////////////
namespace UT_VDBUtils {
// Helper function used internally by UTvdbProcessTypedGrid()
// to instantiate a templated functor for a specific grid type
// and then to call the functor with a grid of that type
template<typename GridType, typename OpType, typename GridBaseType>
inline void
callTypedGrid(GridBaseType &grid, OpType& op)
{
op.template operator()<GridType>(UTvdbGridCast<GridType>(grid));
}
} // namespace UT_VDBUtils
////////////////////////////////////////
/// @brief Utility function that, given a generic grid pointer,
/// calls a functor on the fully-resolved grid
///
/// @par Example:
/// @code
/// using openvdb::Coord;
/// using openvdb::CoordBBox;
///
/// struct FillOp {
/// const CoordBBox bbox;
///
/// FillOp(const CoordBBox& b): bbox(b) {}
///
/// template<typename GridT>
/// void operator()(GridT& grid) const {
/// using ValueT = typename GridT::ValueType;
/// grid.fill(bbox, ValueT(1));
/// }
/// };
///
/// GU_PrimVDB* vdb = ...;
/// vdb->makeGridUnique();
/// CoordBBox bbox(Coord(0,0,0), Coord(10,10,10));
/// UTvdbProcessTypedGrid(vdb->getStorageType(), vdb->getGrid(), FillOp(bbox));
/// @endcode
///
/// @return @c false if the grid type is unknown or unhandled.
/// @{
#define UT_VDB_DECL_PROCESS_TYPED_GRID(GRID_BASE_T) \
template<typename OpType> \
inline bool \
UTvdbProcessTypedGrid(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
{ \
using namespace openvdb; \
using namespace UT_VDBUtils; \
switch (grid_type) \
{ \
case UT_VDB_FLOAT: callTypedGrid<FloatGrid>(grid, op); break; \
case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \
case UT_VDB_INT32: callTypedGrid<Int32Grid>(grid, op); break; \
case UT_VDB_INT64: callTypedGrid<Int64Grid>(grid, op); break; \
case UT_VDB_VEC3F: callTypedGrid<Vec3SGrid>(grid, op); break; \
case UT_VDB_VEC3D: callTypedGrid<Vec3DGrid>(grid, op); break; \
case UT_VDB_VEC3I: callTypedGrid<Vec3IGrid>(grid, op); break; \
default: return false; \
} \
return true; \
} \
template<typename OpType> \
inline bool \
UTvdbProcessTypedGridTopology(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
{ \
using namespace openvdb; \
using namespace UT_VDBUtils; \
switch (grid_type) \
{ \
case UT_VDB_FLOAT: callTypedGrid<FloatGrid>(grid, op); break; \
case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \
case UT_VDB_INT32: callTypedGrid<Int32Grid>(grid, op); break; \
case UT_VDB_INT64: callTypedGrid<Int64Grid>(grid, op); break; \
case UT_VDB_VEC3F: callTypedGrid<Vec3SGrid>(grid, op); break; \
case UT_VDB_VEC3D: callTypedGrid<Vec3DGrid>(grid, op); break; \
case UT_VDB_VEC3I: callTypedGrid<Vec3IGrid>(grid, op); break; \
case UT_VDB_BOOL: callTypedGrid<BoolGrid>(grid, op); break; \
default: return false; \
} \
return true; \
} \
template<typename OpType> \
inline bool \
UTvdbProcessTypedGridVec3(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
{ \
using namespace openvdb; \
using namespace UT_VDBUtils; \
switch (grid_type) \
{ \
case UT_VDB_VEC3F: callTypedGrid<Vec3SGrid>(grid, op); break; \
case UT_VDB_VEC3D: callTypedGrid<Vec3DGrid>(grid, op); break; \
case UT_VDB_VEC3I: callTypedGrid<Vec3IGrid>(grid, op); break; \
default: return false; \
} \
return true; \
} \
template<typename OpType> \
inline bool \
UTvdbProcessTypedGridScalar(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
{ \
using namespace openvdb; \
using namespace UT_VDBUtils; \
switch (grid_type) \
{ \
case UT_VDB_FLOAT: callTypedGrid<FloatGrid>(grid, op); break; \
case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \
case UT_VDB_INT32: callTypedGrid<Int32Grid>(grid, op); break; \
case UT_VDB_INT64: callTypedGrid<Int64Grid>(grid, op); break; \
default: return false; \
} \
return true; \
} \
template<typename OpType> \
inline bool \
UTvdbProcessTypedGridReal(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
{ \
using namespace openvdb; \
using namespace UT_VDBUtils; \
switch (grid_type) \
{ \
case UT_VDB_FLOAT: callTypedGrid<FloatGrid>(grid, op); break; \
case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \
default: return false; \
} \
return true; \
} \
template<typename OpType> \
inline bool \
UTvdbProcessTypedGridPoint(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
{ \
using namespace openvdb; \
using namespace openvdb::tools; \
using namespace openvdb::points; \
using namespace UT_VDBUtils; \
switch (grid_type) \
{ \
case UT_VDB_POINTINDEX: callTypedGrid<PointIndexGrid>(grid, op); break; \
case UT_VDB_POINTDATA: callTypedGrid<PointDataGrid>(grid, op); break; \
default: return false; \
} \
return true; \
} \
/**/
UT_VDB_DECL_PROCESS_TYPED_GRID(const openvdb::GridBase &)
UT_VDB_DECL_PROCESS_TYPED_GRID(const openvdb::GridBase *)
UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase::ConstPtr)
UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase &)
UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase *)
UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase::Ptr)
/// @}
// Helper macro for UTvdbCall* macros, do not outside of this file!
#define UT_VDB_CALL(GRIDT, RETURN, FNAME, GRIDBASE, ...) \
{ \
RETURN FNAME <GRIDT> (UTvdbGridCast<GRIDT>(GRIDBASE), __VA_ARGS__ ); \
} \
/**/
//@{
/// Macro to invoke the correct type of grid.
/// Use like:
/// @code
/// UTvdbCallScalarType(grid_type, myfunction, grid, parms)
/// @endcode
/// to invoke
/// @code
/// template <typename GridType>
/// static void
/// myfunction(const GridType &grid, parms)
/// { }
/// @endcode
#define UTvdbCallRealType(TYPE, FNAME, GRIDBASE, ...) \
if (TYPE == UT_VDB_FLOAT) \
UT_VDB_CALL(openvdb::FloatGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_DOUBLE) \
UT_VDB_CALL(openvdb::DoubleGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbCallScalarType(TYPE, FNAME, GRIDBASE, ...) \
UTvdbCallRealType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
else if (TYPE == UT_VDB_INT32) \
UT_VDB_CALL(openvdb::Int32Grid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_INT64) \
UT_VDB_CALL(openvdb::Int64Grid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbCallVec3Type(TYPE, FNAME, GRIDBASE, ...) \
if (TYPE == UT_VDB_VEC3F) \
UT_VDB_CALL(openvdb::Vec3fGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_VEC3D) \
UT_VDB_CALL(openvdb::Vec3dGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_VEC3I) \
UT_VDB_CALL(openvdb::Vec3IGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbCallPointType(TYPE, FNAME, GRIDBASE, ...) \
if (TYPE == UT_VDB_POINTINDEX) \
UT_VDB_CALL(openvdb::tools::PointIndexGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_POINTDATA) \
UT_VDB_CALL(openvdb::points::PointDataGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbCallBoolType(TYPE, FNAME, GRIDBASE, ...) \
if (TYPE == UT_VDB_BOOL) \
UT_VDB_CALL(openvdb::BoolGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbCallAllType(TYPE, FNAME, GRIDBASE, ...) \
UTvdbCallScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
else UTvdbCallVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__); \
/**/
#define UTvdbCallAllTopology(TYPE, FNAME, GRIDBASE, ...) \
UTvdbCallScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
else UTvdbCallVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
else UTvdbCallBoolType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
/**/
//@}
//@{
/// Macro to invoke the correct type of grid.
/// Use like:
/// @code
/// UTvdbReturnScalarType(grid_type, myfunction, grid, parms)
/// @endcode
/// to invoke
/// @code
/// return myfunction(grid, parms);
/// @endcode
/// via:
/// @code
/// template <typename GridType>
/// static RESULT
/// myfunction(const GridType &grid, parms)
/// { }
/// @endcode
#define UTvdbReturnRealType(TYPE, FNAME, GRIDBASE, ...) \
if (TYPE == UT_VDB_FLOAT) \
UT_VDB_CALL(openvdb::FloatGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_DOUBLE) \
UT_VDB_CALL(openvdb::DoubleGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbReturnScalarType(TYPE, FNAME, GRIDBASE, ...) \
UTvdbReturnRealType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
else if (TYPE == UT_VDB_INT32) \
UT_VDB_CALL(openvdb::Int32Grid,return,FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_INT64) \
UT_VDB_CALL(openvdb::Int64Grid,return,FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbReturnVec3Type(TYPE, FNAME, GRIDBASE, ...) \
if (TYPE == UT_VDB_VEC3F) \
UT_VDB_CALL(openvdb::Vec3fGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_VEC3D) \
UT_VDB_CALL(openvdb::Vec3dGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_VEC3I) \
UT_VDB_CALL(openvdb::Vec3IGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbReturnPointType(TYPE, FNAME, GRIDBASE, ...) \
if (TYPE == UT_VDB_POINTINDEX) \
UT_VDB_CALL(openvdb::tools::PointIndexGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
else if (TYPE == UT_VDB_POINTDATA) \
UT_VDB_CALL(openvdb::points::PointDataGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbReturnBoolType(TYPE, FNAME, GRIDBASE, ...) \
if (TYPE == UT_VDB_BOOL) \
UT_VDB_CALL(openvdb::BoolGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
/**/
#define UTvdbReturnAllType(TYPE, FNAME, GRIDBASE, ...) \
UTvdbReturnScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
else UTvdbReturnVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__); \
/**/
#define UTvdbReturnAllTopology(TYPE, FNAME, GRIDBASE, ...) \
UTvdbReturnScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
else UTvdbReturnVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
else UTvdbReturnBoolType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
/**/
//@}
////////////////////////////////////////
/// Matrix conversion from openvdb to UT
// @{
template <typename S>
UT_Matrix4T<S>
UTvdbConvert(const openvdb::math::Mat4<S> &src)
{
return UT_Matrix4T<S>(src(0,0), src(0,1), src(0,2), src(0,3),
src(1,0), src(1,1), src(1,2), src(1,3),
src(2,0), src(2,1), src(2,2), src(2,3),
src(3,0), src(3,1), src(3,2), src(3,3));
}
template <typename S>
UT_Matrix3T<S>
UTvdbConvert(const openvdb::math::Mat3<S> &src)
{
return UT_Matrix3T<S>(src(0,0), src(0,1), src(0,2),
src(1,0), src(1,1), src(1,2),
src(2,0), src(2,1), src(2,2));
}
template <typename S>
UT_Matrix2T<S>
UTvdbConvert(const openvdb::math::Mat2<S> &src)
{
return UT_Matrix2T<S>(src(0,0), src(0,1),
src(1,0), src(1,1));
}
// @}
/// Matrix conversion from UT to openvdb
// @{
template <typename S>
openvdb::math::Mat4<S>
UTvdbConvert(const UT_Matrix4T<S> &src)
{
return openvdb::math::Mat4<S>(src(0,0), src(0,1), src(0,2), src(0,3),
src(1,0), src(1,1), src(1,2), src(1,3),
src(2,0), src(2,1), src(2,2), src(2,3),
src(3,0), src(3,1), src(3,2), src(3,3));
}
template <typename S>
openvdb::math::Mat3<S>
UTvdbConvert(const UT_Matrix3T<S> &src)
{
return openvdb::math::Mat3<S>(src(0,0), src(0,1), src(0,2),
src(1,0), src(1,1), src(1,2),
src(2,0), src(2,1), src(2,2));
}
template <typename S>
openvdb::math::Mat2<S>
UTvdbConvert(const UT_Matrix2T<S> &src)
{
return openvdb::math::Mat2<S>(src(0,0), src(0,1),
src(1,0), src(1,1));
}
// @}
/// Vector conversion from openvdb to UT
// @{
template <typename S>
UT_Vector4T<S>
UTvdbConvert(const openvdb::math::Vec4<S> &src)
{
return UT_Vector4T<S>(src.asPointer());
}
template <typename S>
UT_Vector3T<S>
UTvdbConvert(const openvdb::math::Vec3<S> &src)
{
return UT_Vector3T<S>(src.asPointer());
}
template <typename S>
UT_Vector2T<S>
UTvdbConvert(const openvdb::math::Vec2<S> &src)
{
return UT_Vector2T<S>(src.asPointer());
}
// @}
/// Vector conversion from UT to openvdb
// @{
template <typename S>
openvdb::math::Vec4<S>
UTvdbConvert(const UT_Vector4T<S> &src)
{
return openvdb::math::Vec4<S>(src.data());
}
template <typename S>
openvdb::math::Vec3<S>
UTvdbConvert(const UT_Vector3T<S> &src)
{
return openvdb::math::Vec3<S>(src.data());
}
template <typename S>
openvdb::math::Vec2<S>
UTvdbConvert(const UT_Vector2T<S> &src)
{
return openvdb::math::Vec2<S>(src.data());
}
// @}
/// Bounding box conversion from openvdb to UT
inline UT_BoundingBoxD
UTvdbConvert(const openvdb::CoordBBox &bbox)
{
return UT_BoundingBoxD(UTvdbConvert(bbox.getStart().asVec3d()),
UTvdbConvert(bbox.getEnd().asVec3d()));
}
/// Bounding box conversion from openvdb to UT
inline openvdb::math::CoordBBox
UTvdbConvert(const UT_BoundingBoxI &bbox)
{
return openvdb::math::CoordBBox(
openvdb::math::Coord(bbox.xmin(), bbox.ymin(), bbox.zmin()),
openvdb::math::Coord(bbox.xmax(), bbox.ymax(), bbox.zmax()));
}
/// Utility method to construct a Transform that lines up with a
/// cell-centered Houdini volume with specified origin and voxel size.
inline openvdb::math::Transform::Ptr
UTvdbCreateTransform(const UT_Vector3 &orig, const UT_Vector3 &voxsize)
{
// Transforms only valid for square voxels.
UT_ASSERT(SYSalmostEqual(voxsize.minComponent(), voxsize.maxComponent()));
fpreal vs = voxsize.maxComponent();
openvdb::math::Transform::Ptr xform =
openvdb::math::Transform::createLinearTransform(vs);
// Ensure voxel centers line up.
xform->postTranslate(UTvdbConvert(orig) + vs / 2);
return xform;
}
template <typename T>
inline openvdb::math::Vec4<T> SYSabs(const openvdb::math::Vec4<T> &v1)
{ return openvdb::math::Vec4<T>( SYSabs(v1[0]),
SYSabs(v1[1]),
SYSabs(v1[2]),
SYSabs(v1[3])
);
}
template <typename T>
inline openvdb::math::Vec3<T> SYSabs(const openvdb::math::Vec3<T> &v1)
{ return openvdb::math::Vec3<T>( SYSabs(v1[0]),
SYSabs(v1[1]),
SYSabs(v1[2])
);
}
template <typename T>
inline openvdb::math::Vec2<T> SYSabs(const openvdb::math::Vec2<T> &v1)
{ return openvdb::math::Vec2<T>( SYSabs(v1[0]),
SYSabs(v1[1])
);
}
template <typename T>
inline openvdb::math::Vec4<T> SYSmin(const openvdb::math::Vec4<T> &v1, const openvdb::math::Vec4<T> &v2)
{ return openvdb::math::Vec4<T>( SYSmin(v1[0], v2[0]),
SYSmin(v1[1], v2[1]),
SYSmin(v1[2], v2[2]),
SYSmin(v1[3], v2[3])
);
}
template <typename T>
inline openvdb::math::Vec4<T> SYSmax(const openvdb::math::Vec4<T> &v1, const openvdb::math::Vec4<T> &v2)
{ return openvdb::math::Vec4<T>( SYSmax(v1[0], v2[0]),
SYSmax(v1[1], v2[1]),
SYSmax(v1[2], v2[2]),
SYSmax(v1[3], v2[3])
);
}
template <typename T>
inline openvdb::math::Vec4<T> SYSmin(const openvdb::math::Vec4<T> &v1, const openvdb::math::Vec4<T> &v2, const openvdb::math::Vec4<T> &v3)
{ return openvdb::math::Vec4<T>( SYSmin(v1[0], v2[0], v3[0]),
SYSmin(v1[1], v2[1], v3[1]),
SYSmin(v1[2], v2[2], v3[2]),
SYSmin(v1[3], v2[3], v3[3])
);
}
template <typename T>
inline openvdb::math::Vec4<T> SYSmax(const openvdb::math::Vec4<T> &v1, const openvdb::math::Vec4<T> &v2, const openvdb::math::Vec4<T> &v3)
{ return openvdb::math::Vec4<T>( SYSmax(v1[0], v2[0], v3[0]),
SYSmax(v1[1], v2[1], v3[1]),
SYSmax(v1[2], v2[2], v3[2]),
SYSmax(v1[3], v2[3], v3[3])
);
}
template <typename T>
inline openvdb::math::Vec3<T> SYSmin(const openvdb::math::Vec3<T> &v1, const openvdb::math::Vec3<T> &v2)
{ return openvdb::math::Vec3<T>( SYSmin(v1[0], v2[0]),
SYSmin(v1[1], v2[1]),
SYSmin(v1[2], v2[2])
);
}
template <typename T>
inline openvdb::math::Vec3<T> SYSmax(const openvdb::math::Vec3<T> &v1, const openvdb::math::Vec3<T> &v2)
{ return openvdb::math::Vec3<T>( SYSmax(v1[0], v2[0]),
SYSmax(v1[1], v2[1]),
SYSmax(v1[2], v2[2])
);
}
template <typename T>
inline openvdb::math::Vec3<T> SYSmin(const openvdb::math::Vec3<T> &v1, const openvdb::math::Vec3<T> &v2, const openvdb::math::Vec3<T> &v3)
{ return openvdb::math::Vec3<T>( SYSmin(v1[0], v2[0], v3[0]),
SYSmin(v1[1], v2[1], v3[1]),
SYSmin(v1[2], v2[2], v3[2])
);
}
template <typename T>
inline openvdb::math::Vec3<T> SYSmax(const openvdb::math::Vec3<T> &v1, const openvdb::math::Vec3<T> &v2, const openvdb::math::Vec3<T> &v3)
{ return openvdb::math::Vec3<T>( SYSmax(v1[0], v2[0], v3[0]),
SYSmax(v1[1], v2[1], v3[1]),
SYSmax(v1[2], v2[2], v3[2])
);
}
template <typename T>
inline openvdb::math::Vec2<T> SYSmin(const openvdb::math::Vec2<T> &v1, const openvdb::math::Vec2<T> &v2)
{ return openvdb::math::Vec2<T>( SYSmin(v1[0], v2[0]),
SYSmin(v1[1], v2[1])
);
}
template <typename T>
inline openvdb::math::Vec2<T> SYSmax(const openvdb::math::Vec2<T> &v1, const openvdb::math::Vec2<T> &v2)
{ return openvdb::math::Vec2<T>( SYSmax(v1[0], v2[0]),
SYSmax(v1[1], v2[1])
);
}
template <typename T>
inline openvdb::math::Vec2<T> SYSmin(const openvdb::math::Vec2<T> &v1, const openvdb::math::Vec2<T> &v2, const openvdb::math::Vec2<T> &v3)
{ return openvdb::math::Vec2<T>( SYSmin(v1[0], v2[0], v3[0]),
SYSmin(v1[1], v2[1], v3[1])
);
}
template <typename T>
inline openvdb::math::Vec2<T> SYSmax(const openvdb::math::Vec2<T> &v1, const openvdb::math::Vec2<T> &v2, const openvdb::math::Vec2<T> &v3)
{ return openvdb::math::Vec2<T>( SYSmax(v1[0], v2[0], v3[0]),
SYSmax(v1[1], v2[1], v3[1])
);
}
#endif // __HDK_UT_VDBUtils__
#endif // SESI_OPENVDB || SESI_OPENVDB_PRIM
| 24,374 | C | 32.118206 | 140 | 0.587552 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/GU_PrimVDB.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/*
* Copyright (c) Side Effects Software Inc.
*
* Produced by:
* Side Effects Software Inc
* 477 Richmond Street West
* Toronto, Ontario
* Canada M5V 3E7
* 416-504-9876
*
* NAME: GU_PrimVDB.C ( GU Library, C++)
*
* COMMENTS: Definitions for utility functions of vdb.
*/
#include <UT/UT_Version.h>
#if defined(SESI_OPENVDB) || defined(SESI_OPENVDB_PRIM)
#include "GU_PrimVDB.h"
#include "GT_GEOPrimCollectVDB.h"
#include <GU/GU_ConvertParms.h>
#include <GU/GU_PrimPoly.h>
#include <GU/GU_PrimPolySoup.h>
#include <GU/GU_PrimVolume.h>
#include <GU/GU_RayIntersect.h>
#include <GEO/GEO_AttributeHandleList.h>
#include <GEO/GEO_Closure.h>
#include <GEO/GEO_WorkVertexBuffer.h>
#include <GA/GA_AIFTuple.h>
#include <GA/GA_AttributeFilter.h>
#include <GA/GA_ElementWrangler.h>
#include <GA/GA_Handle.h>
#include <GA/GA_PageHandle.h>
#include <GA/GA_PageIterator.h>
#include <GA/GA_SplittableRange.h>
#include <UT/UT_Debug.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_Lock.h>
#include <UT/UT_MemoryCounter.h>
#include <UT/UT_ParallelUtil.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Singleton.h>
#include <UT/UT_StopWatch.h>
#include <SYS/SYS_Inline.h>
#include <SYS/SYS_Types.h>
#include <SYS/SYS_TypeTraits.h>
#include <openvdb/tools/VolumeToMesh.h>
#include <hboost/function.hpp>
#include <openvdb/tools/SignedFloodFill.h>
#include <algorithm>
#include <vector>
#include <stddef.h>
#define TIMING_DEF \
UT_StopWatch timer; \
if (verbose) timer.start();
#define TIMING_LOG(msg) \
if (verbose) { \
printf(msg ": %f ms\n", 1000*timer.stop()); \
fflush(stdout); \
timer.start(); \
}
GA_PrimitiveDefinition *GU_PrimVDB::theDefinition = 0;
GU_PrimVDB*
GU_PrimVDB::build(GU_Detail *gdp, bool append_points)
{
#ifndef SESI_OPENVDB
// This is only necessary as a stop gap measure until we have the
// registration code split out properly.
if (!GU_PrimVDB::theDefinition)
GU_PrimVDB::registerMyself(&GUgetFactory());
GU_PrimVDB* primvdb = (GU_PrimVDB *)gdp->appendPrimitive(GU_PrimVDB::theTypeId());
#else
GU_PrimVDB* primvdb = UTverify_cast<GU_PrimVDB *>(gdp->appendPrimitive(GEO_PRIMVDB));
primvdb->assignVertex(gdp->appendVertex(), true);
#endif
if (append_points) {
GEO_Primitive *prim = primvdb;
const GA_Size npts = primvdb->getVertexCount();
GA_Offset startptoff = gdp->appendPointBlock(npts);
for (GA_Size i = 0; i < npts; i++) {
prim->setPointOffset(i, startptoff+i);
}
}
return primvdb;
}
GU_PrimVDB*
GU_PrimVDB::buildFromGridAdapter(GU_Detail& gdp, void* gridPtr,
const GEO_PrimVDB* src, const char* name)
{
// gridPtr is assumed to point to an openvdb::vX_Y_Z::GridBase::Ptr, for
// some version X.Y.Z of OpenVDB that may be newer than the one with which
// libHoudiniGEO.so was built. This is safe provided that GridBase and
// its member objects are ABI-compatible between the two OpenVDB versions.
openvdb::GridBase::Ptr grid =
*static_cast<openvdb::GridBase::Ptr*>(gridPtr);
if (!grid)
return nullptr;
GU_PrimVDB* vdb = GU_PrimVDB::build(&gdp);
if (vdb != nullptr) {
if (src != nullptr) {
// Copy the source primitive's attributes to this primitive,
// then transfer those attributes to this grid's metadata.
vdb->copyAttributesAndGroups(*src, /*copyGroups=*/true);
GU_PrimVDB::createMetadataFromGridAttrs(*grid, *vdb, gdp);
// Copy the source's visualization options.
GEO_VolumeOptions visopt = src->getVisOptions();
vdb->setVisualization(visopt.myMode, visopt.myIso, visopt.myDensity,
visopt.myLod);
}
// Ensure that certain metadata exists (grid name, grid class, etc.).
if (name != nullptr) grid->setName(name);
grid->removeMeta("value_type");
grid->insertMeta("value_type", openvdb::StringMetadata(grid->valueType()));
// For each of the following, force any existing metadata's value to be
// one of the supported values. Note the careful 3 statement sequences
// so that it works with type mismatches.
openvdb::GridClass grid_class = grid->getGridClass();
grid->removeMeta(openvdb::GridBase::META_GRID_CLASS);
grid->setGridClass(grid_class);
openvdb::VecType vec_type = grid->getVectorType();
grid->removeMeta(openvdb::GridBase::META_VECTOR_TYPE);
grid->setVectorType(vec_type);
bool is_in_world_space = grid->isInWorldSpace();
grid->removeMeta(openvdb::GridBase::META_IS_LOCAL_SPACE);
grid->setIsInWorldSpace(is_in_world_space);
bool save_as_half = grid->saveFloatAsHalf();
grid->removeMeta(openvdb::GridBase::META_SAVE_HALF_FLOAT);
grid->setSaveFloatAsHalf(save_as_half);
// Transfer the grid's metadata to primitive attributes.
GU_PrimVDB::createGridAttrsFromMetadata(*vdb, *grid, gdp);
vdb->setGrid(*grid);
// If we had no source, have to set options to reasonable
// defaults.
if (src == nullptr)
{
if (grid->getGridClass() == openvdb::GRID_LEVEL_SET)
{
vdb->setVisualization(GEO_VOLUMEVIS_ISO,
vdb->getVisIso(), vdb->getVisDensity(),
vdb->getVisLod());
}
else
{
vdb->setVisualization(GEO_VOLUMEVIS_SMOKE,
vdb->getVisIso(), vdb->getVisDensity(),
vdb->getVisLod());
}
}
}
return vdb;
}
int64
GU_PrimVDB::getMemoryUsage() const
{
int64 mem = sizeof(*this);
mem += GEO_PrimVDB::getBaseMemoryUsage();
return mem;
}
void
GU_PrimVDB::countMemory(UT_MemoryCounter &counter) const
{
counter.countUnshared(sizeof(*this));
GEO_PrimVDB::countBaseMemory(counter);
}
namespace // anonymous
{
class gu_VolumeMax
{
public:
gu_VolumeMax(
const UT_VoxelArrayReadHandleF &vox,
UT_AutoInterrupt &progress)
: myVox(vox)
, myProgress(progress)
, myMax(std::numeric_limits<float>::min())
{
}
gu_VolumeMax(const gu_VolumeMax &other, UT_Split)
: myVox(other.myVox)
, myProgress(other.myProgress)
// NOTE: other.myMax could be half written-to while this
// constructor is being called, so don't use its
// value here. Initialize myMax as in the main
// constructor.
, myMax(std::numeric_limits<float>::min())
{
}
void operator()(const UT_BlockedRange<int> &range)
{
uint8 bcnt = 0;
for (int i = range.begin(); i != range.end(); ++i) {
float min_value;
float max_value;
myVox->getLinearTile(i)->findMinMax(min_value, max_value);
myMax = SYSmax(myMax, max_value);
if (!bcnt++ && myProgress.wasInterrupted())
break;
}
}
void join(const gu_VolumeMax &other)
{
myMax = std::max(myMax, other.myMax);
}
float findMax()
{
UTparallelReduce(UT_BlockedRange<int>(0, myVox->numTiles()), *this);
return myMax;
}
private:
const UT_VoxelArrayReadHandleF & myVox;
UT_AutoInterrupt & myProgress;
float myMax;
};
class gu_ConvertToVDB
{
public:
gu_ConvertToVDB(
const UT_VoxelArrayReadHandleF &vox,
float background,
UT_AutoInterrupt &progress,
bool activateInsideSDF
)
: myVox(vox)
, myGrid(openvdb::FloatGrid::create(background))
, myProgress(progress)
, myActivateInsideSDF(activateInsideSDF)
{
}
gu_ConvertToVDB(const gu_ConvertToVDB &other, UT_Split)
: myVox(other.myVox)
, myGrid(openvdb::FloatGrid::create(other.myGrid->background()))
, myProgress(other.myProgress)
, myActivateInsideSDF(other.myActivateInsideSDF)
{
}
openvdb::FloatGrid::Ptr run()
{
using namespace openvdb;
UTparallelReduce(UT_BlockedRange<int>(0, myVox->numTiles()), *this);
// Check if the VDB grid can be made empty
openvdb::Coord dim = myGrid->evalActiveVoxelDim();
if (dim[0] == 1 && dim[1] == 1 && dim[2] == 1) {
openvdb::Coord ijk = myGrid->evalActiveVoxelBoundingBox().min();
float value = myGrid->tree().getValue(ijk);
if (openvdb::math::isApproxEqual<float>(value, myGrid->background())) {
myGrid->clear();
}
}
return myGrid;
}
void operator()(const UT_BlockedRange<int> &range)
{
using namespace openvdb;
FloatGrid & grid = *myGrid.get();
const float background = grid.background();
const UT_VoxelArrayF & vox = *myVox;
uint8 bcnt = 0;
FloatGrid::Accessor acc = grid.getAccessor();
for (int i = range.begin(); i != range.end(); ++i) {
const UT_VoxelTile<float> & tile = *vox.getLinearTile(i);
Coord org;
Coord dim;
vox.linearTileToXYZ(i, org[0], org[1], org[2]);
org[0] *= TILESIZE; org[1] *= TILESIZE; org[2] *= TILESIZE;
dim[0] = tile.xres(); dim[1] = tile.yres(); dim[2] = tile.zres();
if (tile.isConstant()) {
CoordBBox bbox(org, org + dim.offsetBy(-1));
float value = tile(0, 0, 0);
if (!SYSisEqual(value, background) &&
(myActivateInsideSDF || !SYSisEqual(value, -background))) {
grid.fill(bbox, value);
}
} else {
openvdb::Coord ijk;
for (ijk[2] = 0; ijk[2] < dim[2]; ++ijk[2]) {
for (ijk[1] = 0; ijk[1] < dim[1]; ++ijk[1]) {
for (ijk[0] = 0; ijk[0] < dim[0]; ++ijk[0]) {
float value = tile(ijk[0], ijk[1], ijk[2]);
if (!SYSisEqual(value, background) &&
(myActivateInsideSDF || !SYSisEqual(value, -background))) {
Coord pos = ijk.offsetBy(org[0], org[1], org[2]);
acc.setValue(pos, value);
}
}
}
}
}
if (!bcnt++ && myProgress.wasInterrupted())
break;
}
}
void join(const gu_ConvertToVDB &other)
{
if (myProgress.wasInterrupted())
return;
UT_IF_ASSERT(int old_count = myGrid->activeVoxelCount();)
UT_IF_ASSERT(int other_count = other.myGrid->activeVoxelCount();)
myGrid->merge(*other.myGrid);
UT_ASSERT(myGrid->activeVoxelCount() == old_count + other_count);
}
private:
const UT_VoxelArrayReadHandleF & myVox;
openvdb::FloatGrid::Ptr myGrid;
UT_AutoInterrupt & myProgress;
bool myActivateInsideSDF;
}; // class gu_ConvertToVDB
} // namespace anonymous
GU_PrimVDB *
GU_PrimVDB::buildFromPrimVolume(
GU_Detail &geo,
const GEO_PrimVolume &vol,
const char *name,
const bool flood_sdf,
const bool prune,
const float tolerance,
const bool activate_inside_sdf)
{
using namespace openvdb;
UT_AutoInterrupt progress("Converting to VDB");
UT_VoxelArrayReadHandleF vox = vol.getVoxelHandle();
float background;
if (vol.isSDF())
{
gu_VolumeMax max_op(vox, progress);
background = max_op.findMax();
if (progress.wasInterrupted())
return nullptr;
}
else
{
if (vol.getBorder() == GEO_VOLUMEBORDER_CONSTANT)
background = vol.getBorderValue();
else
background = 0.0;
}
// When flood-filling SDFs, the inactive interior voxels will be set to
// -background. In that case we can avoid activating all inside voxels
// that already have that value, maintaining the narrow band (if any) of the
// original native volume. For non-SDF we always activate interior voxels.
gu_ConvertToVDB converter(vox, background, progress,
activate_inside_sdf || !flood_sdf || !vol.isSDF());
FloatGrid::Ptr grid = converter.run();
if (progress.wasInterrupted())
return nullptr;
if (vol.isSDF())
grid->setGridClass(GridClass(GRID_LEVEL_SET));
else
grid->setGridClass(GridClass(GRID_FOG_VOLUME));
if (prune) {
grid->pruneGrid(tolerance);
}
if (flood_sdf && vol.isSDF()) {
// only call signed flood fill on SDFs
openvdb::tools::signedFloodFill(grid->tree());
}
GU_PrimVDB *prim_vdb = buildFromGrid(geo, grid, nullptr, name);
if (!prim_vdb)
return nullptr;
int rx, ry, rz;
vol.getRes(rx, ry, rz);
prim_vdb->setSpaceTransform(vol.getSpaceTransform(), UT_Vector3R(rx,ry,rz));
prim_vdb->setVisualization(
vol.getVisualization(), vol.getVisIso(), vol.getVisDensity(),
GEO_VOLUMEVISLOD_FULL);
return prim_vdb;
}
// Copy the exclusive bbox [start,end) from myVox into acc
static void
guCopyVoxelBBox(
const UT_VoxelArrayReadHandleF &vox,
openvdb::FloatGrid::Accessor &acc,
openvdb::Coord start, openvdb::Coord end)
{
openvdb::Coord c;
for (c[0] = start[0] ; c[0] < end[0]; c[0]++) {
for (c[1] = start[1] ; c[1] < end[1]; c[1]++) {
for (c[2] = start[2] ; c[2] < end[2]; c[2]++) {
float value = vox->getValue(c[0], c[1], c[2]);
acc.setValueOnly(c, value);
}
}
}
}
void
GU_PrimVDB::expandBorderFromPrimVolume(const GEO_PrimVolume &vol, int pad)
{
using namespace openvdb;
UT_AutoInterrupt progress("Add inactive VDB border");
const UT_VoxelArrayReadHandleF vox(vol.getVoxelHandle());
const Coord res(vox->getXRes(),
vox->getYRes(),
vox->getZRes());
GridBase & base = getGrid();
FloatGrid & grid = UTvdbGridCast<FloatGrid>(base);
FloatGrid::Accessor acc = grid.getAccessor();
// For simplicity, we overdraw the edges and corners
for (int axis = 0; axis < 3; axis++) {
if (progress.wasInterrupted())
return;
openvdb::Coord beg(-pad, -pad, -pad);
openvdb::Coord end = res.offsetBy(+pad);
beg[axis] = -pad;
end[axis] = 0;
guCopyVoxelBBox(vox, acc, beg, end);
beg[axis] = res[axis];
end[axis] = res[axis] + pad;
guCopyVoxelBBox(vox, acc, beg, end);
}
}
// The following code is for HDK only
#ifndef SESI_OPENVDB
// Static callback for our factory.
static GA_Primitive*
gu_newPrimVDB(GA_Detail &detail, GA_Offset offset,
const GA_PrimitiveDefinition &)
{
return new GU_PrimVDB(static_cast<GU_Detail *>(&detail), offset);
}
static GA_Primitive*
gaPrimitiveMergeConstructor(const GA_MergeMap &map,
GA_Detail &dest_detail,
GA_Offset dest_offset,
const GA_Primitive &src_prim)
{
return new GU_PrimVDB(map, dest_detail, dest_offset, static_cast<const GU_PrimVDB &>(src_prim));
}
static UT_Lock theInitPrimDefLock;
void
GU_PrimVDB::registerMyself(GA_PrimitiveFactory *factory)
{
// Ignore double registration
if (theDefinition) return;
UT_Lock::Scope lock(theInitPrimDefLock);
if (theDefinition) return;
#if defined(__ICC)
// Disable ICC "assignment to static variable" warning,
// since the assignment to theDefinition is mutex-protected.
__pragma(warning(disable:1711));
#endif
theDefinition = factory->registerDefinition("VDB",
gu_newPrimVDB, GA_FAMILY_NONE);
#if defined(__ICC)
__pragma(warning(default:1711));
#endif
if (!theDefinition) {
std::cerr << "WARNING: Unable to register custom GU_PrimVDB\n";
if (!factory->lookupDefinition("VDB")) {
std::cerr << "WARNING: failed to register GU_PrimVDB\n";
}
return;
}
theDefinition->setLabel("Sparse Volumes (VDBs)");
theDefinition->setHasLocalTransform(true);
theDefinition->setMergeConstructor(&gaPrimitiveMergeConstructor);
registerIntrinsics(*theDefinition);
// Register the GT tesselation too (now we know what type id we have)
openvdb_houdini::GT_GEOPrimCollectVDB::registerPrimitive(theDefinition->getId());
}
#endif
GEO_Primitive *
GU_PrimVDB::convertToNewPrim(
GEO_Detail &dst_geo,
GU_ConvertParms &parms,
fpreal adaptivity,
bool split_disjoint_volumes,
bool &success) const
{
GEO_Primitive * prim = nullptr;
const GA_PrimCompat::TypeMask parmType = parms.toType();
success = false;
if (parmType == GEO_PrimTypeCompat::GEOPRIMPOLY) {
prim = convertToPoly(dst_geo, parms, adaptivity,
/*polysoup*/false, success);
} else if (parmType == GEO_PrimTypeCompat::GEOPRIMPOLYSOUP) {
prim = convertToPoly(dst_geo, parms, adaptivity,
/*polysoup*/true, success);
} else if (parmType == GEO_PrimTypeCompat::GEOPRIMVOLUME) {
prim = convertToPrimVolume(dst_geo, parms, split_disjoint_volumes);
if (prim)
success = true;
}
return prim;
}
GEO_Primitive *
GU_PrimVDB::convertNew(GU_ConvertParms &parms)
{
bool success = false;
return convertToNewPrim(*getParent(), parms,
/*adaptivity*/0, /*sparse*/false, success);
}
static void
guCopyMesh(
GEO_Detail& detail,
openvdb::tools::VolumeToMesh& mesher,
bool buildpolysoup,
bool verbose)
{
TIMING_DEF;
const openvdb::tools::PointList& points = mesher.pointList();
openvdb::tools::PolygonPoolList& polygonPoolList = mesher.polygonPoolList();
// NOTE: Adaptive meshes consist of tringles and quads.
// Construct the points
GA_Size npoints = mesher.pointListSize();
GA_Offset startpt = detail.appendPointBlock(npoints);
SYS_STATIC_ASSERT(sizeof(openvdb::tools::PointList::element_type) == sizeof(UT_Vector3));
GA_RWHandleV3 pthandle(detail.getP());
pthandle.setBlock(startpt, npoints, (UT_Vector3 *)points.get());
TIMING_LOG("Copy Points");
// Construct the array of polygon point numbers
// NOTE: For quad meshes, the number of quads is about the number of points,
// so the number of vertices is about 4*npoints
GA_Size nquads = 0, ntris = 0;
for (size_t n = 0, N = mesher.polygonPoolListSize(); n < N; ++n) {
const openvdb::tools::PolygonPool& polygons = polygonPoolList[n];
nquads += polygons.numQuads();
ntris += polygons.numTriangles();
}
TIMING_LOG("Count Quads and Tris");
// Don't create anything if nothing to create
if (!ntris && !nquads)
return;
GA_Size nverts = nquads*4 + ntris*3;
UT_IntArray verts(nverts, nverts);
GA_Size iquad = 0;
GA_Size itri = nquads*4;
for (size_t n = 0, N = mesher.polygonPoolListSize(); n < N; ++n) {
const openvdb::tools::PolygonPool& polygons = polygonPoolList[n];
// Copy quads
for (size_t i = 0, I = polygons.numQuads(); i < I; ++i) {
const openvdb::Vec4I& quad = polygons.quad(i);
verts(iquad++) = quad[0];
verts(iquad++) = quad[1];
verts(iquad++) = quad[2];
verts(iquad++) = quad[3];
}
// Copy triangles (adaptive mesh)
for (size_t i = 0, I = polygons.numTriangles(); i < I; ++i) {
const openvdb::Vec3I& triangle = polygons.triangle(i);
verts(itri++) = triangle[0];
verts(itri++) = triangle[1];
verts(itri++) = triangle[2];
}
}
TIMING_LOG("Get Quad and Tri Verts");
GEO_PolyCounts sizelist;
if (nquads)
sizelist.append(4, nquads);
if (ntris)
sizelist.append(3, ntris);
if (buildpolysoup)
GU_PrimPolySoup::build(&detail, startpt, npoints, sizelist, verts.array());
else
GU_PrimPoly::buildBlock(&detail, startpt, npoints, sizelist, verts.array());
TIMING_LOG("Build Polys");
}
namespace {
class gu_VDBNormalsParallel
{
public:
gu_VDBNormalsParallel(GA_Attribute *p, GA_Attribute *n, const GU_PrimVDB &vdb)
: myP(p)
, myN(n)
, myVDB(vdb)
{}
void operator()(const GA_SplittableRange &r) const
{
UT_Interrupt *boss = UTgetInterrupt();
GA_ROPageHandleV3 positions(myP);
GA_RWPageHandleV3 normals(myN);
for (GA_PageIterator pit = r.beginPages(); !pit.atEnd(); ++pit)
{
if (boss->opInterrupt())
break;
const GA_Offset pagefirstoff = pit.getFirstOffsetInPage();
positions.setPage(pagefirstoff);
normals.setPage(pagefirstoff);
GA_Offset start;
GA_Offset end;
for (GA_Iterator it = pit.begin(); it.blockAdvance(start, end); )
{
myVDB.evalGradients(&normals.value(start), 1,
&positions.value(start), end - start,
/*normalize*/true);
}
}
}
private:
GA_Attribute *const myP;
GA_Attribute *const myN;
const GU_PrimVDB &myVDB;
};
}
GEO_Primitive *
GU_PrimVDB::convertToPoly(
GEO_Detail &dst_geo,
GU_ConvertParms &parms,
fpreal adaptivity,
bool polysoup,
bool &success) const
{
using namespace openvdb;
UT_AutoInterrupt progress("Convert VDB to Polygons");
GA_Detail::OffsetMarker marker(dst_geo);
bool verbose = false;
success = false;
try
{
tools::VolumeToMesh mesher(parms.myOffset, adaptivity);
UTvdbProcessTypedGridScalar(getStorageType(), getGrid(), mesher);
if (progress.wasInterrupted())
return nullptr;
guCopyMesh(dst_geo, mesher, polysoup, verbose);
if (progress.wasInterrupted())
return nullptr;
}
catch (std::exception& /*e*/)
{
return nullptr;
}
GA_Range pointrange(marker.pointRange());
GA_Range primitiverange(marker.primitiveRange());
GUconvertCopySingleVertexPrimAttribsAndGroups(
parms, *getParent(), getMapOffset(), dst_geo,
primitiverange, pointrange);
if (progress.wasInterrupted())
return nullptr;
// If there was already a point normal attribute, we should compute normals
// to avoid getting zero default values for the new polygons.
GA_RWAttributeRef normal_ref = dst_geo.findNormalAttribute(GA_ATTRIB_POINT);
if (normal_ref.isValid() && !pointrange.isEmpty())
{
UTparallelFor(GA_SplittableRange(pointrange),
gu_VDBNormalsParallel(dst_geo.getP(), normal_ref.getAttribute(), *this));
if (progress.wasInterrupted())
return nullptr;
}
// At this point, we have succeeded, marker.numPrimitives() might be 0 if
// we had an empty VDB.
success = true;
if (primitiverange.isEmpty())
return nullptr;
return dst_geo.getGEOPrimitive(marker.primitiveBegin());
}
namespace {
class gu_DestroyVDBPrimGuard
{
public:
gu_DestroyVDBPrimGuard(GU_PrimVDB &vdb)
: myVDB(vdb)
{
}
~gu_DestroyVDBPrimGuard()
{
myVDB.getDetail().destroyPrimitive(myVDB, /*and_points*/true);
}
private:
GU_PrimVDB &myVDB;
};
} // anonymous namespace
/*static*/ void
GU_PrimVDB::convertPrimVolumeToPolySoup(
GU_Detail &dst_geo,
const GEO_PrimVolume &src_vol)
{
using namespace openvdb;
UT_AutoInterrupt progress("Convert to Polygons");
GU_PrimVDB &vdb = *buildFromPrimVolume(
dst_geo, src_vol, nullptr,
/*flood*/false, /*prune*/true, /*tol*/0,
/*activate_inside*/true);
gu_DestroyVDBPrimGuard destroy_guard(vdb);
if (progress.wasInterrupted())
return;
try
{
BoolGrid::Ptr mask;
if (src_vol.getBorder() != GEO_VOLUMEBORDER_CONSTANT)
{
Coord res;
src_vol.getRes(res[0], res[1], res[2]);
CoordBBox bbox(Coord(0, 0, 0), res.offsetBy(-1)); // inclusive
if (bbox.hasVolume())
{
vdb.expandBorderFromPrimVolume(src_vol, 4);
if (progress.wasInterrupted())
return;
mask = BoolGrid::create(/*background*/false);
mask->setTransform(vdb.getGrid().transform().copy());
mask->fill(bbox, /*foreground*/true);
}
}
tools::VolumeToMesh mesher(src_vol.getVisIso());
mesher.setSurfaceMask(mask);
GEOvdbProcessTypedGridScalar(vdb, mesher);
if (progress.wasInterrupted())
return;
guCopyMesh(dst_geo, mesher, /*polysoup*/true, /*verbose*/false);
if (progress.wasInterrupted())
return;
}
catch (std::exception& /*e*/)
{
}
}
namespace // anonymous
{
#define SCALAR_RET(T) \
typename SYS_EnableIf< SYS_IsArithmetic<T>::value, T >::type
#define NON_SCALAR_RET(T) \
typename SYS_DisableIf< SYS_IsArithmetic<T>::value, T >::type
/// Houdini Volume wrapper to abstract multiple volumes with a consistent API.
template <int TUPLE_SIZE>
class VoxelArrayVolume
{
public:
static const int TupleSize = TUPLE_SIZE;
VoxelArrayVolume(GU_Detail& geo): mGeo(geo)
{
for (int i = 0; i < TUPLE_SIZE; i++) {
mVol[i] = (GU_PrimVolume *)GU_PrimVolume::build(&mGeo);
mHandle[i] = mVol[i]->getVoxelWriteHandle();
}
}
void
setSize(const openvdb::Coord &dim)
{
for (int i = 0; i < TUPLE_SIZE; i++) {
mHandle[i]->size(dim[0], dim[1], dim[2]);
}
}
template <class ValueT>
void
setVolumeOptions(
bool is_sdf, const ValueT& background,
GEO_VolumeVis vismode, fpreal iso, fpreal density,
SCALAR_RET(ValueT)* /*dummy*/ = 0)
{
if (is_sdf) {
mVol[0]->setBorder(GEO_VOLUMEBORDER_SDF, background);
mVol[0]->setVisualization(vismode, iso, density);
} else {
mVol[0]->setBorder(GEO_VOLUMEBORDER_CONSTANT, background);
mVol[0]->setVisualization(vismode, iso, density);
}
}
template <class ValueT>
void
setVolumeOptions(
bool is_sdf, const ValueT& background,
GEO_VolumeVis vismode, fpreal iso, fpreal density,
NON_SCALAR_RET(ValueT)* /*dummy*/ = 0)
{
if (is_sdf) {
for (int i = 0; i < TUPLE_SIZE; i++) {
mVol[i]->setBorder(GEO_VOLUMEBORDER_SDF, background[i]);
mVol[i]->setVisualization(vismode, iso, density);
}
} else {
for (int i = 0; i < TUPLE_SIZE; i++) {
mVol[i]->setBorder(GEO_VOLUMEBORDER_CONSTANT, background[i]);
mVol[i]->setVisualization(vismode, iso, density);
}
}
}
void setSpaceTransform(const GEO_PrimVolumeXform& s)
{
for (int i = 0; i < TUPLE_SIZE; i++)
mVol[i]->setSpaceTransform(s);
}
int
numTiles() const
{
// Since we create all volumes the same size, we can simply use the
// first one.
return mHandle[0]->numTiles();
}
template<typename ConstAccessorT>
void copyToAlignedTile(
int tile_index,
ConstAccessorT& src,
const openvdb::Coord& src_origin);
template<typename ConstAccessorT>
void copyToTile(
int tile_index,
ConstAccessorT& src,
const openvdb::Coord& src_origin);
private: // methods
using VoxelTileF = UT_VoxelTile<fpreal32>;
template <class ValueT>
static void
makeConstant_(VoxelTileF* tiles[TUPLE_SIZE], const ValueT& v,
SCALAR_RET(ValueT)* /*dummy*/ = 0)
{
tiles[0]->makeConstant(fpreal32(v));
}
template <class ValueT>
static void
makeConstant_(VoxelTileF* tiles[TUPLE_SIZE], const ValueT& v,
NON_SCALAR_RET(ValueT)* /*dummy*/ = 0)
{
for (int i = 0; i < TUPLE_SIZE; i++)
tiles[i]->makeConstant(fpreal32(v[i]));
}
// Convert a local tile coordinate to a linear offset. This is used instead
// of UT_VoxelTile::operator()() since we always decompress the tile first.
SYS_FORCE_INLINE static int
tileCoordToOffset(const VoxelTileF* tile, const openvdb::Coord& xyz)
{
UT_ASSERT_P(xyz[0] >= 0 && xyz[0] < tile->xres());
UT_ASSERT_P(xyz[1] >= 0 && xyz[1] < tile->yres());
UT_ASSERT_P(xyz[2] >= 0 && xyz[2] < tile->zres());
return ((xyz[2] * tile->yres()) + xyz[1]) * tile->xres() + xyz[0];
}
// Set the value into tile coord xyz
template <class ValueT>
static void
setTileVoxel(
const openvdb::Coord& xyz,
VoxelTileF* tile,
fpreal32* rawData,
const ValueT& v,
int /*i*/,
SCALAR_RET(ValueT)* /*dummy*/ = 0)
{
rawData[tileCoordToOffset(tile, xyz)] = v;
}
template <class ValueT>
static void
setTileVoxel(
const openvdb::Coord& xyz,
VoxelTileF* tile,
fpreal32* rawData,
const ValueT& v,
int i,
NON_SCALAR_RET(ValueT)* /*dummy*/ = 0)
{
rawData[tileCoordToOffset(tile, xyz)] = v[i];
}
template <class ValueT>
static bool
compareVoxel(
const openvdb::Coord& xyz,
VoxelTileF* tile,
fpreal32* rawData,
const ValueT& v,
int i,
SCALAR_RET(ValueT) *dummy = 0)
{
UT_ASSERT_P(xyz[0] >= 0 && xyz[0] < tile->xres());
UT_ASSERT_P(xyz[1] >= 0 && xyz[1] < tile->yres());
UT_ASSERT_P(xyz[2] >= 0 && xyz[2] < tile->zres());
float vox = (*tile)(xyz[0], xyz[1], xyz[2]);
return openvdb::math::isApproxEqual<float>(vox, v);
}
template <class ValueT>
static bool
compareVoxel(
const openvdb::Coord& xyz,
VoxelTileF* tile,
fpreal32* rawData,
const ValueT& v,
int i,
NON_SCALAR_RET(ValueT) *dummy = 0)
{
UT_ASSERT_P(xyz[0] >= 0 && xyz[0] < tile->xres());
UT_ASSERT_P(xyz[1] >= 0 && xyz[1] < tile->yres());
UT_ASSERT_P(xyz[2] >= 0 && xyz[2] < tile->zres());
float vox = (*tile)(xyz[0], xyz[1], xyz[2]);
return openvdb::math::isApproxEqual<float>(vox, v[i]);
}
// Check if aligned VDB bbox region is constant
template<typename ConstAccessorT, typename ValueType>
static bool
isAlignedConstantRegion_(
ConstAccessorT& acc,
const openvdb::Coord& beg,
const openvdb::Coord& end,
const ValueType& const_value)
{
using openvdb::math::isApproxEqual;
using LeafNodeType = typename ConstAccessorT::LeafNodeT;
const openvdb::Index DIM = LeafNodeType::DIM;
// The smallest constant tile size in vdb is DIM and the
// vdb-leaf/hdk-tile coords are aligned.
openvdb::Coord ijk;
for (ijk[0] = beg[0]; ijk[0] < end[0]; ijk[0] += DIM) {
for (ijk[1] = beg[1]; ijk[1] < end[1]; ijk[1] += DIM) {
for (ijk[2] = beg[2]; ijk[2] < end[2]; ijk[2] += DIM) {
if (acc.probeConstLeaf(ijk) != nullptr)
return false;
ValueType sampleValue = acc.getValue(ijk);
if (!isApproxEqual(const_value, sampleValue))
return false;
}
}
}
return true;
}
// Copy all data of the aligned leaf node to the tile at origin
template<typename LeafType>
static void
copyAlignedLeafNode_(
VoxelTileF* tile,
int tuple_i,
const openvdb::Coord& origin,
const LeafType& leaf)
{
fpreal32* data = tile->rawData();
for (openvdb::Index i = 0; i < LeafType::NUM_VALUES; ++i) {
openvdb::Coord xyz = origin + LeafType::offsetToLocalCoord(i);
setTileVoxel(xyz, tile, data, leaf.getValue(i), tuple_i);
}
}
// Check if unaligned VDB bbox region is constant.
// beg_a is beg rounded down to the nearest leaf origin.
template<typename ConstAccessorT, typename ValueType>
static bool
isConstantRegion_(
ConstAccessorT& acc,
const openvdb::Coord& beg,
const openvdb::Coord& end,
const openvdb::Coord& beg_a,
const ValueType& const_value)
{
using openvdb::math::isApproxEqual;
using LeafNodeType = typename ConstAccessorT::LeafNodeT;
const openvdb::Index DIM = LeafNodeType::DIM;
const openvdb::Index LOG2DIM = LeafNodeType::LOG2DIM;
UT_ASSERT(beg_a[0] % DIM == 0);
UT_ASSERT(beg_a[1] % DIM == 0);
UT_ASSERT(beg_a[2] % DIM == 0);
openvdb::Coord ijk;
for (ijk[0] = beg_a[0]; ijk[0] < end[0]; ijk[0] += DIM) {
for (ijk[1] = beg_a[1]; ijk[1] < end[1]; ijk[1] += DIM) {
for (ijk[2] = beg_a[2]; ijk[2] < end[2]; ijk[2] += DIM) {
const LeafNodeType* leaf = acc.probeConstLeaf(ijk);
if (!leaf)
{
ValueType sampleValue = acc.getValue(ijk);
if (!isApproxEqual(const_value, sampleValue))
return false;
continue;
}
// Else, we're a leaf node, determine if region is constant
openvdb::Coord leaf_beg = ijk;
openvdb::Coord leaf_end = ijk + openvdb::Coord(DIM, DIM, DIM);
// Clamp the leaf region to the tile bbox
leaf_beg.maxComponent(beg);
leaf_end.minComponent(end);
// Offset into local leaf coordinates
leaf_beg -= leaf->origin();
leaf_end -= leaf->origin();
const ValueType* s0 = &leaf->getValue(leaf_beg[2]);
for (openvdb::Int32 x = leaf_beg[0]; x < leaf_end[0]; ++x) {
const ValueType* s1 = s0 + (x<<2*LOG2DIM);
for (openvdb::Int32 y = leaf_beg[1]; y < leaf_end[1]; ++y) {
const ValueType* s2 = s1 + (y<<LOG2DIM);
for (openvdb::Int32 z = leaf_beg[2]; z < leaf_end[2]; ++z) {
if (!isApproxEqual(const_value, *s2))
return false;
s2++;
}
}
}
}
}
}
return true;
}
// Copy the leaf node data at the global coord leaf_origin to the local
// tile region [beg,end)
template<typename LeafType>
static void
copyLeafNode_(
VoxelTileF* tile,
int tuple_i,
const openvdb::Coord& beg,
const openvdb::Coord& end,
const openvdb::Coord& leaf_origin,
const LeafType& leaf)
{
using openvdb::Coord;
fpreal32* data = tile->rawData();
Coord xyz;
Coord ijk = leaf_origin;
for (xyz[2] = beg[2]; xyz[2] < end[2]; ++xyz[2], ++ijk[2]) {
ijk[1] = leaf_origin[1];
for (xyz[1] = beg[1]; xyz[1] < end[1]; ++xyz[1], ++ijk[1]) {
ijk[0] = leaf_origin[0];
for (xyz[0] = beg[0]; xyz[0] < end[0]; ++xyz[0], ++ijk[0]) {
setTileVoxel(xyz, tile, data, leaf.getValue(ijk), tuple_i);
}
}
}
}
// Set the local tile region [beg,end) to the same value.
template <class ValueT>
static void
setConstantRegion_(
VoxelTileF* tile,
int tuple_i,
const openvdb::Coord& beg,
const openvdb::Coord& end,
const ValueT& value)
{
fpreal32* data = tile->rawData();
openvdb::Coord xyz;
for (xyz[2] = beg[2]; xyz[2] < end[2]; ++xyz[2]) {
for (xyz[1] = beg[1]; xyz[1] < end[1]; ++xyz[1]) {
for (xyz[0] = beg[0]; xyz[0] < end[0]; ++xyz[0]) {
setTileVoxel(xyz, tile, data, value, tuple_i);
}
}
}
}
void
getTileCopyData_(
int tile_index,
const openvdb::Coord& src_origin,
VoxelTileF* tiles[TUPLE_SIZE],
openvdb::Coord& res,
openvdb::Coord& src_bbox_beg,
openvdb::Coord& src_bbox_end)
{
for (int i = 0; i < TUPLE_SIZE; i++) {
tiles[i] = mHandle[i]->getLinearTile(tile_index);
}
// Since all tiles are the same size, so just use the first one.
res[0] = tiles[0]->xres();
res[1] = tiles[0]->yres();
res[2] = tiles[0]->zres();
// Define the inclusive coordinate range, in vdb index space.
// ie. The source bounding box that we will copy from.
// NOTE: All tiles are the same size, so just use the first handle.
openvdb::Coord dst;
mHandle[0]->linearTileToXYZ(tile_index, dst.x(), dst.y(), dst.z());
dst.x() *= TILESIZE;
dst.y() *= TILESIZE;
dst.z() *= TILESIZE;
src_bbox_beg = src_origin + dst;
src_bbox_end = src_bbox_beg + res;
}
private: // data
GU_Detail& mGeo;
GU_PrimVolume *mVol[TUPLE_SIZE];
UT_VoxelArrayWriteHandleF mHandle[TUPLE_SIZE];
};
// Copy the vdb data to the current tile. Assumes full tiles.
template<int TUPLE_SIZE>
template<typename ConstAccessorT>
inline void
VoxelArrayVolume<TUPLE_SIZE>::copyToAlignedTile(
int tile_index, ConstAccessorT &acc, const openvdb::Coord& src_origin)
{
using openvdb::Coord;
using openvdb::CoordBBox;
using ValueType = typename ConstAccessorT::ValueType;
using LeafNodeType = typename ConstAccessorT::LeafNodeT;
const openvdb::Index LEAF_DIM = LeafNodeType::DIM;
VoxelTileF* tiles[TUPLE_SIZE];
Coord tile_res;
Coord beg;
Coord end;
getTileCopyData_(tile_index, src_origin, tiles, tile_res, beg, end);
ValueType const_value = acc.getValue(beg);
if (isAlignedConstantRegion_(acc, beg, end, const_value)) {
makeConstant_(tiles, const_value);
} else { // populate dense tile
for (int tuple_i = 0; tuple_i < TUPLE_SIZE; tuple_i++) {
VoxelTileF* tile = tiles[tuple_i];
tile->makeRawUninitialized();
Coord ijk;
for (ijk[0] = beg[0]; ijk[0] < end[0]; ijk[0] += LEAF_DIM) {
for (ijk[1] = beg[1]; ijk[1] < end[1]; ijk[1] += LEAF_DIM) {
for (ijk[2] = beg[2]; ijk[2] < end[2]; ijk[2] += LEAF_DIM) {
Coord tile_beg = ijk - beg; // local tile coord
Coord tile_end = tile_beg.offsetBy(LEAF_DIM);
const LeafNodeType* leaf = acc.probeConstLeaf(ijk);
if (leaf != nullptr) {
copyAlignedLeafNode_(
tile, tuple_i, tile_beg, *leaf);
} else {
setConstantRegion_(
tile, tuple_i, tile_beg, tile_end,
acc.getValue(ijk));
}
}
}
}
}
} // end populate dense tile
}
template<int TUPLE_SIZE>
template<typename ConstAccessorT>
inline void
VoxelArrayVolume<TUPLE_SIZE>::copyToTile(
int tile_index, ConstAccessorT &acc, const openvdb::Coord& src_origin)
{
using openvdb::Coord;
using openvdb::CoordBBox;
using ValueType = typename ConstAccessorT::ValueType;
using LeafNodeType = typename ConstAccessorT::LeafNodeT;
const openvdb::Index DIM = LeafNodeType::DIM;
VoxelTileF* tiles[TUPLE_SIZE];
Coord tile_res;
Coord beg;
Coord end;
getTileCopyData_(tile_index, src_origin, tiles, tile_res, beg, end);
// a_beg is beg rounded down to the nearest leaf origin
Coord a_beg(beg[0]&~(DIM-1), beg[1]&~(DIM-1), beg[2]&~(DIM-1));
ValueType const_value = acc.getValue(a_beg);
if (isConstantRegion_(acc, beg, end, a_beg, const_value)) {
makeConstant_(tiles, const_value);
} else {
for (int tuple_i = 0; tuple_i < TUPLE_SIZE; tuple_i++) {
VoxelTileF* tile = tiles[tuple_i];
tile->makeRawUninitialized();
Coord ijk;
for (ijk[0] = a_beg[0]; ijk[0] < end[0]; ijk[0] += DIM) {
for (ijk[1] = a_beg[1]; ijk[1] < end[1]; ijk[1] += DIM) {
for (ijk[2] = a_beg[2]; ijk[2] < end[2]; ijk[2] += DIM) {
// Compute clamped local tile coord bbox
Coord leaf_beg = ijk;
Coord tile_beg = ijk - beg;
Coord tile_end = tile_beg.offsetBy(DIM);
for (int axis = 0; axis < 3; ++axis) {
if (tile_beg[axis] < 0) {
tile_beg[axis] = 0;
leaf_beg[axis] = beg[axis];
}
if (tile_end[axis] > tile_res[axis])
tile_end[axis] = tile_res[axis];
}
// Copy the region
const LeafNodeType* leaf = acc.probeConstLeaf(leaf_beg);
if (leaf != nullptr) {
copyLeafNode_(
tile, tuple_i, tile_beg, tile_end,
leaf_beg, *leaf);
} else {
setConstantRegion_(
tile, tuple_i, tile_beg, tile_end,
acc.getValue(ijk));
}
}
}
}
}
}
// Enable this to do slow code path verification
#if 0
for (int tuple_i = 0; tuple_i < TUPLE_SIZE; ++tuple_i) {
VoxelTileF* tile = tiles[tuple_i];
fpreal32* data = tile->rawData();
Coord xyz;
for (xyz[2] = 0; xyz[2] < tile_res[2]; ++xyz[2]) {
for (xyz[1] = 0; xyz[1] < tile_res[1]; ++xyz[1]) {
for (xyz[0] = 0; xyz[0] < tile_res[0]; ++xyz[0]) {
Coord ijk = beg + xyz;
if (!compareVoxel(xyz, tile, data,
acc.getValue(ijk), tuple_i)) {
UT_ASSERT(!"Voxels are different");
compareVoxel(xyz, tile, data,
acc.getValue(ijk), tuple_i);
}
}
}
}
}
#endif
}
template<typename TreeType, typename VolumeT, bool aligned>
class gu_SparseTreeCopy;
template<typename TreeType, typename VolumeT>
class gu_SparseTreeCopy<TreeType, VolumeT, /*aligned=*/true>
{
public:
gu_SparseTreeCopy(
const TreeType& tree,
VolumeT& volume,
const openvdb::Coord& src_origin,
UT_AutoInterrupt& progress
)
: mVdbAcc(tree)
, mVolume(volume)
, mSrcOrigin(src_origin)
, mProgress(progress)
{
}
void run(bool threaded = true)
{
tbb::blocked_range<int> range(0, mVolume.numTiles());
if (threaded) tbb::parallel_for(range, *this);
else (*this)(range);
}
void operator()(const tbb::blocked_range<int>& range) const
{
uint8 bcnt = 0;
for (int i = range.begin(); i != range.end(); ++i) {
mVolume.copyToAlignedTile(i, mVdbAcc, mSrcOrigin);
if (!bcnt++ && mProgress.wasInterrupted())
return;
}
}
private:
openvdb::tree::ValueAccessor<const TreeType> mVdbAcc;
VolumeT& mVolume;
const openvdb::Coord mSrcOrigin;
UT_AutoInterrupt& mProgress;
};
template<typename TreeType, typename VolumeT>
class gu_SparseTreeCopy<TreeType, VolumeT, /*aligned=*/false>
{
public:
gu_SparseTreeCopy(
const TreeType& tree,
VolumeT& volume,
const openvdb::Coord& src_origin,
UT_AutoInterrupt& progress
)
: mVdbAcc(tree)
, mVolume(volume)
, mSrcOrigin(src_origin)
, mProgress(progress)
{
}
void run(bool threaded = true)
{
tbb::blocked_range<int> range(0, mVolume.numTiles());
if (threaded) tbb::parallel_for(range, *this);
else (*this)(range);
}
void operator()(const tbb::blocked_range<int>& range) const
{
uint8 bcnt = 0;
for (int i = range.begin(); i != range.end(); ++i) {
mVolume.copyToTile(i, mVdbAcc, mSrcOrigin);
if (!bcnt++ && mProgress.wasInterrupted())
return;
}
}
private:
openvdb::tree::ValueAccessor<const TreeType> mVdbAcc;
VolumeT& mVolume;
const openvdb::Coord mSrcOrigin;
UT_AutoInterrupt& mProgress;
};
/// @brief Converts an OpenVDB grid into one/three Houdini Volume.
/// @note Vector grids are converted into three Houdini Volumes.
template <class VolumeT>
class gu_ConvertFromVDB
{
public:
gu_ConvertFromVDB(
GEO_Detail& dst_geo,
const GU_PrimVDB& src_vdb,
bool split_disjoint_volumes,
UT_AutoInterrupt& progress)
: mDstGeo(static_cast<GU_Detail&>(dst_geo))
, mSrcVDB(src_vdb)
, mSplitDisjoint(split_disjoint_volumes)
, mProgress(progress)
{
}
template<typename GridT>
void operator()(const GridT &grid)
{
if (mSplitDisjoint) {
vdbToDisjointVolumes(grid);
} else {
using LeafNodeType = typename GridT::TreeType::LeafNodeType;
const openvdb::Index LEAF_DIM = LeafNodeType::DIM;
VolumeT volume(mDstGeo);
openvdb::CoordBBox bbox(grid.evalActiveVoxelBoundingBox());
bool aligned = ( (bbox.min()[0] % LEAF_DIM) == 0
&& (bbox.min()[1] % LEAF_DIM) == 0
&& (bbox.min()[2] % LEAF_DIM) == 0
&& ((bbox.max()[0]+1) % LEAF_DIM) == 0
&& ((bbox.max()[1]+1) % LEAF_DIM) == 0
&& ((bbox.max()[2]+1) % LEAF_DIM) == 0);
vdbToVolume(grid, bbox, volume, aligned);
}
}
const UT_IntArray& components() const
{
return mDstComponents;
}
private:
template<typename GridType>
void vdbToVolume(const GridType& grid, const openvdb::CoordBBox& bbox,
VolumeT& volume, bool aligned);
template<typename GridType>
void vdbToDisjointVolumes(const GridType& grid);
private:
GU_Detail& mDstGeo;
UT_IntArray mDstComponents;
const GU_PrimVDB& mSrcVDB;
bool mSplitDisjoint;
UT_AutoInterrupt& mProgress;
};
// Copy the grid's bbox into volume at (0,0,0)
template<typename VolumeT>
template<typename GridType>
void
gu_ConvertFromVDB<VolumeT>::vdbToVolume(
const GridType& grid,
const openvdb::CoordBBox& bbox,
VolumeT& vol,
bool aligned)
{
using LeafNodeType = typename GridType::TreeType::LeafNodeType;
// Creating a Houdini volume with a zero bbox seems to break the transform.
// (probably related to the bbox derived 'local space')
openvdb::CoordBBox space_bbox = bbox;
if (space_bbox.empty())
space_bbox.resetToCube(openvdb::Coord(0, 0, 0), 1);
vol.setSize(space_bbox.dim());
vol.setVolumeOptions(mSrcVDB.isSDF(), grid.background(),
mSrcVDB.getVisualization(), mSrcVDB.getVisIso(),
mSrcVDB.getVisDensity());
vol.setSpaceTransform(mSrcVDB.getSpaceTransform(UTvdbConvert(space_bbox)));
for (int i = 0; i < VolumeT::TupleSize; i++)
mDstComponents.append(i);
// Copy the VDB bbox data to voxel array coord (0,0,0).
SYS_STATIC_ASSERT(LeafNodeType::DIM <= TILESIZE);
SYS_STATIC_ASSERT((TILESIZE % LeafNodeType::DIM) == 0);
if (aligned) {
gu_SparseTreeCopy<typename GridType::TreeType, VolumeT, true>
copy(grid.tree(), vol, space_bbox.min(), mProgress);
copy.run();
} else {
gu_SparseTreeCopy<typename GridType::TreeType, VolumeT, false>
copy(grid.tree(), vol, space_bbox.min(), mProgress);
copy.run();
}
}
template<typename VolumeT>
template<typename GridType>
void
gu_ConvertFromVDB<VolumeT>::vdbToDisjointVolumes(const GridType& grid)
{
using TreeType = typename GridType::TreeType;
using NodeType = typename TreeType::RootNodeType::ChildNodeType;
std::vector<const NodeType*> nodes;
typename TreeType::NodeCIter iter = grid.tree().cbeginNode();
iter.setMaxDepth(1);
iter.setMinDepth(1);
for (; iter; ++iter) {
const NodeType* node = nullptr;
iter.template getNode<const NodeType>(node);
if (node) nodes.push_back(node);
}
std::vector<openvdb::CoordBBox> nodeBBox(nodes.size());
for (size_t n = 0, N = nodes.size(); n < N; ++n) {
nodes[n]->evalActiveBoundingBox(nodeBBox[n], false);
}
openvdb::CoordBBox regionA, regionB;
const int searchDist = int(GridType::TreeType::LeafNodeType::DIM) << 1;
for (size_t n = 0, N = nodes.size(); n < N; ++n) {
if (!nodes[n]) continue;
openvdb::CoordBBox& bbox = nodeBBox[n];
regionA = bbox;
regionA.max().offset(searchDist);
bool expanded = true;
while (expanded) {
expanded = false;
for (size_t i = (n + 1); i < N; ++i) {
if (!nodes[i]) continue;
regionB = nodeBBox[i];
regionB.max().offset(searchDist);
if (regionA.hasOverlap(regionB)) {
nodes[i] = nullptr;
expanded = true;
bbox.expand(nodeBBox[i]);
regionA = bbox;
regionA.max().offset(searchDist);
}
}
}
VolumeT volume(mDstGeo);
vdbToVolume(grid, bbox, volume, /*aligned*/true);
}
}
} // namespace anonymous
GEO_Primitive *
GU_PrimVDB::convertToPrimVolume(
GEO_Detail &dst_geo,
GU_ConvertParms &parms,
bool split_disjoint_volumes) const
{
using namespace openvdb;
UT_AutoInterrupt progress("Convert VDB to Volume");
GA_Detail::OffsetMarker marker(dst_geo);
UT_IntArray dst_components;
bool processed = false;
{ // Try to convert scalar grid
gu_ConvertFromVDB< VoxelArrayVolume<1> >
converter(dst_geo, *this, split_disjoint_volumes, progress);
processed = GEOvdbProcessTypedGridScalar(*this, converter);
}
if (!processed) { // Try to convert vector grid
gu_ConvertFromVDB< VoxelArrayVolume<3> >
converter(dst_geo, *this, split_disjoint_volumes, progress);
processed = GEOvdbProcessTypedGridVec3(*this, converter);
dst_components = converter.components();
}
// Copy attributes from source to dest primitives
GA_Range pointrange(marker.pointRange());
GA_Range primitiverange(marker.primitiveRange());
if (!processed || primitiverange.isEmpty() || progress.wasInterrupted())
return nullptr;
GUconvertCopySingleVertexPrimAttribsAndGroups(
parms, *getParent(), getMapOffset(),
dst_geo, primitiverange, pointrange);
// Handle the name attribute if needed
if (dst_components.entries() > 0)
{
GA_ROHandleS src_name(getParent(), GA_ATTRIB_PRIMITIVE, "name");
GA_RWHandleS dst_name(&dst_geo, GA_ATTRIB_PRIMITIVE, "name");
if (src_name.isValid() && dst_name.isValid())
{
const UT_String name(src_name.get(getMapOffset()));
if (name.isstring())
{
UT_String full_name(name);
int last = name.length() + 1;
const char component[] = { 'x', 'y', 'z', 'w' };
GA_Size nprimitives = primitiverange.getEntries();
UT_ASSERT(dst_components.entries() == nprimitives);
full_name += ".x";
for (int j = 0; j < nprimitives; j++)
{
int i = dst_components(j);
if (i < 4)
full_name(last) = component[i];
else
full_name.sprintf("%s%d", (const char *)name, i);
// NOTE: This assumes that the offsets are contiguous,
// which is only valid if the converter didn't
// delete anything.
dst_name.set(marker.primitiveBegin() + GA_Offset(i),
full_name);
}
}
}
}
return dst_geo.getGEOPrimitive(marker.primitiveBegin());
}
GEO_Primitive *
GU_PrimVDB::convert(GU_ConvertParms &parms, GA_PointGroup *usedpts)
{
bool success = false;
GEO_Primitive * prim;
prim = convertToNewPrim(*getParent(), parms,
/*adaptivity*/0, /*sparse*/false, success);
if (success)
{
if (usedpts)
addPointRefToGroup(*usedpts);
GA_PrimitiveGroup *group = parms.getDeletePrimitives();
if (group)
group->add(this);
else
getParent()->deletePrimitive(*this, !usedpts);
}
return prim;
}
/*static*/ void
GU_PrimVDB::convertVolumesToVDBs(
GU_Detail &dst_geo,
const GU_Detail &src_geo,
GU_ConvertParms &parms,
bool flood_sdf,
bool prune,
fpreal tolerance,
bool keep_original,
bool activate_inside_sdf)
{
UT_AutoInterrupt progress("Convert");
const GA_ROHandleS nameHandle(&src_geo, GA_ATTRIB_PRIMITIVE, "name");
GEO_Primitive *prim;
GEO_Primitive *next;
GA_FOR_SAFE_GROUP_PRIMITIVES(&src_geo, parms.primGroup, prim, next)
{
if (progress.wasInterrupted())
break;
if (prim->getTypeId() != GEO_PRIMVOLUME)
continue;
GEO_PrimVolume *vol = UTverify_cast<GEO_PrimVolume*>(prim);
GA_Offset voloff = vol->getMapOffset();
GA_Detail::OffsetMarker marker(dst_geo);
// Get the volume's name, if it has one.
char const * const volname = (nameHandle.isValid() ? nameHandle.get(voloff) : nullptr);
GU_PrimVDB *new_prim;
new_prim = GU_PrimVDB::buildFromPrimVolume(
dst_geo, *vol, volname, flood_sdf, prune, tolerance,
activate_inside_sdf);
if (!new_prim || progress.wasInterrupted())
break;
GA_Range pointrange(marker.pointRange());
GA_Range primitiverange(marker.primitiveRange());
GUconvertCopySingleVertexPrimAttribsAndGroups(
parms, src_geo, voloff, dst_geo,
primitiverange, pointrange);
if (!keep_original && (&dst_geo == &src_geo))
dst_geo.deletePrimitive(*vol, /*and points*/true);
}
}
/*static*/ void
GU_PrimVDB::convertVDBs(
GU_Detail &dst_geo,
const GU_Detail &src_geo,
GU_ConvertParms &parms,
fpreal adaptivity,
bool keep_original,
bool split_disjoint_volumes)
{
UT_AutoInterrupt progress("Convert");
GEO_Primitive *prim;
GEO_Primitive *next;
GA_FOR_SAFE_GROUP_PRIMITIVES(&src_geo, parms.primGroup, prim, next)
{
if (progress.wasInterrupted())
break;
GU_PrimVDB *vdb = dynamic_cast<GU_PrimVDB*>(prim);
if (vdb == nullptr)
continue;
bool success = false;
(void) vdb->convertToNewPrim(dst_geo, parms, adaptivity,
split_disjoint_volumes, success);
if (success && !keep_original && (&dst_geo == &src_geo))
dst_geo.deletePrimitive(*vdb, /*and points*/true);
}
}
/*static*/ void
GU_PrimVDB::convertVDBs(
GU_Detail &dst_geo,
const GU_Detail &src_geo,
GU_ConvertParms &parms,
fpreal adaptivity,
bool keep_original)
{
convertVDBs(dst_geo, src_geo, parms, adaptivity, keep_original, false);
}
void
GU_PrimVDB::normal(NormalComp& /*output*/) const
{
// No need here.
}
////////////////////////////////////////
namespace {
template <typename T> struct IsScalarMeta
{ HBOOST_STATIC_CONSTANT(bool, value = true); };
#define DECLARE_VECTOR(METADATA_T) \
template <> struct IsScalarMeta<METADATA_T> \
{ HBOOST_STATIC_CONSTANT(bool, value = false); }; \
/**/
DECLARE_VECTOR(openvdb::Vec2IMetadata)
DECLARE_VECTOR(openvdb::Vec2SMetadata)
DECLARE_VECTOR(openvdb::Vec2DMetadata)
DECLARE_VECTOR(openvdb::Vec3IMetadata)
DECLARE_VECTOR(openvdb::Vec3SMetadata)
DECLARE_VECTOR(openvdb::Vec3DMetadata)
DECLARE_VECTOR(openvdb::Vec4IMetadata)
DECLARE_VECTOR(openvdb::Vec4SMetadata)
DECLARE_VECTOR(openvdb::Vec4DMetadata)
#undef DECLARE_VECTOR
template<typename T, typename MetadataT, int I, typename ENABLE = void>
struct MetaTuple
{
static T get(const MetadataT& meta) {
return meta.value()[I];
}
};
template<typename T, typename MetadataT, int I>
struct MetaTuple<T, MetadataT, I, typename SYS_EnableIf< IsScalarMeta<MetadataT>::value >::type>
{
static T get(const MetadataT& meta) {
UT_ASSERT(I == 0);
return meta.value();
}
};
template<int I>
struct MetaTuple<const char*, openvdb::StringMetadata, I>
{
static const char* get(const openvdb::StringMetadata& meta) {
UT_ASSERT(I == 0);
return meta.value().c_str();
}
};
template <typename MetadataT> struct MetaAttr;
#define META_ATTR(METADATA_T, STORAGE, TUPLE_T, TUPLE_SIZE) \
template <> \
struct MetaAttr<METADATA_T> { \
using TupleT = TUPLE_T; \
using RWHandleT = GA_HandleT<TupleT>::RWType; \
static const int theTupleSize = TUPLE_SIZE; \
static const GA_Storage theStorage = STORAGE; \
}; \
/**/
META_ATTR(openvdb::BoolMetadata, GA_STORE_INT8, int8, 1)
META_ATTR(openvdb::FloatMetadata, GA_STORE_REAL32, fpreal32, 1)
META_ATTR(openvdb::DoubleMetadata, GA_STORE_REAL64, fpreal64, 1)
META_ATTR(openvdb::Int32Metadata, GA_STORE_INT32, int32, 1)
META_ATTR(openvdb::Int64Metadata, GA_STORE_INT64, int64, 1)
//META_ATTR(openvdb::StringMetadata, GA_STORE_STRING, const char*, 1)
META_ATTR(openvdb::Vec2IMetadata, GA_STORE_INT32, int32, 2)
META_ATTR(openvdb::Vec2SMetadata, GA_STORE_REAL32, fpreal32, 2)
META_ATTR(openvdb::Vec2DMetadata, GA_STORE_REAL64, fpreal64, 2)
META_ATTR(openvdb::Vec3IMetadata, GA_STORE_INT32, int32, 3)
META_ATTR(openvdb::Vec3SMetadata, GA_STORE_REAL32, fpreal32, 3)
META_ATTR(openvdb::Vec3DMetadata, GA_STORE_REAL64, fpreal64, 3)
META_ATTR(openvdb::Vec4IMetadata, GA_STORE_INT32, int32, 4)
META_ATTR(openvdb::Vec4SMetadata, GA_STORE_REAL32, fpreal32, 4)
META_ATTR(openvdb::Vec4DMetadata, GA_STORE_REAL64, fpreal64, 4)
META_ATTR(openvdb::Mat4SMetadata, GA_STORE_REAL32, fpreal32, 16)
META_ATTR(openvdb::Mat4DMetadata, GA_STORE_REAL64, fpreal64, 16)
#undef META_ATTR
// Functor for setAttr()
typedef hboost::function<
void (GEO_Detail&, GA_AttributeOwner, GA_Offset, const char*, const openvdb::Metadata&)> AttrSettor;
template <typename MetadataT>
static void
setAttr(GEO_Detail& geo, GA_AttributeOwner owner, GA_Offset elem,
const char* name, const openvdb::Metadata& meta_base)
{
using MetaAttrT = MetaAttr<MetadataT>;
using RWHandleT = typename MetaAttrT::RWHandleT;
using TupleT = typename MetaAttrT::TupleT;
/// @todo If there is an existing attribute with the given name but
/// a different type, this will replace the old attribute with a new one.
/// See GA_ReuseStrategy for alternative behaviors.
GA_RWAttributeRef attrRef = geo.addTuple(MetaAttrT::theStorage, owner, name, MetaAttrT::theTupleSize);
if (attrRef.isInvalid()) return;
RWHandleT handle(attrRef.getAttribute());
const MetadataT& meta = static_cast<const MetadataT&>(meta_base);
switch (MetaAttrT::theTupleSize) {
case 4: handle.set(elem, 3, MetaTuple<TupleT,MetadataT,3>::get(meta));
SYS_FALLTHROUGH;
case 3: handle.set(elem, 2, MetaTuple<TupleT,MetadataT,2>::get(meta));
SYS_FALLTHROUGH;
case 2: handle.set(elem, 1, MetaTuple<TupleT,MetadataT,1>::get(meta));
SYS_FALLTHROUGH;
case 1: handle.set(elem, 0, MetaTuple<TupleT,MetadataT,0>::get(meta));
}
UT_ASSERT(MetaAttrT::theTupleSize >= 1 && MetaAttrT::theTupleSize <= 4);
}
/// for Houdini 12.1
template <typename MetadataT>
static void
setStrAttr(GEO_Detail& geo, GA_AttributeOwner owner, GA_Offset elem,
const char* name, const openvdb::Metadata& meta_base)
{
GA_RWAttributeRef attrRef = geo.addStringTuple(owner, name, 1);
if (attrRef.isInvalid()) return;
GA_RWHandleS handle(attrRef.getAttribute());
const MetadataT& meta = static_cast<const MetadataT&>(meta_base);
handle.set(elem, 0, MetaTuple<const char*, MetadataT, 0>::get(meta));
}
template <typename MetadataT>
static void
setMatAttr(GEO_Detail& geo, GA_AttributeOwner owner, GA_Offset elem,
const char* name, const openvdb::Metadata& meta_base)
{
using MetaAttrT = MetaAttr<MetadataT>;
using RWHandleT = typename MetaAttrT::RWHandleT;
using TupleT = typename MetaAttrT::TupleT;
GA_RWAttributeRef attrRef = geo.addTuple(MetaAttrT::theStorage, owner, name, MetaAttrT::theTupleSize);
if (attrRef.isInvalid()) return;
RWHandleT handle(attrRef.getAttribute());
const MetadataT& meta = static_cast<const MetadataT&>(meta_base);
auto && value = meta.value();
for (int i = 0; i < MetaAttrT::theTupleSize; i++)
{
handle.set(elem, i, value.asPointer()[i]);
}
}
class MetaToAttrMap : public std::map<std::string, AttrSettor>
{
public:
MetaToAttrMap()
{
using namespace openvdb;
// Construct a mapping from OpenVDB metadata types to functions
// that create attributes of corresponding types.
(*this)[BoolMetadata::staticTypeName()] = &setAttr<BoolMetadata>;
(*this)[FloatMetadata::staticTypeName()] = &setAttr<FloatMetadata>;
(*this)[DoubleMetadata::staticTypeName()] = &setAttr<DoubleMetadata>;
(*this)[Int32Metadata::staticTypeName()] = &setAttr<Int32Metadata>;
(*this)[Int64Metadata::staticTypeName()] = &setAttr<Int64Metadata>;
(*this)[StringMetadata::staticTypeName()] = &setStrAttr<StringMetadata>;
(*this)[Vec2IMetadata::staticTypeName()] = &setAttr<Vec2IMetadata>;
(*this)[Vec2SMetadata::staticTypeName()] = &setAttr<Vec2SMetadata>;
(*this)[Vec2DMetadata::staticTypeName()] = &setAttr<Vec2DMetadata>;
(*this)[Vec3IMetadata::staticTypeName()] = &setAttr<Vec3IMetadata>;
(*this)[Vec3SMetadata::staticTypeName()] = &setAttr<Vec3SMetadata>;
(*this)[Vec3DMetadata::staticTypeName()] = &setAttr<Vec3DMetadata>;
(*this)[Vec4IMetadata::staticTypeName()] = &setAttr<Vec4IMetadata>;
(*this)[Vec4SMetadata::staticTypeName()] = &setAttr<Vec4SMetadata>;
(*this)[Vec4DMetadata::staticTypeName()] = &setAttr<Vec4DMetadata>;
(*this)[Mat4SMetadata::staticTypeName()] = &setMatAttr<Mat4SMetadata>;
(*this)[Mat4DMetadata::staticTypeName()] = &setMatAttr<Mat4DMetadata>;
}
};
static UT_SingletonWithLock<MetaToAttrMap> sMetaToAttrMap;
} // unnamed namespace
////////////////////////////////////////
void
GU_PrimVDB::syncAttrsFromMetadata()
{
if (GEO_Detail* detail = this->getParent()) {
createGridAttrsFromMetadata(*this, this->getConstGrid(), *detail);
}
}
void
GU_PrimVDB::createGridAttrsFromMetadataAdapter(
const GEO_PrimVDB& prim,
const void* gridPtr,
GEO_Detail& aGdp)
{
createAttrsFromMetadataAdapter(
GA_ATTRIB_PRIMITIVE, prim.getMapOffset(), gridPtr, aGdp);
}
void
GU_PrimVDB::createAttrsFromMetadataAdapter(
GA_AttributeOwner owner,
GA_Offset element,
const void* meta_map_ptr,
GEO_Detail& geo)
{
// meta_map_ptr is assumed to point to an openvdb::vX_Y_Z::MetaMap, for some
// version X.Y.Z of OpenVDB that may be newer than the one with which
// libHoudiniGEO.so was built. This is safe provided that MetaMap and
// its member objects are ABI-compatible between the two OpenVDB versions.
const openvdb::MetaMap& meta_map = *static_cast<const openvdb::MetaMap*>(meta_map_ptr);
for (openvdb::MetaMap::ConstMetaIterator metaIt = meta_map.beginMeta(),
metaEnd = meta_map.endMeta(); metaIt != metaEnd; ++metaIt) {
if (openvdb::Metadata::Ptr meta = metaIt->second) {
std::string name = metaIt->first;
UT_String str(name);
str.toLower();
str.forceValidVariableName();
UT_String prefixed(name);
prefixed.prepend("vdb_");
if (isIntrinsicMetadata(prefixed))
continue;
// If this grid's name is empty and a "name" attribute
// doesn't already exist, don't create one.
if (str == "name"
&& meta->typeName() == openvdb::StringMetadata::staticTypeName()
&& meta->str().empty())
{
if (!geo.findAttribute(owner, name.c_str())) continue;
}
MetaToAttrMap::const_iterator creatorIt =
sMetaToAttrMap->find(meta->typeName());
if (creatorIt != sMetaToAttrMap->end()) {
creatorIt->second(geo, owner, element, name.c_str(), *meta);
} else {
/// @todo Add warning:
// std::string("discarded metadata \"") + name
// + "\" of unsupported type " + meta->typeName()
}
}
}
}
void
GU_PrimVDB::createMetadataFromGridAttrsAdapter(
void* gridPtr,
const GEO_PrimVDB& prim,
const GEO_Detail& aGdp)
{
createMetadataFromAttrsAdapter(
gridPtr, GA_ATTRIB_PRIMITIVE, prim.getMapOffset(), aGdp);
}
void
GU_PrimVDB::createMetadataFromAttrsAdapter(
void* meta_map_ptr,
GA_AttributeOwner owner,
GA_Offset element,
const GEO_Detail& geo)
{
using namespace openvdb;
// meta_map_ptr is assumed to point to an openvdb::vX_Y_Z::MetaMap, for some
// version X.Y.Z of OpenVDB that may be newer than the one with which
// libHoudiniGEO.so was built. This is safe provided that MetaMap and
// its member objects are ABI-compatible between the two OpenVDB versions.
openvdb::MetaMap& meta_map = *static_cast<openvdb::MetaMap*>(meta_map_ptr);
const GA_AttributeSet& attrs = geo.getAttributes();
for (GA_AttributeDict::iterator it = attrs.begin(owner, GA_SCOPE_PUBLIC); !it.atEnd(); ++it) {
if (!it.name()) continue;
std::string name = it.name();
UT_String prefixed(name);
prefixed.prepend("vdb_");
if (isIntrinsicMetadata(prefixed))
continue;
const GA_Attribute* attrib = it.attrib();
const GA_AIFTuple* tuple = attrib->getAIFTuple();
const int entries = attrib->getTupleSize();
switch (attrib->getStorageClass()) {
case GA_STORECLASS_INT:
if (!tuple)
continue;
switch (entries) {
case 1:
meta_map.removeMeta(name);
if (name.substr(0, 3) == "is_") {
// Scalar integer attributes whose names begin with "is_"
// are mapped to boolean metadata.
if (tuple->getStorage(attrib) == GA_STORE_INT64) {
GA_ROHandleT<int64> handle(attrib);
meta_map.insertMeta(name, BoolMetadata(
handle.get(element) != 0));
} else {
GA_ROHandleT<int32> handle(attrib);
meta_map.insertMeta(name, BoolMetadata(
handle.get(element) != 0));
}
} else {
if (tuple->getStorage(attrib) == GA_STORE_INT64) {
GA_ROHandleT<int64> handle(attrib);
meta_map.insertMeta(name, Int64Metadata(
handle.get(element)));
} else {
GA_ROHandleT<int32> handle(attrib);
meta_map.insertMeta(name, Int32Metadata(
handle.get(element)));
}
}
break;
case 2:
{
GA_ROHandleT<UT_Vector2i> handle(attrib);
meta_map.removeMeta(name);
meta_map.insertMeta(name, Vec2IMetadata(
UTvdbConvert(handle.get(element))));
}
break;
case 3:
{
GA_ROHandleT<UT_Vector3i> handle(attrib);
meta_map.removeMeta(name);
meta_map.insertMeta(name, Vec3IMetadata(
UTvdbConvert(handle.get(element))));
}
break;
case 4:
{
GA_ROHandleT<UT_Vector4i> handle(attrib);
meta_map.removeMeta(name);
meta_map.insertMeta(name, Vec4IMetadata(
UTvdbConvert(handle.get(element))));
}
break;
default:
{
/// @todo Add warning:
//std::ostringstream ostr;
//ostr << "Skipped int[" << entries << "] metadata attribute \""
// << it.name() << "\" (int tuples of size > 3 are not supported)";
}
break;
}
break;
case GA_STORECLASS_FLOAT:
if (!tuple)
continue;
switch (entries) {
case 1:
meta_map.removeMeta(name);
if (tuple->getStorage(attrib) == GA_STORE_REAL64) {
GA_ROHandleT<fpreal64> handle(attrib);
meta_map.insertMeta(name, DoubleMetadata(
handle.get(element)));
} else {
GA_ROHandleT<fpreal32> handle(attrib);
meta_map.insertMeta(name, FloatMetadata(
handle.get(element)));
}
break;
case 2:
meta_map.removeMeta(name);
if (tuple->getStorage(attrib) == GA_STORE_REAL64) {
GA_ROHandleT<UT_Vector2D> handle(attrib);
meta_map.insertMeta(name, Vec2DMetadata(
UTvdbConvert(handle.get(element))));
} else {
GA_ROHandleT<UT_Vector2F> handle(attrib);
meta_map.insertMeta(name, Vec2SMetadata(
UTvdbConvert(handle.get(element))));
}
break;
case 3:
meta_map.removeMeta(name);
if (tuple->getStorage(attrib) == GA_STORE_REAL64) {
GA_ROHandleT<UT_Vector3D> handle(attrib);
meta_map.insertMeta(name, Vec3DMetadata(
UTvdbConvert(handle.get(element))));
} else {
GA_ROHandleT<UT_Vector3F> handle(attrib);
meta_map.insertMeta(name, Vec3SMetadata(
UTvdbConvert(handle.get(element))));
}
break;
case 4:
meta_map.removeMeta(name);
if (tuple->getStorage(attrib) == GA_STORE_REAL64) {
GA_ROHandleT<UT_Vector4D> handle(attrib);
meta_map.insertMeta(name, Vec4DMetadata(
UTvdbConvert(handle.get(element))));
} else {
GA_ROHandleT<UT_Vector4F> handle(attrib);
meta_map.insertMeta(name, Vec4SMetadata(
UTvdbConvert(handle.get(element))));
}
break;
case 16:
meta_map.removeMeta(name);
if (tuple->getStorage(attrib) == GA_STORE_REAL64) {
GA_ROHandleT<UT_Matrix4D> handle(attrib);
meta_map.insertMeta(name, Mat4DMetadata(
UTvdbConvert(handle.get(element))));
} else {
GA_ROHandleT<UT_Matrix4F> handle(attrib);
meta_map.insertMeta(name, Mat4SMetadata(
UTvdbConvert(handle.get(element))));
}
break;
default:
{
/// @todo Add warning:
//std::ostringstream ostr;
//ostr << "Skipped float[" << entries << "] metadata attribute \""
// << it.name() << "\" (float tuples of size > 3 are not supported)";
}
break;
}
break;
case GA_STORECLASS_STRING: {
GA_ROHandleS handle(attrib);
if (entries == 1 && handle.isValid()) {
meta_map.removeMeta(name);
const char* str = handle.get(element);
if (!str) str = "";
meta_map.insertMeta(name, StringMetadata(str));
} else {
/// @todo Add warning:
//std::ostringstream ostr;
//ostr << "Skipped string[" << entries << "] metadata attribute \""
// << it.name() << "\" (string tuples are not supported)";
}
break;
}
case GA_STORECLASS_INVALID: break;
case GA_STORECLASS_DICT: break;
case GA_STORECLASS_OTHER: break;
}
}
}
////////////////////////////////////////
// Following code is for HDK only
#ifndef SESI_OPENVDB
// This is the usual DSO hook.
extern "C" {
void
newGeometryPrim(GA_PrimitiveFactory *factory)
{
GU_PrimVDB::registerMyself(factory);
}
} // extern "C"
#endif
#endif // SESI_OPENVDB || SESI_OPENVDB_PRIM
| 75,727 | C++ | 31.910908 | 106 | 0.558691 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Segment.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Segment.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Segment VDB Grids
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb/tools/LevelSetUtil.h>
#include <GA/GA_AttributeRef.h>
#include <GA/GA_ElementGroup.h>
#include <GA/GA_Handle.h>
#include <GA/GA_Types.h>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
namespace
{
struct SegmentActiveVoxels
{
SegmentActiveVoxels(GU_Detail& geo, bool visualize, bool appendNumber, hvdb::Interrupter&)
: mGeoPt(&geo)
, mVisualize(visualize)
, mAppendNumber(appendNumber)
{
}
template<typename GridType>
void operator()(const GridType& grid)
{
using GridPtrType = typename GridType::Ptr;
std::vector<GridPtrType> segments;
openvdb::tools::segmentActiveVoxels(grid, segments);
GA_RWHandleV3 color;
if (mVisualize) {
GA_RWAttributeRef attrRef = mGeoPt->findDiffuseAttribute(GA_ATTRIB_PRIMITIVE);
if (!attrRef.isValid()) attrRef = mGeoPt->addDiffuseAttribute(GA_ATTRIB_PRIMITIVE);
color.bind(attrRef.getAttribute());
}
float r, g, b;
for (size_t n = 0, N = segments.size(); n < N; ++n) {
std::string name = grid.getName();
if (mAppendNumber) {
std::stringstream ss;
ss << name << "_" << n;
name = ss.str();
}
GU_PrimVDB* vdb = hvdb::createVdbPrimitive(*mGeoPt, segments[n], name.c_str());
if (color.isValid()) {
GA_Offset offset = vdb->getMapOffset();
exint colorID = exint(offset);
UT_Color::getUniqueColor(colorID, &r, &g, &b);
color.set(vdb->getMapOffset(), UT_Vector3(r, g, b));
}
}
}
private:
GU_Detail * const mGeoPt;
bool const mVisualize;
bool const mAppendNumber;
}; // struct SegmentActiveVoxels
struct SegmentSDF
{
SegmentSDF(GU_Detail& geo, bool visualize, bool appendNumber, hvdb::Interrupter&)
: mGeoPt(&geo)
, mVisualize(visualize)
, mAppendNumber(appendNumber)
{
}
template<typename GridType>
void operator()(const GridType& grid)
{
using GridPtrType = typename GridType::Ptr;
std::vector<GridPtrType> segments;
openvdb::tools::segmentSDF(grid, segments);
GA_RWHandleV3 color;
if (mVisualize) {
GA_RWAttributeRef attrRef = mGeoPt->findDiffuseAttribute(GA_ATTRIB_PRIMITIVE);
if (!attrRef.isValid()) attrRef = mGeoPt->addDiffuseAttribute(GA_ATTRIB_PRIMITIVE);
color.bind(attrRef.getAttribute());
}
float r, g, b;
for (size_t n = 0, N = segments.size(); n < N; ++n) {
std::string name = grid.getName();
if (mAppendNumber) {
std::stringstream ss;
ss << name << "_" << n;
name = ss.str();
}
GU_PrimVDB* vdb = hvdb::createVdbPrimitive(*mGeoPt, segments[n], name.c_str());
if (color.isValid()) {
GA_Offset offset = vdb->getMapOffset();
exint colorID = exint(offset);
UT_Color::getUniqueColor(colorID, &r, &g, &b);
color.set(offset, UT_Vector3(r, g, b));
}
}
}
private:
GU_Detail * const mGeoPt;
bool const mVisualize;
bool const mAppendNumber;
}; // struct SegmentSDF
} // unnamed namespace
////////////////////////////////////////
class SOP_OpenVDB_Segment: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Segment(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Segment() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i ) const override { return (i > 0); }
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
};
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setTooltip("Select a subset of the input OpenVDB grids to segment.")
.setDocumentation(
"A subset of the input VDB grids to be segmented"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "colorsegments", "Color Segments")
.setDefault(PRMoneDefaults)
.setDocumentation(
"If enabled, assign a unique, random color to each segment"
" for ease of identification."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "appendnumber", "Append Segment Number to Grid Name")
.setDefault(PRMoneDefaults)
.setDocumentation(
"If enabled, name each output VDB after the input VDB with"
" a unique segment number appended for ease of identification."));
hvdb::OpenVDBOpFactory("VDB Segment by Connectivity",
SOP_OpenVDB_Segment::factory, parms, *table)
#ifndef SESI_OPENVDB
.setInternalName("DW_OpenVDBSegment")
#endif
.addInput("OpenVDB grids")
.setVerb(SOP_NodeVerb::COOK_GENERATOR, []() { return new SOP_OpenVDB_Segment::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Split SDF VDB volumes into connected components.\"\"\"\n\
\n\
@overview\n\
\n\
A single SDF VDB may represent multiple disjoint objects.\n\
This node detects disjoint components and creates a new VDB for each component.\n\
\n\
@related\n\
- [Node:sop/vdbsegmentbyconnectivity]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Segment::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Segment(net, name, op);
}
SOP_OpenVDB_Segment::SOP_OpenVDB_Segment(OP_Network* net,
const char* name, OP_Operator* op): hvdb::SOP_NodeVDB(net, name, op)
{
}
////////////////////////////////////////
bool
SOP_OpenVDB_Segment::updateParmsFlags()
{
bool changed = false;
return changed;
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Segment::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
const GU_Detail* inputGeoPt = inputGeo(0);
const GA_PrimitiveGroup *group = nullptr;
hvdb::Interrupter boss("Segmenting VDBs");
{
UT_String str;
evalString(str, "group", 0, time);
group = matchGroup(*inputGeoPt, str.toStdString());
}
hvdb::VdbPrimCIterator vdbIt(inputGeoPt, group);
if (!vdbIt) {
addWarning(SOP_MESSAGE, "No VDB grids to process.");
return error();
}
bool visualize = bool(evalInt("colorsegments", 0, time));
bool appendNumber = bool(evalInt("appendnumber", 0, time));
SegmentActiveVoxels segmentActiveVoxels(*gdp, visualize, appendNumber, boss);
SegmentSDF segmentSDF(*gdp, visualize, appendNumber, boss);
for (; vdbIt; ++vdbIt) {
if (boss.wasInterrupted()) break;
const GU_PrimVDB* vdb = vdbIt.getPrimitive();
const openvdb::GridClass gridClass = vdb->getGrid().getGridClass();
if (gridClass == openvdb::GRID_LEVEL_SET) {
hvdb::GEOvdbApply<hvdb::NumericGridTypes>(*vdb, segmentSDF);
} else {
hvdb::GEOvdbApply<hvdb::AllGridTypes>(*vdb, segmentActiveVoxels);
}
}
if (boss.wasInterrupted()) {
addWarning(SOP_MESSAGE, "Process was interrupted");
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 8,400 | C++ | 26.012862 | 98 | 0.587143 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Metadata.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Metadata.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <UT/UT_Interrupt.h>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
class SOP_OpenVDB_Metadata: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Metadata(OP_Network*, const char* name, OP_Operator*);
~SOP_OpenVDB_Metadata() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
class Cache: public SOP_VDBCacheOptions { OP_ERROR cookVDBSop(OP_Context&) override; };
protected:
bool updateParmsFlags() override;
};
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setTooltip("Specify a subset of the input VDBs to be modified.")
.setChoiceList(&hutil::PrimGroupMenuInput1)
.setDocumentation(
"A subset of the input VDBs to be modified"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setname", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_STRING, "name", "Name")
.setTooltip("The name of the VDB"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setclass", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
{
std::vector<std::string> items;
for (int n = 0; n < openvdb::NUM_GRID_CLASSES; ++n) {
openvdb::GridClass gridclass = static_cast<openvdb::GridClass>(n);
items.push_back(openvdb::GridBase::gridClassToString(gridclass));
items.push_back(openvdb::GridBase::gridClassToMenuName(gridclass));
}
parms.add(
hutil::ParmFactory(PRM_STRING, "class", "Class")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip("Specify how voxel values should be interpreted.")
.setDocumentation("\
How voxel values should be interpreted\n\
\n\
Fog Volume:\n\
The volume represents a density field. Values should be positive,\n\
with zero representing empty regions.\n\
Level Set:\n\
The volume is treated as a narrow-band signed distance field level set.\n\
The voxels within a certain distance—the \"narrow band width\"—of\n\
an isosurface are expected to define positive (exterior) and negative (interior)\n\
distances to the surface. Outside the narrow band, the distance value\n\
is constant and equal to the band width.\n\
Staggered Vector Field:\n\
If the volume is vector-valued, the _x_, _y_ and _z_ vector components\n\
are to be treated as lying on the respective faces of voxels,\n\
not at their centers.\n\
Other:\n\
No special meaning is assigned to the volume's data.\n"));
}
/// @todo Do we really need to expose this?
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setcreator", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_STRING, "creator", "Creator")
.setTooltip("Who (or what node) created the VDB"));
/// @todo Currently, no SOP pays attention to this setting.
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setworld", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "world", "Transform Values")
.setDefault(PRMzeroDefaults)
.setTooltip(
"For vector-valued VDBs, specify whether voxel values\n"
"are in world space and should be affected by transforms\n"
"or in local space and should not be transformed."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setvectype", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
{
std::string help =
"For vector-valued VDBs, specify an interpretation of the vectors"
" that determines how they are affected by transforms.\n";
std::vector<std::string> items;
for (int n = 0; n < openvdb::NUM_VEC_TYPES; ++n) {
const auto vectype = static_cast<openvdb::VecType>(n);
items.push_back(openvdb::GridBase::vecTypeToString(vectype));
items.push_back(openvdb::GridBase::vecTypeExamples(vectype));
help += "\n" + openvdb::GridBase::vecTypeExamples(vectype) + "\n "
+ openvdb::GridBase::vecTypeDescription(vectype) + ".";
}
parms.add(hutil::ParmFactory(PRM_STRING, "vectype", "Vector Type")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip(::strdup(help.c_str())));
}
parms.add(hutil::ParmFactory(PRM_TOGGLE, "setfloat16", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "float16", "Write 16-Bit Floats")
.setDefault(PRMzeroDefaults)
.setTooltip(
"When saving the VDB to a file, write floating-point\n"
"scalar or vector voxel values as 16-bit half floats."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "syncattrs", "Transfer Metadata to Attributes")
.setDefault(PRMoneDefaults)
.setTooltip("Transfer all standard metadata values to intrinsic primitive attributes.")
.setDocumentation(
"Transfer all standard metadata values to intrinsic primitive attributes,\n"
"whether or not any of the above values were changed."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "syncmetadata", "Transfer Attributes to Metadata")
.setDefault(PRMzeroDefaults)
.setTooltip("Transfer all standard intrinsic primitive attribute values to metadata.")
.setDocumentation(
"Transfer all standard intrinsic primitive attribute values to metadata,\n"
"whether or not any of the above values were changed."));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Metadata", SOP_OpenVDB_Metadata::factory, parms, *table)
.setNativeName("")
.addInput("Input with VDBs")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Metadata::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Modify the metadata associated with a VDB volume.\"\"\"\n\
\n\
@overview\n\
\n\
This node allows one to create and edit\n\
[metadata|http://www.openvdb.org/documentation/doxygen/codeExamples.html#sHandlingMetadata]\n\
attached to a VDB volume.\n\
Some standard VDB metadata, such as the\n\
[grid class|http://www.openvdb.org/documentation/doxygen/overview.html#secGrid],\n\
is exposed via intrinsic attributes on the primitive and can be viewed\n\
and in some cases edited either from the [geometry spreadsheet|/ref/panes/geosheet]\n\
or with the [Node:sop/attribcreate] node, but changes to attribute values\n\
made through those means are typically not propagated immediately, if at all,\n\
to a VDB's metadata.\n\
This node provides more direct access to the standard VDB metadata.\n\
\n\
@related\n\
- [OpenVDB Create|Node:sop/DW_OpenVDBCreate]\n\
- [Node:sop/attribcreate]\n\
- [Node:sop/name]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
bool
SOP_OpenVDB_Metadata::updateParmsFlags()
{
bool changed = false;
const fpreal time = 0; // No point using CHgetTime as that is unstable.
changed |= enableParm("name", bool(evalInt("setname", 0, time)));
changed |= enableParm("class", bool(evalInt("setclass", 0, time)));
changed |= enableParm("creator", bool(evalInt("setcreator", 0, time)));
changed |= enableParm("float16", bool(evalInt("setfloat16", 0, time)));
changed |= enableParm("world", bool(evalInt("setworld", 0, time)));
changed |= enableParm("vectype", bool(evalInt("setvectype", 0, time)));
return changed;
}
OP_Node*
SOP_OpenVDB_Metadata::factory(OP_Network* net,
const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Metadata(net, name, op);
}
SOP_OpenVDB_Metadata::SOP_OpenVDB_Metadata(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
OP_ERROR
SOP_OpenVDB_Metadata::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
// Get UI parameter values.
const bool
setname = evalInt("setname", 0, time),
setclass = evalInt("setclass", 0, time),
setcreator = evalInt("setcreator", 0, time),
setfloat16 = evalInt("setfloat16", 0, time),
setvectype = evalInt("setvectype", 0, time),
setworld = evalInt("setworld", 0, time),
syncattrs = evalInt("syncattrs", 0, time),
syncmetadata = evalInt("syncmetadata", 0, time);
if (!(setname || setclass || setcreator || setfloat16 || setvectype || setworld
|| syncattrs || syncmetadata))
{
return error();
}
const bool float16 = (!setfloat16 ? false : evalInt("float16", 0, time));
const bool world = (!setworld ? false : evalInt("world", 0, time));
const std::string name = (!setname ? std::string{} : evalStdString("name", time));
const std::string creator = (!setcreator ? std::string{} : evalStdString("creator", time));
const openvdb::GridClass gridclass = (!setclass ? openvdb::GRID_UNKNOWN
: openvdb::GridBase::stringToGridClass(evalStdString("class", time)));
const openvdb::VecType vectype = (!setvectype ? openvdb::VEC_INVARIANT
: openvdb::GridBase::stringToVecType(evalStdString("vectype", time)));
// Get the group of grids to be modified.
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
UT_AutoInterrupt progress("Set VDB grid metadata");
// For each VDB primitive in the given group...
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (progress.wasInterrupted()) throw std::runtime_error("was interrupted");
GU_PrimVDB* vdb = *it;
// No need to make the grid unique, since we're not modifying its voxel data.
hvdb::Grid& grid = vdb->getGrid();
// Set various grid metadata items.
if (setname) grid.setName(name);
if (setcreator) grid.setCreator(creator);
if (setfloat16) grid.setSaveFloatAsHalf(float16);
if (setvectype) grid.setVectorType(vectype);
if (setworld) grid.setIsInWorldSpace(world);
if (setclass) {
grid.setGridClass(gridclass);
// Update viewport visualization options.
switch (gridclass) {
case openvdb::GRID_LEVEL_SET:
case openvdb::GRID_FOG_VOLUME:
{
const GEO_VolumeOptions& visOps = vdb->getVisOptions();
vdb->setVisualization(
((gridclass == openvdb::GRID_LEVEL_SET) ?
GEO_VOLUMEVIS_ISO : GEO_VOLUMEVIS_SMOKE),
visOps.myIso, visOps.myDensity);
break;
}
default: break;
}
}
// Optionally transfer metadata to primitive attributes.
if (syncattrs) vdb->syncAttrsFromMetadata();
// Optionally transfer primitive attributes to metadata.
if (syncmetadata) GU_PrimVDB::createMetadataFromGridAttrs(grid, *vdb, *gdp);
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 11,886 | C++ | 39.294915 | 99 | 0.637473 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/ParmFactory.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file ParmFactory.cc
/// @author FX R&D OpenVDB team
#include "ParmFactory.h"
#include <CH/CH_Manager.h>
#include <CMD/CMD_Args.h>
#include <CMD/CMD_Manager.h>
#include <GOP/GOP_GroupParse.h>
#include <GU/GU_Detail.h>
#include <GU/GU_PrimPoly.h>
#include <GU/GU_Selection.h>
#include <GA/GA_AIFSharedStringTuple.h>
#include <GA/GA_Attribute.h>
#include <GA/GA_AttributeRef.h>
#include <HOM/HOM_Module.h>
#include <OP/OP_OperatorTable.h>
#include <PRM/PRM_Parm.h>
#include <PRM/PRM_SharedFunc.h>
#include <PY/PY_CPythonAPI.h>
#include <PY/PY_InterpreterAutoLock.h>
#include <PY/PY_Python.h>
#include <SOP/SOP_NodeParmsOptions.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_WorkArgs.h>
#include <algorithm> // for std::for_each(), std::max(), std::remove(), std::sort()
#include <cstdint> // for std::uintptr_t()
#include <cstdlib> // for std::atoi()
#include <cstring> // for std::strcmp(), ::strdup()
#include <limits>
#include <ostream>
#include <sstream>
#include <stdexcept>
namespace houdini_utils {
namespace {
// PRM_SpareData token names
// SOP input index specifier
/// @todo Is there an existing constant for this token?
char const * const kSopInputToken = "sop_input";
// Parameter documentation wiki markup
char const * const kParmDocToken = "houdini_utils::doc";
// String-encoded GA_AttributeOwner
char const * const kAttrOwnerToken = "houdini_utils::attr_owner";
// Pointer to an AttrFilterFunc
char const * const kAttrFilterToken = "houdini_utils::attr_filter";
// Add an integer value (encoded into a string) to a PRM_SpareData map
// under the given token name.
inline void
setSpareInteger(PRM_SpareData* spare, const char* token, int value)
{
if (spare && token) {
spare->addTokenValue(token, std::to_string(value).c_str());
}
}
// Retrieve the integer value with the given token name from a PRM_SpareData map.
// If no such token exists, return the specified default integer value.
inline int
getSpareInteger(const PRM_SpareData* spare, const char* token, int deflt = 0)
{
if (!spare || !token) return deflt;
char const * const str = spare->getValue(token);
return str ? std::atoi(str) : deflt;
}
// Add a pointer (encoded into a string) to a PRM_SpareData map
// under the given token name.
inline void
setSparePointer(PRM_SpareData* spare, const char* token, const void* ptr)
{
if (spare && token) {
spare->addTokenValue(token,
std::to_string(reinterpret_cast<std::uintptr_t>(ptr)).c_str());
}
}
// Retrieve the pointer with the given token name from a PRM_SpareData map.
// If no such token exists, return the specified default pointer.
inline const void*
getSparePointer(const PRM_SpareData* spare, const char* token, const void* deflt = nullptr)
{
if (!spare || !token) return deflt;
if (sizeof(std::uintptr_t) > sizeof(unsigned long long)) {
throw std::range_error{"houdini_utils::ParmFactory: can't decode pointer from string"};
}
if (const char* str = spare->getValue(token)) {
auto intPtr = static_cast<std::uintptr_t>(std::stoull(str));
return reinterpret_cast<void*>(intPtr);
}
return deflt;
}
// Copy elements from one spare data map to another,
// overwriting any existing elements with the same keys.
inline void
mergeSpareData(SpareDataMap& dst, const SpareDataMap& src)
{
for (const auto& it: src) {
dst[it.first] = it.second;
}
}
} // anonymous namespace
ParmList&
ParmList::add(const PRM_Template& p)
{
mParmVec.push_back(p);
incFolderParmCount();
return *this;
}
ParmList&
ParmList::add(const ParmFactory& f)
{
add(f.get());
return *this;
}
ParmList::SwitcherInfo*
ParmList::getCurrentSwitcher()
{
SwitcherInfo* info = nullptr;
if (!mSwitchers.empty()) {
info = &mSwitchers.back();
}
return info;
}
ParmList&
ParmList::beginSwitcher(const std::string& token, const std::string& label)
{
if (nullptr != getCurrentSwitcher()) {
incFolderParmCount();
}
SwitcherInfo info;
info.parmIdx = mParmVec.size();
info.exclusive = false;
mSwitchers.push_back(info);
// Add a switcher parameter with the given token and name, but no folders.
mParmVec.push_back(ParmFactory(PRM_SWITCHER, token, label).get());
return *this;
}
ParmList&
ParmList::beginExclusiveSwitcher(const std::string& token, const std::string& label)
{
if (nullptr != getCurrentSwitcher()) {
incFolderParmCount();
}
SwitcherInfo info;
info.parmIdx = mParmVec.size();
info.exclusive = true;
mSwitchers.push_back(info);
// Add a switcher parameter with the given token and name, but no folders.
mParmVec.push_back(ParmFactory(PRM_SWITCHER, token, label).get());
return *this;
}
ParmList&
ParmList::endSwitcher()
{
if (SwitcherInfo* info = getCurrentSwitcher()) {
if (info->folders.empty()) {
throw std::runtime_error("added switcher that has no folders");
} else {
// Replace the placeholder switcher parameter that was added to
// mParmVec in beginSwitcher() with a new parameter that has
// the correct folder count and folder info.
PRM_Template& switcherParm = mParmVec[info->parmIdx];
std::string token, label;
if (const char* s = switcherParm.getToken()) token = s;
if (const char* s = switcherParm.getLabel()) label = s;
mParmVec[info->parmIdx] =
ParmFactory(info->exclusive ? PRM_SWITCHER_EXCLUSIVE : PRM_SWITCHER,
token.c_str(), label.c_str())
.setVectorSize(int(info->folders.size()))
.setDefault(info->folders)
.get();
}
mSwitchers.pop_back();
} else {
throw std::runtime_error("endSwitcher() called with no corresponding beginSwitcher()");
}
return *this;
}
ParmList&
ParmList::addFolder(const std::string& label)
{
if (SwitcherInfo* info = getCurrentSwitcher()) {
info->folders.push_back(PRM_Default(/*numParms=*/0, ::strdup(label.c_str())));
} else {
throw std::runtime_error("added folder to nonexistent switcher");
}
return *this;
}
void
ParmList::incFolderParmCount()
{
if (SwitcherInfo* info = getCurrentSwitcher()) {
if (info->folders.empty()) {
throw std::runtime_error("added parameter to switcher that has no folders");
} else {
// If a parameter is added to this ParmList while a switcher with at least
// one folder is active, increment the folder's parameter count.
PRM_Default& def = *(info->folders.rbegin());
def.setOrdinal(def.getOrdinal() + 1);
}
}
}
PRM_Template*
ParmList::get() const
{
const size_t numParms = mParmVec.size();
PRM_Template* ret = new PRM_Template[numParms + 1];
for (size_t n = 0; n < numParms; ++n) {
ret[n] = mParmVec[n];
}
return ret;
}
////////////////////////////////////////
struct ParmFactory::Impl
{
Impl(const std::string& token, const std::string& label):
callbackFunc(0),
choicelist(nullptr),
conditional(nullptr),
defaults(PRMzeroDefaults),
multiType(PRM_MULTITYPE_NONE),
name(new PRM_Name(token.c_str(), label.c_str())),
parmGroup(0),
range(nullptr),
spareData(nullptr),
multiparms(nullptr),
typeExtended(PRM_TYPE_NONE),
vectorSize(1),
invisible(false)
{
const_cast<PRM_Name*>(name)->harden();
}
static PRM_SpareData* getSopInputSpareData(size_t inp); ///< @todo return a const pointer?
static void getAttrChoices(void* op, PRM_Name* choices, int maxChoices,
const PRM_SpareData*, const PRM_Parm*);
PRM_Callback callbackFunc;
const PRM_ChoiceList* choicelist;
const PRM_ConditionalBase* conditional;
const PRM_Default* defaults;
std::string tooltip;
PRM_MultiType multiType;
const PRM_Name* name;
int parmGroup;
const PRM_Range* range;
PRM_SpareData* spareData;
const PRM_Template* multiparms;
PRM_Type type;
PRM_TypeExtended typeExtended;
int vectorSize;
bool invisible;
static PRM_SpareData* const sSOPInputSpareData[4];
};
PRM_SpareData* const ParmFactory::Impl::sSOPInputSpareData[4] = {
&SOP_Node::theFirstInput, &SOP_Node::theSecondInput,
&SOP_Node::theThirdInput, &SOP_Node::theFourthInput};
// Return one of the predefined PRM_SpareData maps that specify a SOP input number,
// or construct new PRM_SpareData if none exists for the given input number.
PRM_SpareData*
ParmFactory::Impl::getSopInputSpareData(size_t inp)
{
if (inp < 4) return Impl::sSOPInputSpareData[inp];
auto spare = new PRM_SpareData{SOP_Node::theFirstInput};
spare->addTokenValue(kSopInputToken, std::to_string(inp).c_str());
return spare;
}
// PRM_ChoiceGenFunc invoked by ParmFactory::setAttrChoiceList()
void
ParmFactory::Impl::getAttrChoices(void* op, PRM_Name* choices, int maxChoices,
const PRM_SpareData* spare, const PRM_Parm* parm)
{
if (!op || !choices || !parm) return;
// This function can only be used in SOPs, because it calls SOP_Node::fillAttribNameMenu().
if (static_cast<OP_Node*>(op)->getOpTypeID() != SOP_OPTYPE_ID) return;
auto* sop = static_cast<SOP_Node*>(op);
// Extract the SOP input number, the attribute class, and an optional
// pointer to a filter functor from the spare data.
const int inp = getSpareInteger(spare, kSopInputToken);
const int attrOwner = getSpareInteger(spare, kAttrOwnerToken, GA_ATTRIB_INVALID);
const auto* attrFilter =
static_cast<const AttrFilterFunc*>(getSparePointer(spare, kAttrFilterToken));
// Marshal pointers to the filter functor and the parameter and SOP for which this function
// is being called into blind data that can be passed to SOP_Node::fillAttribNameMenu().
struct AttrFilterData {
const AttrFilterFunc* func;
const PRM_Parm* parm;
const SOP_Node* sop;
};
AttrFilterData cbData{attrFilter, parm, sop};
// Define a filter callback function to be passed to SOP_Node::fillAttribNameMenu().
// Because the latter uses a C-style callback mechanism, this callback must be
// equivalent to a static function pointer (as a non-capturing lambda is).
auto cb = [](const GA_Attribute* aAttr, void* aData) -> bool {
if (!aAttr) return false;
// Cast the blind data pointer supplied by SOP_Node::fillAttribNameMenu().
const auto* data = static_cast<AttrFilterData*>(aData);
if (!data || !data->func) return true; // no filter; accept all attributes
// Invoke the filter functor and return the result.
return (*(data->func))(*aAttr, *(data->parm), *(data->sop));
};
// Invoke SOP_Node::fillAttribNameMenu() for the appropriate attribute class.
switch (attrOwner) {
case GA_ATTRIB_VERTEX:
case GA_ATTRIB_POINT:
case GA_ATTRIB_PRIMITIVE:
case GA_ATTRIB_DETAIL:
if (cbData.func) {
sop->fillAttribNameMenu(choices, maxChoices,
static_cast<GA_AttributeOwner>(attrOwner), inp, cb, &cbData);
} else {
sop->fillAttribNameMenu(choices, maxChoices,
static_cast<GA_AttributeOwner>(attrOwner), inp);
}
break;
default: // all attributes
{
// To collect all classes of attributes, call SOP_Node::fillAttribNameMenu()
// once for each class. Each call appends zero or more PRM_Names to the list
// as well as an end-of-list terminator.
auto* head = choices;
int count = 0, maxCount = maxChoices;
for (auto owner:
{ GA_ATTRIB_VERTEX, GA_ATTRIB_POINT, GA_ATTRIB_PRIMITIVE, GA_ATTRIB_DETAIL })
{
int numAdded = (cbData.func ?
sop->fillAttribNameMenu(head, maxCount, owner, inp, cb, &cbData) :
sop->fillAttribNameMenu(head, maxCount, owner, inp));
if (numAdded > 0) {
// SOP_Node::fillAttribNameMenu() returns the number of entries added
// to the list, not including the terminator.
// Advance the list head pointer so that the next entry to be added
// (if any) overwrites the terminator.
count += numAdded;
head += numAdded;
maxCount -= numAdded;
}
}
if (count) {
// Sort the list by name to reproduce the behavior of SOP_Node::allAttribMenu.
std::sort(choices, choices + count,
[](const PRM_Name& n1, const PRM_Name& n2) {
return (0 > std::strcmp(n1.getToken(), n2.getToken()));
}
);
}
break;
}
}
}
////////////////////////////////////////
ParmFactory::ParmFactory(PRM_Type type, const std::string& token, const std::string& label):
mImpl(new Impl(token, label))
{
mImpl->type = type;
}
ParmFactory::ParmFactory(PRM_MultiType multiType, const std::string& token,
const std::string& label): mImpl(new Impl(token, label))
{
mImpl->multiType = multiType;
}
ParmFactory&
ParmFactory::setCallbackFunc(const PRM_Callback& f) { mImpl->callbackFunc = f; return *this; }
ParmFactory&
ParmFactory::setChoiceList(const PRM_ChoiceList* c)
{
mImpl->choicelist = c;
if (c == &PrimGroupMenuInput1) {
setSpareData(SOP_Node::getGroupSelectButton(GA_GROUP_PRIMITIVE,
nullptr, 0, &SOP_Node::theFirstInput));
} else if (c == &PrimGroupMenuInput2) {
setSpareData(SOP_Node::getGroupSelectButton(GA_GROUP_PRIMITIVE,
nullptr, 1, &SOP_Node::theSecondInput));
} else if (c == &PrimGroupMenuInput3) {
setSpareData(SOP_Node::getGroupSelectButton(GA_GROUP_PRIMITIVE,
nullptr, 2, &SOP_Node::theThirdInput));
} else if (c == &PrimGroupMenuInput4) {
setSpareData(SOP_Node::getGroupSelectButton(GA_GROUP_PRIMITIVE,
nullptr, 3, &SOP_Node::theFourthInput));
}
return *this;
}
/// @todo Merge this into setChoiceListItems() once the deprecated
/// setChoiceList() overloads have been removed.
ParmFactory&
ParmFactory::doSetChoiceList(PRM_ChoiceListType typ, const char* const* items, bool paired)
{
size_t numItems = 0;
for ( ; items[numItems] != nullptr; ++numItems) {}
if (paired) numItems >>= 1;
PRM_Name* copyOfItems = new PRM_Name[numItems + 1]; // extra item is list terminator
if (paired) {
for (size_t i = 0, n = 0; n < numItems; ++n, i += 2) {
copyOfItems[n].setToken(items[i]);
copyOfItems[n].setLabel(items[i+1]);
copyOfItems[n].harden();
}
} else {
for (size_t n = 0; n < numItems; ++n) {
UT_String idx;
idx.itoa(n);
copyOfItems[n].setToken(idx.buffer());
copyOfItems[n].setLabel(items[n]);
copyOfItems[n].harden();
}
}
mImpl->choicelist = new PRM_ChoiceList(typ, copyOfItems);
return *this;
}
/// @todo Merge this into setChoiceListItems() once the deprecated
/// setChoiceList() overloads have been removed.
ParmFactory&
ParmFactory::doSetChoiceList(PRM_ChoiceListType typ,
const std::vector<std::string>& items, bool paired)
{
const size_t numItems = items.size() >> (paired ? 1 : 0);
PRM_Name* copyOfItems = new PRM_Name[numItems + 1]; // extra item is list terminator
if (paired) {
for (size_t i = 0, n = 0; n < numItems; ++n, i += 2) {
copyOfItems[n].setToken(items[i].c_str());
copyOfItems[n].setLabel(items[i+1].c_str());
copyOfItems[n].harden();
}
} else {
for (size_t n = 0; n < numItems; ++n) {
UT_String idx;
idx.itoa(n);
copyOfItems[n].setToken(idx.buffer());
copyOfItems[n].setLabel(items[n].c_str());
copyOfItems[n].harden();
}
}
mImpl->choicelist = new PRM_ChoiceList(typ, copyOfItems);
return *this;
}
ParmFactory&
ParmFactory::setChoiceList(PRM_ChoiceListType typ, const char* const* items, bool paired)
{
return doSetChoiceList(typ, items, paired);
}
ParmFactory&
ParmFactory::setChoiceList(PRM_ChoiceListType typ,
const std::vector<std::string>& items, bool paired)
{
return doSetChoiceList(typ, items, paired);
}
ParmFactory&
ParmFactory::setChoiceListItems(PRM_ChoiceListType typ, const char* const* items)
{
return doSetChoiceList(typ, items, /*paired=*/true);
}
ParmFactory&
ParmFactory::setChoiceListItems(PRM_ChoiceListType typ, const std::vector<std::string>& items)
{
return doSetChoiceList(typ, items, /*paired=*/true);
}
ParmFactory&
ParmFactory::setGroupChoiceList(size_t inputIndex, PRM_ChoiceListType typ)
{
mImpl->choicelist = new PRM_ChoiceList(typ, PrimGroupMenu.getChoiceGenerator());
setSpareData(SOP_Node::getGroupSelectButton(GA_GROUP_PRIMITIVE, nullptr,
static_cast<int>(inputIndex), mImpl->getSopInputSpareData(inputIndex)));
return *this;
}
ParmFactory&
ParmFactory::setAttrChoiceList(size_t inputIndex, GA_AttributeOwner attrOwner,
PRM_ChoiceListType typ, AttrFilterFunc attrFilter)
{
setChoiceList(new PRM_ChoiceList{typ, Impl::getAttrChoices});
mImpl->spareData = new PRM_SpareData;
setSpareInteger(mImpl->spareData, kSopInputToken, int(inputIndex));
setSpareInteger(mImpl->spareData, kAttrOwnerToken, static_cast<int>(attrOwner));
if (attrFilter) {
setSparePointer(mImpl->spareData, kAttrFilterToken, new AttrFilterFunc{attrFilter});
}
return *this;
}
ParmFactory&
ParmFactory::setConditional(const PRM_ConditionalBase* c) { mImpl->conditional = c; return *this; }
ParmFactory&
ParmFactory::setDefault(fpreal f, const char* s, CH_StringMeaning meaning)
{
mImpl->defaults = new PRM_Default(f, s, meaning);
return *this;
}
ParmFactory&
ParmFactory::setDefault(const std::string& s, CH_StringMeaning meaning)
{
mImpl->defaults = new PRM_Default(0.0, ::strdup(s.c_str()), meaning);
return *this;
}
ParmFactory&
ParmFactory::setDefault(const std::vector<fpreal>& v)
{
const size_t numDefaults = v.size();
PRM_Default* defaults = new PRM_Default[numDefaults + 1];
for (size_t n = 0; n < numDefaults; ++n) {
defaults[n] = PRM_Default(v[n]);
}
mImpl->defaults = defaults;
return *this;
}
ParmFactory&
ParmFactory::setDefault(const std::vector<PRM_Default>& defaults)
{
const size_t numDefaults = defaults.size();
PRM_Default* copyOfDefaults = new PRM_Default[numDefaults + 1];
for (size_t n = 0; n < numDefaults; ++n) {
copyOfDefaults[n] = defaults[n];
}
mImpl->defaults = copyOfDefaults;
return *this;
}
ParmFactory&
ParmFactory::setDefault(const PRM_Default* d) { mImpl->defaults = d; return *this; }
ParmFactory&
ParmFactory::setTooltip(const char* t) { mImpl->tooltip = (t ? t : ""); return *this; }
ParmFactory&
ParmFactory::setHelpText(const char* t) { return setTooltip(t); }
ParmFactory&
ParmFactory::setDocumentation(const char* doc)
{
if (!mImpl->spareData) { mImpl->spareData = new PRM_SpareData; }
mImpl->spareData->addTokenValue(kParmDocToken, ::strdup(doc ? doc : ""));
return *this;
}
ParmFactory&
ParmFactory::setParmGroup(int n) { mImpl->parmGroup = n; return *this; }
ParmFactory&
ParmFactory::setRange(PRM_RangeFlag minFlag, fpreal minVal, PRM_RangeFlag maxFlag, fpreal maxVal)
{
mImpl->range = new PRM_Range(minFlag, minVal, maxFlag, maxVal);
return *this;
}
ParmFactory&
ParmFactory::setRange(const std::vector<PRM_Range>& ranges)
{
const size_t numRanges = ranges.size();
PRM_Range* copyOfRanges = new PRM_Range[numRanges + 1];
for (size_t n = 0; n < numRanges; ++n) {
copyOfRanges[n] = ranges[n];
}
mImpl->range = copyOfRanges;
return *this;
}
ParmFactory&
ParmFactory::setRange(const PRM_Range* r) { mImpl->range = r; return *this; }
ParmFactory&
ParmFactory::setSpareData(const SpareDataMap& items)
{
if (!items.empty()) {
if (!mImpl->spareData) { mImpl->spareData = new PRM_SpareData; }
for (SpareDataMap::const_iterator i = items.begin(), e = items.end(); i != e; ++i) {
mImpl->spareData->addTokenValue(i->first.c_str(), i->second.c_str());
}
}
return *this;
}
ParmFactory&
ParmFactory::setSpareData(const PRM_SpareData* d)
{
if (!d) {
if (mImpl->spareData) mImpl->spareData->clear();
} else {
mImpl->spareData = new PRM_SpareData{*d};
}
return *this;
}
ParmFactory&
ParmFactory::setMultiparms(const ParmList& p) { mImpl->multiparms = p.get(); return *this; }
ParmFactory&
ParmFactory::setTypeExtended(PRM_TypeExtended t) { mImpl->typeExtended = t; return *this; }
ParmFactory&
ParmFactory::setVectorSize(int n) { mImpl->vectorSize = n; return *this; }
ParmFactory&
ParmFactory::setInvisible() { mImpl->invisible = true; return *this; }
PRM_Template
ParmFactory::get() const
{
#ifdef SESI_OPENVDB
// Help is maintained separately within Houdini
const char *tooltip = nullptr;
#else
const char *tooltip = mImpl->tooltip.c_str();
#endif
PRM_Template parm;
if (mImpl->multiType != PRM_MULTITYPE_NONE) {
parm.initMulti(
mImpl->multiType,
const_cast<PRM_Template*>(mImpl->multiparms),
PRM_Template::PRM_EXPORT_MIN,
fpreal(mImpl->vectorSize),
const_cast<PRM_Name*>(mImpl->name),
const_cast<PRM_Default*>(mImpl->defaults),
const_cast<PRM_Range*>(mImpl->range),
0, // no callback
mImpl->spareData,
tooltip ? ::strdup(tooltip) : nullptr,
const_cast<PRM_ConditionalBase*>(mImpl->conditional));
} else {
parm.initialize(
mImpl->type,
mImpl->typeExtended,
PRM_Template::PRM_EXPORT_MIN,
mImpl->vectorSize,
const_cast<PRM_Name*>(mImpl->name),
const_cast<PRM_Default*>(mImpl->defaults),
const_cast<PRM_ChoiceList*>(mImpl->choicelist),
const_cast<PRM_Range*>(mImpl->range),
mImpl->callbackFunc,
mImpl->spareData,
mImpl->parmGroup,
tooltip ? ::strdup(tooltip) : nullptr,
const_cast<PRM_ConditionalBase*>(mImpl->conditional));
}
if (mImpl->invisible) {
parm.setInvisible(true);
}
return parm;
}
////////////////////////////////////////
namespace {
/// @brief Output wiki markup documentation to the given stream for
/// a (possibly nested) list of parameters.
/// @return the address of the parameter list entry one past the last parameter
/// that was documented
inline const PRM_Template*
documentParms(std::ostream& os, PRM_Template const * const parmList, int level = 0,
int numParms = std::numeric_limits<int>::max())
{
if (level > 10) return parmList; // probably something wrong if there are 10 levels of nesting
auto indent = [&level]() { return std::string(4 * std::max(0, level), ' '); };
bool hasHeading = false;
const PRM_Template* parm = parmList;
for (int parmIdx = 0;
parm && (parmIdx < numParms) && (parm->getType() != PRM_LIST_TERMINATOR);
++parmIdx, ++parm)
{
const auto parmType = parm->getType();
if (parmType == PRM_LABEL || parm->getInvisible()) continue;
const auto parmLabel = [parm]() {
UT_String lbl = parm->getLabel();
// Houdini's wiki markup parser aggressively expands square-bracketed text into
// hyperlinks. The following is one way to suppress that behavior, given that
// there doesn't appear to be any native escaping mechanism. Since we might want
// to use brackets--but probably not hyperlinks--in parameter labels, and since
// hacks like this don't render correctly in the parameter pane, we unconditionally
// "escape" brackets in parameter labels, but only in the documentation markup.
lbl.substitute("[", "[", /*all=*/true); // 91 is the ISO-8859 code for "["
lbl.substitute("]", "]", /*all=*/true); // 93 is the ISO-8859 code for "]"
return lbl;
}();
const bool hasLabel = parmLabel.isstring();
if ((parmType == PRM_SEPARATOR) || ((parmType == PRM_HEADING) && !hasLabel)) {
// A separator or empty heading removes one level of nesting.
// (There are no begin/end grouping indicators, so this is just a best guess.)
level = std::max(0, level - 1);
hasHeading = false;
continue;
}
UT_String parmDoc;
const PRM_SpareData* const spare = parm->getSparePtr();
if (spare && spare->getValue(kParmDocToken)) {
// If the parameter was documented with setDocumentation(), use that text.
// (This relies on kParmDocToken not being paired with nullptr.
// ParmFactory::setDocumentation(), at least, ensures that it isn't.)
parmDoc = spare->getValue(kParmDocToken);
// If the text is empty, suppress this parameter.
if (!parmDoc.isstring()) continue;
} else {
// Otherwise, if the parameter has a tool tip, use that.
parmDoc = parm->getHelpText();
// If the parameter has no tool tip but has a choice list, list the choices
// (except if the parameter is a toggle--toggles seem to be implemented as
// on/off choice lists).
if (!parmDoc.isstring() && (parmType.getOrdinalType() != PRM_Type::PRM_ORD_TOGGLE)) {
if (const PRM_ChoiceList* choices = parm->getChoiceListPtr()) {
for (const PRM_Name* choiceName =
const_cast<PRM_ChoiceList*>(choices)->choiceNamesPtr();
choiceName && choiceName->getToken(); ++choiceName)
{
if (const char* n = choiceName->getLabel()) {
parmDoc += (std::string{"* "} + n + "\n").c_str();
}
}
}
}
// Otherwise, show the parameter without documentation.
/// @todo Just suppress undocumented parameters?
if ((parmType != PRM_HEADING) && !parm->isMultiType() && !parmDoc.isstring()) {
parmDoc = " ";
}
}
const bool hasDoc = parmDoc.isstring();
if (parmType == PRM_HEADING) {
// Decrement the nesting level for a heading label if there was
// a previous heading. (This assumes that headings aren't nested.)
if (hasHeading) --level;
hasHeading = true;
os << indent() << parmLabel.c_str() << ":\n";
++level; // increment the nesting level below a heading
if (hasDoc) {
parmDoc.substitute("\n", ("\n" + indent()).c_str(), /*all=*/true);
os << indent() << parmDoc.c_str() << "\n\n";
}
} else if ((parmType == PRM_SWITCHER) || (parmType == PRM_SWITCHER_EXCLUSIVE)
|| (parmType == PRM_SWITCHER_REFRESH))
{
// The vector size of a switcher is the number of folders.
const int numFolders = parm->getVectorSize();
const PRM_Template* firstFolderParm = parm + 1;
const PRM_Default* deflt = parm->getFactoryDefaults();
for (int folder = 0; deflt && (folder < numFolders); ++folder, ++deflt) {
// The default values of a switcher are per-folder (member count, title) pairs.
const int numMembers = deflt->getOrdinal();
char const * const title = deflt->getString();
if (title) {
// If the folder has a title, show the title and increment
// the nesting level for the folder's members.
os << indent() << title << ":\n";
++level;
}
firstFolderParm = documentParms(os, firstFolderParm, level, numMembers);
if (title) { --level; }
}
parm = PRM_Template::getEndOfSwitcher(parm);
--parm; // decrement to compensate for loop increment
} else if (parm->isMultiType()) {
if (hasLabel) { os << indent() << parmLabel.c_str() << ":\n"; }
++level; // increment the nesting level for the members of a multiparm
if (hasDoc) {
// Add the multiparm's documentation.
parmDoc.substitute("\n", ("\n" + indent()).c_str(), /*all=*/true);
os << indent() << parmDoc.c_str() << "\n\n";
}
// Add documentation for the members of the multiparm
// (but not for members of native types such as ramps,
// since those members have only generic descriptions).
if ((parm->getMultiType() != PRM_MULTITYPE_RAMP_FLT)
&& (parm->getMultiType() != PRM_MULTITYPE_RAMP_RGB))
{
if (PRM_Template const * const subparms = parm->getMultiParmTemplate()) {
documentParms(os, subparms, level);
}
}
--level;
} else if (hasLabel && hasDoc) {
// Add this parameter only if it has both a label and documentation.
os << indent() << parmLabel.c_str() << ":\n";
++level;
parmDoc.substitute("\n", ("\n" + indent()).c_str(), /*all=*/true);
os << indent() << parmDoc.c_str() << "\n\n";
--level;
}
}
return parm;
}
/// @brief Operator class that adds the help link. Used by the OpFactory.
class OP_OperatorDW: public OP_Operator
{
public:
OP_OperatorDW(
OpFactory::OpFlavor flavor,
const char* name,
const char* english,
OP_Constructor construct,
PRM_Template* multiparms,
const char* operatorTableName,
unsigned minSources,
unsigned maxSources,
CH_LocalVariable* variables,
unsigned flags,
const char** inputlabels,
const std::string& helpUrl,
const std::string& doc)
: OP_Operator(name, english, construct, multiparms,
operatorTableName,
minSources, maxSources, variables, flags, inputlabels)
, mHelpUrl(helpUrl)
{
#ifndef SESI_OPENVDB
// Generate help page markup for this operator if the help URL is empty
// and the documentation string is nonempty.
if (mHelpUrl.empty() && !doc.empty()) {
UT_String flavorStr{OpFactory::flavorToString(flavor)};
flavorStr.toLower();
std::ostringstream os;
os << "= " << english << " =\n\n"
<< "#type: node\n"
<< "#context: " << flavorStr << "\n"
<< "#internal: " << name << "\n\n"
<< doc << "\n\n";
{
std::ostringstream osParm;
documentParms(osParm, multiparms);
const std::string parmDoc = osParm.str();
if (!parmDoc.empty()) {
os << "@parameters\n\n" << parmDoc;
}
}
const_cast<std::string*>(&mDoc)->assign(os.str());
}
#endif
}
~OP_OperatorDW() override {}
bool getOpHelpURL(UT_String& url) override { url = mHelpUrl; return !mHelpUrl.empty(); }
bool getHDKHelp(UT_String& txt) const override
{
if (!mHelpUrl.empty()) return false; // URL takes precedence over help text
txt = mDoc;
txt.hardenIfNeeded();
return !mDoc.empty();
}
#ifndef SESI_OPENVDB
bool getVersion(UT_String &version) override
{
auto it = spareData().find("operatorversion");
if (it != spareData().end()) {
version = it->second;
return true;
}
return OP_Operator::getVersion(version);
}
#endif
const SpareDataMap& spareData() const { return mSpareData; }
SpareDataMap& spareData() { return mSpareData; }
private:
const std::string mHelpUrl, mDoc;
SpareDataMap mSpareData;
};
class OpFactoryVerb: public SOP_NodeVerb
{
public:
OpFactoryVerb(const std::string& name, SOP_NodeVerb::CookMode cookMode,
const OpFactory::CacheAllocFunc& allocator, PRM_Template* parms)
: mName{name}
, mCookMode{cookMode}
, mAllocator{allocator}
, mParms{parms}
{}
SOP_NodeParms* allocParms() const override { return new SOP_NodeParmsOptions{mParms}; }
SOP_NodeCache* allocCache() const override { return mAllocator(); }
void setName(const std::string& name) { mName = name; }
UT_StringHolder name() const override { return mName; }
CookMode cookMode(const SOP_NodeParms*) const override { return mCookMode; }
void cook(const CookParms& cookParms) const override
{
if (auto* cache = static_cast<SOP_NodeCacheOptions*>(cookParms.cache())) {
cache->doCook(this, cookParms);
}
}
private:
std::string mName;
SOP_NodeVerb::CookMode mCookMode;
OpFactory::CacheAllocFunc mAllocator;
PRM_Template* mParms;
}; // class OpFactoryVerb
} // anonymous namespace
////////////////////////////////////////
struct OpFactory::Impl
{
Impl(const std::string& english, OP_Constructor& constructor, PRM_Template* parms,
OP_OperatorTable& table, OpFactory::OpFlavor flavor):
mFlavor(flavor),
mEnglish(english),
mConstruct(constructor),
mTable(&table),
mParms(parms),
mObsoleteParms(nullptr),
mMaxSources(0),
mVariables(nullptr),
mFlags(0)
{
}
~Impl()
{
std::for_each(mInputLabels.begin(), mInputLabels.end(), ::free);
// Note: In get(), mOptInputLabels are appended to mInputLabels.
}
void init(const OpFactory& factory, OpPolicyPtr policy)
{
// Because mPolicy is supplied by this Impl's parent OpFactory
// (which knows which OpPolicy subclass to use), initialization
// of the following members must be postponed until both
// the OpFactory and this Impl have been fully constructed.
mPolicy = policy;
mName = mPolicy->getName(factory);
mLabelName = mPolicy->getLabelName(factory);
mIconName = mPolicy->getIconName(factory);
mHelpUrl = mPolicy->getHelpURL(factory);
mFirstName = mPolicy->getFirstName(factory);
mTabSubMenuPath = mPolicy->getTabSubMenuPath(factory);
initScripting();
}
OP_OperatorDW* get()
{
// Get the number of required inputs.
const unsigned minSources = unsigned(mInputLabels.size());
// Append optional input labels to required input labels.
mInputLabels.insert(mInputLabels.end(),
mOptInputLabels.begin(), mOptInputLabels.end());
// Ensure that the maximum number of inputs is at least as large
// as the number of labeled inputs.
mMaxSources = std::max<unsigned>(unsigned(mInputLabels.size()), mMaxSources);
mInputLabels.push_back(nullptr);
OP_OperatorDW* op = new OP_OperatorDW(mFlavor, mName.c_str(), mLabelName.c_str(),
mConstruct, mParms,
UTisstring(mOperatorTableName.c_str()) ? mOperatorTableName.c_str() : 0,
minSources, mMaxSources, mVariables, mFlags,
const_cast<const char**>(&mInputLabels[0]), mHelpUrl, mDoc);
if (!mIconName.empty()) op->setIconName(mIconName.c_str());
if (!mTabSubMenuPath.empty()) op->setOpTabSubMenuPath(mTabSubMenuPath.c_str());
if (mObsoleteParms != nullptr) op->setObsoleteTemplates(mObsoleteParms);
if (mVerb) {
// reset the name in case the internal name has changed
mVerb->setName(mName);
SOP_NodeVerb::registerVerb(mVerb);
}
mergeSpareData(op->spareData(), mSpareData);
return op;
}
void initScripting()
{
// Install an HScript command to retrieve spare data from operators.
if (auto* cmgr = CMD_Manager::getContext()) {
if (!cmgr->isCommandDefined(kSpareDataCmdName)) {
cmgr->installCommand(kSpareDataCmdName, "", cmdGetOperatorSpareData);
}
}
// Install Python functions to retrieve spare data from operators.
static bool sDidInstallHOMModule = false;
if (!sDidInstallHOMModule) {
// Install a _dwhoudiniutils module with a NodeType_spareData() function.
static PY_PyMethodDef sMethods[] = {
{"NodeType_spareData", homGetOperatorSpareData, PY_METH_VARARGS(), ""},
{ nullptr, nullptr, 0, nullptr }
};
{
PY_InterpreterAutoLock interpreterLock;
PY_Py_InitModule("_dwhoudiniutils", sMethods);
sDidInstallHOMModule = true;
}
// Add methods to the hou.NodeType class.
PYrunPythonStatementsAndExpectNoErrors("\
def _spareData(self, name):\n\
'''\n\
spareData(name) -> str or None\n\
\n\
Return the spare data with the given name, or None\n\
if no data with that name is defined for this node type.\n\
\n\
Currently, only node types defined with OpenVDB's OpFactory\n\
can have spare data. See www.openvdb.org for more information.\n\
'''\n\
import _dwhoudiniutils\n\
return _dwhoudiniutils.NodeType_spareData(self.category().name(), self.name(), name)\n\
\n\
def _spareDataDict(self):\n\
'''\n\
spareDataDict() -> dict of str to str\n\
\n\
Return a dictionary of the spare data for this node type.\n\
\n\
Currently, only node types defined with OpenVDB's OpFactory\n\
can have spare data. See www.openvdb.org for more information.\n\
'''\n\
import _dwhoudiniutils\n\
return _dwhoudiniutils.NodeType_spareData(self.category().name(), self.name())\n\
\n\
nt = __import__('hou').NodeType\n\
nt.spareData = _spareData\n\
nt.spareDataDict = _spareDataDict\n\
del nt, _spareData, _spareDataDict\n");
}
}
// HScript callback to retrieve spare data from an OP_OperatorDW-derived operator
static void cmdGetOperatorSpareData(CMD_Args& args)
{
// The operator's network type ("Sop", "Dop", etc.)
const char* const networkType = args[1];
// The operator's name
const char* const opName = args[2];
// An optional spare data token
const char* const token = args[3];
if (!networkType || !opName) {
/// @todo Install this as a command.help file?
args.out() << kSpareDataCmdName << "\n\
\n\
List spare data associated with an operator type.\n\
\n\
USAGE\n\
" << kSpareDataCmdName << " <networktype> <opname> [<token>]\n\
\n\
When the token is omitted, all (token, value) pairs\n\
associated with the operator type are displayed.\n\
\n\
Currently, only operator types defined with OpenVDB's OpFactory\n\
can have spare data. See www.openvdb.org for more information.\n\
\n\
EXAMPLES\n\
> " << kSpareDataCmdName << " Sop DW_OpenVDBConvert\n\
lists all spare data associated with the Convert VDB SOP\n\
> " << kSpareDataCmdName << " Sop DW_OpenVDBClip nativename\n\
displays the VDB Clip SOP's native name\n\
\n";
return;
}
// Retrieve the operator table for the specified network type.
const OP_OperatorTable* table = nullptr;
{
OP_OperatorTableList opTables;
OP_OperatorTable::getAllOperatorTables(opTables);
for (const auto& t: opTables) {
if (t && (t->getName() == networkType)) {
table = t;
break;
}
}
}
if (table) {
if (const auto* op = table->getOperator(opName)) {
// Retrieve the operator's spare data map.
// (The map is empty for operators that don't support spare data.)
const auto& spare = getOperatorSpareData(*op);
if (token) {
// If a token was provided and it exists in the map,
// print the corresponding value.
const auto it = spare.find(token);
if (it != spare.end()) {
args.out() << it->second << "\n";
}
} else {
// If no token was provided, print all of the operator's
// (token, value) pairs.
for (const auto& it: spare) {
args.out() << it.first << " " << it.second << "\n";
}
}
}
}
}
// Python callback to retrieve spare data from an OP_OperatorDW-derived operator
static PY_PyObject* homGetOperatorSpareData(PY_PyObject* self, PY_PyObject* args)
{
// The operator's network type ("Sop", "Dop", etc.)
const char* networkType = nullptr;
// The operator's name
const char* opName = nullptr;
// An optional spare data token
const char* token = nullptr;
if (!PY_PyArg_ParseTuple(args, "ss|s", &networkType, &opName, &token)) {
return nullptr;
}
if (!networkType || !opName) {
return PY_Py_None();
}
try {
HOM_AutoLock homLock;
// Retrieve the operator table for the specified network type.
const OP_OperatorTable* table = nullptr;
{
OP_OperatorTableList opTables;
OP_OperatorTable::getAllOperatorTables(opTables);
for (const auto& t: opTables) {
if (t && (t->getName() == networkType)) {
table = t;
break;
}
}
}
if (table) {
if (const auto* op = table->getOperator(opName)) {
// Retrieve the operator's spare data map.
// (The map is empty for operators that don't support spare data.)
const auto& spare = getOperatorSpareData(*op);
if (token) {
// If a token was provided and it exists in the map,
// return the corresponding value.
const auto it = spare.find(token);
if (it != spare.end()) {
return PY_Py_BuildValue("s", it->second.c_str());
}
} else {
// If no token was provided, return a dictionary
// of all of the operator's (token, value) pairs.
if (auto* dict = PY_Py_BuildValue("{}")) {
for (const auto& it: spare) {
PY_PyDict_SetItemString(dict, it.first.c_str(),
PY_Py_BuildValue("s", it.second.c_str()));
}
return dict;
}
}
}
}
} catch (HOM_Error&) {
}
return PY_Py_None();
}
OpPolicyPtr mPolicy; // polymorphic, so stored by pointer
OpFactory::OpFlavor mFlavor;
std::string mEnglish, mName, mLabelName, mIconName, mHelpUrl, mDoc, mOperatorTableName;
std::string mFirstName, mTabSubMenuPath;
OP_Constructor mConstruct;
OP_OperatorTable* mTable;
PRM_Template *mParms, *mObsoleteParms;
unsigned mMinSources;
unsigned mMaxSources;
CH_LocalVariable* mVariables;
unsigned mFlags;
std::vector<std::string> mAliases;
std::vector<char*> mInputLabels, mOptInputLabels;
OpFactoryVerb* mVerb = nullptr;
bool mInvisible = false;
SpareDataMap mSpareData;
static constexpr auto* kSpareDataCmdName = "opsparedata";
};
OpFactory::OpFactory(const std::string& english, OP_Constructor ctor,
ParmList& parms, OP_OperatorTable& table, OpFlavor flavor)
{
this->init(OpPolicyPtr(new OpPolicy), english, ctor, parms, table, flavor);
}
OpFactory::~OpFactory()
{
mImpl->mTable->addOperator(mImpl->get());
for (size_t n = 0, N = mImpl->mAliases.size(); n < N; ++n) {
const std::string& alias = mImpl->mAliases[n];
if (!alias.empty()) {
mImpl->mTable->setOpAlias(/*original=*/mImpl->mName.c_str(), alias.c_str());
}
}
// apply first name if set
if (!mImpl->mFirstName.empty()) {
mImpl->mTable->setOpFirstName(mImpl->mName.c_str(), mImpl->mFirstName.c_str());
}
// hide node if marked as invisible
if (mImpl->mInvisible) {
mImpl->mTable->addOpHidden(mImpl->mName.c_str());
}
}
void
OpFactory::init(OpPolicyPtr policy, const std::string& english, OP_Constructor ctor,
ParmList& parms, OP_OperatorTable& table, OpFlavor flavor)
{
mImpl.reset(new Impl(english, ctor, parms.get(), table, flavor));
mImpl->init(*this, policy);
}
//static
std::string
OpFactory::flavorToString(OpFlavor flavor)
{
switch (flavor) {
case SOP: return "SOP";
case POP: return "POP";
case ROP: return "ROP";
case VOP: return "VOP";
case HDA: return "HDA";
}
return "";
}
OpFactory::OpFlavor
OpFactory::flavor() const
{
return mImpl->mFlavor;
}
std::string
OpFactory::flavorString() const
{
return flavorToString(mImpl->mFlavor);
}
const std::string&
OpFactory::name() const
{
return mImpl->mName;
}
const std::string&
OpFactory::english() const
{
return mImpl->mEnglish;
}
const std::string&
OpFactory::iconName() const
{
return mImpl->mIconName;
}
const std::string&
OpFactory::helpURL() const
{
return mImpl->mHelpUrl;
}
const std::string&
OpFactory::documentation() const
{
return mImpl->mDoc;
}
const OP_OperatorTable&
OpFactory::table() const
{
return *mImpl->mTable;
}
OP_OperatorTable&
OpFactory::table()
{
return *mImpl->mTable;
}
OpFactory&
OpFactory::addAlias(const std::string& english)
{
if (!english.empty()) {
this->addAliasVerbatim(mImpl->mPolicy->getName(*this, english));
}
return *this;
}
OpFactory&
OpFactory::addAliasVerbatim(const std::string& name)
{
if (!name.empty()) {
mImpl->mAliases.push_back(name);
}
return *this;
}
OpFactory&
OpFactory::setDocumentation(const std::string& doc)
{
mImpl->mDoc = doc;
return *this;
}
OpFactory&
OpFactory::addInput(const std::string& name)
{
mImpl->mInputLabels.push_back(::strdup(name.c_str()));
return *this;
}
OpFactory&
OpFactory::addOptionalInput(const std::string& name)
{
mImpl->mOptInputLabels.push_back(::strdup(name.c_str()));
return *this;
}
OpFactory&
OpFactory::setMaxInputs(unsigned n) { mImpl->mMaxSources = n; return *this; }
OpFactory&
OpFactory::setObsoleteParms(const ParmList& parms)
{
delete mImpl->mObsoleteParms;
mImpl->mObsoleteParms = parms.get();
return *this;
}
OpFactory&
OpFactory::setLocalVariables(CH_LocalVariable* v) { mImpl->mVariables = v; return *this; }
OpFactory&
OpFactory::setFlags(unsigned f) { mImpl->mFlags = f; return *this; }
OpFactory&
OpFactory::setInternalName(const std::string& name)
{
mImpl->mName = name;
return *this;
}
OpFactory&
OpFactory::setOperatorTable(const std::string& name)
{
mImpl->mOperatorTableName = name;
return *this;
}
OpFactory&
OpFactory::setVerb(SOP_NodeVerb::CookMode cookMode, const CacheAllocFunc& allocator)
{
if (flavor() != SOP) {
throw std::runtime_error{"expected operator of type SOP, got " + flavorToString(flavor())};
}
if (!allocator) throw std::invalid_argument{"must provide a cache allocator function"};
mImpl->mVerb = new OpFactoryVerb{name(), cookMode, allocator, mImpl->mParms};
return *this;
}
OpFactory&
OpFactory::setInvisible()
{
mImpl->mInvisible = true;
return *this;
}
OpFactory&
OpFactory::addSpareData(const SpareDataMap& spare)
{
mergeSpareData(mImpl->mSpareData, spare);
return *this;
}
////////////////////////////////////////
const SpareDataMap&
getOperatorSpareData(const OP_Operator& op)
{
static const SpareDataMap sNoSpareData;
if (const auto* opdw = dynamic_cast<const OP_OperatorDW*>(&op)) {
return opdw->spareData();
}
return sNoSpareData;
}
void
addOperatorSpareData(OP_Operator& op, SpareDataMap& spare)
{
if (auto* opdw = dynamic_cast<OP_OperatorDW*>(&op)) {
mergeSpareData(opdw->spareData(), spare);
} else {
throw std::runtime_error("spare data cannot be added to the \""
+ op.getName().toStdString() + "\" operator");
}
}
////////////////////////////////////////
//virtual
std::string
OpPolicy::getName(const OpFactory&, const std::string& english)
{
UT_String s(english);
s.forceValidVariableName();
return s.toStdString();
}
//virtual
std::string
OpPolicy::getLabelName(const OpFactory& factory)
{
return factory.english();
}
////////////////////////////////////////
const PRM_ChoiceList PrimGroupMenuInput1 = SOP_Node::primGroupMenu;
const PRM_ChoiceList PrimGroupMenuInput2 = SOP_Node::primGroupMenu;
const PRM_ChoiceList PrimGroupMenuInput3 = SOP_Node::primGroupMenu;
const PRM_ChoiceList PrimGroupMenuInput4 = SOP_Node::primGroupMenu;
const PRM_ChoiceList PrimGroupMenu = SOP_Node::primGroupMenu;
} // namespace houdini_utils
| 50,328 | C++ | 31.077119 | 99 | 0.602746 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Diagnostics.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Diagnostics.cc
///
/// @author FX R&D OpenVDB team
///
/// @brief Perform diagnostics on VDB volumes to detect potential issues.
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/Utils.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb/math/Math.h> // Tolerance, isApproxEqual and isFinite
#include <openvdb/math/Operators.h> // ISGradientNormSqrd
#include <openvdb/tools/LevelSetRebuild.h>
#include <openvdb/tools/LevelSetTracker.h> // LevelSetTracker::normalize
#include <UT/UT_Interrupt.h>
#include <UT/UT_UniquePtr.h>
#include <PRM/PRM_Parm.h>
#include <memory>
#include <string>
#include <sstream>
#include <type_traits>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
////////////////////////////////////////
// Local Utility Methods
namespace {
////////////////////////////////////////
// Tests
struct AlwaysFalse {
template<typename Iterator>
bool operator()(const Iterator&) const { return false; }
};
struct FiniteValue {
template<typename Iterator>
bool operator()(const Iterator& it) const { return openvdb::math::isFinite(*it); }
};
template<typename ValueType>
struct ApproxEqual {
ApproxEqual(const ValueType& val,
const ValueType& tol = openvdb::math::Tolerance<ValueType>::value())
: mValue(val), mTol(tol) {}
template<typename Iterator>
bool operator()(const Iterator& it) const {
return openvdb::math::isApproxEqual(mValue, *it, mTol);
}
const ValueType mValue, mTol;
};
template<typename ValueType>
struct AbsApproxEqual {
AbsApproxEqual(const ValueType& val,
const ValueType& tol = openvdb::math::Tolerance<ValueType>::value())
: mValue(openvdb::math::Abs(val)), mTol(tol) {}
template<typename Iterator>
bool operator()(const Iterator& it) const {
return openvdb::math::isApproxEqual(mValue, openvdb::math::Abs(*it), mTol);
}
const ValueType mValue, mTol;
};
template<typename ValueType>
struct AbsLessThan {
AbsLessThan(ValueType val) : mValue(openvdb::math::Abs(val)) {}
template<typename Iterator>
bool operator()(const Iterator& it) const {
return !(ValueType(openvdb::math::Abs(*it)) < mValue);
}
const ValueType mValue;
};
template<typename T>
inline float toFloat(const T s) { return float(s); }
template<typename T>
inline float toFloat(const openvdb::math::Vec3<T> v) { return float(v[0]); }
struct InRange {
InRange(float minValue, float maxValue) : mMin(minValue), mMax(maxValue) {}
template<typename Iterator>
bool operator()(const Iterator& it) const { return test(*it); }
template<typename T>
bool test(const T& s) const { return !(s < T(mMin) || T(mMax) < s); }
template<typename T>
bool test(const openvdb::math::Vec3<T>& v) const { return test(v.length()); }
const float mMin, mMax;
};
template<typename TreeType>
struct GradientNorm {
using ValueType = typename TreeType::ValueType;
GradientNorm(const TreeType& tree, double voxelSize, ValueType tol)
: mAcc(tree), mScale(ValueType(1.0 / voxelSize)), mTol(tol) {}
GradientNorm(const GradientNorm& rhs)
: mAcc(rhs.mAcc.tree()), mScale(rhs.mScale), mTol(rhs.mTol) {}
template<typename Iterator>
bool operator()(const Iterator& it) {
const openvdb::Coord ijk = it.getCoord();
// ignore voxels adjacent to the active narrow band boundary
if (!mAcc.isValueOn(ijk.offsetBy(-1, 0, 0))) return true;
if (!mAcc.isValueOn(ijk.offsetBy( 1, 0, 0))) return true;
if (!mAcc.isValueOn(ijk.offsetBy( 0,-1, 0))) return true;
if (!mAcc.isValueOn(ijk.offsetBy( 0, 1, 0))) return true;
if (!mAcc.isValueOn(ijk.offsetBy( 0, 0,-1))) return true;
if (!mAcc.isValueOn(ijk.offsetBy( 0, 0, 1))) return true;
return openvdb::math::isApproxEqual(ValueType(1.0), gradientNorm(ijk, mScale), mTol);
}
template<typename T>
inline T
gradientNorm(const openvdb::Coord& ijk, const T scale) {
return scale * T(std::sqrt(double(
openvdb::math::ISGradientNormSqrd<openvdb::math::FIRST_BIAS>::result(mAcc, ijk))));
}
/// @{
// The gradient magnitude test is applied only to scalar, floating-point grids,
// but this class needs to compile for all grid types.
template<typename T>
inline openvdb::math::Vec3<T>
gradientNorm(const openvdb::Coord&, const openvdb::math::Vec3<T>) {
return openvdb::math::Vec3<T>(0);
}
inline bool gradientNorm(const openvdb::Coord&, bool) { return false; }
/// @}
private:
GradientNorm& operator=(const GradientNorm&); // disable assignment
openvdb::tree::ValueAccessor<const TreeType> mAcc;
const ValueType mScale, mTol;
};
template<typename TreeType>
struct SameSign {
using ValueType = typename TreeType::ValueType;
SameSign(const TreeType& tree) : mAcc(tree) {}
SameSign(const SameSign& rhs) : mAcc(rhs.mAcc.tree()) {}
template<typename Iterator>
bool operator()(const Iterator& it) {
ValueType val;
const bool state = mAcc.probeValue(it.getCoord(), val);
return state ? true : (val < ValueType(0)) == (*it < ValueType(0));
}
private:
SameSign& operator=(const SameSign&); // disable assignment
openvdb::tree::ValueAccessor<const TreeType> mAcc;
};
////////////////////////////////////////
/// @brief Visits values and performs tests
template<typename GridType>
struct Visitor
{
enum ValueKind { TILES_AND_VOXELS, TILES, VOXELS };
enum ValueState { ALL_VALUES, ACTIVE_VALUES, INACTIVE_VALUES };
using TreeType = typename GridType::TreeType;
using LeafNodeType = typename TreeType::LeafNodeType;
using RootNodeType = typename TreeType::RootNodeType;
using NodeChainType = typename RootNodeType::NodeChainType;
using InternalNodeType = typename NodeChainType::template Get<1>;
using BoolTreeType = typename TreeType::template ValueConverter<bool>::Type;
using BoolTreePtr = typename BoolTreeType::Ptr;
//////////
Visitor(const TreeType& tree) : mTree(tree), mValueMask(new BoolTreeType(false))
{
tree.getNodes(mLeafNodes);
tree.getNodes(mInternalNodes);
}
BoolTreePtr& valueMask() { return mValueMask; }
std::string invalidValuesInfo() const
{
std::stringstream info;
if (!mValueMask->empty()) {
info << "invalid: ";
const size_t voxelCount = size_t(mValueMask->activeLeafVoxelCount());
if (voxelCount > 0) info << voxelCount << " voxels ";
const size_t tileCount = size_t(mValueMask->activeTileCount());
if (tileCount > 0) {
if (voxelCount > 0) info << "& ";
info << tileCount << " tiles";
}
}
return info.str();
}
template<typename TestType>
bool run(ValueKind kind, const ValueState& state, const TestType& test)
{
mValueMask.reset(new BoolTreeType(false));
if (kind == TILES_AND_VOXELS || kind == VOXELS) {
LeafNodeReduction<TestType> op(state, &mLeafNodes[0], test, *mValueMask);
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, mLeafNodes.size()), op);
}
if (kind == TILES_AND_VOXELS || kind == TILES) {
InternalNodeReduction<TestType> op(state, &mInternalNodes[0], test, *mValueMask);
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, mInternalNodes.size()), op);
TestType myTest(test);
if (state == ACTIVE_VALUES) {
typename TreeType::ValueOnCIter it(mTree);
it.setMaxDepth(TreeType::ValueOnCIter::LEAF_DEPTH - 2);
for ( ; it; ++it) {
if (!myTest(it)) {
mValueMask->fill(it.getBoundingBox(), true);
}
}
} else if (state == INACTIVE_VALUES) {
typename TreeType::ValueOffCIter it(mTree);
it.setMaxDepth(TreeType::ValueOffCIter::LEAF_DEPTH - 2);
for ( ; it; ++it) {
if (!myTest(it)) {
mValueMask->fill(it.getBoundingBox(), true);
}
}
} else {
typename TreeType::ValueAllCIter it(mTree);
it.setMaxDepth(TreeType::ValueAllCIter::LEAF_DEPTH - 2);
for ( ; it; ++it) {
if (!myTest(it)) {
mValueMask->fill(it.getBoundingBox(), true);
}
}
}
}
return mValueMask->empty(); // passed if mask is empty
}
private:
template<typename TestType>
struct LeafNodeReduction
{
LeafNodeReduction(const ValueState& state, const LeafNodeType ** nodes,
const TestType& test, BoolTreeType& mask)
: mState(state), mNodes(nodes), mPrimMask(&mask), mTempMask(false),
mMask(mPrimMask ? mPrimMask : &mTempMask), mTest(test)
{}
LeafNodeReduction(LeafNodeReduction& other, tbb::split)
: mState(other.mState), mNodes(other.mNodes), mPrimMask(other.mPrimMask),
mTempMask(false), mMask(&mTempMask), mTest(other.mTest)
{}
void join(LeafNodeReduction& other) { mMask->merge(*other.mMask); }
void operator()(const tbb::blocked_range<size_t>& range) {
openvdb::tree::ValueAccessor<BoolTreeType> mask(*mMask);
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
const LeafNodeType& node = *mNodes[n];
if (mState == ACTIVE_VALUES) {
for (typename LeafNodeType::ValueOnCIter it = node.cbeginValueOn(); it; ++it) {
if (!mTest(it)) {
mask.setValueOn(it.getCoord());
}
}
} else if (mState == INACTIVE_VALUES) {
for (typename LeafNodeType::ValueOffCIter it = node.cbeginValueOff();
it; ++it)
{
if (!mTest(it)) {
mask.setValueOn(it.getCoord());
}
}
} else {
for (typename LeafNodeType::ValueAllCIter it=node.cbeginValueAll(); it; ++it) {
if (!mTest(it)) {
mask.setValueOn(it.getCoord());
}
}
}
}
}
private:
ValueState mState;
LeafNodeType const * const * const mNodes;
BoolTreeType * const mPrimMask;
BoolTreeType mTempMask;
BoolTreeType * const mMask;
TestType mTest;
}; // struct LeafNodeReduction
template<typename TestType>
struct InternalNodeReduction
{
InternalNodeReduction(const ValueState& state, const InternalNodeType** nodes,
const TestType& test, BoolTreeType& mask)
: mState(state), mNodes(nodes), mPrimMask(&mask), mTempMask(false),
mMask(mPrimMask ? mPrimMask : &mTempMask), mTest(test)
{}
InternalNodeReduction(InternalNodeReduction& other, tbb::split)
: mState(other.mState), mNodes(other.mNodes), mPrimMask(other.mPrimMask),
mTempMask(false), mMask(&mTempMask), mTest(other.mTest)
{}
void join(InternalNodeReduction& other) { mMask->merge(*other.mMask); }
void operator()(const tbb::blocked_range<size_t>& range) {
openvdb::Coord ijk;
const int dim = int(InternalNodeType::ChildNodeType::DIM) - 1;
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
const InternalNodeType& node = *mNodes[n];
if (mState == ACTIVE_VALUES) {
for (typename InternalNodeType::ValueOnCIter it = node.cbeginValueOn();
it; ++it)
{
if (!node.isChildMaskOn(it.pos()) && !mTest(it)) {
ijk = it.getCoord();
mMask->fill(openvdb::CoordBBox(ijk, ijk.offsetBy(dim)), true);
}
}
} else if (mState == INACTIVE_VALUES) {
for (typename InternalNodeType::ValueOffCIter it = node.cbeginValueOff();
it; ++it)
{
if (!node.isChildMaskOn(it.pos()) && !mTest(it)) {
ijk = it.getCoord();
mMask->fill(openvdb::CoordBBox(ijk, ijk.offsetBy(dim)), true);
}
}
} else {
for (typename InternalNodeType::ValueAllCIter it = node.cbeginValueAll();
it; ++it)
{
if (!node.isChildMaskOn(it.pos()) && !mTest(it)) {
ijk = it.getCoord();
mMask->fill(openvdb::CoordBBox(ijk, ijk.offsetBy(dim)), true);
}
}
}
}
}
private:
ValueState mState;
InternalNodeType const * const * const mNodes;
BoolTreeType * const mPrimMask;
BoolTreeType mTempMask;
BoolTreeType * const mMask;
TestType mTest;
}; // struct InternalNodeReduction
const TreeType& mTree;
BoolTreePtr mValueMask;
std::vector<const LeafNodeType*> mLeafNodes;
std::vector<const InternalNodeType*> mInternalNodes;
}; // struct Visitor
////////////////////////////////////////
// HDK Points With Values Create and Transfer
template<typename BoolLeafNodeType>
struct GetPoints
{
GetPoints(const BoolLeafNodeType ** maskNodes, UT_Vector3* points,
const size_t* offsetTable, const openvdb::math::Transform& xform)
: mMaskNodes(maskNodes)
, mPoints(points)
, mOffsetTable(offsetTable)
, mXform(xform)
{
}
void operator()(const tbb::blocked_range<size_t>& range) const {
openvdb::Vec3d xyz;
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
const BoolLeafNodeType& maskNode = *mMaskNodes[n];
UT_Vector3* points = &mPoints[mOffsetTable[n]];
size_t idx = 0;
for (typename BoolLeafNodeType::ValueOnCIter it = maskNode.cbeginValueOn(); it; ++it) {
xyz = mXform.indexToWorld(it.getCoord());
UT_Vector3& pos = points[idx++];
pos[0] = UT_Vector3::value_type(xyz[0]);
pos[1] = UT_Vector3::value_type(xyz[1]);
pos[2] = UT_Vector3::value_type(xyz[2]);
}
}
}
BoolLeafNodeType const * const * const mMaskNodes;
UT_Vector3 * const mPoints;
size_t const * const mOffsetTable;
openvdb::math::Transform mXform;
}; // struct GetPoints
template<typename BoolTreeType>
inline size_t
getPoints(const openvdb::math::Transform& xform, const BoolTreeType& mask,
UT_UniquePtr<UT_Vector3[]>& points)
{
using BoolLeafNodeType = typename BoolTreeType::LeafNodeType;
std::vector<const BoolLeafNodeType*> nodes;
mask.getNodes(nodes);
const size_t tileCount = mask.activeTileCount();
size_t voxelCount = 0, totalCount = tileCount;
if (!nodes.empty()) {
UT_UniquePtr<size_t[]> offsetTable(new size_t[nodes.size()]);
for (size_t n = 0, N = nodes.size(); n < N; ++n) {
offsetTable[n] = voxelCount;
voxelCount += nodes[n]->onVoxelCount();
}
totalCount += voxelCount;
points.reset(new UT_Vector3[totalCount]);
tbb::parallel_for(tbb::blocked_range<size_t>(0, nodes.size()),
GetPoints<BoolLeafNodeType>(&nodes[0], points.get(), offsetTable.get(), xform));
}
if (tileCount > 0) {
if (!points) {
points.reset(new UT_Vector3[tileCount]);
}
openvdb::Vec3d xyz;
typename BoolTreeType::ValueOnCIter it(mask);
it.setMaxDepth(BoolTreeType::ValueOnCIter::LEAF_DEPTH - 1);
for (size_t idx = voxelCount; it; ++it, ++idx) {
xyz = xform.indexToWorld(it.getCoord());
UT_Vector3& pos = points[idx];
pos[0] = UT_Vector3::value_type(xyz[0]);
pos[1] = UT_Vector3::value_type(xyz[1]);
pos[2] = UT_Vector3::value_type(xyz[2]);
}
}
return totalCount;
}
inline GA_Offset
transferPoints(GU_Detail& detail, const UT_UniquePtr<UT_Vector3[]>& points, size_t pointCount)
{
const GA_Offset startOffset = detail.getNumPointOffsets();
detail.appendPointBlock(pointCount);
GA_Offset offset = startOffset;
for (size_t n = 0, N = pointCount; n < N; ++n) {
detail.setPos3(offset++, points[n]);
}
return startOffset;
}
template<typename TreeType>
struct GetValues
{
using ValueType = typename TreeType::ValueType;
using BoolTreeType = typename TreeType::template ValueConverter<bool>::Type;
using BoolLeafNodeType = typename BoolTreeType::LeafNodeType;
GetValues(const TreeType& tree, const BoolLeafNodeType ** maskNodes,
ValueType* values, const size_t* offsetTable)
: mTree(&tree)
, mMaskNodes(maskNodes)
, mValues(values)
, mOffsetTable(offsetTable)
{
}
void operator()(const tbb::blocked_range<size_t>& range) const {
openvdb::tree::ValueAccessor<const TreeType> acc(*mTree);
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
const BoolLeafNodeType& maskNode = *mMaskNodes[n];
ValueType* values = &mValues[mOffsetTable[n]];
size_t idx = 0;
for (typename BoolLeafNodeType::ValueOnCIter it = maskNode.cbeginValueOn(); it; ++it) {
values[idx++] = acc.getValue(it.getCoord());
}
}
}
TreeType const * const mTree;
BoolLeafNodeType const * const * const mMaskNodes;
ValueType * const mValues;
size_t const * const mOffsetTable;
}; // struct GetValues
template<typename TreeType>
inline size_t
getValues(const TreeType& tree,
const typename TreeType::template ValueConverter<bool>::Type& mask,
UT_UniquePtr<typename TreeType::ValueType[]>& values)
{
using ValueType = typename TreeType::ValueType;
using BoolTreeType = typename TreeType::template ValueConverter<bool>::Type;
using BoolLeafNodeType = typename BoolTreeType::LeafNodeType;
std::vector<const BoolLeafNodeType*> nodes;
mask.getNodes(nodes);
const size_t tileCount = mask.activeTileCount();
size_t voxelCount = 0, totalCount = tileCount;
if (!nodes.empty()) {
UT_UniquePtr<size_t[]> offsetTable(new size_t[nodes.size()]);
for (size_t n = 0, N = nodes.size(); n < N; ++n) {
offsetTable[n] = voxelCount;
voxelCount += nodes[n]->onVoxelCount();
}
totalCount += voxelCount;
values.reset(new ValueType[totalCount]);
tbb::parallel_for(tbb::blocked_range<size_t>(0, nodes.size()),
GetValues<TreeType>(tree, &nodes[0], values.get(), offsetTable.get()));
}
if (tileCount > 0) {
if (!values) {
values.reset(new ValueType[tileCount]);
}
typename BoolTreeType::ValueOnCIter it(mask);
it.setMaxDepth(BoolTreeType::ValueOnCIter::LEAF_DEPTH - 1);
openvdb::tree::ValueAccessor<const TreeType> acc(tree);
for (size_t idx = voxelCount; it; ++it, ++idx) {
values[idx] = acc.getValue(it.getCoord());
}
}
return totalCount;
}
template<typename ValueType>
inline void
transferValues(GU_Detail& detail, const std::string& name, GA_Offset startOffset,
const UT_UniquePtr<ValueType[]>& values, size_t pointCount)
{
GA_RWAttributeRef attr = detail.addFloatTuple(
GA_ATTRIB_POINT, (name + "_scalar").c_str(), 1, GA_Defaults(0));
GA_RWHandleF handle = attr.getAttribute();
for (size_t n = 0, N = pointCount; n < N; ++n) {
handle.set(startOffset++, float(values[n]));
}
}
template<typename ValueType>
inline void
transferValues(GU_Detail& detail, const std::string& name, GA_Offset startOffset,
const UT_UniquePtr<openvdb::math::Vec3<ValueType>[]>& values, size_t pointCount)
{
GA_RWAttributeRef attr = detail.addFloatTuple(
GA_ATTRIB_POINT, (name + "_vector").c_str(), 3, GA_Defaults(0));
GA_RWHandleV3 handle = attr.getAttribute();
UT_Vector3 vec(0.0f, 0.0f, 0.0f);
using VectorType = openvdb::math::Vec3<ValueType>;
for (size_t n = 0, N = pointCount; n < N; ++n) {
const VectorType& val = values[n];
vec[0] = float(val[0]);
vec[1] = float(val[1]);
vec[2] = float(val[2]);
handle.set(startOffset++, vec);
}
}
////////////////////////////////////////
// Utility Objects
struct TestData
{
// settings
bool useMask, usePoints, respectGridClass;
// general tests
bool testFinite, idFinite, fixFinite;
bool testUniformBackground, idUniformBackground, fixUniformBackground;
bool testInRange, idInRange, fixInRange;
bool testUniformVoxelSize;
float rangeMin, rangeMax;
// level set tests
bool testSymmetricNarrowBand;
bool testMinimumBandWidth;
bool testClosedSurface;
bool testGradientMagnitude, idGradientMagnitude, fixGradientMagnitude;
bool testNoActiveTiles, idNoActiveTiles, fixNoActiveTiles;
float gradientTolerance, minBandWidth;
// fog volume tests
bool testBackgroundZero, idBackgroundZero, fixBackgroundZero;
bool testActiveValuesFromZeroToOne, idActiveValuesFromZeroToOne, fixActiveValuesFromZeroToOne;
}; // struct TestData
struct GridTestLog
{
GridTestLog(int primitiveIndex, const std::string& gridName)
: mGridName(), mFailedMsg(), mFailed(0), mPassed(0), mSkipped(0)
{
std::stringstream name;
name << " (" << primitiveIndex << ") '" << gridName << "'";
mGridName = name.str();
}
size_t failedCount() const { return mFailed; }
size_t passedCount() const { return mPassed; }
size_t skippedCount() const { return mSkipped; }
void appendFailed(const std::string& testName, const std::string& msg = "") {
mFailed++;
mFailedMsg += " - '" + testName + "' " + msg + "\n";
}
void appendPassed() { mPassed++; }
void appendSkipped() { mSkipped++; }
std::string str() const {
std::stringstream log;
log << mGridName;
if (mPassed > 0) {
log << " passed " << mPassed;
}
if (mFailed > 0) {
log << " failed " << mFailed;
}
if ((mPassed + mFailed) == 0) {
log << " not tested";
}
log << "\n";
if (mSkipped > 0) {
log << " - skipped " << mSkipped << " scalar floating-point specific test"
<< (mSkipped > 1 ? "s.\n" : ".\n");
}
if (!mFailedMsg.empty()) {
log << mFailedMsg << "\n";
}
return log.str();
}
private:
std::string mGridName, mFailedMsg;
size_t mFailed, mPassed, mSkipped;
}; // struct GridTestLog
template<typename GridType>
struct MaskData {
using TreeType = typename GridType::TreeType;
using ValueType = typename GridType::ValueType;
using BoolTreeType = typename TreeType::template ValueConverter<bool>::Type;
MaskData() : mask(), minValue(ValueType(0)), maxValue(ValueType(0)), isRange(false) {}
MaskData(typename BoolTreeType::Ptr& tree, ValueType val)
: mask(tree), minValue(val), maxValue(val), isRange(false) {}
MaskData(typename BoolTreeType::Ptr& tree, ValueType minval, ValueType maxval)
: mask(tree), minValue(minval), maxValue(maxval), isRange(true) {}
typename BoolTreeType::Ptr mask;
ValueType minValue, maxValue;
bool isRange;
}; // struct MaskData
////////////////////////////////////////
template<typename GridType>
inline
typename std::enable_if<std::is_floating_point<typename GridType::ValueType>::value, void>::type
normalizeLevelSet(GridType& grid)
{
openvdb::tools::LevelSetTracker<GridType> op(grid);
op.setNormCount(3);
op.setSpatialScheme(openvdb::math::FIRST_BIAS);
op.setTemporalScheme(openvdb::math::TVD_RK3);
op.normalize();
}
template<typename GridType>
inline
typename std::enable_if<!std::is_floating_point<typename GridType::ValueType>::value, void>::type
normalizeLevelSet(GridType&)
{
}
template<typename T>
inline T
clampValueAndVectorMagnitude(T s, const T& minVal, const T& maxVal)
{
if (s < minVal) s = minVal;
if (s > maxVal) s = maxVal;
return s;
}
template<typename T>
inline openvdb::math::Vec3<T>
clampValueAndVectorMagnitude(openvdb::math::Vec3<T> v,
const openvdb::math::Vec3<T>& minVal,
const openvdb::math::Vec3<T>& maxVal)
{
const T scale = clampValueAndVectorMagnitude(v.length(), minVal[0], maxVal[0]);
v.normalize();
v *= scale;
return v;
}
template<typename GridType>
struct FixVoxelValues
{
using TreeType = typename GridType::TreeType;
using ValueType = typename TreeType::ValueType;
using LeafNodeType = typename TreeType::LeafNodeType;
using BoolTreeType = typename TreeType::template ValueConverter<bool>::Type;
using BoolLeafNodeType = typename BoolTreeType::LeafNodeType;
using MaskDataType = MaskData<GridType>;
FixVoxelValues(TreeType& tree, const BoolLeafNodeType ** maskNodes,
const MaskDataType& maskdata)
: mTree(&tree)
, mMaskNodes(maskNodes)
, mMaskData(&maskdata)
{
}
void operator()(const tbb::blocked_range<size_t>& range) const {
using ValueOnCIter = typename BoolLeafNodeType::ValueOnCIter;
openvdb::tree::ValueAccessor<TreeType> acc(*mTree);
const ValueType minVal = mMaskData->minValue;
const ValueType maxVal = mMaskData->maxValue;
const bool isRange = mMaskData->isRange;
for (size_t n = range.begin(), N = range.end(); n < N; ++n) {
const BoolLeafNodeType& maskNode = *mMaskNodes[n];
LeafNodeType* node = acc.probeLeaf(maskNode.origin());
if (!node) continue;
if (isRange) { // clamp
for (ValueOnCIter it = maskNode.cbeginValueOn(); it; ++it) {
node->setValueOnly(it.pos(),
clampValueAndVectorMagnitude(node->getValue(it.pos()), minVal, maxVal));
}
} else { // replace
for (ValueOnCIter it = maskNode.cbeginValueOn(); it; ++it) {
node->setValueOnly(it.pos(), minVal);
}
}
}
}
TreeType * const mTree;
BoolLeafNodeType const * const * const mMaskNodes;
MaskDataType const * const mMaskData;
}; // struct FixVoxelValues
template<typename GridType>
inline typename GridType::Ptr
fixValues(const GridType& grid, std::vector<MaskData<GridType> > fixMasks,
bool inactivateTiles = false,
bool renormalizeLevelSet = false)
{
using TreeType = typename GridType::TreeType;
using ValueType = typename GridType::ValueType;
using BoolTreeType = typename TreeType::template ValueConverter<bool>::Type;
using BoolLeafNodeType = typename BoolTreeType::LeafNodeType;
using MaskDataType = MaskData<GridType>;
typename GridType::Ptr replacementGrid = grid.deepCopy();
BoolTreeType alreadyFixedValues(false);
for (size_t n = 0, N = fixMasks.size(); n < N; ++n) {
MaskDataType& fix = fixMasks[n];
BoolTreeType mask(false);
mask.topologyUnion(*fix.mask);
mask.topologyDifference(alreadyFixedValues);
// fix voxels
{
std::vector<const BoolLeafNodeType*> nodes;
mask.getNodes(nodes);
tbb::parallel_for(tbb::blocked_range<size_t>(0, nodes.size()),
FixVoxelValues<GridType>(replacementGrid->tree(), &nodes[0], fix));
}
// fix tiles
typename BoolTreeType::ValueOnCIter it(mask);
it.setMaxDepth(BoolTreeType::ValueOnCIter::LEAF_DEPTH - 1);
openvdb::tree::ValueAccessor<TreeType> acc(replacementGrid->tree());
openvdb::Coord ijk;
if (fix.isRange) { // clamp
for (; it; ++it) {
ijk = it.getCoord();
const ValueType val = clampValueAndVectorMagnitude(
acc.getValue(ijk), fix.minValue, fix.maxValue);
acc.addTile(it.getLevel(), ijk, val, acc.isValueOn(ijk));
}
} else { // replace
const ValueType val = fix.minValue;
for (; it; ++it) {
ijk = it.getCoord();
acc.addTile(it.getLevel(), ijk, val, acc.isValueOn(ijk));
}
}
alreadyFixedValues.topologyUnion(mask);
}
if (inactivateTiles) {
typename TreeType::ValueOnIter it(replacementGrid->tree());
it.setMaxDepth(TreeType::ValueOnIter::LEAF_DEPTH - 1);
for (; it; ++it) {
it.setActiveState(false);
}
}
if (renormalizeLevelSet) {
normalizeLevelSet(*replacementGrid);
}
return replacementGrid;
}
template<typename GridType>
inline void
outputMaskAndPoints(const GridType& grid, const std::string& gridName,
std::vector<typename GridType::TreeType::template ValueConverter<bool>::Type::Ptr> masks,
bool outputMask,
bool outputPoints,
GU_Detail& detail,
hvdb::Interrupter& interupter,
const GridType* replacementGrid = nullptr)
{
using TreeType = typename GridType::TreeType;
using ValueType = typename GridType::ValueType;
using BoolTreeType = typename TreeType::template ValueConverter<bool>::Type;
using BoolGridType = typename openvdb::Grid<BoolTreeType>;
if (outputMask || outputPoints) {
const TreeType& tree = grid.tree();
typename BoolGridType::Ptr maskGrid = openvdb::createGrid<BoolGridType>(false);
BoolTreeType& mask = maskGrid->tree();
for (size_t n = 0, N = masks.size(); n < N; ++n) {
BoolTreeType* maskPt = masks[n].get();
if (maskPt && !maskPt->empty()) {
mask.merge(*masks[n]);
}
}
if (outputPoints && !mask.empty()) {
if (interupter.wasInterrupted()) return;
UT_UniquePtr<UT_Vector3[]> points;
const size_t totalPointCount = getPoints(grid.transform(), mask, points);
if (interupter.wasInterrupted()) return;
if (totalPointCount > 0) {
const GA_Offset startOffset = transferPoints(detail, points, totalPointCount);
points.reset(); // clear
UT_UniquePtr<ValueType[]> values;
getValues(tree, mask, values);
if (interupter.wasInterrupted()) return;
transferValues(detail, "input", startOffset, values, totalPointCount);
if (replacementGrid) {
if (interupter.wasInterrupted()) return;
getValues(replacementGrid->tree(), mask, values);
if (interupter.wasInterrupted()) return;
transferValues(detail, "output", startOffset, values, totalPointCount);
}
}
}
if (interupter.wasInterrupted()) return;
if (outputMask && !mask.empty()) {
maskGrid->setName(gridName + "_mask");
maskGrid->setTransform(grid.transform().copy());
hvdb::createVdbPrimitive(detail, maskGrid, maskGrid->getName().c_str());
}
}
}
////////////////////////////////////////
struct TestCollection
{
TestCollection(const TestData& test, GU_Detail& detail,
hvdb::Interrupter& interupter, UT_ErrorManager* errorManager = nullptr)
: mTest(test)
, mDetail(&detail)
, mInterupter(&interupter)
, mErrorManager(errorManager)
, mMessageStr()
, mPrimitiveName()
, mPrimitiveIndex(0)
, mGridsFailed(0)
, mReplacementGrid()
{
}
~TestCollection()
{
if (mErrorManager) {
if (mGridsFailed > 0) {
std::stringstream msg;
msg << mGridsFailed << " grid" << (mGridsFailed > 1 ? "s" : "")
<< " failed one or more tests.";
mErrorManager->addWarning(SOP_OPTYPE_NAME, SOP_MESSAGE, msg.str().c_str());
}
if (!mMessageStr.empty()) {
std::stringstream msg;
msg << "Diagnostics results\n";
msg << mMessageStr;
mErrorManager->addMessage(SOP_OPTYPE_NAME, SOP_MESSAGE, msg.str().c_str());
}
}
}
void setPrimitiveIndex(int i) { mPrimitiveIndex = i; }
void setPrimitiveName(const std::string& name) { mPrimitiveName = name; }
bool hasReplacementGrid() const { return mReplacementGrid != nullptr; }
openvdb::GridBase::Ptr replacementGrid() { return mReplacementGrid; }
template<typename GridType>
void operator()(const GridType& grid)
{
mReplacementGrid.reset(); // clear
using TreeType = typename GridType::TreeType;
using ValueType = typename GridType::ValueType;
using BoolTreeType = typename TreeType::template ValueConverter<bool>::Type;
using MaskDataType = MaskData<GridType>;
using VisitorType = Visitor<GridType>;
//////////
const double voxelSize = grid.transform().voxelSize()[0];
const std::string gridName = mPrimitiveName.empty() ? grid.getName() : mPrimitiveName;
const TreeType& tree = grid.tree();
GridTestLog log(mPrimitiveIndex, gridName);
VisitorType visitor(tree);
std::vector<typename BoolTreeType::Ptr> idMasks;
std::vector<MaskDataType> fixMasks;
// General tests
bool inactivateTiles = false, renormalizeLevelSet = false;
if (mTest.testFinite) {
if (!visitor.run(VisitorType::TILES_AND_VOXELS,
VisitorType::ALL_VALUES, FiniteValue()))
{
log.appendFailed("Finite Values", visitor.invalidValuesInfo());
if (mTest.fixFinite) {
fixMasks.push_back(MaskDataType(visitor.valueMask(), tree.background()));
}
if (mTest.idFinite) idMasks.push_back(visitor.valueMask());
} else {
log.appendPassed();
}
}
if (mInterupter->wasInterrupted()) return;
if (mTest.testUniformBackground
&& (!mTest.respectGridClass || grid.getGridClass() != openvdb::GRID_LEVEL_SET))
{
ApproxEqual<ValueType> test(tree.background());
if (!visitor.run(VisitorType::TILES_AND_VOXELS, VisitorType::INACTIVE_VALUES, test)) {
log.appendFailed("Uniform Background", visitor.invalidValuesInfo());
if (mTest.fixUniformBackground) {
fixMasks.push_back(MaskDataType(visitor.valueMask(), tree.background()));
}
if (mTest.idUniformBackground) idMasks.push_back(visitor.valueMask());
} else {
log.appendPassed();
}
}
if (mInterupter->wasInterrupted()) return;
if (mTest.testInRange) {
InRange test(mTest.rangeMin, mTest.rangeMax);
if (!visitor.run(VisitorType::TILES_AND_VOXELS, VisitorType::ALL_VALUES, test)) {
log.appendFailed("Values in Range", visitor.invalidValuesInfo());
if (mTest.fixInRange) {
fixMasks.push_back(MaskDataType(visitor.valueMask(),
ValueType(mTest.rangeMin), ValueType(mTest.rangeMax)));
}
if (mTest.idInRange) idMasks.push_back(visitor.valueMask());
} else {
log.appendPassed();
}
}
if (mInterupter->wasInterrupted()) return;
// Level Set tests
if (!mTest.respectGridClass || grid.getGridClass() == openvdb::GRID_LEVEL_SET) {
if (mTest.testUniformVoxelSize) {
if (!grid.hasUniformVoxels()) log.appendFailed("'Uniform Voxel Size'");
else log.appendPassed();
}
if (mTest.testNoActiveTiles) {
if (!visitor.run(VisitorType::TILES, VisitorType::ACTIVE_VALUES, AlwaysFalse())) {
log.appendFailed("Inactive Tiles", visitor.invalidValuesInfo());
if (mTest.fixNoActiveTiles) inactivateTiles = true;
if (mTest.idNoActiveTiles) idMasks.push_back(visitor.valueMask());
} else {
log.appendPassed();
}
}
if (mTest.testSymmetricNarrowBand) {
if (std::is_floating_point<ValueType>::value) {
const ValueType background = openvdb::math::Abs(tree.background());
AbsApproxEqual<ValueType> bgTest(background);
InRange valueTest(-toFloat(background), toFloat(background));
if (!visitor.run(VisitorType::TILES_AND_VOXELS,
VisitorType::INACTIVE_VALUES, bgTest)
|| !visitor.run(VisitorType::VOXELS, VisitorType::ACTIVE_VALUES, valueTest))
{
log.appendFailed("Symmetric Narrow Band");
} else {
log.appendPassed();
}
} else {
log.appendSkipped();
}
}
if (mInterupter->wasInterrupted()) return;
if (mTest.testMinimumBandWidth) {
if (std::is_floating_point<ValueType>::value) {
const ValueType width = ValueType(mTest.minBandWidth) * ValueType(voxelSize);
AbsLessThan<ValueType> test(width);
if (tree.background() < width || !visitor.run(
VisitorType::TILES_AND_VOXELS, VisitorType::INACTIVE_VALUES, test))
{
log.appendFailed("Minimum Band Width");
} else {
log.appendPassed();
}
} else {
log.appendSkipped();
}
}
if (mInterupter->wasInterrupted()) return;
if (mTest.testClosedSurface) {
if (std::is_floating_point<ValueType>::value) {
typename GridType::Ptr levelSet = openvdb::tools::levelSetRebuild(
grid, 0.0f, 2.0f, 2.0f, nullptr, mInterupter);
SameSign<TreeType> test(levelSet->tree());
if (!visitor.run(VisitorType::TILES_AND_VOXELS,
VisitorType::ALL_VALUES, test))
{
log.appendFailed("Closed Surface");
} else {
log.appendPassed();
}
} else {
log.appendSkipped();
}
}
if (mInterupter->wasInterrupted()) return;
if (mTest.testGradientMagnitude) {
if (std::is_floating_point<ValueType>::value) {
GradientNorm<TreeType> test(tree, voxelSize,
ValueType(mTest.gradientTolerance));
if (!visitor.run(VisitorType::VOXELS, VisitorType::ACTIVE_VALUES, test)) {
log.appendFailed("Gradient Magnitude", visitor.invalidValuesInfo());
if (mTest.fixGradientMagnitude) renormalizeLevelSet = true;
if (mTest.idGradientMagnitude) idMasks.push_back(visitor.valueMask());
} else {
log.appendPassed();
}
} else {
log.appendSkipped();
}
}
} // end Level Set tests
// Fog Volume tests
if (!mTest.respectGridClass || grid.getGridClass() == openvdb::GRID_FOG_VOLUME) {
if (mTest.testBackgroundZero) {
ApproxEqual<ValueType> test(ValueType(0.0));
if (!visitor.run(VisitorType::TILES_AND_VOXELS,
VisitorType::INACTIVE_VALUES, test))
{
log.appendFailed("Background Zero", visitor.invalidValuesInfo());
if (mTest.fixBackgroundZero) {
fixMasks.push_back(MaskDataType(visitor.valueMask(), ValueType(0.0)));
}
if (mTest.idBackgroundZero) idMasks.push_back(visitor.valueMask());
} else {
log.appendPassed();
}
}
if (mTest.testActiveValuesFromZeroToOne) {
InRange test(0.0f, 1.0f);
if (!visitor.run(VisitorType::TILES_AND_VOXELS, VisitorType::ACTIVE_VALUES, test)) {
log.appendFailed("Active Values in [0, 1]", visitor.invalidValuesInfo());
if (mTest.fixActiveValuesFromZeroToOne) {
fixMasks.push_back(
MaskDataType(visitor.valueMask(), ValueType(0.0), ValueType(1.0)));
}
if (mTest.idActiveValuesFromZeroToOne) idMasks.push_back(visitor.valueMask());
} else {
log.appendPassed();
}
}
} // end Fog Volume tests
typename GridType::Ptr replacement;
if (!fixMasks.empty() || inactivateTiles || renormalizeLevelSet) {
replacement = fixValues(grid, fixMasks, inactivateTiles, renormalizeLevelSet);
mReplacementGrid = replacement;
}
if (mInterupter->wasInterrupted()) return;
outputMaskAndPoints<GridType>(grid, gridName, idMasks, mTest.useMask, mTest.usePoints,
*mDetail, *mInterupter, replacement.get());
// log diagnostics info
mMessageStr += log.str();
if (log.failedCount() > 0) ++mGridsFailed;
}
private:
TestData mTest;
GU_Detail * const mDetail;
hvdb::Interrupter * const mInterupter;
UT_ErrorManager * const mErrorManager;
std::string mMessageStr, mPrimitiveName;
int mPrimitiveIndex, mGridsFailed;
openvdb::GridBase::Ptr mReplacementGrid;
}; // struct TestCollection
} // unnamed namespace
////////////////////////////////////////
// SOP Implementation
class SOP_OpenVDB_Diagnostics: public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Diagnostics(OP_Network*, const char* name, OP_Operator*);
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned i) const override { return (i == 1); }
int selectOperationTests();
int validateOperationTests();
class Cache: public SOP_VDBCacheOptions
{
OP_ERROR cookVDBSop(OP_Context&) override;
TestData getTestData(const fpreal time) const;
};
protected:
bool updateParmsFlags() override;
};
int
SOP_OpenVDB_Diagnostics::selectOperationTests()
{
setInt("test_valrange", 0, 0, 0);
setInt("test_backgroundzero", 0, 0, 0);
setInt("test_fogvalues", 0, 0, 0);
setInt("test_voxelsize", 0, 0, 0);
setInt("test_activetiles", 0, 0, 0);
setInt("test_symmetric", 0, 0, 0);
setInt("test_surface", 0, 0, 0);
setInt("test_bandwidth", 0, 0, 0);
if (bool(evalInt("verify_fogvolume", 0, 0))) {
setInt("test_finite", 0, 0, 1);
setInt("test_backgroundzero", 0, 0, 1);
setInt("test_fogvalues", 0, 0, 1);
}
if (bool(evalInt("verify_csg", 0, 0))) {
setInt("test_finite", 0, 0, 1);
setInt("test_voxelsize", 0, 0, 1);
setInt("test_activetiles", 0, 0, 1);
setInt("test_symmetric", 0, 0, 1);
setInt("test_surface", 0, 0, 1);
setInt("test_background", 0, 0, 0);
}
if (bool(evalInt("verify_filtering", 0, 0))) {
setInt("test_finite", 0, 0, 1);
setInt("test_voxelsize", 0, 0, 1);
setInt("test_activetiles", 0, 0, 1);
setInt("test_symmetric", 0, 0, 1);
setInt("test_bandwidth", 0, 0, 1);
setInt("bandwidth", 0, 0, 3);
setInt("test_background", 0, 0, 0);
}
if (bool(evalInt("verify_advection", 0, 0))) {
setInt("test_finite", 0, 0, 1);
setInt("test_voxelsize", 0, 0, 1);
setInt("test_activetiles", 0, 0, 1);
setInt("test_surface", 0, 0, 1);
setInt("test_symmetric", 0, 0, 1);
setInt("test_bandwidth", 0, 0, 1);
setInt("bandwidth", 0, 0, 3);
setInt("test_background", 0, 0, 0);
}
return 1;
}
int
SOP_OpenVDB_Diagnostics::validateOperationTests()
{
// general tests
const bool testFinite = bool(evalInt("test_finite", 0, 0));
const bool testUniformBackground = bool(evalInt("test_background", 0, 0));
const bool testInRange = bool(evalInt("test_valrange", 0, 0));
const bool testUniformVoxelSize = bool(evalInt("test_voxelsize", 0, 0));
// level set
const bool testSymmetricNarrowBand = bool(evalInt("test_symmetric", 0, 0));
const bool minBandWidth =
bool(evalInt("test_bandwidth", 0, 0)) && evalInt("bandwidth", 0, 0) > 2;
const bool testClosedSurface = bool(evalInt("test_surface", 0, 0));
const bool testNoActiveTiles = bool(evalInt("test_activetiles", 0, 0));
const bool basicLevelSetChecks = testFinite && !testUniformBackground && !testInRange
&& testUniformVoxelSize && testNoActiveTiles;
// fog volume tests
const bool basicFogVolumeChecks = testFinite && !testInRange &&
bool(evalInt("test_backgroundzero", 0, 0)) && bool(evalInt("test_fogvalues", 0, 0));
{ // Validate fog volume operations
setInt("verify_fogvolume", 0, 0, int(basicFogVolumeChecks));
}
{ // Validate level set CSG tests
bool isValid = basicLevelSetChecks && testClosedSurface && testSymmetricNarrowBand;
setInt("verify_csg", 0, 0, int(isValid));
}
{ // Validate level set filtering tests
bool isValid = basicLevelSetChecks && testSymmetricNarrowBand && minBandWidth;
setInt("verify_filtering", 0, 0, int(isValid));
}
{ // Validate level set advection tests
bool isValid = basicLevelSetChecks && testClosedSurface
&& testSymmetricNarrowBand && minBandWidth;
setInt("verify_advection", 0, 0, int(isValid));
}
return 1;
}
int selectOperationTestsCB(void*, int, float, const PRM_Template*);
int validateOperationTestsCB(void*, int, float, const PRM_Template*);
int
selectOperationTestsCB(void* data, int /*idx*/, float /*time*/, const PRM_Template*)
{
SOP_OpenVDB_Diagnostics* sop = static_cast<SOP_OpenVDB_Diagnostics*>(data);
if (sop == nullptr) return 0;
return sop->selectOperationTests();
}
int
validateOperationTestsCB(void* data, int /*idx*/, float /*time*/, const PRM_Template*)
{
SOP_OpenVDB_Diagnostics* sop = static_cast<SOP_OpenVDB_Diagnostics*>(data);
if (sop == nullptr) return 0;
return sop->validateOperationTests();
}
// Hack to work around lack of grid layout in parameter pane
// (one space character is four pixels wide, but the middle column is centered)
inline std::string
spacing(int widthInPixels)
{
return std::string(widthInPixels >> 1, ' '); // 2 * width / 4
}
void
newSopOperator(OP_OperatorTable* table)
{
if (table == nullptr) return;
hutil::ParmList parms;
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setChoiceList(&hutil::PrimGroupMenu)
.setTooltip("Specify a subset of the input VDBs to examine.")
.setDocumentation(
"A subset of the input VDBs to be examined"
" (see [specifying volumes|/model/volumes#group])"));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "usemask", "Mark in Mask VDB")
.setTooltip(
"For tests set to Mark, output a mask VDB that highlights\n"
"problematic regions in input VDBs."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "usepoints", "Mark as Points With Values")
.setDefault(PRMoneDefaults)
.setTooltip(
"For tests set to Mark, output a point cloud that highlights\n"
"problematic regions in input VDBs."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "respectclass", "Respect VDB Class")
.setDefault(PRMoneDefaults)
.setTooltip(
"If disabled, apply fog volume and level set tests to all VDBs,\n"
"not just VDBs classified as fog volumes or level sets."));
//////////
// Operation
parms.add(hutil::ParmFactory(PRM_SEPARATOR,"operation", ""));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "verify_fogvolume", "Validate Fog Volumes")
.setCallbackFunc(&selectOperationTestsCB)
.setTooltip("Verify that VDBs classified as fog volumes are valid fog volumes."));
parms.add(hutil::ParmFactory(PRM_TOGGLE,
"verify_csg", "Validate for Level Set CSG and Fracture")
.setCallbackFunc(&selectOperationTestsCB)
.setTooltip(
"Verify that level set VDBs meet the requirements\n"
"for CSG and fracture operations."));
parms.add(hutil::ParmFactory(PRM_TOGGLE,
"verify_filtering", "Validate for Level Set Filtering and Renormalization")
.setCallbackFunc(&selectOperationTestsCB)
.setTooltip(
"Verify that level set VDBs meet the requirements\n"
"for filtering and renormalization."));
parms.add(hutil::ParmFactory(PRM_TOGGLE,
"verify_advection", "Validate for Level Set Advection and Morphing")
.setCallbackFunc(&selectOperationTestsCB)
.setTooltip(
"Verify that level set VDBs meet the requirements\n"
"for advection and morphing."));
//////////
// General
parms.add(hutil::ParmFactory(PRM_HEADING, "general", "General Tests")
.setDocumentation(
"In the following, enable __Mark__ to add incorrect values"
" to the output mask and/or point cloud, and enable __Fix__"
" to replace incorrect values."));
// { Finite values
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_finite", "Finite Values"
+ spacing(35)
)
.setCallbackFunc(&validateOperationTestsCB)
.setDefault(PRMoneDefaults)
.setTypeExtended(PRM_TYPE_MENU_JOIN)
.setTooltip("Verify that all values are finite and non-NaN.")
.setDocumentation(
"Verify that all values are finite and non-NaN.\n\n"
"If __Fix__ is enabled, replace incorrect values with the background value."));
parms.add(hutil::ParmFactory(PRM_TOGGLE | PRM_TYPE_JOIN_NEXT, "id_finite", "Mark")
.setTooltip("Add incorrect values to the output mask and/or point cloud.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fix_finite", "Fix")
.setTooltip("Replace incorrect values with the background value.")
.setDocumentation(nullptr));
// }
// { Uniform background values
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_background", "Uniform Background"
)
.setCallbackFunc(&validateOperationTestsCB)
.setTypeExtended(PRM_TYPE_MENU_JOIN)
.setTooltip("Verify that all inactive voxels are set to the background value.")
.setDocumentation(
"Verify that all inactive voxels are set to the background value.\n\n"
"If __Fix__ is enabled, replace incorrect values with the background value."));
parms.add(hutil::ParmFactory(PRM_TOGGLE | PRM_TYPE_JOIN_NEXT, "id_background", "Mark")
.setTooltip("Add incorrect values to the output mask and/or point cloud.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fix_background", "Fix")
.setTooltip("Replace incorrect values with the background value.")
.setDocumentation(nullptr));
// }
// { Values in range
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_valrange", "Values in Range"
+ spacing(23)
)
.setCallbackFunc(&validateOperationTestsCB)
.setTypeExtended(PRM_TYPE_MENU_JOIN)
.setTooltip(
"Verify that all scalar voxel values and vector magnitudes\n"
"are in the given range.")
.setDocumentation(
"Verify that all scalar voxel values and vector magnitudes are in the given range.\n\n"
"If __Fix__ is enabled, clamp values and vector magnitudes to the given range."));
parms.add(hutil::ParmFactory(PRM_TOGGLE | PRM_TYPE_JOIN_NEXT, "id_valrange", "Mark")
.setTooltip("Add incorrect values to the output mask and/or point cloud.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fix_valrange", "Fix")
.setTooltip("Clamp values and vector magnitudes to the given range.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_LABEL | PRM_TYPE_JOIN_NEXT, "label_valrange", ""));
std::vector<fpreal> defaultRange;
defaultRange.push_back(fpreal(0.0));
defaultRange.push_back(fpreal(1.0));
parms.add(hutil::ParmFactory(PRM_FLT_J, "valrange", "Range")
.setDefault(defaultRange)
.setVectorSize(2)
.setTooltip("Minimum and maximum allowed values (inclusive)"));
// }
//////////
// Level Set
parms.add(hutil::ParmFactory(PRM_HEADING, "ls_heading", "Level Set Tests"));
// { Symmetric Narrow Band
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_symmetric", "Symmetric Narrow Band")
.setCallbackFunc(&validateOperationTestsCB)
.setTooltip("Verify that level set inside and outside values are of equal magnitude."));
// }
// { Min Band Width
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_bandwidth", "Minimum Band Width")
.setCallbackFunc(&validateOperationTestsCB)
.setTooltip(
"Verify that interior and exterior narrow band widths"
" are sufficiently large."));
parms.add(hutil::ParmFactory(PRM_LABEL | PRM_TYPE_JOIN_NEXT, "label_bandwidth", ""));
parms.add(hutil::ParmFactory(PRM_INT_J, "bandwidth", "Minimum Width in Voxels")
.setCallbackFunc(&validateOperationTestsCB)
.setDefault(3));
// }
// { Closed Surface
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_surface", "Closed Surface")
.setCallbackFunc(&validateOperationTestsCB)
.setTooltip("Verify that level sets represent watertight surfaces."));
// }
// { Gradient magnitude
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_gradient", "Gradient Magnitude"
+ spacing(7)
)
.setCallbackFunc(&validateOperationTestsCB)
.setTypeExtended(PRM_TYPE_MENU_JOIN)
.setTooltip(
"Verify that the level set gradient has magnitude one everywhere\n"
"(within a given tolerance).")
.setDocumentation(
"Verify that the level set gradient has magnitude one everywhere"
" (within a given tolerance).\n\n"
"If __Fix__ is enabled, renormalize level sets."));
parms.add(hutil::ParmFactory(PRM_TOGGLE | PRM_TYPE_JOIN_NEXT, "id_gradient", "Mark")
.setTooltip("Add incorrect values to the output mask and/or point cloud.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fix_gradient", "Fix")
.setTooltip("Renormalize level sets.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_LABEL | PRM_TYPE_JOIN_NEXT, "label_gradient", ""));
parms.add(hutil::ParmFactory(PRM_FLT_J, "gradienttolerance", "Tolerance")
.setDefault(0.2f)
.setDocumentation(nullptr));
// }
// { Inactive Tiles
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_activetiles", "Inactive Tiles"
+ spacing(36)
)
.setCallbackFunc(&validateOperationTestsCB)
.setTypeExtended(PRM_TYPE_MENU_JOIN)
.setTooltip("Verify that level sets have no active tiles.")
.setDocumentation(
"Verify that level sets have no active tiles.\n\n"
"If __Fix__ is enabled, deactivate all tiles."));
parms.add(hutil::ParmFactory(PRM_TOGGLE | PRM_TYPE_JOIN_NEXT, "id_activetiles", "Mark")
.setTooltip("Add incorrect values to the output mask and/or point cloud.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fix_activetiles", "Fix")
.setTooltip("Deactivate all tiles.")
.setDocumentation(nullptr));
// }
// { Uniform Voxel Size
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_voxelsize", "Uniform Voxel Size")
.setTooltip("Verify that level sets have uniform voxel sizes."));
// }
//////////
// Fog Volume
parms.add(hutil::ParmFactory(PRM_HEADING, "fog_heading", "Fog Volume Tests")
.setTooltip("Fog Volume specific tests."));
// { Background values
parms.add(hutil::ParmFactory(PRM_TOGGLE, "test_backgroundzero", "Background Zero"
+ spacing(17)
)
.setCallbackFunc(&validateOperationTestsCB)
.setTypeExtended(PRM_TYPE_MENU_JOIN)
.setTooltip("Verify that all inactive voxels in fog volumes have value zero.")
.setDocumentation(
"Verify that all inactive voxels in fog volumes have value zero.\n\n"
"If __Fix__ is enabled, set inactive voxels to zero."));
parms.add(hutil::ParmFactory(PRM_TOGGLE | PRM_TYPE_JOIN_NEXT, "id_backgroundzero", "Mark")
.setTooltip("Add incorrect values to the output mask and/or point cloud.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fix_backgroundzero", "Fix")
.setTooltip("Set inactive voxels to zero.")
.setDocumentation(nullptr));
// }
// { Active values
parms.add(hutil::ParmFactory(PRM_TOGGLE,
// Note: this label currently determines the spacing of the second column of toggles.
"test_fogvalues", "Active Values in [0, 1]")
.setCallbackFunc(&validateOperationTestsCB)
.setTypeExtended(PRM_TYPE_MENU_JOIN)
.setTooltip(
"Verify that all active voxels in fog volumes\n"
"have values in the range [0, 1].")
.setDocumentation(
"Verify that all active voxels in fog volumes have values in the range"
" [0, 1].\n\n" // "[0, 1]"
"If __Fix__ is enabled, clamp active voxels to the range [0, 1]."));
parms.add(hutil::ParmFactory(PRM_TOGGLE | PRM_TYPE_JOIN_NEXT, "id_fogvalues", "Mark")
.setTooltip("Add incorrect values to the output mask and/or point cloud.")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "fix_fogvalues", "Fix")
.setTooltip("Clamp active values to the range [0, 1].")
.setDocumentation(nullptr));
// }
hvdb::OpenVDBOpFactory("VDB Diagnostics", SOP_OpenVDB_Diagnostics::factory, parms, *table)
.addInput("VDB Volumes")
.setVerb(SOP_NodeVerb::COOK_INPLACE, []() { return new SOP_OpenVDB_Diagnostics::Cache; })
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Examine VDB volumes for bad values.\"\"\"\n\
\n\
@overview\n\
\n\
This node runs a suite of tests to validate and correct common errors in VDB volumes.\n\
It provides the option to output either a mask VDB or a point cloud that identifies\n\
the troublesome voxels, and it is optionally able to correct most types of errors.\n\
\n\
@related\n\
- [Node:sop/vdbdiagnostics]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node*
SOP_OpenVDB_Diagnostics::factory(OP_Network* net, const char* name, OP_Operator* op)
{
return new SOP_OpenVDB_Diagnostics(net, name, op);
}
SOP_OpenVDB_Diagnostics::SOP_OpenVDB_Diagnostics(OP_Network* net,
const char* name, OP_Operator* op):
hvdb::SOP_NodeVDB(net, name, op)
{
}
bool
SOP_OpenVDB_Diagnostics::updateParmsFlags()
{
bool changed = false;
const bool identify = bool(evalInt("usemask", 0, 0)) || bool(evalInt("usepoints", 0, 0));
// general
const bool testFinite = bool(evalInt("test_finite", 0, 0));
changed |= enableParm("id_finite", identify && testFinite);
changed |= enableParm("fix_finite", testFinite);
const bool testUniformBackground = bool(evalInt("test_background", 0, 0));
changed |= enableParm("id_background", identify && testUniformBackground);
changed |= enableParm("fix_background", testUniformBackground);
const bool testInRange = bool(evalInt("test_valrange", 0, 0));
changed |= enableParm("id_valrange", identify && testInRange);
setVisibleState("label_valrange", testInRange);
setVisibleState("valrange", testInRange);
changed |= enableParm("fix_valrange", testInRange);
// level set
setVisibleState("label_bandwidth", evalInt("test_bandwidth", 0, 0));
setVisibleState("bandwidth", evalInt("test_bandwidth", 0, 0));
const bool testGradientMagnitude = bool(evalInt("test_gradient", 0, 0));
changed |= enableParm("id_gradient", identify && testGradientMagnitude);
setVisibleState("label_gradient", testGradientMagnitude);
setVisibleState("gradienttolerance", testGradientMagnitude);
changed |= enableParm("fix_gradient", testGradientMagnitude);
const bool testNoActiveTiles = bool(evalInt("test_activetiles", 0, 0));
changed |= enableParm("id_activetiles", identify && testNoActiveTiles);
changed |= enableParm("fix_activetiles", testNoActiveTiles);
// fog volume
const bool testBackgroundZero = bool(evalInt("test_backgroundzero", 0, 0));
changed |= enableParm("id_backgroundzero", identify && testBackgroundZero);
changed |= enableParm("fix_backgroundzero", testBackgroundZero);
const bool testActiveValuesFromZeroToOne = bool(evalInt("test_fogvalues", 0, 0));
changed |= enableParm("id_fogvalues", identify && testActiveValuesFromZeroToOne);
changed |= enableParm("fix_fogvalues", testActiveValuesFromZeroToOne);
return changed;
}
TestData
SOP_OpenVDB_Diagnostics::Cache::getTestData(const fpreal time) const
{
TestData test;
test.useMask = bool(evalInt("usemask", 0, time));
test.usePoints = bool(evalInt("usepoints", 0, time));
test.respectGridClass = bool(evalInt("respectclass", 0, time));
const bool identify = test.useMask || test.usePoints;
// general
test.testFinite = bool(evalInt("test_finite", 0, time));
test.idFinite = identify && bool(evalInt("id_finite", 0, time));
test.fixFinite = bool(evalInt("fix_finite", 0, time));
test.testUniformBackground = bool(evalInt("test_background", 0, time));
test.idUniformBackground = identify && bool(evalInt("id_background", 0, time));
test.fixUniformBackground = bool(evalInt("fix_background", 0, time));
test.testInRange = bool(evalInt("test_valrange", 0, time));
test.idInRange = identify && bool(evalInt("id_valrange", 0, time));
test.fixInRange = bool(evalInt("fix_valrange", 0, time));
test.rangeMin = float(evalFloat("valrange", 0, time));
test.rangeMax = float(evalFloat("valrange", 1, time));
// level set
test.testSymmetricNarrowBand = bool(evalInt("test_symmetric", 0, time));
test.testMinimumBandWidth = bool(evalInt("test_bandwidth", 0, time));
test.minBandWidth = float(evalInt("bandwidth", 0, time));
test.testClosedSurface = bool(evalInt("test_surface", 0, time));
test.testGradientMagnitude = bool(evalInt("test_gradient", 0, time));
test.idGradientMagnitude = identify && bool(evalInt("id_gradient", 0, time));
test.fixGradientMagnitude = bool(evalInt("fix_gradient", 0, time));
test.gradientTolerance = float(evalFloat("gradienttolerance", 0, time));
test.testNoActiveTiles = bool(evalInt("test_activetiles", 0, time));
test.idNoActiveTiles = identify && bool(evalInt("id_activetiles", 0, time));
test.fixNoActiveTiles = bool(evalInt("fix_activetiles", 0, time));
test.testUniformVoxelSize = bool(evalInt("test_voxelsize", 0, time));
// fog volume
test.testBackgroundZero = bool(evalInt("test_backgroundzero", 0, time));
test.idBackgroundZero = identify && bool(evalInt("id_backgroundzero", 0, time));
test.fixBackgroundZero = bool(evalInt("fix_backgroundzero", 0, time));
test.testActiveValuesFromZeroToOne = bool(evalInt("test_fogvalues", 0, time));
test.idActiveValuesFromZeroToOne = identify && bool(evalInt("id_fogvalues", 0, time));
test.fixActiveValuesFromZeroToOne = bool(evalInt("fix_fogvalues", 0, time));
return test;
}
OP_ERROR
SOP_OpenVDB_Diagnostics::Cache::cookVDBSop(OP_Context& context)
{
try {
const fpreal time = context.getTime();
hvdb::Interrupter boss("Performing diagnostics");
TestCollection tests(getTestData(time), *gdp, boss, UTgetErrorManager());
const GA_PrimitiveGroup* group = matchGroup(*gdp, evalStdString("group", time));
size_t vdbPrimCount = 0;
for (hvdb::VdbPrimIterator it(gdp, group); it; ++it) {
if (boss.wasInterrupted()) break;
tests.setPrimitiveName(it.getPrimitiveName().toStdString());
tests.setPrimitiveIndex(int(it.getIndex()));
hvdb::GEOvdbApply<hvdb::VolumeGridTypes>(**it, tests, /*makeUnique=*/false);
if (tests.replacementGrid()) {
hvdb::replaceVdbPrimitive(*gdp, tests.replacementGrid(), **it, true,
tests.replacementGrid()->getName().c_str());
}
++vdbPrimCount;
}
if (vdbPrimCount == 0) {
addWarning(SOP_MESSAGE, "Did not find any VDBs to diagnose.");
}
} catch (std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
| 67,089 | C++ | 33.212137 | 100 | 0.598638 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_NodeVDB.h | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_NodeVDB.h
/// @author FX R&D OpenVDB team
/// @brief Base class for OpenVDB plugins
#ifndef OPENVDB_HOUDINI_SOP_NODEVDB_HAS_BEEN_INCLUDED
#define OPENVDB_HOUDINI_SOP_NODEVDB_HAS_BEEN_INCLUDED
#include <houdini_utils/ParmFactory.h>
#include <openvdb/openvdb.h>
#include <openvdb/Platform.h>
#include <SOP/SOP_Node.h>
#ifndef SESI_OPENVDB
#include <UT/UT_DSOVersion.h>
#endif
#include "SOP_VDBVerbUtils.h"
#include <iosfwd>
#include <string>
class GU_Detail;
namespace openvdb_houdini {
/// @brief Use this class to register a new OpenVDB operator (SOP, POP, etc.)
/// @details This class ensures that the operator uses the appropriate OpPolicy.
/// @sa houdini_utils::OpFactory, houdini_utils::OpPolicy
class OPENVDB_HOUDINI_API OpenVDBOpFactory: public houdini_utils::OpFactory
{
public:
/// Construct an OpFactory that on destruction registers a new OpenVDB operator type.
OpenVDBOpFactory(const std::string& english, OP_Constructor, houdini_utils::ParmList&,
OP_OperatorTable&, houdini_utils::OpFactory::OpFlavor = SOP);
/// @brief Set the name of the equivalent native operator as shipped with Houdini.
/// @details This is only needed where the native name policy doesn't provide the correct name.
/// Pass an empty string to indicate that there is no equivalent native operator.
OpenVDBOpFactory& setNativeName(const std::string& name);
private:
std::string mNativeName;
};
////////////////////////////////////////
/// @brief Base class from which to derive OpenVDB-related Houdini SOPs
class OPENVDB_HOUDINI_API SOP_NodeVDB: public SOP_Node
{
public:
SOP_NodeVDB(OP_Network*, const char*, OP_Operator*);
~SOP_NodeVDB() override = default;
void fillInfoTreeNodeSpecific(UT_InfoTree&, const OP_NodeInfoTreeParms&) override;
void getNodeSpecificInfoText(OP_Context&, OP_NodeInfoParms&) override;
/// @brief Return this node's registered verb.
const SOP_NodeVerb* cookVerb() const override;
/// @brief Retrieve a group from a geometry detail by parsing a pattern
/// (typically, the value of a Group parameter belonging to this node).
/// @throw std::runtime_error if the pattern is nonempty but doesn't match any group.
/// @todo This is a wrapper for SOP_Node::parsePrimitiveGroups(), so it needs access
/// to a SOP_Node instance. But it probably doesn't need to be a SOP_NodeVDB method.
/// @{
const GA_PrimitiveGroup* matchGroup(GU_Detail&, const std::string& pattern);
const GA_PrimitiveGroup* matchGroup(const GU_Detail&, const std::string& pattern);
/// @}
/// @name Parameter evaluation
/// @{
/// @brief Evaluate a vector-valued parameter.
openvdb::Vec3f evalVec3f(const char* name, fpreal time) const;
/// @brief Evaluate a vector-valued parameter.
openvdb::Vec3R evalVec3R(const char* name, fpreal time) const;
/// @brief Evaluate a vector-valued parameter.
openvdb::Vec3i evalVec3i(const char* name, fpreal time) const;
/// @brief Evaluate a vector-valued parameter.
openvdb::Vec2R evalVec2R(const char* name, fpreal time) const;
/// @brief Evaluate a vector-valued parameter.
openvdb::Vec2i evalVec2i(const char* name, fpreal time) const;
/// @brief Evaluate a string-valued parameter as an STL string.
/// @details This method facilitates string parameter evaluation in expressions.
/// For example,
/// @code
/// matchGroup(*gdp, evalStdString("group", time));
/// @endcode
std::string evalStdString(const char* name, fpreal time, int index = 0) const;
/// @}
protected:
/// @{
/// @brief To facilitate compilable SOPs, cookMySop() is now final.
/// Instead, either override SOP_NodeVDB::cookVDBSop() (for a non-compilable SOP)
/// or override SOP_VDBCacheOptions::cookVDBSop() (for a compilable SOP).
OP_ERROR cookMySop(OP_Context&) override final;
virtual OP_ERROR cookVDBSop(OP_Context&) { return UT_ERROR_NONE; }
/// @}
OP_ERROR cookMyGuide1(OP_Context&) override;
//OP_ERROR cookMyGuide2(OP_Context&) override;
/// @brief Transfer the value of an obsolete parameter that was renamed
/// to the parameter with the new name.
/// @details This convenience method is intended to be called from
/// @c resolveObsoleteParms(), when that function is implemented.
void resolveRenamedParm(PRM_ParmList& obsoleteParms,
const char* oldName, const char* newName);
/// @name Input stealing
/// @{
/// @brief Steal the geometry on the specified input if possible, instead of copying the data.
///
/// @details In certain cases where a node's input geometry isn't being shared with
/// other nodes, it is safe for the node to directly modify the geometry.
/// Normally, input geometry is shared with the upstream node's output cache,
/// so for stealing to be possible, the "unload" flag must be set on the upstream node
/// to inhibit caching. In addition, reference counting of GEO_PrimVDB shared pointers
/// ensures we cannot steal data that is in use elsewhere. When stealing is not possible,
/// this method falls back to copying the shared pointer, effectively performing
/// a duplicateSource().
///
/// @param index the index of the input from which to perform this operation
/// @param context the current SOP context is used for cook time for network traversal
/// @param pgdp pointer to the SOP's gdp
/// @param gdh handle to manage input locking
/// @param clean (forwarded to duplicateSource())
///
/// @note Prior to Houdini 13.0, this method peforms a duplicateSource() and unlocks the
/// inputs to the SOP. From Houdini 13.0 on, this method will insert the existing data
/// into the detail and update the detail handle in the SOP.
///
/// @warning No attempt to call duplicateSource() or inputGeo() should be made after
/// calling this method, as there will be no data on the input stream if isSourceStealable()
/// returns @c true.
/// @deprecated verbification renders this redundant
[[deprecated]]
OP_ERROR duplicateSourceStealable(const unsigned index,
OP_Context& context, GU_Detail **pgdp, GU_DetailHandle& gdh, bool clean = true);
/// @brief Steal the geometry on the specified input if possible, instead of copying the data.
///
/// @details In certain cases where a node's input geometry isn't being shared with
/// other nodes, it is safe for the node to directly modify the geometry.
/// Normally, input geometry is shared with the upstream node's output cache,
/// so for stealing to be possible, the "unload" flag must be set on the upstream node
/// to inhibit caching. In addition, reference counting of GEO_PrimVDB shared pointers
/// ensures we cannot steal data that is in use elsewhere. When stealing is not possible,
/// this method falls back to copying the shared pointer, effectively performing
/// a duplicateSource().
///
/// @note Prior to Houdini 13.0, this method peforms a duplicateSource() and unlocks the
/// inputs to the SOP. From Houdini 13.0 on, this method will insert the existing data
/// into the detail and update the detail handle in the SOP.
///
/// @param index the index of the input from which to perform this operation
/// @param context the current SOP context is used for cook time for network traversal
/// @deprecated verbification renders this redundant
[[deprecated]]
OP_ERROR duplicateSourceStealable(const unsigned index, OP_Context& context);
/// @}
private:
/// @brief Traverse the upstream network to determine if the source input can be stolen.
///
/// An upstream SOP cannot be stolen if it is implicitly caching the data (no "unload" flag)
/// or explictly caching the data (using a Cache SOP)
///
/// The traversal ignores pass through nodes such as null SOPs and bypassing.
///
/// @param index the index of the input from which to perform this operation
/// @param context the current SOP context is used for cook time for network traversal
/// @deprecated verbification renders this redundant
[[deprecated]]
bool isSourceStealable(const unsigned index, OP_Context& context) const;
}; // class SOP_NodeVDB
////////////////////////////////////////
/// @brief Namespace to hold functionality for registering info text callbacks. Whenever
/// getNodeSpecificInfoText() is called, the default info text is added to MMB output unless
/// a valid callback has been registered for the grid type.
///
/// @details Use node_info_text::registerGridSpecificInfoText<> to register a grid type to
/// a function pointer which matches the ApplyGridSpecificInfoText signature.
///
/// void floatGridText(std::ostream&, const openvdb::GridBase&);
///
/// node_info_text::registerGridSpecificInfoText<openvdb::FloatGrid>(&floatGridText);
///
namespace node_info_text
{
// The function pointer signature expected when registering an grid type text
// callback. The grid is passed untyped but is guaranteed to match the registered
// type.
using ApplyGridSpecificInfoText = void (*)(std::ostream&, const openvdb::GridBase&);
/// @brief Register an info text callback to a specific grid type.
/// @note Does not add the callback if the grid type already has a registered callback.
/// @param gridType the grid type as a unique string (see templated
/// registerGridSpecificInfoText<>)
/// @param callback a pointer to the callback function to execute
void registerGridSpecificInfoText(const std::string& gridType,
ApplyGridSpecificInfoText callback);
/// @brief Register an info text callback to a templated grid type.
/// @note Does not add the callback if the grid type already has a registered callback.
/// @param callback a pointer to the callback function to execute
template<typename GridType>
inline void registerGridSpecificInfoText(ApplyGridSpecificInfoText callback)
{
registerGridSpecificInfoText(GridType::gridType(), callback);
}
} // namespace node_info_text
} // namespace openvdb_houdini
#endif // OPENVDB_HOUDINI_SOP_NODEVDB_HAS_BEEN_INCLUDED
| 10,423 | C | 43.931034 | 99 | 0.702293 |
NVIDIA-Omniverse/ext-openvdb/openvdb_houdini/openvdb_houdini/SOP_OpenVDB_Create.cc | // Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
/// @file SOP_OpenVDB_Create.cc
///
/// @author FX R&D OpenVDB team
#include <houdini_utils/ParmFactory.h>
#include <openvdb_houdini/GeometryUtil.h>
#include <openvdb_houdini/SOP_NodeVDB.h>
#include <openvdb_houdini/UT_VDBTools.h> // for GridTransformOp, et al.
#include <openvdb_houdini/Utils.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_WorkArgs.h>
#include <hboost/algorithm/string/case_conv.hpp>
#include <hboost/algorithm/string/trim.hpp>
#include <OBJ/OBJ_Camera.h>
#include <cmath>
#include <stdexcept>
#include <string>
#include <vector>
namespace hvdb = openvdb_houdini;
namespace hutil = houdini_utils;
namespace cvdb = openvdb;
////////////////////////////////////////
namespace {
// Add new items to the *end* of this list, and update NUM_DATA_TYPES.
enum DataType {
TYPE_FLOAT = 0,
TYPE_DOUBLE,
TYPE_INT,
TYPE_BOOL,
TYPE_VEC3S,
TYPE_VEC3D,
TYPE_VEC3I
};
enum { NUM_DATA_TYPES = TYPE_VEC3I + 1 };
std::string
dataTypeToString(DataType dts)
{
std::string ret;
switch (dts) {
case TYPE_FLOAT: ret = "float"; break;
case TYPE_DOUBLE: ret = "double"; break;
case TYPE_INT: ret = "int"; break;
case TYPE_BOOL: ret = "bool"; break;
case TYPE_VEC3S: ret = "vec3s"; break;
case TYPE_VEC3D: ret = "vec3d"; break;
case TYPE_VEC3I: ret = "vec3i"; break;
}
return ret;
}
std::string
dataTypeToMenuItems(DataType dts)
{
std::string ret;
switch (dts) {
case TYPE_FLOAT: ret = "float"; break;
case TYPE_DOUBLE: ret = "double"; break;
case TYPE_INT: ret = "int"; break;
case TYPE_BOOL: ret = "bool"; break;
case TYPE_VEC3S: ret = "vec3s (float)"; break;
case TYPE_VEC3D: ret = "vec3d (double)"; break;
case TYPE_VEC3I: ret = "vec3i (int)"; break;
}
return ret;
}
DataType
stringToDataType(const std::string& s)
{
DataType ret = TYPE_FLOAT;
std::string str = s;
hboost::trim(str);
hboost::to_lower(str);
if (str == dataTypeToString(TYPE_FLOAT)) {
ret = TYPE_FLOAT;
} else if (str == dataTypeToString(TYPE_DOUBLE)) {
ret = TYPE_DOUBLE;
} else if (str == dataTypeToString(TYPE_INT)) {
ret = TYPE_INT;
} else if (str == dataTypeToString(TYPE_BOOL)) {
ret = TYPE_BOOL;
} else if (str == dataTypeToString(TYPE_VEC3S)) {
ret = TYPE_VEC3S;
} else if (str == dataTypeToString(TYPE_VEC3D)) {
ret = TYPE_VEC3D;
} else if (str == dataTypeToString(TYPE_VEC3I)) {
ret = TYPE_VEC3I;
}
return ret;
}
} // unnamed namespace
////////////////////////////////////////
class SOP_OpenVDB_Create : public hvdb::SOP_NodeVDB
{
public:
SOP_OpenVDB_Create(OP_Network *net, const char *name, OP_Operator *op);
~SOP_OpenVDB_Create() override {}
static OP_Node* factory(OP_Network*, const char* name, OP_Operator*);
int isRefInput(unsigned) const override { return true; }
int updateNearFar(float time);
int updateFarPlane(float time);
int updateNearPlane(float time);
protected:
OP_ERROR cookVDBSop(OP_Context&) override;
bool updateParmsFlags() override;
void resolveObsoleteParms(PRM_ParmList*) override;
private:
inline cvdb::Vec3i voxelToIndex(const cvdb::Vec3R& V) const
{
return cvdb::Vec3i(cvdb::Int32(V[0]), cvdb::Int32(V[1]), cvdb::Int32(V[2]));
}
template<typename GridType>
void createNewGrid(
const UT_String& gridNameStr,
const typename GridType::ValueType& background,
const cvdb::math::Transform::Ptr&,
const cvdb::MaskGrid::ConstPtr& maskGrid = nullptr,
GA_PrimitiveGroup* group = nullptr,
int gridClass = 0,
int vecType = -1);
OP_ERROR buildTransform(OP_Context&, openvdb::math::Transform::Ptr&, const GU_PrimVDB*);
const GU_PrimVDB* getReferenceVdb(OP_Context &context);
cvdb::MaskGrid::Ptr createMaskGrid(const GU_PrimVDB*, const openvdb::math::Transform::Ptr&);
bool mNeedsResampling;
};
////////////////////////////////////////
// Callback functions that update the near and far parameters
int updateNearFarCallback(void*, int, float, const PRM_Template*);
int updateNearPlaneCallback(void*, int, float, const PRM_Template*);
int updateFarPlaneCallback(void*, int, float, const PRM_Template*);
int
updateNearFarCallback(void* data, int /*idx*/, float time, const PRM_Template*)
{
SOP_OpenVDB_Create* sop = static_cast<SOP_OpenVDB_Create*>(data);
if (sop == nullptr) return 0;
return sop->updateNearFar(time);
}
int
SOP_OpenVDB_Create::updateNearFar(float time)
{
const auto cameraPath = evalStdString("camera", time);
if (cameraPath.empty()) return 1;
OBJ_Node *camobj = findOBJNode(cameraPath.c_str());
if (!camobj) return 1;
OBJ_Camera* cam = camobj->castToOBJCamera();
if (!cam) return 1;
fpreal nearPlane = cam->getNEAR(time);
fpreal farPlane = cam->getFAR(time);
setFloat("nearPlane", 0, time, nearPlane);
setFloat("farPlane", 0, time, farPlane);
return 1;
}
int
updateNearPlaneCallback(void* data, int /*idx*/, float time, const PRM_Template*)
{
SOP_OpenVDB_Create* sop = static_cast<SOP_OpenVDB_Create*>(data);
if (sop == nullptr) return 0;
return sop->updateNearPlane(time);
}
int
SOP_OpenVDB_Create::updateNearPlane(float time)
{
fpreal
nearPlane = evalFloat("nearPlane", 0, time),
farPlane = evalFloat("farPlane", 0, time),
voxelDepthSize = evalFloat("voxelDepthSize", 0, time);
if (!(voxelDepthSize > 0.0)) voxelDepthSize = 1e-6;
farPlane -= voxelDepthSize;
if (farPlane < nearPlane) {
setFloat("nearPlane", 0, time, farPlane);
}
return 1;
}
int
updateFarPlaneCallback(void* data, int /*idx*/, float time, const PRM_Template*)
{
SOP_OpenVDB_Create* sop = static_cast<SOP_OpenVDB_Create*>(data);
if (sop == nullptr) return 0;
return sop->updateFarPlane(time);
}
int
SOP_OpenVDB_Create::updateFarPlane(float time)
{
fpreal
nearPlane = evalFloat("nearPlane", 0, time),
farPlane = evalFloat("farPlane", 0, time),
voxelDepthSize = evalFloat("voxelDepthSize", 0, time);
if (!(voxelDepthSize > 0.0)) voxelDepthSize = 1e-6;
nearPlane += voxelDepthSize;
if (farPlane < nearPlane) {
setFloat("farPlane", 0, time, nearPlane);
}
return 1;
}
////////////////////////////////////////
void
newSopOperator(OP_OperatorTable *table)
{
if (table == nullptr) return;
hutil::ParmList parms;
// Group name
parms.add(hutil::ParmFactory(PRM_STRING, "group", "Group")
.setTooltip("Specify a name for this group of VDBs."));
parms.add(hutil::ParmFactory(PRM_SEPARATOR,"sep1", "Sep"));
// Transform type
parms.add(hutil::ParmFactory(PRM_ORD | PRM_TYPE_JOIN_NEXT, "transform", "Transform")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, {
"linear", "Linear",
"frustum", "Frustum",
"refVDB", "Reference VDB"
})
.setTooltip(
"The type of transform to assign to each VDB\n\n"
"Linear:\n"
" Rotation and scale only\n"
"Frustum:\n"
" Perspective projection, with focal length and near and far planes"
" from a given camera\n"
"Reference VDB:\n"
" Match the transform of an input VDB."));
// Toggle to preview the frustum
parms.add(hutil::ParmFactory(PRM_TOGGLE, "previewFrustum", "Preview")
.setDefault(PRMoneDefaults)
.setTooltip("Generate geometry indicating the bounds of the camera frustum.")
.setDocumentation(
"For a frustum transform, generate geometry indicating"
" the bounds of the camera frustum."));
// Uniform voxel size
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxelSize", "Voxel Size")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 5)
.setTooltip("The size (length of a side) of a cubic voxel in world units")
.setTooltip(
"For non-frustum transforms, the size (length of a side)"
" of a cubic voxel in world units"));
// Rotation
parms.add(hutil::ParmFactory(PRM_XYZ_J, "rotation", "Rotation")
.setVectorSize(3)
.setDefault(PRMzeroDefaults)
.setTooltip("Rotation specified in ZYX order"));
// Frustum settings
// {
parms.add(hutil::ParmFactory(PRM_STRING, "camera", "Camera")
.setTypeExtended(PRM_TYPE_DYNAMIC_PATH)
.setCallbackFunc(&updateNearFarCallback)
.setSpareData(&PRM_SpareData::objCameraPath)
.setTooltip("The path to the reference camera object (e.g., \"/obj/cam1\")")
.setDocumentation(
"For a frustum transform, the path to the reference camera object"
" (for example, `/obj/cam1`)"));
parms.add(hutil::ParmFactory(PRM_FLT_J | PRM_TYPE_JOIN_NEXT, "nearPlane", "Near/Far Planes")
.setDefault(PRMzeroDefaults)
.setCallbackFunc(&updateNearPlaneCallback)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 20)
.setTooltip("The near and far plane distances in world units")
.setDocumentation(
"The near and far plane distances in world units\n\n"
"The near plane distance should always be <= `farPlane` − `voxelDepthSize`,\n"
"and the far plane distance should always be => `nearPlane` + `voxelDepthSize`."));
parms.add(hutil::ParmFactory(
PRM_FLT_J | PRM_Type(PRM_Type::PRM_INTERFACE_LABEL_NONE), "farPlane", "")
.setDefault(PRMoneDefaults)
.setCallbackFunc(&updateFarPlaneCallback)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 20)
.setTooltip("Far plane distance, should always be >= nearPlane + voxelDepthSize")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_INT_J, "voxelCount", "Voxel Count")
.setDefault(PRM100Defaults)
.setRange(PRM_RANGE_RESTRICTED, 1, PRM_RANGE_UI, 200)
.setTooltip("The desired width of the near plane in voxels"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxelDepthSize", "Voxel Depth")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 5)
.setTooltip("The z dimension of a voxel in world units (all voxels have the same depth)")
.setTooltip(
"For a frustum transform, the z dimension of a voxel"
" in world units (all voxels have the same depth)"));
parms.add(hutil::ParmFactory(PRM_FLT_J, "cameraOffset", "Camera Offset")
.setDefault(PRMzeroDefaults)
.setRange(PRM_RANGE_RESTRICTED, 0.0, PRM_RANGE_FREE, 20.0)
.setTooltip(
"Add padding to the frustum without changing the near and far plane positions.\n\n"
"The camera position is offset in the direction opposite the view."));
// }
// Matching settings
parms.add(hutil::ParmFactory(PRM_STRING, "reference", "Reference")
.setChoiceList(&hutil::PrimGroupMenuInput2)
.setTooltip("The VDB to be used as a reference")
.setDocumentation(
"A VDB from the second input to be used as reference"
" (see [specifying volumes|/model/volumes#group])\n\n"
"If multiple VDBs are selected, only the first one will be used."));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "useVoxelSize", "")
.setTypeExtended(PRM_TYPE_TOGGLE_JOIN)
.setDefault(PRMzeroDefaults)
.setTooltip(
"If enabled, use the given voxel size, otherwise"
" match the voxel size of the reference VDB."));
parms.add(hutil::ParmFactory(PRM_FLT_J, "voxelSizeRef", "Voxel Size")
.setDefault(PRMoneDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1e-5, PRM_RANGE_UI, 5)
.setTooltip("The size (length of a side) of a cubic voxel in world units")
.setDocumentation(nullptr));
parms.add(hutil::ParmFactory(PRM_TOGGLE, "matchTopology", "Match Topology")
.setDefault(PRMoneDefaults)
.setTooltip("Match the voxel topology of the reference VDB."));
// Grids Heading
parms.add(hutil::ParmFactory(PRM_HEADING, "gridsHeading", ""));
// Dynamic grid menu
hutil::ParmList gridParms;
{
{ // Grid class menu
std::vector<std::string> items;
for (int i = 0; i < openvdb::NUM_GRID_CLASSES; ++i) {
openvdb::GridClass cls = openvdb::GridClass(i);
items.push_back(openvdb::GridBase::gridClassToString(cls)); // token
items.push_back(openvdb::GridBase::gridClassToMenuName(cls)); // label
}
gridParms.add(hutil::ParmFactory(PRM_STRING, "gridClass#", "Class")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip("Specify how voxel values should be interpreted.")
.setDocumentation("\
How voxel values should be interpreted\n\
\n\
Fog Volume:\n\
The volume represents a density field. Values should be positive,\n\
with zero representing empty regions.\n\
Level Set:\n\
The volume is treated as a narrow-band signed distance field level set.\n\
The voxels within a certain distance—the \"narrow band width\"—of\n\
an isosurface are expected to define positive (exterior) and negative (interior)\n\
distances to the surface. Outside the narrow band, the distance value\n\
is constant and equal to the band width.\n\
Staggered Vector Field:\n\
If the volume is vector-valued, the _x_, _y_ and _z_ vector components\n\
are to be treated as lying on the respective faces of voxels,\n\
not at their centers.\n\
Other:\n\
No special meaning is assigned to the volume's data.\n"));
}
{ // Element type menu
std::vector<std::string> items;
for (int i = 0; i < NUM_DATA_TYPES; ++i) {
items.push_back(dataTypeToString(DataType(i))); // token
items.push_back(dataTypeToMenuItems(DataType(i))); // label
}
gridParms.add(hutil::ParmFactory(PRM_STRING, "elementType#", "Type")
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip("The type of value stored at each voxel")
.setDocumentation(
"The type of value stored at each voxel\n\n"
"VDB volumes are able to store vector values, unlike Houdini volumes,\n"
"which require one scalar volume for each vector component."));
}
// Optional grid name string
gridParms.add(hutil::ParmFactory(PRM_STRING, "gridName#", "Name")
.setTooltip("A name for this VDB")
.setDocumentation("A value for the `name` attribute of this VDB primitive"));
// Default background values
// {
const char* bgHelpStr = "The \"default\" value for any voxel not explicitly set";
gridParms.add(hutil::ParmFactory(PRM_FLT_J, "bgFloat#", "Background Value")
.setTooltip(bgHelpStr)
.setDocumentation(bgHelpStr));
gridParms.add(hutil::ParmFactory(PRM_INT_J, "bgInt#", "Background Value")
.setDefault(PRMoneDefaults)
.setTooltip(bgHelpStr)
.setDocumentation(nullptr));
gridParms.add(hutil::ParmFactory(PRM_INT_J, "bgBool#", "Background Value")
.setRange(PRM_RANGE_RESTRICTED, 0, PRM_RANGE_RESTRICTED, 1)
.setDefault(PRMoneDefaults)
.setTooltip(bgHelpStr)
.setDocumentation(nullptr));
gridParms.add(hutil::ParmFactory(PRM_FLT_J, "bgVec3f#", "Background Value")
.setVectorSize(3)
.setTooltip(bgHelpStr)
.setDocumentation(nullptr));
gridParms.add(hutil::ParmFactory(PRM_INT_J, "bgVec3i#", "Background Value")
.setVectorSize(3)
.setTooltip(bgHelpStr)
.setDocumentation(nullptr));
gridParms.add(hutil::ParmFactory(PRM_FLT_J, "width#", "Half-Band Width")
.setDefault(PRMthreeDefaults)
.setRange(PRM_RANGE_RESTRICTED, 1.0, PRM_RANGE_UI, 10)
.setTooltip(
"Half the width of the narrow band, in voxels\n\n"
"(Many level set operations require this to be a minimum of three voxels.)"));
// }
// Vec type menu
{
std::string help =
"For vector-valued VDBs, specify an interpretation of the vectors"
" that determines how they are affected by transforms.\n";
std::vector<std::string> items;
for (int i = 0; i < openvdb::NUM_VEC_TYPES ; ++i) {
const auto vectype = static_cast<openvdb::VecType>(i);
items.push_back(openvdb::GridBase::vecTypeToString(vectype));
items.push_back(openvdb::GridBase::vecTypeExamples(vectype));
help += "\n" + openvdb::GridBase::vecTypeExamples(vectype) + "\n "
+ openvdb::GridBase::vecTypeDescription(vectype) + ".";
}
gridParms.add(hutil::ParmFactory(PRM_ORD, "vecType#", "Vector Type")
.setDefault(PRMzeroDefaults)
.setChoiceListItems(PRM_CHOICELIST_SINGLE, items)
.setTooltip(help.c_str()));
}
}
parms.add(hutil::ParmFactory(PRM_MULTITYPE_LIST, "gridList", "VDBs")
.setMultiparms(gridParms)
.setDefault(PRMoneDefaults));
// Obsolete parameters
hutil::ParmList obsoleteParms;
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING,
"propertiesHeading", "Shared Grid Properties"));
obsoleteParms.add(hutil::ParmFactory(PRM_HEADING, "frustumHeading", "Frustum Grid Settings"));
obsoleteParms.add(hutil::ParmFactory(PRM_FLT_J, "padding", "Padding"));
obsoleteParms.add(hutil::ParmFactory(PRM_TOGGLE, "matchVoxelSize", "Match Voxel Size"));
// Register this operator.
hvdb::OpenVDBOpFactory("VDB Create", SOP_OpenVDB_Create::factory, parms, *table)
.setObsoleteParms(obsoleteParms)
.addOptionalInput("Optional Input to Merge With")
.addOptionalInput("Optional Reference VDB")
.setDocumentation("\
#icon: COMMON/openvdb\n\
#tags: vdb\n\
\n\
\"\"\"Create one or more empty VDB volume primitives.\"\"\"\n\
\n\
@overview\n\
\n\
[Include:volume_types]\n\
\n\
@related\n\
- [OpenVDB From Particles|Node:sop/DW_OpenVDBFromParticles]\n\
- [OpenVDB From Polygons|Node:sop/DW_OpenVDBFromPolygons]\n\
- [OpenVDB Metadata|Node:sop/DW_OpenVDBMetadata]\n\
- [Node:sop/vdb]\n\
\n\
@examples\n\
\n\
See [openvdb.org|http://www.openvdb.org/download/] for source code\n\
and usage examples.\n");
}
////////////////////////////////////////
OP_Node *
SOP_OpenVDB_Create::factory(OP_Network *net, const char *name, OP_Operator *op)
{
return new SOP_OpenVDB_Create(net, name, op);
}
SOP_OpenVDB_Create::SOP_OpenVDB_Create(OP_Network *net, const char *name, OP_Operator *op)
: hvdb::SOP_NodeVDB(net, name, op)
, mNeedsResampling(false)
{
}
////////////////////////////////////////
bool
SOP_OpenVDB_Create::updateParmsFlags()
{
bool changed = false;
UT_String tmpStr;
const auto transformParm = evalInt("transform", 0, 0);
const bool linear = (transformParm == 0);
const bool frustum = (transformParm == 1);
const bool matching = (transformParm == 2);
for (int i = 1, N = static_cast<int>(evalInt("gridList", 0, 0)); i <= N; ++i) {
evalStringInst("gridClass#", &i, tmpStr, 0, 0);
openvdb::GridClass gridClass = openvdb::GridBase::stringToGridClass(tmpStr.toStdString());
evalStringInst("elementType#", &i, tmpStr, 0, 0);
DataType eType = stringToDataType(tmpStr.toStdString());
bool isLevelSet = false;
// Force a specific data type for some of the grid classes
if (gridClass == openvdb::GRID_LEVEL_SET) {
eType = TYPE_FLOAT;
isLevelSet = true;
} else if (gridClass == openvdb::GRID_FOG_VOLUME) {
eType = TYPE_FLOAT;
} else if (gridClass == openvdb::GRID_STAGGERED) {
eType = TYPE_VEC3S;
}
/// Disbale unused bg value options
changed |= enableParmInst("bgFloat#", &i,
!isLevelSet && (eType == TYPE_FLOAT || eType == TYPE_DOUBLE));
changed |= enableParmInst("width#", &i, isLevelSet);
changed |= enableParmInst("bgInt#", &i, eType == TYPE_INT || eType == TYPE_BOOL);
changed |= enableParmInst("bgVec3f#", &i, eType == TYPE_VEC3S || eType == TYPE_VEC3D);
changed |= enableParmInst("bgVec3i#", &i, eType == TYPE_VEC3I);
changed |= enableParmInst("vecType#", &i, eType >= TYPE_VEC3S);
// Hide unused bg value options.
changed |= setVisibleStateInst("bgFloat#", &i,
!isLevelSet && (eType == TYPE_FLOAT || eType == TYPE_DOUBLE));
changed |= setVisibleStateInst("width#", &i, isLevelSet);
changed |= setVisibleStateInst("bgInt#", &i, eType == TYPE_INT);
changed |= setVisibleStateInst("bgBool#", &i, eType == TYPE_BOOL);
changed |= setVisibleStateInst("bgVec3f#", &i, eType == TYPE_VEC3S || eType == TYPE_VEC3D);
changed |= setVisibleStateInst("bgVec3i#", &i, eType == TYPE_VEC3I);
changed |= setVisibleStateInst("vecType#", &i, eType >= TYPE_VEC3S);
// Enable different data types
changed |= enableParmInst("elementType#", &i, gridClass == openvdb::GRID_UNKNOWN);
changed |= setVisibleStateInst("elementType#", &i, gridClass == openvdb::GRID_UNKNOWN);
}
// linear transform and voxel size
changed |= enableParm("voxelSize", linear);
changed |= enableParm("rotation", linear);
changed |= setVisibleState("voxelSize", linear);
changed |= setVisibleState("rotation", linear);
// frustum transform
const auto cameraPath = evalStdString("camera", 0);
const bool enableFrustumSettings = (!cameraPath.empty() && findOBJNode(cameraPath.c_str()));
changed |= enableParm("camera", frustum);
changed |= enableParm("voxelCount", frustum & enableFrustumSettings);
changed |= enableParm("voxelDepthSize", frustum & enableFrustumSettings);
changed |= enableParm("offset", frustum & enableFrustumSettings);
changed |= enableParm("nearPlane", frustum & enableFrustumSettings);
changed |= enableParm("farPlane", frustum & enableFrustumSettings);
changed |= enableParm("cameraOffset", frustum & enableFrustumSettings);
changed |= enableParm("previewFrustum", frustum & enableFrustumSettings);
changed |= setVisibleState("camera", frustum);
changed |= setVisibleState("voxelCount", frustum);
changed |= setVisibleState("voxelDepthSize", frustum);
changed |= setVisibleState("offset", frustum);
changed |= setVisibleState("nearPlane", frustum);
changed |= setVisibleState("farPlane", frustum);
changed |= setVisibleState("cameraOffset", frustum);
changed |= setVisibleState("previewFrustum", frustum);
// matching
const bool useVoxelSize = evalInt("useVoxelSize", 0, 0);
changed |= enableParm("reference", matching);
changed |= enableParm("useVoxelSize", matching);
changed |= enableParm("voxelSizeRef", matching && useVoxelSize);
changed |= enableParm("matchTopology", matching);
changed |= setVisibleState("reference", matching);
changed |= setVisibleState("useVoxelSize", matching);
changed |= setVisibleState("voxelSizeRef", matching);
changed |= setVisibleState("matchTopology", matching);
changed |= setVisibleState("matchTopologyPlaceholder", false);
return changed;
}
void
SOP_OpenVDB_Create::resolveObsoleteParms(PRM_ParmList* obsoleteParms)
{
if (!obsoleteParms) return;
PRM_Parm* parm = obsoleteParms->getParmPtr("matchVoxelSize");
if (parm && !parm->isFactoryDefault()) {
const bool matchVoxelSize = obsoleteParms->evalInt("matchVoxelSize", 0, /*time=*/0.0);
setInt("useVoxelSize", 0, 0.0, !matchVoxelSize);
}
// Delegate to the base class.
hvdb::SOP_NodeVDB::resolveObsoleteParms(obsoleteParms);
}
////////////////////////////////////////
template<typename GridType>
void
SOP_OpenVDB_Create::createNewGrid(
const UT_String& gridNameStr,
const typename GridType::ValueType& background,
const cvdb::math::Transform::Ptr& transform,
const cvdb::MaskGrid::ConstPtr& maskGrid,
GA_PrimitiveGroup* group,
int gridClass,
int vecType)
{
using Tree = typename GridType::TreeType;
// Create a grid of a pre-registered type and assign it a transform.
hvdb::GridPtr newGrid;
if (maskGrid) {
newGrid = GridType::create(
typename Tree::Ptr(new Tree(maskGrid->tree(), background, cvdb::TopologyCopy())));
} else {
newGrid = GridType::create(background);
}
newGrid->setTransform(transform);
newGrid->setGridClass(openvdb::GridClass(gridClass));
if (vecType != -1) newGrid->setVectorType(openvdb::VecType(vecType));
// Store the grid in a new VDB primitive and add the primitive
// to the output geometry detail.
GEO_PrimVDB* vdb = hvdb::createVdbPrimitive(*gdp, newGrid,
gridNameStr.toStdString().c_str());
// Add the primitive to the group.
if (group) group->add(vdb);
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Create::cookVDBSop(OP_Context &context)
{
try {
hutil::ScopedInputLock lock(*this, context);
gdp->clearAndDestroy();
if (getInput(0)) duplicateSource(0, context);
fpreal time = context.getTime();
// Create a group for the grid primitives.
const auto groupStr = evalStdString("group", time);
GA_PrimitiveGroup* group = (groupStr.empty() ?
nullptr : gdp->newPrimitiveGroup(groupStr.c_str()));
// Get reference VDB, if exists
const bool matchTransfom = (evalInt("transform", 0, time) == 2);
const GU_PrimVDB* refVdb = (matchTransfom ? getReferenceVdb(context) : nullptr);
// Create a shared transform
cvdb::math::Transform::Ptr transform;
if (buildTransform(context, transform, refVdb) >= UT_ERROR_ABORT) return error();
cvdb::MaskGrid::Ptr maskGrid;
const bool matchTopology = evalInt("matchTopology", 0, time);
if (matchTransfom && matchTopology)
maskGrid = createMaskGrid(refVdb, transform);
// Create the grids
UT_String gridNameStr, tmpStr;
for (int i = 1, N = static_cast<int>(evalInt("gridList", 0, 0)); i <= N; ++i) {
evalStringInst("gridName#", &i, gridNameStr, 0, time);
evalStringInst("gridClass#", &i, tmpStr, 0, time);
openvdb::GridClass gridClass =
openvdb::GridBase::stringToGridClass(tmpStr.toStdString());
evalStringInst("elementType#", &i, tmpStr, 0, time);
DataType eType = stringToDataType(tmpStr.toStdString());
// Force a specific data type for some of the grid classes
if (gridClass == openvdb::GRID_LEVEL_SET ||
gridClass == openvdb::GRID_FOG_VOLUME) {
eType = TYPE_FLOAT;
} else if (gridClass == openvdb::GRID_STAGGERED) {
eType = TYPE_VEC3S;
}
switch(eType) {
case TYPE_FLOAT:
{
float voxelSize = float(transform->voxelSize()[0]);
float background = 0.0;
if (gridClass == openvdb::GRID_LEVEL_SET) {
background = float(evalFloatInst("width#", &i, 0, time) * voxelSize);
} else {
background = float(evalFloatInst("bgFloat#", &i, 0, time));
}
createNewGrid<cvdb::FloatGrid>(
gridNameStr, background, transform, maskGrid, group, gridClass);
break;
}
case TYPE_DOUBLE:
{
double background = double(evalFloatInst("bgFloat#", &i, 0, time));
createNewGrid<cvdb::DoubleGrid>(
gridNameStr, background, transform, maskGrid, group, gridClass);
break;
}
case TYPE_INT:
{
int background = static_cast<int>(evalIntInst("bgInt#", &i, 0, time));
createNewGrid<cvdb::Int32Grid>(
gridNameStr, background, transform, maskGrid, group, gridClass);
break;
}
case TYPE_BOOL:
{
bool background = evalIntInst("bgBool#", &i, 0, time);
createNewGrid<cvdb::BoolGrid>(
gridNameStr, background, transform, maskGrid, group, gridClass);
break;
}
case TYPE_VEC3S:
{
cvdb::Vec3f background(
float(evalFloatInst("bgVec3f#", &i, 0, time)),
float(evalFloatInst("bgVec3f#", &i, 1, time)),
float(evalFloatInst("bgVec3f#", &i, 2, time)));
int vecType = static_cast<int>(evalIntInst("vecType#", &i, 0, time));
createNewGrid<cvdb::Vec3SGrid>(
gridNameStr, background, transform, maskGrid, group, gridClass, vecType);
break;
}
case TYPE_VEC3D:
{
cvdb::Vec3d background(
double(evalFloatInst("bgVec3f#", &i, 0, time)),
double(evalFloatInst("bgVec3f#", &i, 1, time)),
double(evalFloatInst("bgVec3f#", &i, 2, time)));
int vecType = static_cast<int>(evalIntInst("vecType#", &i, 0, time));
createNewGrid<cvdb::Vec3DGrid>(
gridNameStr, background, transform, maskGrid, group, gridClass, vecType);
break;
}
case TYPE_VEC3I:
{
cvdb::Vec3i background(
static_cast<cvdb::Int32>(evalIntInst("bgVec3i#", &i, 0, time)),
static_cast<cvdb::Int32>(evalIntInst("bgVec3i#", &i, 1, time)),
static_cast<cvdb::Int32>(evalIntInst("bgVec3i#", &i, 2, time)));
int vecType = static_cast<int>(evalIntInst("vecType#", &i, 0, time));
createNewGrid<cvdb::Vec3IGrid>(
gridNameStr, background, transform, maskGrid, group, gridClass, vecType);
break;
}
} // eType switch
} // grid create loop
} catch ( std::exception& e) {
addError(SOP_MESSAGE, e.what());
}
return error();
}
////////////////////////////////////////
OP_ERROR
SOP_OpenVDB_Create::buildTransform(OP_Context& context, openvdb::math::Transform::Ptr& transform,
const GU_PrimVDB* refVdb)
{
fpreal time = context.getTime();
const auto transformParm = evalInt("transform", 0, time);
const bool linear = (transformParm == 0);
const bool frustum = (transformParm == 1);
if (frustum) { // nonlinear frustum transform
const auto cameraPath = evalStdString("camera", time);
if (cameraPath.empty()) {
addError(SOP_MESSAGE, "No camera selected");
return error();
}
OBJ_Node *camobj = findOBJNode(cameraPath.c_str());
if (!camobj) {
addError(SOP_MESSAGE, "Camera not found");
return error();
}
OBJ_Camera* cam = camobj->castToOBJCamera();
if (!cam) {
addError(SOP_MESSAGE, "Camera not found");
return error();
}
// Register
this->addExtraInput(cam, OP_INTEREST_DATA);
const float
offset = static_cast<float>(evalFloat("cameraOffset", 0, time)),
nearPlane = static_cast<float>(evalFloat("nearPlane", 0, time)),
farPlane = static_cast<float>(evalFloat("farPlane", 0, time)),
voxelDepthSize = static_cast<float>(evalFloat("voxelDepthSize", 0, time));
const int voxelCount = static_cast<int>(evalInt("voxelCount", 0, time));
transform = hvdb::frustumTransformFromCamera(*this, context, *cam,
offset, nearPlane, farPlane, voxelDepthSize, voxelCount);
if (bool(evalInt("previewFrustum", 0, time))) {
UT_Vector3 boxColor(0.6f, 0.6f, 0.6f);
UT_Vector3 tickColor(0.0f, 0.0f, 0.0f);
hvdb::drawFrustum(*gdp, *transform,
&boxColor, &tickColor, /*shaded*/true);
}
} else if (linear) { // linear affine transform
const double voxelSize = double(evalFloat("voxelSize", 0, time));
openvdb::Vec3d rotation(
evalFloat("rotation", 0, time),
evalFloat("rotation", 1, time),
evalFloat("rotation", 2, time));
if (std::abs(rotation.x()) < 0.00001 && std::abs(rotation.y()) < 0.00001
&& std::abs(rotation.z()) < 0.00001) {
transform = openvdb::math::Transform::createLinearTransform(voxelSize);
} else {
openvdb::math::Mat4d xform(openvdb::math::Mat4d::identity());
xform.preRotate(openvdb::math::X_AXIS, rotation.x());
xform.preRotate(openvdb::math::Y_AXIS, rotation.y());
xform.preRotate(openvdb::math::Z_AXIS, rotation.z());
xform.preScale(openvdb::Vec3d(voxelSize));
transform = openvdb::math::Transform::createLinearTransform(xform);
}
} else { // match reference
if (refVdb == nullptr) {
addError(SOP_MESSAGE, "Missing reference grid");
return error();
}
transform = refVdb->getGrid().transform().copy();
const bool useVoxelSize = evalInt("useVoxelSize", 0, time);
if (useVoxelSize) { // NOT matching the reference's voxel size
if (!transform->isLinear()) {
addError(SOP_MESSAGE, "Cannot change voxel size on a non-linear transform");
return error();
}
const double voxelSize = double(evalFloat("voxelSizeRef", 0, time));
openvdb::Vec3d relativeVoxelScale = voxelSize / refVdb->getGrid().voxelSize();
// If the user is changing the voxel size to the original,
// then there is no need to do anything
if (!isApproxEqual(openvdb::Vec3d::ones(), relativeVoxelScale)) {
mNeedsResampling = true;
transform->preScale(relativeVoxelScale);
}
}
}
return error();
}
////////////////////////////////////////
const GU_PrimVDB*
SOP_OpenVDB_Create::getReferenceVdb(OP_Context &context)
{
const GU_Detail* refGdp = inputGeo(1, context);
if (!refGdp) return nullptr;
const GA_PrimitiveGroup* refGroup = matchGroup(
*refGdp, evalStdString("reference", context.getTime()));
hvdb::VdbPrimCIterator vdbIter(refGdp, refGroup);
const GU_PrimVDB* refVdb = *vdbIter;
if (++vdbIter) {
addWarning(SOP_MESSAGE, "Multiple reference grids were found.\n"
"Using the first one for reference.");
}
return refVdb;
}
////////////////////////////////////////
class GridConvertToMask {
public:
GridConvertToMask(cvdb::MaskGrid::Ptr& maskGrid) : outGrid(maskGrid) {}
template<typename GridType>
void operator()(const GridType& inGrid)
{
using MaskTree = cvdb::MaskGrid::TreeType;
outGrid = cvdb::MaskGrid::create(
MaskTree::Ptr(new MaskTree(inGrid.tree(), 0, cvdb::TopologyCopy())));
}
private:
cvdb::MaskGrid::Ptr& outGrid;
};
cvdb::MaskGrid::Ptr
SOP_OpenVDB_Create::createMaskGrid(const GU_PrimVDB* refVdb,
const openvdb::math::Transform::Ptr& transform)
{
if (refVdb == nullptr)
throw std::runtime_error("Missing reference grid");
cvdb::MaskGrid::Ptr maskGrid;
GridConvertToMask op(maskGrid);
if (hvdb::GEOvdbApply<hvdb::AllGridTypes>(*refVdb, op)) {
maskGrid->setTransform(refVdb->getGrid().transform().copy());
} else {
throw std::runtime_error("No valid reference grid found");
}
if (!mNeedsResampling)
return maskGrid;
cvdb::MaskGrid::Ptr resampledMaskGrid = cvdb::MaskGrid::create();
resampledMaskGrid->setTransform(transform);
hvdb::Interrupter interrupter;
cvdb::tools::resampleToMatch<cvdb::tools::PointSampler>(*maskGrid, *resampledMaskGrid,
interrupter);
return resampledMaskGrid;
}
| 37,024 | C++ | 35.29902 | 99 | 0.604527 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.