Debug try with ImageReslice update and autoCrop

diff --git a/vv/vvSlicer.cxx b/vv/vvSlicer.cxx
index 3773aa0477cec92a846084869972b6a03d3c8d26..c35e8cc4bcd39d974e4018df2fd4ba9317785194 100644 (file)
--- a/vv/vvSlicer.cxx
+++ b/vv/vvSlicer.cxx
@@ -1097,30 +1097,40 @@ void vvSlicer::UpdateDisplayExtent()
   this->ImageActor->SetVisibility(mImageVisibility);
   this->ImageActor->SetDisplayExtent(w_ext);
 #if VTK_MAJOR_VERSION >= 6
+//mSlicingTransform->Print(cout);
+//GetImage()->GetTransform()[0]->Print(cout);
+//mSlicingTransform = GetImage()->GetTransform()[0];
+//mImageReslice->SetResliceTransform(mSlicingTransform);
+//mImageReslice->AutoCropOutputOff();
+//mImageReslice->Update();
+int* extentTest = mImageReslice->GetOutput()->GetExtent();
+cout<< extentTest[0] << " " << extentTest[1] << " " <<  extentTest[2] << " " <<  extentTest[3] << " " <<  extentTest[4] << " " <<  extentTest[5] << endl;
+//this->GetInput()->Print(cout);
+//GetImageActor()->GetMapper()->Print(cout);
   vtkSmartPointer<vtkOpenGLImageSliceMapper> mapperOpenGL= vtkSmartPointer<vtkOpenGLImageSliceMapper>::New();
-
   try {
-        mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(GetImageActor()->GetMapper());
+    mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(GetImageActor()->GetMapper());
   } catch (const std::bad_cast& e) {
-               std::cerr << e.what() << std::endl;
-               std::cerr << "Conversion error" << std::endl;
-               return;
+    std::cerr << e.what() << std::endl;
+       std::cerr << "Conversion error" << std::endl;
+       return;
   }
   if (mFirstSetSliceOrientation) {
     copyExtent(ext, mRegisterExtent);
   } else {
     int w_croppingRegion[6];
     if (mUseReducedExtent) {
-        copyExtent(mReducedExtent, w_croppingRegion);
+        copyExtent(extentTest, w_croppingRegion);
     } else {
-        copyExtent(mRegisterExtent, w_croppingRegion);
+        copyExtent(extentTest, w_croppingRegion);
     }
-    this->ImageActor->SetDisplayExtent(w_ext);
+    cout << "w_ext : " << w_ext[0] << " " << w_ext[1] << " " << w_ext[2] << " " << w_ext[3] << " " << w_ext[4] << " " << w_ext[5] << endl;
     w_croppingRegion[ this->SliceOrientation*2   ] = this->Slice;
     w_croppingRegion[ this->SliceOrientation*2+1 ] = this->Slice;
-    mapperOpenGL->SetCroppingRegion(w_croppingRegion);    
+    mapperOpenGL->SetCroppingRegion(w_croppingRegion);
+    cout << "w_croppingRegion : " << w_croppingRegion[0] << " " << w_croppingRegion[1] << " " << w_croppingRegion[2] << " " << w_croppingRegion[3] << " " << w_croppingRegion[4] << " " << w_croppingRegion[5] << endl;
   }
-#endif 
+#endif
   
 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
   // Fix for bug #1882
@@ -1129,6 +1139,7 @@ void vvSlicer::UpdateDisplayExtent()
 
   // Overlay image actor
   if (mOverlay && mOverlayVisibility) {
+    //mOverlayMapper->GetOutput()->Print(cout);
     AdjustResliceToSliceOrientation(mOverlayReslice);
     int overExtent[6];
     this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlayReslice->GetOutput(), overExtent);
