]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESH_I/SMESH_Measurements_i.cxx
Salome HOME
Merge branch 'V8_2_BR' into pre/V8_2_BR
[modules/smesh.git] / 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 "SMESH_Gen_i.hxx"
32 #include "SMESH_Filter_i.hxx"
33 #include "SMESH_PythonDump.hxx"
34
35 #include "SMDS_Mesh.hxx"
36 #include "SMDS_MeshNode.hxx"
37 #include "SMDS_MeshElement.hxx"
38 #include "SMDS_ElemIterator.hxx"
39
40 #include "SMESHDS_Mesh.hxx"
41
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       const SMDS_MeshElement* elem = aMesh->FindElement( aElementsId[i] );
260       if (!elem)
261         continue;
262       SMDS_ElemIteratorPtr aNodeIter = elem->nodesIterator();
263       while( aNodeIter->more() )
264         enlargeBoundingBox( dynamic_cast<const SMDS_MeshNode*>( aNodeIter->next() ), theMeasure);
265     }
266   }
267 }
268                                
269 //=======================================================================
270 // name    : BoundingBox
271 // Purpose : compute common bounding box of entities
272 //=======================================================================
273 SMESH::Measure Measurements_i::BoundingBox (const SMESH::ListOfIDSources& theSources)
274 {
275   SMESH::Measure aMeasure;
276   initMeasure(aMeasure);
277
278   // calculate bounding box on sources
279   for ( int i = 0, n = theSources.length(); i < n ; ++i )
280     enlargeBoundingBox( theSources[i], aMeasure );
281
282   return aMeasure;
283 }
284
285 //=======================================================================
286 // name    : Length
287 // Purpose : sum of length of 1D elements of the source
288 //=======================================================================
289 double Measurements_i::Length(SMESH::SMESH_IDSource_ptr theSource)
290 {
291   return getNumericalValue( theSource, SMESH::Controls::NumericalFunctorPtr(new SMESH::Controls::Length()) );
292 }
293
294 //=======================================================================
295 // name    : Area
296 // Purpose : sum of area of 2D elements of the source
297 //=======================================================================
298 double Measurements_i::Area(SMESH::SMESH_IDSource_ptr theSource)
299 {
300   return getNumericalValue( theSource, SMESH::Controls::NumericalFunctorPtr(new SMESH::Controls::Area()) );
301 }
302
303 //=======================================================================
304 // name    : Volume
305 // Purpose : sum of volume of 3D elements of the source
306 //=======================================================================
307 double Measurements_i::Volume(SMESH::SMESH_IDSource_ptr theSource)
308 {
309   return getNumericalValue( theSource, SMESH::Controls::NumericalFunctorPtr(new SMESH::Controls::Volume()) );
310 }