Fix for the bug #40: Fatal error when edit image.

diff --git a/src/HYDROGUI/HYDROGUI_ImportImageDlg.cxx b/src/HYDROGUI/HYDROGUI_ImportImageDlg.cxx
index 862876e6b2436d87e70e8efe96451a0d9cf47cb3..7637e743d2a0171ad8e0d78c669ff55ce0791321 100644 (file)
--- a/src/HYDROGUI/HYDROGUI_ImportImageDlg.cxx
+++ b/src/HYDROGUI/HYDROGUI_ImportImageDlg.cxx
@@ -454,8 +454,8 @@ void HYDROGUI_ImportImageDlg::setTransformationDataMap( const TransformationData
         int aXDeg = 0, aYDeg = 0;
         int aXMin = 0, aYMin = 0;
         double aXSec = 0, aYSec = 0;
-        HYDROData_Lambert93::secToDMS( aLPoint.x(), aXDeg, aXMin, aXSec );
-        HYDROData_Lambert93::secToDMS( aLPoint.y(), aYDeg, aYMin, aYSec );
+        HYDROData_Lambert93::degToDMS( aLPoint.x(), aXDeg, aXMin, aXSec );
+        HYDROData_Lambert93::degToDMS( aLPoint.y(), aYDeg, aYMin, aYSec );
 
         myPointXDegMap[ aPointType ]->setValue( aXDeg );
         myPointYDegMap[ aPointType ]->setValue( aYDeg );
@@ -512,8 +512,8 @@ bool HYDROGUI_ImportImageDlg::getTransformationDataMap( TransformationDataMap& t
         return false;
 
     double aX2 = 0, aY2 = 0;
-    HYDROData_Lambert93::DMSToSec( aXDeg, aXMin, aXSec, aX2 );
-    HYDROData_Lambert93::DMSToSec( aYDeg, aYMin, aYSec, aY2 );
+    HYDROData_Lambert93::DMSToDeg( aXDeg, aXMin, aXSec, aX2 );
+    HYDROData_Lambert93::DMSToDeg( aYDeg, aYMin, aYSec, aY2 );
 
     TransformationData aData( QPoint( aX1, aY1 ), QPointF( aX2, aY2 ), QPointF( aXCart, aYCart ) );
     theMap[ aPointType ] = aData;
@@ -584,7 +584,8 @@ HYDROGUI_ImportImageDlg::TransformationData HYDROGUI_ImportImageDlg::ComputeTrsf
   {
     // Geodesic to Cartesian
     double aXCart = 0, aYCart = 0;
-    HYDROData_Lambert93::toXY( arx, ary, aXCart, aYCart );
+    // Interpreting arY as attitude and arX as longitude
+    HYDROData_Lambert93::toXY( ary, arx, aXCart, aYCart );
 
     aResTrsfData.GeodesicPoint = theGlobalPoint;
     aResTrsfData.CartesianPoint = QPointF( aXCart, aYCart );

diff --git a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx
index a144bf344188f5ff84f46c9850c215ae711e3057..cc0d9b428479f70310727ef68f90e68ec6ca72f6 100644 (file)
--- a/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx
+++ b/src/HYDROGUI/HYDROGUI_ImportImageOp.cxx
@@ -84,78 +84,88 @@ void HYDROGUI_ImportImageOp::startOperation()
       QPoint aLocalPointA, aLocalPointB, aLocalPointC;
       myEditedObject->GetLocalPoints( aLocalPointA, aLocalPointB, aLocalPointC );
 
+      // Create the edited image preview presentation in the viewer
       onCreatePreview( anImage );
 
-      if( myPreviewPrs )
+      // Set transformation local points A,B,C to the image preview presentation
+      setPresentationTrsfPoints( myPreviewPrs, anIsByTwoPoints, aLocalPointA, 
+        aLocalPointB, aLocalPointC );
+
+      // Build the existing image local and global points mapping 
+      // according to the current transformation mode.
+      HYDROData_Image::TransformationMode aTrsfMode = myEditedObject->GetTrsfMode();
+      QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC;
+      HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
+      if ( aTrsfMode == HYDROData_Image::ReferenceImage )
       {
-        HYDROGUI_PrsImage::TransformationPointMap aPointMap =
-          myPreviewPrs->getTransformationPointMap();
-        if( !aPointMap.isEmpty() )
+        // Compute global points using the transformation matrix of the reference image
+        Handle(HYDROData_Image) aRefImage = myEditedObject->GetTrsfReferenceImage();
+        if ( !aRefImage.IsNull() )
         {
-          aPointMap[ HYDROGUI_PrsImage::PointA ].Point = aLocalPointA;
-          aPointMap[ HYDROGUI_PrsImage::PointB ].Point = aLocalPointB;
+          QTransform aRefTrsf = aRefImage->Trsf(); // The reference image transformation matrix
+          aTrsfPointA = aRefTrsf.map( aLocalPointA ); // Compute the global point A
+          aTrsfPointB = aRefTrsf.map( aLocalPointB ); // Compute the global point B
           if ( !anIsByTwoPoints )
-            aPointMap[ HYDROGUI_PrsImage::PointC ].Point = aLocalPointC;
-
-          myPreviewPrs->setTransformationPointMap( aPointMap );
+          {
+            aTrsfPointC = aRefTrsf.map( aLocalPointC ); // Compute the global point C if used
+          }
+          // Build the local-global points map
+          // Use the reference image transformation mode for interpreting global points
+          computeTrsfData( aRefImage->GetTrsfMode(), anIsByTwoPoints, aLocalPointA, aLocalPointB, aLocalPointC,
+            aTrsfPointA, aTrsfPointB, aTrsfPointC, aDataMap );
         }
       }
+      else
+      {
+        // Get global points from the edited image
+        myEditedObject->GetGlobalPoints( aTrsfMode, aTrsfPointA, aTrsfPointB, aTrsfPointC );
+        // Build the local-global points map
+        computeTrsfData( aTrsfMode, anIsByTwoPoints, aLocalPointA, aLocalPointB, aLocalPointC,
+          aTrsfPointA, aTrsfPointB, aTrsfPointC, aDataMap );
+      }
 
-      HYDROData_Image::TransformationMode aTrsfMode;
-      QPointF aTrsfPointA, aTrsfPointB, aTrsfPointC;
-      myEditedObject->GetGlobalPoints( aTrsfMode,
-                                       aTrsfPointA, aTrsfPointB, aTrsfPointC );
-
-      HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
-      aDataMap[ HYDROGUI_PrsImage::PointA ] = 
-        HYDROGUI_ImportImageDlg::ComputeTrsfData( aTrsfMode, aLocalPointA, aTrsfPointA );
-      aDataMap[ HYDROGUI_PrsImage::PointB ] =
-        HYDROGUI_ImportImageDlg::ComputeTrsfData( aTrsfMode, aLocalPointB, aTrsfPointB );
-      if ( !anIsByTwoPoints )
-        aDataMap[ HYDROGUI_PrsImage::PointC ] =
-          HYDROGUI_ImportImageDlg::ComputeTrsfData( aTrsfMode, aLocalPointC, aTrsfPointC );
-
+      // Initialize the dialog mode, local and global coordinates 
+      // except coordinates on the reference image
       aPanel->setTransformationMode( aTrsfMode );
       aPanel->setTransformationDataMap( aDataMap );
       aPanel->setByTwoPoints( anIsByTwoPoints );
 
-      // Set points on reference image
-      if ( aTrsfMode = HYDROData_Image::ReferenceImage )
+      // Set points of the reference image
+      if ( aTrsfMode == HYDROData_Image::ReferenceImage )
       {
-        Handle(HYDROData_Image) aRefImage = myEditedObject->GetTrsfReferenceImage();
+        Handle(HYDROData_Image) aRefImage;
+        myEditedObject->GetReferencePoints( aRefImage,
+                                         aTrsfPointA, aTrsfPointB, aTrsfPointC );
         if ( !aRefImage.IsNull() )
         {
           aRefImageName = aRefImage->GetName();
 
+          // Create the reference image presentation in the viewer
           onRefImageActivated( aRefImageName );
-          if( myRefPreviewPrs )
-          {
-            HYDROGUI_PrsImage::TransformationPointMap aRefPointMap =
-              myRefPreviewPrs->getTransformationPointMap();
-            if( !aRefPointMap.isEmpty() )
-            {
-              aRefPointMap[ HYDROGUI_PrsImage::PointA ].Point = aTrsfPointA.toPoint();
-              aRefPointMap[ HYDROGUI_PrsImage::PointB ].Point = aTrsfPointB.toPoint();
-              if ( !anIsByTwoPoints )
-                aRefPointMap[ HYDROGUI_PrsImage::PointC ].Point = aTrsfPointC.toPoint();
-
-              myRefPreviewPrs->setTransformationPointMap( aRefPointMap );
-            }
-          }
 
+          // Set transformation points A,B,C to the reference image presentation
+          setPresentationTrsfPoints( myRefPreviewPrs, anIsByTwoPoints, aTrsfPointA.toPoint(), 
+            aTrsfPointB.toPoint(), aTrsfPointC.toPoint() );
+
+          // Prepare A, B, C points on the reference image
           HYDROGUI_ImportImageDlg::TransformationDataMap aRefDataMap;
-          aRefDataMap[ HYDROGUI_PrsImage::PointA ] = HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointA.toPoint() );
-          aRefDataMap[ HYDROGUI_PrsImage::PointB ] = HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointB.toPoint() );
+          aRefDataMap[ HYDROGUI_PrsImage::PointA ] = 
+            HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointA.toPoint() );
+          aRefDataMap[ HYDROGUI_PrsImage::PointB ] = 
+            HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointB.toPoint() );
           if ( !anIsByTwoPoints )
-            aRefDataMap[ HYDROGUI_PrsImage::PointC ] = HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointC.toPoint() );
+            aRefDataMap[ HYDROGUI_PrsImage::PointC ] = 
+            HYDROGUI_ImportImageDlg::TransformationData( aTrsfPointC.toPoint() );
 
