X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROPy%2FHYDROData_Image.sip;h=b6728fb9383c64733dfd51f276bad79c4a5734b9;hb=f2cd9ebfca8f8f58c6e98e30d2ebb387488016cc;hp=ca4ded28ee6a12c7223ea47dd03f6d688698a82d;hpb=7d5b68c02696c7d07ea7e87b67728fae4cf692e0;p=modules%2Fhydro.git diff --git a/src/HYDROPy/HYDROData_Image.sip b/src/HYDROPy/HYDROData_Image.sip index ca4ded28..b6728fb9 100644 --- a/src/HYDROPy/HYDROData_Image.sip +++ b/src/HYDROPy/HYDROData_Image.sip @@ -24,7 +24,7 @@ #include %End -class HYDROData_Image : HYDROData_Entity +class HYDROData_Image : public HYDROData_Entity { %ConvertToSubClassCode @@ -44,206 +44,361 @@ class HYDROData_Image : 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 ); + void SetTrsf( const QTransform& theTrsf ); /** * Returns the kept transformation, or "identity" if not yet stored */ - QTransform Trsf(); + QTransform Trsf() const; /** - * Stores the image transformation points (3 input + 3 output) - * \param thePointA input point A - * \param thePointB input point B - * \param thePointC input point C - * \param theLambertPointA output point A in Lambert93 coordinates - * \param theLambertPointB output point B in Lambert93 coordinates - * \param theLambertPointC output point C in Lambert93 coordinates - * \param theCartesianPointA output point A in Cartesian coordinates - * \param theCartesianPointB output point B in Cartesian coordinates - * \param theCartesianPointC output point C in Cartesian coordinates + * Updates the matrix of transformation in accordance with reference points. + * \param theTrsf new transformation */ - void SetTrsfPoints( const QPoint& thePointA, - const QPoint& thePointB, - const QPoint& thePointC, - const QPointF& theLambertPointA, - const QPointF& theLambertPointB, - const QPointF& theLambertPointC, - const QPointF& theCartesianPointA, - const QPointF& theCartesianPointB, - const QPointF& theCartesianPointC ); + void UpdateTrsf(); + /** - * Returns the image transformation points (3 input + 3 output) - * \param thePointA input point A - * \param thePointB input point B - * \param thePointC input point C - * \param theLambertPointA output point A in Lambert93 coordinates - * \param theLambertPointB output point B in Lambert93 coordinates - * \param theLambertPointC output point C in Lambert93 coordinates - * \param theCartesianPointA output point A in Cartesian coordinates - * \param theCartesianPointB output point B in Cartesian coordinates - * \param theCartesianPointC output point C in Cartesian coordinates + * Returns true if transformation is done by two points only */ - void TrsfPoints( QPoint& thePointA, - QPoint& thePointB, - QPoint& thePointC, - QPointF& theLambertPointA, - QPointF& theLambertPointB, - QPointF& theLambertPointC, - QPointF& theCartesianPointA, - QPointF& theCartesianPointB, - QPointF& theCartesianPointC ) const; + bool IsByTwoPoints() const; + /** - * Returns true if the image has stored transformation points + * Removes all references from this image. */ - bool HasTrsfPoints() const; + bool HasReferences() const; /** - * Stores the transformation mode (0 - Lambert93, 1 - Cartesian) + * Removes all references from this image. */ - void SetTrsfMode(const int theMode); + void RemoveAllReferences(); + /** - * Returns the transformation mode (0 - Lambert93, 1 - Cartesian) + * Stores the transformation points in local cs of image + * \param thePointA point A + * \param thePointB point B + * \param thePointC point C */ - int TrsfMode() const; + 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 the number of referenced images - * \return zero if there is no references + * 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 */ - int NbReferences(); + bool HasGlobalPoints() const; + /** - * Appends reference to other image. - * \param theReferenced the image referenced by this + * 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 AppendReference( HYDROData_Entity theReferenced ) [void (Handle_HYDROData_Entity)]; + 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 - Handle(HYDROData_Entity) aRefObj = createHandle( a0 ); - if ( !aRefObj.IsNull() ) + /** + * 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 - sipSelfWasArg ? sipCpp->HYDROData_Image::AppendReference( aRefObj ) : - sipCpp->AppendReference( aRefObj ); + 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 image, or Null if index is invalid + * \returns the referenced object, or Null if index is invalid */ - HYDROData_Entity Reference( const int theIndex ) const [Handle_HYDROData_Entity (const int)]; + HYDROData_Entity Reference( const int theIndex ) const [Handle_HYDROData_Entity ()]; %MethodCode - - Handle(HYDROData_Entity) aRefObj; + Handle(HYDROData_Entity) aRef; Py_BEGIN_ALLOW_THREADS - aRefObj = sipSelfWasArg ? sipCpp->HYDROData_Image::Reference( a0 ) : - sipCpp->Reference( a0 ); + aRef = sipSelfWasArg ? sipCpp->HYDROData_Image::Reference( a0 ) : + sipCpp->Reference( a0 ); Py_END_ALLOW_THREADS - sipRes = createPointer( aRefObj ); - + 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 image referenced by this + * \param theReferenced the object referenced by this */ - void ChangeReference( const int theIndex, HYDROData_Entity theReferenced ) [void (const int, Handle_HYDROData_Entity)]; + void ChangeReference( const int theIndex, HYDROData_Entity theReferenced ) + [void ( const int, const Handle_HYDROData_Entity& )]; %MethodCode - - Handle(HYDROData_Entity) aRefObj = createHandle( a1 ); - if ( !aRefObj.IsNull() ) + Handle(HYDROData_Entity) aRef = createHandle( a1 ); + if ( !aRef.IsNull() ) { Py_BEGIN_ALLOW_THREADS - sipSelfWasArg ? sipCpp->HYDROData_Image::ChangeReference( a0, aRefObj ) : - sipCpp->ChangeReference( a0, aRefObj ); + 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 ); + void RemoveReference( const int theIndex ); /** * Removes all references. */ - void ClearReferences(); + void ClearReferences(); + /** * Stores the operator name * \param theOpName name of the operator that must be executed for image update */ - void SetOperatorName( const QString theOpName ); + void SetOperatorName(const QString theOpName); /** * Returns the operator name * \returns the name of the operator that must be executed for image update */ - QString OperatorName(); + QString OperatorName() const; /** * Stores the operator arguments * \param theArgs array that stores the operator arguments, needed for execution */ - void SetArgs( const QByteArray& theArgs ); + void SetArgs(const QByteArray& theArgs); /** * Returns the operator arguments * \returns array that stores the operator arguments, needed for execution */ - QByteArray Args(); + QByteArray Args() const; + /** - * Sets the "MustBeUpdated" flag: if image is depended on updated features. - * \param theFlag is true for images that must be updated, false for up-to-date + * Marks the image as self-splitted. + * \param theFlag is true for self-splitted image */ - void MustBeUpdated( bool theFlag ); + void SetIsSelfSplitted(bool theFlag); /** - * Returns the "MustBeUpdated" flag: is image must be recomputed or not - * \returns false if image is up to date + * Checks that the image is self-splitted. + * \returns true if image is self-splitted */ - bool MustBeUpdated(); - + bool IsSelfSplitted() const; protected: