#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::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)
{
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+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)
{
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:
}
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;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
-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);
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::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