+          // Initialize the dialog's A, B, C points coordinates of the reference image
           aPanel->setTransformationDataMap( aRefDataMap, true, true );
         }
       }
     }
   }
 
-  // collect information about existing images
+  // Collect information about existing images and initialize the combobox 
+  // reference image selector in the dialog.
   HYDROGUI_ImportImageDlg::PrsPointDataList aPrsPointDataList;
   HYDROData_Iterator anIterator( doc(), KIND_IMAGE );
   for( ; anIterator.More(); anIterator.Next() )
@@ -175,22 +185,66 @@ void HYDROGUI_ImportImageOp::startOperation()
                                    aTrsfPointA, aTrsfPointB, aTrsfPointC );
 
       HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
-      aDataMap[ HYDROGUI_PrsImage::PointA ] = 
-        HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointA, aTrsfPointA );
-      aDataMap[ HYDROGUI_PrsImage::PointB ] =
-        HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointB, aTrsfPointB );
-      aDataMap[ HYDROGUI_PrsImage::PointC ] =
-        HYDROGUI_ImportImageDlg::ComputeTrsfData( aImgTrsfMode, aLocalPointC, aTrsfPointC );
+      computeTrsfData( aImgTrsfMode, false, aLocalPointA, aLocalPointB, aLocalPointC,
+        aTrsfPointA, aTrsfPointB, aTrsfPointC, aDataMap );
 
       HYDROGUI_ImportImageDlg::PrsPointData aPrsPointData( anImageObj->GetName(), aDataMap );
       aPrsPointDataList.append( aPrsPointData );
     }
   }
 
