0030131: Foundation Classes - support of Linear builder for 2D BVH trees

BVH_LinearBuilder and BVH_RadixSorter now accept N==2.
NCollection_Vec2/3/4 - added missing division by vec operators.

diff --git a/src/BVH/BVH.cxx b/src/BVH/BVH.cxx
index 451fd0c19d202eb091f50ac3d2b6ef1f68151201..671844e50ccb82acde3846b6f15e19f26327c482 100644 (file)
--- a/src/BVH/BVH.cxx
+++ b/src/BVH/BVH.cxx
@@ -105,15 +105,19 @@ template class BVH_QuickSorter<Standard_Real, 4>;
 template class BVH_QuickSorter<Standard_ShortReal, 3>;
 template class BVH_QuickSorter<Standard_ShortReal, 4>;
 
+template class BVH_RadixSorter<Standard_Real, 2>;
 template class BVH_RadixSorter<Standard_Real, 3>;
 template class BVH_RadixSorter<Standard_Real, 4>;
 
+template class BVH_RadixSorter<Standard_ShortReal, 2>;
 template class BVH_RadixSorter<Standard_ShortReal, 3>;
 template class BVH_RadixSorter<Standard_ShortReal, 4>;
 
+template class BVH_LinearBuilder<Standard_Real, 2>;
 template class BVH_LinearBuilder<Standard_Real, 3>;
 template class BVH_LinearBuilder<Standard_Real, 4>;
 
+template class BVH_LinearBuilder<Standard_ShortReal, 2>;
 template class BVH_LinearBuilder<Standard_ShortReal, 3>;
 template class BVH_LinearBuilder<Standard_ShortReal, 4>;
 

