From d5042386ce5c1842d2f837e8afb46f813160bbff Mon Sep 17 00:00:00 2001 From: adv Date: Wed, 29 Jan 2014 11:20:49 +0000 Subject: [PATCH] Dump image to python script. --- src/HYDROData/HYDROData_Image.cxx | 42 ++-- src/HYDROPy/HYDROData_Image.sip | 343 +++++++++++++++++++++++++++++- 2 files changed, 370 insertions(+), 15 deletions(-) diff --git a/src/HYDROData/HYDROData_Image.cxx b/src/HYDROData/HYDROData_Image.cxx index ef915a00..09ce073a 100644 --- a/src/HYDROData/HYDROData_Image.cxx +++ b/src/HYDROData/HYDROData_Image.cxx @@ -52,19 +52,27 @@ QStringList HYDROData_Image::DumpToPython( MapOfTreatedObjects& theTreatedObject // Dump transformation points for image - QString aGap = QString().fill( ' ', anImageName.size() + 16 ); - bool anIsByTwoPoints = IsByTwoPoints(); QPoint aLocalPointA, aLocalPointB, aLocalPointC; if ( GetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC ) ) { + QString aGap = QString().fill( ' ', anImageName.size() + 17 ); + aResList << QString( "%1.SetLocalPoints( QPoint( %2, %3 )," ) .arg( anImageName ).arg( aLocalPointA.x() ).arg( aLocalPointA.y() ); - aResList << QString( aGap + "QPoint( %1, %2 )," ) + aResList << QString( aGap + "QPoint( %1, %2 )" ) .arg( aLocalPointB.x() ).arg( aLocalPointB.y() ); - aResList << QString( aGap + "QPoint( %1, %2 ) );" ) - .arg( aLocalPointC.x() ).arg( aLocalPointC.y() ); + if ( !anIsByTwoPoints ) + { + aResList.last().append( "," ); + aResList << QString( aGap + "QPoint( %1, %2 ) );" ) + .arg( aLocalPointC.x() ).arg( aLocalPointC.y() ); + } + else + { + aResList.last().append( " );" ); + } aResList << QString( "" ); } @@ -72,14 +80,24 @@ QStringList HYDROData_Image::DumpToPython( MapOfTreatedObjects& theTreatedObject QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC; if ( GetGlobalPoints( aTransformationMode, aTrsfPointA, aTrsfPointB, aTrsfPointC ) ) { + QString aGap = QString().fill( ' ', anImageName.size() + 18 ); + aResList << QString( "%1.SetGlobalPoints( %2," ) .arg( anImageName ).arg( aTransformationMode ); aResList << QString( aGap + "QPointF( %1, %2 )," ) .arg( aTrsfPointA.x() ).arg( aTrsfPointA.y() ); - aResList << QString( aGap + "QPointF( %1, %2 )," ) + aResList << QString( aGap + "QPointF( %1, %2 )" ) .arg( aTrsfPointB.x() ).arg( aTrsfPointB.y() ); - aResList << QString( aGap + "QPointF( %1, %2 ) );" ) - .arg( aTrsfPointC.x() ).arg( aTrsfPointC.y() ); + if ( !anIsByTwoPoints ) + { + aResList.last().append( "," ); + aResList << QString( aGap + "QPointF( %1, %2 ) );" ) + .arg( aTrsfPointC.x() ).arg( aTrsfPointC.y() ); + } + else + { + aResList.last().append( " );" ); + } if ( aTransformationMode == ReferenceImage ) { @@ -130,13 +148,10 @@ QStringList HYDROData_Image::DumpToPython( MapOfTreatedObjects& theTreatedObject setPythonReferenceObject( theTreatedObjects, aResList, aRefImg, "AppendReference" ); } } - - // Necessary to update image in case of composed operator - aResList << QString( "" ); - aResList << QString( "%1.Update();" ).arg( anImageName ); } aResList << QString( "" ); + aResList << QString( "%1.Update();" ).arg( anImageName ); return aResList; } @@ -264,6 +279,9 @@ bool HYDROData_Image::LoadImage( const QString& theFilePath ) { QImage anImage( theFilePath ); SetImage( anImage ); + + SetFilePath( theFilePath ); + return !anImage.isNull(); } diff --git a/src/HYDROPy/HYDROData_Image.sip b/src/HYDROPy/HYDROData_Image.sip index f0a74b31..b6728fb9 100644 --- a/src/HYDROPy/HYDROData_Image.sip +++ b/src/HYDROPy/HYDROData_Image.sip @@ -44,24 +44,361 @@ class HYDROData_Image : public HYDROData_Entity #include %End +public: + + enum TransformationMode + { + ManualGeodesic = 0, + ManualCartesian, + CartesianFromFile, + ReferenceImage + }; + public: /** * Stores the image * \param theImage new image */ - void SetImage( const QImage& theImage ); + void SetImage( const QImage& theImage ); /** * Load the image from file * \param theFilePath path to image */ - bool LoadImage( const QString& theFilePath ); + bool LoadImage( const QString& theFilePath ); /** * Returns the kept image */ - QImage Image(); + QImage Image(); + + + /** + * Stores the image file path + * \param theFilePath image file path + */ + void SetFilePath( const QString& theFilePath ); + + /** + * Returns uploaded image file path + */ + QString GetFilePath() const; + + + /** + * Stores the image transformation + * \param theTrsf new transformation + */ + void SetTrsf( const QTransform& theTrsf ); + + /** + * Returns the kept transformation, or "identity" if not yet stored + */ + QTransform Trsf() const; + + /** + * Updates the matrix of transformation in accordance with reference points. + * \param theTrsf new transformation + */ + void UpdateTrsf(); + + + /** + * Returns true if transformation is done by two points only + */ + bool IsByTwoPoints() const; + + + /** + * Removes all references from this image. + */ + bool HasReferences() const; + + /** + * Removes all references from this image. + */ + void RemoveAllReferences(); + + + /** + * Stores the transformation points in local cs of image + * \param thePointA point A + * \param thePointB point B + * \param thePointC point C + */ + void SetLocalPoints( const QPoint& thePointA, + const QPoint& thePointB, + const QPoint& thePointC = QPoint( INT_MIN, INT_MIN ), + const bool theIsUpdate = true ); + + /** + * Returns the transformation points in local cs of image + * \param thePointA point A + * \param thePointB point B + * \param thePointC point C + * \return true if all parameters has been set before + */ + bool GetLocalPoints( QPoint& thePointA /Out/, + QPoint& thePointB /Out/, + QPoint& thePointC /Out/ ) const; + + /** + * Returns true if local points has been set before + */ + bool HasLocalPoints() const; + + + /** + * Stores the transformation points in global cs + * \param theMode transformation mode + * \param thePointA point A + * \param thePointB point B + * \param thePointC point C + */ + void SetGlobalPoints( const TransformationMode& theMode, + const QPointF& thePointA, + const QPointF& thePointB, + const QPointF& thePointC = QPoint( INT_MIN, INT_MIN ), + const bool theIsUpdate = true ); + + /** + * Returns the transformation points in global cs + * \param theMode transformation mode + * \param thePointA point A + * \param thePointB point B + * \param thePointC point C + * \return true if all parameters has been set before + */ + bool GetGlobalPoints( TransformationMode& theMode, + QPointF& thePointA /Out/, + QPointF& thePointB /Out/, + QPointF& thePointC /Out/ ) const; + + /** + * Get transformation points from the file and stores them in global cs + * \param theFileName the image georeferencement file name + * \return true in case of success + */ + bool SetGlobalPointsFromFile( const QString& theFileName ); + + /** + * Returns true if global points has been set before + */ + bool HasGlobalPoints() const; + + + /** + * Stores the transformation points in reference image local cs + * \param theRefImage reference image + * \param thePointA point A + * \param thePointB point B + * \param thePointC point C + */ + void SetReferencePoints( HYDROData_Image theRefImage, + const QPointF& thePointA, + const QPointF& thePointB, + const QPointF& thePointC = QPoint( INT_MIN, INT_MIN ), + const bool theIsUpdate = true ) + [void ( const Handle_HYDROData_Image&, const QPointF&, const QPointF&, const QPointF&, const bool )]; + %MethodCode + Handle(HYDROData_Image) aRefImage = + Handle(HYDROData_Image)::DownCast( createHandle( a0 ) ); + if ( !aRefImage.IsNull() ) + { + Py_BEGIN_ALLOW_THREADS + sipSelfWasArg ? sipCpp->HYDROData_Image::SetReferencePoints( aRefImage, *a1, *a2, *a3, a4 ) : + sipCpp->SetReferencePoints( aRefImage, *a1, *a2, *a3, a4 ); + Py_END_ALLOW_THREADS + } + %End + + /** + * Returns the transformation points in reference image local cs + * \param theRefImage reference image + * \param thePointA point A + * \param thePointB point B + * \param thePointC point C + * \return true if all parameters has been set correctly + */ + bool GetReferencePoints( HYDROData_Image theRefImage, + QPointF& thePointA /Out/, + QPointF& thePointB /Out/, + QPointF& thePointC /Out/ ) const + [bool ( const Handle_HYDROData_Image&, QPointF&, QPointF&, QPointF& )]; + %MethodCode + Handle(HYDROData_Image) aRefImage = + Handle(HYDROData_Image)::DownCast( createHandle( a0 ) ); + if ( !aRefImage.IsNull() ) + { + Py_BEGIN_ALLOW_THREADS + sipRes = sipSelfWasArg ? sipCpp->HYDROData_Image::GetReferencePoints( aRefImage, *a1, *a2, *a3 ) : + sipCpp->GetReferencePoints( aRefImage, *a1, *a2, *a3 ); + Py_END_ALLOW_THREADS + } + %End + + /** + * Returns true if reference points has been set before + */ + bool HasReferencePoints() const; + + + /** + * Stores the reference image for transformation + * \param theRefImage reference image + */ + void SetTrsfReferenceImage( HYDROData_Image theRefImage ) [void ( const Handle_HYDROData_Image& )]; + %MethodCode + Handle(HYDROData_Image) aRefImage = + Handle(HYDROData_Image)::DownCast( createHandle( a0 ) ); + if ( !aRefImage.IsNull() ) + { + Py_BEGIN_ALLOW_THREADS + sipSelfWasArg ? sipCpp->HYDROData_Image::SetTrsfReferenceImage( aRefImage ) : + sipCpp->SetTrsfReferenceImage( aRefImage ); + Py_END_ALLOW_THREADS + } + %End + + /** + * Returns the reference image for transformation + */ + HYDROData_Image GetTrsfReferenceImage() const [Handle_HYDROData_Image ()]; + %MethodCode + Handle(HYDROData_Image) aRefImage; + + Py_BEGIN_ALLOW_THREADS + aRefImage = sipSelfWasArg ? sipCpp->HYDROData_Image::GetTrsfReferenceImage() : + sipCpp->GetTrsfReferenceImage(); + Py_END_ALLOW_THREADS + + sipRes = (HYDROData_Image*)createPointer( aRefImage ); + %End + + /** + * Removes the reference image for transformation + */ + void RemoveTrsfReferenceImage(); + + + /** + * Stores the transformation mode + */ + void SetTrsfMode( const TransformationMode& theMode ); + + /** + * Returns the transformation mode + */ + TransformationMode GetTrsfMode() const; + + + /** + * Returns the number of referenced objects + * \return zero if there is no references + */ + int NbReferences() const; + + /** + * Appends reference to other object (image or polyline). + * \param theReferenced the object referenced by this + */ + void AppendReference( HYDROData_Entity theReferenced ) [void ( const Handle_HYDROData_Entity& )]; + %MethodCode + Handle(HYDROData_Entity) aRef = createHandle( a0 ); + if ( !aRef.IsNull() ) + { + Py_BEGIN_ALLOW_THREADS + sipSelfWasArg ? sipCpp->HYDROData_Image::AppendReference( aRef ) : + sipCpp->AppendReference( aRef ); + Py_END_ALLOW_THREADS + } + %End + + /** + * Returns reference by index. + * \param theIndex number of reference [0; NbReference) + * \returns the referenced object, or Null if index is invalid + */ + HYDROData_Entity Reference( const int theIndex ) const [Handle_HYDROData_Entity ()]; + %MethodCode + Handle(HYDROData_Entity) aRef; + + Py_BEGIN_ALLOW_THREADS + aRef = sipSelfWasArg ? sipCpp->HYDROData_Image::Reference( a0 ) : + sipCpp->Reference( a0 ); + Py_END_ALLOW_THREADS + + sipRes = createPointer( aRef ); + %End + + /** + * Updates reference by index. If index is one-bigger than \a NbReferences, + * this method appends it to the end (NbReferences is incremented). + * \param theIndex number of reference [0; NbReference] + * \param theReferenced the object referenced by this + */ + void ChangeReference( const int theIndex, HYDROData_Entity theReferenced ) + [void ( const int, const Handle_HYDROData_Entity& )]; + %MethodCode + Handle(HYDROData_Entity) aRef = createHandle( a1 ); + if ( !aRef.IsNull() ) + { + Py_BEGIN_ALLOW_THREADS + sipSelfWasArg ? sipCpp->HYDROData_Image::ChangeReference( a0, aRef ) : + sipCpp->ChangeReference( a0, aRef ); + Py_END_ALLOW_THREADS + } + %End + + /** + * Removes reference by index + * \param theIndex number of reference [0; NbReference) + */ + void RemoveReference( const int theIndex ); + + /** + * Removes all references. + */ + void ClearReferences(); + + + /** + * Stores the operator name + * \param theOpName name of the operator that must be executed for image update + */ + void SetOperatorName(const QString theOpName); + + /** + * Returns the operator name + * \returns the name of the operator that must be executed for image update + */ + QString OperatorName() const; + + /** + * Stores the operator arguments + * \param theArgs array that stores the operator arguments, needed for execution + */ + void SetArgs(const QByteArray& theArgs); + + /** + * Returns the operator arguments + * \returns array that stores the operator arguments, needed for execution + */ + QByteArray Args() const; + + + /** + * Marks the image as self-splitted. + * \param theFlag is true for self-splitted image + */ + void SetIsSelfSplitted(bool theFlag); + + /** + * Checks that the image is self-splitted. + * \returns true if image is self-splitted + */ + bool IsSelfSplitted() const; protected: -- 2.39.2