X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_ImportImageOp.cxx;h=ca37f4a5fc8e7eb6643c2da40af972d2814b9f36;hb=5cae7e874afd2fc1b6f61023e8ebd33a933db3c7;hp=dabeaad10cc3f0a3c3b3b2f484b93fbb96cde800;hpb=41d3a5f489e8ec606523394f435e356fc607719b;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx index dabeaad1..ca37f4a5 100644 --- a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx +++ b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx @@ -31,8 +31,8 @@ #include #include - #include +#include #include #include @@ -73,24 +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(); - int aTransformationMode = myEditedObject->TrsfMode(); - if( aTransformationMode == HYDROGUI_ImportImageDlg::RefImage ) - aTransformationMode = HYDROGUI_ImportImageDlg::ManualCartesian; - aPanel->setTransformationMode( aTransformationMode ); - - QPoint aPointA1, aPointB1, aPointC1; - QPointF aPointA2, aPointB2, aPointC2; - QPointF aPointA3, aPointB3, aPointC3; - myEditedObject->TrsfPoints( aPointA1, aPointB1, aPointC1, - aPointA2, aPointB2, aPointC2, - aPointA3, aPointB3, aPointC3 ); + QPoint aLocalPointA, aLocalPointB, aLocalPointC; + myEditedObject->GetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC ); onCreatePreview( anImage ); @@ -100,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, aPointA3 ); + aDataMap[ HYDROGUI_PrsImage::PointA ] = + HYDROGUI_ImportImageDlg::ComputeTrsfData( aTrsfMode, aLocalPointA, aTrsfPointA ); aDataMap[ HYDROGUI_PrsImage::PointB ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointB1, aPointB2, aPointB3 ); - aDataMap[ HYDROGUI_PrsImage::PointC ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointC1, aPointC2, aPointC3 ); + 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 ); + } + } } } @@ -129,26 +168,29 @@ void HYDROGUI_ImportImageOp::startOperation() if( myIsEdit && IsEqual( anImageObj, myEditedObject ) ) continue; - QPoint aPointA1, aPointB1, aPointC1; - QPointF aPointA2, aPointB2, aPointC2; - QPointF aPointA3, aPointB3, aPointC3; - anImageObj->TrsfPoints( aPointA1, aPointB1, aPointC1, - aPointA2, aPointB2, aPointC2, - aPointA3, aPointB3, aPointC3 ); + 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, aPointA3 ); + aDataMap[ HYDROGUI_PrsImage::PointA ] = + HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointA, aTrsfPointA ); aDataMap[ HYDROGUI_PrsImage::PointB ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointB1, aPointB2, aPointB3 ); + HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointB, aTrsfPointB ); aDataMap[ HYDROGUI_PrsImage::PointC ] = - HYDROGUI_ImportImageDlg::TransformationData( aPointC1, aPointC2, aPointC3 ); + HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointC, aTrsfPointC ); HYDROGUI_ImportImageDlg::PrsPointData aPrsPointData( anImageObj->GetName(), aDataMap ); aPrsPointDataList.append( aPrsPointData ); } } + aPanel->setPrsPointDataList( aPrsPointDataList ); + aPanel->setRefImageName( aRefImageName ); } void HYDROGUI_ImportImageOp::abortOperation() @@ -181,6 +223,57 @@ HYDROGUI_InputPanel* HYDROGUI_ImportImageOp::createInputPanel() const 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 ) { @@ -201,90 +294,76 @@ bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, } } - int aTransformationMode = aPanel->getTransformationMode(); - bool anIsRefImage = aTransformationMode == HYDROGUI_ImportImageDlg::RefImage; - 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 aPointA = aMap[ HYDROGUI_PrsImage::PointA ].ImagePoint; QPoint aPointB = aMap[ HYDROGUI_PrsImage::PointB ].ImagePoint; - QPoint aPointC = aMap[ HYDROGUI_PrsImage::PointC ].ImagePoint; - - QPointF aLPointA = aMap[ HYDROGUI_PrsImage::PointA ].LambertPoint; - QPointF aLPointB = aMap[ HYDROGUI_PrsImage::PointB ].LambertPoint; - QPointF aLPointC = aMap[ HYDROGUI_PrsImage::PointC ].LambertPoint; + QPoint aPointC = anIsByTwoPoints ? QPoint( INT_MIN, INT_MIN ) : + aMap[ HYDROGUI_PrsImage::PointC ].ImagePoint; + + // 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; - QPointF aCPointA = aMap[ HYDROGUI_PrsImage::PointA ].CartesianPoint; - QPointF aCPointB = aMap[ HYDROGUI_PrsImage::PointB ].CartesianPoint; - QPointF aCPointC = aMap[ HYDROGUI_PrsImage::PointC ].CartesianPoint; + Handle(HYDROData_Image) aRefImageObj; + QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC( INT_MIN, INT_MIN ); - QPoint aRefPointA, aRefPointB, aRefPointC; - if( anIsRefImage ) + HYDROData_Image::TransformationMode aTransformationMode = + (HYDROData_Image::TransformationMode)aPanel->getTransformationMode(); + if ( aTransformationMode == HYDROData_Image::ReferenceImage ) { - aRefPointA = aRefMap[ HYDROGUI_PrsImage::PointA ].ImagePoint; - aRefPointB = aRefMap[ HYDROGUI_PrsImage::PointB ].ImagePoint; - aRefPointC = aRefMap[ HYDROGUI_PrsImage::PointC ].ImagePoint; - } + QString aRefImageName = aPanel->getRefImageName(); + if( aRefImageName.isEmpty() ) + { + theErrorMsg = tr( "REFERENCE_IMAGE_IS_NOT_SELECTED" ); + return false; + } - int xa = aPointA.x(); - int ya = aPointA.y(); - int xb = aPointB.x(); - int yb = aPointB.y(); - int xc = aPointC.x(); - int yc = aPointC.y(); - - double xca = aCPointA.x(); - double yca = aCPointA.y(); - double xcb = aCPointB.x(); - double ycb = aCPointB.y(); - double xcc = aCPointC.x(); - double ycc = aCPointC.y(); - - int xra = aRefPointA.x(); - int yra = aRefPointA.y(); - int xrb = aRefPointB.x(); - int yrb = aRefPointB.y(); - int xrc = aRefPointC.x(); - int yrc = aRefPointC.y(); - - // first, check that three input points don't belong to a single line - if( ( yb - ya ) * ( xc - xa ) == ( yc - ya ) * ( xb - xa ) ) - { - theErrorMsg = tr( "POINTS_A_B_C_BELONG_TO_SINGLE_LINE" ); - return false; - } + HYDROGUI_ImportImageDlg::TransformationDataMap aRefMap; + if( !aPanel->getTransformationDataMap( aRefMap, true ) ) + return false; - // the same check for the reference points - if( anIsRefImage && - ( ( yrb - yra ) * ( xrc - xra ) == ( yrc - yra ) * ( xrb - xra ) ) ) - { - theErrorMsg = tr( "REFERENCE_POINTS_A_B_C_BELONG_TO_SINGLE_LINE" ); - return false; - } + aRefImageObj = Handle(HYDROData_Image)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aRefImageName, KIND_IMAGE ) ); + if( aRefImageObj.IsNull() ) + return false; - QTransform aTransform1( xa, ya, 1, xb, yb, 1, xc, yc, 1 ); - QTransform aTransform2( xca, yca, 1, xcb, ycb, 1, xcc, ycc, 1 ); - QTransform aTransform3( xra, yra, 1, xrb, yrb, 1, xrc, yrc, 1 ); + aTrsfPointA = aRefMap[ HYDROGUI_PrsImage::PointA ].ImagePoint; + aTrsfPointB = aRefMap[ HYDROGUI_PrsImage::PointB ].ImagePoint; + if ( !anIsByTwoPoints ) + aTrsfPointC = aRefMap[ HYDROGUI_PrsImage::PointC ].ImagePoint; - bool anIsInvertible = false; - QTransform aTransform1Inverted = aTransform1.inverted( &anIsInvertible ); - if( !anIsInvertible ) - { - theErrorMsg = tr( "TRANSFORMATION_MATRIX_CANNOT_BE_COMPUTED" ); - return false; + // 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; } - - QTransform aTransform; - if( anIsRefImage ) - aTransform = aTransform1Inverted * aTransform3 * myRefTransform; 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 ) @@ -296,38 +375,19 @@ bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, return false; anImageObj->SetName( anImageName ); - anImageObj->SetImage( myImage ); - anImageObj->SetTrsf( aTransform ); + anImageObj->SetLocalPoints( aPointA, aPointB, aPointC ); - if( anIsRefImage ) + if ( aTransformationMode == HYDROData_Image::ReferenceImage ) { - aCPointA = QPointF( aTransform.map( aPointA ) ); - aCPointB = QPointF( aTransform.map( aPointB ) ); - aCPointC = QPointF( aTransform.map( aPointC ) ); - - // compute Lambert93 points - xca = aCPointA.x(); - yca = aCPointA.y(); - xcb = aCPointB.x(); - ycb = aCPointB.y(); - xcc = aCPointC.x(); - ycc = aCPointC.y(); - - double xla = 0, yla = 0, xlb = 0, ylb = 0, xlc = 0, ylc = 0; - HYDROData_Lambert93::toGeo( xca, yca, yla, xla ); - HYDROData_Lambert93::toGeo( xcb, ycb, ylb, xlb ); - HYDROData_Lambert93::toGeo( xcc, ycc, ylc, xlc ); - - aLPointA = QPointF( xla * 3600.0, yla * 3600.0 ); // convert degrees to seconds - aLPointB = QPointF( xlb * 3600.0, ylb * 3600.0 ); // convert degrees to seconds - aLPointC = QPointF( xlc * 3600.0, ylc * 3600.0 ); // convert degrees to seconds + anImageObj->SetReferencePoints( aRefImageObj, + aTrsfPointA, aTrsfPointB, aTrsfPointC ); + } + else + { + anImageObj->SetGlobalPoints( aTransformationMode, + aTrsfPointA, aTrsfPointB, aTrsfPointC ); } - - anImageObj->SetTrsfMode( aTransformationMode ); - anImageObj->SetTrsfPoints( aPointA, aPointB, aPointC, - aLPointA, aLPointB, aLPointC, - aCPointA, aCPointB, aCPointC ); if( !myIsEdit ) { @@ -449,7 +509,7 @@ void HYDROGUI_ImportImageOp::onModeActivated( int theMode ) HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); QString aRefImageName; - if( theMode == HYDROGUI_ImportImageDlg::RefImage ) + if( theMode == HYDROData_Image::ReferenceImage ) { aRefImageName = aPanel->getRefImageName(); if( aRefImageName.isEmpty() ) @@ -467,7 +527,6 @@ void HYDROGUI_ImportImageOp::onModeActivated( int theMode ) void HYDROGUI_ImportImageOp::onRefImageActivated( const QString& theName ) { - myRefTransform.reset(); GraphicsView_ViewPort* aViewPort = 0; LightApp_Application* anApp = module()->getApp(); @@ -522,7 +581,6 @@ void HYDROGUI_ImportImageOp::onRefImageActivated( const QString& theName ) if( !anImageObj.IsNull() ) { anImage = anImageObj->Image(); - myRefTransform = anImageObj->Trsf(); myRefPreviewPrs = new HYDROGUI_PrsImage( anImageObj ); myRefPreviewPrs->setImage( anImage ); @@ -615,7 +673,7 @@ void HYDROGUI_ImportImageOp::closeView( GraphicsView_ViewManager* &aViewMgr ) this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) ); // Nullify appropriate presentation pointer - HYDROGUI_PrsImage* aPrs; + HYDROGUI_PrsImage* aPrs = 0; switch ( module()->getViewManagerRole( aViewMgr ) ) { case HYDROGUI_Module::VMR_ReferenceImage: