src/HYDROGUI/HYDROGUI_ImportImageOp.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #include "HYDROGUI_ImportImageOp.h"
  24
  25 #include "HYDROGUI_DataModel.h"
  26 #include "HYDROGUI_ImportImageDlg.h"
  27 #include "HYDROGUI_Module.h"
  28 #include "HYDROGUI_PrsImage.h"
  29 #include "HYDROGUI_Tool.h"
  30 #include "HYDROGUI_UpdateFlags.h"
  31
  32 #include <HYDROData_Iterator.h>
  33
  34 #include <HYDROOperations_Factory.h>
  35
  36 #include <GraphicsView_ViewManager.h>
  37 #include <GraphicsView_ViewPort.h>
  38 #include <GraphicsView_Viewer.h>
  39
  40 #include <LightApp_Application.h>
  41 #include <LightApp_UpdateFlags.h>
  42
  43 HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule,
  44                                                 const bool theIsEdit )
  45 : HYDROGUI_Operation( theModule ),
  46   myIsEdit( theIsEdit ),
  47   myEditedObject( 0 ),
  48   myActiveViewManager( 0 ),
  49   myPreviewViewManager( 0 ),
  50   myPreviewPrs( 0 ),
  51   myRefPreviewPrs( 0 ),
  52   myPointType( HYDROGUI_PrsImage::None )
  53 {
  54   setName( theIsEdit ? tr( "EDIT_IMPORTED_IMAGE" ) : tr( "IMPORT_IMAGE" ) );
  55 }
  56
  57 HYDROGUI_ImportImageOp::~HYDROGUI_ImportImageOp()
  58 {
  59 }
  60
  61 void HYDROGUI_ImportImageOp::startOperation()
  62 {
  63   HYDROGUI_Operation::startOperation();
  64
  65   HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
  66   aPanel->reset();
  67   aPanel->setIsEdit( myIsEdit );
  68
  69   if( myIsEdit )
  70   {
  71     myEditedObject = Handle(HYDROData_Image)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) );
  72     if( !myEditedObject.IsNull() )
  73     {
  74       QImage anImage = myEditedObject->Image();
  75
  76       QPoint aPointA1, aPointB1, aPointC1;
  77       QPointF aPointA2, aPointB2, aPointC2;
  78       myEditedObject->TrsfPoints( aPointA1, aPointB1, aPointC1,
  79                                   aPointA2, aPointB2, aPointC2 );
  80
  81       onCreatePreview( anImage );
  82
  83       if( myPreviewPrs )
  84       {
  85         HYDROGUI_PrsImage::TransformationPointMap aPointMap =
  86           myPreviewPrs->getTransformationPointMap();
  87         if( !aPointMap.isEmpty() )
  88         {
  89           aPointMap[ HYDROGUI_PrsImage::PointA ].Point = aPointA1;
  90           aPointMap[ HYDROGUI_PrsImage::PointB ].Point = aPointB1;
  91           aPointMap[ HYDROGUI_PrsImage::PointC ].Point = aPointC1;
  92           myPreviewPrs->setTransformationPointMap( aPointMap );
  93         }
  94       }
  95
  96       HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
  97       aDataMap[ HYDROGUI_PrsImage::PointA ] =
  98         HYDROGUI_ImportImageDlg::TransformationData( aPointA1, aPointA2 );
  99       aDataMap[ HYDROGUI_PrsImage::PointB ] =
 100         HYDROGUI_ImportImageDlg::TransformationData( aPointB1, aPointB2 );
 101       aDataMap[ HYDROGUI_PrsImage::PointC ] =
 102         HYDROGUI_ImportImageDlg::TransformationData( aPointC1, aPointC2 );
 103       ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setTransformationDataMap( aDataMap );
 104     }
 105   }
 106
 107   // collect information about existing images
 108   HYDROGUI_ImportImageDlg::PrsPointDataList aPrsPointDataList;
 109   HYDROData_Iterator anIterator( doc(), KIND_IMAGE );
 110   for( ; anIterator.More(); anIterator.Next() )
 111   {
 112     Handle(HYDROData_Image) anImageObj = Handle(HYDROData_Image)::DownCast( anIterator.Current() );
 113     if( !anImageObj.IsNull() )
 114     {
 115       if( myIsEdit && HYDROGUI_Tool::IsEqual( anImageObj, myEditedObject ) )
 116         continue;
 117
 118       QPoint aPointA1, aPointB1, aPointC1;
 119       QPointF aPointA2, aPointB2, aPointC2;
 120       anImageObj->TrsfPoints( aPointA1, aPointB1, aPointC1,
 121                               aPointA2, aPointB2, aPointC2 );
 122
 123       HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
 124       aDataMap[ HYDROGUI_PrsImage::PointA ] =
 125         HYDROGUI_ImportImageDlg::TransformationData( aPointA1, aPointA2 );
 126       aDataMap[ HYDROGUI_PrsImage::PointB ] =
 127         HYDROGUI_ImportImageDlg::TransformationData( aPointB1, aPointB2 );
 128       aDataMap[ HYDROGUI_PrsImage::PointC ] =
 129         HYDROGUI_ImportImageDlg::TransformationData( aPointC1, aPointC2 );
 130
 131       HYDROGUI_ImportImageDlg::PrsPointData aPrsPointData( anImageObj->GetName(), aDataMap );
 132       aPrsPointDataList.append( aPrsPointData );
 133     }
 134   }
 135   ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setPrsPointDataList( aPrsPointDataList );
 136 }
 137
 138 void HYDROGUI_ImportImageOp::abortOperation()
 139 {
 140   closePreview();
 141
 142   HYDROGUI_Operation::abortOperation();
 143 }
 144
 145 void HYDROGUI_ImportImageOp::commitOperation()
 146 {
 147   closePreview();
 148
 149   HYDROGUI_Operation::commitOperation();
 150 }
 151
 152 HYDROGUI_InputPanel* HYDROGUI_ImportImageOp::createInputPanel() const
 153 {
 154   HYDROGUI_InputPanel* aPanel = new HYDROGUI_ImportImageDlg( module(), getName() );
 155   connect( aPanel, SIGNAL( createPreview( QImage ) ),
 156            this, SLOT( onCreatePreview( QImage ) ) );
 157   connect( aPanel, SIGNAL( activatePointSelection( int ) ),
 158            this, SLOT( onActivatePointSelection( int ) ) );
 159   connect( aPanel, SIGNAL( pointCoordChanged( bool, int, bool, int ) ),
 160            this, SLOT( onPointCoordChanged( bool, int, bool, int ) ) );
 161   connect( aPanel, SIGNAL( refImageActivated( const QString& ) ),
 162            this, SLOT( onRefImageActivated( const QString& ) ) );
 163   return aPanel;
 164 }
 165
 166 bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags,
 167                                            QString& theErrorMsg )
 168 {
 169   HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
 170
 171   QString anImageName = aPanel->getImageName();
 172   if( anImageName.isEmpty() )
 173     return false;
 174
 175   if( !myIsEdit || ( !myEditedObject.IsNull() && myEditedObject->GetName() != anImageName ) )
 176   {
 177     // check that there are no other objects with the same name in the document
 178     Handle(HYDROData_Object) anObject = HYDROGUI_Tool::FindObjectByName( module(), anImageName );
 179     if( !anObject.IsNull() )
 180     {
 181       theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( anImageName );
 182       return false;
 183     }
 184   }
 185
 186   bool anIsRefImage = aPanel->getTransformationMode() == HYDROGUI_ImportImageDlg::RefImage;
 187
 188   HYDROGUI_ImportImageDlg::TransformationDataMap aMap;
 189   if( !aPanel->getTransformationDataMap( aMap ) )
 190     return false;
 191
 192   HYDROGUI_ImportImageDlg::TransformationDataMap aRefMap;
 193   if( anIsRefImage && !aPanel->getTransformationDataMap( aRefMap, true ) )
 194     return false;
 195
 196   QPoint aPointA1 = aMap[ HYDROGUI_PrsImage::PointA ].first;
 197   QPoint aPointB1 = aMap[ HYDROGUI_PrsImage::PointB ].first;
 198   QPoint aPointC1 = aMap[ HYDROGUI_PrsImage::PointC ].first;
 199
 200   QPointF aPointA2 = aMap[ HYDROGUI_PrsImage::PointA ].second;
 201   QPointF aPointB2 = aMap[ HYDROGUI_PrsImage::PointB ].second;
 202   QPointF aPointC2 = aMap[ HYDROGUI_PrsImage::PointC ].second;
 203
 204   QPoint aPointA3, aPointB3, aPointC3;
 205   if( anIsRefImage )
 206   {
 207     aPointA3 = aRefMap[ HYDROGUI_PrsImage::PointA ].first;
 208     aPointB3 = aRefMap[ HYDROGUI_PrsImage::PointB ].first;
 209     aPointC3 = aRefMap[ HYDROGUI_PrsImage::PointC ].first;
 210   }
 211
 212   int xa1 = aPointA1.x();
 213   int ya1 = aPointA1.y();
 214   int xb1 = aPointB1.x();
 215   int yb1 = aPointB1.y();
 216   int xc1 = aPointC1.x();
 217   int yc1 = aPointC1.y();
 218
 219   double xa2 = aPointA2.x();
 220   double ya2 = aPointA2.y();
 221   double xb2 = aPointB2.x();
 222   double yb2 = aPointB2.y();
 223   double xc2 = aPointC2.x();
 224   double yc2 = aPointC2.y();
 225
 226   int xa3 = aPointA3.x();
 227   int ya3 = aPointA3.y();
 228   int xb3 = aPointB3.x();
 229   int yb3 = aPointB3.y();
 230   int xc3 = aPointC3.x();
 231   int yc3 = aPointC3.y();
 232
 233   // first, check that three input points don't belong to a single line
 234   if( ( yb1 - ya1 ) * ( xc1 - xa1 ) == ( yc1 - ya1 ) * ( xb1 - xa1 ) )
 235   {
 236     theErrorMsg = tr( "POINTS_A_B_C_BELONG_TO_SINGLE_LINE" );
 237     return false;
 238   }
 239
 240   // the same check for the reference points
 241   if( anIsRefImage && ( ( yb3 - ya3 ) * ( xc3 - xa3 ) == ( yc3 - ya3 ) * ( xb3 - xa3 ) ) )
 242   {
 243     theErrorMsg = tr( "REFERENCE_POINTS_A_B_C_BELONG_TO_SINGLE_LINE" );
 244     return false;
 245   }
 246
 247   QTransform aTransform1( xa1, ya1, 1, xb1, yb1, 1, xc1, yc1, 1 );
 248   QTransform aTransform2( xa2, ya2, 1, xb2, yb2, 1, xc2, yc2, 1 );
 249   QTransform aTransform3( xa3, ya3, 1, xb3, yb3, 1, xc3, yc3, 1 );
 250
 251   bool anIsInvertible = false;
 252   QTransform aTransform1Inverted = aTransform1.inverted( &anIsInvertible );
 253   if( !anIsInvertible )
 254   {
 255     theErrorMsg = tr( "TRANSFORMATION_MATRIX_CANNOT_BE_COMPUTED" );
 256     return false;
 257   }
 258
 259   QTransform aTransform;
 260   if( anIsRefImage )
 261     aTransform = aTransform1Inverted * aTransform3 * myRefTransform;
 262   else
 263     aTransform = aTransform1Inverted * aTransform2;
 264
 265   Handle(HYDROData_Image) anImageObj;
 266   if( myIsEdit )
 267     anImageObj = myEditedObject;
 268   else
 269     anImageObj = Handle(HYDROData_Image)::DownCast( doc()->CreateObject( KIND_IMAGE ) );
 270
 271   if( anImageObj.IsNull() )
 272     return false;
 273
 274   anImageObj->SetName( anImageName );
 275
 276   anImageObj->SetImage( myImage );
 277   anImageObj->SetTrsf( aTransform );
 278
 279   if( anIsRefImage )
 280   {
 281     aPointA2 = QPointF( aTransform.map( aPointA1 ) );
 282     aPointB2 = QPointF( aTransform.map( aPointB1 ) );
 283     aPointC2 = QPointF( aTransform.map( aPointC1 ) );
 284   }
 285
 286   anImageObj->SetTrsfPoints( aPointA1, aPointB1, aPointC1,
 287                              aPointA2, aPointB2, aPointC2 );
 288
 289   if( !myIsEdit )
 290   {
 291     // Set imported file name for image
 292     QString aFilePath = aPanel->getFileName();
 293     anImageObj->SetFilePath( aFilePath );
 294   }
 295
 296   // must be done after all checks and before calling SetVisible() method below
 297   closePreview();
 298
 299   if( !myIsEdit )
 300     module()->setObjectVisible( HYDROGUI_Tool::GetActiveGraphicsViewId( module() ), anImageObj, true );
 301
 302   if( myIsEdit )
 303     if( HYDROOperations_Factory* aFactory = HYDROOperations_Factory::Factory() )
 304       aFactory->UpdateImage( doc(), anImageObj );
 305
 306   theUpdateFlags = UF_Model | UF_Viewer | UF_GV_Forced;
 307   return true;
 308 }
 309
 310 void HYDROGUI_ImportImageOp::onCreatePreview( QImage theImage )
 311 {
 312   myImage = theImage;
 313
 314   LightApp_Application* anApp = module()->getApp();
 315
 316   myActiveViewManager = anApp->activeViewManager();
 317
 318   myPreviewPrs = new HYDROGUI_PrsImage( myIsEdit ? myEditedObject : 0 );
 319   myPreviewPrs->setImage( myImage );
 320   myPreviewPrs->compute();
 321
 322   myPreviewViewManager =
 323     dynamic_cast<GraphicsView_ViewManager*>( anApp->createViewManager( GraphicsView_Viewer::Type() ) );
 324   if( myPreviewViewManager )
 325   {
 326     connect( myPreviewViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
 327              this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) );
 328
 329     module()->setViewManagerRole( myPreviewViewManager, HYDROGUI_Module::VMR_TransformImage );
 330     myPreviewViewManager->setTitle( tr( "TRANSFORM_IMAGE" ) );
 331     if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() )
 332     {
 333       if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() )
 334       {
 335         //aViewPort->setMousePositionEnabled( true ); //ouv: temporarily commented
 336
 337         aViewPort->addItem( myPreviewPrs );
 338         aViewPort->fitAll();
 339
 340         myPreviewPrs->setIsTransformationPointPreview( true );
 341       }
 342       connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ),
 343                this, SLOT( onPointSelected() ) );
 344     }
 345   }
 346
 347   HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
 348
 349   QString anImageName;
 350   if( myIsEdit )
 351   {
 352     if( !myEditedObject.IsNull() )
 353       anImageName = myEditedObject->GetName();
 354   }
 355   else
 356     anImageName = HYDROGUI_Tool::GenerateObjectName( module(), "Image" );
 357   aPanel->setImageName( anImageName );
 358
 359   aPanel->setImageSize( myImage.size() );
 360
 361   aPanel->initializePointSelection();
 362   onPointSelected( false );
 363 }
 364
 365 void HYDROGUI_ImportImageOp::onActivatePointSelection( int thePointType )
 366 {
 367   myPointType = thePointType;
 368   if( myPreviewPrs )
 369     myPreviewPrs->setTransformationPointType( thePointType );
 370   if( myRefPreviewPrs )
 371     myRefPreviewPrs->setTransformationPointType( thePointType );
 372 }
 373
 374 void HYDROGUI_ImportImageOp::onPointCoordChanged( bool theIsRef,
 375                                                   int thePointType,
 376                                                   bool theIsY,
 377                                                   int theValue )
 378 {
 379   if( !theIsRef && myPreviewPrs )
 380     myPreviewPrs->updateTransformationPoint( thePointType, theIsY, theValue );
 381   else if( theIsRef && myRefPreviewPrs )
 382     myRefPreviewPrs->updateTransformationPoint( thePointType, theIsY, theValue );
 383 }
 384
 385 void HYDROGUI_ImportImageOp::onRefImageActivated( const QString& theName )
 386 {
 387   myRefTransform.reset();
 388
 389   GraphicsView_ViewPort* aViewPort = 0;
 390   if( myPreviewViewManager )
 391     if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() )
 392       aViewPort = aViewer->getActiveViewPort();
 393
 394   if( !aViewPort )
 395     return;
 396
 397   if( myPreviewPrs )
 398     myPreviewPrs->setCaption( QString() );
 399
 400   if( myRefPreviewPrs )
 401   {
 402     myRefPreviewPrs->setCaption( QString() );
 403     aViewPort->removeItem( myRefPreviewPrs );
 404
 405     delete myRefPreviewPrs;
 406     myRefPreviewPrs = 0;
 407   }
 408
 409   QImage anImage;
 410   Handle(HYDROData_Image) anImageObj = Handle(HYDROData_Image)::DownCast(
 411     HYDROGUI_Tool::FindObjectByName( module(), theName, KIND_IMAGE ) );
 412   if( !anImageObj.IsNull() )
 413   {
 414     anImage = anImageObj->Image();
 415     myRefTransform = anImageObj->Trsf();
 416
 417     myRefPreviewPrs = new HYDROGUI_PrsImage( anImageObj );
 418     myRefPreviewPrs->setImage( anImage );
 419     myRefPreviewPrs->compute();
 420
 421     myRefPreviewPrs->setIsTransformationPointPreview( true );
 422     myRefPreviewPrs->setTransformationPointType( myPointType );
 423
 424     // vertically shift the reference prs relatively to the main prs
 425     if( myPreviewPrs )
 426     {
 427       myPreviewPrs->setCaption( tr( "IMPORTED_IMAGE" ) );
 428
 429       QImage anImage = myPreviewPrs->getImage();
 430       myRefPreviewPrs->moveBy( 0, anImage.height() + 60 );
 431       myRefPreviewPrs->setCaption( tr( "REFERENCE_IMAGE" ) );
 432     }
 433
 434     aViewPort->addItem( myRefPreviewPrs );
 435   }
 436
 437   aViewPort->fitAll();
 438
 439   HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
 440
 441   aPanel->setImageSize( anImage.size(), true );
 442
 443   aPanel->initializePointSelection();
 444   onPointSelected( true );
 445 }
 446
 447 void HYDROGUI_ImportImageOp::onLastViewClosed( SUIT_ViewManager* theViewManager )
 448 {
 449   closePreview();
 450 }
 451
 452 void HYDROGUI_ImportImageOp::onPointSelected()
 453 {
 454   onPointSelected( myRefPreviewPrs && myRefPreviewPrs->isSelected() );
 455 }
 456
 457 void HYDROGUI_ImportImageOp::onPointSelected( bool theIsRefImage )
 458 {
 459   HYDROGUI_PrsImage* aPrs = theIsRefImage ? myRefPreviewPrs : myPreviewPrs;
 460   if( !aPrs )
 461     return;
 462
 463   HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
 464
 465   const HYDROGUI_PrsImage::TransformationPointMap& aPointMap =
 466     aPrs->getTransformationPointMap();
 467   HYDROGUI_PrsImage::TransformationPointMapIterator anIter( aPointMap );
 468   while( anIter.hasNext() )
 469   {
 470     int aPointType = anIter.next().key();
 471     const HYDROGUI_PrsImage::TransformationPoint& aTransformationPoint = anIter.value();
 472     const QPoint& aPoint = aTransformationPoint.Point;
 473
 474     HYDROGUI_ImportImageDlg::TransformationData aData( aPoint, QPointF() );
 475     aDataMap[ aPointType ] = aData;
 476   }
 477
 478   ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setTransformationDataMap( aDataMap, true, theIsRefImage );
 479 }
 480
 481 void HYDROGUI_ImportImageOp::closePreview()
 482 {
 483   if( myPreviewPrs )
 484   {
 485     delete myPreviewPrs;
 486     myPreviewPrs = 0;
 487   }
 488
 489   if( myRefPreviewPrs )
 490   {
 491     delete myRefPreviewPrs;
 492     myRefPreviewPrs = 0;
 493   }
 494
 495   if( myPreviewViewManager )
 496   {
 497     disconnect( myPreviewViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
 498                 this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) );
 499
 500     module()->getApp()->removeViewManager( myPreviewViewManager ); // myPreviewViewManager is deleted here
 501     myPreviewViewManager = 0;
 502   }
 503
 504   if( myActiveViewManager )
 505     HYDROGUI_Tool::SetActiveViewManager( module(), myActiveViewManager );
 506 }