X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=vv%2FvvToolRigidReg.cxx;h=644920b4435fa420e35c7d33664c5ad9697a5c2e;hb=18243ee643931eb014e0bd3fef016d4a77009479;hp=57d7bcb085329ba1d4d004fd8c5887824be80fe4;hpb=1753519ccc5895a24e2bb5853bf6e9d33050ba12;p=clitk.git

diff --git a/vv/vvToolRigidReg.cxx b/vv/vvToolRigidReg.cxx
index 57d7bcb..644920b 100644
--- a/vv/vvToolRigidReg.cxx
+++ b/vv/vvToolRigidReg.cxx
@@ -19,17 +19,23 @@
 // vv
 #include "vvToolRigidReg.h"
 #include "vvSlicer.h"
+#include <vvBlendImageActor.h>
 
 // vtk
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
+#include <vtkInformation.h>
 #include <vtkTransform.h>
+#include <vtkImageActor.h>
+#include <vtkImageMapper3D.h>
+#include <vtkOpenGLImageSliceMapper.h>
 
 // itk
 #include <itkEuler3DTransform.h>
 
 // clitk
 #include "clitkTransformUtilities.h"
+#include "clitkMatrix.h"
 
 // qt
 #include <QMessageBox>
@@ -108,9 +114,9 @@ void vvToolRigidReg::InputIsSelected(vvSlicerManager *input)
   imageorigin=mInput->GetImage()->GetOrigin();
   std::vector<int> imageSize = mInput->GetImage()->GetSize();
   std::vector<double> imageSpacing = mInput->GetImage()->GetSpacing();
-  xcord=xcord.setNum(imageorigin[0]+imageSize[0]*imageSpacing[0]/2, 'g', 3);
-  ycord=ycord.setNum(imageorigin[1]+imageSize[1]*imageSpacing[1]/2, 'g', 3);
-  zcord=zcord.setNum(imageorigin[2]+imageSize[2]*imageSpacing[2]/2, 'g', 3);
+  xcord=xcord.setNum(imageorigin[0]+(imageSize[0]-1)*imageSpacing[0]*0.5, 'g', 3);
+  ycord=ycord.setNum(imageorigin[1]+(imageSize[1]-1)*imageSpacing[1]*0.5, 'g', 3);
+  zcord=zcord.setNum(imageorigin[2]+(imageSize[2]-1)*imageSpacing[2]*0.5, 'g', 3);
   Xval->setText(xcord);
   Yval->setText(ycord);
   Zval->setText(zcord);
@@ -118,8 +124,9 @@ void vvToolRigidReg::InputIsSelected(vvSlicerManager *input)
   //backup original matrix
   for(int j=0; j<4; j++)
     for(int i=0; i<4; i++)
-      mInitialMatrix->SetElement(i,j, mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix()->GetElement(i,j));
-  QString origTransformString = dynamic_cast<vvMainWindow*>(mMainWindow)->Get4x4MatrixDoubleAsString(mInitialMatrix);
+      // TODO SR and BP: check on the list of transforms and not the first only
+      mInitialMatrix->SetElement(i,j, mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j));
+  QString origTransformString(clitk::Get4x4MatrixDoubleAsString(mInitialMatrix).c_str());
   transformationLabel->setText(origTransformString);
   SetTransform(mInitialMatrix);
 
@@ -242,7 +249,8 @@ void vvToolRigidReg::SpinBoxChange(double newVal)
   }
 
   // Compute transform and set
-  vtkSmartPointer<vtkTransform> transform_final=mInput->GetImage()->GetTransform();
+  // TODO SR and BP: check on the list of transforms and not the first only
+  vtkSmartPointer<vtkTransform> transform_final=mInput->GetImage()->GetTransform()[0];
   transform_final->Identity();
   transform_final->PostMultiply();
 
@@ -294,8 +302,9 @@ void vvToolRigidReg::SaveFile()
 
   QFile file(filename);
   if (file.open(QFile::WriteOnly | QFile::Truncate)) {
-    vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix();
-    QString matrixStr = dynamic_cast<vvMainWindow*>(mMainWindow)->Get4x4MatrixDoubleAsString(matrix,16);
+    // TODO SR and BP: check on the list of transforms and not the first only
+    vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix();
+    QString matrixStr = clitk::Get4x4MatrixDoubleAsString(matrix,16).c_str();
     QTextStream out(&file);
     out << matrixStr;
   }
