X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_ProfileInterpolateOp.cxx;h=3bfb229203d426a8ee7b993b66ac36ad8f7fd463;hb=7bc13643f345b813472c30c65307ea78c12df428;hp=c713bfab1121756df44aaa42976cb7c046f38335;hpb=7e11c53f099ac1d312e9e8580b98f76783b862ae;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_ProfileInterpolateOp.cxx b/src/HYDROGUI/HYDROGUI_ProfileInterpolateOp.cxx index c713bfab..3bfb2292 100644 --- a/src/HYDROGUI/HYDROGUI_ProfileInterpolateOp.cxx +++ b/src/HYDROGUI/HYDROGUI_ProfileInterpolateOp.cxx @@ -1,8 +1,4 @@ -// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE -// -// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// +// 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 @@ -20,261 +16,358 @@ // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -#include #include -#include -#include -#include -#include -#include + +#include "HYDROGUI_Tool.h" +#include "HYDROGUI_Module.h" +#include "HYDROGUI_DataObject.h" +#include "HYDROGUI_UpdateFlags.h" +#include "HYDROGUI_ProfileInterpolateDlg.h" + +#include #include -#include -#include +#include +#include +#include +#include +#include +#include #include #include #include -#include #include +#include #include - +#include #include -#include +#include +#include + +#include +#include -//static int ZValueIncrement = 0; +#include -HYDROGUI_ProfileInterpolateOp::HYDROGUI_ProfileInterpolateOp( HYDROGUI_Module* theModule, bool theIsEdit ) -: HYDROGUI_Operation( theModule ), myIsEdit(theIsEdit), myProfile(NULL) +HYDROGUI_ProfileInterpolateOp::HYDROGUI_ProfileInterpolateOp( HYDROGUI_Module* theModule ) + : HYDROGUI_Operation( theModule ) { - setName( theIsEdit ? tr( "EDIT_PROFILE" ) : tr( "CREATE_PROFILE" ) ); + setName( tr( "PROFILE_INTERPOLATION" ) ); } HYDROGUI_ProfileInterpolateOp::~HYDROGUI_ProfileInterpolateOp() { - erasePreview(); } -/** - * Redirect the delete action to input panel - */ -void HYDROGUI_ProfileInterpolateOp::deleteSelected() +void HYDROGUI_ProfileInterpolateOp::startOperation() { - HYDROGUI_ProfileDlg* aPanel = (HYDROGUI_ProfileDlg*)inputPanel(); - aPanel->deleteSelected(); + HYDROGUI_Operation::startOperation(); + + if ( isApplyAndClose() ) + { + HYDROGUI_ProfileInterpolateDlg* aPanel = ::qobject_cast( inputPanel() ); + if ( aPanel ) + { + aPanel->reset(); + aPanel->setInterpolators( interpolators() ); + } + } } -/** - * Checks whether there are some to delete - */ -bool HYDROGUI_ProfileInterpolateOp::deleteEnabled() +void HYDROGUI_ProfileInterpolateOp::abortOperation() { - HYDROGUI_ProfileDlg* aPanel = (HYDROGUI_ProfileDlg*)inputPanel(); - return aPanel->deleteEnabled(); + if ( !myPreview.IsNull() ) + { + HYDROGUI_ProfileInterpolateDlg* aDlg = new HYDROGUI_ProfileInterpolateDlg( module(), getName() ); + if ( aDlg && !aDlg->getAISContext().IsNull() ) + { + aDlg->getAISContext()->Remove( myPreview, false ); + myPreview.Nullify(); + } + } + + HYDROGUI_Operation::abortOperation(); } -void HYDROGUI_ProfileInterpolateOp::startOperation() +void HYDROGUI_ProfileInterpolateOp::commitOperation() { - if( myProfile ) - delete myProfile; + if ( !myPreview.IsNull() ) + { + HYDROGUI_ProfileInterpolateDlg* aDlg = new HYDROGUI_ProfileInterpolateDlg( module(), getName() ); + if ( aDlg && !aDlg->getAISContext().IsNull() ) + { + aDlg->getAISContext()->Remove( myPreview, false ); + myPreview.Nullify(); + } + } - myProfile = new HYDROGUI_CurveCreatorProfile(); + HYDROGUI_Operation::commitOperation(); +} + +HYDROGUI_InputPanel* HYDROGUI_ProfileInterpolateOp::createInputPanel() const +{ + HYDROGUI_ProfileInterpolateDlg* aDlg = new HYDROGUI_ProfileInterpolateDlg( module(), getName() ); - HYDROGUI_Operation::startOperation(); + connect( aDlg, SIGNAL( riverChanged( const QString& ) ), this, SLOT( onRiverChanged( const QString& ) ) ); + connect( aDlg, SIGNAL( interpolatorChanged( const QString& ) ), this, SLOT( onInterpolatorChanged( const QString& ) ) ); + connect( aDlg, SIGNAL( interpolatorParametersChanged( const QString& ) ), this, SLOT( updatePreview() ) ); + connect( aDlg, SIGNAL( profileNumberChanged( int ) ), this, SLOT( updatePreview() ) ); + connect( aDlg, SIGNAL( profileStartChanged( const QString& ) ), this, SLOT( updatePreview() ) ); + connect( aDlg, SIGNAL( profileFinishChanged( const QString& ) ), this, SLOT( updatePreview() ) ); - HYDROGUI_ProfileDlg* aPanel = (HYDROGUI_ProfileDlg*)inputPanel(); - aPanel->reset(); + return aDlg; +} - if( myIsEdit ) - myEditedObject = Handle(HYDROData_Profile)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) ); +bool HYDROGUI_ProfileInterpolateOp::processApply( int& theUpdateFlags, QString& theErrorMsg, + QStringList& theBrowseObjectsEntries ) +{ + HYDROGUI_ProfileInterpolateDlg* aDlg = ::qobject_cast( inputPanel() ); + if ( !aDlg ) + return false; - QString aProfileName; - if( !myEditedObject.IsNull() ) - { - Handle(HYDROData_ProfileUZ) aProfileUZ = myEditedObject->GetProfileUZ( false ); - if ( !aProfileUZ.IsNull() ) + QString errMessage; + HYDROData_IProfilesInterpolator* anIterp = interpolator( aDlg->interpolator() ); + if ( anIterp ) { - CurveCreator::Coordinates aCurveCoords; - CurveCreator::SectionsMap aSectionsMap; + updateInterpolator( anIterp ); + Handle(HYDROData_Stream) aRiver = Handle(HYDROData_Stream)::DownCast( HYDROGUI_Tool::FindObjectByName( module(), aDlg->river(), KIND_STREAM ) ); + if ( !aRiver.IsNull() ) + { + startDocOperation(); + aRiver->Interpolate( anIterp ); + if ( anIterp->GetErrorCode() == OK ) + commitDocOperation(); + else + { + errMessage = tr( "CALCULATE_ERROR" ), QString( HYDROGUI_Tool::ToQString( anIterp->GetErrorMessage() ) ); + abortDocOperation(); + } + } + else + errMessage = tr( "CANT_GET_STREAM_OBJECT" ).arg( aDlg->river() ); + + if ( !errMessage.isEmpty() ) + QMessageBox::critical( aDlg->topLevelWidget(), tr( "INTERPOLATION_ERROR" ), errMessage, QMessageBox::Ok ); + else + commit(); + } - HYDROData_ProfileUZ::PointsList aSectPointsList = aProfileUZ->GetPoints(); - CurveCreator::PosPointsList aPoints; - for ( int k = 1, aNbPoints = aSectPointsList.Size(); k <= aNbPoints; ++k ) - { - const HYDROData_ProfileUZ::Point& aSectPoint = aSectPointsList.Value( k ); - aCurveCoords.clear(); - aCurveCoords.push_back( aSectPoint.X() ); - aCurveCoords.push_back( aSectPoint.Y() ); + bool res = errMessage.isEmpty(); - CurveCreator_PosPoint* aPosPoint = new CurveCreator_PosPoint( k, aCurveCoords ); - aPoints.push_back( aPosPoint ); - } + if ( res ) + theUpdateFlags = UF_Model | UF_OCCViewer | UF_OCC_Forced | UF_VTKViewer; - aSectionsMap[0] = aPoints; - myProfile->addPointsInternal( aSectionsMap ); + return res; +} - HYDROData_ProfileUZ::SectionType aSectType = aProfileUZ->GetSectionType( 0 ); +void HYDROGUI_ProfileInterpolateOp::updatePreview() +{ + HYDROGUI_ProfileInterpolateDlg* aDlg = ::qobject_cast( inputPanel() ); + if ( !aDlg ) + return; - CurveCreator::SectionType aCurveType = CurveCreator::Polyline; - if( aSectType == HYDROData_ProfileUZ::SECTION_SPLINE ) - aCurveType = CurveCreator::Spline; + Handle(AIS_InteractiveContext) aCtx = aDlg->getAISContext(); + if ( aCtx.IsNull() ) + return; - myProfile->setSectionType( 0, aCurveType ); - } + if ( !myPreview.IsNull() ) + aCtx->Remove( myPreview, false ); - aProfileName = myEditedObject->GetName(); - } - else - { - aProfileName = HYDROGUI_Tool::GenerateObjectName( module(), tr( "DEFAULT_PROFILE_NAME" ) ); - } + myPreview.Nullify(); - aPanel->setProfileName( aProfileName ); - aPanel->setProfile( myProfile ); - displayPreview(); + HYDROData_IProfilesInterpolator* anIterp = interpolator( aDlg->interpolator() ); + if ( anIterp ) + { + updateInterpolator( anIterp ); + anIterp->Calculate(); + if ( anIterp->GetErrorCode() == OK ) + { + TopoDS_Shape aShape = previewShape( anIterp ); + if ( !aShape.IsNull() ) + { + myPreview = new AIS_Shape( aShape ); + myPreview->SetColor( Quantity_NOC_RED ); + aCtx->Display( myPreview, 1, -1, false ); + } + } + } + + aCtx->UpdateCurrentViewer(); } -void HYDROGUI_ProfileInterpolateOp::abortOperation() +void HYDROGUI_ProfileInterpolateOp::updateInterpolator( HYDROData_IProfilesInterpolator* theInt ) { - erasePreview(); + HYDROGUI_ProfileInterpolateDlg* aDlg = ::qobject_cast( inputPanel() ); + if ( !aDlg || !theInt ) + return; + + theInt->Reset(); + theInt->SetResultProfilesNumber( aDlg->profileNumber() ); + theInt->SetProfiles( profile( aDlg->profileStart() ), profile( aDlg->profileFinish() ) ); + ParamsList aParams = parameters( aDlg->interpolatorParameters() ); + for ( ParamsList::Iterator it = aParams.begin(); it != aParams.end(); ++it ) { + theInt->SetParameter( HYDROGUI_Tool::ToAsciiString( (*it).first ), + HYDROGUI_Tool::ToAsciiString( (*it).second ) ); + } +} - HYDROGUI_Operation::abortOperation(); +HYDROData_Profile::ProfilePoints HYDROGUI_ProfileInterpolateOp::profile( const QString& theName ) const +{ + HYDROData_Profile::ProfilePoints aPoints; + Handle(HYDROData_Profile) aProf = Handle(HYDROData_Profile)::DownCast( HYDROGUI_Tool::FindObjectByName( module(), theName, KIND_PROFILE ) ); + if ( !aProf.IsNull() ) + { + aPoints = aProf->GetProfilePoints(); + } + return aPoints; } -void HYDROGUI_ProfileInterpolateOp::commitOperation() +HYDROGUI_ProfileInterpolateOp::ParamsList HYDROGUI_ProfileInterpolateOp::parameters( const QString& theStr ) const { - erasePreview(); + // Regular expression for parsing parameters string of kind: ..." + // QRegExp rx( "([A-Za-z_\\d]+)\\s+([A-Za-z_\\d]+)\\s*" ); + + // Regular expression for parsing parameters string of kind: = = ..." + QRegExp rx( "([A-Za-z_\\d]+)\\s*=\\s*([A-Za-z_\\d]+)\\s*" ); + + ParamsList aParamList; + for ( int i = 0; i >= 0; ) + { + i = rx.indexIn( theStr, i ); + if ( i >= 0 ) + { + aParamList.append( QPair( rx.cap( 1 ), rx.cap( 2 ) ) ); + i += rx.matchedLength(); + } + } - HYDROGUI_Operation::commitOperation(); + return aParamList; } -HYDROGUI_InputPanel* HYDROGUI_ProfileInterpolateOp::createInputPanel() const +QString HYDROGUI_ProfileInterpolateOp::parameters( const ParamsList& theParamList ) const { - HYDROGUI_ProfileDlg* aDlg = new HYDROGUI_ProfileDlg( module(), getName() ); - return aDlg; + QStringList paramList; + for ( ParamsList::const_iterator it = theParamList.begin(); it != theParamList.end(); ++it ) + paramList.append( QString( "%1 = %2" ).arg( (*it).first ).arg( (*it).second ) ); + return paramList.join( " " ); } -bool HYDROGUI_ProfileInterpolateOp::processApply( int& theUpdateFlags, - QString& theErrorMsg, - QStringList& theBrowseObjectsEntries ) +QStringList HYDROGUI_ProfileInterpolateOp::interpolators() const { - HYDROGUI_ProfileDlg* aPanel = ::qobject_cast( inputPanel() ); - if ( !aPanel ) - return false; - - QString aProfileName = aPanel->getProfileName().simplified(); - if ( aProfileName.isEmpty() ) - { - theErrorMsg = tr( "INCORRECT_OBJECT_NAME" ); - return false; - } - - if( !myIsEdit || ( !myEditedObject.IsNull() && myEditedObject->GetName() != aProfileName ) ) - { - // check that there are no other objects with the same name in the document - Handle(HYDROData_Entity) anObject = HYDROGUI_Tool::FindObjectByName( module(), aProfileName ); - if( !anObject.IsNull() ) + HYDROData_InterpolatorsFactory* anIFactory = 0; + Handle(HYDROData_Document) aDoc = doc(); + if ( !aDoc.IsNull() ) + anIFactory = aDoc->GetInterpolatorsFactory(); + + QStringList aNames; + if ( anIFactory ) { - theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( aProfileName ); - return false; + NCollection_Sequence iNames = anIFactory->GetInterpolatorNames(); + for ( int i = 1, n = iNames.Size(); i <= n; ++i ) { + const TCollection_AsciiString& anInterpName = iNames.Value( i ); + aNames.append( HYDROGUI_Tool::ToQString( anInterpName ) ); + } } - } - - Handle(HYDROData_Profile) aProfileObj; - if( myIsEdit ){ - aProfileObj = myEditedObject; - } - else{ - aProfileObj = Handle(HYDROData_Profile)::DownCast( doc()->CreateObject( KIND_PROFILE ) ); - } - - if( aProfileObj.IsNull() ) - return false; - - Handle(HYDROData_ProfileUZ) aProfileUZ = aProfileObj->GetProfileUZ(); - if ( aProfileUZ.IsNull() ) - return false; - - aProfileObj->SetName(aProfileName); - - HYDROData_ProfileUZ::PointsList aProfileParamPoints; - - CurveCreator::Coordinates aCurveCoords = myProfile->getPoints( 0 ); - if ( aCurveCoords.size() <= 2 ) - { - theErrorMsg = tr( "NUMBER_OF_PROFILE_POINTS_INCORRECT" ); - return false; - } - - for ( int k = 0 ; k + 1 < aCurveCoords.size() ; k++ ) - { - HYDROData_ProfileUZ::Point aProfileParamPoint; - - aProfileParamPoint.SetX( aCurveCoords.at( k ) ); - k++; - aProfileParamPoint.SetY( aCurveCoords.at( k ) ); - - aProfileParamPoints.Append( aProfileParamPoint ); - } - aProfileObj->SetParametricPoints( aProfileParamPoints ); - - HYDROData_ProfileUZ::SectionType aSectType = HYDROData_ProfileUZ::SECTION_POLYLINE; - if ( myProfile->getSectionType( 0 ) == CurveCreator::Spline ) - aSectType = HYDROData_ProfileUZ::SECTION_SPLINE; - - aProfileUZ->SetSectionType( 0, aSectType ); - - if ( !myIsEdit ) - { - aProfileObj->SetBorderColor( HYDROData_Profile::DefaultBorderColor() ); - } - - // At first we update the child u,z profile object - aProfileUZ->SetToUpdate( true ); - aProfileUZ->Update(); - - // And now we update our edited object - aProfileObj->Update(); - module()->setIsToUpdate( aProfileObj ); - - theUpdateFlags = UF_Model; - if ( myIsEdit ) - theUpdateFlags |= UF_OCCViewer | UF_OCC_Forced | UF_VTKViewer; - else - { - QString anEntry = HYDROGUI_DataObject::dataObjectEntry( aProfileObj ); - theBrowseObjectsEntries.append( anEntry ); - } - - return true; + + return aNames; +} + +HYDROData_IProfilesInterpolator* HYDROGUI_ProfileInterpolateOp::interpolator( const QString& theName ) const +{ + HYDROData_InterpolatorsFactory* anIFactory = 0; + Handle(HYDROData_Document) aDoc = doc(); + if ( !aDoc.IsNull() ) + anIFactory = aDoc->GetInterpolatorsFactory(); + + HYDROData_IProfilesInterpolator* aRes = 0; + if ( anIFactory ) + aRes = anIFactory->GetInterpolator( HYDROGUI_Tool::ToAsciiString( theName ) ); + return aRes; } -void HYDROGUI_ProfileInterpolateOp::displayPreview() +TopoDS_Shape HYDROGUI_ProfileInterpolateOp::previewShape( HYDROData_IProfilesInterpolator* theInterp ) const { - HYDROGUI_ProfileDlg* aPanel = dynamic_cast( inputPanel() ); - if( aPanel ) - { - Handle(AIS_InteractiveContext) aCtx = aPanel->getAISContext(); - if( !aCtx.IsNull() ) + TopoDS_Compound aPreviewShape; + if ( theInterp ) { - CurveCreator_Displayer* aDisplayer = new CurveCreator_Displayer( aCtx ); - myProfile->setDisplayer( aDisplayer ); - aDisplayer->display( myProfile->getAISObject( true ), true ); + BRep_Builder aBuilder; + aBuilder.MakeCompound( aPreviewShape ); + for ( int i = 0; i < theInterp->GetCalculatedProfilesNumber(); i++ ) + { + NCollection_Sequence pointSeq = theInterp->GetResultProfilePoints( i ); + + TopoDS_Shape aWire = HYDROData_PolylineXY::BuildWire( HYDROData_IPolyline::SECTION_SPLINE, false, pointSeq ); + if ( !aWire.IsNull() ) + aBuilder.Add( aPreviewShape, aWire ); + } } - } + + return aPreviewShape; +} + +void HYDROGUI_ProfileInterpolateOp::onInterpolatorChanged( const QString& theInterpName ) +{ + HYDROGUI_ProfileInterpolateDlg* aPanel = dynamic_cast( inputPanel() ); + HYDROData_IProfilesInterpolator* anInterp = interpolator( theInterpName ); + if ( !aPanel || !anInterp ) + return; + + aPanel->setInterpolatorDescription( HYDROGUI_Tool::ToQString( anInterp->GetDescription() ) ); + + updatePreview(); } -void HYDROGUI_ProfileInterpolateOp::erasePreview() +void HYDROGUI_ProfileInterpolateOp::onRiverChanged( const QString& theRiver ) { - HYDROGUI_ProfileDlg* aPanel = dynamic_cast( inputPanel() ); - CurveCreator_Displayer* aDisplayer = myProfile ? myProfile->getDisplayer() : 0; - if( aPanel && aDisplayer ) - { - Handle(AIS_InteractiveContext) aCtx = aPanel->getAISContext(); - if( !aCtx.IsNull() ) + HYDROGUI_ProfileInterpolateDlg* aDlg = ::qobject_cast( inputPanel() ); + if ( !aDlg ) + return; + + Handle(AIS_InteractiveContext) aCtx = aDlg->getAISContext(); + if ( !aCtx.IsNull() ) { - aDisplayer->eraseAll( true ); + AIS_ListOfInteractive aList; + aCtx->DisplayedObjects( aList ); + for ( AIS_ListIteratorOfListOfInteractive it( aList ); it.More(); it.Next() ) + { + Handle(AIS_Shape) anObj = Handle(AIS_Shape)::DownCast( it.Value() ); + if ( !anObj.IsNull() ) + aCtx->Remove( anObj, false ); + } + + Handle(HYDROData_Stream) aStream = Handle(HYDROData_Stream)::DownCast( HYDROGUI_Tool::FindObjectByName( module(), theRiver, KIND_STREAM ) ); + if ( !aStream.IsNull() ) + { + HYDROData_SequenceOfObjects aSeq = aStream->GetProfiles(); + for ( int i = aSeq.Lower(); i <= aSeq.Upper(); i++ ) + { + Handle(HYDROData_Profile) aProfile = Handle(HYDROData_Profile)::DownCast( aSeq.Value( i ) ); + if ( !aProfile.IsNull() ) + { + Handle(AIS_Shape) aPrs = new AIS_Shape( aProfile->GetShape3D() ); + aPrs->SetOwner( aProfile ); + aPrs->SetColor( Quantity_NOC_BLACK ); + aCtx->Display( aPrs, 1, 0, false ); + } + } + OCCViewer_ViewManager* vm = aDlg->viewManager(); + if ( vm ) + { + QVector winList = vm->getViews(); + for ( QVector::iterator it = winList.begin(); it != winList.end(); ++it ) + { + OCCViewer_ViewWindow* occWin = ::qobject_cast( *it ); + if ( occWin ) + { + OCCViewer_ViewPort3d* vp = occWin->getViewPort(); + if ( vp ) + vp->fitAll(); + } + } + } + } } - } + updatePreview(); }