1 // Copyright (C) 2014-2015 EDF-R&D
2 // This library is free software; you can redistribute it and/or
3 // modify it under the terms of the GNU Lesser General Public
4 // License as published by the Free Software Foundation; either
5 // version 2.1 of the License, or (at your option) any later version.
7 // This library is distributed in the hope that it will be useful,
8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10 // Lesser General Public License for more details.
12 // You should have received a copy of the GNU Lesser General Public
13 // License along with this library; if not, write to the Free Software
14 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 #include "HYDROGUI_ImportImageOp.h"
21 #include "HYDROGUI_DataModel.h"
22 #include <HYDROGUI_DataObject.h>
23 #include "HYDROGUI_ImportImageDlg.h"
24 #include "HYDROGUI_Module.h"
25 #include "HYDROGUI_PrsImage.h"
26 #include "HYDROGUI_Tool2.h"
27 #include "HYDROGUI_UpdateFlags.h"
29 #include <HYDROData_Iterator.h>
30 #include <HYDROData_Tool.h>
32 #include <GraphicsView_ViewManager.h>
33 #include <GraphicsView_ViewPort.h>
34 #include <GraphicsView_Viewer.h>
36 #include <LightApp_Application.h>
37 #include <LightApp_UpdateFlags.h>
39 #include <STD_TabDesktop.h>
40 #include <SUIT_Desktop.h>
41 #include <SUIT_MessageBox.h>
42 #include <QtxWorkstack.h>
43 #include <QApplication>
46 HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule,
47 const bool theIsEdit )
48 : HYDROGUI_Operation( theModule ),
49 myIsEdit( theIsEdit ),
51 myActiveViewManager( 0 ),
52 myPreviewViewManager( 0 ),
53 myRefViewManager( 0 ),
56 myPointType( HYDROGUI_PrsImage::None )
58 setName( theIsEdit ? tr( "EDIT_IMPORTED_IMAGE" ) : tr( "IMPORT_IMAGE" ) );
61 HYDROGUI_ImportImageOp::~HYDROGUI_ImportImageOp()
65 void HYDROGUI_ImportImageOp::startOperation()
67 HYDROGUI_Operation::startOperation();
69 HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
71 aPanel->setIsEdit( myIsEdit );
73 QString aRefImageName;
77 if ( isApplyAndClose() )
78 myEditedObject = Handle(HYDROData_Image)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) );
79 if( !myEditedObject.IsNull() )
81 QImage anImage = myEditedObject->Image();
82 bool anIsByTwoPoints = myEditedObject->IsByTwoPoints();
84 QPoint aLocalPointA, aLocalPointB, aLocalPointC;
85 myEditedObject->GetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC );
87 // Create the edited image preview presentation in the viewer
88 onCreatePreview( anImage );
90 // Set transformation local points A,B,C to the image preview presentation
91 setPresentationTrsfPoints( myPreviewPrs, anIsByTwoPoints, aLocalPointA,
92 aLocalPointB, aLocalPointC );
94 // Build the existing image local and global points mapping
95 // according to the current transformation mode.
96 HYDROData_Image::TransformationMode aTrsfMode = myEditedObject->GetTrsfMode();
97 QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC;
98 HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
99 if ( aTrsfMode == HYDROData_Image::ReferenceImage )
101 // Compute global points using the transformation matrix of the reference image
102 Handle(HYDROData_Image) aRefImage = myEditedObject->GetTrsfReferenceImage();
103 if ( !aRefImage.IsNull() )
105 QTransform aRefTrsf = aRefImage->Trsf(); // The reference image transformation matrix
106 aTrsfPointA = aRefTrsf.map( aLocalPointA ); // Compute the global point A
107 aTrsfPointB = aRefTrsf.map( aLocalPointB ); // Compute the global point B
108 if ( !anIsByTwoPoints )
110 aTrsfPointC = aRefTrsf.map( aLocalPointC ); // Compute the global point C if used
112 // Build the local-global points map
113 // Use the reference image transformation mode for interpreting global points
114 computeTrsfData( aRefImage->GetTrsfMode(), anIsByTwoPoints, aLocalPointA, aLocalPointB, aLocalPointC,
115 aTrsfPointA, aTrsfPointB, aTrsfPointC, aDataMap );
120 // Get global points from the edited image
121 myEditedObject->GetGlobalPoints( aTrsfMode, aTrsfPointA, aTrsfPointB, aTrsfPointC );
122 // Build the local-global points map
123 computeTrsfData( aTrsfMode, anIsByTwoPoints, aLocalPointA, aLocalPointB, aLocalPointC,
124 aTrsfPointA, aTrsfPointB, aTrsfPointC, aDataMap );
127 // Initialize the dialog mode, local and global coordinates
128 // except coordinates on the reference image
129 aPanel->setTransformationMode( aTrsfMode );
130 aPanel->setTransformationDataMap( aDataMap );
131 aPanel->setByTwoPoints( anIsByTwoPoints );
133 // Set points of the reference image
134 if ( aTrsfMode == HYDROData_Image::ReferenceImage )
136 Handle(HYDROData_Image) aRefImage;
137 myEditedObject->GetReferencePoints( aRefImage,
138 aTrsfPointA, aTrsfPointB, aTrsfPointC );
139 if ( !aRefImage.IsNull() )
141 aRefImageName = aRefImage->GetName();
143 // Create the reference image presentation in the viewer
144 onRefImageActivated( aRefImageName );
146 // Set transformation points A,B,C to the reference image presentation
147 setPresentationTrsfPoints( myRefPreviewPrs, anIsByTwoPoints, aTrsfPointA.toPoint(),
148 aTrsfPointB.toPoint(), aTrsfPointC.toPoint() );
150 // Prepare A, B, C points on the reference image
151 HYDROGUI_ImportImageDlg::TransformationDataMap aRefDataMap;
152 aRefDataMap[ HYDROGUI_PrsImage::PointA ] =
153 HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointA.toPoint() );
154 aRefDataMap[ HYDROGUI_PrsImage::PointB ] =
155 HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointB.toPoint() );
156 if ( !anIsByTwoPoints )
157 aRefDataMap[ HYDROGUI_PrsImage::PointC ] =
158 HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointC.toPoint() );
160 // Initialize the dialog's A, B, C points coordinates of the reference image
161 aPanel->setTransformationDataMap( aRefDataMap, true, true );
167 HYDROGUI_ImportImageDlg::PrsPointDataList aPrsPointDataList;
168 getReferenceDataList( aPrsPointDataList );
169 aPanel->setPrsPointDataList( aPrsPointDataList );
170 // Select the current reference image in the dialog combobox
171 aPanel->setRefImageName( aRefImageName );
174 void HYDROGUI_ImportImageOp::setPresentationTrsfPoints( HYDROGUI_PrsImage* thePrs,
175 bool theIsByTwoPoints,
176 const QPoint theLocalPointA,
177 const QPoint theLocalPointB,
178 const QPoint theLocalPointC )
180 // Set transformation points A,B,C to the image presentation
183 HYDROGUI_PrsImage::TransformationPointMap aPointMap =
184 thePrs->getTransformationPointMap();
185 if( !aPointMap.isEmpty() )
187 aPointMap[ HYDROGUI_PrsImage::PointA ].Point = theLocalPointA;
188 aPointMap[ HYDROGUI_PrsImage::PointB ].Point = theLocalPointB;
189 if ( !theIsByTwoPoints )
190 aPointMap[ HYDROGUI_PrsImage::PointC ].Point = theLocalPointC;
192 thePrs->setIsByTwoPoints( theIsByTwoPoints );
193 thePrs->setTransformationPointMap( aPointMap );
198 void HYDROGUI_ImportImageOp::getReferenceDataList(
199 HYDROGUI_ImportImageDlg::PrsPointDataList& theList ) const
201 // Collect information about existing images and initialize the combobox
202 // reference image selector in the dialog.
203 HYDROData_Iterator anIterator( doc(), KIND_IMAGE );
204 for( ; anIterator.More(); anIterator.Next() )
206 Handle(HYDROData_Image) anImageObj = Handle(HYDROData_Image)::DownCast( anIterator.Current() );
207 if( !anImageObj.IsNull() )
209 if( myIsEdit && IsEqual( anImageObj, myEditedObject ) )
212 QPoint aLocalPointA, aLocalPointB, aLocalPointC;
213 anImageObj->GetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC );
215 HYDROData_Image::TransformationMode aImgTrsfMode;
216 QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC;
217 anImageObj->GetGlobalPoints( aImgTrsfMode,
218 aTrsfPointA, aTrsfPointB, aTrsfPointC );
220 HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
221 computeTrsfData( aImgTrsfMode, false, aLocalPointA, aLocalPointB, aLocalPointC,
222 aTrsfPointA, aTrsfPointB, aTrsfPointC, aDataMap );
224 HYDROGUI_ImportImageDlg::PrsPointData aPrsPointData( anImageObj->GetName(), aDataMap );
225 theList.append( aPrsPointData );
230 void HYDROGUI_ImportImageOp::computeTrsfData( HYDROData_Image::TransformationMode theTrsfMode,
231 bool theIsByTwoPoints,
232 const QPoint& theLocalPointA,
233 const QPoint& theLocalPointB,
234 const QPoint& theLocalPointC,
235 const QPointF& theGlobalPointA,
236 const QPointF& theGlobalPointB,
237 const QPointF& theGlobalPointC,
238 HYDROGUI_ImportImageDlg::TransformationDataMap& theDataMap ) const
240 // Build the local-global points map
241 HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
242 theDataMap[ HYDROGUI_PrsImage::PointA ] =
243 HYDROGUI_ImportImageDlg::ComputeTrsfData( theTrsfMode, theLocalPointA, theGlobalPointA );
244 theDataMap[ HYDROGUI_PrsImage::PointB ] =
245 HYDROGUI_ImportImageDlg::ComputeTrsfData( theTrsfMode, theLocalPointB, theGlobalPointB );
246 if ( !theIsByTwoPoints )
248 theDataMap[ HYDROGUI_PrsImage::PointC ] =
249 HYDROGUI_ImportImageDlg::ComputeTrsfData( theTrsfMode, theLocalPointC, theGlobalPointC );
253 void HYDROGUI_ImportImageOp::abortOperation()
257 HYDROGUI_Operation::abortOperation();
260 void HYDROGUI_ImportImageOp::commitOperation()
262 if ( isApplyAndClose() )
265 HYDROGUI_Operation::commitOperation();
268 HYDROGUI_InputPanel* HYDROGUI_ImportImageOp::createInputPanel() const
270 HYDROGUI_InputPanel* aPanel = new HYDROGUI_ImportImageDlg( module(), getName() );
271 connect( aPanel, SIGNAL( createPreview( QImage ) ), SLOT( onCreatePreview( QImage ) ) );
272 connect( aPanel, SIGNAL( activatePointSelection( int ) ), SLOT( onActivatePointSelection( int ) ) );
273 connect( aPanel, SIGNAL( pointCoordChanged( bool, int, bool, int ) ),
274 SLOT( onPointCoordChanged( bool, int, bool, int ) ) );
275 connect( aPanel, SIGNAL( modeActivated( int ) ), SLOT( onModeActivated( int ) ) );
276 connect( aPanel, SIGNAL( refImageActivated( const QString& ) ),
277 SLOT( onRefImageActivated( const QString& ) ) );
278 connect( aPanel, SIGNAL( setCIsUsed( bool ) ), SLOT( onSetCIsUsed( bool ) ) );
279 connect( aPanel, SIGNAL( filesSelected( const QStringList& ) ),
280 SLOT( onFilesSelected( const QStringList& ) ) );
284 void HYDROGUI_ImportImageOp::onSetCIsUsed( bool theCIsUsed )
288 myPreviewPrs->setIsByTwoPoints( !theCIsUsed );
290 if ( myRefPreviewPrs )
292 myRefPreviewPrs->setIsByTwoPoints( !theCIsUsed );
296 bool HYDROGUI_ImportImageOp::checkPoints( const QPointF& thePointA,
297 const QPointF& thePointB,
298 const QPointF& thePointC,
299 const bool theIsByTwoPoints,
300 const QString& theLineErrMsg,
301 const QString& thePoinErrMsg,
302 QString& theErrorMsg,
303 const bool theIsToCheckInvertibles ) const
305 double xa = thePointA.x();
306 double ya = thePointA.y();
307 double xb = thePointB.x();
308 double yb = thePointB.y();
309 double xc = thePointC.x();
310 double yc = thePointC.y();
312 if ( !theIsByTwoPoints )
314 // check that three input points don't belong to a single line
315 if ( ValuesEquals( ( yb - ya ) * ( xc - xa ), ( yc - ya ) * ( xb - xa ) ) )
317 theErrorMsg = theLineErrMsg;
321 if ( theIsToCheckInvertibles )
323 QTransform aTransform1( xa, ya, 1, xb, yb, 1, xc, yc, 1 );
325 bool anIsInvertible = false;
326 QTransform aTransform1Inverted = aTransform1.inverted( &anIsInvertible );
327 if( !anIsInvertible )
329 theErrorMsg = tr( "TRANSFORMATION_MATRIX_CANNOT_BE_COMPUTED" );
336 // check that two points are not identical
337 if ( ValuesEquals( xa, xb ) && ValuesEquals( ya, yb ) )
339 theErrorMsg = thePoinErrMsg;
347 bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags,
348 QString& theErrorMsg,
349 QStringList& theBrowseObjectsEntries )
351 HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
355 QString aFilePath = aPanel->getFileName();
356 if( aFilePath.isEmpty() )
358 theErrorMsg = tr( "SELECT_IMAGE_FILE" ).arg( aFilePath );
363 QString anImageName = aPanel->getImageName();
364 if( anImageName.isEmpty() )
366 theErrorMsg = tr( "SELECT_IMAGE_NAME" ).arg( anImageName );
370 if( !myIsEdit || ( !myEditedObject.IsNull() && myEditedObject->GetName() != anImageName ) )
372 // check that there are no other objects with the same name in the document
373 Handle(HYDROData_Entity) anObject = HYDROGUI_Tool::FindObjectByName( module(), anImageName );
374 if( !anObject.IsNull() )
376 theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( anImageName );
381 HYDROData_Image::TransformationMode aTransformationMode =
382 (HYDROData_Image::TransformationMode)aPanel->getTransformationMode();
384 QPoint aPointA, aPointB, aPointC;
385 QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC( INT_MIN, INT_MIN );
386 Handle(HYDROData_Image) aRefImageObj;
388 if ( aTransformationMode != HYDROData_Image::CartesianFromFile ) {
389 HYDROGUI_ImportImageDlg::TransformationDataMap aMap;
390 if( !aPanel->getTransformationDataMap( aMap ) )
393 bool anIsByTwoPoints = aPanel->isByTwoPoints();
395 aPointA = aMap[ HYDROGUI_PrsImage::PointA ].ImagePoint;
396 aPointB = aMap[ HYDROGUI_PrsImage::PointB ].ImagePoint;
397 aPointC = anIsByTwoPoints ? QPoint( INT_MIN, INT_MIN ) :
398 aMap[ HYDROGUI_PrsImage::PointC ].ImagePoint;
400 // first, we check correctness of image points
401 if ( !checkPoints( aPointA, aPointB, aPointC, anIsByTwoPoints,
402 tr( "POINTS_A_B_C_BELONG_TO_SINGLE_LINE" ),
403 tr( "POINTS_A_B_ARE_IDENTICAL" ),
404 theErrorMsg, true ) )
407 if ( aTransformationMode == HYDROData_Image::ReferenceImage )
409 QString aRefImageName = aPanel->getRefImageName();
410 if( aRefImageName.isEmpty() )
412 theErrorMsg = tr( "REFERENCE_IMAGE_IS_NOT_SELECTED" );
416 HYDROGUI_ImportImageDlg::TransformationDataMap aRefMap;
417 if( !aPanel->getTransformationDataMap( aRefMap, true ) )
420 aRefImageObj = Handle(HYDROData_Image)::DownCast(
421 HYDROGUI_Tool::FindObjectByName( module(), aRefImageName, KIND_IMAGE ) );
422 if( aRefImageObj.IsNull() ) {
425 else if ( !isReferenceCorrect() ) {
426 aRefImageObj->RemoveAllReferences();
429 aTrsfPointA = aRefMap[ HYDROGUI_PrsImage::PointA ].ImagePoint;
430 aTrsfPointB = aRefMap[ HYDROGUI_PrsImage::PointB ].ImagePoint;
431 if ( !anIsByTwoPoints )
432 aTrsfPointC = aRefMap[ HYDROGUI_PrsImage::PointC ].ImagePoint;
434 // the same check of correctness for the reference points
435 if ( !checkPoints( aTrsfPointA, aTrsfPointB, aTrsfPointC, anIsByTwoPoints,
436 tr( "REFERENCE_POINTS_A_B_C_BELONG_TO_SINGLE_LINE" ),
437 tr( "REFERENCE_POINTS_A_B_ARE_IDENTICAL" ),
438 theErrorMsg, false ) )
443 if ( aTransformationMode == HYDROData_Image::ManualGeodesic )
445 aTrsfPointA = aMap[ HYDROGUI_PrsImage::PointA ].GeodesicPoint;
446 aTrsfPointB = aMap[ HYDROGUI_PrsImage::PointB ].GeodesicPoint;
447 if ( !anIsByTwoPoints )
448 aTrsfPointC = aMap[ HYDROGUI_PrsImage::PointC ].GeodesicPoint;
452 aTrsfPointA = aMap[ HYDROGUI_PrsImage::PointA ].CartesianPoint;
453 aTrsfPointB = aMap[ HYDROGUI_PrsImage::PointB ].CartesianPoint;
454 if ( !anIsByTwoPoints )
455 aTrsfPointC = aMap[ HYDROGUI_PrsImage::PointC ].CartesianPoint;
460 Handle(HYDROData_Image) anImageObj;
462 anImageObj = myEditedObject;
465 anImageObj = Handle(HYDROData_Image)::DownCast( doc()->CreateObject( KIND_IMAGE ) );
466 QString anEntry = HYDROGUI_DataObject::dataObjectEntry( anImageObj );
467 theBrowseObjectsEntries.append( anEntry );
470 if( anImageObj.IsNull() )
473 anImageObj->SetName( anImageName );
474 anImageObj->SetImage( myImage );
476 if ( aTransformationMode == HYDROData_Image::CartesianFromFile ) {
477 QString aGeoreferencementFileName = aPanel->getGeoreferencementFileName();
478 if ( aGeoreferencementFileName.isEmpty() ) {
482 QPoint aLocalPointA( 0, 0 ),
483 aLocalPointB( anImageObj->Image().width(), 0 ),
484 aLocalPointC( INT_MIN, INT_MIN );
485 anImageObj->SetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC, false );
486 if ( !anImageObj->SetGlobalPointsFromFile( aGeoreferencementFileName ) ) {
487 theErrorMsg = tr( "CANT_LOAD_GEOREFERENCEMENT_FILE" );
491 anImageObj->SetLocalPoints( aPointA, aPointB, aPointC, false );
493 if ( aTransformationMode == HYDROData_Image::ReferenceImage )
495 anImageObj->SetReferencePoints( aRefImageObj,
496 aTrsfPointA, aTrsfPointB, aTrsfPointC );
500 anImageObj->SetGlobalPoints( aTransformationMode,
501 aTrsfPointA, aTrsfPointB, aTrsfPointC );
507 // Set imported file name for image
508 QString aFilePath = aPanel->getFileName();
509 anImageObj->SetFilePath( aFilePath );
512 // must be done after all checks and before calling SetVisible() method below
513 if ( isApplyAndClose() )
517 module()->setObjectVisible( HYDROGUI_Tool::GetActiveGraphicsViewId( module() ), anImageObj, true );
519 anImageObj->Update();
521 theUpdateFlags = UF_Model;
522 if ( isApplyAndClose() )
523 theUpdateFlags |= UF_Viewer | UF_GV_Forced | UF_OCCViewer | UF_OCC_Forced;
525 if( isApplyAndClose() )
527 commitDocOperation(); // to save the modifications in the data model
534 module()->updateObjBrowser();
535 return false; // and to continue the operation
538 /*if( myFiles.count() > 1 )
540 setIsApplyAndClose( true );
545 bool HYDROGUI_ImportImageOp::isReferenceCorrect() const
547 bool isCorrect = true;
549 if( myIsEdit && !myEditedObject.IsNull() )
551 HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
552 Handle(HYDROData_Image) aRefImageObj = Handle(HYDROData_Image)::DownCast(
553 HYDROGUI_Tool::FindObjectByName( module(), aPanel->getRefImageName(), KIND_IMAGE ) );
554 if( !aRefImageObj.IsNull() )
556 bool isFoundEdited = false;
557 HYDROData_SequenceOfObjects aRefSeq = aRefImageObj->GetAllReferenceObjects();
558 for ( int i = 1, n = aRefSeq.Length(); i <= n && !isFoundEdited; ++i )
560 Handle(HYDROData_Entity) anObject = aRefSeq.Value( i );
561 isFoundEdited = anObject->GetName() == myEditedObject->GetName();
563 isCorrect = !isFoundEdited;
569 void HYDROGUI_ImportImageOp::apply()
571 HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
573 bool aCanApply = isReferenceCorrect();
574 if ( !aCanApply && !myEditedObject.IsNull() )
576 Handle(HYDROData_Image) aRefImageObj = Handle(HYDROData_Image)::DownCast(
577 HYDROGUI_Tool::FindObjectByName( module(), aPanel->getRefImageName(), KIND_IMAGE ) );
578 if ( !aRefImageObj.IsNull() )
579 aCanApply = SUIT_MessageBox::question( module()->getApp()->desktop(),
580 tr( "CORRECT_INPUT_DATA" ), tr( "CONFIRM_REMOVE_REFERENCE_FROM_IMAGE" ).
581 arg( aRefImageObj->GetName() ).arg( myEditedObject->GetName() ),
582 QMessageBox::Yes | QMessageBox::No, QMessageBox::No ) == QMessageBox::Yes;
585 HYDROGUI_Operation::apply();
587 aPanel->setRefImageName( "" );
588 onRefImageActivated( aPanel->getRefImageName() );
592 void HYDROGUI_ImportImageOp::onCreatePreview( QImage theImage )
594 HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
598 if( myPreviewPrs ) // if the image is changed by choosing another file
600 myPreviewPrs->setImage( myImage, true );
601 if ( sender() ) // reset the previous presentation settings
603 QString aFileName = aPanel->getFileName();
606 aPanel->setIsEdit( myIsEdit );
607 // restore the file name
608 aPanel->setFileName( aFileName );
609 // fill the reference list
610 HYDROGUI_ImportImageDlg::PrsPointDataList aPrsPointDataList;
611 getReferenceDataList( aPrsPointDataList );
612 aPanel->setPrsPointDataList( aPrsPointDataList );
614 if( myPreviewViewManager )
616 if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() )
618 if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() )
620 aViewPort->onBoundingRectChanged();
628 LightApp_Application* anApp = module()->getApp();
630 myActiveViewManager = anApp->activeViewManager();
632 myPreviewPrs = new HYDROGUI_PrsImage( myIsEdit ? myEditedObject : 0 );
633 myPreviewPrs->setImage( myImage, true );
635 myPreviewViewManager =
636 dynamic_cast<GraphicsView_ViewManager*>( anApp->createViewManager( GraphicsView_Viewer::Type() ) );
637 if( myPreviewViewManager )
639 connect( myPreviewViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
640 this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) );
642 module()->setViewManagerRole( myPreviewViewManager, HYDROGUI_Module::VMR_TransformImage );
643 myPreviewViewManager->setTitle( tr( "TRANSFORM_IMAGE" ) );
644 if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() )
646 if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() )
648 //aViewPort->setMousePositionEnabled( true ); //ouv: temporarily commented
650 aViewPort->addItem( myPreviewPrs );
653 if ( myEditedObject ) {
654 size_t aViewId = (size_t)aViewer;
655 module()->setObjectVisible( aViewId, myEditedObject, true );
658 myPreviewPrs->setIsTransformationPointPreview( true );
659 myPreviewPrs->setTransformationPointCursorShape( module()->getPrefEditCursor().shape() );
661 connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ),
662 this, SLOT( onPointSelected() ) );
667 // Set the image name in the dialog
668 QString anImageName = aPanel->getImageName().simplified();
669 // If edit mode and the name was not set yet then get from the edited object
670 if( myIsEdit && anImageName.isEmpty() )
672 if( !myEditedObject.IsNull() )
673 anImageName = myEditedObject->GetName();
675 // If the name was not set then initialize it from the selected file name
676 if ( anImageName.isEmpty() )
678 anImageName = aPanel->getFileName();
679 if ( !anImageName.isEmpty() ) {
680 anImageName = QFileInfo( anImageName ).baseName();
682 // If no file name then generate a new image name
683 if ( anImageName.isEmpty() ) {
684 anImageName = HYDROGUI_Tool::GenerateObjectName( module(), tr( "DEFAULT_IMAGE_NAME" ) );
687 aPanel->setImageName( anImageName );
689 aPanel->setImageSize( myImage.size() );
691 aPanel->initializePointSelection();
692 onPointSelected( false );
693 onSetCIsUsed( !aPanel->isByTwoPoints() );
696 void HYDROGUI_ImportImageOp::onActivatePointSelection( int thePointType )
698 myPointType = thePointType;
700 myPreviewPrs->setTransformationPointType( thePointType );
701 if( myRefPreviewPrs )
702 myRefPreviewPrs->setTransformationPointType( thePointType );
705 void HYDROGUI_ImportImageOp::onPointCoordChanged( bool theIsRef,
710 if( !theIsRef && myPreviewPrs )
711 myPreviewPrs->updateTransformationPoint( thePointType, theIsY, theValue );
712 else if( theIsRef && myRefPreviewPrs )
713 myRefPreviewPrs->updateTransformationPoint( thePointType, theIsY, theValue );
716 void HYDROGUI_ImportImageOp::onModeActivated( int theMode )
718 HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
720 QString aRefImageName;
721 if( theMode == HYDROData_Image::ReferenceImage )
723 aRefImageName = aPanel->getRefImageName();
724 if( aRefImageName.isEmpty() )
725 return; // do nothing in this case to avoid visual moving of preview prs
726 onRefImageActivated( aRefImageName );
730 if( myRefViewManager )
732 closeView( myRefViewManager );
737 void HYDROGUI_ImportImageOp::onRefImageActivated( const QString& theName )
739 if( theName.isEmpty() ) {
740 if( myRefViewManager )
741 closeView( myRefViewManager );
745 GraphicsView_ViewPort* aViewPort = 0;
747 LightApp_Application* anApp = module()->getApp();
748 ///// Get a view port for the reference image preview
749 if( myRefViewManager )
751 if( GraphicsView_Viewer* aViewer = myRefViewManager->getViewer() )
753 aViewPort = aViewer->getActiveViewPort();
758 anApp = module()->getApp();
759 // Init reference image preview
761 dynamic_cast<GraphicsView_ViewManager*>( anApp->createViewManager( GraphicsView_Viewer::Type() ) );
762 if( myRefViewManager )
764 connect( myRefViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
765 this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) );
767 module()->setViewManagerRole( myRefViewManager, HYDROGUI_Module::VMR_ReferenceImage );
768 myRefViewManager->setTitle( tr( "REFERENCE_IMAGE" ) );
769 if( GraphicsView_Viewer* aViewer = myRefViewManager->getViewer() )
771 aViewPort = aViewer->getActiveViewPort();
772 connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ),
773 this, SLOT( onRefPointSelected() ) );
781 size_t aViewId = (size_t)myRefViewManager->getViewer();
783 // Remove the old presentation of the reference image if any
784 if( myRefPreviewPrs )
786 module()->setObjectVisible( aViewId, myRefPreviewPrs->getObject(), false );
788 myRefPreviewPrs->setCaption( QString() );
789 aViewPort->removeItem( myRefPreviewPrs );
791 delete myRefPreviewPrs;
795 // Create a new reference image presentation
797 Handle(HYDROData_Image) anImageObj = Handle(HYDROData_Image)::DownCast(
798 HYDROGUI_Tool::FindObjectByName( module(), theName, KIND_IMAGE ) );
799 HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel();
800 if( !anImageObj.IsNull() )
802 anImage = anImageObj->Image();
804 myRefPreviewPrs = new HYDROGUI_PrsImage( anImageObj );
805 myRefPreviewPrs->setImage( anImage, true );
807 myRefPreviewPrs->setIsTransformationPointPreview( true );
808 myRefPreviewPrs->setTransformationPointType( myPointType );
810 myRefPreviewPrs->setIsByTwoPoints( aPanel->isByTwoPoints() );
812 myRefPreviewPrs->setTransformationPointCursorShape( module()->getPrefEditCursor().shape() );
814 // Add the new reference image presentation to the appropriate view
815 aViewPort->addItem( myRefPreviewPrs );
817 module()->setObjectVisible( aViewId, anImageObj, true );
822 // Split views horizontally
823 if( anApp->desktop()->inherits( "STD_TabDesktop" ) )
825 qApp->processEvents();
826 QtxWorkstack* aWorkstack = ( (STD_TabDesktop*)anApp->desktop() )->workstack();
827 aViewPort->activateWindow();
829 aViewPort->setFocus(Qt::ActiveWindowFocusReason);
830 aWorkstack->splitHorizontal();
833 // Initialize the dialog
834 aPanel->setImageSize( anImage.size(), true );
835 aPanel->initializePointSelection();
836 onPointSelected( true );
839 void HYDROGUI_ImportImageOp::onLastViewClosed( SUIT_ViewManager* theViewManager )
844 void HYDROGUI_ImportImageOp::onPointSelected()
846 onPointSelected( myRefPreviewPrs && myRefPreviewPrs->isSelected() );
849 void HYDROGUI_ImportImageOp::onRefPointSelected()
851 onPointSelected( true );
854 void HYDROGUI_ImportImageOp::onPointSelected( bool theIsRefImage )
856 HYDROGUI_PrsImage* aPrs = theIsRefImage ? myRefPreviewPrs : myPreviewPrs;
860 HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
862 const HYDROGUI_PrsImage::TransformationPointMap& aPointMap =
863 aPrs->getTransformationPointMap();
865 HYDROGUI_PrsImage::TransformationPointMapIterator anIter( aPointMap );
866 while( anIter.hasNext() )
868 int aPointType = anIter.next().key();
869 const HYDROGUI_PrsImage::TransformationPoint& aTransformationPoint = anIter.value();
870 const QPoint& aPoint = aTransformationPoint.Point;
872 HYDROGUI_ImportImageDlg::TransformationData aData( aPoint, QPointF(), QPointF() );
873 aDataMap[ aPointType ] = aData;
876 ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setTransformationDataMap( aDataMap, true, theIsRefImage );
879 void HYDROGUI_ImportImageOp::closePreview()
881 closeView( myPreviewViewManager );
882 closeView( myRefViewManager );
884 if( myActiveViewManager )
885 HYDROGUI_Tool::SetActiveViewManager( module(), myActiveViewManager );
888 void HYDROGUI_ImportImageOp::closeView( GraphicsView_ViewManager* &aViewMgr )
892 GraphicsView_ViewPort* aViewPort = 0;
893 if( GraphicsView_Viewer* aViewer = aViewMgr->getViewer() )
895 aViewPort = aViewer->getActiveViewPort();
897 disconnect( aViewMgr, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
898 this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) );
900 // Nullify appropriate presentation pointer
901 HYDROGUI_PrsImage* aPrs = 0;
902 switch ( module()->getViewManagerRole( aViewMgr ) )
904 case HYDROGUI_Module::VMR_ReferenceImage:
905 aPrs = myRefPreviewPrs;
908 case HYDROGUI_Module::VMR_TransformImage:
913 // Remove the appropriate presentation from the view
914 if( aPrs && aViewPort )
916 aViewPort->removeItem( aPrs );
921 module()->getApp()->removeViewManager( aViewMgr ); // aViewMgr is deleted here
926 void HYDROGUI_ImportImageOp::onFilesSelected( const QStringList& theFileNames )
928 myFiles = theFileNames;
933 bool HYDROGUI_ImportImageOp::SetNextFile()
936 bool isEnabledEdit = myFiles.count()==1 || myFileIndex==myFiles.count();
937 bool isValid = ( myFileIndex>=0 && myFileIndex<myFiles.count() );
938 QString aFile = isValid ? myFiles[myFileIndex] : "";
940 HYDROGUI_ImportImageDlg* aPanel = dynamic_cast<HYDROGUI_ImportImageDlg*>( inputPanel() );
941 aPanel->ActivateFile( aFile, isEnabledEdit );