#include <Geom2d_TrimmedCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
+#include <GeomAPI_Interpolate.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfVec.hxx>
+#include <TColgp_HArray1OfPnt.hxx>
+#include <Geom2dAPI_InterCurveCurve.hxx>
+#include <Geom2dAPI_ProjectPointOnCurve.hxx>
+#include <Geom2dAdaptor_Curve.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <limits>
+
+#include <BRepLib_MakeEdge.hxx>
+#include <BRepLib_MakeWire.hxx>
+#include <BRep_Builder.hxx>
+#include <GeomProjLib.hxx>
+#include <Geom_TrimmedCurve.hxx>
+#include <Geom_Plane.hxx>
+#include <BRepTools_WireExplorer.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopExp.hxx>
+#include <TopTools_IndexedMapOfOrientedShape.hxx>
+
+#include <BRepLib_MakeEdge.hxx>
+#include <BRepLib_MakeWire.hxx>
+#include <BRep_Builder.hxx>
+#include <ShapeAnalysis_Wire.hxx>
+#include <BRepAlgo_NormalProjection.hxx>
+
+#include <BRepBuilderAPI_MakePolygon.hxx>
+
IMPLEMENT_STANDARD_HANDLE( HYDROData_DTM, HYDROData_Bathymetry )
IMPLEMENT_STANDARD_RTTIEXT( HYDROData_DTM, HYDROData_Bathymetry )
+HYDROData_DTM::CurveUZ::CurveUZ( double theXCurv, const gp_Vec2d& theProfileDir, double theDeltaZ )
+ : myXcurv( theXCurv ), myProfileDir( theProfileDir ), myDeltaZ( theDeltaZ )
+{
+}
+
+HYDROData_DTM::CurveUZ::~CurveUZ()
+{
+}
+
+double HYDROData_DTM::CurveUZ::Xcurv() const
+{
+ return myXcurv;
+}
+
+gp_Vec2d HYDROData_DTM::CurveUZ::ProfileDir() const
+{
+ return myProfileDir;
+}
+
+double HYDROData_DTM::CurveUZ::DeltaZ() const
+{
+ return myDeltaZ;
+}
+
+HYDROData_DTM::CurveUZ HYDROData_DTM::CurveUZ::operator + ( const CurveUZ& c ) const
+{
+ HYDROData_DTM::CurveUZ res( Xcurv() + c.Xcurv(), ProfileDir() + c.ProfileDir(), DeltaZ() + c.DeltaZ() );
+ size_t n = size(), n1 = c.size();
+ if( n!=n1 )
+ {
+ std::cout << "Warning: different number of points in curves: " << n << ", " << n1 << std::endl;
+ }
+ res.reserve( n );
+ for( int i=0; i<n; i++ )
+ {
+ PointUZ p;
+ p.U = operator[]( i ).U + c[i].U;
+ p.Z = operator[]( i ).Z;
+ res.push_back( p );
+ }
+ return res;
+}
+
+HYDROData_DTM::CurveUZ HYDROData_DTM::CurveUZ::operator * ( double d ) const
+{
+ HYDROData_DTM::CurveUZ res( Xcurv()*d, ProfileDir()*d, DeltaZ()*d );
+ size_t n = size();
+ res.reserve( n );
+ for( int i=0; i<n; i++ )
+ {
+ PointUZ p;
+ p.U = operator[]( i ).U * d;
+ p.Z = operator[]( i ).Z;
+ res.push_back( p );
+ }
+ return res;
+}
+
+
+
+
HYDROData_DTM::HYDROData_DTM()
{
}
{
}
+HYDROData_SequenceOfObjects HYDROData_DTM::GetProfiles() const
+{
+ return GetReferenceObjects( DataTag_Profiles );
+}
+
+void HYDROData_DTM::SetProfiles( const HYDROData_SequenceOfObjects& theProfiles )
+{
+ SetReferenceObjects( theProfiles, DataTag_Profiles );
+ Changed( Geom_3d );
+}
+
+double HYDROData_DTM::GetDDZ() const
+{
+ return GetDouble( DataTag_DDZ );
+}
+
+void HYDROData_DTM::SetDDZ( double theDDZ )
+{
+ SetDouble( DataTag_DDZ, theDDZ );
+ Changed( Geom_3d );
+}
+
+double HYDROData_DTM::GetSpatialStep() const
+{
+ return GetDouble( DataTag_SpatialStep );
+}
+
+void HYDROData_DTM::SetSpatialStep( double theSpatialStep )
+{
+ SetDouble( DataTag_SpatialStep, theSpatialStep );
+ Changed( Geom_3d );
+}
+
+void HYDROData_DTM::PointToWire(const AltitudePoints& pnts, TopoDS_Wire& W )
+{
+ /*BRepLib_MakeWire WM;
+ if (pnts.empty())
+ return;
+ for (int i = 0; i < pnts.size() - 1; i++)
+ {
+ gp_Pnt p1(pnts[i].X, pnts[i].Y, pnts[i].Z);
+ gp_Pnt p2(pnts[i+1].X, pnts[i+1].Y, pnts[i+1].Z);
+ WM.Add(BRepLib_MakeEdge(p1, p2).Edge());
+ }
+ if (WM.IsDone())*/
+
+ BRepBuilderAPI_MakePolygon PM;
+ for (int i = 0; i < pnts.size(); i++)
+ PM.Add(gp_Pnt(pnts[i].X, pnts[i].Y, pnts[i].Z));
+
+ W = PM.Wire();
+}
+
+TopTools_IndexedMapOfOrientedShape HYDROData_DTM::Create3DShape(const AltitudePoints& left,
+ const AltitudePoints& right,
+ const std::vector<AltitudePoints>& main_profiles)
+{
+ TopTools_IndexedMapOfOrientedShape ll;
+ TopoDS_Wire LWire, RWire;
+ PointToWire(left, LWire);
+ PointToWire(right, RWire);
+ if (!LWire.IsNull())
+ ll.Add(LWire.Oriented(TopAbs_FORWARD));
+
+ for (int k = 0; k < main_profiles.size(); k++)
+ {
+ TopoDS_Wire W;
+ PointToWire(main_profiles[k], W);
+ TopAbs_Orientation Ori = TopAbs_INTERNAL;
+ if (k == 0 || k == main_profiles.size() - 1)
+ Ori = TopAbs_FORWARD;
+ ll.Add(W.Oriented(Ori));
+ }
+
+ if (!RWire.IsNull())
+ ll.Add(RWire.Oriented(TopAbs_FORWARD));
+ //yes, add subshapes in this order (left + profiles + right)
+ //otherwise the projected wire will be non-manifold
+
+ return ll;
+}
+
+
+void HYDROData_DTM::Update()
+{
+ AltitudePoints points;
+ TopoDS_Shape Out3dPres;
+ TopoDS_Shape Out2dPres;
+ TopoDS_Shape OutLeftB;
+ TopoDS_Shape OutRightB;
+ TopoDS_Shape OutInlet;
+ TopoDS_Shape OutOutlet;
+
+ HYDROData_SequenceOfObjects objs = GetProfiles();
+ double ddz = GetDDZ();
+ double step = GetSpatialStep();
+ std::set<int> InvInd;
+ bool WireIntersections; //__TODO
+ CreateProfilesFromDTM( objs, ddz, step, points, Out3dPres, Out2dPres, OutLeftB, OutRightB, OutInlet, OutOutlet, true, true, InvInd, -1, WireIntersections );
+ SetAltitudePoints( points );
+
+ SetShape( DataTag_LeftBankShape, OutLeftB);
+ SetShape( DataTag_RightBankShape, OutRightB);
+ SetShape( DataTag_InletShape, OutInlet);
+ SetShape( DataTag_OutletShape, OutOutlet );
+ SetShape( DataTag_3DShape, Out3dPres );
+ SetShape( DataTag_2DShape, Out2dPres );
+
+ HYDROData_Bathymetry::Update();
+}
+
+void HYDROData_DTM::GetPresentationShapes( TopoDS_Shape& Out3dPres,
+ TopoDS_Shape& Out2dPres,
+ TopoDS_Shape& OutLeftB,
+ TopoDS_Shape& OutRightB,
+ TopoDS_Shape& OutInlet,
+ TopoDS_Shape& OutOutlet )
+{
+ //without update!
+ OutLeftB = GetShape( DataTag_LeftBankShape);
+ OutRightB = GetShape( DataTag_RightBankShape);
+ OutInlet = GetShape( DataTag_InletShape);
+ OutOutlet = GetShape( DataTag_OutletShape );
+ Out3dPres = GetShape( DataTag_3DShape );
+ Out2dPres = GetShape( DataTag_2DShape );
+}
+void HYDROData_DTM::CreateProfilesFromDTM (const HYDROData_SequenceOfObjects& InpProfiles,
+ double ddz,
+ double step,
+ AltitudePoints& points,
+ TopoDS_Shape& Out3dPres,
+ TopoDS_Shape& Out2dPres,
+ TopoDS_Shape& OutLeftB,
+ TopoDS_Shape& OutRightB,
+ TopoDS_Shape& OutInlet,
+ TopoDS_Shape& OutOutlet,
+ bool Create3dPres,
+ bool Create2dPres,
+ std::set<int>& InvInd,
+ int thePntsLimit,
+ bool& WireIntersections)
+{
+ int aLower = InpProfiles.Lower(), anUpper = InpProfiles.Upper();
+ size_t n = anUpper - aLower + 1;
+
+ std::vector<Handle_HYDROData_Profile> profiles;
+ profiles.reserve( n );
+ for( int i=aLower; i<=anUpper; i++ )
+ {
+ Handle(HYDROData_Profile) aProfile = Handle(HYDROData_Profile)::DownCast( InpProfiles.Value( i ) );
+ if( !aProfile.IsNull() )
+ profiles.push_back( aProfile );
+ }
+ const double EPS = 1E-3;
+ AltitudePoints left;
+ AltitudePoints right;
+ std::vector<AltitudePoints> main_profiles;
+
+ if( thePntsLimit > 0 )
+ {
+ int aNbPoints = EstimateNbPoints( profiles, ddz, step );
+ if( aNbPoints < 0 || aNbPoints > thePntsLimit )
+ return;
+ }
+
+ if( ddz>EPS && step>EPS )
+ CreateProfiles(profiles, ddz, step, left, right, points, main_profiles,
+ Out3dPres, Out2dPres, OutLeftB, OutRightB, OutInlet, OutOutlet, Create3dPres, Create2dPres, InvInd, WireIntersections );
+}
+
+void HYDROData_DTM::ProjWireOnPlane(const TopoDS_Wire& inpWire, const Handle_Geom_Plane& RefPlane, TopoDS_Wire& outWire)
+{
+ /*BRepTools_WireExplorer ex(TopoDS::Wire(inpWire.Oriented(TopAbs_FORWARD)));
+ BRepLib_MakeWire WM;
+ for (;ex.More();ex.Next())
+ {
+ const TopoDS_Edge& CE = ex.Current();
+ double f, l;
+ Handle(Geom_Curve) C3d = BRep_Tool::Curve(CE, f, l);
+ Handle(Geom_Curve) ProjectedCurve = GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3d, f, l), RefPlane, RefPlane->Position().Direction(), Standard_True);
+ if (!ProjectedCurve.IsNull())
+ {
+ TopoDS_Edge ProjEdge = BRepLib_MakeEdge(ProjectedCurve, f, l );
+ if (!BRep_Tool::Degenerated(ProjEdge))
+ WM.Add(ProjEdge); //auto sharing between edges if vertex is coincident
+ }
+ }*/
+
+ BRep_Builder BB;
+ TopoDS_Face F;
+ BB.MakeFace(F, RefPlane, Precision::Confusion());
+ BRepLib_MakeWire WM;
+
+ BRepAlgo_NormalProjection nproj(F);
+ nproj.Add(inpWire);
+ nproj.SetDefaultParams();
+ nproj.Build();
+ if(!nproj.IsDone())
+ return;
+ TopoDS_Shape projRes = nproj.Projection();
+ TopExp_Explorer exp(projRes, TopAbs_EDGE);
+ TopTools_ListOfShape llE;
+ for (;exp.More();exp.Next())
+ llE.Append(exp.Current());
+
+ WM.Add(llE);
+ outWire = WM.Wire();
+
+ outWire.Orientation(inpWire.Orientation()); //take from the original wire
+}
+
+
+bool HYDROData_DTM::Get2dFaceFrom3dPres(const TopoDS_Compound& cmp, TopoDS_Face& outF )
+{
+ Handle_Geom_Plane refpl = new Geom_Plane(gp_Pnt(0,0,0), gp_Dir(0,0,1));
+ BRepLib_MakeWire WM;
+ TopoDS_Iterator it(cmp);
+ //TopTools_IndexedMapOfShape IntW;
+ for (;it.More(); it.Next())
+ {
+ const TopoDS_Wire& W = TopoDS::Wire(it.Value());
+ if (W.Orientation() != TopAbs_INTERNAL)
+ {
+ //use list of edges to protect againts non-manifold cases.
+ //auto sharing between edges will be added automatically
+ TopTools_IndexedMapOfShape ME;
+ TopTools_ListOfShape LE;
+ TopExp::MapShapes(W, TopAbs_EDGE, ME);
+ for (int i = 1; i <= ME.Extent(); i++)
+ LE.Append(ME(i));
+ WM.Add(LE);
+ }
+ //else
+ // IntW.Add(W);
+ }
+
+ TopoDS_Wire outW;
+ ProjWireOnPlane(WM.Wire(), refpl, outW);
+ BRepBuilderAPI_MakeFace mf(refpl, outW, true); //check inside is true by def
+ outF = mf.Face();
+
+ ShapeAnalysis_Wire WA(outW, outF, Precision::Confusion());
+ bool res = WA.CheckSelfIntersection();
+ return res;
+
+ ///!!! the internal wires cant be added with 'internal' ori.
+ // it's possible to do with brep builder yet the result will not be correct!
+ // more proper way is to use BOP operation here.
+ /*for (int i = 1; i <= IntW.Extent(); i++)
+ {
+ TopoDS_Wire outIW;
+ const TopoDS_Wire& W = TopoDS::Wire(IntW(i));
+ ProjWireOnPlane(W, refpl, outIW);
+ BB.Add(outF, outIW);
+ }*/
+}
+
+void HYDROData_DTM::CreateProfiles(const std::vector<Handle_HYDROData_Profile>& theProfiles,
+ double theDDZ,
+ double theSpatialStep,
+ AltitudePoints& theOutLeft,
+ AltitudePoints& theOutRight,
+ AltitudePoints& theOutPoints,
+ std::vector<AltitudePoints>& theOutMainProfiles,
+ TopoDS_Shape& Out3dPres,
+ TopoDS_Shape& Out2dPres,
+ TopoDS_Shape& OutLeftB,
+ TopoDS_Shape& OutRightB,
+ TopoDS_Shape& OutInlet,
+ TopoDS_Shape& OutOutlet,
+ bool Create3dPres,
+ bool Create2dPres,
+ std::set<int>& InvInd,
+ bool& WireIntersections)
+{
+ if (theProfiles.empty())
+ return;
+ theOutPoints = Interpolate( theProfiles, theDDZ, theSpatialStep, theOutLeft, theOutRight, theOutMainProfiles, InvInd );
+ //note that if Create3dPres is false => Create2dPres flag is meaningless!
+ if (Create3dPres)
+ {
+ TopTools_IndexedMapOfOrientedShape ll = Create3DShape( theOutLeft, theOutRight, theOutMainProfiles);
+
+ if (ll.IsEmpty())
+ return;
+ BRep_Builder BB;
+ TopoDS_Compound cmp;
+ BB.MakeCompound(cmp);
+ for (int i = 1; i <= ll.Extent(); i++)
+ BB.Add(cmp, ll(i));
+
+ Out3dPres = cmp;
+
+ //same order as in HYDROData_DTM::Update()
+ OutLeftB = ll(1);
+ OutRightB = ll(ll.Extent());
+ OutInlet = ll(2);
+ OutOutlet = ll(ll.Extent() - 1);
+
+ if (Create2dPres)
+ {
+ TopoDS_Face outF;
+ WireIntersections = Get2dFaceFrom3dPres(cmp, outF); //__TODO
+ Out2dPres = outF;
+ };
+ }
+}
+
+
+
-void GetProperties( const Handle_HYDROData_Profile& theProfile,
- gp_Pnt& theLowestPoint,
- gp_Vec2d& theDir,
- bool isNormalDir )
+void HYDROData_DTM::GetProperties( const Handle_HYDROData_Profile& theProfile,
+ gp_Pnt& theLowestPoint, gp_Vec2d& theDir,
+ bool isNormalDir,
+ double& theZMin, double& theZMax )
{
theLowestPoint = theProfile->GetBottomPoint();
theDir = gp_Vec2d( -y, x );
else
theDir = gp_Vec2d( x, y );
+
+ HYDROData_Profile::ProfilePoints points = theProfile->GetProfilePoints();
+ int lo = points.Lower();
+ int up = points.Upper();
+ theZMin = std::numeric_limits<double>::max();
+ theZMax = -theZMin;
+ for( int i=lo; i<=up; i++ )
+ {
+ double z = points.Value( i ).Z();
+ if( z>theZMax )
+ theZMax = z;
+ if( z<theZMin )
+ theZMin = z;
+ }
}
-inline gp_Pnt2d To2D( const gp_Pnt& thePnt, const gp_Trsf& theTr )
+inline gp_Pnt2d To2D( const gp_Pnt& thePnt, const gp_Trsf& theTr,
+ double& theUMin, double& theUMax )
{
gp_Pnt p = thePnt.Transformed( theTr );
- return gp_Pnt2d( p.X(), p.Z() );
+ double u = p.X();
+ double z = p.Z();
+ if( u<theUMin )
+ theUMin = u;
+ if( u>theUMax )
+ theUMax = u;
+ return gp_Pnt2d( u, z );
}
-Handle(TColgp_HArray1OfPnt2d) To2D( const TColgp_Array1OfPnt& thePoints, const gp_Trsf& theTr )
+Handle(TColgp_HArray1OfPnt2d) To2D( const TColgp_Array1OfPnt& thePoints,
+ const gp_Trsf& theTr,
+ double& theUMin, double& theUMax )
{
int low = thePoints.Lower(), up = thePoints.Upper();
Handle(TColgp_HArray1OfPnt2d) points = new TColgp_HArray1OfPnt2d( low, up );
for( int i=low; i<=up; i++ )
- points->SetValue( i, To2D( thePoints.Value( i ), theTr ) );
+ points->SetValue( i, To2D( thePoints.Value( i ), theTr, theUMin, theUMax ) );
return points;
}
Handle(Geom2d_Curve) CurveTo2D( const Handle(Geom_Curve)& theCurve,
Standard_Real theFirst, Standard_Real theLast,
- const gp_Trsf& theTr )
+ const gp_Trsf& theTr,
+ double& theUMin, double& theUMax )
{
if( theCurve->IsKind( STANDARD_TYPE( Geom_Line ) ) )
{
theCurve->D0( theLast, aLastPnt );
gp_Pnt2d
- aFirst2d = To2D( aFirstPnt, theTr ),
- aLast2d = To2D( aLastPnt, theTr );
+ aFirst2d = To2D( aFirstPnt, theTr, theUMin, theUMax ),
+ aLast2d = To2D( aLastPnt, theTr, theUMin, theUMax );
gp_Vec2d dir( aFirst2d, aLast2d );
Handle_Geom2d_Line aLine2d = new Geom2d_Line( aFirst2d, gp_Dir2d( dir.X(), dir.Y() ) );
{
Handle(Geom_BSplineCurve) aSpline = Handle(Geom_BSplineCurve)::DownCast( theCurve );
- Handle(TColgp_HArray1OfPnt2d) poles = To2D( aSpline->Poles(), theTr );
+ Handle(TColgp_HArray1OfPnt2d) poles = To2D( aSpline->Poles(), theTr, theUMin, theUMax );
const TColStd_Array1OfReal& knots = aSpline->Knots();
const TColStd_Array1OfInteger& multiplicities = aSpline->Multiplicities();
int aDegree = aSpline->Degree();
}
Handle_Geom2d_BSplineCurve HYDROData_DTM::CreateHydraulicAxis(
- const std::vector<Handle_HYDROData_Profile>& theProfiles )
+ const std::vector<Handle_HYDROData_Profile>& theProfiles,
+ std::vector<double>& theDistances )
{
size_t n = theProfiles.size();
Handle_Geom2d_BSplineCurve aResult;
for( size_t i = 1; i <= n; i++ )
{
Handle_HYDROData_Profile aProfile = theProfiles[i-1];
+ aProfile->Update();
+
gp_Pnt aLowest;
gp_Vec2d aTangent;
- GetProperties( aProfile, aLowest, aTangent, true );
+ double zmin, zmax;
+ GetProperties( aProfile, aLowest, aTangent, true, zmin, zmax );
aTangent.Normalize();
points->SetValue( (int)i, gp_Pnt2d( aLowest.X(), aLowest.Y() ) );
anInterpolator.Load( tangents, flags );
anInterpolator.Perform();
if( anInterpolator.IsDone() )
+ {
aResult = anInterpolator.Curve();
+
+ //fill the distances vector
+ Geom2dAdaptor_Curve anAdaptor( aResult );
+
+ theDistances.clear();
+ theDistances.reserve( n );
+ Standard_Real aParamFirst = anAdaptor.FirstParameter(), aParamLast = anAdaptor.LastParameter();
+ for( size_t i = 1; i <= n; i++ )
+ {
+ gp_Pnt2d aPnt = points->Value( (Standard_Integer)i );
+ Geom2dAPI_ProjectPointOnCurve aProject( aPnt, aResult );
+ Standard_Real aParam = aProject.LowerDistanceParameter();
+ double aDistance = GCPnts_AbscissaPoint::Length( anAdaptor, aParamFirst, aParam );
+ theDistances.push_back( aDistance );
+ }
+ }
return aResult;
}
-std::vector<Handle_Geom2d_Curve> HYDROData_DTM::ProfileToParametric( const Handle_HYDROData_Profile& theProfile )
+std::vector<Handle_Geom2d_Curve> HYDROData_DTM::ProfileToParametric(
+ const Handle_HYDROData_Profile& theProfile,
+ double& theUMin, double& theUMax, gp_Vec2d& theDir )
{
std::vector<Handle_Geom2d_Curve> curves;
- theProfile->Update();
// Transformation of the coordinate systems
gp_Pnt aLowest;
- gp_Vec2d aDir;
- GetProperties( theProfile, aLowest, aDir, false );
+ double zmin, zmax;
+ GetProperties( theProfile, aLowest, theDir, false, zmin, zmax );
gp_Ax3 aStd3d( gp_Pnt( 0, 0, 0 ), gp_Dir( 0, 0, 1 ), gp_Dir( 1, 0, 0 ) );
- gp_Ax3 aLocal( aLowest, gp_Dir( 0, 0, 1 ), gp_Dir( aDir.X(), aDir.Y(), 0 ) );
+ gp_Ax3 aLocal( gp_Pnt( aLowest.X(), aLowest.Y(), 0 ), gp_Dir( 0, 0, 1 ), gp_Dir( theDir.X(), theDir.Y(), 0 ) );
gp_Trsf aTransf;
aTransf.SetTransformation( aStd3d, aLocal );
Handle(Geom_Curve) aCurve = BRep_Tool::Curve( anEdge, aLoc, aFirst, aLast );
// Convert the curve to 2d CS
- Handle(Geom2d_Curve) aCurve2d = CurveTo2D( aCurve, aFirst, aLast, aTransf );
+ Handle(Geom2d_Curve) aCurve2d = CurveTo2D( aCurve, aFirst, aLast, aTransf, theUMin, theUMax );
if( !aCurve2d.IsNull() )
curves.push_back( aCurve2d );
}
return curves;
}
+
+bool CalcMidWidth( const std::set<double>& intersections, double& theMid, double& theWid )
+{
+ double umin = std::numeric_limits<double>::max(),
+ umax = -umin;
+
+ size_t n = intersections.size();
+ if( n <= 0 )
+ return false;
+
+ std::set<double>::const_iterator it = intersections.begin(), last = intersections.end();
+ for( ; it!=last; it++ )
+ {
+ double u = *it;
+ if( u<umin )
+ umin = u;
+ if( u>umax )
+ umax = u;
+ }
+ theMid = ( umin+umax )/2;
+ theWid = umax-umin;
+ return true;
+}
+
void HYDROData_DTM::ProfileDiscretization( const Handle_HYDROData_Profile& theProfile,
- double theMinZ, double theMaxZ, double theDDZ,
+ double theXCurv, double theMinZ, double theMaxZ, double theDDZ,
CurveUZ& theMidPointCurve,
- CurveUZ& theWidthCurve )
+ CurveUZ& theWidthCurve,
+ int& intersection_nb,
+ double theTolerance)
{
- /*for( double z = theMinZ; z<=theMaxZ; z += theDDZ )
+ double aDblMax = std::numeric_limits<double>::max(),
+ aUMin = aDblMax,
+ aUMax = -aUMin,
+ aVMax = 1000000;
+
+ gp_Vec2d aProfileDir;
+ std::vector<Handle_Geom2d_Curve> curves = ProfileToParametric( theProfile, aUMin, aUMax, aProfileDir );
+ size_t n = curves.size();
+
+ if( n==0 )
+ return;
+
+ // we add the "virtual" vertical lines to simulate the intersection with profile
+ gp_Pnt2d aFirst, aLast;
+ curves[0]->D0( curves[0]->FirstParameter(), aFirst );
+ curves[n-1]->D0( curves[n-1]->LastParameter(), aLast );
+ Handle(Geom2d_Line) aV1 = new Geom2d_Line( aFirst, gp_Dir2d( 0, 1 ) );
+ Handle(Geom2d_TrimmedCurve) aT1 = new Geom2d_TrimmedCurve( aV1, 0.0, aVMax );
+
+ Handle(Geom2d_Line) aV2 = new Geom2d_Line( aLast, gp_Dir2d( 0, 1 ) );
+ Handle(Geom2d_TrimmedCurve) aT2 = new Geom2d_TrimmedCurve( aV2, 0.0, aVMax );
+
+ curves.push_back( aT1 );
+ curves.push_back( aT2 );
+
+ int psize = ( int )( ( theMaxZ-theMinZ ) / theDDZ + 1 );
+ theMidPointCurve = CurveUZ( theXCurv, aProfileDir, theMinZ );
+ theMidPointCurve.reserve( psize );
+ theWidthCurve = CurveUZ( theXCurv, aProfileDir, theMinZ );
+ theWidthCurve.reserve( psize );
+
+ n = curves.size();
+ // for each discrete value of z we search intersection with profile
+ for( double z1 = theMinZ; z1 <= theMaxZ; z1 += theDDZ )
{
+ Handle(Geom2d_Line) aLine = new Geom2d_Line( gp_Pnt2d( 0, z1 ), gp_Dir2d( 1, 0 ) );
+ std::set<double> intersections;
+ for( size_t i = 0; i < n; i++ )
+ {
+ Handle_Geom2d_Curve aCurve = curves[i];
+ Geom2dAPI_InterCurveCurve anIntersect( aCurve, aLine, theTolerance );
+ for( int k=1, m=anIntersect.NbPoints(); k<=m; k++ )
+ intersections.insert( anIntersect.Point( k ).X() );
+ }
- }*/
+ intersection_nb = intersections.size();
+ if( intersection_nb >= 1 )
+ {
+ double u_mid, u_wid;
+ if( !CalcMidWidth( intersections, u_mid, u_wid ) )
+ continue;
+
+ double z = z1 - theMinZ;
+ PointUZ p_mid;
+ p_mid.U = u_mid;
+ p_mid.Z = z;
+ theMidPointCurve.push_back( p_mid );
+
+ PointUZ p_wid;
+ p_wid.U = u_wid;
+ p_wid.Z = z;
+ theWidthCurve.push_back( p_wid );
+ }
+ }
}
void HYDROData_DTM::Interpolate( const CurveUZ& theCurveA, const CurveUZ& theCurveB,
- int theNbSteps, std::vector<CurveUZ>& theInterpolation )
+ int theNbSteps, std::vector<CurveUZ>& theInterpolation,
+ bool isAddSecond )
+{
+ theInterpolation.clear();
+ int d = isAddSecond ? 2 : 1;
+ theInterpolation.reserve( theNbSteps+d );
+ double dt = 1.0 / double( theNbSteps + 1 );
+ double t = dt;
+ theInterpolation.push_back( theCurveA );
+ for( int i=0; i<theNbSteps; i++, t+=dt )
+ {
+ CurveUZ anInterp = theCurveA*(1-t) + theCurveB*t;
+ theInterpolation.push_back( anInterp );
+ }
+ if( isAddSecond )
+ theInterpolation.push_back( theCurveB );
+}
+#include <BRepLib_MakeEdge2d.hxx>
+void HYDROData_DTM::CurveTo3D( const Handle_Geom2d_BSplineCurve& theHydraulicAxis,
+ const CurveUZ& theMidCurve, const CurveUZ& theWidthCurve,
+ AltitudePoints& thePoints )
+{
+ Geom2dAdaptor_Curve anAdaptor( theHydraulicAxis );
+ TopoDS_Edge E2d = BRepLib_MakeEdge2d(theHydraulicAxis).Edge();
+ GCPnts_AbscissaPoint ap( anAdaptor, theMidCurve.Xcurv(), anAdaptor.FirstParameter() );
+ double aParam = ap.Parameter();
+
+ gp_Pnt2d point;
+ anAdaptor.D0( aParam, point );
+ gp_Vec2d profile_dir = theMidCurve.ProfileDir();
+ //gp_Dir tangent_n( -profile_dir.Y(), profile_dir.X(), dz );
+ profile_dir.Normalize();
+
+ size_t n = theMidCurve.size();
+ std::map<double, AltitudePoint> sorted_points;
+ for( size_t i=0; i<n; i++ )
+ {
+ double param1 = theMidCurve[i].U - theWidthCurve[i].U / 2;
+ double param2 = theMidCurve[i].U + theWidthCurve[i].U / 2;
+
+ gp_Pnt2d p1 = point.Translated( param1 * profile_dir);
+ gp_Pnt2d p2 = point.Translated( param2 * profile_dir);
+
+ double z = theMidCurve[i].Z + theMidCurve.DeltaZ();
+
+ AltitudePoint p3d_1( p1.X(), p1.Y(), z ), p3d_2( p2.X(), p2.Y(), z );
+
+ sorted_points[param1] = p3d_1;
+ sorted_points[param2] = p3d_2;
+ }
+
+ thePoints.reserve( sorted_points.size() );
+ const double EPS = 1E-12;
+ std::map<double, AltitudePoint>::const_iterator it = sorted_points.begin(), last = sorted_points.end();
+ for( ; it!=last; it++ )
+ if( thePoints.empty() || thePoints.back().SquareDistance( it->second ) > EPS )
+ thePoints.push_back( it->second );
+}
+
+inline double max( double a, double b )
{
+ if( a>b )
+ return a;
+ else
+ return b;
}
-void HYDROData_DTM::CurveTo3d( const CurveUZ& theCurve, const CurveUZ& theCurveB,
- int theNbSteps, std::vector<CurveUZ>& theInterpolation )
+inline double min( double a, double b )
{
+ if( a<b )
+ return a;
+ else
+ return b;
+}
+
+#include <BRepLib_MakeWire.hxx>
+
+std::vector<HYDROData_Bathymetry::AltitudePoints> HYDROData_DTM::Interpolate
+ ( const Handle_Geom2d_BSplineCurve& theHydraulicAxis,
+ const Handle_HYDROData_Profile& theProfileA,
+ double theXCurvA,
+ const Handle_HYDROData_Profile& theProfileB,
+ double theXCurvB,
+ double theDDZ, int theNbSteps, bool isAddSecond,
+ int& inter_nb_1, int& inter_nb_2)
+{
+ double zminA, zmaxA, zminB, zmaxB;
+ gp_Pnt lowestA, lowestB;
+ gp_Vec2d dirA, dirB;
+
+ GetProperties( theProfileA, lowestA, dirA, false, zminA, zmaxA );
+ GetProperties( theProfileB, lowestB, dirB, false, zminB, zmaxB );
+
+
+ double hmax = max( zmaxA-zminA, zmaxB-zminB );
+
+ //double dz = zminB - zminA;
+ //double zmin = min( zminA, zminB );
+ //double zmax = max( zmaxA, zmaxB );
+
+ CurveUZ midA(0, gp_Vec2d(), 0), midB(0, gp_Vec2d(), 0);
+ CurveUZ widA(0, gp_Vec2d(), 0), widB(0, gp_Vec2d(), 0);
+
+ ProfileDiscretization( theProfileA, theXCurvA, zminA, zminA+hmax, theDDZ, midA, widA, inter_nb_1 );
+ ProfileDiscretization( theProfileB, theXCurvB, zminB, zminB+hmax, theDDZ, midB, widB, inter_nb_2 );
+
+ std::vector<CurveUZ> mid, wid;
+ Interpolate( midA, midB, theNbSteps, mid, isAddSecond );
+ Interpolate( widA, widB, theNbSteps, wid, isAddSecond );
+
+ size_t p = mid.size();
+ size_t q = p>0 ? 2*mid[0].size() : 1;
+ std::vector<AltitudePoints> points;
+ points.resize( p );
+
+ for( size_t i=0; i<p; i++ )
+ {
+ points[i].reserve( q );
+ CurveTo3D( theHydraulicAxis, mid[i], wid[i], points[i] );
+ }
+
+ return points;
+}
+
+HYDROData_Bathymetry::AltitudePoints HYDROData_DTM::Interpolate
+ ( const std::vector<Handle_HYDROData_Profile>& theProfiles,
+ double theDDZ, double theSpatialStep,
+ AltitudePoints& theLeft,
+ AltitudePoints& theRight,
+ std::vector<AltitudePoints>& theMainProfiles,
+ std::set<int>& invalInd)
+{
+ AltitudePoints points;
+ size_t n = theProfiles.size();
+ if( n<=1 )
+ return points;
+
+ std::vector<double> distances;
+ Handle_Geom2d_BSplineCurve aHydraulicAxis = CreateHydraulicAxis( theProfiles, distances );
+ if( aHydraulicAxis.IsNull() )
+ return points;
+
+ theMainProfiles.reserve( n );
+
+ for( size_t i=0, n1=n-1; i<n1; i++ )
+ {
+ double aDistance = distances[i+1]-distances[i];
+ int aNbSteps = int(aDistance/theSpatialStep);
+ bool isAddSecond = i==n1-1;
+
+ // 1. Calculate interpolated profiles
+ int inter_nb_1, inter_nb_2;
+ std::vector<AltitudePoints> local_points = Interpolate( aHydraulicAxis, theProfiles[i], distances[i],
+ theProfiles[i+1], distances[i+1], theDDZ, aNbSteps, isAddSecond, inter_nb_1, inter_nb_2 );
+ int lps = local_points.size();
+
+ if (inter_nb_1 > 2)
+ invalInd.insert(i);
+
+ if (inter_nb_2 > 2)
+ invalInd.insert(i+1);
+
+ // 2. Put all points into the global container
+ for( size_t j=0; j<lps; j++ )
+ {
+ const AltitudePoints& lp = local_points[j];
+ if( i==0 && j==0 )
+ points.reserve( lp.size() * n );
+ for( size_t k=0, ks=lp.size(); k<ks; k++ )
+ points.push_back( lp[k] );
+ }
+
+ // 3. Get left/right banks' points
+ if( i==0 )
+ {
+ theLeft.reserve( lps * n );
+ theRight.reserve( lps * n );
+ }
+ for( size_t j=0; j<lps; j++ )
+ {
+ const AltitudePoints& lp = local_points[j];
+ theLeft.push_back( lp[0] );
+ theRight.push_back( lp[lp.size()-1] );
+ }
+
+ // 4. Get main profiles points
+ theMainProfiles.push_back( local_points[0] );
+ if( isAddSecond )
+ theMainProfiles.push_back( local_points[lps-1] );
+ }
+ return points;
+}
+
+int HYDROData_DTM::EstimateNbPoints( const std::vector<Handle_HYDROData_Profile>& theProfiles,
+ double theDDZ, double theSpatialStep )
+{
+ size_t n = theProfiles.size();
+ if( n<=1 )
+ return 0;
+ if( theDDZ<1E-6 || theSpatialStep<1E-6 )
+ return 1 << 20;
+
+ std::vector<double> distances;
+ Handle_Geom2d_BSplineCurve aHydraulicAxis = CreateHydraulicAxis( theProfiles, distances );
+ if( aHydraulicAxis.IsNull() )
+ return 0;
+
+ double aCompleteDistance = distances[n-1];
+ int aNbSteps = int( aCompleteDistance / theSpatialStep ) + 1;
+ gp_Pnt aLowest;
+ gp_Vec2d aDir;
+ double aZMin, aZMax;
+ GetProperties( theProfiles[0], aLowest, aDir, true, aZMin, aZMax );
+ int aNbZSteps = (aZMax-aZMin)/theDDZ;
+
+ if( aNbSteps > ( 1<<16 ) || aNbZSteps > ( 1<<16 ) )
+ return 1 << 20;
+
+ return aNbSteps * aNbZSteps;
}