+  // Initialize the combobox in the dialog with the list of available reference images
   aPanel->setPrsPointDataList( aPrsPointDataList );
+  // Select the current reference image in the dialog combobox
   aPanel->setRefImageName( aRefImageName );
 }
 
+void HYDROGUI_ImportImageOp::setPresentationTrsfPoints( HYDROGUI_PrsImage* thePrs, 
+                                                        bool theIsByTwoPoints,
+                                                        const QPoint theLocalPointA, 
+                                                        const QPoint theLocalPointB, 
+                                                        const QPoint theLocalPointC )
+{
+  // Set transformation points A,B,C to the image presentation
+  if( thePrs )
+  {
+    HYDROGUI_PrsImage::TransformationPointMap aPointMap =
+      thePrs->getTransformationPointMap();
+    if( !aPointMap.isEmpty() )
+    {
+      aPointMap[ HYDROGUI_PrsImage::PointA ].Point = theLocalPointA;
+      aPointMap[ HYDROGUI_PrsImage::PointB ].Point = theLocalPointB;
+      if ( !theIsByTwoPoints )
+        aPointMap[ HYDROGUI_PrsImage::PointC ].Point = theLocalPointC;
+
+      thePrs->setTransformationPointMap( aPointMap );
+    }
+  }
+}
+
+void HYDROGUI_ImportImageOp::computeTrsfData( HYDROData_Image::TransformationMode theTrsfMode,
+                                              bool theIsByTwoPoints,
+                                              const QPoint& theLocalPointA,
+                                              const QPoint& theLocalPointB,
+                                              const QPoint& theLocalPointC,
+                                              const QPointF& theGlobalPointA,
+                                              const QPointF& theGlobalPointB,
+                                              const QPointF& theGlobalPointC,
+                                              HYDROGUI_ImportImageDlg::TransformationDataMap& theDataMap ) const
+{
+  // Build the local-global points map
+  HYDROGUI_ImportImageDlg::TransformationDataMap aDataMap;
+  theDataMap[ HYDROGUI_PrsImage::PointA ] = 
+    HYDROGUI_ImportImageDlg::ComputeTrsfData( theTrsfMode, theLocalPointA, theGlobalPointA );
+  theDataMap[ HYDROGUI_PrsImage::PointB ] =
+    HYDROGUI_ImportImageDlg::ComputeTrsfData( theTrsfMode, theLocalPointB, theGlobalPointB );
+  if ( !theIsByTwoPoints )
+  {
+    theDataMap[ HYDROGUI_PrsImage::PointC ] =
+      HYDROGUI_ImportImageDlg::ComputeTrsfData( theTrsfMode, theLocalPointC, theGlobalPointC );
+  }
+}
+
 void HYDROGUI_ImportImageOp::abortOperation()
 {
   closePreview();

diff --git a/src/HYDROGUI/HYDROGUI_ImportImageOp.h b/src/HYDROGUI/HYDROGUI_ImportImageOp.h
index ad45664edab7f1b025326372048b95cc786f8cf8..e473373137ae9bc3ca10882a2981197555ee0866 100644 (file)
--- a/src/HYDROGUI/HYDROGUI_ImportImageOp.h
+++ b/src/HYDROGUI/HYDROGUI_ImportImageOp.h
@@ -24,15 +24,14 @@
 #define HYDROGUI_IMPORTIMAGEOP_H
 
 #include "HYDROGUI_Operation.h"
+#include "HYDROGUI_ImportImageDlg.h"
 
 #include <HYDROData_Image.h>
 
 #include <QImage>
 
 class GraphicsView_ViewManager;
-
 class SUIT_ViewManager;
-
 class HYDROGUI_PrsImage;
 
 class HYDROGUI_ImportImageOp : public HYDROGUI_Operation
@@ -78,6 +77,28 @@ private:
                                           QString&       theErrorMsg,
                                           const bool     theIsToCheckInvertibles ) const;
 
+  /**
+   * Build the local-global points mapping.
+   */
+  void                       computeTrsfData( HYDROData_Image::TransformationMode theTrsfMode,
+                                              bool theIsByTwoPoints,
+                                              const QPoint& theLocalPointA,
+                                              const QPoint& theLocalPointB,
+                                              const QPoint& theLocalPointC,
+                                              const QPointF& theGlobalPointA,
+                                              const QPointF& theGlobalPointB,
+                                              const QPointF& theGlobalPointC,
+                                              HYDROGUI_ImportImageDlg::TransformationDataMap& theDataMap ) const;
+
+  /**
+   * Set transformation points A,B,C to the image presentation.
+   */
+  void                       setPresentationTrsfPoints( HYDROGUI_PrsImage* thePrs, 
+                                                        bool theIsByTwoPoints,
+                                                        const QPoint theLocalPointA, 
+                                                        const QPoint theLocalPointB, 
+                                                        const QPoint theLocalPointC );
+
 private:
   bool                       myIsEdit;
   Handle(HYDROData_Image)    myEditedObject;