@@ -1596,7 +1607,6 @@ double vvSlicer::GetScalarComponentAsDouble(vtkImageData *image, double X, doubl
 //----------------------------------------------------------------------------
 void vvSlicer::Render()
 { //out << __func__ << endl;
-
   if (this->mFusion && mFusionActor->GetVisibility() && showFusionLegend) {
     legend->SetLookupTable(this->GetFusionMapper()->GetLookupTable());
     legend->UseOpacityOn();
@@ -1609,6 +1619,7 @@ void vvSlicer::Render()
   } else legend->SetVisibility(0);
 
   if (ca->GetVisibility()) {
+
     std::stringstream worldPos(" ");
     double pt[3];
     mConcatenatedTransform->TransformPoint(mCurrent, pt);
@@ -1648,7 +1659,7 @@ void vvSlicer::Render()
         Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 &&
         Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 &&
         Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5) {
-      
+
       int ix, iy, iz;
       double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
 
@@ -1710,6 +1721,7 @@ void vvSlicer::Render()
                std::cerr << "Conversion error" << std::endl;
                return;
        }
+
     if (xCursor >= mapperOpenGL->GetCroppingRegion()[0]-0.5 &&
         xCursor < mapperOpenGL->GetCroppingRegion()[1]+0.5 &&
         yCursor >= mapperOpenGL->GetCroppingRegion()[2]-0.5 &&

diff --git a/vv/vvSlicer.h b/vv/vvSlicer.h
index 48d14de3c80272cdcdfccd2a2fadf359a5ace108..1818e6c190c812e85f32a2db8d76e354eb63872b 100644 (file)
--- a/vv/vvSlicer.h
+++ b/vv/vvSlicer.h
@@ -148,7 +148,6 @@ public:
   double* GetCursorPosition() {
     return mCursor;
   }
-
   vtkTransform * GetSlicingTransform() { return mSlicingTransform; }
   vtkTransform * GetConcatenatedTransform() { return mConcatenatedTransform; }
   vtkTransform * GetConcatenatedFusionTransform() { return mConcatenatedFusionTransform; }

diff --git a/vv/vvToolRigidReg.cxx b/vv/vvToolRigidReg.cxx
index 5cc862d5aaf2b34fefac0a35b4a24cef2839f148..0c4199325904b32d212f1dd093764ce068573cc2 100644 (file)
--- a/vv/vvToolRigidReg.cxx
+++ b/vv/vvToolRigidReg.cxx
@@ -19,6 +19,7 @@
 // vv
 #include "vvToolRigidReg.h"
 #include "vvSlicer.h"
+#include <vvBlendImageActor.h>
 
 // vtk
 #include <vtkImageData.h>
@@ -358,6 +359,7 @@ void vvToolRigidReg::SetTransform(vtkMatrix4x4 *matrix)
   vtkSmartPointer<vtkTransform> transform=vtkSmartPointer<vtkTransform>::New();
   // TODO SR and BP: check on the list of transforms and not the first only
   mCurrentSlicerManager->GetImage()->GetTransform()[0]->SetMatrix(matrix);
+  //mCurrentSlicerManager->GetSlicer(2)->GetSlicingTransform()->SetMatrix(matrix);
   transform->Update();
   Render();
   dynamic_cast<vvMainWindow*>(mMainWindow)->ImageInfoChanged();
@@ -408,7 +410,7 @@ void vvToolRigidReg::SetTransform(vtkMatrix4x4 *matrix)
       rotSliders[i]->setValue(iAngle);
       rotSliders[i]->blockSignals(false);
     }
-  }
+  }cout << euler->GetParameters()[0+3] << " " << euler->GetParameters()[1+3] << " " << euler->GetParameters()[2+3] << endl;
 }
 //------------------------------------------------------------------------------
 
@@ -459,7 +461,9 @@ void vvToolRigidReg::ExtentMax(const double pointExtent[8][4], double maxExtent[
 //------------------------------------------------------------------------------
 void vvToolRigidReg::Render()
 { //out << __func__ << endl;
-#if VTK_MAJOR_VERSION > 5
+#if VTK_MAJOR_VERSION > 7
+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) {
@@ -468,17 +472,23 @@ for (int i=0; i<3; ++i) {
         matrixTranspose->SetElement(i,j,matrix->GetElement(j,i));
     }
 }
-for (int i=0; i<4; ++i) {
-   matrixTranspose->SetElement(3,i,matrix->GetElement(3,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(i,3,matrix->GetElement(i,3));
+   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];
+for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+#if VTK_MAJOR_VERSION > 7
+    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;
@@ -514,24 +524,46 @@ for (int i=0; i<4; ++i) {
        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()->GetOrigin()[j] + mCurrentSlicerManager->GetImage()->GetSpacing()[j] * pointExtent[k][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()->GetOrigin()[j])/mCurrentSlicerManager->GetImage()->GetSpacing()[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]);
     }
-double extUpdateTemp[2][3];
-int extUpdate[6];
-ExtentMax(pointExtentUpdate, extUpdateTemp);
-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();
@@ -544,11 +576,87 @@ for (int j=0; j<3; ++j) {
                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();
-    }
+}
 }
 //------------------------------------------------------------------------------