X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_ImportImageOp.cxx;h=ca37f4a5fc8e7eb6643c2da40af972d2814b9f36;hb=5cae7e874afd2fc1b6f61023e8ebd33a933db3c7;hp=f2835a47f0ba2988f4e1eded84c7f41268926304;hpb=efb4364f3d91fb7106136328dec46c9e376d2144;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx index f2835a47..ca37f4a5 100644 --- a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx +++ b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx @@ -30,8 +30,9 @@ #include "HYDROGUI_UpdateFlags.h" #include - -#include +#include +#include +#include #include #include @@ -40,6 +41,11 @@ #include #include +#include +#include +#include +#include + HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule, const bool theIsEdit ) : HYDROGUI_Operation( theModule ), @@ -47,6 +53,7 @@ HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule, myEditedObject( 0 ), myActiveViewManager( 0 ), myPreviewViewManager( 0 ), + myRefViewManager( 0 ), myPreviewPrs( 0 ), myRefPreviewPrs( 0 ), myPointType( HYDROGUI_PrsImage::None ) @@ -66,17 +73,18 @@ void HYDROGUI_ImportImageOp::startOperation() aPanel->reset(); aPanel->setIsEdit( myIsEdit ); + QString aRefImageName; + if( myIsEdit ) { myEditedObject = Handle(HYDROData_Image)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) ); if( !myEditedObject.IsNull() ) { QImage anImage = myEditedObject->Image(); + bool anIsByTwoPoints = myEditedObject->IsByTwoPoints(); - QPoint aPointA1, aPointB1, aPointC1; - QPointF aPointA2, aPointB2, aPointC2; - myEditedObject->TrsfPoints( aPointA1, aPointB1, aPointC1, - aPointA2, aPointB2, aPointC2 ); + QPoint aLocalPointA, aLocalPointB, aLocalPointC; + myEditedObject->GetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC ); onCreatePreview( anImage ); @@ -86,21 +94,66 @@ void HYDROGUI_ImportImageOp::startOperation() myPreviewPrs->getTransformationPointMap(); if( !aPointMap.isEmpty() ) { - aPointMap[ HYDROGUI_PrsImage::PointA ].Point = aPointA1; - aPointMap[ HYDROGUI_PrsImage::PointB ].Point = aPointB1; - aPointMap[ HYDROGUI_PrsImage::PointC ].Point = aPointC1; + aPointMap[ HYDROGUI_PrsImage::PointA ].Point = aLocalPointA; + aPointMap[ HYDROGUI_PrsImage::PointB ].Point = aLocalPointB; + if ( !anIsByTwoPoints ) + aPointMap[ HYDROGUI_PrsImage::PointC ].Point = aLocalPointC; + myPreviewPrs->setTransformationPointMap( aPointMap ); } } + HYDROData_Image::TransformationMode aTrsfMode; + QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC; + myEditedObject->GetGlobalPoints( aTrsfMode, + aTrsfPointA, aTrsfPointB, aTrsfPointC ); + HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap; - aDataMap[ HYDROGUI_PrsImage::PointA ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointA1, aPointA2 ); + aDataMap[ HYDROGUI_PrsImage::PointA ] = + HYDROGUI_ImportImageDlg::ComputeTrsfData( aTrsfMode, aLocalPointA, aTrsfPointA ); aDataMap[ HYDROGUI_PrsImage::PointB ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointB1, aPointB2 ); - aDataMap[ HYDROGUI_PrsImage::PointC ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointC1, aPointC2 ); - ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setTransformationDataMap( aDataMap ); + HYDROGUI_ImportImageDlg::ComputeTrsfData( aTrsfMode, aLocalPointB, aTrsfPointB ); + if ( !anIsByTwoPoints ) + aDataMap[ HYDROGUI_PrsImage::PointC ] = + HYDROGUI_ImportImageDlg::ComputeTrsfData( aTrsfMode, aLocalPointC, aTrsfPointC ); + + aPanel->setTransformationMode( aTrsfMode ); + aPanel->setTransformationDataMap( aDataMap ); + aPanel->setByTwoPoints( anIsByTwoPoints ); + + // Set points on reference image + if ( aTrsfMode = HYDROData_Image::ReferenceImage ) + { + Handle(HYDROData_Image) aRefImage = myEditedObject->GetTrsfReferenceImage(); + if ( !aRefImage.IsNull() ) + { + aRefImageName = aRefImage->GetName(); + + onRefImageActivated( aRefImageName ); + if( myRefPreviewPrs ) + { + HYDROGUI_PrsImage::TransformationPointMap aRefPointMap = + myRefPreviewPrs->getTransformationPointMap(); + if( !aRefPointMap.isEmpty() ) + { + aRefPointMap[ HYDROGUI_PrsImage::PointA ].Point = aTrsfPointA.toPoint(); + aRefPointMap[ HYDROGUI_PrsImage::PointB ].Point = aTrsfPointB.toPoint(); + if ( !anIsByTwoPoints ) + aRefPointMap[ HYDROGUI_PrsImage::PointC ].Point = aTrsfPointC.toPoint(); + + myRefPreviewPrs->setTransformationPointMap( aRefPointMap ); + } + } + + HYDROGUI_ImportImageDlg::TransformationDataMap aRefDataMap; + aRefDataMap[ HYDROGUI_PrsImage::PointA ] = HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointA.toPoint() ); + aRefDataMap[ HYDROGUI_PrsImage::PointB ] = HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointB.toPoint() ); + if ( !anIsByTwoPoints ) + aRefDataMap[ HYDROGUI_PrsImage::PointC ] = HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointC.toPoint() ); + + aPanel->setTransformationDataMap( aRefDataMap, true, true ); + } + } } } @@ -112,27 +165,32 @@ void HYDROGUI_ImportImageOp::startOperation() Handle(HYDROData_Image) anImageObj = Handle(HYDROData_Image)::DownCast( anIterator.Current() ); if( !anImageObj.IsNull() ) { - if( myIsEdit && HYDROGUI_Tool::IsEqual( anImageObj, myEditedObject ) ) + if( myIsEdit && IsEqual( anImageObj, myEditedObject ) ) continue; - QPoint aPointA1, aPointB1, aPointC1; - QPointF aPointA2, aPointB2, aPointC2; - anImageObj->TrsfPoints( aPointA1, aPointB1, aPointC1, - aPointA2, aPointB2, aPointC2 ); + QPoint aLocalPointA, aLocalPointB, aLocalPointC; + anImageObj->GetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC ); + + HYDROData_Image::TransformationMode aImgTrsfMode; + QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC; + anImageObj->GetGlobalPoints( aImgTrsfMode, + aTrsfPointA, aTrsfPointB, aTrsfPointC ); HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap; - aDataMap[ HYDROGUI_PrsImage::PointA ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointA1, aPointA2 ); + aDataMap[ HYDROGUI_PrsImage::PointA ] = + HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointA, aTrsfPointA ); aDataMap[ HYDROGUI_PrsImage::PointB ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointB1, aPointB2 ); + HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointB, aTrsfPointB ); aDataMap[ HYDROGUI_PrsImage::PointC ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointC1, aPointC2 ); + HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointC, aTrsfPointC ); HYDROGUI_ImportImageDlg::PrsPointData aPrsPointData( anImageObj->GetName(), aDataMap ); aPrsPointDataList.append( aPrsPointData ); } } - ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setPrsPointDataList( aPrsPointDataList ); + + aPanel->setPrsPointDataList( aPrsPointDataList ); + aPanel->setRefImageName( aRefImageName ); } void HYDROGUI_ImportImageOp::abortOperation() @@ -158,11 +216,64 @@ HYDROGUI_InputPanel* HYDROGUI_ImportImageOp::createInputPanel() const this, SLOT( onActivatePointSelection( int ) ) ); connect( aPanel, SIGNAL( pointCoordChanged( bool, int, bool, int ) ), this, SLOT( onPointCoordChanged( bool, int, bool, int ) ) ); + connect( aPanel, SIGNAL( modeActivated( int ) ), + this, SLOT( onModeActivated( int ) ) ); connect( aPanel, SIGNAL( refImageActivated( const QString& ) ), this, SLOT( onRefImageActivated( const QString& ) ) ); return aPanel; } +bool HYDROGUI_ImportImageOp::checkPoints( const QPointF& thePointA, + const QPointF& thePointB, + const QPointF& thePointC, + const bool theIsByTwoPoints, + const QString& theLineErrMsg, + const QString& thePoinErrMsg, + QString& theErrorMsg, + const bool theIsToCheckInvertibles ) const +{ + double xa = thePointA.x(); + double ya = thePointA.y(); + double xb = thePointB.x(); + double yb = thePointB.y(); + double xc = thePointC.x(); + double yc = thePointC.y(); + + if ( !theIsByTwoPoints ) + { + // check that three input points don't belong to a single line + if ( ValuesEquals( ( yb - ya ) * ( xc - xa ), ( yc - ya ) * ( xb - xa ) ) ) + { + theErrorMsg = theLineErrMsg; + return false; + } + } + else + { + // check that two points are not identical + if ( ValuesEquals( xa, ya ) && ValuesEquals( xb, yb ) ) + { + theErrorMsg = thePoinErrMsg; + return false; + } + } + + if ( theIsToCheckInvertibles ) + { + QTransform aTransform1( xa, ya, 1, xb, yb, 1, xc, yc, 1 ); + + bool anIsInvertible = false; + QTransform aTransform1Inverted = aTransform1.inverted( &anIsInvertible ); + if( !anIsInvertible ) + { + theErrorMsg = tr( "TRANSFORMATION_MATRIX_CANNOT_BE_COMPUTED" ); + return false; + } + } + + return true; +} + bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, QString& theErrorMsg ) { @@ -175,7 +286,7 @@ bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, if( !myIsEdit || ( !myEditedObject.IsNull() && myEditedObject->GetName() != anImageName ) ) { // check that there are no other objects with the same name in the document - Handle(HYDROData_Object) anObject = HYDROGUI_Tool::FindObjectByName( module(), anImageName ); + Handle(HYDROData_Entity) anObject = HYDROGUI_Tool::FindObjectByName( module(), anImageName ); if( !anObject.IsNull() ) { theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( anImageName ); @@ -183,98 +294,76 @@ bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, } } - if( !myPreviewPrs ) - return false; - - QImage anImage = myPreviewPrs->getImage(); - - bool anIsRefImage = aPanel->getTransformationMode() == HYDROGUI_ImportImageDlg::RefImage; - - QTransform aRefTransform; - if( anIsRefImage && myRefPreviewPrs ) - { - Handle(HYDROData_Image) aRefImageObj = - Handle(HYDROData_Image)::DownCast( myRefPreviewPrs->getObject() ); - if( !aRefImageObj.IsNull() ) - aRefTransform = aRefImageObj->Trsf(); - } - HYDROGUI_ImportImageDlg::TransformationDataMap aMap; if( !aPanel->getTransformationDataMap( aMap ) ) return false; - HYDROGUI_ImportImageDlg::TransformationDataMap aRefMap; - if( anIsRefImage && !aPanel->getTransformationDataMap( aRefMap, true ) ) - return false; + bool anIsByTwoPoints = aPanel->isByTwoPoints(); - QPoint aPointA1 = aMap[ HYDROGUI_PrsImage::PointA ].first; - QPoint aPointB1 = aMap[ HYDROGUI_PrsImage::PointB ].first; - QPoint aPointC1 = aMap[ HYDROGUI_PrsImage::PointC ].first; + QPoint aPointA = aMap[ HYDROGUI_PrsImage::PointA ].ImagePoint; + QPoint aPointB = aMap[ HYDROGUI_PrsImage::PointB ].ImagePoint; + QPoint aPointC = anIsByTwoPoints ? QPoint( INT_MIN, INT_MIN ) : + aMap[ HYDROGUI_PrsImage::PointC ].ImagePoint; - QPointF aPointA2 = aMap[ HYDROGUI_PrsImage::PointA ].second; - QPointF aPointB2 = aMap[ HYDROGUI_PrsImage::PointB ].second; - QPointF aPointC2 = aMap[ HYDROGUI_PrsImage::PointC ].second; + // first, we check correctness of image points + if ( !checkPoints( aPointA, aPointB, aPointC, anIsByTwoPoints, + tr( "POINTS_A_B_C_BELONG_TO_SINGLE_LINE" ), + tr( "POINTS_A_B_ARE_IDENTICAL" ), + theErrorMsg, true ) ) + return false; - QPoint aPointA3, aPointB3, aPointC3; - if( anIsRefImage ) - { - aPointA3 = aRefMap[ HYDROGUI_PrsImage::PointA ].first; - aPointB3 = aRefMap[ HYDROGUI_PrsImage::PointB ].first; - aPointC3 = aRefMap[ HYDROGUI_PrsImage::PointC ].first; - } + Handle(HYDROData_Image) aRefImageObj; + QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC( INT_MIN, INT_MIN ); - int xa1 = aPointA1.x(); - int ya1 = aPointA1.y(); - int xb1 = aPointB1.x(); - int yb1 = aPointB1.y(); - int xc1 = aPointC1.x(); - int yc1 = aPointC1.y(); - - double xa2 = aPointA2.x(); - double ya2 = aPointA2.y(); - double xb2 = aPointB2.x(); - double yb2 = aPointB2.y(); - double xc2 = aPointC2.x(); - double yc2 = aPointC2.y(); - - int xa3 = aPointA3.x(); - int ya3 = aPointA3.y(); - int xb3 = aPointB3.x(); - int yb3 = aPointB3.y(); - int xc3 = aPointC3.x(); - int yc3 = aPointC3.y(); - - // first, check that three input points don't belong to a single line - if( ( yb1 - ya1 ) * ( xc1 - xa1 ) == ( yc1 - ya1 ) * ( xb1 - xa1 ) ) + HYDROData_Image::TransformationMode aTransformationMode = + (HYDROData_Image::TransformationMode)aPanel->getTransformationMode(); + if ( aTransformationMode == HYDROData_Image::ReferenceImage ) { - theErrorMsg = tr( "POINTS_A_B_C_BELONG_TO_SINGLE_LINE" ); - return false; - } + QString aRefImageName = aPanel->getRefImageName(); + if( aRefImageName.isEmpty() ) + { + theErrorMsg = tr( "REFERENCE_IMAGE_IS_NOT_SELECTED" ); + return false; + } - // the same check for the reference points - if( anIsRefImage && ( ( yb3 - ya3 ) * ( xc3 - xa3 ) == ( yc3 - ya3 ) * ( xb3 - xa3 ) ) ) - { - theErrorMsg = tr( "REFERENCE_POINTS_A_B_C_BELONG_TO_SINGLE_LINE" ); - return false; - } + HYDROGUI_ImportImageDlg::TransformationDataMap aRefMap; + if( !aPanel->getTransformationDataMap( aRefMap, true ) ) + return false; - QTransform aTransform1( xa1, ya1, 1, xb1, yb1, 1, xc1, yc1, 1 ); - QTransform aTransform2( xa2, ya2, 1, xb2, yb2, 1, xc2, yc2, 1 ); - QTransform aTransform3( xa3, ya3, 1, xb3, yb3, 1, xc3, yc3, 1 ); + aRefImageObj = Handle(HYDROData_Image)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aRefImageName, KIND_IMAGE ) ); + if( aRefImageObj.IsNull() ) + return false; - bool anIsInvertible = false; - QTransform aTransform1Inverted = aTransform1.inverted( &anIsInvertible ); - if( !anIsInvertible ) - { - theErrorMsg = tr( "TRANSFORMATION_MATRIX_CANNOT_BE_COMPUTED" ); - return false; - } + aTrsfPointA = aRefMap[ HYDROGUI_PrsImage::PointA ].ImagePoint; + aTrsfPointB = aRefMap[ HYDROGUI_PrsImage::PointB ].ImagePoint; + if ( !anIsByTwoPoints ) + aTrsfPointC = aRefMap[ HYDROGUI_PrsImage::PointC ].ImagePoint; - QTransform aTransform; - if( anIsRefImage ) - aTransform = aTransform1Inverted * aTransform3 * aRefTransform; + // the same check of correctness for the reference points + if ( !checkPoints( aTrsfPointA, aTrsfPointB, aTrsfPointC, anIsByTwoPoints, + tr( "REFERENCE_POINTS_A_B_C_BELONG_TO_SINGLE_LINE" ), + tr( "REFERENCE_POINTS_A_B_ARE_IDENTICAL" ), + theErrorMsg, false ) ) + return false; + } else - aTransform = aTransform1Inverted * aTransform2; + { + if ( aTransformationMode == HYDROData_Image::ManualLambert ) + { + aTrsfPointA = aMap[ HYDROGUI_PrsImage::PointA ].LambertPoint; + aTrsfPointB = aMap[ HYDROGUI_PrsImage::PointB ].LambertPoint; + if ( !anIsByTwoPoints ) + aTrsfPointC = aMap[ HYDROGUI_PrsImage::PointC ].LambertPoint; + } + else + { + aTrsfPointA = aMap[ HYDROGUI_PrsImage::PointA ].CartesianPoint; + aTrsfPointB = aMap[ HYDROGUI_PrsImage::PointB ].CartesianPoint; + if ( !anIsByTwoPoints ) + aTrsfPointC = aMap[ HYDROGUI_PrsImage::PointC ].CartesianPoint; + } + } Handle(HYDROData_Image) anImageObj; if( myIsEdit ) @@ -286,20 +375,27 @@ bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, return false; anImageObj->SetName( anImageName ); + anImageObj->SetImage( myImage ); + anImageObj->SetLocalPoints( aPointA, aPointB, aPointC ); - anImageObj->SetImage( anImage ); - anImageObj->SetTrsf( aTransform ); - - if( anIsRefImage ) + if ( aTransformationMode == HYDROData_Image::ReferenceImage ) { - aPointA2 = QPointF( aTransform.map( aPointA1 ) ); - aPointB2 = QPointF( aTransform.map( aPointB1 ) ); - aPointC2 = QPointF( aTransform.map( aPointC1 ) ); + anImageObj->SetReferencePoints( aRefImageObj, + aTrsfPointA, aTrsfPointB, aTrsfPointC ); + } + else + { + anImageObj->SetGlobalPoints( aTransformationMode, + aTrsfPointA, aTrsfPointB, aTrsfPointC ); } - anImageObj->SetTrsfPoints( aPointA1, aPointB1, aPointC1, - aPointA2, aPointB2, aPointC2 ); - + if( !myIsEdit ) + { + // Set imported file name for image + QString aFilePath = aPanel->getFileName(); + anImageObj->SetFilePath( aFilePath ); + } + // must be done after all checks and before calling SetVisible() method below closePreview(); @@ -307,58 +403,82 @@ bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, module()->setObjectVisible( HYDROGUI_Tool::GetActiveGraphicsViewId( module() ), anImageObj, true ); if( myIsEdit ) - if( HYDROOperations_Factory* aFactory = HYDROOperations_Factory::Factory() ) - aFactory->UpdateImage( doc(), anImageObj ); + anImageObj->Update(); - theUpdateFlags = UF_Model | UF_Viewer | UF_GV_Forced; + theUpdateFlags = UF_Model | UF_Viewer | UF_GV_Forced | UF_OCCViewer | UF_OCC_Forced; return true; } void HYDROGUI_ImportImageOp::onCreatePreview( QImage theImage ) { - LightApp_Application* anApp = module()->getApp(); + HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); - myActiveViewManager = anApp->activeViewManager(); + myImage = theImage; - myPreviewPrs = new HYDROGUI_PrsImage( myIsEdit ? myEditedObject : 0 ); - myPreviewPrs->setImage( theImage ); - myPreviewPrs->compute(); + if( myPreviewPrs ) // if the image is changed by choosing another file + { + myPreviewPrs->setImage( myImage ); + myPreviewPrs->compute(); - myPreviewViewManager = - dynamic_cast( anApp->createViewManager( GraphicsView_Viewer::Type() ) ); - if( myPreviewViewManager ) + if( myPreviewViewManager ) + { + if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() ) + { + if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() ) + { + aViewPort->onBoundingRectChanged(); + aViewPort->fitAll(); + } + } + } + } + else { - module()->setViewManagerRole( myPreviewViewManager, HYDROGUI_Module::VMR_TransformImage ); - myPreviewViewManager->setTitle( tr( "TRANSFORM_IMAGE" ) ); - if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() ) + LightApp_Application* anApp = module()->getApp(); + + myActiveViewManager = anApp->activeViewManager(); + + myPreviewPrs = new HYDROGUI_PrsImage( myIsEdit ? myEditedObject : 0 ); + myPreviewPrs->setImage( myImage ); + myPreviewPrs->compute(); + + myPreviewViewManager = + dynamic_cast( anApp->createViewManager( GraphicsView_Viewer::Type() ) ); + if( myPreviewViewManager ) { - if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() ) + connect( myPreviewViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ), + this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) ); + + module()->setViewManagerRole( myPreviewViewManager, HYDROGUI_Module::VMR_TransformImage ); + myPreviewViewManager->setTitle( tr( "TRANSFORM_IMAGE" ) ); + if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() ) { - //aViewPort->setMousePositionEnabled( true ); //ouv: temporarily commented + if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() ) + { + //aViewPort->setMousePositionEnabled( true ); //ouv: temporarily commented - aViewPort->addItem( myPreviewPrs ); - aViewPort->fitAll(); + aViewPort->addItem( myPreviewPrs ); + aViewPort->fitAll(); - myPreviewPrs->setIsTransformationPointPreview( true ); + myPreviewPrs->setIsTransformationPointPreview( true ); + } + connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ), + this, SLOT( onPointSelected() ) ); } - connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ), - this, SLOT( onPointSelected() ) ); } - } - HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); - - QString anImageName; - if( myIsEdit ) - { - if( !myEditedObject.IsNull() ) - anImageName = myEditedObject->GetName(); + QString anImageName; + if( myIsEdit ) + { + if( !myEditedObject.IsNull() ) + anImageName = myEditedObject->GetName(); + } + else + anImageName = HYDROGUI_Tool::GenerateObjectName( module(), "Image" ); + aPanel->setImageName( anImageName ); } - else - anImageName = HYDROGUI_Tool::GenerateObjectName( module(), "Image" ); - aPanel->setImageName( anImageName ); - aPanel->setImageSize( theImage.size() ); + aPanel->setImageSize( myImage.size() ); aPanel->initializePointSelection(); onPointSelected( false ); @@ -384,21 +504,77 @@ void HYDROGUI_ImportImageOp::onPointCoordChanged( bool theIsRef, myRefPreviewPrs->updateTransformationPoint( thePointType, theIsY, theValue ); } +void HYDROGUI_ImportImageOp::onModeActivated( int theMode ) +{ + HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); + + QString aRefImageName; + if( theMode == HYDROData_Image::ReferenceImage ) + { + aRefImageName = aPanel->getRefImageName(); + if( aRefImageName.isEmpty() ) + return; // do nothing in this case to avoid visual moving of preview prs + onRefImageActivated( aRefImageName ); + } + else + { + if( myRefViewManager ) + { + closeView( myRefViewManager ); + } + } +} + void HYDROGUI_ImportImageOp::onRefImageActivated( const QString& theName ) { GraphicsView_ViewPort* aViewPort = 0; - if( myPreviewViewManager ) - if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() ) + + LightApp_Application* anApp = module()->getApp(); + ///// Get a view port for the reference image preview + if( myRefViewManager ) + { + if( GraphicsView_Viewer* aViewer = myRefViewManager->getViewer() ) + { aViewPort = aViewer->getActiveViewPort(); + } + } + else + { + anApp = module()->getApp(); + // Init reference image preview + myRefViewManager = + dynamic_cast( anApp->createViewManager( GraphicsView_Viewer::Type() ) ); + if( myRefViewManager ) + { + connect( myRefViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ), + this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) ); + + module()->setViewManagerRole( myRefViewManager, HYDROGUI_Module::VMR_ReferenceImage ); + myRefViewManager->setTitle( tr( "REFERENCE_IMAGE" ) ); + if( GraphicsView_Viewer* aViewer = myRefViewManager->getViewer() ) + { + aViewPort = aViewer->getActiveViewPort(); + connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ), + this, SLOT( onRefPointSelected() ) ); + } + } + } + qApp->processEvents(); if( !aViewPort ) return; - aViewPort->removeItem( myRefPreviewPrs ); + // Remove the old presentation of the reference image if any + if( myRefPreviewPrs ) + { + myRefPreviewPrs->setCaption( QString() ); + aViewPort->removeItem( myRefPreviewPrs ); - delete myRefPreviewPrs; - myRefPreviewPrs = 0; + delete myRefPreviewPrs; + myRefPreviewPrs = 0; + } + // Create a new reference image presentation QImage anImage; Handle(HYDROData_Image) anImageObj = Handle(HYDROData_Image)::DownCast( HYDROGUI_Tool::FindObjectByName( module(), theName, KIND_IMAGE ) ); @@ -413,31 +589,44 @@ void HYDROGUI_ImportImageOp::onRefImageActivated( const QString& theName ) myRefPreviewPrs->setIsTransformationPointPreview( true ); myRefPreviewPrs->setTransformationPointType( myPointType ); - // vertically shift the reference prs relatively to the main prs - if( myPreviewPrs ) - { - QImage anImage = myPreviewPrs->getImage(); - myRefPreviewPrs->moveBy( 0, anImage.height() + 20 ); - } - + // Add the new reference image presentation to the appropriate view aViewPort->addItem( myRefPreviewPrs ); } aViewPort->fitAll(); - HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); + // Split views horizontally + if( anApp->desktop()->inherits( "STD_TabDesktop" ) ) + { + QtxWorkstack* aWorkstack = ( (STD_TabDesktop*)anApp->desktop() )->workstack(); + aViewPort->activateWindow(); + aViewPort->show(); + aViewPort->setFocus(Qt::ActiveWindowFocusReason); + aWorkstack->splitHorizontal(); + } + // Initialize the dialog + HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); aPanel->setImageSize( anImage.size(), true ); - aPanel->initializePointSelection(); onPointSelected( true ); } +void HYDROGUI_ImportImageOp::onLastViewClosed( SUIT_ViewManager* theViewManager ) +{ + closePreview(); +} + void HYDROGUI_ImportImageOp::onPointSelected() { onPointSelected( myRefPreviewPrs && myRefPreviewPrs->isSelected() ); } +void HYDROGUI_ImportImageOp::onRefPointSelected() +{ + onPointSelected( true ); +} + void HYDROGUI_ImportImageOp::onPointSelected( bool theIsRefImage ) { HYDROGUI_PrsImage* aPrs = theIsRefImage ? myRefPreviewPrs : myPreviewPrs; @@ -455,7 +644,7 @@ void HYDROGUI_ImportImageOp::onPointSelected( bool theIsRefImage ) const HYDROGUI_PrsImage::TransformationPoint& aTransformationPoint = anIter.value(); const QPoint& aPoint = aTransformationPoint.Point; - HYDROGUI_ImportImageDlg::TransformationData aData( aPoint, QPointF() ); + HYDROGUI_ImportImageDlg::TransformationData aData( aPoint, QPointF(), QPointF() ); aDataMap[ aPointType ] = aData; } @@ -464,24 +653,47 @@ void HYDROGUI_ImportImageOp::onPointSelected( bool theIsRefImage ) void HYDROGUI_ImportImageOp::closePreview() { - if( myPreviewPrs ) - { - delete myPreviewPrs; - myPreviewPrs = 0; - } + closeView( myPreviewViewManager ); + closeView( myRefViewManager ); - if( myRefPreviewPrs ) - { - delete myRefPreviewPrs; - myRefPreviewPrs = 0; - } + if( myActiveViewManager ) + HYDROGUI_Tool::SetActiveViewManager( module(), myActiveViewManager ); +} - if( myPreviewViewManager ) +void HYDROGUI_ImportImageOp::closeView( GraphicsView_ViewManager* &aViewMgr ) +{ + if( aViewMgr ) { - module()->getApp()->removeViewManager( myPreviewViewManager ); // myPreviewViewManager is deleted here - myPreviewViewManager = 0; - } + GraphicsView_ViewPort* aViewPort = 0; + if( GraphicsView_Viewer* aViewer = aViewMgr->getViewer() ) + { + aViewPort = aViewer->getActiveViewPort(); + } + disconnect( aViewMgr, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ), + this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) ); - if( myActiveViewManager ) - HYDROGUI_Tool::SetActiveViewManager( module(), myActiveViewManager ); + // Nullify appropriate presentation pointer + HYDROGUI_PrsImage* aPrs = 0; + switch ( module()->getViewManagerRole( aViewMgr ) ) + { + case HYDROGUI_Module::VMR_ReferenceImage: + aPrs = myRefPreviewPrs; + myRefPreviewPrs = 0; + break; + case HYDROGUI_Module::VMR_TransformImage: + aPrs = myPreviewPrs; + myPreviewPrs = 0; + } + + // Remove the appropriate presentation from the view + if( aPrs && aViewPort ) + { + aViewPort->removeItem( aPrs ); + delete aPrs; + } + + // Delete the view + module()->getApp()->removeViewManager( aViewMgr ); // aViewMgr is deleted here + aViewMgr = 0; + } }