src/HYDROData/HYDROData_DTM.cxx

   1
   2 #include <HYDROData_DTM.h>
   3 #include <HYDROData_Profile.h>
   4
   5 #include <Geom2d_BSplineCurve.hxx>
   6 #include <Geom2dAPI_Interpolate.hxx>
   7 #include <TColgp_HArray1OfPnt2d.hxx>
   8 #include <TColgp_Array1OfVec2d.hxx>
   9 #include <TColStd_HArray1OfBoolean.hxx>
  10 #include <TopoDS.hxx>
  11 #include <TopoDS_Edge.hxx>
  12 #include <TopoDS_Wire.hxx>
  13 #include <TopExp_Explorer.hxx>
  14 #include <BRep_Tool.hxx>
  15 #include <gp_Ax3.hxx>
  16 #include <Geom_Line.hxx>
  17 #include <Geom2d_Line.hxx>
  18 #include <Geom2d_TrimmedCurve.hxx>
  19 #include <Geom_BSplineCurve.hxx>
  20 #include <Geom2d_BSplineCurve.hxx>
  21 #include <GeomAPI_Interpolate.hxx>
  22 #include <TColStd_Array1OfReal.hxx>
  23 #include <TColStd_Array1OfInteger.hxx>
  24 #include <TColgp_Array1OfPnt.hxx>
  25 #include <TColgp_Array1OfVec.hxx>
  26 #include <TColgp_HArray1OfPnt.hxx>
  27 #include <Geom2dAPI_InterCurveCurve.hxx>
  28 #include <Geom2dAPI_ProjectPointOnCurve.hxx>
  29 #include <Geom2dAdaptor_Curve.hxx>
  30 #include <GCPnts_AbscissaPoint.hxx>
  31 #include <BRepBuilderAPI_MakeEdge.hxx>
  32 #include <limits>
  33
  34 #include <BRepLib_MakeEdge.hxx>
  35 #include <BRepLib_MakeWire.hxx>
  36 #include <BRep_Builder.hxx>
  37 #include <GeomProjLib.hxx>
  38 #include <Geom_TrimmedCurve.hxx>
  39 #include <Geom_Plane.hxx>
  40 #include <BRepTools_WireExplorer.hxx>
  41 #include <TopTools_IndexedMapOfShape.hxx>
  42 #include <BRepBuilderAPI_MakeFace.hxx>
  43 #include <TopExp.hxx>
  44 #include <TopTools_IndexedMapOfOrientedShape.hxx>
  45
  46 #include <BRepLib_MakeEdge.hxx>
  47 #include <BRepLib_MakeWire.hxx>
  48 #include <BRep_Builder.hxx>
  49
  50
  51
  52 IMPLEMENT_STANDARD_HANDLE( HYDROData_DTM, HYDROData_Bathymetry )
  53 IMPLEMENT_STANDARD_RTTIEXT( HYDROData_DTM, HYDROData_Bathymetry )
  54
  55
  56 HYDROData_DTM::CurveUZ::CurveUZ( double theXCurv, const gp_Vec2d& theProfileDir )
  57   : myXcurv( theXCurv ), myProfileDir( theProfileDir )
  58 {
  59 }
  60
  61 HYDROData_DTM::CurveUZ::~CurveUZ()
  62 {
  63 }
  64
  65 double HYDROData_DTM::CurveUZ::Xcurv() const
  66 {
  67   return myXcurv;
  68 }
  69
  70 gp_Vec2d HYDROData_DTM::CurveUZ::ProfileDir() const
  71 {
  72   return myProfileDir;
  73 }
  74
  75 HYDROData_DTM::CurveUZ HYDROData_DTM::CurveUZ::operator + ( const CurveUZ& c ) const
  76 {
  77   HYDROData_DTM::CurveUZ res( Xcurv() + c.Xcurv(), ProfileDir() + c.ProfileDir() );
  78   size_t n = size();
  79   res.reserve( n );
  80   for( int i=0; i<n; i++ )
  81   {
  82     PointUZ p;
  83     p.U = operator[]( i ).U + c[i].U;
  84     p.Z = operator[]( i ).Z;
  85     res.push_back( p );
  86   }
  87   return res;
  88 }
  89
  90 HYDROData_DTM::CurveUZ HYDROData_DTM::CurveUZ::operator * ( double d ) const
  91 {
  92   HYDROData_DTM::CurveUZ res( Xcurv()*d, ProfileDir()*d );
  93   size_t n = size();
  94   res.reserve( n );
  95   for( int i=0; i<n; i++ )
  96   {
  97     PointUZ p;
  98     p.U = operator[]( i ).U * d;
  99     p.Z = operator[]( i ).Z;
 100     res.push_back( p );
 101   }
 102   return res;
 103 }
 104
 105
 106
 107
 108 HYDROData_DTM::HYDROData_DTM()
 109 {
 110 }
 111
 112 HYDROData_DTM::~HYDROData_DTM()
 113 {
 114 }
 115
 116 HYDROData_SequenceOfObjects HYDROData_DTM::GetProfiles() const
 117 {
 118   return GetReferenceObjects( DataTag_Profiles );
 119 }
 120
 121 void HYDROData_DTM::SetProfiles( const HYDROData_SequenceOfObjects& theProfiles )
 122 {
 123   SetReferenceObjects( theProfiles, DataTag_Profiles );
 124 }
 125
 126 double HYDROData_DTM::GetDDZ() const
 127 {
 128   return GetDouble( DataTag_DDZ );
 129 }
 130
 131 void HYDROData_DTM::SetDDZ( double theDDZ )
 132 {
 133   SetDouble( DataTag_DDZ, theDDZ );
 134 }
 135
 136 double HYDROData_DTM::GetSpatialStep() const
 137 {
 138   return GetDouble( DataTag_SpatialStep );
 139 }
 140
 141 void HYDROData_DTM::SetSpatialStep( double theSpatialStep )
 142 {
 143   SetDouble( DataTag_SpatialStep, theSpatialStep );
 144 }
 145
 146 void HYDROData_DTM::PointToWire(const AltitudePoints& pnts, TopoDS_Wire& W )
 147 {
 148   BRepLib_MakeWire WM;
 149   if (pnts.empty())
 150     return;
 151   for (int i = 0; i < pnts.size() - 1; i++)
 152   {
 153     gp_Pnt p1(pnts[i].X, pnts[i].Y, pnts[i].Z);
 154     gp_Pnt p2(pnts[i+1].X, pnts[i+1].Y, pnts[i+1].Z);
 155     WM.Add(BRepLib_MakeEdge(p1, p2).Edge());
 156   }
 157   if (WM.IsDone())
 158     W = WM.Wire();
 159 }
 160
 161 TopTools_IndexedMapOfOrientedShape HYDROData_DTM::Create3DShape(const AltitudePoints& left,
 162                                                                 const AltitudePoints& right,
 163                                                                 const std::vector<AltitudePoints>& main_profiles)
 164 {
 165   TopTools_IndexedMapOfOrientedShape ll;
 166   TopoDS_Wire LWire, RWire;
 167   PointToWire(left, LWire);
 168   PointToWire(right, RWire);
 169   if (!LWire.IsNull())
 170     ll.Add(LWire.Oriented(TopAbs_FORWARD));
 171
 172   for (int k = 0; k < main_profiles.size(); k++)
 173   {
 174     TopoDS_Wire W;
 175     PointToWire(main_profiles[k], W);
 176     TopAbs_Orientation Ori = TopAbs_INTERNAL;
 177     if (k == 0 || k == main_profiles.size() - 1)
 178       Ori = TopAbs_FORWARD;
 179     ll.Add(W.Oriented(Ori));
 180   }
 181
 182   if (!RWire.IsNull())
 183     ll.Add(RWire.Oriented(TopAbs_FORWARD));
 184   //yes, add subshapes in this order (left + profiles + right)
 185   //otherwise the projected wire will be non-manifold
 186
 187   return ll;
 188 }
 189
 190
 191 void HYDROData_DTM::Update()
 192 {
 193   AltitudePoints points;
 194   TopoDS_Shape Out3dPres;
 195   TopoDS_Shape Out2dPres;
 196   TopoDS_Shape OutLeftB;
 197   TopoDS_Shape OutRightB;
 198   TopoDS_Shape OutInlet;
 199   TopoDS_Shape OutOutlet;
 200
 201   HYDROData_SequenceOfObjects objs = GetProfiles();
 202   double ddz = GetDDZ();
 203   double step = GetSpatialStep();
 204   std::set<int> InvInd;
 205   CreateProfilesFromDTM( objs, ddz, step, points, Out3dPres, Out2dPres, OutLeftB, OutRightB, OutInlet, OutOutlet, true, true, InvInd );
 206   SetAltitudePoints( points );
 207
 208   SetShape( DataTag_LeftBankShape, OutLeftB);
 209   SetShape( DataTag_RightBankShape, OutRightB);
 210   SetShape( DataTag_InletShape, OutInlet);
 211   SetShape( DataTag_OutletShape, OutOutlet );
 212   SetShape( DataTag_3DShape, Out3dPres );
 213   SetShape( DataTag_2DShape, Out2dPres );
 214
 215   HYDROData_Bathymetry::Update();
 216 }
 217
 218 void HYDROData_DTM::GetPresentationShapes( TopoDS_Shape& Out3dPres,
 219                                            TopoDS_Shape& Out2dPres,
 220                                            TopoDS_Shape& OutLeftB,
 221                                            TopoDS_Shape& OutRightB,
 222                                            TopoDS_Shape& OutInlet,
 223                                            TopoDS_Shape& OutOutlet )
 224 {
 225   //without update!
 226   OutLeftB = GetShape( DataTag_LeftBankShape);
 227   OutRightB = GetShape( DataTag_RightBankShape);
 228   OutInlet = GetShape( DataTag_InletShape);
 229   OutOutlet = GetShape( DataTag_OutletShape );
 230   Out3dPres = GetShape( DataTag_3DShape );
 231   Out2dPres = GetShape( DataTag_2DShape );
 232 }
 233
 234 void HYDROData_DTM::CreateProfilesFromDTM (const HYDROData_SequenceOfObjects& InpProfiles,
 235                                            double ddz,
 236                                            double step,
 237                                            AltitudePoints& points,
 238                                            TopoDS_Shape& Out3dPres,
 239                                            TopoDS_Shape& Out2dPres,
 240                                            TopoDS_Shape& OutLeftB,
 241                                            TopoDS_Shape& OutRightB,
 242                                            TopoDS_Shape& OutInlet,
 243                                            TopoDS_Shape& OutOutlet,
 244                                            bool Create3dPres,
 245                                            bool Create2dPres,
 246                                            std::set<int>& InvInd)
 247 {
 248
 249   int aLower = InpProfiles.Lower(), anUpper = InpProfiles.Upper();
 250   size_t n = anUpper - aLower + 1;
 251
 252   std::vector<Handle_HYDROData_Profile> profiles;
 253   profiles.reserve( n );
 254   for( int i=aLower; i<=anUpper; i++ )
 255   {
 256     Handle(HYDROData_Profile) aProfile = Handle(HYDROData_Profile)::DownCast( InpProfiles.Value( i ) );
 257     if( !aProfile.IsNull() )
 258       profiles.push_back( aProfile );
 259   }
 260   const double EPS = 1E-3;
 261   AltitudePoints left;
 262   AltitudePoints right;
 263   std::vector<AltitudePoints> main_profiles;
 264
 265   if( ddz>EPS && step>EPS )
 266     CreateProfiles(profiles, ddz, step, left, right, points, main_profiles,
 267     Out3dPres, Out2dPres, OutLeftB, OutRightB, OutInlet, OutOutlet, Create3dPres, Create2dPres, InvInd );
 268 }
 269
 270 void HYDROData_DTM::ProjWireOnPlane(const TopoDS_Wire& inpWire, const Handle_Geom_Plane& RefPlane, TopoDS_Wire& outWire)
 271 {
 272   //its also possible to use BrepAlgo_NormalProjection here!
 273   BRepTools_WireExplorer ex(TopoDS::Wire(inpWire.Oriented(TopAbs_FORWARD)));
 274   BRepLib_MakeWire WM;
 275   for (;ex.More();ex.Next())
 276   {
 277     const TopoDS_Edge& CE = ex.Current();
 278     double f, l;
 279     Handle(Geom_Curve) C3d = BRep_Tool::Curve(CE, f, l);
 280     Handle(Geom_Curve) ProjectedCurve = GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3d, f, l), RefPlane, RefPlane->Position().Direction(), Standard_True);
 281     TopoDS_Edge ProjEdge = BRepLib_MakeEdge(ProjectedCurve);
 282     WM.Add(ProjEdge); //auto sharing between edges if vertex is coincident
 283   }
 284   outWire = WM.Wire();
 285   outWire.Orientation(inpWire.Orientation()); //take from the original wire
 286 }
 287
 288
 289 void HYDROData_DTM::Get2dFaceFrom3dPres(const TopoDS_Compound& cmp, TopoDS_Face& outF )
 290 {
 291   Handle_Geom_Plane refpl = new Geom_Plane(gp_Pnt(0,0,0), gp_Dir(0,0,1));
 292   BRepLib_MakeWire WM;
 293   TopoDS_Iterator it(cmp);
 294   //TopTools_IndexedMapOfShape IntW;
 295   for (;it.More(); it.Next())
 296   {
 297     const TopoDS_Wire& W = TopoDS::Wire(it.Value());
 298     if (W.Orientation() != TopAbs_INTERNAL)
 299     {
 300       //use list of edges to protect againts non-manifold cases.
 301       //auto sharing between edges will be added automatically
 302       TopTools_IndexedMapOfShape ME;
 303       TopTools_ListOfShape LE;
 304       TopExp::MapShapes(W, TopAbs_EDGE, ME);
 305       for (int i = 1; i <= ME.Extent(); i++)
 306         LE.Append(ME(i));
 307       WM.Add(LE);
 308     }
 309     //else
 310     //  IntW.Add(W);
 311   }
 312
 313   TopoDS_Wire outW;
 314   ProjWireOnPlane(WM.Wire(), refpl, outW);
 315   BRepBuilderAPI_MakeFace mf(refpl, outW); //check inside is true by def
 316   outF = mf.Face();
 317
 318   ///!!! the internal wires cant be added with 'internal' ori.
 319   // it's possible to do with brep builder yet the result will not be correct!
 320   // more proper way is to use BOP operation here.
 321   /*for (int i = 1; i <= IntW.Extent(); i++)
 322   {
 323   TopoDS_Wire outIW;
 324   const TopoDS_Wire& W = TopoDS::Wire(IntW(i));
 325   ProjWireOnPlane(W, refpl, outIW);
 326   BB.Add(outF, outIW);
 327   }*/
 328 }
 329
 330 void HYDROData_DTM::CreateProfiles(const std::vector<Handle_HYDROData_Profile>& theProfiles,
 331                                    double theDDZ,
 332                                    double theSpatialStep,
 333                                    AltitudePoints& theOutLeft,
 334                                    AltitudePoints& theOutRight,
 335                                    AltitudePoints& theOutPoints,
 336                                    std::vector<AltitudePoints>& theOutMainProfiles,
 337                                    TopoDS_Shape& Out3dPres,
 338                                    TopoDS_Shape& Out2dPres,
 339                                    TopoDS_Shape& OutLeftB,
 340                                    TopoDS_Shape& OutRightB,
 341                                    TopoDS_Shape& OutInlet,
 342                                    TopoDS_Shape& OutOutlet,
 343                                    bool Create3dPres,
 344                                    bool Create2dPres,
 345                                    std::set<int>& InvInd)
 346 {
 347   if (theProfiles.empty())
 348     return;
 349   theOutPoints = Interpolate( theProfiles, theDDZ, theSpatialStep, theOutLeft, theOutRight, theOutMainProfiles, InvInd );
 350   //note that if Create3dPres is false => Create2dPres flag is meaningless!
 351   if (Create3dPres)
 352   {
 353     TopTools_IndexedMapOfOrientedShape ll = Create3DShape( theOutLeft, theOutRight, theOutMainProfiles);
 354
 355     if (ll.IsEmpty())
 356       return;
 357     BRep_Builder BB;
 358     TopoDS_Compound cmp;
 359     BB.MakeCompound(cmp);
 360     for (int i = 1; i <= ll.Extent(); i++)
 361       BB.Add(cmp, ll(i));
 362
 363     Out3dPres = cmp;
 364
 365     //same order as in HYDROData_DTM::Update()
 366     OutLeftB = ll(1);
 367     OutRightB = ll(ll.Extent());
 368     OutInlet = ll(2);
 369     OutOutlet = ll(ll.Extent() - 1);
 370
 371     if (Create2dPres)
 372     {
 373       TopoDS_Face outF;
 374       Get2dFaceFrom3dPres(cmp, outF);
 375       Out2dPres = outF;
 376     };
 377   }
 378 }
 379
 380
 381
 382
 383 void HYDROData_DTM::GetProperties( const Handle_HYDROData_Profile& theProfile,
 384                     gp_Pnt& theLowestPoint, gp_Vec2d& theDir,
 385                     bool isNormalDir,
 386                     double& theZMin, double& theZMax )
 387 {
 388   theLowestPoint = theProfile->GetBottomPoint();
 389
 390   gp_XY aLeft, aRight;
 391   theProfile->GetLeftPoint( aLeft, true, true );
 392   theProfile->GetRightPoint( aRight, true, true );
 393   double x = aRight.X()-aLeft.X();
 394   double y = aRight.Y()-aLeft.Y();
 395   if( isNormalDir )
 396     theDir = gp_Vec2d( -y, x );
 397   else
 398     theDir = gp_Vec2d( x, y );
 399
 400   HYDROData_Profile::ProfilePoints points = theProfile->GetProfilePoints();
 401   int lo = points.Lower();
 402   int up = points.Upper();
 403   theZMin = std::numeric_limits<double>::max();
 404   theZMax = -theZMin;
 405   for( int i=lo; i<=up; i++ )
 406   {
 407     double z = points.Value( i ).Z();
 408     if( z>theZMax )
 409       theZMax = z;
 410     if( z<theZMin )
 411       theZMin = z;
 412   }
 413 }
 414
 415 inline gp_Pnt2d To2D( const gp_Pnt& thePnt, const gp_Trsf& theTr,
 416                       double& theUMin, double& theUMax )
 417 {
 418   gp_Pnt p = thePnt.Transformed( theTr );
 419   double u = p.X();
 420   double z = p.Z();
 421   if( u<theUMin )
 422     theUMin = u;
 423   if( u>theUMax )
 424     theUMax = u;
 425   return gp_Pnt2d( u, z );
 426 }
 427
 428 Handle(TColgp_HArray1OfPnt2d) To2D( const TColgp_Array1OfPnt& thePoints,
 429                                     const gp_Trsf& theTr,
 430                                     double& theUMin, double& theUMax )
 431 {
 432   int low = thePoints.Lower(), up = thePoints.Upper();
 433   Handle(TColgp_HArray1OfPnt2d) points = new TColgp_HArray1OfPnt2d( low, up );
 434   for( int i=low; i<=up; i++ )
 435     points->SetValue( i, To2D( thePoints.Value( i ), theTr, theUMin, theUMax ) );
 436   return points;
 437 }
 438
 439 Handle(Geom2d_Curve) CurveTo2D( const Handle(Geom_Curve)& theCurve,
 440                                 Standard_Real theFirst, Standard_Real theLast,
 441                                 const gp_Trsf& theTr,
 442                                 double& theUMin, double& theUMax )
 443 {
 444   if( theCurve->IsKind( STANDARD_TYPE( Geom_Line ) ) )
 445   {
 446     gp_Pnt aFirstPnt, aLastPnt;
 447     theCurve->D0( theFirst, aFirstPnt );
 448     theCurve->D0( theLast, aLastPnt );
 449
 450     gp_Pnt2d
 451       aFirst2d = To2D( aFirstPnt, theTr, theUMin, theUMax ),
 452       aLast2d = To2D( aLastPnt, theTr, theUMin, theUMax );
 453
 454     gp_Vec2d dir( aFirst2d, aLast2d );
 455     Handle_Geom2d_Line aLine2d = new Geom2d_Line( aFirst2d, gp_Dir2d( dir.X(), dir.Y() ) );
 456     return new Geom2d_TrimmedCurve( aLine2d, 0, aLast2d.Distance( aFirst2d ) );
 457   }
 458
 459   if( theCurve->IsKind( STANDARD_TYPE( Geom_BSplineCurve ) ) )
 460   {
 461     Handle(Geom_BSplineCurve) aSpline = Handle(Geom_BSplineCurve)::DownCast( theCurve );
 462
 463     Handle(TColgp_HArray1OfPnt2d) poles = To2D( aSpline->Poles(), theTr, theUMin, theUMax );
 464     const TColStd_Array1OfReal& knots = aSpline->Knots();
 465     const TColStd_Array1OfInteger& multiplicities = aSpline->Multiplicities();
 466     int aDegree = aSpline->Degree();
 467
 468     return new Geom2d_BSplineCurve( poles->Array1(), knots, multiplicities, aDegree );
 469   }
 470
 471   return Handle(Geom2d_Curve)();
 472 }
 473
 474 Handle_Geom2d_BSplineCurve HYDROData_DTM::CreateHydraulicAxis(
 475   const std::vector<Handle_HYDROData_Profile>& theProfiles,
 476   std::vector<double>& theDistances )
 477 {
 478   size_t n = theProfiles.size();
 479   Handle_Geom2d_BSplineCurve aResult;
 480
 481   Handle(TColgp_HArray1OfPnt2d) points = new TColgp_HArray1OfPnt2d( 1, (int)n );
 482   TColgp_Array1OfVec2d tangents( 1, (int)n );
 483   Handle(TColStd_HArray1OfBoolean) flags = new TColStd_HArray1OfBoolean( 1, (int)n );
 484
 485   for( size_t i = 1; i <= n; i++ )
 486   {
 487     Handle_HYDROData_Profile aProfile = theProfiles[i-1];
 488     aProfile->Update();
 489
 490     gp_Pnt aLowest;
 491     gp_Vec2d aTangent;
 492     double zmin, zmax;
 493     GetProperties( aProfile, aLowest, aTangent, true, zmin, zmax );
 494     aTangent.Normalize();
 495
 496     points->SetValue( (int)i, gp_Pnt2d( aLowest.X(), aLowest.Y() ) );
 497     tangents.SetValue( (int)i, aTangent );
 498     flags->SetValue( (int)i, Standard_True );
 499   }
 500
 501   Geom2dAPI_Interpolate anInterpolator( points, Standard_False, Standard_False );
 502   anInterpolator.Load( tangents, flags );
 503   anInterpolator.Perform();
 504   if( anInterpolator.IsDone() )
 505   {
 506     aResult = anInterpolator.Curve();
 507
 508     //fill the distances vector
 509     Geom2dAdaptor_Curve anAdaptor( aResult );
 510
 511     theDistances.clear();
 512     theDistances.reserve( n );
 513     Standard_Real aParamFirst = anAdaptor.FirstParameter(), aParamLast = anAdaptor.LastParameter();
 514     for( size_t i = 1; i <= n; i++ )
 515     {
 516       gp_Pnt2d aPnt = points->Value( (Standard_Integer)i );
 517       Geom2dAPI_ProjectPointOnCurve aProject( aPnt, aResult );
 518       Standard_Real aParam = aProject.LowerDistanceParameter();
 519       double aDistance = GCPnts_AbscissaPoint::Length( anAdaptor, aParamFirst, aParam );
 520       theDistances.push_back( aDistance );
 521     }
 522   }
 523   return aResult;
 524 }
 525
 526 std::vector<Handle_Geom2d_Curve> HYDROData_DTM::ProfileToParametric(
 527   const Handle_HYDROData_Profile& theProfile,
 528   double& theUMin, double& theUMax, gp_Vec2d& theDir )
 529 {
 530   std::vector<Handle_Geom2d_Curve> curves;
 531
 532   // Transformation of the coordinate systems
 533   gp_Pnt aLowest;
 534   double zmin, zmax;
 535   GetProperties( theProfile, aLowest, theDir, false, zmin, zmax );
 536
 537   gp_Ax3 aStd3d( gp_Pnt( 0, 0, 0 ), gp_Dir( 0, 0, 1 ), gp_Dir( 1, 0, 0 ) );
 538   gp_Ax3 aLocal( aLowest, gp_Dir( 0, 0, 1 ), gp_Dir( theDir.X(), theDir.Y(), 0 ) );
 539
 540   gp_Trsf aTransf;
 541   aTransf.SetTransformation( aStd3d, aLocal );
 542
 543   // Iteration via edges
 544   TopoDS_Wire aWire = TopoDS::Wire( theProfile->GetShape3D() );
 545   TopExp_Explorer anExp( aWire, TopAbs_EDGE );
 546   for( ; anExp.More(); anExp.Next() )
 547   {
 548     // Extract an edge from wire
 549     TopoDS_Edge anEdge = TopoDS::Edge( anExp.Current() );
 550
 551     // Extract a curve corresponding to the edge
 552     TopLoc_Location aLoc;
 553     Standard_Real aFirst, aLast;
 554     Handle(Geom_Curve) aCurve = BRep_Tool::Curve( anEdge, aLoc, aFirst, aLast );
 555
 556     // Convert the curve to 2d CS
 557     Handle(Geom2d_Curve) aCurve2d = CurveTo2D( aCurve, aFirst, aLast, aTransf, theUMin, theUMax );
 558     if( !aCurve2d.IsNull() )
 559       curves.push_back( aCurve2d );
 560   }
 561   return curves;
 562 }
 563
 564
 565 bool CalcMidWidth( const std::vector<gp_Pnt2d>& intersections, double& theMid, double& theWid )
 566 {
 567   double umin = std::numeric_limits<double>::max(),
 568          umax = -umin;
 569
 570   size_t n = intersections.size();
 571   if( n <= 1 )
 572     return false;
 573
 574   for( size_t i = 0; i < n; i++ )
 575   {
 576     double u = intersections[i].X();
 577     if( u<umin )
 578       umin = u;
 579     if( u>umax )
 580       umax = u;
 581   }
 582   theMid = ( umin+umax )/2;
 583   theWid = umax-umin;
 584   return true;
 585 }
 586
 587 void HYDROData_DTM::ProfileDiscretization( const Handle_HYDROData_Profile& theProfile,
 588                                            double theXCurv, double theMinZ, double theMaxZ, double theDDZ,
 589                                            CurveUZ& theMidPointCurve,
 590                                            CurveUZ& theWidthCurve,
 591                                            int& intersection_nb,
 592                                            double theTolerance)
 593 {
 594   double aDblMax = std::numeric_limits<double>::max(),
 595          aUMin = aDblMax,
 596          aUMax = -aUMin,
 597          aVMax = 1000000;
 598
 599   gp_Vec2d aProfileDir;
 600   std::vector<Handle_Geom2d_Curve> curves = ProfileToParametric( theProfile, aUMin, aUMax, aProfileDir );
 601   size_t n = curves.size();
 602
 603   if( n==0 )
 604     return;
 605
 606   // we add the "virtual" vertical lines to simulate the intersection with profile
 607   gp_Pnt2d aFirst, aLast;
 608   curves[0]->D0( curves[0]->FirstParameter(), aFirst );
 609   curves[n-1]->D0( curves[n-1]->LastParameter(), aLast );
 610   Handle(Geom2d_Line) aV1 = new Geom2d_Line( aFirst, gp_Dir2d( 0, 1 ) );
 611   Handle(Geom2d_TrimmedCurve) aT1 = new Geom2d_TrimmedCurve( aV1, 0.0, aVMax );
 612
 613   Handle(Geom2d_Line) aV2 = new Geom2d_Line( aLast, gp_Dir2d( 0, 1 ) );
 614   Handle(Geom2d_TrimmedCurve) aT2 = new Geom2d_TrimmedCurve( aV2, 0.0, aVMax );
 615
 616   curves.push_back( aT1 );
 617   curves.push_back( aT2 );
 618
 619   int psize = ( int )( ( theMaxZ-theMinZ ) / theDDZ + 1 );
 620   theMidPointCurve = CurveUZ( theXCurv, aProfileDir );
 621   theMidPointCurve.reserve( psize );
 622   theWidthCurve = CurveUZ( theXCurv, aProfileDir );
 623   theWidthCurve.reserve( psize );
 624
 625   n = curves.size();
 626   // for each discrete value of z we search intersection with profile
 627   for( double z = theMinZ; z <= theMaxZ; z += theDDZ )
 628   {
 629     Handle(Geom2d_Line) aLine = new Geom2d_Line( gp_Pnt2d( 0, z ), gp_Dir2d( 1, 0 ) );
 630     std::vector<gp_Pnt2d> intersections;
 631     for( size_t i = 0; i < n; i++ )
 632     {
 633       Handle_Geom2d_Curve aCurve = curves[i];
 634       Geom2dAPI_InterCurveCurve anIntersect( aCurve, aLine, theTolerance );
 635       for( int k=1, m=anIntersect.NbPoints(); k<=m; k++ )
 636         intersections.push_back( anIntersect.Point( k ) );
 637     }
 638
 639     intersection_nb = intersections.size();
 640     if( intersection_nb >= 2 )
 641     {
 642       double u_mid, u_wid;
 643       if( !CalcMidWidth( intersections, u_mid, u_wid ) )
 644         continue;
 645
 646       PointUZ p_mid;
 647       p_mid.U = u_mid;
 648       p_mid.Z = z;
 649       theMidPointCurve.push_back( p_mid );
 650
 651       PointUZ p_wid;
 652       p_wid.U = u_wid;
 653       p_wid.Z = z;
 654       theWidthCurve.push_back( p_wid );
 655     }
 656   }
 657 }
 658
 659 void HYDROData_DTM::Interpolate( const CurveUZ& theCurveA, const CurveUZ& theCurveB,
 660                                  int theNbSteps, std::vector<CurveUZ>& theInterpolation,
 661                                  bool isAddSecond )
 662 {
 663   theInterpolation.clear();
 664   int d = isAddSecond ? 2 : 1;
 665   theInterpolation.reserve( theNbSteps+d );
 666   double dt = 1.0 / double( theNbSteps + 1 );
 667   double t = dt;
 668   theInterpolation.push_back( theCurveA );
 669   for( int i=0; i<theNbSteps; i++, t+=dt )
 670   {
 671     CurveUZ anInterp = theCurveA*(1-t) + theCurveB*t;
 672     theInterpolation.push_back( anInterp );
 673   }
 674   if( isAddSecond )
 675     theInterpolation.push_back( theCurveB );
 676 }
 677 #include <BRepLib_MakeEdge2d.hxx>
 678 void HYDROData_DTM::CurveTo3D( const Handle_Geom2d_BSplineCurve& theHydraulicAxis,
 679                                const CurveUZ& theMidCurve, const CurveUZ& theWidthCurve,
 680                                AltitudePoints& thePoints, double dz )
 681 {
 682   Geom2dAdaptor_Curve anAdaptor( theHydraulicAxis );
 683   TopoDS_Edge E2d = BRepLib_MakeEdge2d(theHydraulicAxis).Edge();
 684   GCPnts_AbscissaPoint ap( anAdaptor, theMidCurve.Xcurv(), anAdaptor.FirstParameter() );
 685   double aParam = ap.Parameter();
 686
 687   gp_Pnt2d point;
 688   anAdaptor.D0( aParam, point );
 689   gp_Vec2d profile_dir = theMidCurve.ProfileDir();
 690   gp_Dir tangent_n( -profile_dir.Y(), profile_dir.X(), dz );
 691   profile_dir.Normalize();
 692
 693   size_t n = theMidCurve.size();
 694   std::map<double, AltitudePoint> sorted_points;
 695   for( size_t i=0; i<n; i++ )
 696   {
 697     double param1 = theMidCurve[i].U - theWidthCurve[i].U / 2;
 698     double param2 = theMidCurve[i].U + theWidthCurve[i].U / 2;
 699
 700     gp_Pnt2d p1 = point.Translated( param1 * profile_dir);
 701     gp_Pnt2d p2 = point.Translated( param2 * profile_dir);
 702
 703     double z = theMidCurve[i].Z;
 704
 705     AltitudePoint p3d_1( p1.X(), p1.Y(), z ), p3d_2( p2.X(), p2.Y(), z );
 706
 707     sorted_points[param1] = p3d_1;
 708     sorted_points[param2] = p3d_2;
 709   }
 710
 711   thePoints.reserve( sorted_points.size() );
 712   std::map<double, AltitudePoint>::const_iterator it = sorted_points.begin(), last = sorted_points.end();
 713   for( ; it!=last; it++ )
 714     thePoints.push_back( it->second );
 715 }
 716
 717 inline double max( double a, double b )
 718 {
 719   if( a>b )
 720     return a;
 721   else
 722     return b;
 723 }
 724
 725 #include <BRepLib_MakeWire.hxx>
 726
 727 std::vector<HYDROData_Bathymetry::AltitudePoints> HYDROData_DTM::Interpolate
 728   ( const Handle_Geom2d_BSplineCurve& theHydraulicAxis,
 729     const Handle_HYDROData_Profile& theProfileA,
 730     double theXCurvA,
 731     const Handle_HYDROData_Profile& theProfileB,
 732     double theXCurvB,
 733     double theDDZ, int theNbSteps, bool isAddSecond,
 734     int& inter_nb_1, int& inter_nb_2)
 735 {
 736   double zminA, zmaxA, zminB, zmaxB;
 737   gp_Pnt lowestA, lowestB;
 738   gp_Vec2d dirA, dirB;
 739
 740   GetProperties( theProfileA, lowestA, dirA, false, zminA, zmaxA );
 741   GetProperties( theProfileB, lowestB, dirB, false, zminB, zmaxB );
 742
 743   double dz = zminB - zminA;
 744
 745   double zmin = max( zminA, zminB );
 746   double zmax = max( zmaxA, zmaxB );
 747
 748   CurveUZ midA(0, gp_Vec2d()), midB(0, gp_Vec2d());
 749   CurveUZ widA(0, gp_Vec2d()), widB(0, gp_Vec2d());
 750
 751   ProfileDiscretization( theProfileA, theXCurvA, zmin, zmax, theDDZ, midA, widA, inter_nb_1 );
 752   ProfileDiscretization( theProfileB, theXCurvB, zmin, zmax, theDDZ, midB, widB, inter_nb_2 );
 753
 754   std::vector<CurveUZ> mid, wid;
 755   Interpolate( midA, midB, theNbSteps, mid, isAddSecond );
 756   Interpolate( widA, widB, theNbSteps, wid, isAddSecond );
 757
 758   size_t p = mid.size();
 759   size_t q = p>0 ? 2*mid[0].size() : 1;
 760   std::vector<AltitudePoints> points;
 761   points.resize( p );
 762
 763   for( size_t i=0; i<p; i++ )
 764   {
 765     points[i].reserve( q );
 766     CurveTo3D( theHydraulicAxis, mid[i], wid[i], points[i], dz );
 767   }
 768
 769   return points;
 770 }
 771
 772 HYDROData_Bathymetry::AltitudePoints HYDROData_DTM::Interpolate
 773   ( const std::vector<Handle_HYDROData_Profile>& theProfiles,
 774     double theDDZ, double theSpatialStep,
 775     AltitudePoints& theLeft,
 776     AltitudePoints& theRight,
 777     std::vector<AltitudePoints>& theMainProfiles,
 778     std::set<int>& invalInd)
 779 {
 780   AltitudePoints points;
 781   size_t n = theProfiles.size();
 782   if( n<=1 )
 783     return points;
 784
 785   std::vector<double> distances;
 786   Handle_Geom2d_BSplineCurve aHydraulicAxis = CreateHydraulicAxis( theProfiles, distances );
 787   if( aHydraulicAxis.IsNull() )
 788     return points;
 789
 790   theMainProfiles.reserve( n );
 791
 792   for( size_t i=0, n1=n-1; i<n1; i++ )
 793   {
 794     double aDistance = distances[i+1]-distances[i];
 795     int aNbSteps = int(aDistance/theSpatialStep);
 796     bool isAddSecond = i==n1-1;
 797
 798     // 1. Calculate interpolated profiles
 799     int inter_nb_1, inter_nb_2;
 800     std::vector<AltitudePoints> local_points = Interpolate( aHydraulicAxis, theProfiles[i], distances[i],
 801       theProfiles[i+1], distances[i+1], theDDZ, aNbSteps, isAddSecond, inter_nb_1, inter_nb_2 );
 802     int lps = local_points.size();
 803
 804     if (inter_nb_1 >= 2)
 805       invalInd.insert(i);
 806
 807     if (inter_nb_2 >= 2)
 808       invalInd.insert(i+1);
 809
 810     // 2. Put all points into the global container
 811     for( size_t j=0; j<lps; j++ )
 812     {
 813       const AltitudePoints& lp = local_points[j];
 814       if( i==0 && j==0 )
 815         points.reserve( lp.size() * n );
 816       for( size_t k=0, ks=lp.size(); k<ks; k++ )
 817         points.push_back( lp[k] );
 818     }
 819
 820     // 3. Get left/right banks' points
 821     if( i==0 )
 822     {
 823       theLeft.reserve( lps * n );
 824       theRight.reserve( lps * n );
 825     }
 826     for( size_t j=0; j<lps; j++ )
 827     {
 828       const AltitudePoints& lp = local_points[j];
 829       theLeft.push_back( lp[0] );
 830       theRight.push_back( lp[lp.size()-1] );
 831     }
 832
 833     // 4. Get main profiles points
 834     theMainProfiles.push_back( local_points[0] );
 835     if( isAddSecond )
 836       theMainProfiles.push_back( local_points[lps-1] );
 837   }
 838   return points;
 839 }