X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_ImportImageOp.cxx;h=625d263612f4ab2b9f8578523314c326200820c8;hb=17f7f1768ec576845662eba383627385c46d718e;hp=d86e4cfccfba84bea0b75fe9da9168f9514d26a6;hpb=b475ac9f5ce7ab52045e70fec0c8e6f8ffb51432;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx index d86e4cfc..625d2636 100644 --- a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx +++ b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx @@ -29,7 +29,8 @@ #include "HYDROGUI_Tool.h" #include "HYDROGUI_UpdateFlags.h" -#include +#include +#include #include #include @@ -38,6 +39,13 @@ #include #include +#include +#include +#include +#include +#include +#include + HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule, const bool theIsEdit ) : HYDROGUI_Operation( theModule ), @@ -45,10 +53,12 @@ HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule, myEditedObject( 0 ), myActiveViewManager( 0 ), myPreviewViewManager( 0 ), + myRefViewManager( 0 ), myPreviewPrs( 0 ), + myRefPreviewPrs( 0 ), myPointType( HYDROGUI_PrsImage::None ) { - setName( theIsEdit ? tr( "EDIT_IMAGE" ) : tr( "IMPORT_IMAGE" ) ); + setName( theIsEdit ? tr( "EDIT_IMPORTED_IMAGE" ) : tr( "IMPORT_IMAGE" ) ); } HYDROGUI_ImportImageOp::~HYDROGUI_ImportImageOp() @@ -63,45 +73,181 @@ 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 ); + // Create the edited image preview presentation in the viewer onCreatePreview( anImage ); - if( myPreviewPrs ) + // Set transformation local points A,B,C to the image preview presentation + setPresentationTrsfPoints( myPreviewPrs, anIsByTwoPoints, aLocalPointA, + aLocalPointB, aLocalPointC ); + + // Build the existing image local and global points mapping + // according to the current transformation mode. + HYDROData_Image::TransformationMode aTrsfMode = myEditedObject->GetTrsfMode(); + QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC; + HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap; + if ( aTrsfMode == HYDROData_Image::ReferenceImage ) { - HYDROGUI_PrsImage::TransformationPointMap aPointMap = - myPreviewPrs->getTransformationPointMap(); - if( !aPointMap.isEmpty() ) + // Compute global points using the transformation matrix of the reference image + Handle(HYDROData_Image) aRefImage = myEditedObject->GetTrsfReferenceImage(); + if ( !aRefImage.IsNull() ) { - aPointMap[ HYDROGUI_PrsImage::PointA ].Point = aPointA1; - aPointMap[ HYDROGUI_PrsImage::PointB ].Point = aPointB1; - aPointMap[ HYDROGUI_PrsImage::PointC ].Point = aPointC1; - myPreviewPrs->setTransformationPointMap( aPointMap ); + QTransform aRefTrsf = aRefImage->Trsf(); // The reference image transformation matrix + aTrsfPointA = aRefTrsf.map( aLocalPointA ); // Compute the global point A + aTrsfPointB = aRefTrsf.map( aLocalPointB ); // Compute the global point B + if ( !anIsByTwoPoints ) + { + aTrsfPointC = aRefTrsf.map( aLocalPointC ); // Compute the global point C if used + } + // Build the local-global points map + // Use the reference image transformation mode for interpreting global points + computeTrsfData( aRefImage->GetTrsfMode(), anIsByTwoPoints, aLocalPointA, aLocalPointB, aLocalPointC, + aTrsfPointA, aTrsfPointB, aTrsfPointC, aDataMap ); } } + else + { + // Get global points from the edited image + myEditedObject->GetGlobalPoints( aTrsfMode, aTrsfPointA, aTrsfPointB, aTrsfPointC ); + // Build the local-global points map + computeTrsfData( aTrsfMode, anIsByTwoPoints, aLocalPointA, aLocalPointB, aLocalPointC, + aTrsfPointA, aTrsfPointB, aTrsfPointC, aDataMap ); + } + + // Initialize the dialog mode, local and global coordinates + // except coordinates on the reference image + aPanel->setTransformationMode( aTrsfMode ); + aPanel->setTransformationDataMap( aDataMap ); + aPanel->setByTwoPoints( anIsByTwoPoints ); + + // Set points of the reference image + if ( aTrsfMode == HYDROData_Image::ReferenceImage ) + { + Handle(HYDROData_Image) aRefImage; + myEditedObject->GetReferencePoints( aRefImage, + aTrsfPointA, aTrsfPointB, aTrsfPointC ); + if ( !aRefImage.IsNull() ) + { + aRefImageName = aRefImage->GetName(); + + // Create the reference image presentation in the viewer + onRefImageActivated( aRefImageName ); + + // Set transformation points A,B,C to the reference image presentation + setPresentationTrsfPoints( myRefPreviewPrs, anIsByTwoPoints, aTrsfPointA.toPoint(), + aTrsfPointB.toPoint(), aTrsfPointC.toPoint() ); + + // Prepare A, B, C points on the reference image + 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() ); + + // Initialize the dialog's A, B, C points coordinates of the reference image + aPanel->setTransformationDataMap( aRefDataMap, true, true ); + } + } + } + } + + // Collect information about existing images and initialize the combobox + // reference image selector in the dialog. + HYDROGUI_ImportImageDlg::PrsPointDataList aPrsPointDataList; + HYDROData_Iterator anIterator( doc(), KIND_IMAGE ); + for( ; anIterator.More(); anIterator.Next() ) + { + Handle(HYDROData_Image) anImageObj = Handle(HYDROData_Image)::DownCast( anIterator.Current() ); + if( !anImageObj.IsNull() ) + { + if( myIsEdit && IsEqual( anImageObj, myEditedObject ) ) + continue; + + 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::PointB ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointB1, aPointB2 ); - aDataMap[ HYDROGUI_PrsImage::PointC ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointC1, aPointC2 ); - ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setTransformationDataMap( aDataMap ); + computeTrsfData( aImgTrsfMode, false, aLocalPointA, aLocalPointB, aLocalPointC, + aTrsfPointA, aTrsfPointB, aTrsfPointC, aDataMap ); + + HYDROGUI_ImportImageDlg::PrsPointData aPrsPointData( anImageObj->GetName(), aDataMap ); + aPrsPointDataList.append( aPrsPointData ); + } + } + + // Initialize the combobox in the dialog with the list of available reference images + aPanel->setPrsPointDataList( aPrsPointDataList ); + // Select the current reference image in the dialog combobox + aPanel->setRefImageName( aRefImageName ); +} + +void HYDROGUI_ImportImageOp::setPresentationTrsfPoints( HYDROGUI_PrsImage* thePrs, + bool theIsByTwoPoints, + const QPoint theLocalPointA, + const QPoint theLocalPointB, + const QPoint theLocalPointC ) +{ + // Set transformation points A,B,C to the image presentation + if( thePrs ) + { + HYDROGUI_PrsImage::TransformationPointMap aPointMap = + thePrs->getTransformationPointMap(); + if( !aPointMap.isEmpty() ) + { + aPointMap[ HYDROGUI_PrsImage::PointA ].Point = theLocalPointA; + aPointMap[ HYDROGUI_PrsImage::PointB ].Point = theLocalPointB; + if ( !theIsByTwoPoints ) + aPointMap[ HYDROGUI_PrsImage::PointC ].Point = theLocalPointC; + + thePrs->setIsByTwoPoints( theIsByTwoPoints ); + thePrs->setTransformationPointMap( aPointMap ); } } } +void HYDROGUI_ImportImageOp::computeTrsfData( HYDROData_Image::TransformationMode theTrsfMode, + bool theIsByTwoPoints, + const QPoint& theLocalPointA, + const QPoint& theLocalPointB, + const QPoint& theLocalPointC, + const QPointF& theGlobalPointA, + const QPointF& theGlobalPointB, + const QPointF& theGlobalPointC, + HYDROGUI_ImportImageDlg::TransformationDataMap& theDataMap ) const +{ + // Build the local-global points map + HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap; + theDataMap[ HYDROGUI_PrsImage::PointA ] = + HYDROGUI_ImportImageDlg::ComputeTrsfData( theTrsfMode, theLocalPointA, theGlobalPointA ); + theDataMap[ HYDROGUI_PrsImage::PointB ] = + HYDROGUI_ImportImageDlg::ComputeTrsfData( theTrsfMode, theLocalPointB, theGlobalPointB ); + if ( !theIsByTwoPoints ) + { + theDataMap[ HYDROGUI_PrsImage::PointC ] = + HYDROGUI_ImportImageDlg::ComputeTrsfData( theTrsfMode, theLocalPointC, theGlobalPointC ); + } +} + void HYDROGUI_ImportImageOp::abortOperation() { closePreview(); @@ -119,13 +265,80 @@ void HYDROGUI_ImportImageOp::commitOperation() HYDROGUI_InputPanel* HYDROGUI_ImportImageOp::createInputPanel() const { HYDROGUI_InputPanel* aPanel = new HYDROGUI_ImportImageDlg( module(), getName() ); - connect( aPanel, SIGNAL( createPreview( QImage ) ), - this, SLOT( onCreatePreview( QImage ) ) ); - connect( aPanel, SIGNAL( activatePointSelection( int ) ), - this, SLOT( onActivatePointSelection( int ) ) ); + connect( aPanel, SIGNAL( createPreview( QImage ) ), SLOT( onCreatePreview( QImage ) ) ); + connect( aPanel, SIGNAL( activatePointSelection( int ) ), SLOT( onActivatePointSelection( int ) ) ); + connect( aPanel, SIGNAL( pointCoordChanged( bool, int, bool, int ) ), + SLOT( onPointCoordChanged( bool, int, bool, int ) ) ); + connect( aPanel, SIGNAL( modeActivated( int ) ), SLOT( onModeActivated( int ) ) ); + connect( aPanel, SIGNAL( refImageActivated( const QString& ) ), + SLOT( onRefImageActivated( const QString& ) ) ); + connect( aPanel, SIGNAL( setCIsUsed( bool ) ), SLOT( onSetCIsUsed( bool ) ) ); return aPanel; } +void HYDROGUI_ImportImageOp::onSetCIsUsed( bool theCIsUsed ) +{ + if ( myPreviewPrs ) + { + myPreviewPrs->setIsByTwoPoints( !theCIsUsed ); + } + if ( myRefPreviewPrs ) + { + myRefPreviewPrs->setIsByTwoPoints( !theCIsUsed ); + } +} + +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; + } + + 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; + } + } + } + else + { + // check that two points are not identical + if ( ValuesEquals( xa, xb ) && ValuesEquals( ya, yb ) ) + { + theErrorMsg = thePoinErrMsg; + return false; + } + } + + return true; +} + bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, QString& theErrorMsg ) { @@ -138,7 +351,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 = findObjectByName( anImageName, KIND_UNKNOWN ); + Handle(HYDROData_Entity) anObject = HYDROGUI_Tool::FindObjectByName( module(), anImageName ); if( !anObject.IsNull() ) { theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( anImageName ); @@ -146,51 +359,83 @@ bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, } } - QImage anImage = myPreviewPrs->getImage(); + HYDROData_Image::TransformationMode aTransformationMode = + (HYDROData_Image::TransformationMode)aPanel->getTransformationMode(); + + QPoint aPointA, aPointB, aPointC; + QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC( INT_MIN, INT_MIN ); + Handle(HYDROData_Image) aRefImageObj; - HYDROGUI_ImportImageDlg::TransformationDataMap aMap; - bool anIsOk = aPanel->getTransformationDataMap( aMap ); - if( !anIsOk || !myPreviewPrs ) - return false; + if ( aTransformationMode != HYDROData_Image::CartesianFromFile ) { + HYDROGUI_ImportImageDlg::TransformationDataMap aMap; + if( !aPanel->getTransformationDataMap( aMap ) ) + return false; - QPoint aPointA1 = aMap[ HYDROGUI_PrsImage::PointA ].first; - QPoint aPointB1 = aMap[ HYDROGUI_PrsImage::PointB ].first; - QPoint aPointC1 = aMap[ HYDROGUI_PrsImage::PointC ].first; - - QPointF aPointA2 = aMap[ HYDROGUI_PrsImage::PointA ].second; - QPointF aPointB2 = aMap[ HYDROGUI_PrsImage::PointB ].second; - QPointF aPointC2 = aMap[ HYDROGUI_PrsImage::PointC ].second; - - 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(); - - // first, check that three input points don't belong to a single line - if( ( yb1 - ya1 ) * ( xc1 - xa1 ) == ( yc1 - ya1 ) * ( xb1 - xa1 ) ) - { - theErrorMsg = tr( "POINTS_A_B_C_BELONG_TO_SINGLE_LINE" ); - return false; - } + bool anIsByTwoPoints = aPanel->isByTwoPoints(); - QTransform aTransform1( xa1, ya1, 1, xb1, yb1, 1, xc1, yc1, 1 ); - QTransform aTransform2( xa2, ya2, 1, xb2, yb2, 1, xc2, yc2, 1 ); + aPointA = aMap[ HYDROGUI_PrsImage::PointA ].ImagePoint; + aPointB = aMap[ HYDROGUI_PrsImage::PointB ].ImagePoint; + aPointC = anIsByTwoPoints ? QPoint( INT_MIN, INT_MIN ) : + aMap[ HYDROGUI_PrsImage::PointC ].ImagePoint; - bool anIsInvertible = false; - QTransform aTransform = aTransform1.inverted( &anIsInvertible ) * aTransform2; - if( !anIsInvertible ) - { - theErrorMsg = tr( "TRANSFORMATION_MATRIX_CANNOT_BE_COMPUTED" ); - return false; + // 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; + + if ( aTransformationMode == HYDROData_Image::ReferenceImage ) + { + QString aRefImageName = aPanel->getRefImageName(); + if( aRefImageName.isEmpty() ) + { + theErrorMsg = tr( "REFERENCE_IMAGE_IS_NOT_SELECTED" ); + return false; + } + + HYDROGUI_ImportImageDlg::TransformationDataMap aRefMap; + if( !aPanel->getTransformationDataMap( aRefMap, true ) ) + return false; + + aRefImageObj = Handle(HYDROData_Image)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aRefImageName, KIND_IMAGE ) ); + if( aRefImageObj.IsNull() ) { + return false; + } + else if ( !isReferenceCorrect() ) { + aRefImageObj->RemoveAllReferences(); + } + + aTrsfPointA = aRefMap[ HYDROGUI_PrsImage::PointA ].ImagePoint; + aTrsfPointB = aRefMap[ HYDROGUI_PrsImage::PointB ].ImagePoint; + if ( !anIsByTwoPoints ) + aTrsfPointC = aRefMap[ HYDROGUI_PrsImage::PointC ].ImagePoint; + + // 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 + { + if ( aTransformationMode == HYDROData_Image::ManualGeodesic ) + { + aTrsfPointA = aMap[ HYDROGUI_PrsImage::PointA ].GeodesicPoint; + aTrsfPointB = aMap[ HYDROGUI_PrsImage::PointB ].GeodesicPoint; + if ( !anIsByTwoPoints ) + aTrsfPointC = aMap[ HYDROGUI_PrsImage::PointC ].GeodesicPoint; + } + 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; @@ -203,90 +448,350 @@ bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, return false; anImageObj->SetName( anImageName ); + anImageObj->SetImage( myImage ); + + if ( aTransformationMode == HYDROData_Image::CartesianFromFile ) { + QString aGeoreferencementFileName = aPanel->getGeoreferencementFileName(); + if ( aGeoreferencementFileName.isEmpty() ) { + return false; + } + + QPoint aLocalPointA( 0, 0 ), + aLocalPointB( anImageObj->Image().width(), 0 ), + aLocalPointC( INT_MIN, INT_MIN ); + anImageObj->SetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC, false ); + if ( !anImageObj->SetGlobalPointsFromFile( aGeoreferencementFileName ) ) { + theErrorMsg = tr( "CANT_LOAD_GEOREFERENCEMENT_FILE" ); + return false; + } + } else { + anImageObj->SetLocalPoints( aPointA, aPointB, aPointC, false ); + + if ( aTransformationMode == HYDROData_Image::ReferenceImage ) + { + anImageObj->SetReferencePoints( aRefImageObj, + aTrsfPointA, aTrsfPointB, aTrsfPointC ); + } + else + { + anImageObj->SetGlobalPoints( aTransformationMode, + aTrsfPointA, aTrsfPointB, aTrsfPointC ); + } + } - anImageObj->SetImage( anImage ); - anImageObj->SetTrsf( aTransform ); + 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(); - anImageObj->SetTrsfPoints( aPointA1, aPointB1, aPointC1, - aPointA2, aPointB2, aPointC2 ); + if( !myIsEdit ) + module()->setObjectVisible( HYDROGUI_Tool::GetActiveGraphicsViewId( module() ), anImageObj, true ); - anImageObj->SetVisibility( true ); + 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; } +bool HYDROGUI_ImportImageOp::isReferenceCorrect() const +{ + bool isCorrect = true; + + if( myIsEdit && !myEditedObject.IsNull() ) + { + HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); + Handle(HYDROData_Image) aRefImageObj = Handle(HYDROData_Image)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aPanel->getRefImageName(), KIND_IMAGE ) ); + if( !aRefImageObj.IsNull() ) + { + bool isFoundEdited = false; + HYDROData_SequenceOfObjects aRefSeq = aRefImageObj->GetAllReferenceObjects(); + for ( int i = 1, n = aRefSeq.Length(); i <= n && !isFoundEdited; ++i ) + { + Handle(HYDROData_Entity) anObject = aRefSeq.Value( i ); + isFoundEdited = anObject->GetName() == myEditedObject->GetName(); + } + isCorrect = !isFoundEdited; + } + } + return isCorrect; +} + +void HYDROGUI_ImportImageOp::onApply() +{ + HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); + + bool aCanApply = isReferenceCorrect(); + if ( !aCanApply && !myEditedObject.IsNull() ) + { + Handle(HYDROData_Image) aRefImageObj = Handle(HYDROData_Image)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aPanel->getRefImageName(), KIND_IMAGE ) ); + if ( !aRefImageObj.IsNull() ) + aCanApply = SUIT_MessageBox::question( module()->getApp()->desktop(), + tr( "CORRECT_INPUT_DATA" ), tr( "CONFIRM_REMOVE_REFERENCE_FROM_IMAGE" ). + arg( aRefImageObj->GetName() ).arg( myEditedObject->GetName() ), + QMessageBox::Yes | QMessageBox::No, QMessageBox::No ) == QMessageBox::Yes; + } + if ( aCanApply ) + HYDROGUI_Operation::onApply(); + else { + aPanel->setRefImageName( "" ); + onRefImageActivated( aPanel->getRefImageName() ); + } +} + 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 { - myPreviewViewManager->setTitle( tr( "MAPPING" ) ); - 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 ); + 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 ); + } + connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ), + this, SLOT( onPointSelected() ) ); + } + } - myPreviewPrs->setIsTransformationPointPreview( true ); + // Set the image name in the dialog + QString anImageName = aPanel->getImageName().simplified(); + // If edit mode and the name was not set yet then get from the edited object + if( myIsEdit && anImageName.isEmpty() ) + { + if( !myEditedObject.IsNull() ) + anImageName = myEditedObject->GetName(); + } + // If the name was not set then initialize it from the selected file name + if ( anImageName.isEmpty() ) + { + anImageName = aPanel->getFileName(); + if ( !anImageName.isEmpty() ) { + anImageName = QFileInfo( anImageName ).baseName(); + } + // If no file name then generate a new image name + if ( anImageName.isEmpty() ) { + anImageName = HYDROGUI_Tool::GenerateObjectName( module(), tr( "DEFAULT_IMAGE_NAME" ) ); } - connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ), - this, SLOT( onPointSelected() ) ); } + + aPanel->setImageName( anImageName ); } + aPanel->setImageSize( myImage.size() ); + + aPanel->initializePointSelection(); + onPointSelected( false ); + onSetCIsUsed( !aPanel->isByTwoPoints() ); +} + +void HYDROGUI_ImportImageOp::onActivatePointSelection( int thePointType ) +{ + myPointType = thePointType; + if( myPreviewPrs ) + myPreviewPrs->setTransformationPointType( thePointType ); + if( myRefPreviewPrs ) + myRefPreviewPrs->setTransformationPointType( thePointType ); +} + +void HYDROGUI_ImportImageOp::onPointCoordChanged( bool theIsRef, + int thePointType, + bool theIsY, + int theValue ) +{ + if( !theIsRef && myPreviewPrs ) + myPreviewPrs->updateTransformationPoint( thePointType, theIsY, theValue ); + else if( theIsRef && myRefPreviewPrs ) + myRefPreviewPrs->updateTransformationPoint( thePointType, theIsY, theValue ); +} + +void HYDROGUI_ImportImageOp::onModeActivated( int theMode ) +{ HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); - QString anImageName; - if( myIsEdit ) + QString aRefImageName; + if( theMode == HYDROData_Image::ReferenceImage ) { - if( !myEditedObject.IsNull() ) - anImageName = myEditedObject->GetName(); + aRefImageName = aPanel->getRefImageName(); + if( aRefImageName.isEmpty() ) + return; // do nothing in this case to avoid visual moving of preview prs + onRefImageActivated( aRefImageName ); } else { - int anImageId = 1; - while( anImageId < 100 ) + if( myRefViewManager ) { - anImageName = QString( "Image_%1" ).arg( QString::number( anImageId++ ) ); + closeView( myRefViewManager ); + } + } +} - // check that there are no other objects with the same name in the document - Handle(HYDROData_Object) anObject = findObjectByName( anImageName, KIND_UNKNOWN ); - if( anObject.IsNull() ) - break; +void HYDROGUI_ImportImageOp::onRefImageActivated( const QString& theName ) +{ + GraphicsView_ViewPort* aViewPort = 0; + + LightApp_Application* anApp = module()->getApp(); + ///// Get a view port for the reference image preview + if( myRefViewManager ) + { + if( theName.isEmpty() ) + { + closeView( myRefViewManager ); + } + else if( GraphicsView_Viewer* aViewer = myRefViewManager->getViewer() ) + { + aViewPort = aViewer->getActiveViewPort(); } } - aPanel->setImageName( anImageName ); + 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() ) ); + } + } + } + + if( !aViewPort ) + return; + + // Remove the old presentation of the reference image if any + if( myRefPreviewPrs ) + { + myRefPreviewPrs->setCaption( QString() ); + aViewPort->removeItem( myRefPreviewPrs ); + + 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 ) ); + if( !anImageObj.IsNull() ) + { + anImage = anImageObj->Image(); + + myRefPreviewPrs = new HYDROGUI_PrsImage( anImageObj ); + myRefPreviewPrs->setImage( anImage ); + myRefPreviewPrs->compute(); + + myRefPreviewPrs->setIsTransformationPointPreview( true ); + myRefPreviewPrs->setTransformationPointType( myPointType ); + + // Add the new reference image presentation to the appropriate view + aViewPort->addItem( myRefPreviewPrs ); + } + + aViewPort->fitAll(); + + // Split views horizontally + if( anApp->desktop()->inherits( "STD_TabDesktop" ) ) + { + qApp->processEvents(); + 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(); + onPointSelected( true ); } -void HYDROGUI_ImportImageOp::onActivatePointSelection( int thePointType ) +void HYDROGUI_ImportImageOp::onLastViewClosed( SUIT_ViewManager* theViewManager ) { - myPointType = thePointType; - if( myPreviewPrs ) - myPreviewPrs->setTransformationPointMode( thePointType ); + 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; + if( !aPrs ) + return; + HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap; const HYDROGUI_PrsImage::TransformationPointMap& aPointMap = - myPreviewPrs->getTransformationPointMap(); + aPrs->getTransformationPointMap(); + HYDROGUI_PrsImage::TransformationPointMapIterator anIter( aPointMap ); while( anIter.hasNext() ) { @@ -294,27 +799,56 @@ void HYDROGUI_ImportImageOp::onPointSelected() 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; } - ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setTransformationDataMap( aDataMap, true ); + ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setTransformationDataMap( aDataMap, true, theIsRefImage ); } void HYDROGUI_ImportImageOp::closePreview() { - if( myPreviewPrs ) - { - delete myPreviewPrs; - myPreviewPrs = 0; - } - - if( myPreviewViewManager ) - { - module()->getApp()->removeViewManager( myPreviewViewManager ); // myPreviewViewManager is deleted here - myPreviewViewManager = 0; - } + closeView( myPreviewViewManager ); + closeView( myRefViewManager ); if( myActiveViewManager ) HYDROGUI_Tool::SetActiveViewManager( module(), myActiveViewManager ); } + +void HYDROGUI_ImportImageOp::closeView( GraphicsView_ViewManager* &aViewMgr ) +{ + if( aViewMgr ) + { + GraphicsView_ViewPort* aViewPort = 0; + if( GraphicsView_Viewer* aViewer = aViewMgr->getViewer() ) + { + aViewPort = aViewer->getActiveViewPort(); + } + disconnect( aViewMgr, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ), + this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) ); + + // 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; + } +}