/*=========================================================================
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
#include <vtkProperty.h>
//------------------------------------------------------------------------------
-vvImageContour::vvImageContour() {
+vvImageContour::vvImageContour()
+{
mTSlice = -1;
mSlice = 0;
mHiddenImageIsUsed = false;
//------------------------------------------------------------------------------
-vvImageContour::~vvImageContour() {
+vvImageContour::~vvImageContour()
+{
for (unsigned int i = 0; i < mSlicer->GetImage()->GetVTKImages().size(); i++) {
mSlicer->GetRenderer()->RemoveActor(mSquaresActorList[i]);
}
//------------------------------------------------------------------------------
-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);
+ CreateNewActor(&mSquaresActor, &mSquares, &mClipper, numImage);
mSquaresActorList.push_back(mSquaresActor);
mSquaresList.push_back(mSquares);
mClipperList.push_back(mClipper);
//------------------------------------------------------------------------------
-void vvImageContour::setImage(vvImage::Pointer image) {
+void vvImageContour::SetImage(vvImage::Pointer image) {
for (unsigned int numImage = 0; numImage < image->GetVTKImages().size(); numImage++) {
mClipperList[numImage]->SetInput(image->GetVTKImages()[numImage]);
}
//------------------------------------------------------------------------------
-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;
if (!b) {
- hideActors();
- initializeCacheMode();
+ HideActors();
+ InitializeCacheMode();
}
else {
for(unsigned int d=0; d<mListOfCachedContourActors.size(); d++)
mListOfCachedContourActors[d].clear();
mListOfCachedContourActors.clear();
- showActors();
+ ShowActors();
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-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);
}
//------------------------------------------------------------------------------
-void vvImageContour::SetLineWidth(double w) {
+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();
// for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
mSquaresActorList[mTSlice]->VisibilityOn();
- update(mValue);
+ Update(mValue);
//}
}
//------------------------------------------------------------------------------
-
+
//------------------------------------------------------------------------------
-void vvImageContour::update(double value) {
+void vvImageContour::Update(double value) {
// DD(value);
if (!mSlicer) return;
if (mPreviousValue == value) {
if (mPreviousSlice == mSlicer->GetSlice()) {
if (mPreviousTSlice == mSlicer->GetTSlice()) {
- // DD("vvImageContour::update nothing");
+ // DD("vvImageContour::update nothing");
return; // Nothing to do
}
}
mSlice = mSlicer->GetSlice();
// DD(mDisplayModeIsPreserveMemory);
if (mDisplayModeIsPreserveMemory) {
- updateWithPreserveMemoryMode();
+ UpdateWithPreserveMemoryMode();
}
else {
- updateWithFastCacheMode();
+ UpdateWithFastCacheMode();
}
-
- mSlicer->Render(); //DS ---> REMOVE ??
-
+ // mSlicer->Render(); //DS ---> REMOVE ??
mPreviousTSlice = mSlicer->GetTSlice();
mPreviousSlice = mSlicer->GetSlice();
//------------------------------------------------------------------------------
-void vvImageContour::updateWithPreserveMemoryMode() {
+void vvImageContour::UpdateWithPreserveMemoryMode() {
// Only change actor visibility if tslice change
//DD(mTSlice);
//DD(mSlice);
vtkMarchingSquares * mSquares = mSquaresList[mTSlice];
vtkImageClip * mClipper = mClipperList[mTSlice];
vtkActor * mSquaresActor = mSquaresActorList[mTSlice];
- int orientation = computeCurrentOrientation();
+ int orientation = ComputeCurrentOrientation();
// DD(orientation);
//DD(mValue);
//DD(mSlice);
//DD(mPreviousTslice);
- updateActor(mSquaresActor, mSquares, mClipper, mValue, orientation, mSlice);
+ UpdateActor(mSquaresActor, mSquares, mClipper, mValue, orientation, mSlice);
mSquaresActorList[mTSlice]->VisibilityOn();
if (mPreviousTslice != mTSlice) {
if (mPreviousTslice != -1) mSquaresActorList[mPreviousTslice]->VisibilityOff();
//------------------------------------------------------------------------------
-void vvImageContour::initializeCacheMode() {
+void vvImageContour::InitializeCacheMode() {
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();
-
+
// Compute orientation
int orientation;
- for (orientation = 0; orientation < 6;orientation = orientation+2) {
+ for (orientation = 0; orientation < 6; orientation = orientation+2) {
if (extent[orientation] == extent[orientation+1]) {
break;
}
//------------------------------------------------------------------------------
-void vvImageContour::updateWithFastCacheMode() {
+void vvImageContour::UpdateWithFastCacheMode() {
// Compute orientation
- int orientation = computeCurrentOrientation();
+ int orientation = ComputeCurrentOrientation();
if ((mPreviousSlice == mSlice) && (mPreviousOrientation == orientation)) return;
vtkActor * actor = mListOfCachedContourActors[orientation][mSlice];
if (actor != NULL) {
mListOfCachedContourActors[orientation][mSlice]->VisibilityOn();
- }
- else {
+ } else {
vtkImageClip * mClipper;
vtkMarchingSquares * mSquares;
vtkActor * mSquaresActor;
- createNewActor(&mSquaresActor, &mSquares, &mClipper, 0);
- updateActor(mSquaresActor, mSquares, mClipper, mValue, orientation, mSlice);
+ CreateNewActor(&mSquaresActor, &mSquares, &mClipper, 0);
+ UpdateActor(mSquaresActor, mSquares, mClipper, mValue, orientation, mSlice);
mListOfCachedContourActors[orientation][mSlice] = mSquaresActor;
mSquaresActor->VisibilityOn();
}
//------------------------------------------------------------------------------
-void vvImageContour::createNewActor(vtkActor ** actor,
- vtkMarchingSquares ** squares,
- vtkImageClip ** clipper,
+void vvImageContour::CreateNewActor(vtkActor ** actor,
+ vtkMarchingSquares ** squares,
+ vtkImageClip ** clipper,
int numImage) {
vtkActor * mSquaresActor = (*actor = vtkActor::New());
vtkImageClip * mClipper = (*clipper = vtkImageClip::New());
vtkMarchingSquares * mSquares = (*squares = vtkMarchingSquares::New());
vtkPolyDataMapper * mSquaresMapper = vtkPolyDataMapper::New();
-
- if (mHiddenImageIsUsed)
+
+ if (mHiddenImageIsUsed)
mClipper->SetInput(mHiddenImage->GetVTKImages()[0]);
- else
+ else
mClipper->SetInput(mSlicer->GetImage()->GetVTKImages()[numImage]);
mSquares->SetInput(mClipper->GetOutput());
mSquaresMapper->SetInput(mSquares->GetOutput());
mSquaresActor->GetProperty()->SetColor(1.0,0,0);
mSquaresActor->SetPickable(0);
mSquaresActor->VisibilityOff();
- mSlicer->GetRenderer()->AddActor(mSquaresActor);
+ mSlicer->GetRenderer()->AddActor(mSquaresActor);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvImageContour::updateActor(vtkActor * actor,
- vtkMarchingSquares * squares,
- vtkImageClip * clipper,
- double threshold, int orientation, int slice) {
-
+void vvImageContour::UpdateActor(vtkActor * actor,
+ vtkMarchingSquares * squares,
+ vtkImageClip * clipper,
+ double threshold, int orientation, int slice) {
// Set parameter for the MarchigSquare
squares->SetValue(0, threshold);
int * extent3;
extent3 = mHiddenImage->GetFirstVTKImageData()->GetExtent();
for(int i=0; i<6; i++) extent2[i] = extent3[i];
-
+
double s = (double)extent[orientation*2]*(double)mSlicer->GetImage()->GetSpacing()[orientation]; // in mm
s = s+mSlicer->GetImage()->GetOrigin()[orientation]; // from origin
s = s-mHiddenImage->GetFirstVTKImageData()->GetOrigin()[orientation]; // from corner second image
s = s/mHiddenImage->GetFirstVTKImageData()->GetSpacing()[orientation]; // in voxel
-
- if (s == floor(s)) {
+
+ if (s == floor(s)) {
extent2[orientation*2] = extent2[orientation*2+1] = (int)floor(s);
- }
- else {
+ } else {
extent2[orientation*2] = (int)floor(s);
extent2[orientation*2+1] = extent2[orientation*2];
}
- }
- else {
+ } else {
extent2 = extent;
}
clipper->SetOutputWholeExtent(extent2[0],extent2[1],extent2[2],
// Move the actor to be visible
// DD(orientation);
-// DD(slice);
+ // DD(slice);
//TO SIMPLiFY :!!!!!!!!! == ???????
// actor->SetPosition(-1,-1,-1);
-
+
switch (orientation) {
- case 0:
+ case 0:
// DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0]);
if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice) {
actor->SetPosition(1,0,0);
- }
- else {
+ } else {
actor->SetPosition(-1,0,0);
}
break;
- case 1:
+ case 1:
// DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1]);
if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice) {
actor->SetPosition(0,1,0);
- }
- else {
+ } else {
actor->SetPosition(0,-1,0);
}
break;
- case 2:
+ case 2:
// DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2]);
if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice) {
// DD("1");
actor->SetPosition(0,0,1);
- }
- else {
+ } else {
// DD("-1");
actor->SetPosition(0,0,-1);
}