src/HYDROData/HYDROData_Tool.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_Tool.h>
  20 #include <HYDROData_ArtificialObject.h>
  21 #include <HYDROData_Document.h>
  22 #include <HYDROData_Entity.h>
  23 #include <HYDROData_Iterator.h>
  24 #include <HYDROData_NaturalObject.h>
  25 #include <HYDROData_ShapesGroup.h>
  26 #include <QColor>
  27 #include <QFile>
  28 #include <QStringList>
  29 #include <QTextStream>
  30 #include <BRep_Tool.hxx>
  31 #include <BRepAdaptor_Surface.hxx>
  32 #include <BRepTopAdaptor_FClass2d.hxx>
  33 #include <ElSLib.hxx>
  34 #include <Geom_Curve.hxx>
  35 #include <gp_Pln.hxx>
  36 #include <Quantity_Color.hxx>
  37 #include <TopExp_Explorer.hxx>
  38 #include <TopoDS.hxx>
  39 #include <TopoDS_Face.hxx>
  40 #include <TopoDS_Shape.hxx>
  41 #include <TopoDS_Wire.hxx>
  42 #include <limits>
  43 #include <math.h>
  44
  45
  46 #include <BRepTools.hxx>
  47 #include <NCollection_Map.hxx>
  48 #include <TopExp_Explorer.hxx>
  49 #include <TopoDS_Face.hxx>
  50 #include <TopTools_ShapeMapHasher.hxx>
  51 #include <BRep_Builder.hxx>
  52 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
  53 #include <TopExp.hxx>
  54 #include <NCollection_List.hxx>
  55 #include <TopTools_ListIteratorOfListOfShape.hxx>
  56
  57 static int aMaxNameId = INT_MAX;
  58 void HYDROData_Tool::WriteStringsToFile( QFile&             theFile,
  59                                          const QStringList& theStrings,
  60                                          const QString&     theSep )
  61 {
  62   if ( !theFile.isOpen() || theStrings.isEmpty() )
  63     return;
  64
  65   QString aWriteStr = theStrings.join( theSep );
  66   if ( aWriteStr.isEmpty() )
  67     return;
  68
  69   QTextStream anOutStream( &theFile );
  70   anOutStream << aWriteStr.toUtf8() << theSep << theSep;
  71 }
  72
  73 bool HYDROData_Tool::ExtractGeneratedObjectName(const QString& theName, int& outValue, QString& thePrefName)
  74 {
  75   QStringList aLs = theName.split('_');
  76   bool ok = false;
  77   QString last = aLs.last();
  78   outValue = last.toInt(&ok);
  79   if (!ok)
  80     return false;
  81   int last_len = last.length();
  82   int total_len = theName.length();
  83   thePrefName = theName.left(total_len-last_len-1);
  84   return true;
  85 }
  86
  87 QString HYDROData_Tool::GenerateObjectName( const Handle(HYDROData_Document)& theDoc,
  88                                             const QString&                    thePrefix,
  89                                             const QStringList&                theUsedNames,
  90                                             const bool                        theIsTryToUsePurePrefix )
  91 {
  92   QStringList aNamesList( theUsedNames );
  93
  94   // Collect all used names in the document
  95   HYDROData_Iterator anIter( theDoc );
  96   for( ; anIter.More(); anIter.Next() )
  97   {
  98     Handle(HYDROData_Entity) anObject = anIter.Current();
  99     if( anObject.IsNull() )
 100       continue;
 101
 102     QString anObjName = anObject->GetName();
 103     if ( anObjName.isEmpty() )
 104       continue;
 105
 106     aNamesList.append( anObjName );
 107   }
 108
 109   QString aName;
 110
 111   if ( theIsTryToUsePurePrefix && !aNamesList.contains( thePrefix ) ) {
 112     aName = thePrefix;
 113   } else {
 114     int anId = 1;
 115     while( anId < aMaxNameId )
 116     {
 117       aName = QString( "%1_%2" ).arg( thePrefix ).arg( QString::number( anId++ ) );
 118
 119       // check that there are no other objects with the same name in the document
 120       if ( !aNamesList.contains( aName ) )
 121         break;
 122     }
 123   }
 124
 125   return aName;
 126 }
 127
 128 bool HYDROData_Tool::IsGeometryObject( const Handle(HYDROData_Entity)& theObject )
 129 {
 130   if ( theObject.IsNull() )
 131     return false;
 132
 133   return theObject->IsKind( STANDARD_TYPE(HYDROData_ArtificialObject) ) ||
 134          theObject->IsKind( STANDARD_TYPE(HYDROData_NaturalObject) );
 135 }
 136
 137 void HYDROData_Tool::UpdateChildObjectName( const QString&                  theOldStr,
 138                                             const QString&                  theNewStr,
 139                                             const Handle(HYDROData_Entity)& theObject )
 140 {
 141   if ( theObject.IsNull() )
 142     return;
 143
 144   QString anObjName = theObject->GetName();
 145   if ( theOldStr.isEmpty() )
 146   {
 147     while ( anObjName.startsWith( '_' ) )
 148       anObjName.remove( 0, 1 );
 149
 150     anObjName.prepend( theNewStr + "_" );
 151   }
 152   else if ( anObjName.startsWith( theOldStr ) )
 153   {
 154     anObjName.replace( 0, theOldStr.length(), theNewStr );
 155   }
 156   else
 157     return;
 158
 159   theObject->SetName( anObjName );
 160 }
 161
 162 QString HYDROData_Tool::GenerateNameForPython( const MapOfTreatedObjects& theTreatedObjects,
 163                                                const QString&             thePrefix )
 164 {
 165   QString aName = thePrefix;
 166   if ( !theTreatedObjects.contains( aName ) )
 167     return aName;
 168
 169   int anId = 1;
 170   while( anId < aMaxNameId )
 171   {
 172     aName = QString( "%1_%2" ).arg( thePrefix ).arg( QString::number( anId++ ) );
 173
 174     // check that there are no other objects with the same name
 175     if ( !theTreatedObjects.contains( aName ) )
 176       break;
 177   }
 178
 179   return aName;
 180 }
 181 //======================================================================================================
 182 TopAbs_State HYDROData_Tool::ComputePointState( const gp_XY& theXY, const TopoDS_Face& theFace )
 183 {
 184   TopAbs_State aState(TopAbs_UNKNOWN);
 185   if(theFace.IsNull()) return aState;
 186   Standard_Real aTol = BRep_Tool::Tolerance(theFace);
 187   BRepAdaptor_Surface Ads ( theFace, Standard_False );
 188   Standard_Real toluv = Min ( Ads.UResolution(aTol), Ads.VResolution(aTol) );
 189   const gp_Pln& aPlane = Ads.Surface().Plane();
 190   gp_Pnt aPnt(theXY.X(), theXY.Y(), 0.);
 191   Standard_Real aU1, aV1;
 192   ElSLib::Parameters(aPlane,aPnt, aU1, aV1);
 193   BRepTopAdaptor_FClass2d aClassifier( theFace, toluv );
 194   aState = aClassifier.Perform( gp_Pnt2d(aU1, aV1), Standard_False );
 195   return aState;
 196 }
 197
 198 double HYDROData_Tool::GetAltitudeForEdge( const TopoDS_Edge& theEdge,
 199                                            const gp_XY& thePoint,
 200                                            double theParameterTolerance,
 201                                            double theSquareDistanceTolerance,
 202                                            double theInvalidAltitude )
 203 {
 204   double aFirst, aLast;
 205   Handle(Geom_Curve) aCurve = BRep_Tool::Curve( theEdge, aFirst, aLast );
 206   if( aCurve.IsNull() )
 207     return theInvalidAltitude;
 208
 209   gp_Pnt aFirstPnt, aLastPnt;
 210
 211   aCurve->D0( aFirst, aFirstPnt );
 212   aCurve->D0( aLast, aLastPnt );
 213
 214   gp_Pnt2d aFirstPnt2d( aFirstPnt.X(), aFirstPnt.Y() );
 215   gp_Pnt2d aLastPnt2d( aLastPnt.X(), aLastPnt.Y() );
 216
 217   double aFirstDist = 0;
 218   double aLastDist = aFirstPnt2d.SquareDistance( aLastPnt2d );
 219   double aNecDist = aFirstPnt2d.SquareDistance( thePoint );
 220
 221   while( fabs( aLast - aFirst ) > theParameterTolerance )
 222   {
 223     double aMid = ( aFirst + aLast ) / 2;
 224     gp_Pnt aMidPnt;
 225     aCurve->D0( aMid, aMidPnt );
 226     double aDist = aFirstPnt2d.SquareDistance( gp_Pnt2d( aMidPnt.X(), aMidPnt.Y() ) );
 227
 228     if( aDist < aNecDist )
 229       aFirst = aMid;
 230     else
 231       aLast = aMid;
 232   }
 233
 234   double aMid = ( aFirst + aLast ) / 2;
 235   gp_Pnt aMidPnt;
 236   aCurve->D0( aMid, aMidPnt );
 237
 238   gp_Pnt2d aMidPnt2d( aMidPnt.X(), aMidPnt.Y() );
 239   if( aMidPnt2d.SquareDistance( thePoint ) < theSquareDistanceTolerance )
 240     return aMidPnt.Z();
 241   else
 242     return theInvalidAltitude;
 243 }
 244
 245 double HYDROData_Tool::GetAltitudeForWire( const TopoDS_Wire& theWire,
 246                                            const gp_XY& thePoint,
 247                                            double theParameterTolerance,
 248                                            double theSquareDistanceTolerance,
 249                                            double theInvalidAltitude )
 250 {
 251   TopExp_Explorer anExp( theWire, TopAbs_EDGE );
 252   for( ; anExp.More(); anExp.Next() )
 253   {
 254     double anAltitude = GetAltitudeForEdge( TopoDS::Edge( anExp.Current() ), thePoint,
 255       theParameterTolerance, theSquareDistanceTolerance, theInvalidAltitude );
 256     if( anAltitude != theInvalidAltitude )
 257       return anAltitude;
 258   }
 259   return theInvalidAltitude;
 260 }
 261
 262 TopoDS_Shape HYDROData_Tool::getFirstShapeFromGroup( const HYDROData_SequenceOfObjects& theGroups,
 263                                                      const int                          theGroupId )
 264 {
 265   TopoDS_Shape aResShape;
 266   if ( theGroupId < 1 || theGroupId > theGroups.Length() )
 267     return aResShape;
 268
 269   Handle(HYDROData_ShapesGroup) aGroup =
 270     Handle(HYDROData_ShapesGroup)::DownCast( theGroups.Value( theGroupId ) );
 271   if ( aGroup.IsNull() )
 272     return aResShape;
 273
 274   TopTools_SequenceOfShape aGroupShapes;
 275   aGroup->GetShapes( aGroupShapes );
 276
 277   if ( !aGroupShapes.IsEmpty() )
 278     aResShape = aGroupShapes.First();
 279
 280   return aResShape;
 281 }
 282
 283 TCollection_ExtendedString HYDROData_Tool::toExtString( const QString& theStr )
 284 {
 285   TCollection_ExtendedString aRes;
 286   if( !theStr.isEmpty() )
 287   {
 288           Standard_ExtString extStr = new Standard_ExtCharacter[ ( theStr.length() + 1 ) * 2 ];
 289           memcpy( (void*)extStr, theStr.unicode(), theStr.length() * 2 );
 290           ((short*)extStr)[theStr.length()] = '\0';
 291     aRes = TCollection_ExtendedString( extStr );
 292           delete [] extStr;
 293   }
 294   return aRes;
 295 }
 296
 297 QString HYDROData_Tool::toQString( const TCollection_ExtendedString& theStr )
 298 {
 299   return QString( (QChar*)theStr.ToExtString(), theStr.Length() );
 300 }
 301
 302 Quantity_Color HYDROData_Tool::toOccColor( const QColor& theColor )
 303 {
 304   double r = theColor.red() / 255.0;
 305   double g = theColor.green() / 255.0;
 306   double b = theColor.blue() / 255.0;
 307
 308   return Quantity_Color( r, g, b, Quantity_TOC_RGB );
 309 }
 310
 311 QColor HYDROData_Tool::toQtColor( const Quantity_Color& theColor )
 312 {
 313   int r = 255 * theColor.Red();
 314   int g = 255 * theColor.Green();
 315   int b = 255 * theColor.Blue();
 316   return QColor( r, g, b );
 317 }
 318
 319 bool HYDROData_Tool::IsNan( double theValue )
 320 {
 321 #ifdef WIN32
 322   return _isnan( theValue );
 323 #else
 324   return isnan( theValue );
 325 #endif
 326 }
 327
 328 bool HYDROData_Tool::IsInf( double theValue )
 329 {
 330 #ifdef WIN32
 331   return (!_finite( theValue  ) );
 332 #else
 333   return isinf( theValue );
 334 #endif
 335 }
 336
 337 static void MakeShellG(const NCollection_Map<TopoDS_Face, TopTools_ShapeMapHasher>& FG,
 338   TopoDS_Shape& outSh)
 339 {
 340   BRep_Builder bb;
 341   NCollection_Map<TopoDS_Face, TopTools_ShapeMapHasher>::Iterator itFG(FG);
 342   if (FG.Extent() > 1)
 343   {
 344     //face nb > 1 => make shell
 345     TopoDS_Shell outShell;
 346     bb.MakeShell(outShell);
 347     for (;itFG.More();itFG.Next())
 348       bb.Add(outShell, itFG.Value());
 349     outSh = outShell;
 350   }
 351   else if (FG.Extent() == 1)
 352   {
 353     outSh = itFG.Value(); //one face
 354   }
 355 }
 356
 357 TopoDS_Shape HYDROData_Tool::RebuildCmp(const TopoDS_Shape& in)
 358 {
 359   TopTools_IndexedDataMapOfShapeListOfShape mE2LF;
 360   TopExp::MapShapesAndAncestors(in, TopAbs_EDGE, TopAbs_FACE, mE2LF);
 361   if (mE2LF.IsEmpty())
 362     return TopoDS_Shape();
 363   NCollection_Map<TopoDS_Face, TopTools_ShapeMapHasher> dfm;
 364   //TopExp::MapShapes(aFuseShape, TopAbs_FACE, dfm);
 365   TopExp_Explorer expf(in, TopAbs_FACE);
 366   for (;expf.More(); expf.Next())
 367     dfm.Add(TopoDS::Face(expf.Current()));
 368
 369   int nbF = dfm.Extent();
 370   TopExp_Explorer exp_f(in, TopAbs_FACE);
 371   const TopoDS_Face& FF = TopoDS::Face(exp_f.Current());
 372   NCollection_List<TopoDS_Face> CurrFS;
 373   NCollection_List<TopoDS_Face> NeighFS;
 374   NCollection_Map<TopoDS_Face, TopTools_ShapeMapHasher> PrF;
 375   CurrFS.Append(FF);
 376   NCollection_List<NCollection_Map<TopoDS_Face, TopTools_ShapeMapHasher>> GL_F;
 377   NCollection_Map<TopoDS_Face, TopTools_ShapeMapHasher> OneGr;
 378   bool end = false;
 379   while (!end)
 380   {
 381     NCollection_List<TopoDS_Face>::Iterator it_currfs(CurrFS);
 382     NeighFS.Clear();
 383     for (;it_currfs.More();it_currfs.Next())
 384     {
 385       const TopoDS_Face& CF = it_currfs.Value();
 386       TopExp_Explorer exp_edge(CF, TopAbs_EDGE);
 387       for (;exp_edge.More();exp_edge.Next())
 388       {
 389         const TopoDS_Shape& CE = exp_edge.Current();
 390         const TopTools_ListOfShape& lsf = mE2LF.FindFromKey(CE);
 391         TopTools_ListIteratorOfListOfShape ls_it(lsf); //always one face (since all faces are planar)
 392         for (;ls_it.More();ls_it.Next())
 393         {
 394           const TopoDS_Face& F = TopoDS::Face(ls_it.Value());
 395           if (F.IsSame(CF))
 396             continue;
 397           if (!PrF.Contains(F))
 398           {
 399             OneGr.Add(F);
 400             NeighFS.Append(F);
 401             PrF.Add(F);
 402           }
 403         }
 404       }
 405       OneGr.Add(CF);
 406       PrF.Add(CF);
 407     }
 408     if (NeighFS.IsEmpty())
 409     {
 410       GL_F.Append(OneGr);
 411       OneGr.Clear();
 412       dfm.Subtract(PrF);
 413       if (dfm.IsEmpty())
 414         end = true;
 415       else
 416       {
 417         NCollection_Map<TopoDS_Face, TopTools_ShapeMapHasher>::Iterator itDm(dfm);
 418         const TopoDS_Face& nsh = itDm.Key();
 419         NeighFS.Append(nsh);
 420       }
 421     }
 422     CurrFS = NeighFS;
 423   }
 424
 425   TopoDS_Shape sh;
 426
 427   if (GL_F.Extent() > 1)
 428   {
 429     TopoDS_Compound cmp;
 430     NCollection_List<NCollection_Map<TopoDS_Face, TopTools_ShapeMapHasher>>::Iterator itGL_F(GL_F);
 431     BRep_Builder bb;
 432     bb.MakeCompound(cmp);
 433     for (;itGL_F.More();itGL_F.Next())
 434     {
 435       MakeShellG(itGL_F.Value(), sh);
 436       if (!sh.IsNull())
 437         bb.Add(cmp, sh);
 438     }
 439     return  cmp;
 440   }
 441   else if (GL_F.Extent() == 1)
 442   {
 443     MakeShellG(GL_F.First(), sh);
 444     return sh;
 445   }
 446
 447 }
 448
 449
 450 std::ostream& operator<<( std::ostream& theStream, const QString& theText )
 451 {
 452   theStream << theText.toStdString();
 453   return theStream;
 454 }
 455
 456 std::ostream& operator<<( std::ostream& theStream, const QColor& theColor )
 457 {
 458   theStream << "[" << theColor.red() << ", " << theColor.green() << ", " << theColor.blue() << "]";
 459   return theStream;
 460 }
 461
 462 std::ostream& operator<<( std::ostream& theStream, const TopoDS_Shape& theShape )
 463 {
 464   theStream << "[" << theShape.TShape().operator->() << "]";
 465   return theStream;
 466 }
 467
 468 std::ostream& operator<<( std::ostream& theStream, const TopoDS_Face& theFace )
 469 {
 470   theStream << "[" << theFace.TShape().operator->() << "]";
 471   return theStream;
 472 }
 473
 474 std::ostream& operator<<( std::ostream& theStream, const gp_XY& theXY )
 475 {
 476   theStream << "(" << theXY.X() << "; " << theXY.Y() << ")";
 477   return theStream;
 478 }
 479
 480 bool operator == ( const gp_XY& thePoint1, const gp_XY& thePoint2 )
 481 {
 482   const double EPS = 1E-3;
 483   return
 484     fabs( thePoint1.X() - thePoint2.X() ) < EPS &&
 485     fabs( thePoint1.Y() - thePoint2.Y() ) < EPS;
 486
 487 }