[Type] BoundingBox: Phase out TBoundingBox<Real> (#5676)

* add deprecated attribute for TBoundingBox

* rewrite computeBBox where TBoundingBox was used

* use dedicated macros

* fix compilation with sofacuda (and typo)

---------

Co-authored-by: Damien Marchal <damien.marchal@univ-lille1.fr>

Author: fredroy

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineModel.inl

@@ -568,30 +568,20 @@ void LineCollisionModel<DataTypes>::computeBBox(const core::ExecParams* params,
     if( onlyVisible && !sofa::core::visual::VisualParams::defaultInstance()->displayFlags().getShowCollisionModels())
         return;
 
-    static constexpr Real max_real = std::numeric_limits<Real>::max();
-    static constexpr Real min_real = std::numeric_limits<Real>::lowest();
-    Real maxBBox[3] = {min_real,min_real,min_real};
-    Real minBBox[3] = {max_real,max_real,max_real};
-
     const auto& positions = this->mstate->read(core::vec_id::read_access::position)->getValue();
+    type::BoundingBox bbox;
 
     for (sofa::Size i=0; i<size; i++)
     {
-        Element e(this,i);
+        const Element e(this,i);
         const Coord& pt1 = positions[this->elems[i].p[0]];
         const Coord& pt2 = positions[this->elems[i].p[1]];
 
-        for (int c=0; c<3; c++)
-        {
-            if (pt1[c] > maxBBox[c]) maxBBox[c] = (Real)pt1[c];
-            else if (pt1[c] < minBBox[c]) minBBox[c] = (Real)pt1[c];
-
-            if (pt2[c] > maxBBox[c]) maxBBox[c] = (Real)pt2[c];
-            else if (pt2[c] < minBBox[c]) minBBox[c] = (Real)pt2[c];
-        }
+        bbox.include(pt1);
+        bbox.include(pt2);
     }
 
-    this->f_bbox.setValue(sofa::type::TBoundingBox<Real>(minBBox,maxBBox));
+    this->f_bbox.setValue(bbox);
 }
 
 template<class DataTypes>

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointModel.inl

@@ -300,24 +300,17 @@ void PointCollisionModel<DataTypes>::computeBBox(const core::ExecParams* params,
     if (npoints != size)
         return;
 
-    static constexpr Real max_real = std::numeric_limits<Real>::max();
-    static constexpr Real min_real = std::numeric_limits<Real>::lowest();
-    Real maxBBox[3] = {min_real,min_real,min_real};
-    Real minBBox[3] = {max_real,max_real,max_real};
+    type::BoundingBox bbox;
 
     for (sofa::Size i=0; i<size; i++)
     {
-        Element e(this,i);
+        const Element e(this,i);
         const Coord& p = e.p();
 
-        for (int c=0; c<3; c++)
-        {
-            if (p[c] > maxBBox[c]) maxBBox[c] = (Real)p[c];
-            else if (p[c] < minBBox[c]) minBBox[c] = (Real)p[c];
-        }
+        bbox.include(p);
     }
 
-    this->f_bbox.setValue(sofa::type::TBoundingBox<Real>(minBBox,maxBBox));
+    this->f_bbox.setValue(bbox);
 }
 
 
@@ -326,7 +319,6 @@ template<class DataTypes>
 void PointCollisionModel<DataTypes>::draw(const core::visual::VisualParams*, sofa::Index index)
 {
     SOFA_UNUSED(index);
-    //TODO(fred roy 2018-06-21)...please implement.
 }
 
 

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereModel.inl

@@ -260,26 +260,20 @@ void SphereCollisionModel<DataTypes>::computeBBox(const core::ExecParams* params
     if( onlyVisible && !sofa::core::visual::VisualParams::defaultInstance()->displayFlags().getShowCollisionModels())
         return;
 
-    static constexpr Real max_real = std::numeric_limits<Real>::max();
-    Real maxBBox[3] = {-max_real,-max_real,-max_real}; //Warning: minimum of float/double is 0, not -inf
-    Real minBBox[3] = {max_real,max_real,max_real};
-
     const auto npoints = mstate->getSize();
+    type::BoundingBox bbox;
 
     for(sofa::Size i = 0 ; i < npoints ; ++i )
     {
-        TSphere<DataTypes> t(this,i);
+        const TSphere<DataTypes> t(this,i);
         const Coord& p = t.p();
-        Real r = t.r();
+        const Real r = t.r();
 
-        for (int c=0; c<3; c++)
-        {
-            if (p[c]+r > maxBBox[c]) maxBBox[c] = (Real)p[c]+r;
-            if (p[c]-r < minBBox[c]) minBBox[c] = (Real)p[c]-r;
-        }
+        bbox.include(p + type::Vec3{r,r,r});
+        bbox.include(p - type::Vec3{r,r,r});
     }
 
-    this->f_bbox.setValue(sofa::type::TBoundingBox<Real>(minBBox,maxBBox));
+    this->f_bbox.setValue(bbox);
 }
 
 } // namespace sofa::component::collision::geometry

Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModel.inl

