#include "vvInteractorStyleNavigator.h"
#include "vvLandmarks.h"
#include "vvMesh.h"
-#include "vvImageMapToWLColors.h"
#include "vvBlendImageActor.h"
#include <vtkImageActor.h>
#include <vtkCamera.h>
#include <qfileinfo.h>
-
//----------------------------------------------------------------------------
vvSlicerManager::vvSlicerManager(int numberOfSlicers)
{
mFusionLevel = 1000;
mFusionShowLegend = true;
+ mFusionSequenceFrameIndex = -1;
+ mFusionSequenceSpatialSyncFlag = false;
+ mFusionSequenceNbFrames = 0;
+
mLandmarks = NULL;
mLinkedId.resize(0);
for ( int i = 0; i < numberOfSlicers; i++)
mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
-
+ mSelectedSlicer = -1;
+
mPreviousSlice.resize(numberOfSlicers);
mPreviousTSlice.resize(numberOfSlicers);
mSlicingPreset = WORLD_SLICING;
+
+
}
//----------------------------------------------------------------------------
reader = mFusionReader;
else if(actorType=="vector")
reader = mVectorReader;
+ else if(actorType=="fusionSequence")
+ reader = mFusionSequenceReader;
if(!reader)
return "";
//----------------------------------------------------------------------------
-bool vvSlicerManager::SetOverlay(std::string filename,int dim, std::string component)
+bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
{
- mOverlayName = filename;
+ mOverlayName = filenames[0];
mOverlayComponent = component;
if (dim > mImage->GetNumberOfDimensions()) {
- mLastError = " Overlay dimension cannot be greater then reference image!";
+ mLastError = " Overlay dimension cannot be greater than reference image!";
return false;
}
if (mOverlayReader.IsNull())
mOverlayReader = vvImageReader::New();
- std::vector<std::string> filenames;
- filenames.push_back(filename);
mOverlayReader->SetInputFilenames(filenames);
- mOverlayReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
+ mOverlayReader->Update(type);
if (mOverlayReader->GetLastError().size() == 0) {
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
}
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+bool vvSlicerManager::SetFusionSequence(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
+{
+ 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);
+
+ //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()-1; //actually, this is the maximum index...
+ if (mFusionSequenceFrameIndex>=mFusionSequenceNbFrames) {
+ mFusionSequenceFrameIndex=0;
+ }
+
+
+ if (mFusionSequenceReader->GetLastError().size() == 0) {
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+ mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput());
+ }
+ } else {
+ mLastError = mFusionSequenceReader->GetLastError();
+ return false;
+ }
+ double *fusRange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
+ mFusionLevel = (fusRange[0]+fusRange[1])/2;
+ mFusionWindow = fusRange[1]-fusRange[0];
+
+ return true;
+}
+//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
bool vvSlicerManager::SetVF(std::string filename)
}
//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+void vvSlicerManager::EmitMousePositionUpdated(int slicer)
+{
+ emit MousePositionUpdatedSignal(slicer);
+}
+//----------------------------------------------------------------------------
+
+
+//----------------------------------------------------------------------------
+void vvSlicerManager::EmitKeyPressed(std::string KeyPress)
+{
+ emit KeyPressedSignal(KeyPress);
+}
+//----------------------------------------------------------------------------
+
+
//----------------------------------------------------------------------------
void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)
{
if (mLandmarks)
mLandmarks->SetTime(slice);
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
- if (slice != mSlicers[i]->GetTSlice()) {
+ if (slice != mSlicers[i]->GetMaxCurrentTSlice()) {
mSlicers[i]->SetTSlice(slice);
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]->GetTSlice();
+ int t = mSlicers[0]->GetMaxCurrentTSlice();
t++;
if (t > mSlicers[0]->GetTMax())
t = 0;
//----------------------------------------------------------------------------
void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
{
- int t = mSlicers[0]->GetTSlice();
+ int t = mSlicers[0]->GetMaxCurrentTSlice();
t--;
if (t < 0)
t = mSlicers[0]->GetTMax();
if (mLandmarks)
mLandmarks->SetTime(tslice);
- if (mSlicers[slicer]->GetTSlice() == tslice) return;
+ if (mSlicers[slicer]->GetMaxCurrentTSlice() == tslice) return;
+
+ mSlicers[slicer]->SetTSlice(tslice);
if(mSlicingPreset==VOXELS_SLICING) {
vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
- mImage->GetTransform()[tslice]->GetInverse(imageTransformInverse);
+ mImage->GetTransform()[mSlicers[slicer]->GetTSlice()]->GetInverse(imageTransformInverse);
this->GetSlicer(slicer)->GetSlicingTransform()->SetMatrix(imageTransformInverse);
imageTransformInverse->Delete();
}
- mSlicers[slicer]->SetTSlice(tslice);
UpdateTSlice(slicer);
}
//----------------------------------------------------------------------------
z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
mSlicers[slicer]->UpdateCursorPosition();
mSlicers[slicer]->SetCursorColor(10,212,255);
+ mSelectedSlicer = slicer;
switch (mSlicers[slicer]->GetSliceOrientation()) {
case vtkImageViewer2::SLICE_ORIENTATION_XY:
&& mSlicers[i]->GetRenderer()->GetDraw()
&& mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
&& mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
- mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetTSlice());
+ mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
mSlicers[i]->UpdateCursorPosition();
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]->GetTSlice());
+ -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());
mSlicers[i]->SetCursorColor(255,10,212);
} else {
mSlicers[i]->SetCursorColor(150,10,282);
}
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;
}
z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
- emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
- mSlicers[slicer]->GetCurrentPosition()[1],
- mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
+ emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
}
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-double vvSlicerManager::GetColorWindow()
+double vvSlicerManager::GetColorWindow() const
{
if (mSlicers.size())
return mSlicers[0]->GetColorWindow();
//----------------------------------------------------------------------------
-double vvSlicerManager::GetColorLevel()
+double vvSlicerManager::GetColorLevel() const
{
if (mSlicers.size())
return mSlicers[0]->GetColorLevel();
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();
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
mSlicers[i]->SetImage(mImage);
}
+ //TODO: check if this image is involved in a fusion sequence, then the main transform matrix should be updated.
}
//----------------------------------------------------------------------------
}
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+void vvSlicerManager::ReloadFusionSequence()
+{
+ mFusionSequenceReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),vvImageReader::MERGEDWITHTIME);
+
+ for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+ mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput());
+ mSlicers[i]->Render();
+ }
+
+ //Update the slider
+ mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size();
+ if (mFusionSequenceFrameIndex>=mFusionSequenceNbFrames) {
+ mFusionSequenceFrameIndex=0;
+ }
+
+ //Update the list of initial transforms
+ //Warning, the main transform will not be updated on reload.........
+ mFusionSequenceListInitialTransformMatrices.clear();
+ for (unsigned i=0 ; i<mFusionSequenceNbFrames ; i++) {
+ this->AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() );
+ }
+
+ //emit UpdateFusionSequence(mFusionSequenceFrameIndex, mFusionSequenceSpatialSyncFlag, mFusionSequenceNbFrames);
+}
+//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
void vvSlicerManager::ReloadOverlay()
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);
if (mSlicers[slicer]->GetVFActor() ) {
displayVec = 1;
- unsigned int currentTime = mSlicers[slicer]->GetTSlice();
+ unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice();
vtkImageData *vf = NULL;
if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
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);
- }
+\r
+ if (mSlicers[slicer]->GetFusionActor() ) {\r
+ displayFus = 1;\r
+ vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());\r
+ double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];\r
+ double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];\r
+ double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];\r
+ valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);\r
+ }\r
+
+
emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
x,y,z,X,Y,Z,value);
emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
void vvSlicerManager::UpdateTSlice(int slicer)
{
int slice = mSlicers[slicer]->GetSlice();
- int tslice = mSlicers[slicer]->GetTSlice();
+ int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();
if (mPreviousSlice[slicer] == slice) {
if (mPreviousTSlice[slicer] == tslice) {
// DD("************** NOTHING ***********");
window = 400;
level = 20;
break;
- case 3:
- window = 1500;
- level = -500;
+ case 3: // lungs (same as FOCAL)
+ window = 1700;
+ level = -300;
break;
case 4:
window = 1000;
void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)
{
double min, max;
- int t = this->GetTSlice();
if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {
+ int t = mSlicers[slicer]->GetFusionTSlice();
this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
this->mSlicers[slicer]->GetFusion()->GetVTKImages()[t],
- this->mSlicers[slicer]->GetFusion()->GetTransform()[t]);
+ this->mSlicers[slicer]->GetConcatenatedFusionTransform());
this->SetFusionWindow(max-min);
this->SetFusionLevel(0.5*(min+max));
this->SetColorMap(mColorMap);
}
else if(bCtrlKey && this->mSlicers[slicer]->GetOverlay()) {
+ int t = mSlicers[slicer]->GetOverlayTSlice();
this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
this->mSlicers[slicer]->GetOverlay()->GetVTKImages()[t],
- this->mSlicers[slicer]->GetOverlay()->GetTransform()[t]);
+ this->mSlicers[slicer]->GetConcatenatedOverlayTransform());
if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){
this->SetColorWindow(max-min);
this->SetColorLevel(0.5*(min+max));
}
}
else {
+ int t = this->GetTSlice();
this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
this->mSlicers[slicer]->GetImage()->GetVTKImages()[t],
this->mSlicers[slicer]->GetConcatenatedTransform());
void vvSlicerManager::SetColorMap(int colormap)
{
double range[2];
+
range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
}
vtkWindowLevelLookupTable* fusLUT = NULL;
if (mSlicers[0]->GetFusion()) { // && mFusionColorMap >= 0) {
- fusLUT = vtkWindowLevelLookupTable::New();
+ fusLUT = vtkWindowLevelLookupTable::New();
double fusRange [2];
fusRange[0] = mFusionLevel - mFusionWindow/2;
fusRange[1] = mFusionLevel + mFusionWindow/2;
- double* frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
- fusLUT->SetTableRange(frange);
+
+ //check whether it is actually a fusionSequence or a fusion, before invoking mFusionReader...
+ double* frange;
+ if (mFusionReader.IsNull()) 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->SetAlphaRange(1, 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);
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff