#include "vvSlicerManagerCommand.h"
#include "vvInteractorStyleNavigator.h"
#include "vvLandmarks.h"
-#include "vvImageReader.h"
-#include "vvImageReader.h"
#include "vvMesh.h"
#include "vvImageMapToWLColors.h"
#include "vvBlendImageActor.h"
mFusionName = "";
mVFId = "";
mLastError = "";
- mType = UNDEFINEDIMAGETYPE;
+ mType = vvImageReader::UNDEFINEDIMAGETYPE;
mColorMap = 0;
mPreset = 0;
mOverlayColor = 130;
mFusionWindow = 1000;
mFusionLevel = 1000;
- mReader = NULL;
- mImage = NULL;
- mVF=NULL;
- mVectorReader = NULL;
- mOverlayReader = NULL;
- mFusionReader = NULL;
mLandmarks = NULL;
mLinkedId.resize(0);
- for ( int i = 0; i < numberOfSlicers; i++) {
- vvSlicer *slicer = vvSlicer::New();
- mSlicers.push_back(slicer);
- }
+ for ( int i = 0; i < numberOfSlicers; i++)
+ mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
+
mPreviousSlice.resize(numberOfSlicers);
mPreviousTSlice.resize(numberOfSlicers);
}
//----------------------------------------------------------------------------
vvSlicerManager::~vvSlicerManager()
{
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- if (mSlicers[i] != NULL)
- mSlicers[i]->Delete();
- }
- if (mReader) {
- delete mReader;
- }
- if (mVectorReader) {
- delete mVectorReader;
- }
- if (mOverlayReader) {
- delete mOverlayReader;
- }
- if (mFusionReader) {
- delete mFusionReader;
- }
if (mLandmarks)
delete mLandmarks;
}
mFileName = filename;
mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
- // DD(mBaseFileName);
mBaseFileNameNumber = number;
- for(unsigned int i=0; i<mSlicers.size(); i++) {
- mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
- }
-
+ mFileName = mBaseFileName;
if (number != 0) {
mFileName.append("_"+clitk::toString(number));
}
+ mFileName.append(vtksys::SystemTools::GetFilenameLastExtension(filename));
+
+ for(unsigned int i=0; i<mSlicers.size(); i++) {
+ mSlicers[i]->SetFileName(mFileName);//vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
+ }
+
}
//------------------------------------------------------------------------------
//----------------------------------------------------------------------------
-bool vvSlicerManager::SetImage(std::string filename, LoadedImageType type, int n, unsigned int slice)
+bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)
{
mType = type;
- if (mReader == NULL)
- mReader = new vvImageReader;
+ if (mReader.IsNull())
+ mReader = vvImageReader::New();
std::vector<std::string> filenames;
filenames.push_back(filename);
mReader->SetInputFilenames(filenames);
SetFilename(filename, n);
// mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
//mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
- // DD(mBaseFileName);
//mBaseFileNameNumber = n;
if (mReader->GetLastError().size() == 0) {
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
mSlicers[i]->SetImage(mReader->GetOutput());
- // DD(mSlicers[i]->GetFileName());
}
} else {
mLastError = mReader->GetLastError();
return false;
}
// if (n!=0) {
- // // DD(mFileName);
// mFileName.append("_"+clitk::toString(n));
// }
return true;
//----------------------------------------------------------------------------
-bool vvSlicerManager::SetImages(std::vector<std::string> filenames,LoadedImageType type, int n)
+bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)
{
mType = type;
std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
- if (type == DICOM)
+ if (type == vvImageReader::DICOM)
fileWithoutExtension += "_dicom";
- else if (type == MERGED)
+ else if (type == vvImageReader::MERGED)
fileWithoutExtension += "_merged";
- else if (type == MERGEDWITHTIME)
+ else if (type == vvImageReader::MERGEDWITHTIME)
fileWithoutExtension += "_merged_wt";
mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);
- if (mReader == NULL)
- mReader = new vvImageReader;
+ if (mReader.IsNull())
+ mReader = vvImageReader::New();
mReader->SetInputFilenames(filenames);
mReader->Update(type);
mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
- // DD(mBaseFileName);
mBaseFileNameNumber = n;
if (mReader->GetLastError().size() == 0) {
return false;
}
if (n!=0) {
- // DD(mFileName);
mFileName.append("_"+clitk::toString(n));
- // DD(mFileName);
}
return true;
}
mLastError = " Overlay dimension cannot be greater then reference image!";
return false;
}
- if (mOverlayReader == NULL)
- mOverlayReader = new vvImageReader;
+ if (mOverlayReader.IsNull())
+ mOverlayReader = vvImageReader::New();
std::vector<std::string> filenames;
filenames.push_back(filename);
mOverlayReader->SetInputFilenames(filenames);
mLastError = " Overlay dimension cannot be greater then reference image!";
return false;
}
- if (mFusionReader == NULL)
- mFusionReader = new vvImageReader;
+ if (mFusionReader.IsNull())
+ mFusionReader = vvImageReader::New();
std::vector<std::string> filenames;
filenames.push_back(filename);
mFusionReader->SetInputFilenames(filenames);
//----------------------------------------------------------------------------
bool vvSlicerManager::SetVF(std::string filename)
{
- if (mVectorReader == NULL)
- mVectorReader = new vvImageReader;
+ if (mVectorReader.IsNull())
+ mVectorReader = vvImageReader::New();
mVectorReader->SetInputFilename(filename);
- mVectorReader->Update(VECTORFIELD);
+ mVectorReader->Update(vvImageReader::VECTORFIELD);
if (mVectorReader->GetLastError().size() != 0) {
mLastError = mVectorReader->GetLastError();
return false;
return false;
}
if (vf->GetNumberOfDimensions() == 4) {
- // DD(vf->GetSpacing()[3]);
- // DD(mImage->GetSpacing()[3]);
- // DD(vf->GetOrigin()[3]);
- // DD(mImage->GetOrigin()[3]);
if (vf->GetSpacing()[3] != mImage->GetSpacing()[3]) {
mLastError = "Sorry, vector field time spacing cannot be different from time spacing of the reference image.";
return false;
t++;
if (t > mSlicers[0]->GetTMax())
t = 0;
- // DD("SetNextTSlice");
- // DD(originating_slicer);
- // DD(t);
emit UpdateTSlice(originating_slicer,t);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-void vvSlicerManager::SetCursorVisibility(int s)
+void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)
{
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetCursorVisibility(s);
+ mSlicers[i]->SetCornerAnnotationVisibility(s);
}
}
//----------------------------------------------------------------------------
-
//----------------------------------------------------------------------------
void vvSlicerManager::SetOpacity(int i, double factor)
{
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateViews(int current,int slicer)
{
- // DD("UpdateViews");
- // DD(current);
- // DD(slicer);
-
double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
/mSlicers[slicer]->GetInput()->GetSpacing()[0];
double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
switch (mSlicers[slicer]->GetSliceOrientation()) {
case vtkImageViewer2::SLICE_ORIENTATION_XY:
- if (mSlicers[slicer]->GetSlice() == (int)floor(z))
- mSlicers[slicer]->Render();
- else
+ if (mSlicers[slicer]->GetSlice() != (int)floor(z))
mSlicers[slicer]->SetSlice((int)floor(z));
break;
case vtkImageViewer2::SLICE_ORIENTATION_XZ:
- if (mSlicers[slicer]->GetSlice() == (int)floor(y))
- mSlicers[slicer]->Render();
- else
+ if (mSlicers[slicer]->GetSlice() != (int)floor(y))
mSlicers[slicer]->SetSlice((int)floor(y));
break;
case vtkImageViewer2::SLICE_ORIENTATION_YZ:
- if (mSlicers[slicer]->GetSlice() == (int)floor(x))
- mSlicers[slicer]->Render();
- else
+ if (mSlicers[slicer]->GetSlice() != (int)floor(x))
mSlicers[slicer]->SetSlice((int)floor(x));
break;
}
+ mSlicers[slicer]->Render();
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
if (i != (unsigned int)slicer && mSlicers[i]->GetImageActor()->GetVisibility()
}
switch (mSlicers[i]->GetSliceOrientation()) {
case vtkImageViewer2::SLICE_ORIENTATION_XY:
- if (mSlicers[i]->GetSlice() == (int)floor(z))
- mSlicers[i]->Render();
- else
+ if (mSlicers[i]->GetSlice() != (int)floor(z))
mSlicers[i]->SetSlice((int)floor(z));
break;
case vtkImageViewer2::SLICE_ORIENTATION_XZ:
- if (mSlicers[i]->GetSlice() == (int)floor(y))
- mSlicers[i]->Render();
- else
+ if (mSlicers[i]->GetSlice() != (int)floor(y))
mSlicers[i]->SetSlice((int)floor(y));
break;
case vtkImageViewer2::SLICE_ORIENTATION_YZ:
- if (mSlicers[i]->GetSlice() == (int)floor(x))
- mSlicers[i]->Render();
- else
+ if (mSlicers[i]->GetSlice() != (int)floor(x))
mSlicers[i]->SetSlice((int)floor(x));
break;
}
- // DD("UpdateViews::");
- // DD(i);
+
+ mSlicers[i]->Render();
+
UpdateSlice(i);
UpdateTSlice(i);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *slicer, bool bPropagate)
+void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
{
+ vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
+ double refPosition[3], refFocal[3];
+ refCam->GetPosition(refPosition);
+ refCam->GetFocalPoint(refFocal);
+
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- vtkCamera *camera = mSlicers[i] ->GetRenderer()->GetActiveCamera();
- vtkCamera *refCam = slicer->GetRenderer()->GetActiveCamera();
+ vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
camera->SetParallelScale(refCam->GetParallelScale());
double position[3], focal[3];
camera->GetPosition(position);
camera->GetFocalPoint(focal);
- double refPosition[3], refFocal[3];
- refCam->GetPosition(refPosition);
- refCam->GetFocalPoint(refFocal);
-
- if(slicer->GetSliceOrientation()==mSlicers[i]->GetSliceOrientation()) {
+ if(refSlicer->GetSliceOrientation()==mSlicers[i]->GetSliceOrientation()) {
for(int i=0; i<3; i++) {
position[i] = refPosition[i];
focal[i] = refFocal[i];
}
}
- if(slicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
+ if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
position[0] = refPosition[0];
focal[0] = refFocal[0];
}
}
- if(slicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
+ if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
position[2] = refPosition[2];
focal[2] = refFocal[2];
}
}
- if(slicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
+ if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
position[1] = refPosition[1];
focal[1] = refFocal[1];
camera->SetFocalPoint(focal);
camera->SetPosition(position);
-
- if(bPropagate)
- for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
- emit UpdateLinkedNavigation(*i, this);
+
+ //Fix for bug #243
+ mSlicers[i]->ForceUpdateDisplayExtent();
}
+
Render();
+ if(bPropagate)
+ for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
+ emit UpdateLinkedNavigation(*i, this, refSlicer);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::Render()
{
- // DD("vvSlicerManager::Render");
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- // DD(i);
mSlicers[i]->Render();
}
}
//----------------------------------------------------------------------------
void vvSlicerManager::ReloadVF()
{
- mVectorReader->Update(VECTORFIELD); //deletes the old images through the VF::Init() function
+ mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function
mVF=mVectorReader->GetOutput();
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetVF(mVF);
//----------------------------------------------------------------------------
void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
{
- for (unsigned int i = 0; i < mSlicers.size(); i++) {
+ if (actor_type =="overlay")
+ mOverlayReader = NULL;
+
+ if (actor_type =="fusion")
+ mFusionReader = NULL;
+
+ for (unsigned int i = 0; i < mSlicers.size(); i++)
mSlicers[i]->RemoveActor(actor_type,overlay_index);
- }
+
if (actor_type=="vector") {
mVF=NULL;
- if (mVectorReader) {
- delete mVectorReader;
- mVectorReader=NULL;
- }
+ mVectorReader=NULL;
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::RemoveActors()
{
- ///This method leaks a few objects. See RemoveActor for what a correct implementation would look like
+ ///This method leaks a few objects. See RemoveActor for what a
+ ///correct implementation would look like
+ //DS -> probably due to the reader (now released in the
+ //RemoveActor() function. (I hope)
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetDisplayMode(0);
mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
- value = mSlicers[slicer]->GetInput()->GetScalarComponentAsDouble(
- (int)floor(X),
- (int)floor(Y),
- (int)floor(Z),0);
+ value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
+
if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility()) {
displayVec = 1;
unsigned int currentTime = mSlicers[slicer]->GetTSlice();
double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
- xVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),0);
- yVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),1);
- zVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),2);
+ xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);
+ yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);
+ zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);
valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
}
}
Yover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[3] &&
Zover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[4] &&
Zover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[5]) {
- valueOver = static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput())->
- GetScalarComponentAsDouble(
- (int)floor(Xover),
- (int)floor(Yover),
- (int)floor(Zover),0);
+ valueOver = this->GetScalarComponentAsDouble(static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput()), Xover, Yover, Zover);
}
}
if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility()) {
Yfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[3] &&
Zfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[4] &&
Zfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[5]) {
- valueFus = static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput())->
- GetScalarComponentAsDouble(
- (int)floor(Xfus),
- (int)floor(Yfus),
- (int)floor(Zfus),0);
+ valueFus = this->GetScalarComponentAsDouble(static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput()), Xfus, Yfus, Zfus);
}
}
emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+void vvSlicerManager::Picked()
+{
+ emit currentPickedImageChanged(mId);
+}
+//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateWindowLevel()
{
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateSlice(int slicer)
{
- // DD("vvSlicerManager::UpdateSlice emit UpdateSlice");
- // DD(slicer);
- // DD(mSlicers[slicer]->GetSlice());
if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
//DD("============= NOTHING");
return;
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateTSlice(int slicer)
{
- // DD("vvSlicerManager::UpdateTSlice emit UpdateTSlice");
- // DD(slicer);
- // DD(mSlicers[slicer]->GetTSlice());
- // DD(mSlicers[slicer]->GetSlice());
if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
if (mPreviousTSlice[slicer] == mSlicers[slicer]->GetTSlice()) {
// DD("************** NOTHING ***********");
level = 0;
break;
case 2:
- window = 350;
- level = 60;
+ window = 400;
+ level = 20;
break;
case 3:
window = 1500;
y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3] &&
z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4] &&
z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]) {
- double value = mSlicers[0]->GetInput()->GetScalarComponentAsDouble(
- (int)x_index,
- (int)y_index,
- (int)z_index,0);
+ double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);
this->GetLandmarks()->AddLandmark(x,y,z,t,value);
emit LandmarkAdded();
}
}
//----------------------------------------------------------------------------
-
//----------------------------------------------------------------------------
void vvSlicerManager::NextImage(int slicer)
{
}
//----------------------------------------------------------------------------
-
//----------------------------------------------------------------------------
void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
{
}
//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)
+{
+ int ix, iy, iz;
+ return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);
+}
+//----------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff