]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROData/HYDROData_Obstacle.cxx
Salome HOME
Merge branch 'BR_LAND_COVER_MAP' of ssh://git.salome-platform.org/modules/hydro into...
[modules/hydro.git] / src / HYDROData / HYDROData_Obstacle.cxx
1 // Copyright (C) 2014-2015  EDF-R&D
2 // This library is free software; you can redistribute it and/or
3 // modify it under the terms of the GNU Lesser General Public
4 // License as published by the Free Software Foundation; either
5 // version 2.1 of the License, or (at your option) any later version.
6 //
7 // This library is distributed in the hope that it will be useful,
8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10 // Lesser General Public License for more details.
11 //
12 // You should have received a copy of the GNU Lesser General Public
13 // License along with this library; if not, write to the Free Software
14 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
15 //
16 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
17 //
18
19 #include "HYDROData_Obstacle.h"
20
21 #include "HYDROData_Document.h"
22 #include "HYDROData_ShapesGroup.h"
23 #include "HYDROData_ShapesTool.h"
24 #include "HYDROData_Tool.h"
25 #include "HYDROData_GeomTool.h"
26
27 #ifdef WIN32
28   #pragma warning ( disable: 4251 )
29 #endif
30
31 #ifndef LIGHT_MODE
32 #include <Basics_Utils.hxx>
33 #endif
34
35 #ifdef WIN32
36   #pragma warning ( default: 4251 )
37 #endif
38
39 #include <BRepTools.hxx>
40 #include <BRep_Builder.hxx>
41
42 #include <IGESControl_Reader.hxx>
43 #include <IGESData_IGESModel.hxx>
44
45 #include <STEPControl_Reader.hxx>
46
47 #include <Interface_Static.hxx>
48
49 #include <TopoDS.hxx>
50 #include <TopoDS_Iterator.hxx>
51 #include <TopoDS_Shape.hxx>
52 #include <TopoDS_Edge.hxx>
53
54 #include <TDataStd_AsciiString.hxx>
55 #include <TDataStd_RealArray.hxx>
56
57 #include <TColStd_SequenceOfAsciiString.hxx>
58
59 #include <TopExp_Explorer.hxx>
60
61 #ifdef WIN32
62   #pragma warning ( disable: 4251 )
63 #endif
64
65 #include <QColor>
66 #include <QFile>
67 #include <QFileInfo>
68 #include <QStringList>
69
70 #ifdef WIN32
71   #pragma warning ( default: 4251 )
72 #endif
73
74 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic
75
76 #include <HYDROData_Projection.h>
77
78 IMPLEMENT_STANDARD_HANDLE(HYDROData_Obstacle,HYDROData_ArtificialObject)
79 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Obstacle,HYDROData_ArtificialObject)
80
81
82 HYDROData_Obstacle::HYDROData_Obstacle()
83 : HYDROData_ArtificialObject( Geom_3d )
84 {
85 }
86
87 HYDROData_Obstacle::~HYDROData_Obstacle()
88 {
89 }
90
91 QStringList HYDROData_Obstacle::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
92 {
93   QStringList aResList = dumpObjectCreation( theTreatedObjects );
94   
95   QString anObstacleName = GetObjPyName();
96
97   TCollection_AsciiString aGeomObjectEntry = GetGeomObjectEntry();
98   QString aFilePath = GetFilePath();
99
100   if ( !aGeomObjectEntry.IsEmpty() )
101   {
102     QString aSalomeObjName = HYDROData_Tool::GenerateNameForPython( theTreatedObjects, "obstacle_sobj" );
103     // aResList << QString( "%1 = theStudy.FindObjectID( \"%2\" );" )
104     //            .arg( aSalomeObjName ).arg( aGeomObjectEntry.ToCString() );
105     QString aGeomObjectName( GetGeomObjectName().ToCString() );
106     if ( !aGeomObjectName.isEmpty() ) {
107       aResList << QString( "%1 = theStudy.FindObjectByName( \"%2\", \"GEOM\" )[0];" )
108                   .arg( aSalomeObjName ).arg( aGeomObjectName );
109
110       aResList << QString( "%1.ImportFromGeomIOR( %2.GetIOR() );" )
111                   .arg( anObstacleName ).arg( aSalomeObjName );
112
113       aResList << QString( "%1.SetGeomObjectEntry( %2.GetID() );" )
114                   .arg( anObstacleName ).arg( aSalomeObjName );
115     }
116     aResList << QString( "" );
117   }
118   else if ( !aFilePath.isEmpty() )
119   {
120     aResList << QString( "%1.ImportFromFile( \"%2\" );" )
121                 .arg( anObstacleName ).arg( aFilePath );
122     aResList << QString( "" );
123   }
124
125   // Write the translation points
126   double aDx, aDy, aDz;
127   if ( getTranslation( aDx, aDy, aDz ) )
128   {
129     aResList << QString( "%1.Translate( %2, %3, %4 );" )
130                 .arg( anObstacleName ).arg( aDx ).arg( aDy ).arg( aDz );
131     aResList << QString( "" );
132   }
133
134   aResList << QString( "%1.Update();" ).arg( anObstacleName );
135   aResList << QString( "" );
136
137   return aResList;
138 }
139
140 void HYDROData_Obstacle::Update()
141 {
142   RemoveGroupObjects();
143   createGroupObjects();
144   checkAndSetAltitudeObject();
145
146   HYDROData_Entity::Update();
147 }
148
149 bool HYDROData_Obstacle::IsHas2dPrs() const
150 {
151   return true;
152 }
153
154 void HYDROData_Obstacle::SetShape3D( const TopoDS_Shape& theShape )
155 {
156   TopoDS_Face aShape2d = HYDROData_Projection::MakeProjection( theShape );
157   HYDROData_ArtificialObject::SetShape3D( theShape );
158   HYDROData_ArtificialObject::SetTopShape( aShape2d );
159 }
160
161 QColor HYDROData_Obstacle::DefaultFillingColor() const
162 {
163   return QColor( Qt::yellow );
164 }
165
166 QColor HYDROData_Obstacle::DefaultBorderColor() const
167 {
168   return QColor( Qt::transparent );
169 }
170
171 bool HYDROData_Obstacle::ImportFromFile( const QString& theFilePath )
172 {
173   // Check the file existence
174   QFileInfo aFileInfo( theFilePath );
175   if ( !aFileInfo.exists() ) {
176     return false;
177   }
178
179   bool aRes = false;
180   TopoDS_Shape aShape;
181
182   // Import file
183   QString aFileSuf = aFileInfo.suffix().toLower();
184   if ( aFileSuf == "brep" ) {
185     aShape = ImportBREP( theFilePath );
186   } else if ( aFileSuf == "iges" || aFileSuf == "igs" ) {
187     aShape = ImportIGES( theFilePath );
188   } else if ( aFileSuf == "step" ) {
189     aShape = ImportSTEP( theFilePath );
190   }
191  
192   // Check the result shape
193   aRes = !aShape.IsNull();
194
195   // Set shape to the obstacle in case of success
196   if ( aRes ) {
197     SetShape3D( aShape );
198     SetFilePath( theFilePath );
199   }
200
201   return aRes;
202 }
203
204 void HYDROData_Obstacle::SetFilePath( const QString& theFilePath )
205 {
206   TCollection_AsciiString anAsciiStr( theFilePath.toStdString().c_str() );
207   TDataStd_AsciiString::Set( myLab.FindChild( DataTag_FilePath ), anAsciiStr );
208 }
209
210 QString HYDROData_Obstacle::GetFilePath() const
211 {
212   QString aRes;
213
214   TDF_Label aLabel = myLab.FindChild( DataTag_FilePath, false );
215   if ( !aLabel.IsNull() )
216   {
217     Handle(TDataStd_AsciiString) anAsciiStr;
218     if ( aLabel.FindAttribute( TDataStd_AsciiString::GetID(), anAsciiStr ) )
219       aRes = QString( anAsciiStr->Get().ToCString() );
220   }
221
222   return aRes;
223 }
224
225 bool HYDROData_Obstacle::ImportFromGeomIOR( const TCollection_AsciiString& theIOR )
226 {
227   bool aRes = false;
228
229 #ifndef LIGHT_MODE
230   if ( theIOR.IsEmpty() ) {
231     return aRes;
232   }
233   
234   int aDocId = -1;
235   if ( !HYDROData_Document::DocumentId( HYDROData_Document::Document( myLab ), aDocId ) || aDocId < 0 ) {
236     return aRes;
237   }
238
239   // TopoDS_Shape aShape = GEOMBase::GetShapeFromIOR( theIOR.ToCString() );
240   TopoDS_Shape aShape = HYDROData_GeomTool::GetShapeFromIOR( aDocId, theIOR.ToCString() );
241
242   if ( !aShape.IsNull() ) {
243     SetShape3D( aShape );
244     aRes = true;
245   }
246 #endif
247
248   return aRes;
249 }
250
251 void HYDROData_Obstacle::SetGeomObjectEntry( const TCollection_AsciiString& theEntry )
252 {
253   TDataStd_AsciiString::Set( myLab.FindChild( DataTag_GeomObjectEntry ), theEntry );
254 }
255
256 TCollection_AsciiString HYDROData_Obstacle::GetGeomObjectEntry() const
257 {
258   TCollection_AsciiString aRes;
259
260   TDF_Label aLabel = myLab.FindChild( DataTag_GeomObjectEntry, false );
261   if ( !aLabel.IsNull() )
262   {
263     Handle(TDataStd_AsciiString) anAsciiStr;
264     if ( aLabel.FindAttribute( TDataStd_AsciiString::GetID(), anAsciiStr ) )
265       aRes = anAsciiStr->Get();
266   }
267
268   return aRes;
269 }
270
271 TCollection_AsciiString HYDROData_Obstacle::GetGeomObjectName() const
272 {
273   TCollection_AsciiString aRes;
274
275   int aDocId = -1;
276   if ( !HYDROData_Document::DocumentId( HYDROData_Document::Document( myLab ), aDocId ) || aDocId < 0 ) {
277     return aRes;
278   }
279
280 #ifndef LIGHT_MODE
281   SALOMEDS::Study_var aDSStudy = HYDROData_GeomTool::GetStudyByID( aDocId );
282
283   if ( !aDSStudy->_is_nil() ) {
284     TCollection_AsciiString anEntry = GetGeomObjectEntry();
285     SALOMEDS::SObject_var aSObject = aDSStudy->FindObjectID( anEntry.ToCString() );
286     if ( !aSObject->_is_nil() ) {
287       aRes = TCollection_AsciiString( aSObject->GetName() );
288     }
289   }
290 #endif
291   return aRes;
292 }
293
294 void HYDROData_Obstacle::Translate( const double theDx,
295                                     const double theDy,
296                                     const double theDz )
297 {
298   TopoDS_Shape aShape3D = GetShape3D();
299   
300   TopoDS_Shape aTranslatedShape3D = HYDROData_ShapesTool::Translated( aShape3D, theDx, theDy, theDz );
301   if ( aTranslatedShape3D.IsNull() )
302     return;
303
304   SetShape3D( aTranslatedShape3D );
305
306   setTranslation( theDx, theDy, theDz );
307 }
308
309 TopoDS_Shape HYDROData_Obstacle::ImportBREP( const QString& theFilePath ) const
310 {
311   TopoDS_Shape aResShape;
312
313   BRep_Builder aBrepBuilder;
314   BRepTools::Read( aResShape, qPrintable(theFilePath), aBrepBuilder );
315
316   return aResShape;
317 }
318
319 TopoDS_Shape HYDROData_Obstacle::ImportIGES( const QString& theFilePath ) const
320 {
321   TopoDS_Shape aResShape;
322
323 #ifndef LIGHT_MODE
324   // Set "C" numeric locale to save numbers correctly
325   Kernel_Utils::Localizer loc;
326
327   IGESControl_Reader aReader;
328
329   Interface_Static::SetCVal("xstep.cascade.unit","M");
330
331   try {
332     OCC_CATCH_SIGNALS;
333
334     IFSelect_ReturnStatus status = aReader.ReadFile(qPrintable(theFilePath));
335
336     if (status == IFSelect_RetDone) {
337       // Rescale units
338       Handle(IGESData_IGESModel) aModel =
339         Handle(IGESData_IGESModel)::DownCast(aReader.Model());
340       if (!aModel.IsNull()) {
341         IGESData_GlobalSection aGS = aModel->GlobalSection();
342         aGS.SetUnitFlag(6);
343         aModel->SetGlobalSection(aGS);
344       }
345     
346       aReader.ClearShapes();
347       aReader.TransferRoots();
348
349       aResShape = aReader.OneShape();
350     } 
351     else {
352       aResShape.Nullify();
353     }
354   }
355   catch(Standard_Failure) {
356     aResShape.Nullify();
357   }
358 #endif
359
360   return aResShape;
361 }
362
363 TopoDS_Shape HYDROData_Obstacle::ImportSTEP( const QString& theFilePath ) const
364 {
365   TopoDS_Shape aResShape;
366
367 #ifndef LIGHT_MODE
368   // Set "C" numeric locale to save numbers correctly
369   Kernel_Utils::Localizer loc;
370
371   STEPControl_Reader aReader;
372
373   // Convert to METERS
374   Interface_Static::SetCVal("xstep.cascade.unit","M");
375   Interface_Static::SetIVal("read.step.ideas", 1);
376   Interface_Static::SetIVal("read.step.nonmanifold", 1);
377
378   BRep_Builder B;
379   TopoDS_Compound compound;
380   B.MakeCompound(compound);
381
382   try {
383     OCC_CATCH_SIGNALS;
384
385     IFSelect_ReturnStatus status = aReader.ReadFile( qPrintable(theFilePath) );
386
387     if (status == IFSelect_RetDone) {
388       // Rescale units
389       // set UnitFlag to units from file
390       TColStd_SequenceOfAsciiString anUnitLengthNames;
391       TColStd_SequenceOfAsciiString anUnitAngleNames;
392       TColStd_SequenceOfAsciiString anUnitSolidAngleNames;
393       aReader.FileUnits(anUnitLengthNames, anUnitAngleNames, anUnitSolidAngleNames);
394       if (anUnitLengthNames.Length() > 0) {
395         TCollection_AsciiString aLenUnits = anUnitLengthNames.First();
396         if (aLenUnits == "millimetre")
397           Interface_Static::SetCVal("xstep.cascade.unit", "MM");
398         else if (aLenUnits == "centimetre")
399           Interface_Static::SetCVal("xstep.cascade.unit", "CM");
400         else if (aLenUnits == "metre" || aLenUnits.IsEmpty())
401           Interface_Static::SetCVal("xstep.cascade.unit", "M");
402         else if (aLenUnits == "INCH")
403           Interface_Static::SetCVal("xstep.cascade.unit", "INCH");
404         else {
405           // The file contains not supported units
406           return aResShape;
407         }
408       }
409         
410       Standard_Boolean failsonly = Standard_False;
411       aReader.PrintCheckLoad(failsonly, IFSelect_ItemsByEntity);
412
413       // Root transfers
414       Standard_Integer nbr = aReader.NbRootsForTransfer();
415       aReader.PrintCheckTransfer(failsonly, IFSelect_ItemsByEntity);
416
417       for (Standard_Integer n = 1; n <= nbr; n++) {
418         Standard_Boolean ok = aReader.TransferRoot(n);
419         // Collecting resulting entities
420         Standard_Integer nbs = aReader.NbShapes();
421         if (!ok || nbs == 0) {
422           continue; // skip empty root
423         } 
424         else if (nbr == 1 && nbs == 1) { // For a single entity
425           aResShape = aReader.Shape(1);
426           // ATTENTION: this is a workaround for mantis issue 0020442 remark 0010776
427           // It should be removed after patching OCCT for bug OCC22436
428           // (fix for OCCT is expected in service pack next to OCCT6.3sp12)
429           if (aResShape.ShapeType() == TopAbs_COMPOUND) {
430             int nbSub1 = 0;
431             TopoDS_Shape currShape;
432             TopoDS_Iterator It (aResShape, Standard_True, Standard_True);
433             for (; It.More(); It.Next()) {
434               nbSub1++;
435               currShape = It.Value();
436             }
437             if (nbSub1 == 1)
438               aResShape = currShape;
439           }
440           // END workaround
441           break;
442         }
443
444         for (Standard_Integer i = 1; i <= nbs; i++) {
445           TopoDS_Shape aShape = aReader.Shape(i);
446           if (aShape.IsNull()) {
447             continue;
448           }
449           else {
450             B.Add(compound, aShape);
451           }
452         }
453       }
454   
455       if (aResShape.IsNull())
456         aResShape = compound;
457
458       // Check if any BRep entity has been read, there must be at least a vertex
459       if ( !TopExp_Explorer( aResShape, TopAbs_VERTEX ).More() ) {
460         // No geometrical data in the imported file
461         return TopoDS_Shape();
462       }
463     }
464     else {
465       aResShape.Nullify();
466     }
467   }
468   catch (Standard_Failure) {
469     aResShape.Nullify();
470   }
471 #endif
472
473   return aResShape;
474 }
475
476 ObjectKind HYDROData_Obstacle::getAltitudeObjectType() const
477 {
478   return KIND_OBSTACLE_ALTITUDE;
479 }
480
481 void HYDROData_Obstacle::createGroupObjects()
482 {
483   TopoDS_Shape anObstacleShape = GetTopShape();
484   if ( !anObstacleShape.IsNull() )
485   {
486     TopTools_SequenceOfShape aWireEdges;
487     HYDROData_ShapesTool::ExploreShapeToShapes( anObstacleShape, TopAbs_EDGE, aWireEdges );
488     if ( !aWireEdges.IsEmpty() )
489     {
490       QString aWireGroupName = GetName() + "_Outer_Wire";
491
492       Handle(HYDROData_ShapesGroup) anExtWireGroup = createGroupObject();
493       anExtWireGroup->SetName( aWireGroupName );
494      
495       anExtWireGroup->SetShapes( aWireEdges );
496     }
497   }
498 }
499
500 void HYDROData_Obstacle::setTranslation( const double theDx, 
501                                          const double theDy, 
502                                          const double theDz )
503 {
504   TDF_Label aLabel = myLab.FindChild( DataTag_Translation );
505
506   double aCurDx = theDx;
507   double aCurDy = theDy;
508   double aCurDz = theDz;
509
510   double aPrevDx, aPrevDy, aPrevDz;
511   if ( getTranslation( aPrevDx, aPrevDy, aPrevDz ) )
512   {
513     aCurDx += aPrevDx;
514     aCurDy += aPrevDy;
515     aCurDz += aPrevDz;
516   }
517   
518   Handle(TDataStd_RealArray) aCoeffsArray = TDataStd_RealArray::Set( aLabel, 1, 3 );
519   aCoeffsArray->SetValue( 1, aCurDx );
520   aCoeffsArray->SetValue( 2, aCurDy );
521   aCoeffsArray->SetValue( 3, aCurDz );
522 }
523
524 bool HYDROData_Obstacle::getTranslation( double& theDx, double& theDy, double& theDz ) const
525 {
526   theDx = theDy = theDz = 0.0;
527
528   TDF_Label aLabel = myLab.FindChild( DataTag_Translation, false );
529   if ( aLabel.IsNull() )
530     return false;
531
532   Handle(TDataStd_RealArray) aCoeffsArray;
533   if ( !aLabel.FindAttribute( TDataStd_RealArray::GetID(), aCoeffsArray ) )
534     return false;
535
536   theDx = aCoeffsArray->Value( 1 );
537   theDy = aCoeffsArray->Value( 2 );
538   theDz = aCoeffsArray->Value( 3 );
539
540   return true;
541 }
542
543 void HYDROData_Obstacle::UpdateLocalCS( double theDx, double theDy )
544 {
545   Translate( theDx, theDy, 0 );
546 }
547