]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESH_I/SMESH_Pattern_i.cxx
Salome HOME
bcea31b0c9e067eb9ba5ae639995a358ae4e375a
[modules/smesh.git] / src / SMESH_I / SMESH_Pattern_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
23 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
24 // File      : SMESH_Pattern_i.cxx
25 // Created   : Fri Aug 20 16:15:49 2004
26 // Author    : Edward AGAPOV (eap)
27 //
28 #include "SMESH_Pattern_i.hxx"
29
30 #include "SMDS_MeshFace.hxx"
31 #include "SMDS_MeshVolume.hxx"
32 #include "SMESHDS_Mesh.hxx"
33 #include "SMESH_Gen_i.hxx"
34 #include "SMESH_Mesh.hxx"
35 #include "SMESH_Mesh_i.hxx"
36 #include "SMESH_PythonDump.hxx"
37
38 #include <TopExp_Explorer.hxx>
39 #include <TopoDS.hxx>
40 #include <TopoDS_Face.hxx>
41
42 #include <Standard_Failure.hxx>
43 #include <Standard_ErrorHandler.hxx>
44
45 #include <sstream>
46 #include <set>
47
48 using namespace std;
49
50 using SMESH::TPythonDump;
51 using SMESH::TVar;
52
53 //=======================================================================
54 //function : dumpErrorCode
55 //purpose  : 
56 //=======================================================================
57
58 static void addErrorCode(const char* thePyCommand)
59 {
60   TPythonDump() << "if (isDone != 1):";
61   TPythonDump() << "\tprint('" << thePyCommand << " :', pattern.GetErrorCode())";
62 }
63
64 //=============================================================================
65 /*!
66  *  SMESH_Gen_i::GetPattern
67  *
68  *  Create pattern mapper
69  */
70 //=============================================================================
71
72 SMESH::SMESH_Pattern_ptr SMESH_Gen_i::GetPattern()
73 {
74   // Update Python script
75   TPythonDump() << "pattern = " << this << ".GetPattern()";
76
77   SMESH_Pattern_i* i = new SMESH_Pattern_i( this );
78   SMESH::SMESH_Pattern_var anObj = i->_this();
79   return anObj._retn();
80 }
81
82 //=======================================================================
83 //function : SMESH_Pattern_i
84 //purpose  : 
85 //=======================================================================
86
87 SMESH_Pattern_i::SMESH_Pattern_i( SMESH_Gen_i* theGen_i ):
88   myGen( theGen_i )
89 {
90 }
91
92 //=======================================================================
93 //function : getMesh
94 //purpose  :
95 //=======================================================================
96
97 ::SMESH_Mesh* SMESH_Pattern_i::getMesh( SMESH::SMESH_Mesh_ptr & theMesh )
98 {
99   SMESH_Mesh_i* anImplPtr =
100     dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( theMesh ).in() );
101   if ( anImplPtr )
102   {
103     anImplPtr->Load();
104     return & anImplPtr->GetImpl();
105   }
106
107   return 0;
108 }
109
110 //=======================================================================
111 //function : LoadFromFile
112 //purpose  :
113 //=======================================================================
114
115 CORBA::Boolean SMESH_Pattern_i::LoadFromFile(const char* theFileContents)
116 {
117   // remove some gabage from the end
118   TCollection_AsciiString patternDescription = (char*) theFileContents;
119   int pos = patternDescription.Length();
120   while (! isdigit( patternDescription.Value( pos )))
121     pos--;
122   if ( pos != patternDescription.Length() ) {
123     patternDescription.Trunc( pos );
124   }
125
126   // Update Python script
127   TPythonDump() << "isDone = pattern.LoadFromFile("
128                 << TPythonDump::LongStringStart("Pattern")
129                 << patternDescription
130                 << TPythonDump::LongStringEnd()
131                 << ")";
132   addErrorCode( "LoadFromFile" );
133
134   return myPattern.Load( theFileContents );
135 }
136
137 //=======================================================================
138 //function : LoadFromFace
139 //purpose  : 
140 //=======================================================================
141
142 CORBA::Boolean SMESH_Pattern_i::LoadFromFace(SMESH::SMESH_Mesh_ptr theMesh,
143                                              GEOM::GEOM_Object_ptr theFace,
144                                              CORBA::Boolean        theProject)
145 {
146   if ( theMesh->_is_nil() || theFace->_is_nil() )
147     return false;
148
149   ::SMESH_Mesh* aMesh = getMesh( theMesh );
150   if ( !aMesh )
151     return false;
152
153   TopoDS_Shape aFace = myGen->GeomObjectToShape( theFace );
154   if ( aFace.IsNull() || aFace.ShapeType() != TopAbs_FACE )
155     return false;
156
157   // Update Python script
158   TPythonDump() << "isDone = pattern.LoadFromFace( " << theMesh << ".GetMesh(), "
159                 << theFace << ", " << theProject << " )";
160   addErrorCode( "LoadFromFace" );
161
162   return myPattern.Load( aMesh, TopoDS::Face( aFace ), theProject );
163 }
164
165 //=======================================================================
166 //function : LoadFrom3DBlock
167 //purpose  : 
168 //=======================================================================
169
170 CORBA::Boolean SMESH_Pattern_i::LoadFrom3DBlock(SMESH::SMESH_Mesh_ptr theMesh,
171                                                 GEOM::GEOM_Object_ptr theBlock)
172 {
173   if ( theMesh->_is_nil() || theBlock->_is_nil() )
174     return false;
175
176   ::SMESH_Mesh* aMesh = getMesh( theMesh );
177   if ( !aMesh )
178     return false;
179
180   TopoDS_Shape aShape = myGen->GeomObjectToShape( theBlock );
181   if ( aShape.IsNull())
182     return false;
183
184   TopExp_Explorer exp ( aShape, TopAbs_SHELL );
185   if ( !exp.More() )
186     return false;
187
188   // Update Python script
189   TPythonDump() << "isDone = pattern.LoadFrom3DBlock( " << theMesh << ".GetMesh(), " << theBlock << " )";
190   addErrorCode( "LoadFrom3DBlock" );
191
192   return myPattern.Load( aMesh, TopoDS::Shell( exp.Current() ));
193 }
194
195 //=======================================================================
196 //function : ApplyToFace
197 //purpose  : 
198 //=======================================================================
199
200 SMESH::point_array* SMESH_Pattern_i::ApplyToFace(GEOM::GEOM_Object_ptr theFace,
201                                                  GEOM::GEOM_Object_ptr theVertexOnKeyPoint1,
202                                                  CORBA::Boolean        theReverse)
203 {
204   SMESH::point_array_var points = new SMESH::point_array;
205   list<const gp_XYZ *> xyzList;
206
207   TopoDS_Shape F = myGen->GeomObjectToShape( theFace );
208   TopoDS_Shape V = myGen->GeomObjectToShape( theVertexOnKeyPoint1 );
209
210   if (!F.IsNull() && F.ShapeType() == TopAbs_FACE &&
211       !V.IsNull() && V.ShapeType() == TopAbs_VERTEX
212       &&
213       myPattern.Apply( TopoDS::Face( F ), TopoDS::Vertex( V ), theReverse ) &&
214       myPattern.GetMappedPoints( xyzList ))
215   {
216     points->length( xyzList.size() );
217     list<const gp_XYZ *>::iterator xyzIt = xyzList.begin();
218     for ( int i = 0; xyzIt != xyzList.end(); xyzIt++ ) {
219       SMESH::PointStruct & p = points[ i++ ];
220       (*xyzIt)->Coord( p.x, p.y, p.z );
221     }
222   }
223   // Update Python script
224   TPythonDump() << "pattern.ApplyToFace( " << theFace << ", "
225                 << theVertexOnKeyPoint1 << ", " << theReverse << " )";
226
227   return points._retn();
228 }
229
230 //=======================================================================
231 //function : ApplyTo3DBlock
232 //purpose  : 
233 //=======================================================================
234
235 SMESH::point_array* SMESH_Pattern_i::ApplyTo3DBlock(GEOM::GEOM_Object_ptr theBlock,
236                                                     GEOM::GEOM_Object_ptr theVertex000,
237                                                     GEOM::GEOM_Object_ptr theVertex001)
238 {
239   SMESH::point_array_var points = new SMESH::point_array;
240   list<const gp_XYZ *> xyzList;
241
242   TopExp_Explorer exp( myGen->GeomObjectToShape( theBlock ), TopAbs_SHELL );
243   TopoDS_Shape V000 = myGen->GeomObjectToShape( theVertex000 );
244   TopoDS_Shape V001 = myGen->GeomObjectToShape( theVertex001 );
245
246   if (exp.More() &&
247       !V000.IsNull() && V000.ShapeType() == TopAbs_VERTEX &&
248       !V001.IsNull() && V001.ShapeType() == TopAbs_VERTEX 
249       &&
250       myPattern.Apply(TopoDS::Shell( exp.Current() ),
251                       TopoDS::Vertex( V000 ),
252                       TopoDS::Vertex( V001 )) &&
253       myPattern.GetMappedPoints( xyzList ))
254   {
255     points->length( xyzList.size() );
256     list<const gp_XYZ *>::iterator xyzIt = xyzList.begin();
257     for ( int i = 0; xyzIt != xyzList.end(); xyzIt++ ) {
258       SMESH::PointStruct & p = points[ i++ ];
259       (*xyzIt)->Coord( p.x, p.y, p.z );
260     }
261   }
262
263   // Update Python script
264   TPythonDump() << "pattern.ApplyTo3DBlock( " << theBlock << ", "
265                 << theVertex000 << ", " << theVertex001 << " )";
266
267   return points._retn();
268 }
269
270 //=======================================================================
271 //function : ApplyToMeshFaces
272 //purpose  : 
273 //=======================================================================
274
275 SMESH::point_array*
276   SMESH_Pattern_i::ApplyToMeshFaces(SMESH::SMESH_Mesh_ptr    theMesh,
277                                     const SMESH::long_array& theFacesIDs,
278                                     CORBA::Long              theNodeIndexOnKeyPoint1,
279                                     CORBA::Boolean           theReverse)
280 {
281   SMESH::point_array_var points = new SMESH::point_array;
282
283   ::SMESH_Mesh* aMesh = getMesh( theMesh );
284   if ( !aMesh )
285     return points._retn();
286
287   list<const gp_XYZ *> xyzList;
288   set<const SMDS_MeshFace*> fset;
289   for ( CORBA::ULong i = 0; i < theFacesIDs.length(); i++)
290   {
291     CORBA::Long index = theFacesIDs[i];
292     const SMDS_MeshElement * elem = aMesh->GetMeshDS()->FindElement(index);
293     if ( elem && elem->GetType() == SMDSAbs_Face )
294       fset.insert( static_cast<const SMDS_MeshFace *>( elem ));
295   }
296   bool ok = false;
297   try {
298     OCC_CATCH_SIGNALS;
299     ok = myPattern.Apply( aMesh, fset, theNodeIndexOnKeyPoint1, theReverse );
300   }
301   catch (Standard_Failure& exc) {
302     MESSAGE("OCCT Exception in SMESH_Pattern: " << exc.GetMessageString());
303   }
304   catch ( std::exception& exc ) {
305     MESSAGE("STD Exception in SMESH_Pattern: << exc.what()");
306   }
307   catch ( ... ) {
308     MESSAGE("Unknown Exception in SMESH_Pattern");
309   }
310
311   if ( ok && myPattern.GetMappedPoints( xyzList ))
312   {
313     points->length( xyzList.size() );
314     list<const gp_XYZ *>::iterator xyzIt = xyzList.begin();
315     for ( int i = 0; xyzIt != xyzList.end(); xyzIt++ ) {
316       SMESH::PointStruct & p = points[ i++ ];
317       (*xyzIt)->Coord( p.x, p.y, p.z );
318     }
319   }
320
321   // Update Python script
322   TPythonDump() << "pattern.ApplyToMeshFaces( " << theMesh << ".GetMesh(), "
323                 << theFacesIDs << ", "
324                 << TVar( theNodeIndexOnKeyPoint1 ) << ", " << theReverse << " )";
325
326   return points._retn();
327 }
328
329 //=======================================================================
330 //function : ApplyToHexahedrons
331 //purpose  : 
332 //=======================================================================
333
334 SMESH::point_array*
335   SMESH_Pattern_i::ApplyToHexahedrons(SMESH::SMESH_Mesh_ptr    theMesh,
336                                       const SMESH::long_array& theVolumesIDs,
337                                       CORBA::Long              theNode000Index,
338                                       CORBA::Long              theNode001Index)
339 {
340   SMESH::point_array_var points = new SMESH::point_array;
341
342   ::SMESH_Mesh* aMesh = getMesh( theMesh );
343   if ( !aMesh )
344     return points._retn();
345
346   list<const gp_XYZ *> xyzList;
347   set<const SMDS_MeshVolume*> vset;
348   for ( CORBA::ULong i = 0; i < theVolumesIDs.length(); i++)
349   {
350     CORBA::Long index = theVolumesIDs[i];
351     const SMDS_MeshElement * elem = aMesh->GetMeshDS()->FindElement(index);
352     if ( elem && elem->GetType() == SMDSAbs_Volume && elem->NbNodes() == 8 )
353       vset.insert( static_cast<const SMDS_MeshVolume *>( elem ));
354   }
355   if (myPattern.Apply( vset, theNode000Index, theNode001Index ) &&
356       myPattern.GetMappedPoints( xyzList ))
357   {
358     points->length( xyzList.size() );
359     list<const gp_XYZ *>::iterator xyzIt = xyzList.begin();
360     for ( int i = 0; xyzIt != xyzList.end(); xyzIt++ ) {
361       SMESH::PointStruct & p = points[ i++ ];
362       (*xyzIt)->Coord( p.x, p.y, p.z );
363     }
364   }
365
366   // Update Python script
367   TPythonDump() << "pattern.ApplyToHexahedrons( " << theMesh << ".GetMesh(), "
368                 << theVolumesIDs << ", "
369                 << TVar(theNode000Index) << ", " << TVar(theNode001Index) << " )";
370
371   return points._retn();
372 }
373
374 //=======================================================================
375 //function : MakeMesh
376 //purpose  : 
377 //=======================================================================
378
379 CORBA::Boolean SMESH_Pattern_i::MakeMesh (SMESH::SMESH_Mesh_ptr theMesh,
380                                           const CORBA::Boolean  CreatePolygons,
381                                           const CORBA::Boolean  CreatePolyedrs)
382 {
383   ::SMESH_Mesh* aMesh = getMesh( theMesh );
384   if ( !aMesh )
385     return false;
386
387   // Update Python script
388   TPythonDump() << "isDone = pattern.MakeMesh( " << theMesh << ".GetMesh(), "
389                 << CreatePolygons << ", " << CreatePolyedrs << " )";
390   addErrorCode( "MakeMesh" );
391
392   int nb = aMesh->NbNodes() + aMesh->NbEdges() + aMesh->NbFaces() + aMesh->NbVolumes();
393
394   bool res = myPattern.MakeMesh( aMesh, CreatePolygons, CreatePolyedrs );
395
396   if ( nb > 0 && nb != aMesh->NbNodes() + aMesh->NbEdges() + aMesh->NbFaces() + aMesh->NbVolumes())
397     {
398       aMesh->SetIsModified(true);
399       aMesh->GetMeshDS()->Modified();
400     }
401   return res;
402 }
403
404 //=======================================================================
405 //function : GetString
406 //purpose  : 
407 //=======================================================================
408
409 char* SMESH_Pattern_i::GetString()
410 {
411   ostringstream os;
412   myPattern.Save( os );
413   
414   return CORBA::string_dup( os.str().c_str() );
415 }
416
417 //=======================================================================
418 //function : Is2D
419 //purpose  : 
420 //=======================================================================
421
422 CORBA::Boolean SMESH_Pattern_i::Is2D()
423 {
424   return myPattern.Is2D();
425 }
426
427 //=======================================================================
428 //function : GetPoints
429 //purpose  : 
430 //=======================================================================
431
432 SMESH::point_array* SMESH_Pattern_i::GetPoints()
433 {
434   SMESH::point_array_var points = new SMESH::point_array;
435   list<const gp_XYZ *> xyzList;
436
437   if (myPattern.GetPoints( xyzList ))
438   {
439     points->length( xyzList.size() );
440     list<const gp_XYZ *>::iterator xyzIt = xyzList.begin();
441     for ( int i = 0; xyzIt != xyzList.end(); xyzIt++ ) {
442       SMESH::PointStruct & p = points[ i++ ];
443       (*xyzIt)->Coord( p.x, p.y, p.z );
444     }
445   }
446
447   return points._retn();
448 }
449
450 //=======================================================================
451 //function : GetKeyPoints
452 //purpose  : 
453 //=======================================================================
454
455 SMESH::long_array* SMESH_Pattern_i::GetKeyPoints()
456 {
457   SMESH::long_array_var ids = new SMESH::long_array;
458   if ( myPattern.IsLoaded() ) {
459     const list< int > & idList = myPattern.GetKeyPointIDs();
460     ids->length( idList.size() );
461     list< int >::const_iterator iIt = idList.begin();
462     for ( int i = 0; iIt != idList.end(); iIt++, i++ )
463       ids[ i ] = *iIt;
464   }
465   return ids._retn();
466 }
467
468 //=======================================================================
469 //function : GetElementPoints
470 //purpose  : 
471 //=======================================================================
472
473 SMESH::array_of_long_array* SMESH_Pattern_i::GetElementPoints(CORBA::Boolean applied)
474 {
475   SMESH::array_of_long_array_var arrayOfArray = new SMESH::array_of_long_array;
476
477   const list< list< int > >& listOfIdList = myPattern.GetElementPointIDs(applied);
478   arrayOfArray->length( listOfIdList.size() );
479   list< list< int > >::const_iterator llIt = listOfIdList.begin();
480   for ( int i = 0 ; llIt != listOfIdList.end(); llIt++, i++ )
481   {
482     const list< int > & idList = (*llIt);
483     SMESH::long_array& ids = arrayOfArray[ i ];
484     ids.length( idList.size() );
485     list< int >::const_iterator iIt = idList.begin();
486     for ( int j = 0; iIt != idList.end(); iIt++, j++ )
487       ids[ j ] = *iIt;
488   }
489   return arrayOfArray._retn();
490 }
491
492 //=======================================================================
493 //function : GetErrorCode
494 //purpose  : 
495 //=======================================================================
496
497 #define RETCASE(enm) case ::SMESH_Pattern::enm: return SMESH::SMESH_Pattern::enm;
498
499 SMESH::SMESH_Pattern::ErrorCode SMESH_Pattern_i::GetErrorCode()
500 {
501   switch ( myPattern.GetErrorCode() ) {
502     RETCASE( ERR_OK );
503     RETCASE( ERR_READ_NB_POINTS );
504     RETCASE( ERR_READ_POINT_COORDS );
505     RETCASE( ERR_READ_TOO_FEW_POINTS );
506     RETCASE( ERR_READ_3D_COORD );
507     RETCASE( ERR_READ_NO_KEYPOINT );
508     RETCASE( ERR_READ_BAD_INDEX );
509     RETCASE( ERR_READ_ELEM_POINTS );
510     RETCASE( ERR_READ_NO_ELEMS );
511     RETCASE( ERR_READ_BAD_KEY_POINT );
512     RETCASE( ERR_SAVE_NOT_LOADED );
513     RETCASE( ERR_LOAD_EMPTY_SUBMESH );
514     RETCASE( ERR_LOADF_NARROW_FACE );
515     RETCASE( ERR_LOADF_CLOSED_FACE );
516     RETCASE( ERR_LOADF_CANT_PROJECT );
517     RETCASE( ERR_LOADV_BAD_SHAPE );
518     RETCASE( ERR_LOADV_COMPUTE_PARAMS );
519     RETCASE( ERR_APPL_NOT_LOADED );
520     RETCASE( ERR_APPL_BAD_DIMENTION );
521     RETCASE( ERR_APPL_BAD_NB_VERTICES );
522     RETCASE( ERR_APPLF_BAD_TOPOLOGY );
523     RETCASE( ERR_APPLF_BAD_VERTEX );
524     RETCASE( ERR_APPLF_INTERNAL_EEROR );
525     RETCASE( ERR_APPLV_BAD_SHAPE );
526     RETCASE( ERR_MAKEM_NOT_COMPUTED );
527   default:;
528   };
529   return SMESH::SMESH_Pattern::ERR_OK;
530 }
531