]> Creatis software - bbtk.git/blobdiff - packages/vtk/src/bbvtkImagePlanes.cxx
no message
[bbtk.git] / packages / vtk / src / bbvtkImagePlanes.cxx
index 191fcfa426eca62c0f869e548e2d1f94a45431bb..92daa652fad7dca3429fe42ab4b561694f1e2eb4 100644 (file)
@@ -2,8 +2,8 @@
   Program:   bbtk
   Module:    $RCSfile: bbvtkImagePlanes.cxx,v $
   Language:  C++
-  Date:      $Date: 2008/11/25 11:17:23 $
-  Version:   $Revision: 1.10 $
+  Date:      $Date: 2010/03/07 13:18:41 $
+  Version:   $Revision: 1.32 $
 =========================================================================*/
 
 /* ---------------------------------------------------------------------
 #include "bbvtkPackage.h"
 #include "vtkCellPicker.h"
 #include "vtkProperty.h"
+#include "vtkPolyData.h"
+
+
+#include "vtkMetaImageWriter.h"
+#include "vtkPNGWriter.h"
 
 #include "bbstdCast.h"
+#include <vtkCommand.h>
+
+#include "vtkImageData.h"
+//#include "vtkOutlineFilter.h"
+//#include "vtkPolyDataMapper.h"
+//#include "vtkActor.h"
+#include "vtkImagePlaneWidget.h"
+#include "vtkCellPicker.h"
+//#include "vtkProperty.h"
+
+//#include "vtkRenderer.h"
+//#include "vtkCamera.h"
+
+#include "vtkPlaneWidget.h"
+
+#include <vtkImplicitPlaneWidget.h>
+
+#include "bbstdRelay.h"
+
+#include "vtkObjectFactory.h"
+
+
 namespace bbstd
 {
+
   //====================================================================
   BBTK_BLACK_BOX_TEMPLATE2_IMPLEMENTATION(Cast,
                                          bbtk::AtomicBlackBox);
   //====================================================================
+  //====================================================================
+//  BBTK_BLACK_BOX_TEMPLATE_IMPLEMENTATION(Relay,
+//                                      bbtk::AtomicBlackBox);
+  //====================================================================
 
 }
 using namespace bbstd;
+/*
+namespace bbtk
+{
+       typedef vtkImageData::Pointer vtkImageDataPointer;
+  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(vtkImageDataPointer,
+                                      "vtkImageDataPointer");
+}
+*/
 namespace bbvtk
 {
+
+
   //====================================================================
   // Add the specialized adaptors to the package
   typedef vtkImagePlaneWidget* I;
@@ -58,107 +100,418 @@ namespace bbvtk
 
   BBTK_ADD_TEMPLATE2_BLACK_BOX_TO_PACKAGE(vtk,Cast,I,O);
 
+  BBTK_DEFINE_RELAY_BLACK_BOX(vtkImageDataPointer,vtk,vtkImageDataPointerRelay);
+  BBTK_BLACK_BOX_IMPLEMENTATION(vtkImageDataPointerRelay,bbtk::AtomicBlackBox);
+
+  BBTK_ADD_BLACK_BOX_TO_PACKAGE(vtk,vtkImageDataPointerRelay);
+ // BBTK_ADD_TEMPLATE_BLACK_BOX_TO_PACKAGE(vtk,Relay,vtkImageDataPointer);
+  //Pointer);
+
 }
 
 namespace bbvtk
 {
 
+  //================================================================
+ class ImagePlanes::VtkCallbackType : public vtkCommand
+ {
+ public:
+   static VtkCallbackType *New()
+   {
+     return new VtkCallbackType;
+   }
+   //vtkTypeRevisionMacro(VtkCallbackType,vtkCommand);
+
+   virtual void Execute(vtkObject *caller, unsigned long, void*)
+   {
+       mBlackBox->Process();
+       mBlackBox->bbSignalOutputModification();
+   } 
+   void SetBlackBox(ImagePlanes *BB) { mBlackBox = BB;};    
+   //   void SetVtkPlaneWidget( vtkImagePlaneWidget *planeWidget );
+   VtkCallbackType() {};
+
+ private:
+   //   vtkPlaneWidget *planeWidget;
+   ImagePlanes *mBlackBox;
+ };
+  //================================================================
+
+  //vtkCxxRevisionMacro(ImagePlanes::VtkCallbackType, "$Revision: 1.32 $");
+
+  //================================================================
 
    BBTK_ADD_BLACK_BOX_TO_PACKAGE(vtk,ImagePlanes)
    BBTK_BLACK_BOX_IMPLEMENTATION(ImagePlanes,bbtk::AtomicBlackBox);
 
-   void ImagePlanes::bbUserConstructor() 
+       
+       
+   void ImagePlanes::bbUserSetDefaultValues() 
    { 
-     planeWidgetX = planeWidgetY = planeWidgetZ = 0;
+     bbSetOutputPlaneX(0);
+     bbSetOutputPlaneY(0);
+     bbSetOutputPlaneZ(0);
+     bbSetOutputImageX(0);
+     bbSetOutputImageY(0);
+     bbSetOutputImageZ(0);
      bbSetInputIn(0);
      std::vector<double> vect;
-     vect.push_back(512);
-     vect.push_back(256);
-     bbSetInputWindowLevel (vect);
+     vect.push_back(0);
+     vect.push_back(0);
+     bbSetInputWindowLevel (vect);  
+     mVtkCallback = 0;
+
+
+        std::vector<int> vectpoints;
+
+     bbSetOutputPlane3Pts(0);
+        bbSetOutputImage3Pts(0);
+        bbSetInputPointsX(vectpoints);
+        bbSetInputPointsY(vectpoints);
+        bbSetInputPointsZ(vectpoints);
+
+        _imageReslicer = NULL;
+        image=NULL;
+        _transform =NULL;
+       _matrix =NULL;
    }
    
-   void ImagePlanes::bbUserCopyConstructor(bbtk::BlackBox::Pointer) 
-   { 
-     planeWidgetX = planeWidgetY = planeWidgetZ = 0;
-   }
 
-   void ImagePlanes::Init() 
-   { 
-     if (planeWidgetX != 0) return;
+       
+   void ImagePlanes::bbUserInitializeProcessing() 
+   {  
+
+     /// CREATION DES WIDGETS
+     if (bbGetOutputPlaneX() != 0) return;
+       
      // The shared picker enables us to use 3 planes at one time
      // and gets the picking order right
      vtkCellPicker* picker = vtkCellPicker::New();
      picker->SetTolerance(0.005);
   
      // The 3 image plane widgets 
-     planeWidgetX = vtkImagePlaneWidget::New();
-     planeWidgetX->DisplayTextOn();
-     planeWidgetX->SetPicker(picker);
-     planeWidgetX->SetKeyPressActivationValue('x');
-     vtkProperty* prop1 = planeWidgetX->GetPlaneProperty();
-     prop1->SetColor(1, 0, 0);
-
-     planeWidgetY = vtkImagePlaneWidget::New();
-     planeWidgetY->DisplayTextOn();
-     planeWidgetY->SetPicker(picker);
-     planeWidgetY->SetKeyPressActivationValue('y');
-     vtkProperty* prop2 = planeWidgetY->GetPlaneProperty();
-     prop2->SetColor(1, 1, 0);
+     vtkImagePlaneWidget* planeWidgetX = GetPlaneWidget('x', 1, 0, 0, picker);
+        vtkImagePlaneWidget* planeWidgetY = GetPlaneWidget('y', 1, 1, 0, picker);
      planeWidgetY->SetLookupTable(planeWidgetX->GetLookupTable());
 
-     planeWidgetZ = vtkImagePlaneWidget::New();
-     planeWidgetZ->DisplayTextOn();
-     planeWidgetZ->SetPicker(picker);
-     planeWidgetZ->SetKeyPressActivationValue('z');
-     vtkProperty* prop3 = planeWidgetZ->GetPlaneProperty();
-     prop3->SetColor(0, 0, 1);
+     vtkImagePlaneWidget* planeWidgetZ = GetPlaneWidget('z', 0, 0, 1, picker);     
      planeWidgetZ->SetLookupTable(planeWidgetX->GetLookupTable());
 
+        vtkImagePlaneWidget* planeWidget3Pts = GetPlaneWidget('3', 0, 1, 1, picker);    
+     planeWidget3Pts->SetLookupTable(planeWidgetX->GetLookupTable());
+
      bbSetOutputPlaneX(planeWidgetX);
      bbSetOutputPlaneY(planeWidgetY);
      bbSetOutputPlaneZ(planeWidgetZ);
+        bbSetOutputPlane3Pts(planeWidget3Pts);  
+     bbSetOutputImageX(planeWidgetX->GetResliceOutput());
+     bbSetOutputImageY(planeWidgetY->GetResliceOutput());
+     bbSetOutputImageZ(planeWidgetZ->GetResliceOutput());
+        bbSetInputInteractor(0);
+        //bbSetOutputImage3Pts(planeWidget3Pts->GetResliceOutput());
 
      picker->UnRegister(NULL);
+     
+     mVtkCallback = VtkCallbackType::New();
+     mVtkCallback->SetBlackBox(this);
+     planeWidgetX->AddObserver(vtkCommand::InteractionEvent,mVtkCallback);
+     planeWidgetY->AddObserver(vtkCommand::InteractionEvent,mVtkCallback);
+     planeWidgetZ->AddObserver(vtkCommand::InteractionEvent,mVtkCallback);  
    }
 
 //---------------------------------------------------------------------
-  void ImagePlanes::bbUserDestructor()
+  void ImagePlanes::bbUserFinalizeProcessing()
   {
+           
+    if (bbGetOutputPlaneX()) 
+      {
 
-    if (planeWidgetX) planeWidgetX->UnRegister(NULL);
-    if (planeWidgetY) planeWidgetY->UnRegister(NULL);
-    if (planeWidgetZ) planeWidgetZ->UnRegister(NULL);
+       /*
 
+         bbGetOutputPlaneX()->RemoveObserver(mVtkCallback);
+         bbGetOutputPlaneY()->RemoveObserver(mVtkCallback);
+         bbGetOutputPlaneZ()->RemoveObserver(mVtkCallback);
+       
+       
+       bbGetOutputPlaneX()->Delete();
+       bbGetOutputPlaneY()->Delete();
+       bbGetOutputPlaneZ()->Delete();
+       mVtkCallback->Delete();
+       */
+       //bbGetOutputPlaneX()->SetInput(NULL);
+       //bbGetOutputPlaneY()->SetInput(NULL);
+       //bbGetOutputPlaneZ()->SetInput(NULL);
+       
+      }
+    
   }
   
 //---------------------------------------------------------------------  
-   void ImagePlanes::Process()
-   {
-     if (bbGetInputIn()!=0)
-       {
-        Init();
+void ImagePlanes::Process()
+{
+       if (bbGetInputIn()!=0)
+       {
 
-        int xMin, xMax, yMin, yMax, zMin, zMax;
-        bbGetInputIn()->GetExtent(xMin, xMax, yMin, yMax, zMin, zMax);
+               int xMin, xMax, yMin, yMax, zMin, zMax;
+               bbGetInputIn()->GetExtent(xMin, xMax, yMin, yMax, zMin, zMax);
 
-        planeWidgetX->SetInput(bbGetInputIn());
-        planeWidgetX->SetPlaneOrientationToXAxes();
-        planeWidgetX->SetSlicePosition((xMax+xMin)/2.); 
+               if ( image != bbGetInputIn()){//bbGetInputStatus("In") != bbtk::UPTODATE ){
+                       // Input image has changed : reinitialize planes
+                       image = bbGetInputIn();                 
+                       
 
-        planeWidgetY->SetInput(bbGetInputIn());
-        planeWidgetY->SetPlaneOrientationToYAxes();
-        planeWidgetY->SetSlicePosition((yMax+yMin)/2.); 
+                       // Initial values : center of the volume (in real world, not in pixels!)
+                       double xSpacing, ySpacing, zSpacing;
+                       bbGetInputIn()->GetSpacing(xSpacing, ySpacing, zSpacing);
 
-        planeWidgetZ->SetInput(bbGetInputIn());
-        planeWidgetZ->SetPlaneOrientationToZAxes();
-        planeWidgetZ->SetSlicePosition((zMax+zMin)/2.); 
+                       bbGetOutputPlaneX()->SetInput(bbGetInputIn());
+                       bbGetOutputPlaneX()->SetPlaneOrientationToXAxes();       
+                       bbGetOutputPlaneX()->SetSlicePosition((xMax+xMin)/2.*xSpacing);
 
-       // planeWidgetZ->SetWindowLevel(512,256);
 
-         planeWidgetZ->SetWindowLevel(bbGetInputWindowLevel()[0],bbGetInputWindowLevel()[1]);
-       }
-   }
+                       //                 bbGetOutputPlaneX()->SetOrigin( 58*xSpacing , 80*ySpacing , 82*zSpacing );
+                       //                 bbGetOutputPlaneX()->SetPoint1( 0*xSpacing, 146*ySpacing, 186*zSpacing);
+                       //                 bbGetOutputPlaneX()->SetPoint2( 126*xSpacing, 146*ySpacing, 0*zSpacing);
+
+
+                       bbGetOutputPlaneY()->SetInput(bbGetInputIn());
+                       bbGetOutputPlaneY()->SetPlaneOrientationToYAxes();
+                       bbGetOutputPlaneY()->SetSlicePosition((yMax+yMin)/2.*ySpacing);
+
+                       bbGetOutputPlaneZ()->SetInput(bbGetInputIn());
+                       bbGetOutputPlaneZ()->SetPlaneOrientationToZAxes();
+                       bbGetOutputPlaneZ()->SetSlicePosition((zMax+zMin)/2.*zSpacing);
+
+                       if (bbGetInputWindowLevel()[0]!=0)
+                       {
+                               bbGetOutputPlaneZ()->SetWindowLevel(bbGetInputWindowLevel()[0],
+                                                               bbGetInputWindowLevel()[1]);
+                       }
+                       else 
+                       {
+                               double *range = image->GetScalarRange();
+                               bbGetOutputPlaneZ()->SetWindowLevel(range[1] - range[0],
+                                                               0.5*(range[1]+range[0]));
+                       }               
+
+                       updateInteractor();
+
+          }
+                       // UPDATE DES SORTIES 
+               bbGetOutputPlaneX()->GetResliceOutput()->Update();
+               bbGetOutputPlaneY()->GetResliceOutput()->Update(); 
+               bbGetOutputPlaneZ()->GetResliceOutput()->Update();               
+
+               std::vector<int> pointsx = bbGetInputPointsX();
+               std::vector<int> pointsy = bbGetInputPointsY();
+               std::vector<int> pointsz = bbGetInputPointsZ();
+
+               //std::cout<<pointsx.size()<<pointsy.size()<<pointsz.size()<<std::endl;
+
+               if(pointsx.size()==pointsy.size() && pointsx.size()==pointsz.size()&&pointsx.size()>=3){
+
+
+                       //Get the corresponding three points out of the vectors
+                       double origin[3];
+                       origin[0] = pointsx[0];
+                       origin[1] = pointsy[0];
+                       origin[2] = pointsz[0];
+
+                       double point1[3];
+                       point1[0] = pointsx[1];
+                       point1[1] = pointsy[1];
+                       point1[2] = pointsz[1];
+                       double point2[3];
+                       point2[0]= pointsx[2];
+                       point2[1]= pointsy[2];
+                       point2[2]= pointsz[2];  
+
+                       //With the three points we create the corresponding X, Y and Z vectors all orthogonal to each other
+                       double* vect1= getNormal(makeVector(origin, point1));
+                       double* vect2= getNormal(makeVector(origin, point2));                           
+                       double* crossp = getCrossProduct(vect1, vect2);
+
+                       double *newx = getCrossProduct(vect2, crossp);
+                       
+                       int ext[6],factor=0;
+                       bbGetInputIn()->GetExtent(ext);
+
+                       factor = ext[0]<ext[3]? ext[3] : ext[0];
+                       factor = factor<ext[5]? ext[5] : factor;
+
+       //for the plane widgets
+                       vtkImagePlaneWidget* plane3pts = (vtkImagePlaneWidget*)bbGetOutputPlane3Pts();
+                       plane3pts->SetInput(bbGetInputIn());                    
+                       double xSpacing, ySpacing, zSpacing;
+                       bbGetInputIn()->GetSpacing(xSpacing, ySpacing, zSpacing);
+                       plane3pts->SetOrigin(pointsx[0]*xSpacing,pointsy[0]*ySpacing,pointsz[0]*zSpacing);      
+                       plane3pts->SetPoint1((origin[0]+newx[0]*factor)*xSpacing,
+                                                                       (origin[1]+newx[1]*factor)*ySpacing,
+                                                                       (origin[2]+newx[2]*factor)*zSpacing);
+                       plane3pts->SetPoint2((origin[0]+vect2[0]*factor)*xSpacing,
+                                                                       (origin[1]+vect2[1]*factor)*ySpacing,
+                                                                       (origin[2]+vect2[2]*factor)*zSpacing);
+                       plane3pts->GetResliceOutput()->Update();
+//To get the slice of image out of the selected volume
+                       if (_imageReslicer==NULL){
+                               _imageReslicer = vtkImageReslice::New();                                        
+                               _imageReslicer->SetOutputDimensionality(2);
+                               _imageReslicer->SetInterpolationModeToLinear();
+                               _transform = vtkTransform::New();
+                               _matrix = vtkMatrix4x4::New();  
+                       }
+                       _imageReslicer->SetInput( bbGetInputIn() );
+                       _imageReslicer->SetInformationInput(bbGetInputIn());    
+                       //fill out the information with the created vectors and using the spacing of the image
+                       _imageReslicer->SetResliceAxesDirectionCosines(newx[0]*xSpacing,newx[1]*xSpacing,newx[2]*xSpacing,
+                                                                       vect2[0]*ySpacing,vect2[1]*ySpacing,vect2[2]*ySpacing,
+                                                                       crossp[0]*zSpacing,crossp[1]*zSpacing,crossp[2]*zSpacing);                      
+                       _imageReslicer->SetResliceAxesOrigin(origin[0]*xSpacing,origin[1]*ySpacing,origin[2]*zSpacing);
+                       _imageReslicer->GetOutput()->Update();
+                       _imageReslicer->GetOutput()->UpdateInformation();
+
+                       
+                       bbSetOutputImage3Pts(_imageReslicer->GetOutput());
+
+
+                        
+                       _matrix->Identity();    
+
+                       _matrix->SetElement(0,0,newx[0]*xSpacing);
+                       _matrix->SetElement(1,0,newx[1]*xSpacing);
+                       _matrix->SetElement(2,0,newx[2]*xSpacing);
+                       _matrix->SetElement(0,1,vect2[0]*ySpacing);
+                       _matrix->SetElement(1,1,vect2[1]*ySpacing);
+                       _matrix->SetElement(2,1,vect2[2]*ySpacing);
+                       _matrix->SetElement(0,2,crossp[0]*zSpacing);
+                       _matrix->SetElement(1,2,crossp[1]*zSpacing);
+                       _matrix->SetElement(2,2,crossp[2]*zSpacing);
+                       _matrix->SetElement(0,3,origin[0]*xSpacing);
+                       _matrix->SetElement(1,3,origin[1]*ySpacing);
+                       _matrix->SetElement(2,3,origin[2]*zSpacing);
+
+                       
+                       _transform->SetMatrix(_matrix);
+
+                       //set the transformation out to be used by other bbBoxes
+                       bbSetOutputTransform3Pts((vtkLinearTransform*)_transform);
+
+
+                                               
+               }               
+       }
+}
+       
+void ImagePlanes::updateInteractor(){
+
+       vtkRenderWindowInteractor* interactor = bbGetInputInteractor();
+
+       if(interactor){
+               bbGetOutputPlaneX()->SetInteractor(interactor);
+               bbGetOutputPlaneX()->EnabledOn();
+               bbGetOutputPlaneY()->SetInteractor(interactor);
+               bbGetOutputPlaneY()->EnabledOn();
+               bbGetOutputPlaneZ()->SetInteractor(interactor);
+               bbGetOutputPlaneZ()->EnabledOn();
+               bbGetOutputPlane3Pts()->SetInteractor(interactor);
+               bbGetOutputPlane3Pts()->EnabledOn();
+       }
+}
+       //-----------------------------------------------------------------     
+       void vtkImageDataPointerRelay::bbUserSetDefaultValues()
+       {
+               
+       }
+       
+       //-----------------------------------------------------------------     
+       void vtkImageDataPointerRelay::bbUserInitializeProcessing()
+       {
+       }
+       
+       //-----------------------------------------------------------------     
+       void vtkImageDataPointerRelay::bbUserFinalizeProcessing()
+       {
+       }
+       
+       vtkImagePlaneWidget* ImagePlanes::GetPlaneWidget(unsigned char activationkey, double r, double g, double b, vtkCellPicker* picker)
+       {
+               vtkProperty* prop1 = 0;         
+               vtkImagePlaneWidget* planeWidget = 0;
+
+               planeWidget = vtkImagePlaneWidget::New();
+               planeWidget->DisplayTextOn();
+               planeWidget->SetPicker(picker);
+               planeWidget->SetKeyPressActivationValue(activationkey);
+               prop1 = planeWidget->GetPlaneProperty();
+               prop1->SetColor(r, g, b);
+
+               return planeWidget;
+       }
+
+double* ImagePlanes::getCrossProduct(double* vect0,double* vect1){
+       double* vectCross;
+       vectCross = new double[3];
+       vectCross[0] = vect0[1]*vect1[2]-(vect0[2]*vect1[1]);
+       vectCross[1] = -(vect0[0]*vect1[2]-(vect0[2]*vect1[0]));
+       vectCross[2] = vect0[0]*vect1[1]-(vect0[1]*vect1[0]);
+
+       return vectCross;
+}
+/**
+**     Returns the magnitud of the given vector
+**/
+double ImagePlanes::getMagnitud(double* vect){
+
+       double mag;
+
+       mag = sqrt(pow(vect[0],2) + pow(vect[1],2) + pow(vect[2],2));
+
+       std::cout<<"mag "<<mag <<std::endl;
+
+       return mag;
+
+}
+/**
+**     returns the unitary vector of the given vector
+**     u = 1/|vect| . vect
+**/
+double* ImagePlanes::getNormal(double* vect){
+
+       double* vectnorm;
+       double mag = getMagnitud(vect);
+
+       vectnorm = new double[3];
+       
+
+       if(mag!=0){
+               vectnorm[0] = vect[0]/mag;
+               vectnorm[1] = vect[1]/mag;
+               vectnorm[2] = vect[2]/mag;
+       }else{
+               vectnorm[0] = 0;
+               vectnorm[1] = 0;
+               vectnorm[2] = 0;
+       }
+
+       return vectnorm;
+
+
+}
+
+double* ImagePlanes::makeVector(double podouble0[3], double podouble1[3]){
+       double *vect;
+       vect = new double[3];
+
+       vect[0]= podouble1[0]-podouble0[0];
+       vect[1]= podouble1[1]-podouble0[1];
+       vect[2]= podouble1[2]-podouble0[2];
+
+       return vect;
+
+}
+       
 }//namespace bbtk
 
 #endif // _USE_VTK_
 
+