src/SMESH_I/SMESH_Measurements_i.cxx

   1 // Copyright (C) 2007-2013  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.
  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 #include "SMESH_Measurements_i.hxx"
  26
  27 #include "SMESH_Gen_i.hxx"
  28 #include "SMESH_Filter_i.hxx"
  29 #include "SMESH_PythonDump.hxx"
  30
  31 #include "SMDS_Mesh.hxx"
  32 #include "SMDS_MeshNode.hxx"
  33 #include "SMDS_MeshElement.hxx"
  34 #include "SMDS_ElemIterator.hxx"
  35
  36 #include "SMESHDS_Mesh.hxx"
  37
  38
  39 using namespace SMESH;
  40
  41 /**
  42  * this local function to avoid uninitialized fields
  43  */
  44 static void initMeasure( SMESH::Measure& theMeasure)
  45 {
  46
  47   theMeasure.minX = theMeasure.minY = theMeasure.minZ = 0.;
  48   theMeasure.maxX = theMeasure.maxY = theMeasure.maxZ = 0.;
  49   theMeasure.node1 = theMeasure.node2 = -1;
  50   theMeasure.elem1 = theMeasure.elem2 = -1;
  51   theMeasure.value = 0.;
  52 }
  53
  54 //=============================================================================
  55 /*!
  56  *  SMESH_Gen_i::CreateMeasurements
  57  *
  58  *  Create measurement instance
  59  */
  60 //=============================================================================
  61
  62 SMESH::Measurements_ptr SMESH_Gen_i::CreateMeasurements()
  63 {
  64   SMESH::Measurements_i* aMeasure = new SMESH::Measurements_i();
  65   SMESH::Measurements_var anObj = aMeasure->_this();
  66   return anObj._retn();
  67 }
  68
  69
  70 /*
  71   Class       : Measurements
  72   Description : make measure of mesh qunatities
  73 */
  74
  75 //=======================================================================
  76 // name    : Measurements_i
  77 // Purpose : Constructor
  78 //=======================================================================
  79 Measurements_i::Measurements_i()
  80 : SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
  81 {
  82   //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method
  83   //PortableServer::ObjectId_var anObjectId =
  84   //  SMESH_Gen_i::GetPOA()->activate_object( this );
  85 }
  86
  87 //=======================================================================
  88 // name    : ~Measurements_i
  89 // Purpose : Destructor
  90 //=======================================================================
  91 Measurements_i::~Measurements_i()
  92 {
  93   //TPythonDump()<<this<<".UnRegister()";
  94 }
  95
  96 static bool getNodeNodeDistance (SMESH::Measure& theMeasure,
  97                                  const SMDS_MeshNode* theNode1,
  98                                  const SMDS_MeshNode* theNode2 = 0)
  99 {
 100   double dist = 0., dd = 0.;
 101
 102   if (!theNode1)
 103     return false;
 104
 105   dd = theNode1->X(); if (theNode2) dd -= theNode2->X(); theMeasure.minX = dd; dd *= dd; dist += dd;
 106   dd = theNode1->Y(); if (theNode2) dd -= theNode2->Y(); theMeasure.minY = dd; dd *= dd; dist += dd;
 107   dd = theNode1->Z(); if (theNode2) dd -= theNode2->Z(); theMeasure.minZ = dd; dd *= dd; dist += dd;
 108
 109   if (dist < 0)
 110     return false;
 111
 112   theMeasure.value = sqrt(dist);
 113   theMeasure.node1 = theNode1->GetID();
 114   theMeasure.node2 = theNode2 ? theNode2->GetID() : 0;
 115
 116   return true;
 117 }
 118
 119 static SMESHDS_Mesh* getMesh(SMESH::SMESH_IDSource_ptr theSource)
 120 {
 121   if (!CORBA::is_nil( theSource ))
 122   {
 123     SMESH_Mesh_i* anImplPtr = DownCast<SMESH_Mesh_i*>(theSource->GetMesh());
 124     if (anImplPtr)
 125       return anImplPtr->GetImpl().GetMeshDS();
 126   }
 127   return 0;
 128 }
 129
 130 static bool isNodeType (SMESH::array_of_ElementType_var theTypes)
 131 {
 132   return theTypes->length() > 0 && theTypes[0] == SMESH::NODE;
 133 }
 134
 135 static double getNumericalValue(SMESH::SMESH_IDSource_ptr theSource, SMESH::Controls::NumericalFunctorPtr theFunctor)
 136 {
 137   double value = 0;
 138
 139   if ( !CORBA::is_nil( theSource ) ) {
 140     const SMESHDS_Mesh* aMesh = getMesh( theSource );
 141     if ( aMesh ) {
 142       theFunctor->SetMesh( aMesh );
 143
 144       SMESH::long_array_var anElementsId = theSource->GetIDs();
 145       for (int i = 0; i < anElementsId->length(); i++) {
 146         value += theFunctor->GetValue( anElementsId[i] );
 147       }
 148     }
 149   }
 150   return value;
 151 }
 152
 153 //=======================================================================
 154 // name    : MinDistance
 155 // Purpose : minimal distance between two given entities
 156 //=======================================================================
 157 SMESH::Measure Measurements_i::MinDistance
 158  (SMESH::SMESH_IDSource_ptr theSource1,
 159   SMESH::SMESH_IDSource_ptr theSource2)
 160 {
 161   SMESH::Measure aMeasure;
 162   initMeasure(aMeasure);
 163
 164   if (CORBA::is_nil( theSource1 ))
 165     return aMeasure;
 166
 167   // if second source is null, min distance from theSource1 to the origin is calculated
 168   bool isOrigin =  CORBA::is_nil( theSource2 );
 169
 170   // calculate minimal distance between two mesh entities
 171   SMESH::array_of_ElementType_var types1 = theSource1->GetTypes();
 172   SMESH::array_of_ElementType_var types2;
 173   if ( !isOrigin ) types2 = theSource2->GetTypes();
 174
 175   // here we assume that type of all IDs defined by first type in array
 176   bool isNode1 = isNodeType(types1);
 177   bool isNode2 = isOrigin || isNodeType(types2);
 178
 179   SMESH::long_array_var aElementsId1 = theSource1->GetIDs();
 180   SMESH::long_array_var aElementsId2;
 181   if ( !isOrigin ) aElementsId2 = theSource2->GetIDs();
 182
 183   // compute distance between two entities
 184   /* NOTE: currently only node-to-node case is implemented
 185    * all other cases will be implemented later
 186    * below IF should be replaced by complete switch
 187    * on mesh entities types
 188    */
 189   if (isNode1 && isNode2)
 190   {
 191     // node - node
 192     const SMESHDS_Mesh* aMesh1 = getMesh( theSource1 );
 193     const SMESHDS_Mesh* aMesh2 = isOrigin ? 0 : getMesh( theSource2 );
 194     const SMDS_MeshNode* theNode1 = aMesh1 ? aMesh1->FindNode( aElementsId1[0] ) : 0;
 195     const SMDS_MeshNode* theNode2 = aMesh2 ? aMesh2->FindNode( aElementsId2[0] ) : 0;
 196     getNodeNodeDistance( aMeasure, theNode1, theNode2 );
 197   }
 198   else
 199   {
 200     // NOT_IMPLEMENTED
 201   }
 202
 203   return aMeasure;
 204 }
 205
 206 //=======================================================================
 207 // name    : enlargeBoundingBox
 208 // Purpose :
 209 //=======================================================================
 210 static void enlargeBoundingBox(const SMDS_MeshNode* theNode,
 211                                SMESH::Measure&      theMeasure)
 212 {
 213   if (!theNode)
 214     return;
 215   if ( theMeasure.node1 == -1 ) {
 216     // we use this attribute as a flag that it is the first node added to the bnd box
 217     theMeasure.minX = theMeasure.maxX = theNode->X();
 218     theMeasure.minY = theMeasure.maxY = theNode->Y();
 219     theMeasure.minZ = theMeasure.maxZ = theNode->Z();
 220     theMeasure.node1 = theNode->GetID();
 221   }
 222   else {
 223     theMeasure.minX = min( theMeasure.minX, theNode->X() );
 224     theMeasure.maxX = max( theMeasure.maxX, theNode->X() );
 225     theMeasure.minY = min( theMeasure.minY, theNode->Y() );
 226     theMeasure.maxY = max( theMeasure.maxY, theNode->Y() );
 227     theMeasure.minZ = min( theMeasure.minZ, theNode->Z() );
 228     theMeasure.maxZ = max( theMeasure.maxZ, theNode->Z() );
 229   }
 230 }
 231
 232 //=======================================================================
 233 // name    : enlargeBoundingBox
 234 // Purpose :
 235 //=======================================================================
 236 static void enlargeBoundingBox(const SMESH::SMESH_IDSource_ptr theObject,
 237                                SMESH::Measure&                 theMeasure)
 238 {
 239   if ( CORBA::is_nil( theObject ) )
 240     return;
 241   const SMESHDS_Mesh* aMesh = getMesh( theObject );
 242   if ( !aMesh )
 243     return;
 244   SMESH::array_of_ElementType_var types = theObject->GetTypes();
 245   SMESH::long_array_var     aElementsId = theObject->GetIDs();
 246   // here we assume that type of all IDs defined by first type in array
 247   const bool isNode = isNodeType( types );
 248   for(int i = 0, n = aElementsId->length(); i < n; i++)
 249   {
 250     if (isNode)
 251       enlargeBoundingBox( aMesh->FindNode( aElementsId[i] ), theMeasure);
 252     else
 253     {
 254       const SMDS_MeshElement* elem = aMesh->FindElement( aElementsId[i] );
 255       if (!elem)
 256         continue;
 257       SMDS_ElemIteratorPtr aNodeIter = elem->nodesIterator();
 258       while( aNodeIter->more() )
 259         enlargeBoundingBox( dynamic_cast<const SMDS_MeshNode*>( aNodeIter->next() ), theMeasure);
 260     }
 261   }
 262 }
 263
 264 //=======================================================================
 265 // name    : BoundingBox
 266 // Purpose : compute common bounding box of entities
 267 //=======================================================================
 268 SMESH::Measure Measurements_i::BoundingBox (const SMESH::ListOfIDSources& theSources)
 269 {
 270   SMESH::Measure aMeasure;
 271   initMeasure(aMeasure);
 272
 273   // calculate bounding box on sources
 274   for ( int i = 0, n = theSources.length(); i < n ; ++i )
 275     enlargeBoundingBox( theSources[i], aMeasure );
 276
 277   return aMeasure;
 278 }
 279
 280 //=======================================================================
 281 // name    : Length
 282 // Purpose : sum of length of 1D elements of the source
 283 //=======================================================================
 284 double Measurements_i::Length(SMESH::SMESH_IDSource_ptr theSource)
 285 {
 286   return getNumericalValue( theSource, SMESH::Controls::NumericalFunctorPtr(new SMESH::Controls::Length()) );
 287 }
 288
 289 //=======================================================================
 290 // name    : Area
 291 // Purpose : sum of area of 2D elements of the source
 292 //=======================================================================
 293 double Measurements_i::Area(SMESH::SMESH_IDSource_ptr theSource)
 294 {
 295   return getNumericalValue( theSource, SMESH::Controls::NumericalFunctorPtr(new SMESH::Controls::Area()) );
 296 }
 297
 298 //=======================================================================
 299 // name    : Volume
 300 // Purpose : sum of volume of 3D elements of the source
 301 //=======================================================================
 302 double Measurements_i::Volume(SMESH::SMESH_IDSource_ptr theSource)
 303 {
 304   return getNumericalValue( theSource, SMESH::Controls::NumericalFunctorPtr(new SMESH::Controls::Volume()) );
 305 }