#include "HYDROData_Projection.h"
#include "HYDROData_ShapesGroup.h"
#include "HYDROData_ShapesTool.h"
-#include "HYDROData_Pipes.h"
#include "HYDROData_Stream.h"
+#include "HYDROData_Tool.h"
+#include "HYDROData_ChannelAltitude.h"
#include <BRepBuilderAPI_MakeWire.hxx>
+#include <BRepLib_MakePolygon.hxx>
#include <BRepOffsetAPI_MakePipeShell.hxx>
#include <BRepOffsetAPI_MakePipe.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TopTools_HArray1OfShape.hxx>
+#include <TopTools_SequenceOfShape.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Wire.hxx>
#include <TopoDS_Vertex.hxx>
+#include <Quantity_Parameter.hxx>
+
#define DEB_CHANNEL 1
#ifdef DEB_CHANNEL
#include <BRepTools.hxx>
#define _DEVDEBUG_
#include "HYDRO_trace.hxx"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Channel,HYDROData_ArtificialObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Channel,HYDROData_ArtificialObject)
HYDROData_Channel::HYDROData_Channel()
-: HYDROData_ArtificialObject()
+: HYDROData_ArtificialObject( Geom_3d )
{
}
{
}
-QStringList HYDROData_Channel::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
+QStringList HYDROData_Channel::DumpToPython( const QString& thePyScriptPath,
+ MapOfTreatedObjects& theTreatedObjects ) const
{
QStringList aResList = dumpObjectCreation( theTreatedObjects );
QString aName = GetObjPyName();
Handle(HYDROData_Polyline3D) aRefGideLine = GetGuideLine();
- setPythonReferenceObject( theTreatedObjects, aResList, aRefGideLine, "SetGuideLine" );
+ setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aRefGideLine, "SetGuideLine" );
+
+ bool mode = GetProfileMode();
+ QString aMode = mode ? "True" : "False" ;
+ aResList << QString( "%1.SetProfileMode( %2 )" ).arg( aName ).arg( aMode );
+
+ if (mode)
+ {
+ Handle(HYDROData_Profile) aRefProfile = GetProfile();
+ setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aRefProfile, "SetProfile" );
+ }
+ else
+ {
+ QString aLC = QString::number( GetLCValue(), 'f', 3 );
+ QString aDeltaZ = QString::number( GetDeltaZValue(), 'f', 3 );
+ QString aCoteZ = QString::number( GetCoteZValue(), 'f', 3 );
+
+ aResList << QString( "%1.SetLCValue( %2 )" ).arg( aName ).arg( aLC );
+ aResList << QString( "%1.SetDeltaZValue( %2 )" ).arg( aName ).arg( aDeltaZ );
+ aResList << QString( "%1.SetCoteZValue( %2 )" ).arg( aName ).arg( aCoteZ );
+ }
- Handle(HYDROData_Profile) aRefProfile = GetProfile();
- setPythonReferenceObject( theTreatedObjects, aResList, aRefProfile, "SetProfile" );
+ aResList << QString( "%1.SetEquiDistance( %2 )" ).arg( aName ).arg( GetEquiDistance() );
aResList << QString( "" );
- aResList << QString( "%1.Update();" ).arg( aName );
+ aResList << QString( "%1.Update()" ).arg( aName );
aResList << QString( "" );
return aResList;
+
}
HYDROData_SequenceOfObjects HYDROData_Channel::GetAllReferenceObjects() const
return aResSeq;
}
-TopoDS_Shape HYDROData_Channel::GetTopShape() const
+bool HYDROData_Channel::CreatePresentations( const Handle(HYDROData_Polyline3D)& theGuideLine,
+ const Handle(HYDROData_Profile)& theProfile,
+ PrsDefinition& thePrs,
+ double theEquiDistance,
+ bool ReverseXCoord)
{
- return getTopShape();
+ return internalCreatePresentations( true, theGuideLine, theProfile, TopoDS_Wire(), gp_Pnt(), thePrs, theEquiDistance, ReverseXCoord);
}
-TopoDS_Shape HYDROData_Channel::GetShape3D() const
+bool HYDROData_Channel::CreatePresentations( const Handle(HYDROData_Polyline3D)& theGuideLine,
+ double LC,
+ double deltaZ,
+ double coteZ,
+ PrsDefinition& thePrs,
+ double theEquiDistance,
+ bool ReverseXCoord)
{
- return getShape3D();
+ Handle(HYDROData_Profile) theProfile;
+ TopoDS_Wire W;
+ gp_Pnt MP;
+
+ gp_Pnt2d A1(-0.75*LC, coteZ-LC/2.0), A2(0.75*LC, coteZ -LC/2.0), B1(-LC/2.0, coteZ), B2(LC/2.0, coteZ), C(0, coteZ+deltaZ);
+ gp_Pnt A1_3d(A1.X(), 0, A1.Y()), A2_3d(A2.X(), 0, A2.Y()), B1_3d(B1.X(), 0, B1.Y()), B2_3d(B2.X(), 0, B2.Y()), C_3d(C.X(), 0, C.Y());
+ BRepLib_MakePolygon PM;
+ PM.Add(A1_3d);
+ PM.Add(B1_3d);
+ PM.Add(C_3d);
+ PM.Add(B2_3d);
+ PM.Add(A2_3d);
+ W = PM.Wire();
+ return internalCreatePresentations( false, theGuideLine, theProfile, W, MP, thePrs, theEquiDistance, ReverseXCoord);
}
-bool HYDROData_Channel::CreatePresentations( const Handle(HYDROData_Polyline3D)& theGuideLine,
- const Handle(HYDROData_Profile)& theProfile,
- PrsDefinition& thePrs )
+bool HYDROData_Channel::internalCreatePresentations( bool mode,
+ const Handle(HYDROData_Polyline3D)& theGuideLine,
+ const Handle(HYDROData_Profile)& theProfile,
+ const TopoDS_Wire& theProfWire,
+ const gp_Pnt& theMiddlePnt,
+ PrsDefinition& thePrs,
+ double theEquiDistance,
+ bool ReverseXCoord)
{
// Check input parameters
- if ( theGuideLine.IsNull() || theProfile.IsNull() ) {
+ if ( theGuideLine.IsNull() )
+ {
return false;
}
+ if (mode && theProfile.IsNull() || !mode && theProfWire.IsNull() )
+ return false;
TopoDS_Wire aPathWire = TopoDS::Wire( theGuideLine->GetShape3D() );
- TopoDS_Wire aProfileWire = TopoDS::Wire( theProfile->GetShape3D() );
+ TopoDS_Wire aProfileWire = theProfWire;
+ //ignore ReverseXCoord if mode is false
+ if (mode)
+ {
+ if (!ReverseXCoord)
+ aProfileWire = TopoDS::Wire( theProfile->GetShape3D(false, false) ); //temp force rebuild
+ else
+ aProfileWire = TopoDS::Wire( theProfile->GetShape3D(true, true));
+ }
if ( aPathWire.IsNull() || aProfileWire.IsNull() ) {
return false;
}
int aNbPoints = aPolylinePoints.Length();
*/
- HYDROData_Polyline3D::Polyline3DPoints aPolylinePoints3D = theGuideLine->GetPoints();
+ HYDROData_Polyline3D::Polyline3DPoints aPolylinePoints3D = theGuideLine->GetPoints( theEquiDistance );
int aNbPoints = aPolylinePoints3D.Length();
- if ( aNbPoints < 2 ) {
+ if ( aNbPoints < 2 )
return false;
- }
// Get tangent in each point of the guide line ( 2D )
TColgp_Array1OfDir aTangents( 1, aNbPoints );
HYDROData_IPolyline::SectionType aSectionType = aPolylineXY->GetSectionType( 0 );
- if ( aSectionType == HYDROData_IPolyline::SECTION_POLYLINE ) {
+ if( aSectionType == HYDROData_IPolyline::SECTION_POLYLINE )
+ {
for ( int i = 1; i <= aNbPoints; ++i ) {
gp_XYZ aPnt = aPolylinePoints3D.Value( i );
aPnt.SetZ( 0. );
}
// Get the profile middle point ( 3D )
- gp_Pnt aMiddlePoint( theProfile->GetMiddlePoint() );
+ gp_Pnt aMiddlePoint = theMiddlePnt;
+ if (mode)
+ {
+ aMiddlePoint = theProfile->GetMiddlePoint( true );
+ }
// Translate the profile to each point on the guide line ( 3D )
Handle(TColgp_HArray1OfPnt) anArrayOfFPnt = new TColgp_HArray1OfPnt(1, aNbPoints );
// Create presentation
HYDROData_Stream::PrsDefinition aPrs;
Handle(TopTools_HArray1OfShape) anArrOf2DProfiles; // we don't need 2D profiles for channel/digue presentation
- bool aRes = HYDROData_Stream::CreatePresentations( anArrayOfFPnt, anArrayOfLPnt,
- anArrOfProfiles, anArrOf2DProfiles, aPrs );
- if ( aRes ) {
- thePrs.myPrs3D = aPrs.myPrs3D;
- thePrs.myPrs2D = TopoDS::Face( aPrs.myPrs2D );
- BRepBuilderAPI_MakeWire aMakeWire( aPrs.myLeftBank ) ;
- thePrs.myLeftBank = aMakeWire.Wire();
- aMakeWire = BRepBuilderAPI_MakeWire( aPrs.myRightBank );
- thePrs.myRightBank = aMakeWire.Wire();
- aMakeWire = BRepBuilderAPI_MakeWire( aPrs.myInlet );
- thePrs.myInlet = aMakeWire.Wire();
- aMakeWire = BRepBuilderAPI_MakeWire( aPrs.myOutlet );
- thePrs.myOutlet = aMakeWire.Wire();
- }
- return aRes;
+ HYDROData_Stream::CreatePresentations( anArrayOfFPnt, anArrayOfLPnt, anArrOfProfiles, aPrs );
+ thePrs.myInlet = aPrs.myInlet;
+ thePrs.myOutlet = aPrs.myOutlet;
+ thePrs.myLeftBank = aPrs.myLeftBank;
+ thePrs.myRightBank = aPrs.myRightBank;
+ thePrs.myPrs2D = TopoDS::Face(aPrs.myPrs2D);
+ thePrs.myPrs3D = aPrs.myPrs3D;
+
+ //thePrs.myPrs2D = TopoDS::Face( aPrs.myPrs2D );
+ //BRepBuilderAPI_MakeWire aMakeWire( aPrs.myLeftBank ) ;
+ //thePrs.myLeftBank = aMakeWire.Wire();
+ //aMakeWire = BRepBuilderAPI_MakeWire( aPrs.myRightBank );
+ //thePrs.myRightBank = aMakeWire.Wire();
+ //aMakeWire = BRepBuilderAPI_MakeWire( aPrs.myInlet );
+ //thePrs.myInlet = aMakeWire.Wire();
+ //aMakeWire = BRepBuilderAPI_MakeWire( aPrs.myOutlet );
+ //thePrs.myOutlet = aMakeWire.Wire();
+
+ return true;
}
void HYDROData_Channel::Update()
HYDROData_ArtificialObject::Update();
Handle(HYDROData_Polyline3D) aGuideLine = GetGuideLine();
- Handle(HYDROData_Profile) aProfile = GetProfile();
PrsDefinition aResultPrs;
- if ( !CreatePresentations( aGuideLine, aProfile, aResultPrs ) )
- return;
+ double anEquiDistance = GetEquiDistance();
+
+ bool invDirection = false;
+ Handle(HYDROData_IAltitudeObject) anObjAltitude = GetAltitudeObject();
+ Handle(HYDROData_ChannelAltitude) aChannelAlt = Handle(HYDROData_ChannelAltitude)::DownCast(anObjAltitude);
+ if (!aChannelAlt.IsNull())
+ invDirection = aChannelAlt->GetInvertDirection();
+
+ if (GetProfileMode())
+ {
+ Handle(HYDROData_Profile) aProfile = GetProfile();
+ if ( !CreatePresentations( aGuideLine, aProfile, aResultPrs, anEquiDistance, invDirection ) )
+ return;
+ }
+ else
+ {
+ double lc = GetLCValue();
+ double deltaz = GetDeltaZValue();
+ double cotez = GetCoteZValue();
+ if ( !CreatePresentations( aGuideLine, lc, deltaz, cotez, aResultPrs, anEquiDistance, invDirection ) )
+ return;
+ }
SetShape3D( aResultPrs.myPrs3D );
SetTopShape( aResultPrs.myPrs2D );
TopTools_SequenceOfShape anOutletEdges;
HYDROData_ShapesTool::ExploreShapeToShapes( aResultPrs.myOutlet, TopAbs_EDGE, anOutletEdges );
-
+
+ RemoveGroupObjects();
QString aLeftGroupName = GetName() + "_Left_Bank";
-
Handle(HYDROData_ShapesGroup) aLeftGroup = createGroupObject();
aLeftGroup->SetName( aLeftGroupName );
aLeftGroup->SetShapes( aLeftBankEdges );
return true;
}
-QColor HYDROData_Channel::DefaultFillingColor()
+QColor HYDROData_Channel::DefaultFillingColor() const
{
return QColor( Qt::blue );
}
-QColor HYDROData_Channel::DefaultBorderColor()
+QColor HYDROData_Channel::DefaultBorderColor() const
{
return QColor( Qt::transparent );
}
-QColor HYDROData_Channel::getDefaultFillingColor() const
-{
- return DefaultFillingColor();
-}
-
-QColor HYDROData_Channel::getDefaultBorderColor() const
-{
- return DefaultBorderColor();
-}
-
bool HYDROData_Channel::SetGuideLine( const Handle(HYDROData_Polyline3D)& theGuideLine )
{
Handle(HYDROData_Polyline3D) aPrevGuideLine = GetGuideLine();
SetReferenceObject( theGuideLine, DataTag_GuideLine );
// Indicate model of the need to update the chanel presentation
- SetToUpdate( true );
+ Changed( Geom_3d );
return true;
}
ClearReferenceObjects( DataTag_GuideLine );
// Indicate model of the need to update the chanel presentation
- SetToUpdate( true );
+ Changed( Geom_3d );
}
bool HYDROData_Channel::SetProfile( const Handle(HYDROData_Profile)& theProfile )
SetReferenceObject( theProfile, DataTag_Profile );
// Indicate model of the need to update the chanel presentation
- SetToUpdate( true );
+ Changed( Geom_3d );
return true;
}
ClearReferenceObjects( DataTag_Profile );
// Indicate model of the need to update the chanel presentation
- SetToUpdate( true );
+ Changed( Geom_3d );
}
ObjectKind HYDROData_Channel::getAltitudeObjectType() const
{
- DEBTRACE("HYDROData_Channel::getAltitudeObjectType");
+ //DEBTRACE("HYDROData_Channel::getAltitudeObjectType");
return KIND_CHANNEL_ALTITUDE;
+ //return KIND_STREAM_ALTITUDE;
+}
+
+TopoDS_Shape HYDROData_Channel::GetLeftShape() const
+{
+ HYDROData_SequenceOfObjects aGroups = GetGroups();
+ return HYDROData_Tool::getFirstShapeFromGroup( aGroups, 1);
+}
+
+TopoDS_Shape HYDROData_Channel::GetRightShape() const
+{
+ HYDROData_SequenceOfObjects aGroups = GetGroups();
+ return HYDROData_Tool::getFirstShapeFromGroup( aGroups, 2);
+}
+
+void HYDROData_Channel::SetEquiDistance( double theEquiDistance )
+{
+ double anEquiDistance = theEquiDistance > 0 ? theEquiDistance : 1E-3;
+ SetDouble( DataTag_EquiDistance, theEquiDistance );
+}
+
+double HYDROData_Channel::GetEquiDistance() const
+{
+ return GetDouble( DataTag_EquiDistance, 1.0 );
+}
+
+void HYDROData_Channel::SetLCValue( double val )
+{
+ SetDouble( DataTag_LC, val );
+}
+
+double HYDROData_Channel::GetLCValue() const
+{
+ return GetDouble( DataTag_LC, 1.0 );
+}
+
+void HYDROData_Channel::SetDeltaZValue( double val )
+{
+ SetDouble( DataTag_DeltaZ, val );
}
+double HYDROData_Channel::GetDeltaZValue() const
+{
+ return GetDouble( DataTag_DeltaZ, 1.0 );
+}
+
+void HYDROData_Channel::SetCoteZValue( double val )
+{
+ SetDouble( DataTag_CoteZ, val );
+}
+
+double HYDROData_Channel::GetCoteZValue() const
+{
+ return GetDouble( DataTag_CoteZ, 1.0 );
+}
+
+void HYDROData_Channel::SetProfileMode( bool mode )
+{
+ SetInteger( DataTag_ProfileMode, (bool)mode );
+}
+
+bool HYDROData_Channel::GetProfileMode() const
+{
+ return (bool)GetInteger( DataTag_ProfileMode, 1 );
+}
