Merge pull request #941 from Xiangyu-Hu/xiangyu/bonuding_box_generalization

Xiangyu/bonuding box generalization

Author: Xiangyu-Hu

modules/opencascade/opencascade/surface_shape.cpp

@@ -26,7 +26,7 @@ Vecd SurfaceShape::findClosestPoint(const Vecd &input_pnt)
 
 ////=================================================================================================//
 bool SurfaceShape::checkContain(const Vecd &pnt, bool BOUNDARY_INCLUDED) { return 0; }
-BoundingBox SurfaceShape::findBounds() { return BoundingBox(); }
+BoundingBoxd SurfaceShape::findBounds() { return BoundingBoxd(); }
 //=================================================================================================//
 
 Vecd SurfaceShape::getCartesianPoint(Standard_Real u, Standard_Real v)

modules/opencascade/opencascade/surface_shape.h

@@ -49,7 +49,7 @@ class SurfaceShape : public Shape
     Handle_Geom_Surface surface_;
 
   protected:
-    virtual BoundingBox findBounds() override;
+    virtual BoundingBoxd findBounds() override;
 };
 
 class SurfaceShapeSTEP : public SurfaceShape

modules/opencascade/tests/test_3d_aortic_valve/aortic_valve.cpp

@@ -28,7 +28,7 @@ Vec3d domain_upper_bound(15.0, 15.0, 26.0);
 //----------------------------------------------------------------------
 //	Domain bounds of the system.
 //----------------------------------------------------------------------