@@ -332,7 +341,8 @@ void vvToolRigidReg::LoadFile()
 //------------------------------------------------------------------------------
 void vvToolRigidReg::ChangeOfRotationCenter()
 {
-  SetTransform(mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix());
+  // TODO SR and BP: check on the list of transforms and not the first only
+  SetTransform(mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix());
 }
 //------------------------------------------------------------------------------
 
@@ -347,7 +357,8 @@ void vvToolRigidReg::ResetTransform()
 void vvToolRigidReg::SetTransform(vtkMatrix4x4 *matrix)
 {
   vtkSmartPointer<vtkTransform> transform=vtkSmartPointer<vtkTransform>::New();
-  mCurrentSlicerManager->GetImage()->GetTransform()->SetMatrix(matrix);
+  // TODO SR and BP: check on the list of transforms and not the first only
+  mCurrentSlicerManager->GetImage()->GetTransform()[0]->SetMatrix(matrix);
   transform->Update();
   Render();
   dynamic_cast<vvMainWindow*>(mMainWindow)->ImageInfoChanged();
@@ -370,7 +381,6 @@ void vvToolRigidReg::SetTransform(vtkMatrix4x4 *matrix)
   euler->SetMatrix(rotMat);
   euler->SetOffset(transVec);
 
-
   // Modify GUI according to the new parameters
   std::vector<QSlider *> transSliders, rotSliders;
   std::vector<QDoubleSpinBox *> transSBs, rotSBs;
@@ -427,13 +437,225 @@ void vvToolRigidReg::GetSlidersAndSpinBoxes(std::vector<QSlider *>&transSliders,
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
-void vvToolRigidReg::Render()
+void vvToolRigidReg::ExtentMax(const double pointExtent[8][4], double maxExtent[2][3])
 {
-  for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++)
+    double max, min;
+    for (int i=0; i<3; ++i) {
+        max = pointExtent[0][i];
+        min = pointExtent[0][i];
+        for (int j=1; j<8; ++j) {
+            if (pointExtent[j][i] > max) {
+                max = pointExtent[j][i];
+            }
+            if (pointExtent[j][i] < min) {
+                min = pointExtent[j][i];
+            }
+        }
+        maxExtent[0][i] = min;
+        maxExtent[1][i] = max;
+    }
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvToolRigidReg::Render()
+{ //out << __func__ << endl;
+#if VTK_MAJOR_VERSION > 5
+double translationValues[4], translationValuesUpdate[4];
+mCurrentSlicerManager->GetImage()->GetTransform()[0]->Print(cout);
+vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix();
+vtkMatrix4x4* matrixTranspose = matrix->NewInstance();
+for (int i=0; i<3; ++i) {
+    for (int j=0; j<3; ++j)
     {
+        matrixTranspose->SetElement(i,j,matrix->GetElement(j,i));
+    }
+}
+for (int j=0; j<3; ++j)
+{
+    translationValues[j] = matrix->GetElement(j,3);
+}
+translationValues[3] = 0.0;
+matrix->MultiplyPoint(translationValues, translationValuesUpdate);
+for (int i=0; i<3; ++i) {
+   matrixTranspose->SetElement(i,3,translationValuesUpdate[i]);
+}
+for (int i=0; i<4; ++i) {
+   matrixTranspose->SetElement(3,i,matrix->GetElement(3,i));
+}
+
+#endif
+for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+#if VTK_MAJOR_VERSION > 5 
+    double pointExtent[8][4], pointExtentUpdate[8][4], pointOverlayExtent[8][4], pointOverlayExtentUpdate[8][4], centre[3], translation[3];
+    std::vector<int> w_ext;
+    w_ext=mCurrentSlicerManager->GetImage()->GetSize();
+    pointExtent[0][0] = 0.0;
+	pointExtent[0][1] = 0.0;
+	pointExtent[0][2] = 0.0;
+	pointExtent[0][3] = 1.0;
+    pointExtent[1][0] = w_ext[0]-1;
+	pointExtent[1][1] = w_ext[1]-1;
+	pointExtent[1][2] = w_ext[2]-1;
+	pointExtent[1][3] = 1.0;
+	pointExtent[2][0] = 0.0;
+	pointExtent[2][1] = w_ext[1]-1;
+	pointExtent[2][2] = w_ext[2]-1;
+	pointExtent[2][3] = 1.0;
+	pointExtent[3][0] = w_ext[0]-1;
+	pointExtent[3][1] = 0.0;
+	pointExtent[3][2] = w_ext[2]-1;
+	pointExtent[3][3] = 1.0;
+	pointExtent[4][0] = w_ext[0]-1;
+	pointExtent[4][1] = w_ext[1]-1;
+	pointExtent[4][2] = 0.0;
+	pointExtent[4][3] = 1.0;
+	pointExtent[5][0] = 0.0;
+	pointExtent[5][1] = 0.0;
+	pointExtent[5][2] = w_ext[2]-1;
+	pointExtent[5][3] = 1.0;
+	pointExtent[6][0] = 0.0;
+	pointExtent[6][1] = w_ext[1]-1;
+	pointExtent[6][2] = 0.0;
+	pointExtent[6][3] = 1.0;
+	pointExtent[7][0] = w_ext[0]-1;
+	pointExtent[7][1] = 0.0;
+	pointExtent[7][2] = 0.0;
+	pointExtent[7][3] = 1.0;
+	
+	centre[0] = Xval->text().toDouble();
+	centre[1] = Yval->text().toDouble();
+	centre[2] = Zval->text().toDouble();
+	
+	for (int k=0; k<8; ++k) {
+	    for (int j=0; j<3; ++j)
+	    {
+	        pointOverlayExtent[k][j] = mCurrentSlicerManager->GetImage()->GetSpacing()[j]*pointExtent[k][j] - centre[j];
+	    }
+	    pointOverlayExtent[k][3] = 0.0;
+	    matrixTranspose->MultiplyPoint(pointOverlayExtent[k], pointOverlayExtentUpdate[k]);
+	    for (int j=0; j<3; ++j)
+	    {
+	        pointOverlayExtentUpdate[k][j] = (pointOverlayExtentUpdate[k][j] + centre[j])/mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+	        cout << pointOverlayExtentUpdate[k][j] << " ";
+	    }
+	    cout << endl;
+    }
+	cout << endl;
+	for (int k=0; k<8; ++k) {
+	    for (int j=0; j<3; ++j)
+	    {
+	        pointExtent[k][j] = mCurrentSlicerManager->GetImage()->GetSpacing()[j] * pointExtent[k][j];
+	    }
+	    matrixTranspose->MultiplyPoint(pointExtent[k], pointExtentUpdate[k]);
+		for (int j=0; j<3; ++j)
+	    {
+	        pointExtentUpdate[k][j] = (pointExtentUpdate[k][j])/mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+	        cout << pointExtentUpdate[k][j] << " ";
+	    }
+	    cout << endl;
+    }
+    double extUpdateTemp[2][3], extOverlayUpdateTemp[2][3];
+    int extUpdate[6];
+    ExtentMax(pointExtentUpdate, extUpdateTemp);
+    ExtentMax(pointOverlayExtentUpdate, extOverlayUpdateTemp);
+    for (int j=0; j<3; ++j) {
+        extUpdate[2*j] = 0;
+        extUpdate[2*j+1] = itk::Math::Round<double>(extUpdateTemp[1][j] - extUpdateTemp[0][j]);
+    }
+    mCurrentSlicerManager->GetSlicer(i)->SetRegisterExtent(extUpdate);
+    extUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()] = mCurrentSlicerManager->GetSlicer(i)->GetSlice();
+    extUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()+1] = mCurrentSlicerManager->GetSlicer(i)->GetSlice();
+    
+    vtkSmartPointer<vtkOpenGLImageSliceMapper> mapperOpenGL= vtkSmartPointer<vtkOpenGLImageSliceMapper>::New();
+    try {
+        mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(mCurrentSlicerManager->GetSlicer(i)->GetImageActor()->GetMapper());
+    } catch (const std::bad_cast& e) {
+		std::cerr << e.what() << std::endl;
+		std::cerr << "Conversion error" << std::endl;
+		return;
+	}
+	cout << extUpdate[0] << " " << extUpdate[1] << " " << extUpdate[2] << " " << extUpdate[3] << " " << extUpdate[4] << " " << extUpdate[5] << endl;
+	mapperOpenGL->SetCroppingRegion(extUpdate);
+	
+	if (mCurrentSlicerManager->GetSlicer(i)->GetOverlay() && mCurrentSlicerManager->GetSlicer(i)->GetOverlayActor()->GetVisibility()) {
+	    int extOverlayUpdate[6];
+	    for (int j=0; j<3; ++j) { //Rotation
+	        if (extOverlayUpdateTemp[1][j] - extOverlayUpdateTemp[0][j] > w_ext[j]-1) {
+	            extOverlayUpdate[2*j] = 0;
+	            extOverlayUpdate[2*j+1] = w_ext[j]-1;
+	        } else {
+	            extOverlayUpdate[2*j] = itk::Math::Round<double>(extOverlayUpdateTemp[0][j]);
+	            extOverlayUpdate[2*j+1] = itk::Math::Round<double>(extOverlayUpdateTemp[1][j]);
+	        }
+	    }
+	    
+	    //Compute translation
+	    double pointOrigin[4], pointOriginUpdate[4];
+	    for (int j=0; j<3; ++j)
+	    {
+	        pointOrigin[j] = 0 - centre[j];
+	    }
+	    pointOrigin[3] = 0.0;
+	    matrix->MultiplyPoint(pointOrigin, pointOriginUpdate);
+	    for (int j=0; j<3; ++j)
+	    {
+	        pointOriginUpdate[j] = (pointOriginUpdate[j] + centre[j])/mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+	        translation[j] = matrix->GetElement(j,3) - pointOriginUpdate[j]*mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+	        pointOrigin[j] = translation[j];
+	    }
+	    pointOrigin[3] = 0.0;
+	    matrixTranspose->MultiplyPoint(pointOrigin, pointOriginUpdate);
+	    for (int j=0; j<3; ++j)
+	    {
+	        translation[j] = pointOriginUpdate[j]/mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+	    }
+	    
+	    for (int j=0; j<3; ++j) { //Translation
+	        if (0 < extOverlayUpdateTemp[0][j] - translation[j]) {
+	            extOverlayUpdate[2*j] = itk::Math::Round<double>(extOverlayUpdateTemp[0][j] - translation[j]);
+	        } else {
+	            extOverlayUpdate[2*j] = 0;
+	        }
+	        if (extOverlayUpdateTemp[1][j] - translation[j] < w_ext[j]-1) {
+	            extOverlayUpdate[2*j+1] = itk::Math::Round<double>(extOverlayUpdateTemp[1][j] - translation[j]);
+	        } else {
+	            extOverlayUpdate[2*j+1] = w_ext[j]-1;
+	        }
+	    }
+	    extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()] += mCurrentSlicerManager->GetSlicer(i)->GetSlice();
+        extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()+1] = extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()];
+	    vtkSmartPointer<vtkOpenGLImageSliceMapper> mapperOpenGL= vtkSmartPointer<vtkOpenGLImageSliceMapper>::New();
+	    try {
+            mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(mCurrentSlicerManager->GetSlicer(i)->GetOverlayActor()->GetMapper());
+        } catch (const std::bad_cast& e) {
+		    std::cerr << e.what() << std::endl;
+		    std::cerr << "Conversion error" << std::endl;
+		    return;
+	    }
+	    
+	    //Slice number
+	    double spacing[4],spacingUpdate[4];
+	    int sliceNumber;
+	    spacing[0] = 240*mCurrentSlicerManager->GetImage()->GetSpacing()[0]-centre[0];
+	    spacing[1] = 179*mCurrentSlicerManager->GetImage()->GetSpacing()[1]-centre[1];
+	    spacing[2] = 22*mCurrentSlicerManager->GetImage()->GetSpacing()[2]-centre[2];
+	    spacing[3] = 0;
+	    matrixTranspose->MultiplyPoint(spacing, spacingUpdate);
+	    spacingUpdate[0] = (spacingUpdate[0]+centre[0])/mCurrentSlicerManager->GetImage()->GetSpacing()[0];
+	    spacingUpdate[1] = (spacingUpdate[1]+centre[1])/mCurrentSlicerManager->GetImage()->GetSpacing()[1];
+	    spacingUpdate[2] = (spacingUpdate[2]+centre[2])/mCurrentSlicerManager->GetImage()->GetSpacing()[2];
+	    cout << spacingUpdate[0] << " " << spacingUpdate[1] << " " << spacingUpdate[2] << endl;
+	    sliceNumber = mCurrentSlicerManager->GetSlicer(i)->GetSlice()*spacingUpdate[mCurrentSlicerManager->GetSlicer(i)->GetOrientation()]/mCurrentSlicerManager->GetImage()->GetSpacing()[mCurrentSlicerManager->GetSlicer(i)->GetOrientation()];
+	    extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()] = 12;//sliceNumber;
+	    extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()+1] = 12;//sliceNumber;
+	    
+	    mapperOpenGL->SetCroppingRegion(extOverlayUpdate);
+	}
+#endif
     mCurrentSlicerManager->GetSlicer(i)->ForceUpdateDisplayExtent();
     mCurrentSlicerManager->GetSlicer(i)->Render();
-    }
+}
 }
 //------------------------------------------------------------------------------