#include "vvInteractorStyleNavigator.h"
#include "vvLandmarks.h"
#include "vvMesh.h"
-#include "vvImageMapToWLColors.h"
#include "vvBlendImageActor.h"
+#include <vtkVersion.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkInformation.h>
#include <vtkImageActor.h>
#include <vtkImageData.h>
#include <vtkRenderWindow.h>
#include <vtkCamera.h>
#include <qfileinfo.h>
-
+#include <QMessageBox>
//----------------------------------------------------------------------------
vvSlicerManager::vvSlicerManager(int numberOfSlicers)
-{
+{
+
+ connect(this, SIGNAL(callAddLandmark(float,float,float,float)), this, SLOT(AddLandmark(float,float,float,float)));
+
mFileName = "";
mId = "";
mVFName = "";
mFusionLevel = 1000;
mFusionShowLegend = true;
+ mFusionSequenceInvolvementCode = -1;
+ mFusionSequenceIndexLinkedManager = -1;
+ mFusionSequenceFrameIndex = -1;
+ mFusionSequenceNbFrames = 0;
+ mFusionSequenceSpatialSyncFlag = false;
+ mFusionSequenceTemporalSyncFlag = false;
+
mLandmarks = NULL;
mLinkedId.resize(0);
- for ( int i = 0; i < numberOfSlicers; i++)
+ for ( int i = 0; i < numberOfSlicers; i++) {
mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
+ mSlicers[i]->SetSlicerNumber(i);
+ }
mSelectedSlicer = -1;
- mPreviousSlice.resize(numberOfSlicers);
- mPreviousTSlice.resize(numberOfSlicers);
+ mPreviousSlice.resize(numberOfSlicers, 0);
+ mPreviousTSlice.resize(numberOfSlicers, 0);
mSlicingPreset = WORLD_SLICING;
+
+
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
vvSlicerManager::~vvSlicerManager()
-{
+{
if (mLandmarks)
delete mLandmarks;
}
//------------------------------------------------------------------------------
void vvSlicerManager::SetFilename(std::string filename, int number)
-{
+{
mFileName = filename;
mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
//----------------------------------------------------------------------------
void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
-{
+{
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->AddContour(contour,propagate);
}
//----------------------------------------------------------------------------
void vvSlicerManager::ToggleContourSuperposition()
-{
+{
for ( unsigned int i = 0; i < mSlicers.size(); i++)
mSlicers[i]->ToggleContourSuperposition();
}
//----------------------------------------------------------------------------
std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::string &actorType)
-{
+{
vvImageReader *reader = NULL;
if(actorType=="image")
reader = mFusionReader;
else if(actorType=="vector")
reader = mVectorReader;
+ else if(actorType=="fusionSequence")
+ reader = mFusionSequenceReader;
if(!reader)
return "";
//----------------------------------------------------------------------------
bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)
-{
+{
mType = type;
if (mReader.IsNull())
mReader = vvImageReader::New();
//----------------------------------------------------------------------------
void vvSlicerManager::SetImage(vvImage::Pointer image)
-{
+{
mImage=image;
for (unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetImage(image);
//----------------------------------------------------------------------------
-bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)
-{
+bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n, bool patientCoordinateSystem)
+{
mType = type;
std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
if (type == vvImageReader::DICOM)
if (mReader.IsNull())
mReader = vvImageReader::New();
mReader->SetInputFilenames(filenames);
+ if (type == vvImageReader::DICOM)
+ mReader->SetPatientCoordinateSystem(patientCoordinateSystem);
mReader->Update(type);
mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
//----------------------------------------------------------------------------
bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
-{
+{
mOverlayName = filenames[0];
mOverlayComponent = component;
if (dim > mImage->GetNumberOfDimensions()) {
//----------------------------------------------------------------------------
-bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string component)
-{
- mFusionName = filename;
+bool vvSlicerManager::SetFusion(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
+{
+ mFusionName = filenames[0];
mFusionComponent = component;
if (dim > mImage->GetNumberOfDimensions()) {
- mLastError = " Overlay dimension cannot be greater then reference image!";
+ mLastError = " Fusion dimension cannot be greater than reference image!";
return false;
}
if (mFusionReader.IsNull())
mFusionReader = vvImageReader::New();
- std::vector<std::string> filenames;
- filenames.push_back(filename);
mFusionReader->SetInputFilenames(filenames);
- mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
+ mFusionReader->Update(type);
if (mFusionReader->GetLastError().size() == 0) {
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetFusion(mFusionReader->GetOutput());
}
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+//this function is called by vvMainWindow::AddFusionSequence for the primary sequence (CT), while the given files constitute the secondary sequence.
+bool vvSlicerManager::SetFusionSequence(std::vector<std::string> filenames, int dim, std::string component, vvImageReader::LoadedImageType type)
+{
+ mFusionSequenceInvolvementCode = 0;
+
+ mFusionName = filenames[0];
+ mFusionComponent = component;
+
+ if (dim > mImage->GetNumberOfDimensions()) {
+ mLastError = " Fusion Sequence dimension cannot be greater than reference image!";
+ return false;
+ }
+
+ if (mFusionSequenceReader.IsNull())
+ mFusionSequenceReader = vvImageReader::New();
+
+ mFusionSequenceReader->SetInputFilenames(filenames);
+ mFusionSequenceReader->Update(type);
+
+
+ if (mFusionSequenceReader->GetLastError().size() == 0) {
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+ mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput(), mFusionSequenceInvolvementCode);
+ }
+ } else {
+ mLastError = mFusionSequenceReader->GetLastError();
+ return false;
+ }
+ double *fusRange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
+ mFusionLevel = (fusRange[0]+fusRange[1])/2;
+ mFusionWindow = fusRange[1]-fusRange[0];
+
+ //store the initial transform matrices of each frame, and reset them to identity
+ mFusionSequenceListInitialTransformMatrices.clear();
+ for (unsigned i=0 ; i<mFusionSequenceReader->GetOutput()->GetTransform().size() ; i++) {
+ AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );
+ mFusionSequenceReader->GetOutput()->GetTransform()[i]->Identity();
+ mFusionSequenceReader->GetOutput()->GetTransform()[i]->Update();
+ }
+
+ //adjust the time slider in the overlay panel
+ mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size();
+ mFusionSequenceFrameIndex = std::max<int>( 0, std::min<int>(mFusionSequenceFrameIndex, mFusionSequenceNbFrames));
+
+ return true;
+}
+//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
bool vvSlicerManager::SetVF(std::string filename)
-{
+{
if (mVectorReader.IsNull())
mVectorReader = vvImageReader::New();
mVectorReader->SetInputFilename(filename);
//----------------------------------------------------------------------------
bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
-{
+{
if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) {
mLastError = "Sorry, vector field dimension cannot be greater then reference image.";
return false;
//----------------------------------------------------------------------------
vvSlicer* vvSlicerManager::GetSlicer(int i)
-{
+{
return mSlicers[i];
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateSlicer(int num, bool state)
-{
- if (mSlicers[num]->GetImage())
+{
+ if (mSlicers[num]->GetImage()) {
mSlicers[num]->SetDisplayMode(state);
+ }
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)
-{
+{
mSlicers[i]->SetRenderWindow(i,RW);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)
-{
+{
vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();
smc->SM = this;
smc->SetSlicerNumber(i);
//----------------------------------------------------------------------------
void vvSlicerManager::LeftButtonReleaseEvent(int slicer)
-{
+{
emit LeftButtonReleaseSignal(slicer);
}
//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+void vvSlicerManager::EmitMousePositionUpdated(int slicer)
+{
+ emit MousePositionUpdatedSignal(slicer);
+}
+//----------------------------------------------------------------------------
+
+
+//----------------------------------------------------------------------------
+void vvSlicerManager::EmitKeyPressed(std::string KeyPress)
+{
+ emit KeyPressedSignal(KeyPress);
+}
+//----------------------------------------------------------------------------
+
+
//----------------------------------------------------------------------------
void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)
-{
+{
mSlicers[slicer]->SetSliceOrientation(orientation);
emit UpdateOrientation(slicer, orientation);
}
//----------------------------------------------------------------------------
int vvSlicerManager::GetTSlice()
-{
+{
return mSlicers[0]->GetTSlice();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-void vvSlicerManager::SetTSlice(int slice)
-{
+void vvSlicerManager::SetTSlice(int slice, bool updateLinkedImages)
+{
+ if (!updateLinkedImages) { //for fusionSequence, TMax / MaxCurrentTSlice are irrelevant.
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+ mSlicers[i]->SetTSlice(slice, updateLinkedImages);
+ UpdateTSlice(i);
+ }
+ return;
+ }
+
if (slice < 0)
slice = 0;
else if (slice > mSlicers[0]->GetTMax())
mLandmarks->SetTime(slice);
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
if (slice != mSlicers[i]->GetMaxCurrentTSlice()) {
- mSlicers[i]->SetTSlice(slice);
+ mSlicers[i]->SetTSlice(slice, updateLinkedImages);
UpdateTSlice(i);
}
}
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+void vvSlicerManager::SetFusionSequenceTSlice(int slice)
+{
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+ mSlicers[i]->SetFusionSequenceTSlice(slice);
+ UpdateTSlice(i);
+ }
+}
+//----------------------------------------------------------------------------
+
+
//----------------------------------------------------------------------------
void vvSlicerManager::SetNextTSlice(int originating_slicer)
-{
+{
int t = mSlicers[0]->GetMaxCurrentTSlice();
t++;
if (t > mSlicers[0]->GetTMax())
t = 0;
- //std::cout << "vvSlicerManager::SetNextTSlice" << std::endl;
- emit UpdateTSlice(originating_slicer,t);
+ emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
-{
+{
int t = mSlicers[0]->GetMaxCurrentTSlice();
t--;
if (t < 0)
t = mSlicers[0]->GetTMax();
- //std::cout << "vvSlicerManager::SetPreviousTSlice" << std::endl;
- emit UpdateTSlice(originating_slicer,t);
+ emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::ToggleInterpolation()
-{
+{
bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+ mSlicers[i]->SetInterpolationImageReslice(interpolate);
mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
if (mSlicers[i]->GetOverlayActor())
mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate);
//----------------------------------------------------------------------------
void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
-{
+{
if (tslice < 0)
tslice = 0;
else if (tslice > mSlicers[slicer]->GetTMax())
//----------------------------------------------------------------------------
void vvSlicerManager::SetColorWindow(double s)
-{
+{
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetColorWindow(s);
}
//----------------------------------------------------------------------------
void vvSlicerManager::SetColorLevel(double s)
-{
+{
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetColorLevel(s);
}
//----------------------------------------------------------------------------
void vvSlicerManager::SetOverlayColorWindow(double s)
-{
+{
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetOverlayColorWindow(s);
}
//----------------------------------------------------------------------------
void vvSlicerManager::SetOverlayColorLevel(double s)
-{
+{
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetOverlayColorLevel(s);
}
//----------------------------------------------------------------------------
void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)
-{
+{
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetLinkOverlayWindowLevel(b);
}
//----------------------------------------------------------------------------
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)
-{
+{
mSlicers[i]->SetOpacity(1/factor);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateViews(int current,int slicer)
-{
+{
double p[3], pt[3];
p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
/mSlicers[slicer]->GetInput()->GetSpacing()[1];
double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
/mSlicers[slicer]->GetInput()->GetSpacing()[2];
-
+#if VTK_MAJOR_VERSION <= 5
if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
- z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
+ z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5)
+#else
+int extentImageReslice[6];
+mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
+ if (x >= extentImageReslice[0]-0.5 &&
+ x <= extentImageReslice[1]+0.5 &&
+ y >= extentImageReslice[2]-0.5 &&
+ y <= extentImageReslice[3]+0.5 &&
+ z >= extentImageReslice[4]-0.5 &&
+ z <= extentImageReslice[5]+0.5)
+#endif
+ {
mSlicers[slicer]->UpdateCursorPosition();
- mSlicers[slicer]->SetCursorColor(10,212,255);
+ mSlicers[slicer]->SetCursorColor(1,0,0);
mSelectedSlicer = slicer;
switch (mSlicers[slicer]->GetSliceOrientation()) {
if (current) { //do not display corner annotation if image is the one picked
mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
-VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());
- mSlicers[i]->SetCursorColor(255,10,212);
+ mSlicers[i]->SetCursorColor(0,0.96,0.17);
} else {
- mSlicers[i]->SetCursorColor(150,10,282);
+ mSlicers[i]->SetCursorColor(0.41,0.96,1);
}
switch (mSlicers[i]->GetSliceOrientation()) {
case vtkImageViewer2::SLICE_ORIENTATION_XY:
- if (mSlicers[i]->GetSlice() != (int)floor(z))
- mSlicers[i]->SetSlice((int)floor(z));
+ if (mSlicers[i]->GetSlice() != (int)lrint(z))
+ mSlicers[i]->SetSlice((int)lrint(z));
break;
case vtkImageViewer2::SLICE_ORIENTATION_XZ:
- if (mSlicers[i]->GetSlice() != (int)floor(y))
- mSlicers[i]->SetSlice((int)floor(y));
+ if (mSlicers[i]->GetSlice() != (int)lrint(y))
+ mSlicers[i]->SetSlice((int)lrint(y));
break;
case vtkImageViewer2::SLICE_ORIENTATION_YZ:
- if (mSlicers[i]->GetSlice() != (int)floor(x))
- mSlicers[i]->SetSlice((int)floor(x));
+ if (mSlicers[i]->GetSlice() != (int)lrint(x))
+ mSlicers[i]->SetSlice((int)lrint(x));
break;
}
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateLinked(int slicer)
-{
+{
double p[3], pt[3];
p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) / mSlicers[slicer]->GetInput()->GetSpacing()[0];
double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) / mSlicers[slicer]->GetInput()->GetSpacing()[1];
double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) / mSlicers[slicer]->GetInput()->GetSpacing()[2];
-
+#if VTK_MAJOR_VERSION <= 5
if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
- z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
+ z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5)
+#else
+int extentImageReslice[6];
+mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
+ if (x >= extentImageReslice[0]-0.5 &&
+ x <= extentImageReslice[1]+0.5 &&
+ y >= extentImageReslice[2]-0.5 &&
+ y <= extentImageReslice[3]+0.5 &&
+ z >= extentImageReslice[4]-0.5 &&
+ z <= extentImageReslice[5]+0.5)
+#endif
+ {
for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
- emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
+ if (this->IsInvolvedInFusionSequence()) {
+ //this SlicerManager is involved in fusionSequence => do not synchronize the times
+ emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], -1);
+ }
+ else {
+ emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
+ }
}
}
}
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
-{
+{
vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
double refPosition[3];
//----------------------------------------------------------------------------
double vvSlicerManager::GetColorWindow() const
-{
+{
if (mSlicers.size())
return mSlicers[0]->GetColorWindow();
return -1;
//----------------------------------------------------------------------------
double vvSlicerManager::GetColorLevel() const
-{
+{
if (mSlicers.size())
return mSlicers[0]->GetColorLevel();
return -1;
//----------------------------------------------------------------------------
double vvSlicerManager::GetOverlayColorWindow() const
-{
+{
if (mSlicers.size())
return mSlicers[0]->GetOverlayColorWindow();
return -1;
//----------------------------------------------------------------------------
double vvSlicerManager::GetOverlayColorLevel() const
-{
+{
if (mSlicers.size())
return mSlicers[0]->GetOverlayColorLevel();
return -1;
//----------------------------------------------------------------------------
bool vvSlicerManager::GetLinkOverlayWindowLevel() const
-{
+{
if (mSlicers.size())
return mSlicers[0]->GetLinkOverlayWindowLevel();
return -1;
//------------------------------------------------------------------------------
void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)
-{
+{
if(actorType == "image")
for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
this->GetImage()->GetTransform()[i]->Identity();
else if(actorType == "fusion")
for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
+ else if(actorType == "fusionSequence") //TODO: Check what should really be done here
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
+ this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
else if(actorType == "vf")
for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
this->GetVF()->GetTransform()[i]->Identity();
//----------------------------------------------------------------------------
void vvSlicerManager::Render()
-{
+{
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->Render();
}
//----------------------------------------------------------------------------
void vvSlicerManager::GenerateDefaultLookupTable()
-{
+{
SetPreset(mPreset);
SetColorMap(mColorMap);
}
//----------------------------------------------------------------------------
void vvSlicerManager::Reload()
-{
+{
mReader->Update(mType);
mImage=mReader->GetOutput();
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetImage(mImage);
}
+
+ //if this image is the primary sequence of a fusion sequence, then the main transform matrix should be updated.
+ if (this->IsMainSequenceOfFusionSequence()) {
+ SetFusionSequenceMainTransformMatrix( mImage->GetTransform()[0]->GetMatrix() );
+ }
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::ReloadFusion()
-{
+{
mFusionReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),mType);
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
}
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+//the secondary sequence is being reloaded.
+void vvSlicerManager::ReloadFusionSequence()
+{
+ // this is to keep the slice thickness, which needs to be artificially increased for visualization
+ double sp_x, sp_y, sp_z;
+ this->GetImage()->GetVTKImages()[0]->GetSpacing(sp_x, sp_y, sp_z);
+
+ mFusionSequenceReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),vvImageReader::MERGEDWITHTIME);
+
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+ mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput(), 1);
+ mSlicers[i]->Render();
+ }
+
+ //Update the slider
+ mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size();
+ if (mFusionSequenceFrameIndex>=mFusionSequenceNbFrames) {
+ mFusionSequenceFrameIndex=0;
+ }
+
+ //Update the list of initial transforms
+ mFusionSequenceListInitialTransformMatrices.clear();
+ for (unsigned i=0 ; i<mFusionSequenceNbFrames ; i++) {
+ this->AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );
+ }
+
+ // also update the slice thickness
+ for (unsigned i=0 ; i<this->GetImage()->GetTransform().size() ; i++) {
+ sp_x = this->GetImage()->GetVTKImages()[i]->GetSpacing()[0];
+ sp_y = this->GetImage()->GetVTKImages()[i]->GetSpacing()[1];
+ this->GetImage()->GetVTKImages()[i]->SetSpacing( sp_x, sp_y, sp_z);
+ }
+
+}
+//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
void vvSlicerManager::ReloadOverlay()
-{
+{
mOverlayReader->Update(mImage->GetNumberOfDimensions(),mOverlayComponent.c_str(),mType);
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
//----------------------------------------------------------------------------
void vvSlicerManager::ReloadVF()
-{
+{
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++) {
//----------------------------------------------------------------------------
void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
-{
+{
if (actor_type =="overlay")
mOverlayReader = NULL;
if (actor_type =="fusion")
mFusionReader = NULL;
+ if (actor_type =="fusionSequence") {
+ mFusionSequenceReader = NULL;
+ }
+
for (unsigned int i = 0; i < mSlicers.size(); i++)
mSlicers[i]->RemoveActor(actor_type,overlay_index);
//----------------------------------------------------------------------------
void vvSlicerManager::RemoveActors()
-{
+{
///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
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
-{
+{
// int view = mSlicers[slicer]->GetSliceOrientation();
// int slice = mSlicers[slicer]->GetSlice();
- double x = mSlicers[slicer]->GetCursorPosition()[0];
- double y = mSlicers[slicer]->GetCursorPosition()[1];
- double z = mSlicers[slicer]->GetCursorPosition()[2];
- double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
- mSlicers[slicer]->GetInput()->GetSpacing()[0];
- double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
- mSlicers[slicer]->GetInput()->GetSpacing()[1];
- double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
- mSlicers[slicer]->GetInput()->GetSpacing()[2];
+ double x = mSlicers[slicer]->GetCurrentPosition()[0];
+ double y = mSlicers[slicer]->GetCurrentPosition()[1];
+ double z = mSlicers[slicer]->GetCurrentPosition()[2];
+ double xyz[3], xyzTransform[3];
+ xyz[0] = x;
+ xyz[1] = y;
+ xyz[2] = z;
+ mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(xyz, xyzTransform);
+ double X = (xyzTransform[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])/mSlicers[slicer]->GetInput()->GetSpacing()[0];
+ double Y = (xyzTransform[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])/mSlicers[slicer]->GetInput()->GetSpacing()[1];
+ double Z = (xyzTransform[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])/mSlicers[slicer]->GetInput()->GetSpacing()[2];
double value = -VTK_DOUBLE_MAX;
int displayVec = 0;
double xVec=0, yVec=0, zVec=0, valueVec=0;
int displayOver = 0;
int displayFus = 0;
double valueOver=0, valueFus=0;
- if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
- X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
- Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
- Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
- Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
- Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
+#if VTK_MAJOR_VERSION <= 5
+ if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] -0.5 &&
+ X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] +0.5 &&
+ Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] -0.5 &&
+ Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] +0.5 &&
+ Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] -0.5 &&
+ Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5] +0.5)
+#else
+int extentImageReslice[6];
+mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
+ if (X >= extentImageReslice[0] -0.5 &&
+ X <= extentImageReslice[1] +0.5 &&
+ Y >= extentImageReslice[2] -0.5 &&
+ Y <= extentImageReslice[3] +0.5 &&
+ Z >= extentImageReslice[4] -0.5 &&
+ Z <= extentImageReslice[5] +0.5)
+#endif
+ {
value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
if (mSlicers[slicer]->GetVFActor() ) {
double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];
valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);
}
- if (mSlicers[slicer]->GetFusionActor() ) {
- displayFus = 1;
- vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());
- double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];
- double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];
- double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];
- valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);
- }
+
+ if ( mSlicers[slicer]->GetFusionActor() ) {
+ displayFus = 1;
+ vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());
+ double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];
+ double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];
+ double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];
+ valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);
+ }
+ else if (this->IsInvolvedInFusionSequence()) {
+ //if the cursor moves over the 'independent' version of the secondary sequence
+ //do not update the panel, just keep it as it is.
+ displayFus = 1;
+ valueFus = std::numeric_limits<double>::quiet_NaN();
+ }
+
emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
x,y,z,X,Y,Z,value);
emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
//----------------------------------------------------------------------------
void vvSlicerManager::Activated()
-{
+{
emit currentImageChanged(mId);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::Picked()
-{
+{
emit currentPickedImageChanged(mId);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateWindowLevel()
-{
+{
emit WindowLevelChanged();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateSlice(int slicer)
-{
+{
if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
//DD("============= NOTHING");
return;
}
- //std::cout << "vvSlicerManager::UpdateSlice " << slicer << " " << mSlicers[slicer]->GetSlice() << std::endl;
emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...
mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateTSlice(int slicer)
-{
+{
int slice = mSlicers[slicer]->GetSlice();
+
int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();
+ //if (this->IsInvolvedInFusionSequence()) tslice = mSlicers[slicer]->GetTSlice(); //actually, this is handled by the Slicer
+
if (mPreviousSlice[slicer] == slice) {
if (mPreviousTSlice[slicer] == tslice) {
// DD("************** NOTHING ***********");
}
mPreviousSlice[slicer] = slice;
mPreviousTSlice[slicer] = tslice;
- //std::cout << "vvSlicerManager::UpdateTSlice " << slicer << " " << tslice << std::endl;
- emit UpdateTSlice(slicer, tslice);
+
+ emit UpdateTSlice(slicer, tslice, mFusionSequenceInvolvementCode);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateSliceRange(int slicer)
-{
+{
emit UpdateSliceRange(slicer,
mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
0,mSlicers[slicer]->GetTMax());
//----------------------------------------------------------------------------
void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)
-{
+{
if(mSlicingPreset==preset)
return;
return;
}
s->ForceUpdateDisplayExtent();
+#if VTK_MAJOR_VERSION <= 5
s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1]
+s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0);
+#else
+ int extentImageReslice[6];
+ s->GetRegisterExtent(extentImageReslice);
+ s->SetSlice((extentImageReslice[s->GetSliceOrientation()*2+1]
+ +extentImageReslice[s->GetSliceOrientation()*2])/2.0);
+#endif
s->ResetCamera();
s->Render();
}
//----------------------------------------------------------------------------
void vvSlicerManager::SetPreset(int preset)
-{
+{
+
//vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
double window = mSlicers[0]->GetColorWindow();
double level = mSlicers[0]->GetColorLevel();
std::string component_type=mImage->GetScalarTypeAsITKString();
switch (preset) {
- case 0:
+ case WL_AUTO:
double range[2];
mImage->GetScalarRange(range);
window = range[1] - range[0];
level = (range[1] + range[0])* 0.5;
break;
- case 1:
+ case WL_HOUNSFIELD:
window = 2000;
level = 0;
break;
- case 2:
+ case WL_SOFTTISSUE:
window = 400;
level = 20;
break;
- case 3: // lungs (same as FOCAL)
+ case WL_LUNGS: // lungs (same as FOCAL)
window = 1700;
level = -300;
break;
- case 4:
+ case WL_BONES:
window = 1000;
level = 500;
break;
- case 5:
+ case WL_HEAD:
+ window = 200;
+ level = 70;
+ break;
+ case WL_BINARY:
window = 1;
level = 0.5;
break;
- case 6:
+ case WL_USER:
break;
- case 7:
+ case WL_VENTILATION:
window=1.;
level=0.;
break;
//----------------------------------------------------------------------------
void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)
-{
+{
double min, max;
if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {
int t = mSlicers[slicer]->GetFusionTSlice();
this->mSlicers[slicer]->GetConcatenatedTransform());
this->SetColorWindow(max-min);
this->SetColorLevel(0.5*(min+max));
- this->SetPreset(6);
+ this->SetPreset(WL_USER);
}
- this->Render();
this->UpdateWindowLevel();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::SetColorMap(int colormap)
-{
+{
double range[2];
+
range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
LUT->Build();
}
vtkWindowLevelLookupTable* fusLUT = NULL;
+
+ //FUSION / FUSION SEQUENCE
if (mSlicers[0]->GetFusion()) { // && mFusionColorMap >= 0) {
fusLUT = vtkWindowLevelLookupTable::New();
double fusRange [2];
fusRange[0] = mFusionLevel - mFusionWindow/2;
fusRange[1] = mFusionLevel + mFusionWindow/2;
- double* frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
+
+ //check whether it is actually a fusionSequence or a fusion, before invoking mFusionReader...
+ double* frange;
+ if (this->IsInvolvedInFusionSequence())
+ frange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
+ else
+ frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
+
fusLUT->SetTableRange(frange);
fusLUT->SetValueRange(1,1);
fusLUT->SetSaturationRange(1,1);
fusLUT->SetValueRange(0,1);
fusLUT->SetSaturationRange(0,0);
}
-
+
fusLUT->ForceBuild();
double v[4];
-
// set color table transparency
//double alpha_range=(double)mFusionThresOpacity/10;
double range_end = fusRange[0] + (double)mFusionThresOpacity*(fusRange[1] - fusRange[0])/100;
}
}
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
-
+
if (mSlicers[i]->GetOverlay()) {
vtkLookupTable* supLUT = vtkLookupTable::New();
supLUT->SetTableRange(range[0],range[1]);
invLUT->SetSaturationRange(1,1);
invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
invLUT->Build();
- dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
- ->SetWindowLevelMode(true);
mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
invLUT->Delete();
supLUT->Delete();
} else if (mSlicers[i]->GetOverlay()) {
- //dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
- //->SetWindowLevelMode(false);
mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
} else {
mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
}
-
+
if (mSlicers[i]->GetFusion()) {
mSlicers[i]->ShowFusionLegend(mFusionShowLegend);
mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
//----------------------------------------------------------------------------
vvLandmarks* vvSlicerManager::GetLandmarks()
-{
+{
if (mLandmarks == NULL) {
mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
for (unsigned int i = 0; i < mSlicers.size(); i++)
return mLandmarks;
}
//----------------------------------------------------------------------------
-
+void vvSlicerManager::AddNewLandmark(float x,float y,float z,float t)
+{
+ emit callAddLandmark(x,y,z,t);
+}
//----------------------------------------------------------------------------
void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
-{
- double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
- double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
- double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
- if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&
- x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&
- y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&
- y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&
- z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&
- z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5) {
- double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);
+{
+ double x_index = (x - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[0])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[0];
+ double y_index = (y - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[1])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[1];
+ double z_index = (z - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[2])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[2];
+#if VTK_MAJOR_VERSION <= 5
+ if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[0]-0.5 &&
+ x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[1]+0.5 &&
+ y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[2]-0.5 &&
+ y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[3]+0.5 &&
+ z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[4]-0.5 &&
+ z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[5]+0.5)
+#else
+ if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 &&
+ x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 &&
+ y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2]-0.5 &&
+ y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 &&
+ z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 &&
+ z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5)
+#endif
+ {
+ double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetImage()->GetVTKImages()[mSlicers[mSelectedSlicer]->GetTSlice()], x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848
this->GetLandmarks()->AddLandmark(x,y,z,t,value);
emit LandmarkAdded();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-void vvSlicerManager::PrevImage(int slicer)
+void vvSlicerManager::AddLandmarkProfile(float x,float y,float z,float t)
+{
+ double x_index = (x - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[0])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[0];
+ double y_index = (y - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[1])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[1];
+ double z_index = (z - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[2])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[2];
+#if VTK_MAJOR_VERSION <= 5
+ if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[0]-0.5 &&
+ x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[1]+0.5 &&
+ y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[2]-0.5 &&
+ y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[3]+0.5 &&
+ z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[4]-0.5 &&
+ z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[5]+0.5)
+#else
+ if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 &&
+ x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 &&
+ y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2]-0.5 &&
+ y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 &&
+ z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 &&
+ z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5)
+#endif
+ {
+ double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetImage()->GetVTKImages()[mSlicers[mSelectedSlicer]->GetTSlice()], x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848
+ this->GetLandmarks()->AddLandmark(x,y,z,t,value);
+ }
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+void vvSlicerManager::UpdateLandmark()
{
+ this->GetLandmarks()->TransformUpdate(mSlicers[mSelectedSlicer]->GetConcatenatedTransform()->GetInverse());
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+void vvSlicerManager::PrevImage(int slicer)
+{
emit ChangeImageWithIndexOffset(this, slicer, -1);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::NextImage(int slicer)
-{
+{
emit ChangeImageWithIndexOffset(this, slicer, 1);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
-{
+{
emit AVerticalSliderHasChanged(slicer, 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