Merge pull request #1584 from kmuseth/fix_IteratorRange

Fixed precision bug in tree::RangeIterator

Author: Idclip

openvdb/openvdb/tree/TreeIterator.h

@@ -1302,13 +1302,20 @@ template<typename IterT>
 class IteratorRange
 {
 public:
+    /// @brief Constructor from iterator and grain size
+    /// @param iter Iterator from which the range is constructed
+    /// @param grainSize Grain size which controls the granularity of range splitting
     IteratorRange(const IterT& iter, size_t grainSize = 8):
         mIter(iter),
         mGrainSize(grainSize),
         mSize(0)
     {
         mSize = this->size();
     }
+
+    /// @brief Split constructor used by tbb (should rarely be called directly)
+    /// @param other IteratorRange to be split
+    /// @param  tbb::split Dummy class used to create a unique signature for this constructor
     IteratorRange(IteratorRange& other, tbb::split):
         mIter(other.mIter),
         mGrainSize(other.mGrainSize),
@@ -1331,24 +1338,23 @@ class IteratorRange
     bool is_divisible() const { return mSize > mGrainSize; }
 
     /// Advance the iterator @a n times.
-    void increment(Index n = 1) { for ( ; n > 0 && mSize > 0; --n, --mSize, ++mIter) {} }
+    void increment(size_t n = 1) { for ( ; n > 0 && mSize > 0; --n, --mSize, ++mIter) {} }
     /// Advance the iterator to the next item.
     IteratorRange& operator++() { this->increment(); return *this; }
     /// @brief Advance the iterator to the next item.
     /// @return @c true if the iterator is not yet exhausted.
     bool next() { this->increment(); return this->test(); }
 
 private:
-    Index size() const { Index n = 0; for (IterT it(mIter); it.test(); ++n, ++it) {} return n; }
+    size_t size() const { size_t n = 0; for (IterT it(mIter); it.test(); ++n, ++it) {} return n; }
 
     IterT mIter;
-    size_t mGrainSize;
+    size_t mGrainSize, mSize;
     /// @note mSize is only an estimate of the number of times mIter can be incremented
     /// before it is exhausted (because the topology of the underlying tree could change
     /// during iteration).  For the purpose of range splitting, though, that should be
     /// sufficient, since the two halves need not be of exactly equal size.
-    Index mSize;
-};
+};// class IteratorRange
 
 
 ////////////////////////////////////////

pendingchanges/fix_RangeIterator.txt

@@ -0,0 +1,2 @@
+Bug-fix:
+- Internal counters in tree::RangeIterator were limited to 32bit precision. They are now extended to size_t. (reported by SpaceX)