src/BRepGProp/BRepGProp_Gauss.hxx

   1 // Copyright (c) 2015 OPEN CASCADE SAS
   2 //
   3 // This file is part of Open CASCADE Technology software library.
   4 //
   5 // This library is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU Lesser General Public License version 2.1 as published
   7 // by the Free Software Foundation, with special exception defined in the file
   8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
   9 // distribution for complete text of the license and disclaimer of any warranty.
  10 //
  11 // Alternatively, this file may be used under the terms of Open CASCADE
  12 // commercial license or contractual agreement.
  13
  14 #ifndef _BRepGProp_Gauss_HeaderFile
  15 #define _BRepGProp_Gauss_HeaderFile
  16
  17 #include <NCollection_Handle.hxx>
  18 #include <NCollection_Array1.hxx>
  19
  20 class math_Vector;
  21
  22 //! Class performs computing of the global inertia properties
  23 //! of geometric object in 3D space by adaptive and non-adaptive
  24 //! 2D Gauss integration algorithms.
  25 class BRepGProp_Gauss
  26 {
  27   //! Auxiliary structure for storing of inertial moments.
  28   struct Inertia
  29   {
  30     //! Mass of the current system (without density).
  31     //! May correspond to: length, area, volume.
  32     Standard_Real Mass;
  33
  34     //! Static moments of inertia.
  35     Standard_Real Ix;
  36     Standard_Real Iy;
  37     Standard_Real Iz;
  38
  39     //! Quadratic moments of inertia.
  40     Standard_Real Ixx;
  41     Standard_Real Iyy;
  42     Standard_Real Izz;
  43     Standard_Real Ixy;
  44     Standard_Real Ixz;
  45     Standard_Real Iyz;
  46
  47     //! Default constructor.
  48     Inertia();
  49
  50     //! Zeroes all values.
  51     void Reset();
  52   };
  53
  54   typedef NCollection_Handle< NCollection_Array1<Inertia> > InertiaArray;
  55   typedef Standard_Real(*BRepGProp_GaussFunc)(const Standard_Real, const Standard_Real);
  56
  57 public: //! @name public API
  58
  59   //! Describes types of geometric objects.
  60   //! - Vinert is 3D closed region of space delimited with:
  61   //! -- Surface;
  62   //! -- Point and Surface;
  63   //! -- Plane and Surface.
  64   //! - Sinert is face in 3D space.
  65   typedef enum { Vinert = 0, Sinert } BRepGProp_GaussType;
  66
  67   //! Constructor
  68   Standard_EXPORT explicit BRepGProp_Gauss(const BRepGProp_GaussType theType);
  69
  70   //! Computes the global properties of a solid region of 3D space which can be
  71   //! delimited by the surface and point or surface and plane. Surface can be closed.
  72   //! The method is quick and its precision is enough for many cases of analytical surfaces.
  73   //! Non-adaptive 2D Gauss integration with predefined numbers of Gauss points
  74   //! is used. Numbers of points depend on types of surfaces and curves.
  75   //! Error of the computation is not calculated.
  76   //! @param theSurface - bounding surface of the region;
  77   //! @param theLocation - location of the point or the plane;
  78   //! @param theCoeff - plane coefficients;
  79   //! @param theIsByPoint - flag of restricition (point/plane);
  80   //! @param theOutMass[out] - mass (volume) of region;
  81   //! @param theOutGravityCenter[out] - garvity center of region;
  82   //! @param theOutInertia[out] - matrix of inertia;
  83   Standard_EXPORT void Compute(
  84     const BRepGProp_Face&  theSurface,
  85     const gp_Pnt&          theLocation,
  86     const Standard_Real    theCoeff[],
  87     const Standard_Boolean theIsByPoint,
  88     Standard_Real&         theOutMass,
  89     gp_Pnt&                theOutGravityCenter,
  90     gp_Mat&                theOutInertia);
  91
  92   //! Computes the global properties of a surface. Surface can be closed.
  93   //! The method is quick and its precision is enough for many cases of analytical surfaces.
  94   //! Non-adaptive 2D Gauss integration with predefined numbers of Gauss points
  95   //! is used. Numbers of points depend on types of surfaces and curves.
  96   //! Error of the computation is not calculated.
  97   //! @param theSurface - bounding surface of the region;
  98   //! @param theLocation - surface location;
  99   //! @param theOutMass[out] - mass (volume) of region;
 100   //! @param theOutGravityCenter[out] - garvity center of region;
 101   //! @param theOutInertia[out] - matrix of inertia;
 102   Standard_EXPORT void Compute(
 103     const BRepGProp_Face&  theSurface,
 104     const gp_Pnt&          theLocation,
 105     Standard_Real&         theOutMass,
 106     gp_Pnt&                theOutGravityCenter,
 107     gp_Mat&                theOutInertia);
 108
 109   //! Computes the global properties of a region of 3D space which can be
 110   //! delimited by the surface and point or surface and plane. Surface can be closed.
 111   //! The method is quick and its precision is enough for many cases of analytical surfaces.
 112   //! Non-adaptive 2D Gauss integration with predefined numbers of Gauss points is used.
 113   //! Numbers of points depend on types of surfaces and curves.
 114   //! Error of the computation is not calculated.
 115   //! @param theSurface - bounding surface of the region;
 116   //! @param theDomain - surface boundings;
 117   //! @param theLocation - location of the point or the plane;
 118   //! @param theCoeff - plane coefficients;
 119   //! @param theIsByPoint - flag of restricition (point/plane);
 120   //! @param theOutMass[out] - mass (volume) of region;
 121   //! @param theOutGravityCenter[out] - garvity center of region;
 122   //! @param theOutInertia[out] - matrix of inertia;
 123   Standard_EXPORT void Compute(
 124     BRepGProp_Face&        theSurface,
 125     BRepGProp_Domain&      theDomain,
 126     const gp_Pnt&          theLocation,
 127     const Standard_Real    theCoeff[],
 128     const Standard_Boolean theIsByPoint,
 129     Standard_Real&         theOutMass,
 130     gp_Pnt&                theOutGravityCenter,
 131     gp_Mat&                theOutInertia);
 132
 133   //! Computes the global properties of a surface. Surface can be closed.
 134   //! The method is quick and its precision is enough for many cases of analytical surfaces.
 135   //! Non-adaptive 2D Gauss integration with predefined numbers of Gauss points
 136   //! is used. Numbers of points depend on types of surfaces and curves.
 137   //! Error of the computation is not calculated.
 138   //! @param theSurface - bounding surface of the region;
 139   //! @param theDomain - surface boundings;
 140   //! @param theLocation - surface location;
 141   //! @param theOutMass[out] - mass (volume) of region;
 142   //! @param theOutGravityCenter[out] - garvity center of region;
 143   //! @param theOutInertia[out] - matrix of inertia;
 144   Standard_EXPORT void Compute(
 145     BRepGProp_Face&        theSurface,
 146     BRepGProp_Domain&      theDomain,
 147     const gp_Pnt&          theLocation,
 148     Standard_Real&         theOutMass,
 149     gp_Pnt&                theOutGravityCenter,
 150     gp_Mat&                theOutInertia);
 151
 152   //! Computes the global properties of the region of 3D space which can be
 153   //! delimited by the surface and point or surface and plane.
 154   //! Adaptive 2D Gauss integration is used.
 155   //! If Epsilon more than 0.001 then algorithm performs non-adaptive integration.
 156   //! @param theSurface - bounding surface of the region;
 157   //! @param theDomain - surface boundings;
 158   //! @param theLocation - location of the point or the plane;
 159   //! @param theEps - maximal relative error of computed mass (volume) for face;
 160   //! @param theCoeff - plane coefficients;
 161   //! @param theIsByPoint - flag of restricition (point/plane);
 162   //! @param theOutMass[out] - mass (volume) of region;
 163   //! @param theOutGravityCenter[out] - garvity center of region;
 164   //! @param theOutInertia[out] - matrix of inertia;
 165   //! @return value of error which is calculated as
 166   //! Abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values
 167   //! for two successive steps of adaptive integration.
 168   Standard_EXPORT Standard_Real Compute(
 169     BRepGProp_Face&        theSurface,
 170     BRepGProp_Domain&      theDomain,
 171     const gp_Pnt&          theLocation,
 172     const Standard_Real    theEps,
 173     const Standard_Real    theCoeff[],
 174     const Standard_Boolean theByPoint,
 175     Standard_Real&         theOutMass,
 176     gp_Pnt&                theOutGravityCenter,
 177     gp_Mat&                theOutInertia);
 178
 179   //! Computes the global properties of the face. Adaptive 2D Gauss integration is used.
 180   //! If Epsilon more than 0.001 then algorithm performs non-adaptive integration.
 181   //! @param theSurface - bounding surface of the region;
 182   //! @param theDomain - surface boundings;
 183   //! @param theLocation - surface location;
 184   //! @param theEps - maximal relative error of computed mass (square) for face;
 185   //! @param theOutMass[out] - mass (volume) of region;
 186   //! @param theOutGravityCenter[out] - garvity center of region;
 187   //! @param theOutInertia[out] - matrix of inertia;
 188   //! @return value of error which is calculated as
 189   //! Abs((M(i+1)-M(i))/M(i+1)), M(i+1) and M(i) are values
 190   //! for two successive steps of adaptive integration.
 191   Standard_EXPORT Standard_Real Compute(
 192     BRepGProp_Face&        theSurface,
 193     BRepGProp_Domain&      theDomain,
 194     const gp_Pnt&          theLocation,
 195     const Standard_Real    theEps,
 196     Standard_Real&         theOutMass,
 197     gp_Pnt&                theOutGravityCenter,
 198     gp_Mat&                theOutInertia);
 199
 200 private: //! @name private methods
 201
 202   BRepGProp_Gauss(BRepGProp_Gauss const&);
 203   BRepGProp_Gauss& operator= (BRepGProp_Gauss const&);
 204
 205   void computeVInertiaOfElementaryPart(
 206     const gp_Pnt&             thePoint,
 207     const gp_Vec&             theNormal,
 208     const gp_Pnt&             theLocation,
 209     const Standard_Real       theWeight,
 210     const Standard_Real       theCoeff[],
 211     const Standard_Boolean    theIsByPoint,
 212     BRepGProp_Gauss::Inertia& theOutInertia);
 213
 214   void computeSInertiaOfElementaryPart(
 215     const gp_Pnt&             thePoint,
 216     const gp_Vec&             theNormal,
 217     const gp_Pnt&             theLocation,
 218     const Standard_Real       theWeight,
 219     BRepGProp_Gauss::Inertia& theOutInertia);
 220
 221   void checkBounds(
 222     const Standard_Real theU1,
 223     const Standard_Real theU2,
 224     const Standard_Real theV1,
 225     const Standard_Real theV2);
 226
 227   void addAndRestoreInertia(
 228     const BRepGProp_Gauss::Inertia& theInInertia,
 229     BRepGProp_Gauss::Inertia&       theOutInertia);
 230
 231   void multAndRestoreInertia(
 232     const Standard_Real       theValue,
 233     BRepGProp_Gauss::Inertia& theInertia);
 234
 235   void convert(
 236     const BRepGProp_Gauss::Inertia& theInertia,
 237     gp_Pnt&                         theOutGravityCenter,
 238     gp_Mat&                         theOutMatrixOfInertia,
 239     Standard_Real&                  theOutMass);
 240
 241   void convert(
 242     const BRepGProp_Gauss::Inertia& theInertia,
 243     const Standard_Real             theCoeff[],
 244     const Standard_Boolean          theIsByPoint,
 245     gp_Pnt&                         theOutGravityCenter,
 246     gp_Mat&                         theOutMatrixOfInertia,
 247     Standard_Real&                  theOutMass);
 248
 249   static Standard_Integer MaxSubs(
 250     const Standard_Integer theN,
 251     const Standard_Integer theCoeff = 32);
 252
 253   static void Init(
 254     NCollection_Handle<math_Vector>&         theOutVec,
 255     const Standard_Real    theValue,
 256     const Standard_Integer theFirst = 0,
 257     const Standard_Integer theLast  = 0);
 258
 259   static void InitMass(
 260     const Standard_Real    theValue,
 261     const Standard_Integer theFirst,
 262     const Standard_Integer theLast,
 263     InertiaArray&          theArray);
 264
 265   static Standard_Integer FillIntervalBounds(
 266     const Standard_Real         theA,
 267     const Standard_Real         theB,
 268     const TColStd_Array1OfReal& theKnots,
 269     const Standard_Integer      theNumSubs,
 270     InertiaArray&               theInerts,
 271     NCollection_Handle<math_Vector>&              theParam1,
 272     NCollection_Handle<math_Vector>&              theParam2,
 273     NCollection_Handle<math_Vector>&              theError,
 274     NCollection_Handle<math_Vector>&              theCommonError);
 275
 276 private: //! @name private fields
 277
 278   BRepGProp_GaussType myType; //!< Type of geometric object
 279   BRepGProp_GaussFunc add;    //!< Pointer on the add function
 280   BRepGProp_GaussFunc mult;   //!< Pointer on the mult function
 281 };
 282
 283 #endif