X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_Channel.cxx;h=0f31fc1f1ac737f96bbd000251424402e7e918d7;hb=e7e76450be3fadf6ad263f78e10ceb8cd1f70deb;hp=f8e30fbbf434480905e1af09f467dad51c5a7a19;hpb=0b1867b383087c4965ea14e56773f0396c3f890c;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_Channel.cxx b/src/HYDROData/HYDROData_Channel.cxx index f8e30fbb..0f31fc1f 100644 --- a/src/HYDROData/HYDROData_Channel.cxx +++ b/src/HYDROData/HYDROData_Channel.cxx @@ -1,3 +1,20 @@ +// Copyright (C) 2014-2015 EDF-R&D +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include "HYDROData_Channel.h" @@ -8,21 +25,46 @@ #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 +#include #include #include #include -#include + +#include + +#include + +#include +#include + +#include + +#include #include +#include + +#include +#include + +#include + +#include +#include #include #include #include -#include -//#define DEB_CHANNEL 1 +#include + +#define DEB_CHANNEL 1 #ifdef DEB_CHANNEL #include #endif @@ -30,14 +72,14 @@ #include #include -#define PYTHON_CHANNEL_ID "KIND_CHANNEL" +#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 ) { } @@ -45,26 +87,43 @@ HYDROData_Channel::~HYDROData_Channel() { } -QStringList HYDROData_Channel::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const +QStringList HYDROData_Channel::DumpToPython( const QString& thePyScriptPath, + MapOfTreatedObjects& theTreatedObjects ) const { - QStringList aResList; + QStringList aResList = dumpObjectCreation( theTreatedObjects ); + QString aName = GetObjPyName(); - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); - if ( aDocument.IsNull() ) - return aResList; + Handle(HYDROData_Polyline3D) aRefGideLine = GetGuideLine(); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aRefGideLine, "SetGuideLine" ); - QString aDocName = aDocument->GetDocPyName(); - QString aChannelName = GetName(); + bool mode = GetProfileMode(); + QString aMode = mode ? "True" : "False" ; + aResList << QString( "%1.SetProfileMode( %2 )" ).arg( aName ).arg( aMode ); - aResList << QString( "%1 = %2.CreateObject( %3 );" ) - .arg( aChannelName ).arg( aDocName ).arg( PYTHON_CHANNEL_ID ); - aResList << QString( "%1.SetName( \"%2\" );" ) - .arg( aChannelName ).arg( aChannelName ); - aResList << QString( "" ); + 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 ); + } - // TODO + aResList << QString( "%1.SetEquiDistance( %2 )" ).arg( aName ).arg( GetEquiDistance() ); + + aResList << QString( "" ); + aResList << QString( "%1.Update()" ).arg( aName ); + aResList << QString( "" ); return aResList; + } HYDROData_SequenceOfObjects HYDROData_Channel::GetAllReferenceObjects() const @@ -82,14 +141,239 @@ 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::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() ) + { + return false; + } + if (mode && theProfile.IsNull() || !mode && theProfWire.IsNull() ) + return false; + + TopoDS_Wire aPathWire = TopoDS::Wire( theGuideLine->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; + } + +#ifdef DEB_CHANNEL + std::string brepName = "guideline_"; + brepName += theGuideLine->GetName().toStdString(); + brepName += ".brep"; + BRepTools::Write( aPathWire, brepName.c_str() ); + brepName = "profile_"; + brepName += theGuideLine->GetName().toStdString(); + brepName += ".brep"; + BRepTools::Write( aProfileWire, brepName.c_str() ); +#endif + + // Pre-processing + Handle(HYDROData_PolylineXY) aPolylineXY = theGuideLine->GetPolylineXY(); + if ( aPolylineXY.IsNull() ) { + return false; + } + + /* + HYDROData_IPolyline::SectionType aSectionType = aPolylineXY->GetSectionType( 0 ); + HYDROData_IPolyline::PointsList aPolylinePoints = aPolylineXY->GetPoints( 0 ); + int aNbPoints = aPolylinePoints.Length(); + */ + + HYDROData_Polyline3D::Polyline3DPoints aPolylinePoints3D = theGuideLine->GetPoints( theEquiDistance ); + int aNbPoints = aPolylinePoints3D.Length(); + 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 ) + { + for ( int i = 1; i <= aNbPoints; ++i ) { + gp_XYZ aPnt = aPolylinePoints3D.Value( i ); + aPnt.SetZ( 0. ); + gp_XYZ aPrevPnt; + if ( i > 1 ) { + aPrevPnt = aPolylinePoints3D.Value( i - 1 ); + aPrevPnt.SetZ( 0. ); + } + + gp_Vec aDir; + if ( i < aNbPoints ) { + gp_XYZ aNextPnt = aPolylinePoints3D.Value( i + 1 ); + aNextPnt.SetZ( 0. ); + + gp_Vec anEdgeVec( aPnt, aNextPnt ); + + if ( i == 1 ) { + aDir = anEdgeVec; + } else { + gp_Vec aPrevVec( aPrevPnt, aPnt ); + aDir = aPrevVec.Normalized() + anEdgeVec.Normalized(); + } + } else { + aDir = gp_Vec( aPrevPnt, aPnt ); + } + + aTangents.SetValue( i, aDir ); + } + } else { + // Get curve from the first edge ( 2D ) + TopTools_SequenceOfShape anEdges; + HYDROData_ShapesTool::ExploreShapeToShapes( aPolylineXY->GetShape(), TopAbs_EDGE, anEdges ); + Standard_Real aStart, anEnd; + + Handle(Geom_Curve) aCurve = BRep_Tool::Curve( TopoDS::Edge( anEdges.First() ), aStart, anEnd ); + GeomAPI_ProjectPointOnCurve aProject; + + // Get tangents + for ( int i = 1; i <= aNbPoints; ++i ) { + gp_XYZ aPointToTest = aPolylinePoints3D.Value( i ); + aPointToTest.SetZ( 0. ); + + aProject.Init( aPointToTest, aCurve ); + Quantity_Parameter aParam = aProject.LowerDistanceParameter(); + gp_Pnt aPnt; + gp_Vec aDir; + aCurve->D1( aParam, aPnt, aDir); + + aTangents.SetValue( i, aDir ); + } + } + + // Get the profile middle point ( 3D ) + 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 ); + Handle(TColgp_HArray1OfPnt) anArrayOfLPnt = new TColgp_HArray1OfPnt(1, aNbPoints ); + Handle(TopTools_HArray1OfShape) anArrOfProfiles = new TopTools_HArray1OfShape( 1, aNbPoints ); + + for ( int i = 1; i <= aNbPoints; ++i ) { + // Get point on the guide line + gp_Pnt aPointOnGuide( aPolylinePoints3D.Value( i ) ); + + // Define translation and rotation: + gp_Trsf Translation, Rotation; + + // Translation + Translation.SetTranslation( aMiddlePoint, aPointOnGuide ); + TopoDS_Wire aTransformedProfile = + TopoDS::Wire( BRepBuilderAPI_Transform( aProfileWire, Translation, Standard_True ) ); + + // Rotation + gp_Vec aVertical( 0., 0., 1. ); + TopoDS_Vertex aLeftVertex, aRightVertex; + TopExp::Vertices( aTransformedProfile, aLeftVertex, aRightVertex ); + gp_Pnt aLeftPoint = BRep_Tool::Pnt( aLeftVertex ); + gp_Pnt aRightPoint = BRep_Tool::Pnt( aRightVertex ); + gp_Vec aLeftToRight( aLeftPoint, aRightPoint); + gp_Vec NormalToProfile = aVertical ^ aLeftToRight; + + gp_Vec aDir = aTangents.Value( i ); + gp_Vec AxisOfRotation = NormalToProfile ^ aDir; + if (AxisOfRotation.Magnitude() <= gp::Resolution()) { + if ( aVertical * aLeftToRight < 0. ) { + gp_Ax1 theVertical(aPointOnGuide, gp::DZ() ); + Rotation.SetRotation(theVertical, M_PI); + } + } else { + gp_Ax1 theAxis(aPointOnGuide, AxisOfRotation); + Standard_Real theAngle = NormalToProfile.AngleWithRef(aDir, AxisOfRotation); + Rotation.SetRotation(theAxis, theAngle); + } + + aTransformedProfile = TopoDS::Wire(BRepBuilderAPI_Transform( aTransformedProfile, Rotation, Standard_True) ); + + // Get the first and the last points of the transformed profile + TopoDS_Vertex V1, V2; + TopExp::Vertices( aTransformedProfile, V1, V2 ); + + // Fill the data + anArrayOfFPnt->SetValue( i, BRep_Tool::Pnt( V1 ) ); + anArrayOfLPnt->SetValue( i, BRep_Tool::Pnt( V2 ) ); + + anArrOfProfiles->SetValue( i, aTransformedProfile ); + } + + // Create presentation + HYDROData_Stream::PrsDefinition aPrs; + Handle(TopTools_HArray1OfShape) anArrOf2DProfiles; // we don't need 2D profiles for channel/digue presentation + + 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() @@ -97,47 +381,49 @@ void HYDROData_Channel::Update() HYDROData_ArtificialObject::Update(); Handle(HYDROData_Polyline3D) aGuideLine = GetGuideLine(); - Handle(HYDROData_Profile) aProfile = GetProfile(); - if ( aGuideLine.IsNull() || aProfile.IsNull() ) - return; - // build 3d shape - TopoDS_Wire aPathWire = TopoDS::Wire(aGuideLine->GetShape3D()); - if(aPathWire.IsNull()) - return; - TopoDS_Wire aProfileWire = TopoDS::Wire( aProfile->GetShape3D() ); - if(aProfileWire.IsNull()) - return; + PrsDefinition aResultPrs; + 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(); - //BRepTools::Write( aPathWire, "guideline.brep" ); - //BRepTools::Write( aProfileWire, "profile.brep" ); + 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; + } - HYDROData_Canal3dAnd2d aChannelConstructor( aProfileWire, aPathWire ); - aChannelConstructor.Create3dPresentation(); - aChannelConstructor.Create2dPresentation(); - SetShape3D( aChannelConstructor.Get3dPresentation() ); - SetTopShape( aChannelConstructor.Get2dPresentation() ); + SetShape3D( aResultPrs.myPrs3D ); + SetTopShape( aResultPrs.myPrs2D ); // Create groups for channel - TopoDS_Wire aLeftBank = aChannelConstructor.GetLeftBank(); - TopoDS_Wire aRightBank = aChannelConstructor.GetRightBank(); - TopoDS_Wire anInlet = aChannelConstructor.GetInlet(); - TopoDS_Wire anOutlet = aChannelConstructor.GetOutlet(); - TopTools_SequenceOfShape aLeftBankEdges; - HYDROData_ShapesTool::ExploreShapeToShapes( aLeftBank, TopAbs_EDGE, aLeftBankEdges ); + HYDROData_ShapesTool::ExploreShapeToShapes( aResultPrs.myLeftBank, TopAbs_EDGE, aLeftBankEdges ); TopTools_SequenceOfShape aRightBankEdges; - HYDROData_ShapesTool::ExploreShapeToShapes( aRightBank, TopAbs_EDGE, aRightBankEdges ); + HYDROData_ShapesTool::ExploreShapeToShapes( aResultPrs.myRightBank, TopAbs_EDGE, aRightBankEdges ); TopTools_SequenceOfShape anInletEdges; - HYDROData_ShapesTool::ExploreShapeToShapes( anInlet, TopAbs_EDGE, anInletEdges ); + HYDROData_ShapesTool::ExploreShapeToShapes( aResultPrs.myInlet, TopAbs_EDGE, anInletEdges ); TopTools_SequenceOfShape anOutletEdges; - HYDROData_ShapesTool::ExploreShapeToShapes( anOutlet, TopAbs_EDGE, 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 ); @@ -161,24 +447,19 @@ void HYDROData_Channel::Update() anOutGroup->SetShapes( anOutletEdges ); } -QColor HYDROData_Channel::DefaultFillingColor() +bool HYDROData_Channel::IsHas2dPrs() const { - return QColor( Qt::blue ); -} - -QColor HYDROData_Channel::DefaultBorderColor() -{ - return QColor( Qt::transparent ); + return true; } -QColor HYDROData_Channel::getDefaultFillingColor() const +QColor HYDROData_Channel::DefaultFillingColor() const { - return DefaultFillingColor(); + return QColor( Qt::blue ); } -QColor HYDROData_Channel::getDefaultBorderColor() const +QColor HYDROData_Channel::DefaultBorderColor() const { - return DefaultBorderColor(); + return QColor( Qt::transparent ); } bool HYDROData_Channel::SetGuideLine( const Handle(HYDROData_Polyline3D)& theGuideLine ) @@ -201,7 +482,7 @@ bool HYDROData_Channel::SetGuideLine( const Handle(HYDROData_Polyline3D)& theGui SetReferenceObject( theGuideLine, DataTag_GuideLine ); // Indicate model of the need to update the chanel presentation - SetToUpdate( true ); + Changed( Geom_3d ); return true; } @@ -221,7 +502,7 @@ void HYDROData_Channel::RemoveGuideLine() 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 ) @@ -240,7 +521,7 @@ 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; } @@ -260,11 +541,75 @@ void HYDROData_Channel::RemoveProfile() ClearReferenceObjects( DataTag_Profile ); // Indicate model of the need to update the chanel presentation - SetToUpdate( true ); + Changed( Geom_3d ); } ObjectKind HYDROData_Channel::getAltitudeObjectType() const { - return KIND_OBSTACLE_ALTITUDE; + //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 ); +}