37 #ifndef OPENVDB_TOOLS_COMPOSITE_HAS_BEEN_INCLUDED
38 #define OPENVDB_TOOLS_COMPOSITE_HAS_BEEN_INCLUDED
47 #include <boost/utility/enable_if.hpp>
59 inline void csgUnion(GridOrTreeT& a, GridOrTreeT& b,
bool prune =
true);
74 inline void compMax(GridOrTreeT& a, GridOrTreeT& b);
78 inline void compMin(GridOrTreeT& a, GridOrTreeT& b);
82 inline void compSum(GridOrTreeT& a, GridOrTreeT& b);
86 inline void compMul(GridOrTreeT& a, GridOrTreeT& b);
90 inline void compDiv(GridOrTreeT& a, GridOrTreeT& b);
94 inline void compReplace(GridOrTreeT& a,
const GridOrTreeT& b);
100 namespace composite {
103 template<
typename T>
inline
104 const typename boost::disable_if_c<VecTraits<T>::IsVec, T>::type&
107 template<
typename T>
inline
108 const typename boost::disable_if_c<VecTraits<T>::IsVec, T>::type&
113 template<
typename T>
inline
114 const typename boost::enable_if_c<VecTraits<T>::IsVec, T>::type&
115 min(
const T& a,
const T& b)
117 const typename T::ValueType aMag = a.lengthSqr(), bMag = b.lengthSqr();
118 return (aMag < bMag ? a : (bMag < aMag ? b :
std::min(a, b)));
121 template<
typename T>
inline
122 const typename boost::enable_if_c<VecTraits<T>::IsVec, T>::type&
123 max(
const T& a,
const T& b)
125 const typename T::ValueType aMag = a.lengthSqr(), bMag = b.lengthSqr();
126 return (aMag < bMag ? b : (bMag < aMag ? a :
std::max(a, b)));
130 template<
typename T>
inline
131 typename boost::disable_if<boost::is_integral<T>, T>::type
132 divide(
const T& a,
const T& b) {
return a / b; }
134 template<
typename T>
inline
135 typename boost::enable_if<boost::is_integral<T>, T>::type
139 if (b != zero)
return a / b;
140 if (a == zero)
return 0;
147 inline bool divide(
bool a,
bool ) {
return a; }
152 template<
typename Gr
idOrTreeT>
154 compMax(GridOrTreeT& aTree, GridOrTreeT& bTree)
157 typedef typename Adapter::TreeType TreeT;
158 typedef typename TreeT::ValueType ValueT;
164 Adapter::tree(aTree).combineExtended(Adapter::tree(bTree), Local::op,
false);
168 template<
typename Gr
idOrTreeT>
170 compMin(GridOrTreeT& aTree, GridOrTreeT& bTree)
173 typedef typename Adapter::TreeType TreeT;
174 typedef typename TreeT::ValueType ValueT;
180 Adapter::tree(aTree).combineExtended(Adapter::tree(bTree), Local::op,
false);
184 template<
typename Gr
idOrTreeT>
186 compSum(GridOrTreeT& aTree, GridOrTreeT& bTree)
189 typedef typename Adapter::TreeType TreeT;
195 Adapter::tree(aTree).combineExtended(Adapter::tree(bTree), Local::op,
false);
199 template<
typename Gr
idOrTreeT>
201 compMul(GridOrTreeT& aTree, GridOrTreeT& bTree)
204 typedef typename Adapter::TreeType TreeT;
210 Adapter::tree(aTree).combineExtended(Adapter::tree(bTree), Local::op,
false);
214 template<
typename Gr
idOrTreeT>
216 compDiv(GridOrTreeT& aTree, GridOrTreeT& bTree)
219 typedef typename Adapter::TreeType TreeT;
225 Adapter::tree(aTree).combineExtended(Adapter::tree(bTree), Local::op,
false);
232 template<
typename TreeT>
239 void operator()(
const typename TreeT::ValueOnCIter& iter)
const
242 iter.getBoundingBox(bbox);
243 aTree->fill(bbox, *iter);
246 void operator()(
const typename TreeT::LeafCIter& leafIter)
const
249 for (
typename TreeT::LeafCIter::LeafNodeT::ValueOnCIter iter =
250 leafIter->cbeginValueOn(); iter; ++iter)
252 acc.
setValue(iter.getCoord(), *iter);
258 template<
typename Gr
idOrTreeT>
263 typedef typename Adapter::TreeType TreeT;
264 typedef typename TreeT::ValueOnCIter ValueOnCIterT;
267 Adapter::tree(aTree).topologyUnion(Adapter::tree(bTree));
272 ValueOnCIterT iter = bTree.cbeginValueOn();
273 iter.setMaxDepth(iter.getLeafDepth() - 1);
277 foreach(Adapter::tree(bTree).cbeginLeaf(), op);
286 template<
typename TreeType>
291 typedef typename TreeT::ValueType
ValueT;
292 typedef typename TreeT::LeafNodeType::ChildAllIter
ChildIterT;
297 mAOutside(aTree.background()),
298 mAInside(math::
negative(mAOutside)),
299 mBOutside(bTree.background()),
302 const ValueT zero = zeroVal<ValueT>();
303 if (!(mAOutside > zero)) {
305 "expected grid A outside value > 0, got " << mAOutside);
307 if (!(mAInside < zero)) {
309 "expected grid A inside value < 0, got " << mAInside);
311 if (!(mBOutside > zero)) {
313 "expected grid B outside value > 0, got " << mBOutside);
315 if (!(mBInside < zero)) {
317 "expected grid B outside value < 0, got " << mBOutside);
329 template<
typename TreeType>
333 typedef typename TreeT::ValueType
ValueT;
334 typedef typename TreeT::LeafNodeType::ChildAllIter
ChildIterT;
341 template<
typename AIterT,
typename BIterT>
345 template<
typename IterT>
348 ValueT aValue = zeroVal<ValueT>();
349 typename IterT::ChildNodeType* aChild = aIter.probeChild(aValue);
350 if (!aChild && aValue < zeroVal<ValueT>()) {
355 ValueT bValue = zeroVal<ValueT>();
356 typename IterT::ChildNodeType* bChild = bIter.probeChild(bValue);
357 if (!bChild && bValue < zeroVal<ValueT>()) {
359 aIter.setValue(this->mAInside);
360 aIter.setValueOn(bIter.isValueOn());
365 if (!aChild && aValue > zeroVal<ValueT>()) {
369 bIter.setValue(this->mBOutside);
371 bChild->resetBackground(this->mBOutside, this->mAOutside);
372 aIter.setChild(bChild);
380 return (aChild && bChild) ? 0 : STOP;
386 ValueT aValue, bValue;
387 aIter.probeValue(aValue);
388 bIter.probeValue(bValue);
389 if (aValue > bValue) {
390 aIter.setValue(bValue);
391 aIter.setValueOn(bIter.isValueOn());
402 template<
typename TreeType>
406 typedef typename TreeT::ValueType
ValueT;
407 typedef typename TreeT::LeafNodeType::ChildAllIter
ChildIterT;
414 template<
typename AIterT,
typename BIterT>
418 template<
typename IterT>
421 ValueT aValue = zeroVal<ValueT>();
422 typename IterT::ChildNodeType* aChild = aIter.probeChild(aValue);
423 if (!aChild && !(aValue < zeroVal<ValueT>())) {
428 ValueT bValue = zeroVal<ValueT>();
429 typename IterT::ChildNodeType* bChild = bIter.probeChild(bValue);
430 if (!bChild && !(bValue < zeroVal<ValueT>())) {
432 aIter.setValue(this->mAOutside);
433 aIter.setValueOn(bIter.isValueOn());
438 if (!aChild && aValue < zeroVal<ValueT>()) {
442 bIter.setValue(this->mBOutside);
444 bChild->resetBackground(this->mBOutside, this->mAOutside);
445 aIter.setChild(bChild);
453 return (aChild && bChild) ? 0 : STOP;
459 ValueT aValue, bValue;
460 aIter.probeValue(aValue);
461 bIter.probeValue(bValue);
462 if (aValue < bValue) {
463 aIter.setValue(bValue);
464 aIter.setValueOn(bIter.isValueOn());
474 template<
typename TreeType>
478 typedef typename TreeT::ValueType
ValueT;
479 typedef typename TreeT::LeafNodeType::ChildAllIter
ChildIterT;
486 template<
typename AIterT,
typename BIterT>
490 template<
typename IterT>
493 ValueT aValue = zeroVal<ValueT>();
494 typename IterT::ChildNodeType* aChild = aIter.probeChild(aValue);
495 if (!aChild && !(aValue < zeroVal<ValueT>())) {
500 ValueT bValue = zeroVal<ValueT>();
501 typename IterT::ChildNodeType* bChild = bIter.probeChild(bValue);
502 if (!bChild && bValue < zeroVal<ValueT>()) {
504 aIter.setValue(this->mAOutside);
505 aIter.setValueOn(bIter.isValueOn());
510 if (!aChild && aValue < zeroVal<ValueT>()) {
514 bIter.setValue(this->mBOutside);
516 bChild->resetBackground(this->mBOutside, this->mAOutside);
517 aIter.setChild(bChild);
526 return (aChild && bChild) ? 0 : STOP;
532 ValueT aValue, bValue;
533 aIter.probeValue(aValue);
534 bIter.probeValue(bValue);
536 if (aValue < bValue) {
537 aIter.setValue(bValue);
538 aIter.setValueOn(bIter.isValueOn());
548 template<
typename Gr
idOrTreeT>
553 typedef typename Adapter::TreeType TreeT;
554 TreeT &aTree = Adapter::tree(a), &bTree = Adapter::tree(b);
556 aTree.visit2(bTree, visitor);
560 template<
typename Gr
idOrTreeT>
565 typedef typename Adapter::TreeType TreeT;
566 TreeT &aTree = Adapter::tree(a), &bTree = Adapter::tree(b);
568 aTree.visit2(bTree, visitor);
572 template<
typename Gr
idOrTreeT>
577 typedef typename Adapter::TreeType TreeT;
578 TreeT &aTree = Adapter::tree(a), &bTree = Adapter::tree(b);
580 aTree.visit2(bTree, visitor);
588 #endif // OPENVDB_TOOLS_COMPOSITE_HAS_BEEN_INCLUDED
T negative(const T &val)
Return the unary negation of the given value.
Definition: Math.h:116
const BValueType & b() const
Get the B input value.
Definition: Types.h:331
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at...
Definition: Exceptions.h:88
#define OPENVDB_THROW(exception, message)
Definition: Exceptions.h:97
Defined various multi-threaded utility functions for trees.
const AValueType & a() const
Get the A input value.
Definition: Types.h:329
#define OPENVDB_VERSION_NAME
Definition: version.h:43
Definition: Exceptions.h:39
CombineArgs & setResult(const AValueType &val)
Set the output value.
Definition: Types.h:339
This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type...
Definition: Grid.h:880
This struct collects both input and output arguments to "grid combiner" functors used with the tree::...
Definition: Types.h:304
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h:71
void setValue(const Coord &xyz, const ValueType &value)
Set the value of the voxel at the given coordinates and mark the voxel as active. ...
Definition: ValueAccessor.h:287