@@ -384,33 +384,18 @@ void TriangleCollisionModel<DataTypes>::computeBBox(const core::ExecParams* para
     if (m_topology->getRevision() != m_topologyRevision)
         updateFromTopology();
 
-    static constexpr Real max_real = std::numeric_limits<Real>::max();
-    static constexpr Real min_real = std::numeric_limits<Real>::lowest();
-    Real maxBBox[3] = {min_real,min_real,min_real};
-    Real minBBox[3] = {max_real,max_real,max_real};
-
     const auto& positions = this->m_mstate->read(core::vec_id::read_access::position)->getValue();
+    type::BoundingBox bbox;
 
-    for (sofa::Size i=0; i<size; i++)
+    for(const auto& triangle : (*this->m_triangles))
     {
-        const type::Vec3& pt1 = positions[(*this->m_triangles)[i][0]];
-        const type::Vec3& pt2 = positions[(*this->m_triangles)[i][1]];
-        const type::Vec3& pt3 = positions[(*this->m_triangles)[i][2]];
-
-        for (int c=0; c<3; c++)
+        for(const auto ptindex : triangle)
         {
-            if (pt1[c] > maxBBox[c]) maxBBox[c] = (Real)pt1[c];
-            else if (pt1[c] < minBBox[c]) minBBox[c] = (Real)pt1[c];
-
-            if (pt2[c] > maxBBox[c]) maxBBox[c] = (Real)pt2[c];
-            else if (pt2[c] < minBBox[c]) minBBox[c] = (Real)pt2[c];
-
-            if (pt3[c] > maxBBox[c]) maxBBox[c] = (Real)pt3[c];
-            else if (pt3[c] < minBBox[c]) minBBox[c] = (Real)pt3[c];
+            bbox.include(positions[ptindex]);
         }
     }
 
-    this->f_bbox.setValue(sofa::type::TBoundingBox<Real>(minBBox,maxBBox));
+    this->f_bbox.setValue(bbox);
 }
 
 

Sofa/Component/Constraint/Projective/src/sofa/component/constraint/projective/FixedProjectiveConstraint.inl

@@ -365,26 +365,23 @@ void FixedProjectiveConstraint<DataTypes>::computeBBoxForIndices(const type::vec
 {
     using Real = typename DataTypes::Real;
 
-    constexpr Real max_real = std::numeric_limits<Real>::max();
-    constexpr Real min_real = std::numeric_limits<Real>::lowest();
-    Real maxBBox[3] = {min_real,min_real,min_real};
-    Real minBBox[3] = {max_real,max_real,max_real};
-
     const auto drawSize = static_cast<Real>(d_drawSize.getValue());
 
     const VecCoord& x = this->mstate->read(core::vec_id::read_access::position)->getValue();
 
-    for (const auto index : indices)
+    type::BoundingBox bbox;
+    for (const auto index : indices )
     {
         const auto x3d = DataTypes::getCPos(x[index]);
 
-        for (unsigned int i = 0; i < x3d.size(); ++i)
+        for (unsigned int i = 0; i < DataTypes::Coord::spatial_dimensions && i<3; ++i)
         {
-            maxBBox[i] = std::max(x3d[i] + drawSize, maxBBox[i]);
-            minBBox[i] = std::min(x3d[i] - drawSize, minBBox[i]);
+            bbox.maxBBox()[i] = std::max(static_cast<SReal>(x3d[i] + drawSize), bbox.maxBBox()[i]);
+            bbox.minBBox()[i] = std::min(static_cast<SReal>(x3d[i] - drawSize), bbox.minBBox()[i]);
         }
     }
-    this->f_bbox.setValue(sofa::type::TBoundingBox<Real>(minBBox,maxBBox));
+
+    this->f_bbox.setValue(bbox);
 }
 
 template <class DataTypes>

Sofa/Component/Engine/Select/src/sofa/component/engine/select/BaseROI.inl

@@ -38,7 +38,6 @@ using core::objectmodel::BaseData ;
 using core::objectmodel::Event ;
 using core::loader::MeshLoader ;
 using core::ExecParams ;
-using type::TBoundingBox ;
 using type::Vec3 ;
 using type::Vec4f ;
 using helper::WriteOnlyAccessor ;

Sofa/Component/Engine/Select/src/sofa/component/engine/select/BoxROI.inl

@@ -39,7 +39,6 @@ using core::objectmodel::ComponentState ;
 using core::objectmodel::BaseData ;
 using core::objectmodel::Event ;
 using core::ExecParams ;
-using type::TBoundingBox ;
 using type::Vec3 ;
 using type::Vec4f ;
 using helper::WriteOnlyAccessor ;

Sofa/Component/Engine/Select/src/sofa/component/engine/select/SubsetTopology.inl

@@ -878,22 +878,14 @@ void SubsetTopology<DataTypes>::computeBBox(const core::ExecParams*  params , bo
     SOFA_UNUSED(onlyVisible);
 
     const type::vector<Vec6>& vb=boxes.getValue();
-    const Real max_real = std::numeric_limits<Real>::max();
-    const Real min_real = std::numeric_limits<Real>::lowest();
-    Real maxBBox[3] = {min_real,min_real,min_real};
-    Real minBBox[3] = {max_real,max_real,max_real};
-
-    for (unsigned int bi=0; bi<vb.size(); ++bi)
+    type::BoundingBox bbox;
+    for (const auto& b : vb)
     {
-        const Vec6& b=vb[bi];
-        if (b[0] < minBBox[0]) minBBox[0] = b[0];
-        if (b[1] < minBBox[1]) minBBox[1] = b[1];
-        if (b[2] < minBBox[2]) minBBox[2] = b[2];
-        if (b[3] > maxBBox[0]) maxBBox[0] = b[3];
-        if (b[4] > maxBBox[1]) maxBBox[1] = b[4];
-        if (b[5] > maxBBox[2]) maxBBox[2] = b[5];
+        bbox.include(type::Vec3{b[0], b[1], b[2]});
+        bbox.include(type::Vec3{b[3], b[4], b[5]});
     }
-    this->f_bbox.setValue(sofa::type::TBoundingBox<Real>(minBBox,maxBBox));
+
+    this->f_bbox.setValue(bbox);
 }
 
 } //namespace sofa::component::engine::select

