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