Authors belong to:
- University of LYON http://www.universite-lyon.fr/
- - Léon Bérard cancer center http://oncora1.lyon.fnclcc.fr
+ - Léon Bérard cancer center http://www.centreleonberard.fr
- CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
This software is distributed WITHOUT ANY WARRANTY; without even
- BSD See included LICENSE.txt file
- CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
- ======================================================================-====*/
+ ===========================================================================**/
#include "vvImageContour.h"
#include "vvImage.h"
+#include <vtkVersion.h>
#include <vtkImageActor.h>
#include <vtkCamera.h>
#include <vtkRenderer.h>
#include <vtkImageData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
+#include <vtkInformation.h>
//------------------------------------------------------------------------------
vvImageContour::vvImageContour()
-{
+{
mTSlice = -1;
mSlice = 0;
mHiddenImageIsUsed = false;
mDisplayModeIsPreserveMemory = true;
SetPreserveMemoryModeEnabled(true);
+ mPreviousOrientation = -1;
+ mPreviousValue=0;
+ mDepth = 1.0;
+ mSlice = 0;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vvImageContour::~vvImageContour()
-{
- for (unsigned int i = 0; i < mSlicer->GetImage()->GetVTKImages().size(); i++) {
- mSlicer->GetRenderer()->RemoveActor(mSquaresActorList[i]);
+{
+ mSquaresActorList.clear();
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvImageContour::RemoveActors()
+{
+ for (unsigned int i = 0; i < mSquaresActorList.size(); i++) {
+ if (mSlicer != 0) {
+ if (mSlicer!= NULL) {
+ if (mSlicer->GetRenderer() != NULL) {
+ if (mSquaresActorList[i] != NULL) {
+ mSlicer->GetRenderer()->RemoveActor(mSquaresActorList[i]);
+ }
+ }
+ }
+ }
}
- mSquaresActorList.clear();
- mSquaresList.clear();
- mClipperList.clear();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvImageContour::SetSlicer(vvSlicer * slicer) {
+void vvImageContour::SetSlicer(vvSlicer * slicer)
+{
mSlicer = slicer;
// Create an actor for each time slice
for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
- vtkImageClip * mClipper;// = vtkImageClip::New();
- vtkMarchingSquares * mSquares;// = vtkMarchingSquares::New();
- vtkActor * mSquaresActor;// = vtkActor::New();
- CreateNewActor(&mSquaresActor, &mSquares, &mClipper, numImage);
- mSquaresActorList.push_back(mSquaresActor);
- mSquaresList.push_back(mSquares);
- mClipperList.push_back(mClipper);
+ CreateNewActor(numImage);
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvImageContour::SetImage(vvImage * image) {
+void vvImageContour::SetImage(vvImage::Pointer image)
+{
for (unsigned int numImage = 0; numImage < image->GetVTKImages().size(); numImage++) {
+#if VTK_MAJOR_VERSION <= 5
mClipperList[numImage]->SetInput(image->GetVTKImages()[numImage]);
+#else
+ mClipperList[numImage]->SetInputData(image->GetVTKImages()[numImage]);
+#endif
}
mHiddenImageIsUsed = true;
mHiddenImage = image;
//------------------------------------------------------------------------------
-void vvImageContour::SetPreserveMemoryModeEnabled(bool b) {
+void vvImageContour::SetPreserveMemoryModeEnabled(bool b)
+{
// FastCache mode work only if threshold is always the same
if (mDisplayModeIsPreserveMemory == b) return;
mDisplayModeIsPreserveMemory = b;
//------------------------------------------------------------------------------
-void vvImageContour::SetColor(double r, double g, double b) {
+void vvImageContour::SetColor(double r, double g, double b)
+{
for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
mSquaresActorList[i]->GetProperty()->SetColor(r,g,b);
+ mSquaresActorList[i]->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvImageContour::SetLineWidth(double w)
-{
+{
for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
mSquaresActorList[i]->GetProperty()->SetLineWidth(w);
}
//------------------------------------------------------------------------------
-void vvImageContour::HideActors() {
+void vvImageContour::HideActors()
+{
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
//------------------------------------------------------------------------------
-void vvImageContour::ShowActors() {
+void vvImageContour::ShowActors()
+{
if (!mSlicer) return;
mSlice = mSlicer->GetSlice();
mTSlice = mSlicer->GetTSlice();
//------------------------------------------------------------------------------
-void vvImageContour::Update(double value) {
+void vvImageContour::SetDepth(double d)
+{
+ mDepth = d;
+ // Move the actor to be visible
+ double position[3] = {0, 0, 0};
+ int orientation = ComputeCurrentOrientation();
+ position[orientation] = -mDepth;
+
+ for(unsigned int i=0; i<mSquaresActorList.size(); i++)
+ mSquaresActorList[i]->SetPosition(position);
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvImageContour::Update(double value)
+{
if (!mSlicer) return;
if (mPreviousValue == value) {
if (mPreviousSlice == mSlicer->GetSlice()) {
if (mPreviousTSlice == mSlicer->GetTSlice()) {
- return; // Nothing to do
+ if (mPreviousOrientation == ComputeCurrentOrientation()) {
+ return; // Nothing to do
+ }
}
}
}
UpdateWithFastCacheMode();
}
- // mSlicer->Render(); //DS ---> REMOVE ??
+ //mSlicer->Render(); //DS ---> REMOVE ??
mPreviousTSlice = mSlicer->GetTSlice();
mPreviousSlice = mSlicer->GetSlice();
mPreviousValue = value;
+ mPreviousOrientation = ComputeCurrentOrientation();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvImageContour::UpdateWithPreserveMemoryMode() {
+void vvImageContour::UpdateWithPreserveMemoryMode()
+{
// Only change actor visibility if tslice change
- int mPreviousTslice = mTSlice;
+ mPreviousTslice = mTSlice;
mTSlice = mSlicer->GetTSlice();
vtkMarchingSquares * mSquares = mSquaresList[mTSlice];
+ vtkPolyDataMapper* mapper = mSquaresMapperList[mTSlice];
vtkImageClip * mClipper = mClipperList[mTSlice];
vtkActor * mSquaresActor = mSquaresActorList[mTSlice];
int orientation = ComputeCurrentOrientation();
- UpdateActor(mSquaresActor, mSquares, mClipper, mValue, orientation, mSlice);
- mSquaresActorList[mTSlice]->VisibilityOn();
+ UpdateActor(mSquaresActor, mapper, mSquares, mClipper, mValue, orientation, mSlice);
if (mPreviousTslice != mTSlice) {
if (mPreviousTslice != -1) mSquaresActorList[mPreviousTslice]->VisibilityOff();
}
+
+ //mSlicer->Render();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvImageContour::InitializeCacheMode() {
+void vvImageContour::InitializeCacheMode()
+{
clitkExceptionMacro("TODO : not implemented yet");
mPreviousSlice = mPreviousOrientation = 0;
int dim = mSlicer->GetImage()->GetNumberOfDimensions();
//------------------------------------------------------------------------------
-int vvImageContour::ComputeCurrentOrientation() {
+int vvImageContour::ComputeCurrentOrientation()
+{
// Get extent of image in the slicer
int* extent = mSlicer->GetImageActor()->GetDisplayExtent();
//------------------------------------------------------------------------------
-void vvImageContour::UpdateWithFastCacheMode() {
+void vvImageContour::UpdateWithFastCacheMode()
+{
clitkExceptionMacro("TODO : not implemented yet");
// Compute orientation
if (actor != NULL) {
mListOfCachedContourActors[orientation][mSlice]->VisibilityOn();
} else {
- vtkImageClip * mClipper;
- vtkMarchingSquares * mSquares;
- vtkActor * mSquaresActor;
- CreateNewActor(&mSquaresActor, &mSquares, &mClipper, 0);
- UpdateActor(mSquaresActor, mSquares, mClipper, mValue, orientation, mSlice);
- mListOfCachedContourActors[orientation][mSlice] = mSquaresActor;
- mSquaresActor->VisibilityOn();
+ CreateNewActor(0);
+ //SR: commented out, this code is never reached anyway
+ //UpdateActor(mSquaresActor, mSquares, mClipper, mValue, orientation, mSlice);
+ //mListOfCachedContourActors[orientation][mSlice] = mSquaresActor;
+ //mSquaresActor->VisibilityOn();
}
if (mListOfCachedContourActors[mPreviousOrientation][mPreviousSlice] != NULL)
//------------------------------------------------------------------------------
-void vvImageContour::CreateNewActor(vtkActor ** actor,
- vtkMarchingSquares ** squares,
- vtkImageClip ** clipper,
- int numImage) {
- vtkSmartPointer<vtkActor> mSquaresActor = (*actor = vtkSmartPointer<vtkActor>::New());
- vtkSmartPointer<vtkImageClip> mClipper = (*clipper = vtkSmartPointer<vtkImageClip>::New());
- vtkSmartPointer<vtkMarchingSquares> mSquares = (*squares = vtkSmartPointer<vtkMarchingSquares>::New());
- vtkSmartPointer<vtkPolyDataMapper> mSquaresMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-
- if (mHiddenImageIsUsed)
- mClipper->SetInput(mHiddenImage->GetVTKImages()[0]);
- else
- mClipper->SetInput(mSlicer->GetImage()->GetVTKImages()[numImage]);
- mSquares->SetInput(mClipper->GetOutput());
- mSquaresMapper->SetInput(mSquares->GetOutput());
- mSquaresMapper->ScalarVisibilityOff();
- mSquaresActor->SetMapper(mSquaresMapper);
- mSquaresActor->GetProperty()->SetColor(1.0,0,0);
- mSquaresActor->SetPickable(0);
- mSquaresActor->VisibilityOff();
- mSlicer->GetRenderer()->AddActor(mSquaresActor);
+void vvImageContour::CreateNewActor(int numImage)
+{
+ vtkSmartPointer<vtkActor> squaresActor = vtkSmartPointer<vtkActor>::New();
+ vtkSmartPointer<vtkImageClip> clipper = vtkSmartPointer<vtkImageClip>::New();
+ vtkSmartPointer<vtkMarchingSquares> squares = vtkSmartPointer<vtkMarchingSquares>::New();
+ vtkSmartPointer<vtkPolyDataMapper> squaresMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+
+ if (mHiddenImageIsUsed) {
+#if VTK_MAJOR_VERSION <= 5
+ clipper->SetInput(mHiddenImage->GetVTKImages()[0]);
+#else
+ clipper->SetInputData(mHiddenImage->GetVTKImages()[0]);
+#endif
+ } else {
+#if VTK_MAJOR_VERSION <= 5
+ clipper->SetInput(mSlicer->GetImage()->GetVTKImages()[numImage]);
+#else
+ clipper->SetInputData(mSlicer->GetImage()->GetVTKImages()[numImage]);
+#endif
+ }
+#if VTK_MAJOR_VERSION <= 5
+ squares->SetInput(clipper->GetOutput());
+ squaresMapper->SetInput(squares->GetOutput());
+#else
+ squares->SetInputConnection(clipper->GetOutputPort(0));
+ squaresMapper->SetInputConnection(squares->GetOutputPort(0));
+#endif
+ squaresMapper->ScalarVisibilityOff();
+ squaresActor->SetMapper(squaresMapper);
+ squaresActor->GetProperty()->SetColor(1.0,0,0);
+ squaresActor->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL
+ squaresActor->SetPickable(0);
+ squaresActor->VisibilityOff();
+ mSlicer->GetRenderer()->AddActor(squaresActor);
+
+ mSquaresActorList.push_back(squaresActor);
+ mClipperList.push_back(clipper);
+ mSquaresList.push_back(squares);
+ mSquaresMapperList.push_back(squaresMapper);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvImageContour::UpdateActor(vtkActor * actor,
+ vtkPolyDataMapper * mapper,
vtkMarchingSquares * squares,
vtkImageClip * clipper,
- double threshold, int orientation, int slice) {
- // Set parameter for the MarchigSquare
+ double threshold, int orientation, int slice)
+{
+ // Set parameter for the MarchigSquare
squares->SetValue(0, threshold);
-
+ squares->Update();
// Get image extent
int* extent = mSlicer->GetImageActor()->GetDisplayExtent();
s = s-mHiddenImage->GetFirstVTKImageData()->GetOrigin()[orientation]; // from corner second image
s = s/mHiddenImage->GetFirstVTKImageData()->GetSpacing()[orientation]; // in voxel
- if (s == floor(s)) {
- extent2[orientation*2] = extent2[orientation*2+1] = (int)floor(s);
- } else {
- extent2[orientation*2] = (int)floor(s);
- extent2[orientation*2+1] = extent2[orientation*2];
- }
+ // Rint to the closest slice
+ extent2[orientation*2+1] = extent2[orientation*2] = (int)lrint(s);
// Do not display a contour if there is no contour on this slice
- if (extent2[orientation*2+1] > extent3[orientation*2+1]) {
+ // DD(extent2[orientation*2+1]);
+ // DD(extent3[orientation*2+1]);
+ // DD(extent2[orientation*2]);
+ // DD(extent3[orientation*2]);
+ if ((extent2[orientation*2+1] > extent3[orientation*2+1]) ||
+ (extent2[orientation*2] < extent3[orientation*2])) {
actor->VisibilityOff();
return;
}
} else {
extent2 = extent;
+ actor->VisibilityOn();
}
-
+
clipper->SetOutputWholeExtent(extent2[0],extent2[1],extent2[2],
extent2[3],extent2[4],extent2[5]);
-
- if (mHiddenImage) delete extent2;
+
+ if (mHiddenImageIsUsed) delete extent2;
// Move the actor to be visible
- switch (orientation) {
- case 0:
- actor->SetPosition(-1,0,0);
- /*
- // DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0]);
- if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice) {
- actor->SetPosition(1,0,0);
- } else {
- actor->SetPosition(-1,0,0);
- }*/
- break;
- case 1:
- actor->SetPosition(0,-1,0);
- /*
- // DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1]);
- if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice) {
- actor->SetPosition(0,1,0);
- } else {
- actor->SetPosition(0,-1,0);
- }
- */
- break;
- case 2:
- actor->SetPosition(0,0,-1);
- /*
- DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2]);
- if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice) {
- DD("1");
- actor->SetPosition(0,0,1);
- } else {
- DD("-1");
- actor->SetPosition(0,0,-1);
- }
- */
- break;
- }
-
- squares->Update();
+ SetDepth(mDepth);
+ // double position[3] = {0, 0, 0};
+ // DD(mDepth);
+ // position[orientation] = -mDepth;
+ // actor->SetPosition(position);
+ mapper->Update();
}
//------------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff