X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_ImportImageOp.cxx;h=ca37f4a5fc8e7eb6643c2da40af972d2814b9f36;hb=5cae7e874afd2fc1b6f61023e8ebd33a933db3c7;hp=a1f390c90903f9d92bd2f8f8f41b8f1c4b605b72;hpb=d74afc6389ed4e656c9451ac01b4065470746fd8;p=modules%2Fhydro.git

diff --git a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx
index a1f390c9..ca37f4a5 100644
--- a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx
+++ b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx
@@ -22,13 +22,17 @@
 
 #include "HYDROGUI_ImportImageOp.h"
 
+#include "HYDROGUI_DataModel.h"
 #include "HYDROGUI_ImportImageDlg.h"
 #include "HYDROGUI_Module.h"
 #include "HYDROGUI_PrsImage.h"
 #include "HYDROGUI_Tool.h"
+#include "HYDROGUI_UpdateFlags.h"
 
-#include <HYDROData_Document.h>
-#include <HYDROData_Image.h>
+#include <HYDROData_Iterator.h>
+#include <HYDROData_Lambert93.h>
+#include <HYDROData_OperationsFactory.h>
+#include <HYDROData_Tool.h>
 
 #include <GraphicsView_ViewManager.h>
 #include <GraphicsView_ViewPort.h>
@@ -37,16 +41,24 @@
 #include <LightApp_Application.h>
 #include <LightApp_UpdateFlags.h>
 
+#include <STD_TabDesktop.h>
 #include <SUIT_Desktop.h>
-#include <SUIT_MessageBox.h>
+#include <QtxWorkstack.h>
+#include <QApplication>
 
-HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule )
+HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule,
+                                                const bool theIsEdit )
 : HYDROGUI_Operation( theModule ),
+  myIsEdit( theIsEdit ),
+  myEditedObject( 0 ),
   myActiveViewManager( 0 ),
   myPreviewViewManager( 0 ),
+  myRefViewManager( 0 ),
   myPreviewPrs( 0 ),
+  myRefPreviewPrs( 0 ),
   myPointType( HYDROGUI_PrsImage::None )
 {
+  setName( theIsEdit ? tr( "EDIT_IMPORTED_IMAGE" ) : tr( "IMPORT_IMAGE" ) );
 }
 
 HYDROGUI_ImportImageOp::~HYDROGUI_ImportImageOp()
@@ -59,136 +71,572 @@ void HYDROGUI_ImportImageOp::startOperation()
 
   HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
   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 aLocalPointA, aLocalPointB, aLocalPointC;
+      myEditedObject->GetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC );
+
+      onCreatePreview( anImage );
+
+      if( myPreviewPrs )
+      {
+        HYDROGUI_PrsImage::TransformationPointMap aPointMap =
+          myPreviewPrs->getTransformationPointMap();
+        if( !aPointMap.isEmpty() )
+        {
+          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::ComputeTrsfData( aTrsfMode, aLocalPointA, aTrsfPointA );
+      aDataMap[ HYDROGUI_PrsImage::PointB ] =
+        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 );
+        }
+      }
+    }
+  }
+
+  // collect information about existing images
+  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::ComputeTrsfData( aImgTrsfMode, aLocalPointA, aTrsfPointA );
+      aDataMap[ HYDROGUI_PrsImage::PointB ] =
+        HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointB, aTrsfPointB );
+      aDataMap[ HYDROGUI_PrsImage::PointC ] =
+        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()
+{
+  closePreview();
+
+  HYDROGUI_Operation::abortOperation();
+}
+
+void HYDROGUI_ImportImageOp::commitOperation()
+{
+  closePreview();
+
+  HYDROGUI_Operation::commitOperation();
 }
 
 HYDROGUI_InputPanel* HYDROGUI_ImportImageOp::createInputPanel() const
 {
-  HYDROGUI_InputPanel* aPanel = new HYDROGUI_ImportImageDlg( module(), tr( "IMPORT_IMAGE" ) );
-  connect( aPanel, SIGNAL( createPreview( QString ) ),
-           this, SLOT( onCreatePreview( QString ) ) );
+  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( 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;
 }
 
-void HYDROGUI_ImportImageOp::OnApply()
+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 )
 {
   HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
 
-  HYDROGUI_ImportImageDlg::TransformationDataMap aMap;
-  bool anIsOk = aPanel->getTransformationDataMap( aMap );
-  if( !anIsOk || !myPreviewPrs )
+  QString anImageName = aPanel->getImageName();
+  if( anImageName.isEmpty() )
+    return false;
+
+  if( !myIsEdit || ( !myEditedObject.IsNull() && myEditedObject->GetName() != anImageName ) )
   {
-    SUIT_MessageBox::critical( module()->getApp()->desktop(),
-                               tr( "INSUFFICIENT_INPUT_DATA" ),
-                               tr( "INPUT_VALID_DATA" ) ); 
-    return;
+    // check that there are no other objects with the same name in the document
+    Handle(HYDROData_Entity) anObject = HYDROGUI_Tool::FindObjectByName( module(), anImageName );
+    if( !anObject.IsNull() )
+    {
+      theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( anImageName );
+      return false;
+    }
   }
 
-  double xa1 = aMap[ HYDROGUI_PrsImage::PointA ].first.x();
-  double ya1 = aMap[ HYDROGUI_PrsImage::PointA ].first.y();
-  double xb1 = aMap[ HYDROGUI_PrsImage::PointB ].first.x();
-  double yb1 = aMap[ HYDROGUI_PrsImage::PointB ].first.y();
-  double xc1 = aMap[ HYDROGUI_PrsImage::PointC ].first.x();
-  double yc1 = aMap[ HYDROGUI_PrsImage::PointC ].first.y();
+  HYDROGUI_ImportImageDlg::TransformationDataMap aMap;
+  if( !aPanel->getTransformationDataMap( aMap ) )
+    return false;
 
-  double xa2 = aMap[ HYDROGUI_PrsImage::PointA ].second.x();
-  double ya2 = aMap[ HYDROGUI_PrsImage::PointA ].second.y();
-  double xb2 = aMap[ HYDROGUI_PrsImage::PointB ].second.x();
-  double yb2 = aMap[ HYDROGUI_PrsImage::PointB ].second.y();
-  double xc2 = aMap[ HYDROGUI_PrsImage::PointC ].second.x();
-  double yc2 = aMap[ HYDROGUI_PrsImage::PointC ].second.y();
+  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 );
+  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;
 
-  QTransform aTransform = aTransform1.inverted() * aTransform2;
+  // 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;
 
-  QImage anImage = myPreviewPrs->getImage();
+  Handle(HYDROData_Image) aRefImageObj;
+  QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC( INT_MIN, INT_MIN );
 
-  closePreview();
+  HYDROData_Image::TransformationMode aTransformationMode = 
+    (HYDROData_Image::TransformationMode)aPanel->getTransformationMode();
+  if ( aTransformationMode == HYDROData_Image::ReferenceImage )
+  {
+    QString aRefImageName = aPanel->getRefImageName();
+    if( aRefImageName.isEmpty() )
+    {
+      theErrorMsg = tr( "REFERENCE_IMAGE_IS_NOT_SELECTED" );
+      return false;
+    }
 
-  int aStudyId = module()->getStudyId();
-  Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( aStudyId );
-  if( !aDocument.IsNull() )
+    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;
+
+    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
   {
-    Handle(HYDROData_Image) anImageObj =
-      Handle(HYDROData_Image)::DownCast( aDocument->CreateObject( KIND_IMAGE ) );
-    if( !anImageObj.IsNull() )
+    if ( aTransformationMode == HYDROData_Image::ManualLambert )
     {
-      static int ImageId = 0;
-      anImageObj->SetName( QString( "Image_%1" ).arg( QString::number( ++ImageId ) ) );
+      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;
+    }
+  }
 
-      anImageObj->SetImage( anImage );
-      anImageObj->SetTrsf( aTransform );
+  Handle(HYDROData_Image) anImageObj;
+  if( myIsEdit )
+    anImageObj = myEditedObject;
+  else
+    anImageObj = Handle(HYDROData_Image)::DownCast( doc()->CreateObject( KIND_IMAGE ) );
 
-      module()->update( UF_Model | UF_Viewer );
-    }
+  if( anImageObj.IsNull() )
+    return false;
+
+  anImageObj->SetName( anImageName );
+  anImageObj->SetImage( myImage );
+  anImageObj->SetLocalPoints( aPointA, aPointB, aPointC );
+
+  if ( aTransformationMode == HYDROData_Image::ReferenceImage )
+  {
+    anImageObj->SetReferencePoints( aRefImageObj,
+                                    aTrsfPointA, aTrsfPointB, aTrsfPointC );
+  }
+  else
+  {
+    anImageObj->SetGlobalPoints( aTransformationMode,
+                                 aTrsfPointA, aTrsfPointB, aTrsfPointC );
   }
-  commit();
-}
 
-void HYDROGUI_ImportImageOp::OnCancel()
-{
+  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();
-  abort();
+
+  if( !myIsEdit )
+    module()->setObjectVisible( HYDROGUI_Tool::GetActiveGraphicsViewId( module() ), anImageObj, true );
+
+  if( myIsEdit )
+    anImageObj->Update();
+
+  theUpdateFlags = UF_Model | UF_Viewer | UF_GV_Forced | UF_OCCViewer | UF_OCC_Forced;
+  return true;
 }
 
-void HYDROGUI_ImportImageOp::onCreatePreview( QString theFileName )
+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( 0 ); // no data object
+  if( myPreviewPrs ) // if the image is changed by choosing another file
+  {
+    myPreviewPrs->setImage( myImage );
+    myPreviewPrs->compute();
 
-  QImage anImage( theFileName );
-  myPreviewPrs->setImage( anImage );
+    if( myPreviewViewManager )
+    {
+      if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() )
+      {
+        if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() )
+        {
+          aViewPort->onBoundingRectChanged();
+          aViewPort->fitAll();
+        }
+      }
+    }
+  }
+  else
+  {
+    LightApp_Application* anApp = module()->getApp();
 
-  myPreviewPrs->compute();
+    myActiveViewManager = anApp->activeViewManager();
 
-  myPreviewViewManager =
-    dynamic_cast<GraphicsView_ViewManager*>( anApp->createViewManager( GraphicsView_Viewer::Type() ) );
-  if( myPreviewViewManager )
-  {
-    myPreviewViewManager->setTitle( tr( "MAPPING" ) );
-    if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() )
+    myPreviewPrs = new HYDROGUI_PrsImage( myIsEdit ? myEditedObject : 0 );
+    myPreviewPrs->setImage( myImage );
+    myPreviewPrs->compute();
+
+    myPreviewViewManager =
+      dynamic_cast<GraphicsView_ViewManager*>( 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 );
+          myPreviewPrs->setIsTransformationPointPreview( true );
+        }
+        connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ),
+                 this, SLOT( onPointSelected() ) );
       }
-      connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ),
-               this, SLOT( onPointSelected() ) );
     }
+
+    QString anImageName;
+    if( myIsEdit )
+    {
+      if( !myEditedObject.IsNull() )
+        anImageName = myEditedObject->GetName();
+    }
+    else
+      anImageName = HYDROGUI_Tool::GenerateObjectName( module(), "Image" );
+    aPanel->setImageName( anImageName );
   }
 
-  HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
+  aPanel->setImageSize( myImage.size() );
 
   aPanel->initializePointSelection();
-  onPointSelected();
-
-  aPanel->synchronizeTransformedPoints();
+  onPointSelected( false );
 }
 
 void HYDROGUI_ImportImageOp::onActivatePointSelection( int thePointType )
 {
   myPointType = thePointType;
   if( myPreviewPrs )
-    myPreviewPrs->setTransformationPointMode( thePointType );
+    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 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;
+
+  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<GraphicsView_ViewManager*>( 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;
+
+  // 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" ) )
+  {
+    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;
+  if( !aPrs )
+    return;
+
   HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
 
   const HYDROGUI_PrsImage::TransformationPointMap& aPointMap =
-    myPreviewPrs->getTransformationPointMap();
+    aPrs->getTransformationPointMap();
   HYDROGUI_PrsImage::TransformationPointMapIterator anIter( aPointMap );
   while( anIter.hasNext() )
   {
@@ -196,27 +644,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 );
+  ( (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;
+  }
+}