-BoundingBox system_domain_bounds(domain_lower_bound, domain_upper_bound);
+BoundingBoxd system_domain_bounds(domain_lower_bound, domain_upper_bound);
 
 namespace SPH
 {

modules/structural_simulation/structural_simulation_class.cpp

@@ -16,7 +16,7 @@ BodyPartFromMesh::BodyPartFromMesh(SPHBody &body, SharedPtr<TriangleMeshShape> t
     : BodyRegionByParticle(body, triangle_mesh_shape_ptr)
 {
     // set the body domain bounds because it is not set by default
-    BoundingBox bounds = triangle_mesh_shape_ptr->getBounds();
+    BoundingBoxd bounds = triangle_mesh_shape_ptr->getBounds();
     setBodyPartBounds(bounds);
 }
 
@@ -46,18 +46,18 @@ SolidBodyForSimulation::SolidBodyForSimulation(
     std::cout << "  normal initialization done" << std::endl;
 }
 
-BoundingBox expandBoundingBox(const BoundingBox &original, const BoundingBox &additional)
+BoundingBoxd expandBoundingBox(const BoundingBoxd &original, const BoundingBoxd &additional)
 {
-    BoundingBox expanded = original;
-    for (int i = 0; i < expanded.first_.size(); i++)
+    BoundingBoxd expanded = original;
+    for (int i = 0; i < expanded.lower_.size(); i++)
     {
-        if (additional.first_[i] < expanded.first_[i])
+        if (additional.lower_[i] < expanded.lower_[i])
         {
-            expanded.first_[i] = additional.first_[i];
+            expanded.lower_[i] = additional.lower_[i];
         }
-        if (additional.second_[i] > expanded.second_[i])
+        if (additional.upper_[i] > expanded.upper_[i])
         {
-            expanded.second_[i] = additional.second_[i];
+            expanded.upper_[i] = additional.upper_[i];
         }
     }
     return expanded;
@@ -108,7 +108,7 @@ void relaxParticlesSingleResolution(bool write_particle_relaxation_data,
 std::tuple<Vecd *, Real *> generateAndRelaxParticlesFromMesh(
     SharedPtr<TriangleMeshShape> triangle_mesh_shape, Real resolution, bool particle_relaxation, bool write_particle_relaxation_data)
 {
-    BoundingBox bb = triangle_mesh_shape->getBounds();
+    BoundingBoxd bb = triangle_mesh_shape->getBounds();
     SPHSystem system(bb, resolution);
     SolidBody model(system, triangle_mesh_shape);
     model.defineBodyLevelSetShape()->cleanLevelSet();
@@ -197,7 +197,7 @@ StructuralSimulation::StructuralSimulation(const StructuralSimulationInput &inpu
       particle_relaxation_list_(input.particle_relaxation_list_),
       write_particle_relaxation_data_(input.write_particle_relaxation_data_),
       system_resolution_(0.0),
-      system_(SPHSystem(BoundingBox(Vec3d::Zero(), Vec3d::Zero()), system_resolution_)),
+      system_(SPHSystem(BoundingBoxd(Vec3d::Zero(), Vec3d::Zero()), system_resolution_)),
       scale_system_boundaries_(input.scale_system_boundaries_),
       physical_time_(*system_.getSystemVariableDataByName<Real>("PhysicalTime")),
 
@@ -284,17 +284,17 @@ void StructuralSimulation::calculateSystemBoundaries()
     // calculate system bounds from all bodies
     for (size_t i = 0; i < body_mesh_list_.size(); i++)
     {
-        BoundingBox additional = body_mesh_list_[i]->getBounds();
+        BoundingBoxd additional = body_mesh_list_[i]->getBounds();
         system_.setSystemDomainBounds(expandBoundingBox(system_.getSystemDomainBounds(), additional));
     }
     // scale the system bounds around the center point
-    Vecd center_point = (system_.getSystemDomainBounds().first_ + system_.getSystemDomainBounds().second_) * 0.5;
+    Vecd center_point = (system_.getSystemDomainBounds().lower_ + system_.getSystemDomainBounds().upper_) * 0.5;
 
-    Vecd distance_first = system_.getSystemDomainBounds().first_ - center_point;
-    Vecd distance_second = system_.getSystemDomainBounds().second_ - center_point;
+    Vecd distance_first = system_.getSystemDomainBounds().lower_ - center_point;
+    Vecd distance_second = system_.getSystemDomainBounds().upper_ - center_point;
 
-    system_.getSystemDomainBounds().first_ = center_point + distance_first * scale_system_boundaries_;
-    system_.getSystemDomainBounds().second_ = center_point + distance_second * scale_system_boundaries_;
+    system_.getSystemDomainBounds().lower_ = center_point + distance_first * scale_system_boundaries_;
+    system_.getSystemDomainBounds().upper_ = center_point + distance_second * scale_system_boundaries_;
 }
 
 void StructuralSimulation::createBodyMeshList()
@@ -430,17 +430,17 @@ void StructuralSimulation::initializeForceInBodyRegion()
     for (size_t i = 0; i < force_in_body_region_tuple_.size(); i++)
     {
         int body_index = std::get<0>(force_in_body_region_tuple_[i]);
-        BoundingBox bbox = std::get<1>(force_in_body_region_tuple_[i]);
+        BoundingBoxd bbox = std::get<1>(force_in_body_region_tuple_[i]);
         Vec3d force = std::get<2>(force_in_body_region_tuple_[i]);
         Real end_time = std::get<3>(force_in_body_region_tuple_[i]);
 
         // get the length of each side to create the box
-        Real x_side = bbox.second_[0] - bbox.first_[0];
-        Real y_side = bbox.second_[1] - bbox.first_[1];
-        Real z_side = bbox.second_[2] - bbox.first_[2];
+        Real x_side = bbox.upper_[0] - bbox.lower_[0];
+        Real y_side = bbox.upper_[1] - bbox.lower_[1];
+        Real z_side = bbox.upper_[2] - bbox.lower_[2];
         Vec3d halfsize_bbox(0.5 * x_side, 0.5 * y_side, 0.5 * z_side);
         // get the center point for translation from the origin
-        Vec3d center = (bbox.second_ + bbox.first_) * 0.5;
+        Vec3d center = (bbox.upper_ + bbox.lower_) * 0.5;
         // SimTK geometric modeling resolution
         int resolution(20);
         // create the triangle mesh of the box
@@ -510,15 +510,15 @@ void StructuralSimulation::initializeConstrainSolidBodyRegion()
     for (size_t i = 0; i < body_indices_fixed_constraint_region_.size(); i++)
     {
         int body_index = body_indices_fixed_constraint_region_[i].first;
-        BoundingBox bbox = body_indices_fixed_constraint_region_[i].second;
+        BoundingBoxd bbox = body_indices_fixed_constraint_region_[i].second;
 
         // get the length of each side to create the box
-        Real x_side = bbox.second_[0] - bbox.first_[0];
-        Real y_side = bbox.second_[1] - bbox.first_[1];
-        Real z_side = bbox.second_[2] - bbox.first_[2];
+        Real x_side = bbox.upper_[0] - bbox.lower_[0];
+        Real y_side = bbox.upper_[1] - bbox.lower_[1];
+        Real z_side = bbox.upper_[2] - bbox.lower_[2];
         Vec3d halfsize_bbox(0.5 * x_side, 0.5 * y_side, 0.5 * z_side);
         // get the center point for translation from the origin
-        Vec3d center = (bbox.second_ + bbox.first_) * 0.5;
+        Vec3d center = (bbox.upper_ + bbox.lower_) * 0.5;
         // SimTK geometric modeling resolution
         int resolution(20);
         // create the triangle mesh of the box

modules/structural_simulation/structural_simulation_class.h

@@ -37,8 +37,8 @@
 using namespace SPH;
 
 using GravityPair = std::pair<int, Vec3d>;
-using AccelTuple = std::tuple<int, BoundingBox, Vec3d>;
-using ForceTuple = std::tuple<int, BoundingBox, Vec3d, Real>;
+using AccelTuple = std::tuple<int, BoundingBoxd, Vec3d>;
+using ForceTuple = std::tuple<int, BoundingBoxd, Vec3d, Real>;
 using PressureTuple = std::tuple<int, SharedPtr<TriangleMeshShape>, Vec3d, StdVec<std::array<Real, 2>>>;
 using SpringDamperTuple = std::tuple<int, Vec3d, Real>;
 /**
@@ -51,11 +51,11 @@ using SpringDamperTuple = std::tuple<int, Vec3d, Real>;
  * Real: damping coefficient
  */
 using SurfaceSpringTuple = std::tuple<int, SharedPtr<TriangleMeshShape>, bool, Vec3d, Real, Real>;
-using ConstrainedRegionPair = std::pair<int, BoundingBox>;
+using ConstrainedRegionPair = std::pair<int, BoundingBoxd>;
 using PositionSolidBodyTuple = std::tuple<int, Real, Real, Vec3d>;
 using PositionScaleSolidBodyTuple = std::tuple<int, Real, Real, Real>;
 using TranslateSolidBodyTuple = std::tuple<int, Real, Real, Vec3d>;
-using TranslateSolidBodyPartTuple = std::tuple<int, Real, Real, Vec3d, BoundingBox>;
+using TranslateSolidBodyPartTuple = std::tuple<int, Real, Real, Vec3d, BoundingBoxd>;
 
 #ifdef __EMSCRIPTEN__
 struct StlData
@@ -114,7 +114,7 @@ class SolidBodyForSimulation
     DampingWithRandomChoice<InteractionSplit<DampingPairwiseInner<Vec3d, FixedDampingRate>>> *getDampingWithRandomChoice() { return &damping_random_; };
 };
 
-BoundingBox expandBoundingBox(const BoundingBox &original, const BoundingBox &additional);
+BoundingBoxd expandBoundingBox(const BoundingBoxd &original, const BoundingBoxd &additional);
 
 void relaxParticlesSingleResolution(bool write_particles_to_file,
                                     SolidBodyFromMesh &solid_body_from_mesh,

src/for_2D_build/common/data_type.h

@@ -43,7 +43,7 @@ using MatTend = Mat3d;           // matricized symmetric 2x2x2x2 tensor
 using VecMatGrad = VecMatGrad2d; // gradient of vectorized symmetric 2x2 matrix
 using AngularVecd = Real;
 using Rotation = Rotation2d;
-using BoundingBox = BaseBoundingBox<Vec2d>;
+using BoundingBoxd = BoundingBox<Real, 2>;
 using Transform = BaseTransform<Rotation2d, Vec2d>;
 
 /** only works for smoothing length ratio less or equal than 1.3*/

src/for_2D_build/geometries/multi_polygon_shape.cpp

@@ -250,7 +250,7 @@ Vecd MultiPolygon::findClosestPoint(const Vecd &probe_point)
     return p_find;
 }
 //=================================================================================================//
-BoundingBox MultiPolygon::findBounds()
+BoundingBoxd MultiPolygon::findBounds()
 {
     Vecd lower_bound = Vecd::Zero();
     Vecd upper_bound = Vecd::Zero();
@@ -259,7 +259,7 @@ BoundingBox MultiPolygon::findBounds()
     lower_bound[1] = bg::return_envelope<box>(multi_poly_).min_corner().get<1>();
     upper_bound[0] = bg::return_envelope<box>(multi_poly_).max_corner().get<0>();
     upper_bound[1] = bg::return_envelope<box>(multi_poly_).max_corner().get<1>();
-    return BoundingBox(lower_bound, upper_bound);
+    return BoundingBoxd(lower_bound, upper_bound);
 }
 //=================================================================================================//
 bool MultiPolygonShape::isValid()
@@ -277,7 +277,7 @@ Vecd MultiPolygonShape::findClosestPoint(const Vecd &probe_point)
     return multi_polygon_.findClosestPoint(probe_point);
 }
 //=================================================================================================//
-BoundingBox MultiPolygonShape::findBounds()
+BoundingBoxd MultiPolygonShape::findBounds()
 {
     return multi_polygon_.findBounds();
 }

src/for_2D_build/geometries/multi_polygon_shape.h

@@ -85,7 +85,7 @@ class MultiPolygon
     explicit MultiPolygon(const Vecd &center, Real radius, int resolution);
     boost_multi_poly &getBoostMultiPoly() { return multi_poly_; };
 
-    BoundingBox findBounds();
+    BoundingBoxd findBounds();
     bool checkContain(const Vecd &pnt, bool BOUNDARY_INCLUDED = true);
     Vecd findClosestPoint(const Vecd &probe_point);
 
@@ -120,7 +120,7 @@ class MultiPolygonShape : public Shape
     virtual bool isValid() override;
     virtual bool checkContain(const Vecd &probe_point, bool BOUNDARY_INCLUDED = true) override;
     virtual Vecd findClosestPoint(const Vecd &probe_point) override;
-    virtual BoundingBox findBounds() override;
+    virtual BoundingBoxd findBounds() override;
 
   protected:
     MultiPolygon multi_polygon_;

src/for_2D_build/meshes/cell_linked_list_2d.cpp

@@ -6,11 +6,11 @@ namespace SPH
 {
 //=================================================================================================//
 void BaseCellLinkedList::tagBoundingCellsByMesh(Mesh &mesh, StdVec<CellLists> &cell_data_lists,
-                                                const BoundingBox &bounding_bounds, int axis)
+                                                const BoundingBoxd &bounding_bounds, int axis)
 {
     int second_axis = NextAxis(axis);
-    Array2i body_lower_bound_cell_ = mesh.CellIndexFromPosition(bounding_bounds.first_);
-    Array2i body_upper_bound_cell_ = mesh.CellIndexFromPosition(bounding_bounds.second_);
+    Array2i body_lower_bound_cell_ = mesh.CellIndexFromPosition(bounding_bounds.lower_);
+    Array2i body_upper_bound_cell_ = mesh.CellIndexFromPosition(bounding_bounds.upper_);
     Array2i all_cells = mesh.AllCells();
     // lower bound cells
     for (int j = SMAX(body_lower_bound_cell_[second_axis] - 1, 0);

src/for_3D_build/common/data_type.h

@@ -42,7 +42,7 @@ using MatTend = Mat6d;           // matricized symmetric 3x3x3x3 tensor
 using VecMatGrad = VecMatGrad3d; // gradient of vectorized symmetric 3x3 matrix
 using AngularVecd = Vec3d;
 using Rotation = Rotation3d;
-using BoundingBox = BaseBoundingBox<Vec3d>;
+using BoundingBoxd = BoundingBox<Real, 3>;
 using Transform = BaseTransform<Rotation3d, Vec3d>;
 
 /** only works for smoothing length ratio less or equal than 1.3*/