Sofa/Component/Engine/Transform/src/sofa/component/engine/transform/SmoothMeshEngine.inl

@@ -140,20 +140,13 @@ void SmoothMeshEngine<DataTypes>::computeBBox(const core::ExecParams*, bool only
 
 	helper::ReadAccessor< Data<VecCoord> > x(input_position);
 
-	static const Real max_real = std::numeric_limits<Real>::max();
-	static const Real min_real = std::numeric_limits<Real>::lowest();
-	Real maxBBox[3] = {min_real,min_real,min_real};
-	Real minBBox[3] = {max_real,max_real,max_real};
-	for (size_t i=0; i<x.size(); i++)
-	{
-		for (int c=0; c<3; c++)
-		{
-			if (x[i][c] > maxBBox[c]) maxBBox[c] = (Real)x[i][c];
-			else if (x[i][c] < minBBox[c]) minBBox[c] = (Real)x[i][c];
-		}
-	}
-
-	this->f_bbox.setValue(sofa::type::TBoundingBox<Real>(minBBox,maxBBox));
+    type::BoundingBox bbox;
+    for (const auto& p : x )
+    {
+        bbox.include(p);
+    }
+
+    this->f_bbox.setValue(bbox);
 }
 
 template <class DataTypes>

Sofa/Component/MechanicalLoad/src/sofa/component/mechanicalload/PlaneForceField.inl

@@ -410,32 +410,25 @@ void PlaneForceField<DataTypes>::computeBBox(const core::ExecParams * params, bo
     if (onlyVisible && !d_drawIsEnabled.getValue())
         return;
 
-    constexpr SReal max_real = std::numeric_limits<SReal>::max();
-    constexpr SReal min_real = std::numeric_limits<SReal>::lowest();
-    SReal maxBBox[3] = {min_real,min_real,min_real};
-    SReal minBBox[3] = {max_real,max_real,max_real};
-
     const SReal size = d_drawSize.getValue();
 
     type::Vec3 normal{}, v1{}, v2{};
     get3DFrameFromDPosNormal<DataTypes>(d_planeNormal.getValue(), v1, v2, normal);
 
     const type::Vec3& center = normal*d_planeD.getValue();
-    type::Vec3 corners[4];
+    std::array<type::Vec3, 4> corners;
     corners[0] = center-v1*size-v2*size;
     corners[1] = center+v1*size-v2*size;
     corners[2] = center+v1*size+v2*size;
     corners[3] = center-v1*size+v2*size;
 
-    for (unsigned int i=0; i<4; i++)
+    type::BoundingBox bbox;
+    for (const auto& c : corners )
     {
-        for (int c=0; c<3; c++)
-        {
-            if (corners[i][c] > maxBBox[c]) maxBBox[c] = corners[i][c];
-            if (corners[i][c] < minBBox[c]) minBBox[c] = corners[i][c];
-        }
+        bbox.include(c);
     }
-    this->f_bbox.setValue(sofa::type::TBoundingBox<SReal>(minBBox,maxBBox));
+
+    this->f_bbox.setValue(bbox);
 }
 
 } // namespace sofa::component::mechanicalload