// Copyright (C) 2014-2015  EDF-R&D
// 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, or (at your option) any later version.
//
// 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
//

%ExportedHeaderCode
#include <HYDROData_Image.h>
%End

class HYDROData_Image : public HYDROData_Entity
{

%ConvertToSubClassCode
    switch ( sipCpp->GetKind() )
    {
      case KIND_IMAGE:
        sipClass = sipClass_HYDROData_Image;
        break;

      default:
        // We don't recognise the type.
        sipClass = NULL;
    }
%End

%TypeHeaderCode
#include <HYDROData_Image.h>
%End

public:

  enum TransformationMode
  {
    ManualGeodesic = 0,
    ManualCartesian,
    CartesianFromFile,
    ReferenceImage
  };

public:      

  /**
   * Stores the image
   * \param theImage new image
   */
  void SetImage( const QImage& theImage );

  /**
   * Load the image from file
   * \param theFilePath path to image
   */
  bool LoadImage( const QString& theFilePath );

  /**
   * Returns the kept 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:

  /**
   * Creates new object in the internal data structure. Use higher level objects 
   * to create objects with real content.
   */
  HYDROData_Image();

  /**
   * Destructs properties of the object and object itself, removes it from the document.
   */
  ~HYDROData_Image();
};