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