X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_ImportImageOp.cxx;h=14c081255003be9a86e6ba8439faed75c4d14714;hb=0b4df27e9f347d6187dbf30bacf80b45c21813d4;hp=9b0093c27d24a3dfc6645b9e69b71c4ef4273028;hpb=c66fbd26a75a044039dc2b2f8dea2249582deabc;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx index 9b0093c2..14c08125 100644 --- a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx +++ b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx @@ -1,16 +1,308 @@ +// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// -#include +#include "HYDROGUI_ImportImageOp.h" -HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule ) - : HYDROGUI_Operation( theModule ) +#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 +#include +#include + +#include +#include + +HYDROGUI_ImportImageOp::HYDROGUI_ImportImageOp( HYDROGUI_Module* theModule, + const bool theIsEdit ) +: HYDROGUI_Operation( theModule ), + myIsEdit( theIsEdit ), + myEditedObject( 0 ), + myActiveViewManager( 0 ), + myPreviewViewManager( 0 ), + myPreviewPrs( 0 ), + myPointType( HYDROGUI_PrsImage::None ) { + setName( theIsEdit ? tr( "EDIT_IMAGE" ) : tr( "IMPORT_IMAGE" ) ); } HYDROGUI_ImportImageOp::~HYDROGUI_ImportImageOp() { } +void HYDROGUI_ImportImageOp::startOperation() +{ + HYDROGUI_Operation::startOperation(); + + HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); + aPanel->reset(); + aPanel->setIsEdit( myIsEdit ); + + if( myIsEdit ) + { + myEditedObject = Handle(HYDROData_Image)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) ); + if( !myEditedObject.IsNull() ) + { + QImage anImage = myEditedObject->Image(); + + QPoint aPointA1, aPointB1, aPointC1; + QPointF aPointA2, aPointB2, aPointC2; + myEditedObject->TrsfPoints( aPointA1, aPointB1, aPointC1, + aPointA2, aPointB2, aPointC2 ); + + onCreatePreview( anImage ); + + if( myPreviewPrs ) + { + HYDROGUI_PrsImage::TransformationPointMap aPointMap = + myPreviewPrs->getTransformationPointMap(); + if( !aPointMap.isEmpty() ) + { + aPointMap[ HYDROGUI_PrsImage::PointA ].Point = aPointA1; + aPointMap[ HYDROGUI_PrsImage::PointB ].Point = aPointB1; + aPointMap[ HYDROGUI_PrsImage::PointC ].Point = aPointC1; + myPreviewPrs->setTransformationPointMap( aPointMap ); + } + } + + 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 ); + } + } +} + +void HYDROGUI_ImportImageOp::abortOperation() +{ + closePreview(); + + HYDROGUI_Operation::abortOperation(); +} + +void HYDROGUI_ImportImageOp::commitOperation() +{ + closePreview(); + + HYDROGUI_Operation::commitOperation(); +} + HYDROGUI_InputPanel* HYDROGUI_ImportImageOp::createInputPanel() const { - return 0; + 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 ) ) ); + return aPanel; +} + +bool HYDROGUI_ImportImageOp::processApply( int& theUpdateFlags, + QString& theErrorMsg ) +{ + HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); + + QString anImageName = aPanel->getImageName(); + if( anImageName.isEmpty() ) + return false; + + 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 = HYDROGUI_Tool::FindObjectByName( module(), anImageName ); + if( !anObject.IsNull() ) + { + theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( anImageName ); + return false; + } + } + + QImage anImage = myPreviewPrs->getImage(); + + HYDROGUI_ImportImageDlg::TransformationDataMap aMap; + bool anIsOk = aPanel->getTransformationDataMap( aMap ); + if( !anIsOk || !myPreviewPrs ) + 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; + } + + QTransform aTransform1( xa1, ya1, 1, xb1, yb1, 1, xc1, yc1, 1 ); + QTransform aTransform2( xa2, ya2, 1, xb2, yb2, 1, xc2, yc2, 1 ); + + bool anIsInvertible = false; + QTransform aTransform = aTransform1.inverted( &anIsInvertible ) * aTransform2; + if( !anIsInvertible ) + { + theErrorMsg = tr( "TRANSFORMATION_MATRIX_CANNOT_BE_COMPUTED" ); + return false; + } + + Handle(HYDROData_Image) anImageObj; + if( myIsEdit ) + anImageObj = myEditedObject; + else + anImageObj = Handle(HYDROData_Image)::DownCast( doc()->CreateObject( KIND_IMAGE ) ); + + if( anImageObj.IsNull() ) + return false; + + anImageObj->SetName( anImageName ); + + anImageObj->SetImage( anImage ); + anImageObj->SetTrsf( aTransform ); + + anImageObj->SetTrsfPoints( aPointA1, aPointB1, aPointC1, + aPointA2, aPointB2, aPointC2 ); + + anImageObj->SetVisibility( true ); + + theUpdateFlags = UF_Model | UF_Viewer | UF_GV_Forced; + return true; +} + +void HYDROGUI_ImportImageOp::onCreatePreview( QImage theImage ) +{ + LightApp_Application* anApp = module()->getApp(); + + myActiveViewManager = anApp->activeViewManager(); + + myPreviewPrs = new HYDROGUI_PrsImage( myIsEdit ? myEditedObject : 0 ); + myPreviewPrs->setImage( theImage ); + myPreviewPrs->compute(); + + myPreviewViewManager = + dynamic_cast( anApp->createViewManager( GraphicsView_Viewer::Type() ) ); + if( myPreviewViewManager ) + { + module()->setViewManagerRole( myPreviewViewManager, HYDROGUI_Module::VMR_Mapping ); + myPreviewViewManager->setTitle( tr( "MAPPING" ) ); + if( GraphicsView_Viewer* aViewer = myPreviewViewManager->getViewer() ) + { + if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() ) + { + aViewPort->setMousePositionEnabled( true ); + + aViewPort->addItem( myPreviewPrs ); + aViewPort->fitAll(); + + myPreviewPrs->setIsTransformationPointPreview( true ); + } + connect( aViewer, SIGNAL( selectionChanged( GV_SelectionChangeStatus ) ), + this, SLOT( onPointSelected() ) ); + } + } + + HYDROGUI_ImportImageDlg* aPanel = (HYDROGUI_ImportImageDlg*)inputPanel(); + + QString anImageName; + if( myIsEdit ) + { + if( !myEditedObject.IsNull() ) + anImageName = myEditedObject->GetName(); + } + else + anImageName = HYDROGUI_Tool::GenerateObjectName( module(), "Image" ); + aPanel->setImageName( anImageName ); + + aPanel->initializePointSelection(); + onPointSelected(); +} + +void HYDROGUI_ImportImageOp::onActivatePointSelection( int thePointType ) +{ + myPointType = thePointType; + if( myPreviewPrs ) + myPreviewPrs->setTransformationPointMode( thePointType ); +} + +void HYDROGUI_ImportImageOp::onPointSelected() +{ + HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap; + + const HYDROGUI_PrsImage::TransformationPointMap& aPointMap = + myPreviewPrs->getTransformationPointMap(); + HYDROGUI_PrsImage::TransformationPointMapIterator anIter( aPointMap ); + while( anIter.hasNext() ) + { + int aPointType = anIter.next().key(); + const HYDROGUI_PrsImage::TransformationPoint& aTransformationPoint = anIter.value(); + const QPoint& aPoint = aTransformationPoint.Point; + + HYDROGUI_ImportImageDlg::TransformationData aData( aPoint, QPointF() ); + aDataMap[ aPointType ] = aData; + } + + ( (HYDROGUI_ImportImageDlg*)inputPanel() )->setTransformationDataMap( aDataMap, true ); +} + +void HYDROGUI_ImportImageOp::closePreview() +{ + if( myPreviewPrs ) + { + delete myPreviewPrs; + myPreviewPrs = 0; + } + + if( myPreviewViewManager ) + { + module()->getApp()->removeViewManager( myPreviewViewManager ); // myPreviewViewManager is deleted here + myPreviewViewManager = 0; + } + + if( myActiveViewManager ) + HYDROGUI_Tool::SetActiveViewManager( module(), myActiveViewManager ); }