src/SMESH_I/SMESH_Measurements_i.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : SMESH_Measurements_i.cxx
  23 //  Author : Pavel TELKOV, Open CASCADE S.A.S. (pavel.telkov@opencascade.com)
  24
  25 #ifdef WIN32
  26 #define NOMINMAX
  27 #endif
  28
  29 #include "SMESH_Measurements_i.hxx"
  30
  31 #include "SMDS_ElemIterator.hxx"
  32 #include "SMDS_Mesh.hxx"
  33 #include "SMDS_MeshElement.hxx"
  34 #include "SMDS_MeshNode.hxx"
  35 #include "SMESHDS_Mesh.hxx"
  36 #include "SMESH_Filter_i.hxx"
  37 #include "SMESH_Gen_i.hxx"
  38 #include "SMESH_MeshAlgos.hxx"
  39 #include "SMESH_PythonDump.hxx"
  40
  41 #include <cmath>
  42
  43 using namespace SMESH;
  44
  45 /**
  46  * this local function to avoid uninitialized fields
  47  */
  48 static void initMeasure( SMESH::Measure& theMeasure)
  49 {
  50
  51   theMeasure.minX = theMeasure.minY = theMeasure.minZ = 0.;
  52   theMeasure.maxX = theMeasure.maxY = theMeasure.maxZ = 0.;
  53   theMeasure.node1 = theMeasure.node2 = -1;
  54   theMeasure.elem1 = theMeasure.elem2 = -1;
  55   theMeasure.value = 0.;
  56 }
  57
  58 //=============================================================================
  59 /*!
  60  *  SMESH_Gen_i::CreateMeasurements
  61  *
  62  *  Create measurement instance
  63  */
  64 //=============================================================================
  65
  66 SMESH::Measurements_ptr SMESH_Gen_i::CreateMeasurements()
  67 {
  68   SMESH::Measurements_i* aMeasure = new SMESH::Measurements_i();
  69   SMESH::Measurements_var anObj = aMeasure->_this();
  70   return anObj._retn();
  71 }
  72
  73
  74 /*
  75   Class       : Measurements
  76   Description : make measure of mesh qunatities
  77 */
  78
  79 //=======================================================================
  80 // name    : Measurements_i
  81 // Purpose : Constructor
  82 //=======================================================================
  83 Measurements_i::Measurements_i()
  84 : SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
  85 {
  86   //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method
  87   //PortableServer::ObjectId_var anObjectId =
  88   //  SMESH_Gen_i::GetPOA()->activate_object( this );
  89 }
  90
  91 //=======================================================================
  92 // name    : ~Measurements_i
  93 // Purpose : Destructor
  94 //=======================================================================
  95 Measurements_i::~Measurements_i()
  96 {
  97   //TPythonDump()<<this<<".UnRegister()";
  98 }
  99
 100 static bool getNodeNodeDistance (SMESH::Measure& theMeasure,
 101                                  const SMDS_MeshNode* theNode1,
 102                                  const SMDS_MeshNode* theNode2 = 0)
 103 {
 104   double dist = 0., dd = 0.;
 105
 106   if (!theNode1)
 107     return false;
 108
 109   dd = theNode1->X(); if (theNode2) dd -= theNode2->X(); theMeasure.minX = dd; dd *= dd; dist += dd;
 110   dd = theNode1->Y(); if (theNode2) dd -= theNode2->Y(); theMeasure.minY = dd; dd *= dd; dist += dd;
 111   dd = theNode1->Z(); if (theNode2) dd -= theNode2->Z(); theMeasure.minZ = dd; dd *= dd; dist += dd;
 112
 113   if (dist < 0)
 114     return false;
 115
 116   theMeasure.value = sqrt(dist);
 117   theMeasure.node1 = theNode1->GetID();
 118   theMeasure.node2 = theNode2 ? theNode2->GetID() : 0;
 119
 120   return true;
 121 }
 122
 123 static SMESHDS_Mesh* getMesh(SMESH::SMESH_IDSource_ptr theSource)
 124 {
 125   if (!CORBA::is_nil( theSource ))
 126   {
 127     SMESH_Mesh_i* anImplPtr = DownCast<SMESH_Mesh_i*>(theSource->GetMesh());
 128     if (anImplPtr)
 129       return anImplPtr->GetImpl().GetMeshDS();
 130   }
 131   return 0;
 132 }
 133
 134 static bool isNodeType (SMESH::array_of_ElementType_var theTypes)
 135 {
 136   return theTypes->length() > 0 && theTypes[0] == SMESH::NODE;
 137 }
 138
 139 static double getNumericalValue(SMESH::SMESH_IDSource_ptr            theSource,
 140                                 SMESH::Controls::NumericalFunctorPtr theFunctor)
 141 {
 142   double value = 0;
 143
 144   if ( !CORBA::is_nil( theSource ) ) {
 145     const SMESHDS_Mesh* aMesh = getMesh( theSource );
 146     if ( aMesh ) {
 147       theFunctor->SetMesh( aMesh );
 148
 149       SMESH::long_array_var anElementsId = theSource->GetIDs();
 150       for ( CORBA::ULong i = 0; i < anElementsId->length(); i++) {
 151         value += theFunctor->GetValue( anElementsId[i] );
 152       }
 153     }
 154   }
 155   return value;
 156 }
 157
 158 //=======================================================================
 159 // name    : MinDistance
 160 // Purpose : minimal distance between two given entities
 161 //=======================================================================
 162 SMESH::Measure Measurements_i::MinDistance
 163  (SMESH::SMESH_IDSource_ptr theSource1,
 164   SMESH::SMESH_IDSource_ptr theSource2)
 165 {
 166   SMESH::Measure aMeasure;
 167   initMeasure(aMeasure);
 168
 169   if (CORBA::is_nil( theSource1 ))
 170     return aMeasure;
 171
 172   // if second source is null, min distance from theSource1 to the origin is calculated
 173   bool isOrigin =  CORBA::is_nil( theSource2 );
 174
 175   // calculate minimal distance between two mesh entities
 176   SMESH::array_of_ElementType_var types1 = theSource1->GetTypes();
 177   SMESH::array_of_ElementType_var types2;
 178   if ( !isOrigin ) types2 = theSource2->GetTypes();
 179
 180   // here we assume that type of all IDs defined by first type in array
 181   bool isNode1 = isNodeType(types1);
 182   bool isNode2 = isOrigin || isNodeType(types2);
 183
 184   SMESH::long_array_var aElementsId1 = theSource1->GetIDs();
 185   SMESH::long_array_var aElementsId2;
 186   if ( !isOrigin ) aElementsId2 = theSource2->GetIDs();
 187
 188   // compute distance between two entities
 189   /* NOTE: currently only node-to-node case is implemented
 190    * all other cases will be implemented later
 191    * below IF should be replaced by complete switch
 192    * on mesh entities types
 193    */
 194   if (isNode1 && isNode2)
 195   {
 196     // node - node
 197     const SMESHDS_Mesh* aMesh1 = getMesh( theSource1 );
 198     const SMESHDS_Mesh* aMesh2 = isOrigin ? 0 : getMesh( theSource2 );
 199     const SMDS_MeshNode* theNode1 = aMesh1 ? aMesh1->FindNode( aElementsId1[0] ) : 0;
 200     const SMDS_MeshNode* theNode2 = aMesh2 ? aMesh2->FindNode( aElementsId2[0] ) : 0;
 201     getNodeNodeDistance( aMeasure, theNode1, theNode2 );
 202   }
 203   else
 204   {
 205     // NOT_IMPLEMENTED
 206   }
 207
 208   return aMeasure;
 209 }
 210
 211 //=======================================================================
 212 // name    : enlargeBoundingBox
 213 // Purpose :
 214 //=======================================================================
 215 static void enlargeBoundingBox(const SMDS_MeshNode* theNode,
 216                                SMESH::Measure&      theMeasure)
 217 {
 218   if (!theNode)
 219     return;
 220   if ( theMeasure.node1 == -1 ) {
 221     // we use this attribute as a flag that it is the first node added to the bnd box
 222     theMeasure.minX = theMeasure.maxX = theNode->X();
 223     theMeasure.minY = theMeasure.maxY = theNode->Y();
 224     theMeasure.minZ = theMeasure.maxZ = theNode->Z();
 225     theMeasure.node1 = theNode->GetID();
 226   }
 227   else {
 228     theMeasure.minX = std::min( theMeasure.minX, theNode->X() );
 229     theMeasure.maxX = std::max( theMeasure.maxX, theNode->X() );
 230     theMeasure.minY = std::min( theMeasure.minY, theNode->Y() );
 231     theMeasure.maxY = std::max( theMeasure.maxY, theNode->Y() );
 232     theMeasure.minZ = std::min( theMeasure.minZ, theNode->Z() );
 233     theMeasure.maxZ = std::max( theMeasure.maxZ, theNode->Z() );
 234   }
 235 }
 236
 237 //=======================================================================
 238 // name    : enlargeBoundingBox
 239 // Purpose :
 240 //=======================================================================
 241 static void enlargeBoundingBox(const SMESH::SMESH_IDSource_ptr theObject,
 242                                SMESH::Measure&                 theMeasure)
 243 {
 244   if ( CORBA::is_nil( theObject ) )
 245     return;
 246   const SMESHDS_Mesh* aMesh = getMesh( theObject );
 247   if ( !aMesh )
 248     return;
 249   SMESH::array_of_ElementType_var types = theObject->GetTypes();
 250   SMESH::long_array_var     aElementsId = theObject->GetIDs();
 251   // here we assume that type of all IDs defined by first type in array
 252   const bool isNode = isNodeType( types );
 253   for(int i = 0, n = aElementsId->length(); i < n; i++)
 254   {
 255     if (isNode)
 256       enlargeBoundingBox( aMesh->FindNode( aElementsId[i] ), theMeasure);
 257     else
 258     {
 259       if ( const SMDS_MeshElement* elem = aMesh->FindElement( aElementsId[i] ))
 260         for (SMDS_NodeIteratorPtr aNodeIter = elem->nodeIterator(); aNodeIter->more(); )
 261           enlargeBoundingBox( aNodeIter->next(), theMeasure);
 262     }
 263   }
 264 }
 265
 266 //=======================================================================
 267 // name    : BoundingBox
 268 // Purpose : compute common bounding box of entities
 269 //=======================================================================
 270 SMESH::Measure Measurements_i::BoundingBox (const SMESH::ListOfIDSources& theSources)
 271 {
 272   SMESH::Measure aMeasure;
 273   initMeasure(aMeasure);
 274
 275   // calculate bounding box on sources
 276   for ( int i = 0, n = theSources.length(); i < n ; ++i )
 277     enlargeBoundingBox( theSources[i], aMeasure );
 278
 279   return aMeasure;
 280 }
 281
 282 //=======================================================================
 283 // name    : Length
 284 // Purpose : sum of length of 1D elements of the source
 285 //=======================================================================
 286 double Measurements_i::Length(SMESH::SMESH_IDSource_ptr theSource)
 287 {
 288   return getNumericalValue( theSource, SMESH::Controls::NumericalFunctorPtr(new SMESH::Controls::Length()) );
 289 }
 290
 291 //=======================================================================
 292 // name    : Area
 293 // Purpose : sum of area of 2D elements of the source
 294 //=======================================================================
 295 double Measurements_i::Area(SMESH::SMESH_IDSource_ptr theSource)
 296 {
 297   return getNumericalValue( theSource, SMESH::Controls::NumericalFunctorPtr(new SMESH::Controls::Area()) );
 298 }
 299
 300 //=======================================================================
 301 // name    : Volume
 302 // Purpose : sum of volume of 3D elements of the source
 303 //=======================================================================
 304 double Measurements_i::Volume(SMESH::SMESH_IDSource_ptr theSource)
 305 {
 306   return getNumericalValue( theSource, SMESH::Controls::NumericalFunctorPtr(new SMESH::Controls::Volume()) );
 307 }
 308
 309 //=======================================================================
 310 //function : GravityCenter
 311 //purpose  : return gravity center of the source: average coordinates of all nodes
 312 //=======================================================================
 313
 314 SMESH::PointStruct Measurements_i::GravityCenter(SMESH::SMESH_IDSource_ptr theSource)
 315 {
 316   SMESH::PointStruct grCenter = { 0.,0.,0. };
 317   const SMESHDS_Mesh* mesh = getMesh( theSource );
 318   if ( !mesh )
 319     return grCenter;
 320
 321   // unmark all nodes; visited nodes will be marked
 322   SMESH_MeshAlgos::MarkElems( mesh->nodesIterator(), /*isMarked=*/false );
 323
 324   gp_XYZ sumCoord( 0,0,0 );
 325   int nodeCount = 0;
 326
 327   SMDS_ElemIteratorPtr eIt = SMESH_Mesh_i::GetElements( theSource, SMESH::ALL );
 328   while ( eIt->more() )
 329   {
 330     const SMDS_MeshElement*   elem = eIt->next();
 331     for ( SMDS_NodeIteratorPtr nIt = elem->nodeIterator(); nIt->more(); )
 332     {
 333       const SMDS_MeshNode* n = nIt->next();
 334       if ( !n->isMarked() )
 335       {
 336         sumCoord += SMESH_NodeXYZ( n );
 337         ++nodeCount;
 338         n->setIsMarked( true );
 339       }
 340     }
 341   }
 342   sumCoord /= nodeCount;
 343
 344   grCenter.x = sumCoord.X();
 345   grCenter.y = sumCoord.Y();
 346   grCenter.z = sumCoord.Z();
 347
 348   return grCenter;
 349 }
 350
 351 //=======================================================================
 352 //function : Angle
 353 //purpose  : Return angle in radians defined by 3 points <(p1,p2,p3)
 354 //=======================================================================
 355
 356 CORBA::Double Measurements_i::Angle(const SMESH::PointStruct& p1,
 357                                     const SMESH::PointStruct& p2,
 358                                     const SMESH::PointStruct& p3 )
 359 {
 360   gp_Vec v1( p1.x - p2.x, p1.y - p2.y, p1.z - p2.z );
 361   gp_Vec v2( p3.x - p2.x, p3.y - p2.y, p3.z - p2.z );
 362
 363   double angle = -1;
 364
 365   try
 366   {
 367     angle = v1.Angle( v2 );
 368   }
 369   catch(...)
 370   {
 371   }
 372   if ( std::isnan( angle ))
 373     angle = -1;
 374
 375   return angle;
 376 }