diff --git a/src/BVH/BVH_LinearBuilder.hxx b/src/BVH/BVH_LinearBuilder.hxx
index c2aee79389b084c1a5bcdbcbc82aae4cee331864..35e20d46f4a69571032132139087c89a02fd8482 100644 (file)
--- a/src/BVH/BVH_LinearBuilder.hxx
+++ b/src/BVH/BVH_LinearBuilder.hxx
@@ -308,7 +308,7 @@ void BVH_LinearBuilder<T, N>::Build (BVH_Set<T, N>*       theSet,
                                      BVH_Tree<T, N>*      theBVH,
                                      const BVH_Box<T, N>& theBox) const
 {
-  Standard_STATIC_ASSERT (N == 3 || N == 4);
+  Standard_STATIC_ASSERT (N == 2 || N == 3 || N == 4);
   const Standard_Integer aSetSize = theSet->Size();
   if (theBVH == NULL || aSetSize == 0)
   {

diff --git a/src/BVH/BVH_RadixSorter.hxx b/src/BVH/BVH_RadixSorter.hxx
index 83acb45e65c3ff8c7db2084fe2ffb4aae385b076..4425a74231809e22c1254e779a2692cd9590b520 100644 (file)
--- a/src/BVH/BVH_RadixSorter.hxx
+++ b/src/BVH/BVH_RadixSorter.hxx
@@ -173,18 +173,18 @@ namespace BVH
 template<class T, int N>
 void BVH_RadixSorter<T, N>::Perform (BVH_Set<T, N>* theSet, const Standard_Integer theStart, const Standard_Integer theFinal)
 {
-  Standard_STATIC_ASSERT (N == 3 || N == 4);
+  Standard_STATIC_ASSERT (N == 2 || N == 3 || N == 4);
 
-  const Standard_Integer aDimensionX = 1024;
-  const Standard_Integer aDimensionY = 1024;
-  const Standard_Integer aDimensionZ = 1024;
+  const Standard_Integer aDimension = 1024;
+  const Standard_Integer aNbEffComp = N == 2 ? 2 : 3; // 4th component is ignored
 
   const BVH_VecNt aSceneMin = myBox.CornerMin();
   const BVH_VecNt aSceneMax = myBox.CornerMax();
 
-  const T aReverseSizeX = static_cast<T> (aDimensionX) / Max (static_cast<T> (BVH::THE_NODE_MIN_SIZE), aSceneMax.x() - aSceneMin.x());
-  const T aReverseSizeY = static_cast<T> (aDimensionY) / Max (static_cast<T> (BVH::THE_NODE_MIN_SIZE), aSceneMax.y() - aSceneMin.y());
-  const T aReverseSizeZ = static_cast<T> (aDimensionZ) / Max (static_cast<T> (BVH::THE_NODE_MIN_SIZE), aSceneMax.z() - aSceneMin.z());
+  BVH_VecNt aNodeMinSizeVecT (static_cast<T>(BVH::THE_NODE_MIN_SIZE));
+  BVH::BoxMinMax<T, N>::CwiseMax (aNodeMinSizeVecT, aSceneMax - aSceneMin);
+
+  const BVH_VecNt aReverseSize = BVH_VecNt (static_cast<T>(aDimension)) / aNodeMinSizeVecT;
 
   myEncodedLinks = new NCollection_Shared<NCollection_Array1<BVH_EncodedLink> >(theStart, theFinal);
 
@@ -192,32 +192,24 @@ void BVH_RadixSorter<T, N>::Perform (BVH_Set<T, N>* theSet, const Standard_Integ
   for (Standard_Integer aPrimIdx = theStart; aPrimIdx <= theFinal; ++aPrimIdx)
   {
     const BVH_VecNt aCenter = theSet->Box (aPrimIdx).Center();
+    const BVH_VecNt aVoxelF = (aCenter - aSceneMin) * aReverseSize;
 
-    Standard_Integer aVoxelX = BVH::IntFloor ((aCenter.x() - aSceneMin.x()) * aReverseSizeX);
-    Standard_Integer aVoxelY = BVH::IntFloor ((aCenter.y() - aSceneMin.y()) * aReverseSizeY);
-    Standard_Integer aVoxelZ = BVH::IntFloor ((aCenter.z() - aSceneMin.z()) * aReverseSizeZ);
-
-    aVoxelX = Max (0, Min (aVoxelX, aDimensionX - 1));
-    aVoxelY = Max (0, Min (aVoxelY, aDimensionY - 1));
-    aVoxelZ = Max (0, Min (aVoxelZ, aDimensionZ - 1));
+    Standard_Integer aMortonCode = 0;
+    for (Standard_Integer aCompIter = 0; aCompIter < aNbEffComp; ++aCompIter)
+    {
+      Standard_Integer aVoxel = BVH::IntFloor (BVH::VecComp<T, N>::Get (aVoxelF, aCompIter));
 
-    aVoxelX = (aVoxelX | (aVoxelX << 16)) & 0x030000FF;
-    aVoxelX = (aVoxelX | (aVoxelX <<  8)) & 0x0300F00F;
-    aVoxelX = (aVoxelX | (aVoxelX <<  4)) & 0x030C30C3;
-    aVoxelX = (aVoxelX | (aVoxelX <<  2)) & 0x09249249;
+      aVoxel = Max (0, Min (aVoxel, aDimension - 1));
 
-    aVoxelY = (aVoxelY | (aVoxelY << 16)) & 0x030000FF;
-    aVoxelY = (aVoxelY | (aVoxelY <<  8)) & 0x0300F00F;
-    aVoxelY = (aVoxelY | (aVoxelY <<  4)) & 0x030C30C3;
-    aVoxelY = (aVoxelY | (aVoxelY <<  2)) & 0x09249249;
+      aVoxel = (aVoxel | (aVoxel << 16)) & 0x030000FF;
+      aVoxel = (aVoxel | (aVoxel <<  8)) & 0x0300F00F;
+      aVoxel = (aVoxel | (aVoxel <<  4)) & 0x030C30C3;
+      aVoxel = (aVoxel | (aVoxel <<  2)) & 0x09249249;
 
-    aVoxelZ = (aVoxelZ | (aVoxelZ << 16)) & 0x030000FF;
-    aVoxelZ = (aVoxelZ | (aVoxelZ <<  8)) & 0x0300F00F;
-    aVoxelZ = (aVoxelZ | (aVoxelZ <<  4)) & 0x030C30C3;
-    aVoxelZ = (aVoxelZ | (aVoxelZ <<  2)) & 0x09249249;
+      aMortonCode |= (aVoxel << aCompIter);
+    }
 
-    myEncodedLinks->ChangeValue (aPrimIdx) = BVH_EncodedLink (
-      aVoxelX | (aVoxelY << 1) | (aVoxelZ << 2), aPrimIdx);
+    myEncodedLinks->ChangeValue (aPrimIdx) = BVH_EncodedLink (aMortonCode, aPrimIdx);
   }
 
   // Step 2 -- Sort primitives by their Morton codes using radix sort

diff --git a/src/NCollection/NCollection_Vec2.hxx b/src/NCollection/NCollection_Vec2.hxx
index bb74d07def09a9105981042cdfa462bc80db33d9..c1ebb0509a2608b7025d40ddc6aa1c2121f4b73b 100644 (file)
--- a/src/NCollection/NCollection_Vec2.hxx
+++ b/src/NCollection/NCollection_Vec2.hxx
@@ -217,6 +217,14 @@ public:
     return *this;
   }
 
+  //! Compute per-component division.
+  NCollection_Vec2& operator/= (const NCollection_Vec2& theRight)
+  {
+    v[0] /= theRight.v[0];
+    v[1] /= theRight.v[1];
+    return *this;
+  }
+
   //! Compute per-component multiplication by scale factor.
   NCollection_Vec2 operator* (const Element_t theFactor) const
   {
@@ -230,6 +238,14 @@ public:
             v[1] / theInvFactor);
   }
 
+  //! Compute per-component division.
+  friend NCollection_Vec2 operator/ (const NCollection_Vec2& theLeft,
+                                     const NCollection_Vec2& theRight)
+  {
+    return NCollection_Vec2 (theLeft.v[0] / theRight.v[0],
+                             theLeft.v[1] / theRight.v[1]);
+  }
+
   //! Computes the dot product.
   Element_t Dot (const NCollection_Vec2& theOther) const
   {

diff --git a/src/NCollection/NCollection_Vec3.hxx b/src/NCollection/NCollection_Vec3.hxx
index 165b6d5801024c3ec2ff78f43f51ceabc633aec9..7a4e45b9f802ffc31f6f85d6e8597c75200bf953 100644 (file)
--- a/src/NCollection/NCollection_Vec3.hxx
+++ b/src/NCollection/NCollection_Vec3.hxx
@@ -290,6 +290,15 @@ public:
     return *this;
   }
 
+  //! Compute per-component division.
+  NCollection_Vec3& operator/= (const NCollection_Vec3& theRight)
+  {
+    v[0] /= theRight.v[0];
+    v[1] /= theRight.v[1];
+    v[2] /= theRight.v[2];
+    return *this;
+  }
+
   //! Compute per-component division by scale factor.
   NCollection_Vec3 operator/ (const Element_t theInvFactor) const
   {
@@ -297,6 +306,14 @@ public:
     return aResult /= theInvFactor;
   }
 
+  //! Compute per-component division.
+  friend NCollection_Vec3 operator/ (const NCollection_Vec3& theLeft,
+                                     const NCollection_Vec3& theRight)
+  {
+    NCollection_Vec3 aResult = NCollection_Vec3 (theLeft);
+    return aResult /= theRight;
+  }
+
   //! Computes the dot product.
   Element_t Dot (const NCollection_Vec3& theOther) const
   {

diff --git a/src/NCollection/NCollection_Vec4.hxx b/src/NCollection/NCollection_Vec4.hxx
index c3cb93a712b1f2aafd61bee586274de92fba6441..f049585df3c616fb0b42bb9d1ce598c0ad56fa5d 100644 (file)
--- a/src/NCollection/NCollection_Vec4.hxx
+++ b/src/NCollection/NCollection_Vec4.hxx
@@ -336,6 +336,16 @@ public:
     return *this;
   }
 
+  //! Compute per-component division.
+  NCollection_Vec4& operator/= (const NCollection_Vec4& theRight)
+  {
+    v[0] /= theRight.v[0];
+    v[1] /= theRight.v[1];
+    v[2] /= theRight.v[2];
+    v[3] /= theRight.v[3];
+    return *this;
+  }
+
   //! Compute per-component division by scale factor.
   NCollection_Vec4 operator/ (const Element_t theInvFactor)
   {
@@ -343,6 +353,14 @@ public:
     return aResult /= theInvFactor;
   }
 
+  //! Compute per-component division.
+  friend NCollection_Vec4 operator/ (const NCollection_Vec4& theLeft,
+                                     const NCollection_Vec4& theRight)
+  {
+    NCollection_Vec4 aResult = NCollection_Vec4 (theLeft);
+    return aResult /= theRight;
+  }
+
 private:
 
   Element_t v[4]; //!< define the vector as array to avoid structure alignment issues