#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 <BRepTools_WireExplorer.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <TopExp.hxx>
+#include <TopTools_IndexedMapOfOrientedShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <BRepLib_MakeEdge.hxx>
#include <BRepLib_MakeWire.hxx>
#include <BRep_Builder.hxx>
+#include <ShapeAnalysis_Wire.hxx>
+#include <BRepAlgo_NormalProjection.hxx>
+#include <ShapeUpgrade_UnifySameDomain.hxx>
+#include <BRepBuilderAPI_MakePolygon.hxx>
+#include <BOPAlgo_Builder.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <GeomProjLib.hxx>
+#include <gp_Pln.hxx>
+#include <TopTools_IndexedDataMapOfShapeShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_SequenceOfShape.hxx>
+#include <assert.h>
-IMPLEMENT_STANDARD_HANDLE( HYDROData_DTM, HYDROData_Bathymetry )
IMPLEMENT_STANDARD_RTTIEXT( HYDROData_DTM, HYDROData_Bathymetry )
-
-HYDROData_DTM::CurveUZ::CurveUZ( double theXCurv, const gp_Vec2d& theProfileDir )
- : myXcurv( theXCurv ), myProfileDir( theProfileDir )
+HYDROData_DTM::CurveUZ::CurveUZ( double theXCurv, const gp_Vec2d& theProfileDir, double theDeltaZ, double theMaxZ )
+ : myXcurv( theXCurv ), myProfileDir( theProfileDir ), myDeltaZ( theDeltaZ ), myMaxZ (theMaxZ)
{
}
return myProfileDir;
}
+double HYDROData_DTM::CurveUZ::DeltaZ() const
+{
+ return myDeltaZ;
+}
+
+double HYDROData_DTM::CurveUZ::MaxZ() const
+{
+ return myMaxZ;
+}
+
HYDROData_DTM::CurveUZ HYDROData_DTM::CurveUZ::operator + ( const CurveUZ& c ) const
{
- HYDROData_DTM::CurveUZ res( Xcurv() + c.Xcurv(), ProfileDir() + c.ProfileDir() );
- size_t n = size();
- res.reserve( n );
- for( int i=0; i<n; i++ )
+ HYDROData_DTM::CurveUZ res( Xcurv() + c.Xcurv(), ProfileDir() + c.ProfileDir(), DeltaZ() + c.DeltaZ(), MaxZ() + c.MaxZ() );
+ size_t n = size(), n1 = c.size();
+ if( n!=n1 )
+ {
+ std::cout << "Warning: different number of points in curves: " << n << ", " << n1 << std::endl;
+ }
+ int q = std::min(n, n1);
+ res.reserve( q );
+ for( int i=0; i<q; i++ )
{
PointUZ p;
p.U = operator[]( i ).U + c[i].U;
HYDROData_DTM::CurveUZ HYDROData_DTM::CurveUZ::operator * ( double d ) const
{
- HYDROData_DTM::CurveUZ res( Xcurv()*d, ProfileDir()*d );
+ HYDROData_DTM::CurveUZ res( Xcurv()*d, ProfileDir()*d, DeltaZ()*d, MaxZ()*d );
size_t n = size();
res.reserve( n );
for( int i=0; i<n; i++ )
void HYDROData_DTM::SetProfiles( const HYDROData_SequenceOfObjects& theProfiles )
{
SetReferenceObjects( theProfiles, DataTag_Profiles );
+ Changed( Geom_3d );
}
double HYDROData_DTM::GetDDZ() const
void HYDROData_DTM::SetDDZ( double theDDZ )
{
SetDouble( DataTag_DDZ, theDDZ );
+ Changed( Geom_3d );
}
double HYDROData_DTM::GetSpatialStep() const
void HYDROData_DTM::SetSpatialStep( double theSpatialStep )
{
SetDouble( DataTag_SpatialStep, theSpatialStep );
+ Changed( Geom_3d );
}
-void HYDROData_DTM::PointToWire(const AltitudePoints& pnts, TopoDS_Wire& W )
+void HYDROData_DTM::PointsToWire(const AltitudePoints& pnts, TopoDS_Wire& W )
{
- BRepLib_MakeWire WM;
- for (int i =0; i < pnts.size() - 1; i++)
+
+ 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();
+}
+
+void HYDROData_DTM::PointsToEdge(const AltitudePoints& pnts, TopoDS_Edge& E )
+{
+ Handle(TColgp_HArray1OfPnt) gpPoints = new TColgp_HArray1OfPnt(1, (int)pnts.size());
+
+ for (int i = 0; i < pnts.size(); i++)
+ gpPoints->SetValue(i+1, gp_Pnt(pnts[i].X, pnts[i].Y, pnts[i].Z));
+
+ GeomAPI_Interpolate anInterpolator(gpPoints, Standard_False,1.0e-6);
+ anInterpolator.Perform() ;
+ if (anInterpolator.IsDone())
{
- 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());
+ Handle(Geom_BSplineCurve) C = anInterpolator.Curve();
+ E = BRepBuilderAPI_MakeEdge(C).Edge();
}
- W = WM.Wire();
}
-TopoDS_Compound HYDROData_DTM::Create3DShape(const AltitudePoints& left,
- const AltitudePoints& right,
- const std::vector<AltitudePoints>& main_profiles)
+TopTools_IndexedMapOfOrientedShape HYDROData_DTM::Create3DShape(const AltitudePoints& left,
+ const AltitudePoints& right,
+ const std::vector<AltitudePoints>& main_profiles)
{
- BRep_Builder BB;
- TopoDS_Compound cmp;
- BB.MakeCompound(cmp);
- TopoDS_Wire LWire, RWire;
- PointToWire(left, LWire);
- PointToWire(right, RWire);
- BB.Add(cmp, LWire.Oriented(TopAbs_FORWARD));
+ TopTools_IndexedMapOfOrientedShape ll;
+ //TopoDS_Wire LWire, RWire;
+ //PointsToWire(left, LWire);
+ //PointsToWire(right, RWire);
+ TopoDS_Edge LEdge, REdge;
+ PointsToEdge(left, LEdge);
+ PointsToEdge(right, REdge);
+ if (!LEdge.IsNull())
+ ll.Add(LEdge.Oriented(TopAbs_FORWARD));
for (int k = 0; k < main_profiles.size(); k++)
{
TopoDS_Wire W;
- PointToWire(main_profiles[k], W);
+ PointsToWire(main_profiles[k], W);
TopAbs_Orientation Ori = TopAbs_INTERNAL;
if (k == 0 || k == main_profiles.size() - 1)
Ori = TopAbs_FORWARD;
- BB.Add(cmp, W.Oriented(Ori));
+ ll.Add(W.Oriented(Ori));
}
- BB.Add(cmp, RWire.Oriented(TopAbs_FORWARD));
+ if (!REdge.IsNull())
+ ll.Add(REdge.Oriented(TopAbs_FORWARD));
//yes, add subshapes in this order (left + profiles + right)
- //otherwise the projected wire will be non-manifold!!!
+ //otherwise the projected wire will be non-manifold
- return cmp;
+ return ll;
}
+
void HYDROData_DTM::Update()
{
- HYDROData_SequenceOfObjects objs = GetProfiles();
- int aLower = objs.Lower(), anUpper = objs.Upper();
- size_t n = anUpper-aLower+1;
+ 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();
+}
- std::vector<Handle_HYDROData_Profile> profiles;
- profiles.reserve( n );
+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( objs.Value( i ) );
+ Handle(HYDROData_Profile) aProfile = Handle(HYDROData_Profile)::DownCast( InpProfiles.Value( i ) );
if( !aProfile.IsNull() )
profiles.push_back( aProfile );
}
-
- double ddz = GetDDZ();
- double step = GetSpatialStep();
const double EPS = 1E-3;
- AltitudePoints points;
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 )
- points = Interpolate( profiles, ddz, step, left, right, main_profiles );
+ CreateProfiles(profiles, ddz, step, left, right, points, main_profiles,
+ Out3dPres, Out2dPres, OutLeftB, OutRightB, OutInlet, OutOutlet, Create3dPres, Create2dPres, InvInd, WireIntersections );
+}
+
+bool HYDROData_DTM::GetPlanarFaceFromBanks( const TopoDS_Edge& LB, const TopoDS_Edge& RB, TopoDS_Face& outF,
+ TopTools_SequenceOfShape* Boundr)
+{
+ BRep_Builder BB;
+ TopoDS_Face F;
+ Handle_Geom_Plane refpl = new Geom_Plane(gp_Pnt(0,0,0), gp_Dir(0,0,1));
+
+ TopoDS_Vertex VFI, VLI, VFO, VLO;
+ TopoDS_Edge prLB;
+ TopoDS_Edge prRB;
+
- TopoDS_Compound cmp = Create3DShape( left, right, main_profiles);
+ BRepAdaptor_Curve LBAD(LB);
+ Handle_Geom_Curve LBPC = GeomProjLib::ProjectOnPlane(LBAD.Curve().Curve(), refpl, gp_Dir(0, 0, -1), 1 );
+ prLB = BRepLib_MakeEdge(LBPC).Edge();
- SetShape(DataTag_DTM_Shape, cmp); //more safe way is to add each wire (left/right banks etc. with separate tag)
- SetAltitudePoints( points );
+ BRepAdaptor_Curve RBAD(RB);
+ Handle_Geom_Curve RBPC = GeomProjLib::ProjectOnPlane(RBAD.Curve().Curve(), refpl, gp_Dir(0, 0, -1), 1 );
+ prRB = BRepLib_MakeEdge(RBPC).Edge();
+
+ TopExp::Vertices(prLB, VFI, VFO, 1);
+ TopExp::Vertices(prRB, VLI, VLO, 1);
+ TopoDS_Edge prIL = BRepLib_MakeEdge(VFI, VLI).Edge();
+ TopoDS_Edge prOL = BRepLib_MakeEdge(VFO, VLO).Edge();
+ TopoDS_Wire prW = BRepLib_MakeWire(prLB, prIL, prOL, prRB).Wire();
+ outF = BRepBuilderAPI_MakeFace(refpl->Pln(), prW, 1).Face();
+
+ if (Boundr)
+ {
+ Boundr->Append(prLB);
+ Boundr->Append(prIL);
+ Boundr->Append(prOL);
+ Boundr->Append(prRB);
+ }
+
+ ShapeAnalysis_Wire WA(prW, outF, Precision::Confusion());
+ bool res = WA.CheckSelfIntersection();
+ return !res;
}
+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& ProjStat)
+{
+ if (theProfiles.empty())
+ return;
+ theOutPoints = Interpolate( theProfiles, theDDZ, theSpatialStep, theOutLeft, theOutRight, theOutMainProfiles, InvInd );
+ //note that if Create3dPres is false => Create2dPres flag is meaningless!
+ if( theOutPoints.empty() )
+ return;
+
+ 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;
+ ProjStat = GetPlanarFaceFromBanks(TopoDS::Edge(OutLeftB), TopoDS::Edge(OutRightB), outF, NULL);
+ Out2dPres = outF;
+ };
+ }
+}
-void HYDROData_DTM::GetProperties( const Handle_HYDROData_Profile& theProfile,
+
+void HYDROData_DTM::GetProperties( const Handle(HYDROData_Profile)& theProfile,
gp_Pnt& theLowestPoint, gp_Vec2d& theDir,
- bool isNormalDir,
double& theZMin, double& theZMax )
{
theLowestPoint = theProfile->GetBottomPoint();
theProfile->GetRightPoint( aRight, true, true );
double x = aRight.X()-aLeft.X();
double y = aRight.Y()-aLeft.Y();
- if( isNormalDir )
- theDir = gp_Vec2d( -y, x );
- else
- theDir = gp_Vec2d( x, y );
+ theDir = gp_Vec2d( x, y );
HYDROData_Profile::ProfilePoints points = theProfile->GetProfilePoints();
int lo = points.Lower();
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(Geom2d_Line) aLine2d = new Geom2d_Line( aFirst2d, gp_Dir2d( dir.X(), dir.Y() ) );
return new Geom2d_TrimmedCurve( aLine2d, 0, aLast2d.Distance( aFirst2d ) );
}
return Handle(Geom2d_Curve)();
}
-Handle_Geom2d_BSplineCurve HYDROData_DTM::CreateHydraulicAxis(
- const std::vector<Handle_HYDROData_Profile>& theProfiles,
+#include <GCE2d_MakeSegment.hxx>
+#include <Geom2dAPI_InterCurveCurve.hxx>
+bool IsCooriented( const Handle(HYDROData_Profile)& theProfile1,
+ const Handle(HYDROData_Profile)& theProfile2 )
+{
+ if( theProfile1==theProfile2 )
+ return true;
+
+ gp_XY lp1, rp1, lp2, rp2;
+ theProfile1->GetLeftPoint(lp1);
+ theProfile1->GetRightPoint(rp1);
+ theProfile2->GetLeftPoint(lp2);
+ theProfile2->GetRightPoint(rp2);
+
+ GCE2d_MakeSegment s1(lp1, lp2);
+ GCE2d_MakeSegment s2(rp1, rp2);
+
+ Geom2dAPI_InterCurveCurve inter;
+ inter.Init(s1.Value(), s2.Value());
+ if (inter.NbPoints() == 0)
+ return true;
+ else
+ return false;
+}
+
+Handle(Geom2d_BSplineCurve) HYDROData_DTM::CreateHydraulicAxis(
+ const std::vector<Handle(HYDROData_Profile)>& theProfiles,
std::vector<double>& theDistances )
{
size_t n = theProfiles.size();
+ if( n==1 )
+ return Handle_Geom2d_BSplineCurve();
+
Handle_Geom2d_BSplineCurve aResult;
Handle(TColgp_HArray1OfPnt2d) points = new TColgp_HArray1OfPnt2d( 1, (int)n );
TColgp_Array1OfVec2d tangents( 1, (int)n );
Handle(TColStd_HArray1OfBoolean) flags = new TColStd_HArray1OfBoolean( 1, (int)n );
- for( size_t i = 1; i <= n; i++ )
+ // Stage 1. Orient all profiles to be co-oriented with the first profile
+ theProfiles[0]->Update();
+ for( size_t i = 1; i < n; i++ )
{
- Handle_HYDROData_Profile aProfile = theProfiles[i-1];
+ Handle(HYDROData_Profile) aProfile = theProfiles[i];
+ Handle(HYDROData_Profile) aPrevProfile = theProfiles[i-1];
+
+ if( !IsCooriented( aProfile, aPrevProfile ) )
+ {
+ gp_XY lp, rp;
+ aProfile->GetLeftPoint( lp, true );
+ aProfile->GetRightPoint( rp, true );
+ aProfile->SetLeftPoint( rp, true );
+ aProfile->SetRightPoint( lp, true );
+ }
aProfile->Update();
+ }
+
+ // Stage 2. Calculate normals so that each normal "points" to the next profile
+ for( size_t i = 0; i < n; i++ )
+ {
+ Handle(HYDROData_Profile) aProfile = theProfiles[i];
+ Handle(HYDROData_Profile) aNextProfile = i==n-1 ? theProfiles[i-1] : theProfiles[i+1];
gp_Pnt aLowest;
- gp_Vec2d aTangent;
+ gp_Vec2d aNormal;
double zmin, zmax;
- GetProperties( aProfile, aLowest, aTangent, true, zmin, zmax );
- aTangent.Normalize();
- points->SetValue( (int)i, gp_Pnt2d( aLowest.X(), aLowest.Y() ) );
- tangents.SetValue( (int)i, aTangent );
- flags->SetValue( (int)i, Standard_True );
+ gp_XYZ curP = aProfile->GetBottomPoint(true);
+ gp_XY curP2d = gp_XY(curP.X(), curP.Y());
+
+ gp_XYZ nextP = aNextProfile->GetBottomPoint(true);
+ gp_XY nextP2d = gp_XY(nextP.X(), nextP.Y());
+
+ gp_Vec2d aPrTangent;
+ GetProperties( aProfile, aLowest, aPrTangent, zmin, zmax );
+ aNormal.SetCoord( -aPrTangent.Y(), aPrTangent.X() );
+
+ gp_Vec2d aDirToNextProfile(nextP2d.X() - curP2d.X(), nextP2d.Y() - curP2d.Y() );
+ if( i==n-1 )
+ aDirToNextProfile.Reverse();
+
+ if (aNormal.Dot(aDirToNextProfile) < 0)
+ aNormal.Reverse();
+
+ aNormal.Normalize();
+
+ points->SetValue( (int)(i+1), gp_Pnt2d( aLowest.X(), aLowest.Y() ) );
+ tangents.SetValue( (int)(i+1), aNormal );
+ flags->SetValue( (int)(i+1), Standard_True );
}
Geom2dAPI_Interpolate anInterpolator( points, Standard_False, Standard_False );
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;
+ std::vector<Handle(Geom2d_Curve)> curves;
// Transformation of the coordinate systems
gp_Pnt aLowest;
double zmin, zmax;
- GetProperties( theProfile, aLowest, theDir, false, zmin, zmax );
+ GetProperties( theProfile, aLowest, theDir, 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( theDir.X(), theDir.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 );
}
-bool CalcMidWidth( const std::vector<gp_Pnt2d>& intersections, double& theMid, double& theWid )
+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 <= 1 )
+ if( n <= 0 )
return false;
- for( size_t i = 0; i < n; i++ )
+ std::set<double>::const_iterator it = intersections.begin(), last = intersections.end();
+ for( ; it!=last; it++ )
{
- double u = intersections[i].X();
+ double u = *it;
if( u<umin )
umin = u;
if( u>umax )
return true;
}
-void HYDROData_DTM::ProfileDiscretization( const Handle_HYDROData_Profile& theProfile,
- double theXCurv, double theMinZ, double theMaxZ, double theDDZ,
+void HYDROData_DTM::ProfileDiscretization( const Handle(HYDROData_Profile)& theProfile,
+ double theXCurv, double theMinZ, double theMaxZ, double theTopZ, double theDDZ,
CurveUZ& theMidPointCurve,
- CurveUZ& theWidthCurve,
- double theTolerance )
+ CurveUZ& theWidthCurve,
+ int& intersection_nb,
+ double theTolerance)
{
double aDblMax = std::numeric_limits<double>::max(),
aUMin = aDblMax,
aVMax = 1000000;
gp_Vec2d aProfileDir;
- std::vector<Handle_Geom2d_Curve> curves = ProfileToParametric( theProfile, aUMin, aUMax, aProfileDir );
+ std::vector<Handle(Geom2d_Curve)> curves = ProfileToParametric( theProfile, aUMin, aUMax, aProfileDir );
size_t n = curves.size();
if( n==0 )
curves.push_back( aT2 );
int psize = ( int )( ( theMaxZ-theMinZ ) / theDDZ + 1 );
- theMidPointCurve = CurveUZ( theXCurv, aProfileDir );
+ theMidPointCurve = CurveUZ( theXCurv, aProfileDir, theMinZ, theTopZ);
theMidPointCurve.reserve( psize );
- theWidthCurve = CurveUZ( theXCurv, aProfileDir );
+ theWidthCurve = CurveUZ( theXCurv, aProfileDir, theMinZ, theTopZ );
theWidthCurve.reserve( psize );
n = curves.size();
// for each discrete value of z we search intersection with profile
- for( double z = theMinZ; z <= theMaxZ; z += theDDZ )
+ for( double z1 = theMinZ; z1 <= theMaxZ; z1 += theDDZ )
{
- Handle(Geom2d_Line) aLine = new Geom2d_Line( gp_Pnt2d( 0, z ), gp_Dir2d( 1, 0 ) );
- std::vector<gp_Pnt2d> intersections;
+ 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];
+ Handle(Geom2d_Curve) aCurve = curves[i];
Geom2dAPI_InterCurveCurve anIntersect( aCurve, aLine, theTolerance );
for( int k=1, m=anIntersect.NbPoints(); k<=m; k++ )
- intersections.push_back( anIntersect.Point( k ) );
+ intersections.insert( anIntersect.Point( k ).X() );
}
- if( intersections.size() >= 2 )
+ 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;
theInterpolation.push_back( theCurveB );
}
#include <BRepLib_MakeEdge2d.hxx>
-void HYDROData_DTM::CurveTo3D( const Handle_Geom2d_BSplineCurve& theHydraulicAxis,
+void HYDROData_DTM::CurveTo3D( const Handle(Geom2d_BSplineCurve)& theHydraulicAxis,
const CurveUZ& theMidCurve, const CurveUZ& theWidthCurve,
- AltitudePoints& thePoints, double dz )
+ AltitudePoints& thePoints )
{
Geom2dAdaptor_Curve anAdaptor( theHydraulicAxis );
TopoDS_Edge E2d = BRepLib_MakeEdge2d(theHydraulicAxis).Edge();
gp_Pnt2d point;
anAdaptor.D0( aParam, point );
gp_Vec2d profile_dir = theMidCurve.ProfileDir();
- gp_Dir tangent_n( -profile_dir.Y(), profile_dir.X(), dz );
+ //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++ )
+ bool isOnTop = false;
+ for( size_t i=0; i<n; i++ ) // build the two banks of the interpolated profile, from bottom to top
{
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;
-
- 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;
+ bool arrivedOnTop = false;
+ double z = 0;
+ if (theMidCurve[i].Z <= theMidCurve.MaxZ())
+ z = theMidCurve[i].Z + theMidCurve.DeltaZ();
+ else
+ {
+ z = theMidCurve.MaxZ() + theMidCurve.DeltaZ(); // limit z to linear interpolation between maxima on extremity profiles
+ arrivedOnTop = true; // do not keep points after this one
+ }
+ if (!isOnTop)
+ {
+ 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;
+ }
+ //if (arrivedOnTop)
+ // isOnTop =true; // do not keep points after this one (commented: leads to strange limits of 2D shape)
}
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++ )
- thePoints.push_back( it->second );
+ if( thePoints.empty() || thePoints.back().SquareDistance( it->second ) > EPS )
+ thePoints.push_back( it->second );
}
inline double max( double a, double b )
return b;
}
+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,
+ ( const Handle(Geom2d_BSplineCurve)& theHydraulicAxis,
+ const Handle(HYDROData_Profile)& theProfileA,
double theXCurvA,
- const Handle_HYDROData_Profile& theProfileB,
+ const Handle(HYDROData_Profile)& theProfileB,
double theXCurvB,
- double theDDZ, int theNbSteps, bool isAddSecond )
+ 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 );
+ GetProperties( theProfileA, lowestA, dirA, zminA, zmaxA );
+ GetProperties( theProfileB, lowestB, dirB, zminB, zmaxB );
- double dz = zminB - zminA;
+
+ double hmax = max( zmaxA-zminA, zmaxB-zminB );
- double zmin = max( zminA, zminB );
- double zmax = max( zmaxA, zmaxB );
+ //double dz = zminB - zminA;
+ //double zmin = min( zminA, zminB );
+ //double zmax = max( zmaxA, zmaxB );
- CurveUZ midA(0, gp_Vec2d()), midB(0, gp_Vec2d());
- CurveUZ widA(0, gp_Vec2d()), widB(0, gp_Vec2d());
+ CurveUZ midA(0, gp_Vec2d(), 0, 0), midB(0, gp_Vec2d(), 0, 0);
+ CurveUZ widA(0, gp_Vec2d(), 0, 0), widB(0, gp_Vec2d(), 0, 0);
- ProfileDiscretization( theProfileA, theXCurvA, zmin, zmax, theDDZ, midA, widA );
- ProfileDiscretization( theProfileB, theXCurvB, zmin, zmax, theDDZ, midB, widB );
+ ProfileDiscretization( theProfileA, theXCurvA, zminA, zminA+hmax, zmaxA-zminA, theDDZ, midA, widA, inter_nb_1 );
+ ProfileDiscretization( theProfileB, theXCurvB, zminB, zminB+hmax, zmaxB-zminB, theDDZ, midB, widB, inter_nb_2 );
std::vector<CurveUZ> mid, wid;
Interpolate( midA, midB, theNbSteps, mid, isAddSecond );
for( size_t i=0; i<p; i++ )
{
points[i].reserve( q );
- CurveTo3D( theHydraulicAxis, mid[i], wid[i], points[i], dz );
+ CurveTo3D( theHydraulicAxis, mid[i], wid[i], points[i] );
}
return points;
}
HYDROData_Bathymetry::AltitudePoints HYDROData_DTM::Interpolate
- ( const std::vector<Handle_HYDROData_Profile>& theProfiles,
+ ( const std::vector<Handle(HYDROData_Profile)>& theProfiles,
double theDDZ, double theSpatialStep,
AltitudePoints& theLeft,
AltitudePoints& theRight,
- std::vector<AltitudePoints>& theMainProfiles )
+ std::vector<AltitudePoints>& theMainProfiles,
+ std::set<int>& invalInd)
{
AltitudePoints points;
size_t n = theProfiles.size();
return points;
std::vector<double> distances;
- Handle_Geom2d_BSplineCurve aHydraulicAxis = CreateHydraulicAxis( theProfiles, distances );
+ Handle(Geom2d_BSplineCurve) aHydraulicAxis = CreateHydraulicAxis( theProfiles, distances );
if( aHydraulicAxis.IsNull() )
return points;
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 );
+ 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++ )
{
}
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, aZMin, aZMax );
+ int aNbZSteps = (aZMax-aZMin)/theDDZ;
+
+ if( aNbSteps > ( 1<<16 ) || aNbZSteps > ( 1<<16 ) )
+ return 1 << 20;
+
+ return aNbSteps * aNbZSteps;
+}