]> Creatis software - clitk.git/blobdiff - vv/vvBinaryImageOverlayActor.cxx
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Reformatted using new coding style
[clitk.git] / vv / vvBinaryImageOverlayActor.cxx
diff --git a/vv/vvBinaryImageOverlayActor.cxx b/vv/vvBinaryImageOverlayActor.cxx
index 7d6d26c5c8569e68c817fef46176db0dbfe16217..0405cdb2fda4c4b49968ee2cbd71b6972c242f3d 100644 (file)
--- a/vv/vvBinaryImageOverlayActor.cxx
+++ b/vv/vvBinaryImageOverlayActor.cxx
@@ -1,7 +1,7 @@
 /*=========================================================================
   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
 
-  Authors belong to: 
+  Authors belong to:
   - University of LYON              http://www.universite-lyon.fr/
   - Léon Bérard cancer center       http://oncora1.lyon.fnclcc.fr
   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
@@ -30,7 +30,8 @@
 #include <vtkLookupTable.h>
 
 //------------------------------------------------------------------------------
-vvBinaryImageOverlayActor::vvBinaryImageOverlayActor() {
+vvBinaryImageOverlayActor::vvBinaryImageOverlayActor()
+{
   mTSlice = -1;
   mSlice = 0;
   mColor.resize(3);
@@ -43,7 +44,8 @@ vvBinaryImageOverlayActor::vvBinaryImageOverlayActor() {
 
 
 //------------------------------------------------------------------------------
-vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor() {
+vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
+{
   for (unsigned int i = 0; i < mSlicer->GetImage()->GetVTKImages().size(); i++) {
     mSlicer->GetRenderer()->RemoveActor(mImageActorList[i]);
   }
@@ -54,7 +56,8 @@ vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor() {
 
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::SetColor(double r, double g, double b) {
+void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
+{
   mColor[0] = r;
   mColor[1] = g;
   mColor[2] = b;
@@ -63,26 +66,28 @@ void vvBinaryImageOverlayActor::SetColor(double r, double g, double b) {
 
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer) {
+void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
+{
   mSlicer = slicer;
 }
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::Initialize() {
+void vvBinaryImageOverlayActor::Initialize()
+{
   if (!mSlicer) {
     std::cerr << "ERROR. Please use setSlicer before setSlicer in vvBinaryImageOverlayActor." << std::endl;
     exit(0);
   }
-  
+
   if (!mImage) {
     std::cerr << "ERROR. Please use setImage before setSlicer in vvBinaryImageOverlayActor." << std::endl;
     exit(0);
   }
   // Create an actor for each time slice
   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
-    // how many intensity ? 
+    // how many intensity ?
     vtkImageMapToRGBA * mOverlayMapper = vtkImageMapToRGBA::New();
     mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
     mColorLUT->SetRange(0,1);
@@ -90,7 +95,7 @@ void vvBinaryImageOverlayActor::Initialize() {
     mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);   // BG
     mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
     mOverlayMapper->SetLookupTable(mColorLUT);
-    
+
     vtkImageActor * mOverlayActor = vtkImageActor::New();
     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
     mOverlayActor->SetPickable(0);
@@ -99,14 +104,15 @@ void vvBinaryImageOverlayActor::Initialize() {
 
     mMapperList.push_back(mOverlayMapper);
     mImageActorList.push_back(mOverlayActor);
-    mSlicer->GetRenderer()->AddActor(mOverlayActor);  
+    mSlicer->GetRenderer()->AddActor(mOverlayActor);
   }
 }
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::SetOpacity(double d) {
+void vvBinaryImageOverlayActor::SetOpacity(double d)
+{
   mAlpha = d;
 }
 //------------------------------------------------------------------------------
@@ -117,10 +123,10 @@ void vvBinaryImageOverlayActor::SetOpacity(double d) {
 //   mAlpha = d;
 //   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 //   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
-//     // how many intensity ? 
+//     // how many intensity ?
 //     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 //     mOverlayMapper->SetLookupTable(mColorLUT);
-    
+
 //     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 //     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 //   }
@@ -130,15 +136,15 @@ void vvBinaryImageOverlayActor::SetOpacity(double d) {
 
 //------------------------------------------------------------------------------
 // void vvBinaryImageOverlayActor::SetColor(double r, double v, double b) {
-//   mColor[0] = r; 
-//   mColor[1] = v; 
-//   mColor[2] = b; 
+//   mColor[0] = r;
+//   mColor[1] = v;
+//   mColor[2] = b;
 //   // mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 //   // for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
-//   //   // how many intensity ? 
+//   //   // how many intensity ?
 //   //   vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 //   //   mOverlayMapper->SetLookupTable(mColorLUT);
-    
+
 //   //   vtkImageActor * mOverlayActor = mImageActorList[numImage];
 //   //   mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 //   // }
@@ -147,7 +153,8 @@ void vvBinaryImageOverlayActor::SetOpacity(double d) {
 
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg) {
+void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg)
+{
   mImage = image;
   mBackgroundValue = bg;
 }
@@ -155,7 +162,8 @@ void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg) {
 
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::HideActors() {
+void vvBinaryImageOverlayActor::HideActors()
+{
   if (!mSlicer) return;
   mSlice = mSlicer->GetSlice();
   for(unsigned int i=0; i<mImageActorList.size(); i++) {
@@ -165,9 +173,10 @@ void vvBinaryImageOverlayActor::HideActors() {
 }
 //------------------------------------------------------------------------------
 
-  
+
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::ShowActors() {
+void vvBinaryImageOverlayActor::ShowActors()
+{
   if (!mSlicer) return;
   mSlice = mSlicer->GetSlice();
   mTSlice = mSlicer->GetTSlice();
@@ -179,15 +188,16 @@ void vvBinaryImageOverlayActor::ShowActors() {
 }
 //------------------------------------------------------------------------------
 
-  
+
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::UpdateColor() {
+void vvBinaryImageOverlayActor::UpdateColor()
+{
   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
-    // how many intensity ? 
+    // how many intensity ?
     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
     mOverlayMapper->SetLookupTable(mColorLUT);
-    
+
     vtkImageActor * mOverlayActor = mImageActorList[numImage];
     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
   }
@@ -195,7 +205,8 @@ void vvBinaryImageOverlayActor::UpdateColor() {
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice) {
+void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice)
+{
   if (!mSlicer) return;
 
   if (mPreviousSlice == mSlicer->GetSlice()) {
@@ -216,13 +227,13 @@ void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice) {
   ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
   //ComputeExtent(imageExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
   ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
-  // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " " 
+  // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " "
   //       << maskExtent[3] << " " << maskExtent[4] << " " << maskExtent[5] << std::endl;
   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetWholeExtent());
-  // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " " 
+  // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " "
   //       << maskExtent[3] << " " << maskExtent[4] << " " << maskExtent[5] << std::endl;
   SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], 0.0);
-  
+
   // set previous slice
   mPreviousTSlice = mSlicer->GetTSlice();
   mPreviousSlice  = mSlicer->GetSlice();
@@ -231,29 +242,30 @@ void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice) {
 
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::ComputeExtent(int orientation, 
-                                             int slice, 
-                                             int * inExtent,
-                                             int * outExtent) {
-  //  std::cout << "InExtent = " << inExtent[0] << " " << inExtent[1] << " " << inExtent[2] << " " 
+void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
+    int slice,
+    int * inExtent,
+    int * outExtent)
+{
+  //  std::cout << "InExtent = " << inExtent[0] << " " << inExtent[1] << " " << inExtent[2] << " "
   //       << inExtent[3] << " " << inExtent[4] << " " << inExtent[5] << std::endl;
   //  DD(orientation);
   switch (orientation) {
   case vtkImageViewer2::SLICE_ORIENTATION_XY:
     for(int i=0; i<4; i++) outExtent[i] = inExtent[i];
-    outExtent[4] = outExtent[5] = slice; 
+    outExtent[4] = outExtent[5] = slice;
     break;
   case vtkImageViewer2::SLICE_ORIENTATION_XZ:
     for(int i=0; i<2; i++) outExtent[i] = inExtent[i];
     for(int i=4; i<6; i++) outExtent[i] = inExtent[i];
-    outExtent[2] = outExtent[3] = slice; 
+    outExtent[2] = outExtent[3] = slice;
     break;
   case vtkImageViewer2::SLICE_ORIENTATION_YZ:
     for(int i=2; i<6; i++) outExtent[i] = inExtent[i];
-    outExtent[0] = outExtent[1] = slice; 
+    outExtent[0] = outExtent[1] = slice;
     break;
   }
-  // std::cout << "OutExtent = " << outExtent[0] << " " << outExtent[1] << " " << outExtent[2] << " " 
+  // std::cout << "OutExtent = " << outExtent[0] << " " << outExtent[1] << " " << outExtent[2] << " "
   //       << outExtent[3] << " " << outExtent[4] << " " << outExtent[5] << std::endl;
 }
 //------------------------------------------------------------------------------
@@ -263,49 +275,50 @@ void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
 void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
 {
   outExtent[0] = (( image->GetOrigin()[0] + inExtent[0]*image->GetSpacing()[0] ) - overlay->GetOrigin()[0]) /
-    overlay->GetSpacing()[0];
+                 overlay->GetSpacing()[0];
   outExtent[1] = (( image->GetOrigin()[0] + inExtent[1]*image->GetSpacing()[0] ) - overlay->GetOrigin()[0]) /
-    overlay->GetSpacing()[0];
+                 overlay->GetSpacing()[0];
   outExtent[2] = (( image->GetOrigin()[1] + inExtent[2]*image->GetSpacing()[1] ) - overlay->GetOrigin()[1]) /
-    overlay->GetSpacing()[1];
+                 overlay->GetSpacing()[1];
   outExtent[3] = (( image->GetOrigin()[1] + inExtent[3]*image->GetSpacing()[1] ) - overlay->GetOrigin()[1]) /
-    overlay->GetSpacing()[1];
+                 overlay->GetSpacing()[1];
   outExtent[4] = (( image->GetOrigin()[2] + inExtent[4]*image->GetSpacing()[2] ) - overlay->GetOrigin()[2]) /
-    overlay->GetSpacing()[2];
+                 overlay->GetSpacing()[2];
   outExtent[5] = (( image->GetOrigin()[2] + inExtent[5]*image->GetSpacing()[2] ) - overlay->GetOrigin()[2]) /
-    overlay->GetSpacing()[2];
+                 overlay->GetSpacing()[2];
 }
 //----------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation, 
-                                                                 int slice, 
-                                                                 int * extent, 
-                                                                 vtkImageActor * actor, 
-                                                                 double position) {
+void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation,
+    int slice,
+    int * extent,
+    vtkImageActor * actor,
+    double position)
+{
   actor->SetDisplayExtent(extent);
-  
+
   // Set position
   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XY) {
     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice)
       actor->SetPosition(0,0, position);
     else
-      actor->SetPosition(0,0, -position);    
+      actor->SetPosition(0,0, -position);
   }
   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XZ) {
     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice)
       actor->SetPosition(0,position,0);
     else
-      actor->SetPosition(0,-position,0);    
+      actor->SetPosition(0,-position,0);
   }
   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_YZ) {
     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice)
       actor->SetPosition(position,0, 0);
     else
-      actor->SetPosition(-position,0, 0);    
+      actor->SetPosition(-position,0, 0);
   }
-  
+
 }
 //------------------------------------------------------------------------------
 
Public Command Line ITK tools and VV