#include <cassert>
//--------------------------------------------------------------------
-vvImage::vvImage():mTransform(vtkSmartPointer<vtkTransform>::New())
+vvImage::vvImage()
{
Init();
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
-vtkSmartPointer<vtkTransform> vvImage::GetTransform()
+const std::vector< vtkSmartPointer<vtkTransform> >& vvImage::GetTransform()
{
return this->mTransform;
}
bool IsTimeSequence() const;
bool IsScalarTypeInteger();
bool IsScalarTypeInteger(int t);
- vtkSmartPointer<vtkTransform> GetTransform();
+ const std::vector< vtkSmartPointer<vtkTransform> >& GetTransform();
void SetTimeSpacing(double s) { mTimeSpacing = s; }
void SetTimeOrigin(double o) { mTimeOrigin = o; }
bool HaveSameSizeAndSpacingThan(vvImage * other);
~vvImage();
std::vector< ConverterPointer > mItkToVtkConverters;
- std::vector<vtkImageData*> mVtkImages;
- vtkSmartPointer<vtkTransform> mTransform;
+ std::vector< vtkImageData* > mVtkImages;
+ std::vector< vtkSmartPointer<vtkTransform> > mTransform;
double mTimeOrigin;
double mTimeSpacing;
// GetDirection provides the forward transform, vtkImageReslice wants the inverse
matrix->Invert();
- mTransform->SetMatrix(matrix);
+ mTransform.push_back(vtkSmartPointer<vtkTransform>::New());
+ mTransform.back()->SetMatrix(matrix);
}
//--------------------------------------------------------------------
//------------------------------------------------------------------------------
//Read transformation in NKI format (Xdr, transposed, cm)
-void vvImageReader::ReadNkiImageTransform()
-{
- bool bRead=false;
- std::string filename = mInputFilenames[0]+".MACHINEORIENTATION";
- if(itksys::SystemTools::FileExists(filename.c_str())){
- typedef itk::ImageFileReader< itk::Image< double, 2 > > MatrixReaderType;
- MatrixReaderType::Pointer readerTransfo = MatrixReaderType::New();
- readerTransfo->SetFileName(filename);
- try {
- bRead = true;
- readerTransfo->Update();
- } catch( itk::ExceptionObject & err ) {
- bRead=false;
- std::cerr << "Cannot read " << filename << std::endl
- << "The error is: " << err << std::endl;
- }
-
- if (bRead) {
- //Transpose matrix (NKI format)
- for(int j=0; j<4; j++)
- for(int i=0; i<4; i++)
- mImage->GetTransform()->GetMatrix()->SetElement(j,i,readerTransfo->GetOutput()->GetBufferPointer()[4*i+j]);
-
- //From cm to mm
- for(int i=0; i<3; i++)
- mImage->GetTransform()->GetMatrix()->SetElement(i,3,10*mImage->GetTransform()->GetMatrix()->GetElement(i,3));
-
- mImage->GetTransform()->Inverse();
- }
- }
-}
+//void vvImageReader::ReadNkiImageTransform()
+//{
+// bool bRead=false;
+// std::string filename = mInputFilenames[0]+".MACHINEORIENTATION";
+// if(itksys::SystemTools::FileExists(filename.c_str())){
+// typedef itk::ImageFileReader< itk::Image< double, 2 > > MatrixReaderType;
+// MatrixReaderType::Pointer readerTransfo = MatrixReaderType::New();
+// readerTransfo->SetFileName(filename);
+// try {
+// bRead = true;
+// readerTransfo->Update();
+// } catch( itk::ExceptionObject & err ) {
+// bRead=false;
+// std::cerr << "Cannot read " << filename << std::endl
+// << "The error is: " << err << std::endl;
+// }
+
+// if (bRead) {
+// //Transpose matrix (NKI format)
+// for(int j=0; j<4; j++)
+// for(int i=0; i<4; i++)
+// mImage->GetTransform()->GetMatrix()->SetElement(j,i,readerTransfo->GetOutput()->GetBufferPointer()[4*i+j]);
+
+// //From cm to mm
+// for(int i=0; i<3; i++)
+// mImage->GetTransform()->GetMatrix()->SetElement(i,3,10*mImage->GetTransform()->GetMatrix()->GetElement(i,3));
+
+// mImage->GetTransform()->Inverse();
+// }
+// }
+//}
//------------------------------------------------------------------------------
vtkGenericWarningMacro("Matrix in " << filename.c_str() << " cannot be inverted (determinant = 0)");
}
- mImage->GetTransform()->PostMultiply();
- mImage->GetTransform()->Concatenate(matrix);
- mImage->GetTransform()->Update();
+ // TODO SR and BP: check on the list of transforms and not the first only
+ mImage->GetTransform()[0]->PostMultiply();
+ mImage->GetTransform()[0]->Concatenate(matrix);
+ mImage->GetTransform()[0]->Update();
}
}
//------------------------------------------------------------------------------
std::string mInputPixelType;
//====================================================================
- void ReadNkiImageTransform();
+// void ReadNkiImageTransform();
void ReadMatImageTransform();
private:
vvImageReader();
0.,0.,1.,0.,
0.,-1.,0.,0.,
0.,0.,0.,1.};
+ // TODO SR and BP: check on the list of transforms and not the first only
int i;
- for(i=0; i<16 && m[i]==mImage->GetTransform()->GetMatrix()->GetElement(i%4, i/4); i++);
+ for(i=0; i<16 && m[i]==mImage->GetTransform()[0]->GetMatrix()->GetElement(i%4, i/4); i++);
if(i==16) {
itkWarningMacro(<< "Analyze image file format detected with unknown orientation. "
<< "Forcing identity orientation, use other file format if not ok.");
- mImage->GetTransform()->Identity();
+ mImage->GetTransform()[0]->Identity();
}
}
}
0.,-1.,0.,0.,
0.,0.,0.,1.};
int i;
- for (i = 0; i < 16 && m[i] == mImage->GetTransform()->GetMatrix()->GetElement(i % 4, i / 4); i++)
+ for (i = 0; i < 16 && m[i] == mImage->GetTransform()[0]->GetMatrix()->GetElement(i % 4, i / 4); i++)
;
if (i == 16)
{
itkWarningMacro(<< "Analyze image file format detected with unknown orientation. "
<< "Forcing identity orientation, use other file format if not ok.");
- mImage->GetTransform()->Identity();
+ mImage->GetTransform()[0]->Identity();
}
}
}
itk::Matrix<double, 4, 4> trans;
for(int i=0; i<4; i++)
for(int j=0; j<4; j++)
- trans[i][j] = mImage->GetTransform()->GetMatrix()->GetElement(i,j);
+ // TODO SR and BP: check on the list of transforms and not the first only
+ trans[i][j] = mImage->GetTransform()[0]->GetMatrix()->GetElement(i,j);
trans = trans.GetInverse();
// Direction
<property name="spacing">
<number>2</number>
</property>
- <item row="0" column="17">
- <spacer>
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
<item row="0" column="0">
<widget class="QPushButton" name="goToCursorPushButton">
<property name="sizePolicy">
</item>
</widget>
</item>
- <item row="0" column="19">
+ <item row="0" column="21">
<widget class="QPushButton" name="viewButton">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
</property>
</widget>
</item>
- <item row="0" column="18">
- <widget class="Line" name="line_3">
- <property name="orientation">
- <enum>Qt::Vertical</enum>
- </property>
- </widget>
- </item>
<item row="0" column="4">
<widget class="QSpinBox" name="frameRateSpinBox">
<property name="minimum">
</property>
</widget>
</item>
+ <item row="0" column="19">
+ <widget class="QComboBox" name="slicingPresetComboBox">
+ <item>
+ <property name="text">
+ <string>World</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Voxels</string>
+ </property>
+ </item>
+ </widget>
+ </item>
+ <item row="0" column="18">
+ <widget class="QLabel" name="label_2">
+ <property name="text">
+ <string>Slice to</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="17">
+ <spacer name="horizontalSpacer">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
</layout>
</widget>
</item>
<x>0</x>
<y>0</y>
<width>1008</width>
- <height>22</height>
+ <height>25</height>
</rect>
</property>
<property name="defaultUp">
connect(levelSpinBox,SIGNAL(editingFinished()),this,SLOT(WindowLevelEdited()));
connect(colorMapComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateColorMap()));
connect(presetComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateWindowLevel()));
+ connect(slicingPresetComboBox, SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateSlicingPreset()));
connect(inverseButton,SIGNAL(clicked()),this,SLOT(SwitchWindowLevel()));
connect(applyWindowLevelToAllButton,SIGNAL(clicked()),this,SLOT(ApplyWindowLevelToAllImages()));
-
connect(this,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(ShowContextMenu(QPoint)));
connect(linkPanel,SIGNAL(addLink(QString,QString)),this,SLOT(AddLink(QString,QString)));
this,SLOT(UpdateSlice(int,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
this,SLOT(UpdateTSlice(int, int)));
+ connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
+ this,SLOT(ImageInfoChanged()));
connect(mSlicerManagers.back(), SIGNAL(UpdateSliceRange(int,int,int,int,int)),
this,SLOT(UpdateSliceRange(int,int,int,int,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
infoPanel->setOrigin(GetVectorDoubleAsString(origin));
infoPanel->setSpacing(GetVectorDoubleAsString(inputSpacing));
infoPanel->setNPixel(QString::number(NPixel)+" ("+inputSizeInBytes+")");
- transformation = imageSelected->GetTransform()->GetMatrix();
+ transformation = imageSelected->GetTransform()[mSlicerManagers[index]->GetTSlice()]->GetMatrix();
infoPanel->setTransformation(Get4x4MatrixDoubleAsString(transformation));
landmarksPanel->SetCurrentLandmarks(mSlicerManagers[index]->GetLandmarks(),
}
}
WindowLevelChanged();
+ slicingPresetComboBox->setCurrentIndex(mSlicerManagers[index]->GetSlicingPreset());
if (mSlicerManagers[index]->GetSlicer(0)->GetVF()) {
overlayPanel->getVFName(mSlicerManagers[index]->GetVFName().c_str());
}
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void vvMainWindow::UpdateSlicingPreset()
+{
+ if (DataTree->selectedItems().size()) {
+ int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
+ mSlicerManagers[index]->SetSlicingPreset(vvSlicerManager::SlicingPresetType(slicingPresetComboBox->currentIndex()));
+ }
+}
+//------------------------------------------------------------------------------
+
//------------------------------------------------------------------------------
void vvMainWindow::UpdateColorMap()
{
bool bId = true;
for(int i=0; i<4; i++)
for(int j=0; j<4; j++) {
- double elt = mSlicerManagers[index]->GetImage()->GetTransform()->GetMatrix()->GetElement(i,j);
+ // TODO SR and BP: check on the list of transforms and not the first only
+ double elt = mSlicerManagers[index]->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j);
if(i==j && elt!=1.)
bId = false;
if(i!=j && elt!=0.)
this,SLOT(UpdateSlice(int,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
this,SLOT(UpdateTSlice(int, int)));
+ connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
+ this,SLOT(ImageInfoChanged()));
connect(mSlicerManagers.back(), SIGNAL(UpdateSliceRange(int,int,int,int,int)),
this,SLOT(UpdateSliceRange(int,int,int,int,int)));
connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
void SetWindowLevel(double w, double l);
void UpdateColorMap();
void UpdateWindowLevel();
+ void UpdateSlicingPreset();
void SwitchWindowLevel();
void ApplyWindowLevelToAllImages();
void UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps);
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
this->GetImageActor()->GetMapper()->BorderOn();
#endif
+
+ mSlicingTransform = vtkSmartPointer<vtkTransform>::New();
+ mConcatenatedTransform = vtkSmartPointer<vtkTransform>::New();
}
//------------------------------------------------------------------------------
}
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+double* vvSlicer::GetCurrentPosition()
+{
+ return mCurrentBeforeSlicingTransform;
+}
+//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCurrentPosition(double x, double y, double z, int t)
{
- mCurrent[0] = x;
- mCurrent[1] = y;
- mCurrent[2] = z;
+ mCurrentBeforeSlicingTransform[0]=x;
+ mCurrentBeforeSlicingTransform[1]=y;
+ mCurrentBeforeSlicingTransform[2]=z;
+ mSlicingTransform->GetInverse()->TransformPoint(mCurrentBeforeSlicingTransform,mCurrent);
mCurrentTSlice = t;
}
//------------------------------------------------------------------------------
mImageReslice->AutoCropOutputOn();
mImageReslice->SetBackgroundColor(-1000,-1000,-1000,1);
}
- mImageReslice->SetResliceTransform(mImage->GetTransform());
+
+ mConcatenatedTransform->Identity();
+ mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
+ mConcatenatedTransform->Concatenate(mSlicingTransform);
+ mImageReslice->SetResliceTransform(mConcatenatedTransform);
mImageReslice->SetInput(0, mImage->GetFirstVTKImageData());
mImageReslice->UpdateInformation();
mOverlayReslice->AutoCropOutputOn();
mOverlayReslice->SetBackgroundColor(-1000,-1000,-1000,1);
}
- mOverlayReslice->SetResliceTransform(mOverlay->GetTransform());
+ mOverlayReslice->SetResliceTransform(mOverlay->GetTransform()[0]);
mOverlayReslice->SetInput(0, mOverlay->GetFirstVTKImageData());
if (!mOverlayMapper)
mFusionReslice->AutoCropOutputOn();
mFusionReslice->SetBackgroundColor(-1000,-1000,-1000,1);
}
- mFusionReslice->SetResliceTransform(mFusion->GetTransform());
+ mFusionReslice->SetResliceTransform(mFusion->GetTransform()[0]);
mFusionReslice->SetInput(0, mFusion->GetFirstVTKImageData());
if (!mFusionMapper)
else if ((unsigned int)t >= mImage->GetVTKImages().size())
t = mImage->GetVTKImages().size() -1;
+ // Update transform
+ mConcatenatedTransform->Identity();
+ mConcatenatedTransform->Concatenate(mImage->GetTransform()[t]);
+ mConcatenatedTransform->Concatenate(mSlicingTransform);
+
+ // Update image data
mCurrentTSlice = t;
mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
if (mVF && mVFActor->GetVisibility()) {
double cpos = (double)cam->GetPosition()[this->SliceOrientation];
double range = fabs(spos - cpos);
double *spacing = input->GetSpacing();
- double avg_spacing =
- ((double)spacing[0] + (double)spacing[1] + (double)spacing[2]) / 3.0;
- cam->SetClippingRange(range - avg_spacing * 3.0, range + avg_spacing * 3.0);
+ double sumSpacing = spacing[0] + spacing[1] + spacing[2];
+ cam->SetClippingRange(range - sumSpacing, range + sumSpacing);
}
}
}
if (ca->GetVisibility()) {
std::stringstream worldPos;
- double X = (mCurrent[0] - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
- double Y = (mCurrent[1] - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
- double Z = (mCurrent[2] - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
-
-// if (X < this->GetInput()->GetWholeExtent()[0]) X = this->GetInput()->GetWholeExtent()[0];
-// else if (X > this->GetInput()->GetWholeExtent()[1]) X = this->GetInput()->GetWholeExtent()[1];
-// if (Y < this->GetInput()->GetWholeExtent()[2]) Y = this->GetInput()->GetWholeExtent()[2];
-// else if (Y > this->GetInput()->GetWholeExtent()[3]) Y = this->GetInput()->GetWholeExtent()[3];
-// if (Z < this->GetInput()->GetWholeExtent()[4]) Z = this->GetInput()->GetWholeExtent()[4];
-// else if (Z > this->GetInput()->GetWholeExtent()[5]) Z = this->GetInput()->GetWholeExtent()[5];
-
- if (X >= this->GetInput()->GetWholeExtent()[0] &&
- X <= this->GetInput()->GetWholeExtent()[1] &&
- Y >= this->GetInput()->GetWholeExtent()[2] &&
- Y <= this->GetInput()->GetWholeExtent()[3] &&
- Z >= this->GetInput()->GetWholeExtent()[4] &&
- Z <= this->GetInput()->GetWholeExtent()[5]) {
+ double pt[3];
+ mConcatenatedTransform->TransformPoint(mCurrent, pt);
+ double X = (pt[0] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[0])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[0];
+ double Y = (pt[1] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[1])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[1];
+ double Z = (pt[2] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[2])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[2];
+
+ if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[0]-0.5 &&
+ X <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[1]+0.5 &&
+ Y >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[2]-0.5 &&
+ Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[3]+0.5 &&
+ Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[4]-0.5 &&
+ Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[5]+0.5) {
int ix, iy, iz;
- double value = this->GetScalarComponentAsDouble(this->GetInput(), X, Y, Z, ix, iy, iz);
+ double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
if(ImageActor->GetVisibility())
worldPos << "data value : " << value << std::endl;
- worldPos << "mm : " << lrint(mCurrent[0]) << ' '
- << lrint(mCurrent[1]) << ' '
- << lrint(mCurrent[2]) << ' '
+ worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' '
+ << lrint(mCurrentBeforeSlicingTransform[1]) << ' '
+ << lrint(mCurrentBeforeSlicingTransform[2]) << ' '
<< mCurrentTSlice
<< std::endl;
worldPos << "pixel : " << ix << ' '
return mCursor;
}
+ vtkTransform * GetSlicingTransform() { return mSlicingTransform; }
+ vtkTransform * GetConcatenatedTransform() { return mConcatenatedTransform; }
+
void SetCurrentPosition(double x, double y, double z, int t);
- double* GetCurrentPosition() {
- return mCurrent;
- }
+ double* GetCurrentPosition();
void UpdateCursorPosition();
void SetCursorVisibility(bool s);
vvLandmarks* mLandmarks;
+ // __________ Image coordinates accounting for spacing and origin
+ // Λ Λ
+ // | | vvImage.GetTransform()
+ // | |
+ // GetConcatenatedTransform() | _|___ VV world coordinates (mm) (displayed in VV)
+ // | Λ
+ // | | GetSlicingTransform()
+ // | |
+ // ___|__|___ VTK world coordinates (mm) (never displayed)
+
vtkSmartPointer<vtkImageReslice> mImageReslice;
+ vtkSmartPointer<vtkTransform> mSlicingTransform;
+ vtkSmartPointer<vtkTransform> mConcatenatedTransform;
vtkSmartPointer<vtkImageReslice> mOverlayReslice;
vtkSmartPointer<vtkImageMapToWindowLevelColors> mOverlayMapper;
vtkSmartPointer<vvBlendImageActor> mOverlayActor;
int mCurrentTSlice;
double mCurrent[3];
+ double mCurrentBeforeSlicingTransform[3];
double mCursor[4];
int mSubSampling;
int mScale;
mPreviousSlice.resize(numberOfSlicers);
mPreviousTSlice.resize(numberOfSlicers);
+ mSlicingPreset = WORLD_SLICING;
}
//----------------------------------------------------------------------------
}
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+int vvSlicerManager::GetTSlice()
+{
+ return mSlicers[0]->GetTSlice();
+}
+//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
void vvSlicerManager::SetTSlice(int slice)
{
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
if (slice != mSlicers[i]->GetTSlice()) {
mSlicers[i]->SetTSlice(slice);
- UpdateTSlice(i);
+ UpdateTSlice(i);
}
}
}
if (mSlicers[slicer]->GetTSlice() == tslice) return;
+ if(mSlicingPreset==VOXELS_SLICING) {
+ vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
+ mImage->GetTransform()[tslice]->GetInverse(imageTransformInverse);
+ this->GetSlicer(slicer)->GetSlicingTransform()->SetMatrix(imageTransformInverse);
+ imageTransformInverse->Delete();
+ }
+
mSlicers[slicer]->SetTSlice(tslice);
UpdateTSlice(slicer);
}
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateViews(int current,int slicer)
{
- double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
+ double p[3], pt[3];
+ p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
+ p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
+ p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
+ mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
+
+ double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
/mSlicers[slicer]->GetInput()->GetSpacing()[0];
- double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
+ double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
/mSlicers[slicer]->GetInput()->GetSpacing()[1];
- double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
+ double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
/mSlicers[slicer]->GetInput()->GetSpacing()[2];
- 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 (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) {
mSlicers[slicer]->UpdateCursorPosition();
mSlicers[slicer]->SetCursorColor(10,212,255);
switch (mSlicers[slicer]->GetSliceOrientation()) {
case vtkImageViewer2::SLICE_ORIENTATION_XY:
- if (mSlicers[slicer]->GetSlice() != (int)floor(z))
- mSlicers[slicer]->SetSlice((int)floor(z));
+ if (mSlicers[slicer]->GetSlice() != (int)lrint(z))
+ mSlicers[slicer]->SetSlice((int)lrint(z));
break;
case vtkImageViewer2::SLICE_ORIENTATION_XZ:
- if (mSlicers[slicer]->GetSlice() != (int)floor(y))
- mSlicers[slicer]->SetSlice((int)floor(y));
+ if (mSlicers[slicer]->GetSlice() != (int)lrint(y))
+ mSlicers[slicer]->SetSlice((int)lrint(y));
break;
case vtkImageViewer2::SLICE_ORIENTATION_YZ:
- if (mSlicers[slicer]->GetSlice() != (int)floor(x))
- mSlicers[slicer]->SetSlice((int)floor(x));
+ if (mSlicers[slicer]->GetSlice() != (int)lrint(x))
+ mSlicers[slicer]->SetSlice((int)lrint(x));
break;
}
mSlicers[slicer]->Render();
&& mSlicers[i]->GetRenderer()->GetDraw()
&& mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
&& mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
- mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0],
- mSlicers[slicer]->GetCurrentPosition()[1],
- mSlicers[slicer]->GetCurrentPosition()[2],
- mSlicers[slicer]->GetTSlice());
+ mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetTSlice());
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,
//----------------------------------------------------------------------------
void vvSlicerManager::UpdateLinked(int 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])
- /mSlicers[slicer]->GetInput()->GetSpacing()[1];
- double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
- /mSlicers[slicer]->GetInput()->GetSpacing()[2];
-
- 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]) {
+ double p[3], pt[3];
+ p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
+ p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
+ p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
+ mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
+ 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 (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) {
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],
void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
{
vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
- double refPosition[3], refFocal[3];
+
+ double refPosition[3];
refCam->GetPosition(refPosition);
- refCam->GetFocalPoint(refFocal);
-
+ refPosition[refSlicer->GetSliceOrientation()] = refSlicer->GetSlice() *
+ refSlicer->GetInput()->GetSpacing()[refSlicer->GetSliceOrientation()] +
+ refSlicer->GetInput()->GetOrigin()[refSlicer->GetSliceOrientation()];
+
+ refSlicer->GetSlicingTransform()->TransformPoint(refPosition, refPosition);
+ mSlicers[0]->GetSlicingTransform()->GetInverse()->TransformPoint(refPosition, refPosition);
+
for ( unsigned int i = 0; i < mSlicers.size(); i++) {
vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
camera->SetParallelScale(refCam->GetParallelScale());
camera->GetPosition(position);
camera->GetFocalPoint(focal);
- if(refSlicer->GetSliceOrientation()==mSlicers[i]->GetSliceOrientation()) {
- for(int i=0; i<3; i++) {
- position[i] = refPosition[i];
- focal[i] = refFocal[i];
- }
- }
-
- if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
- if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
- position[0] = refPosition[0];
- focal[0] = refFocal[0];
- }
- if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
- position[1] = refPosition[1];
- focal[1] = refFocal[1];
- }
- }
-
- if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
- if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
- position[2] = refPosition[2];
- focal[2] = refFocal[2];
- }
- if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
- position[0] = refPosition[0];
- focal[0] = refFocal[0];
- }
- }
-
- if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
- if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
- position[1] = refPosition[1];
- focal[1] = refFocal[1];
- }
- if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
- position[2] = refPosition[2];
- focal[2] = refFocal[2];
+ for(int j=0; j<3; j++) {
+ if(j!=mSlicers[i]->GetSliceOrientation()) {
+ position[j] = refPosition[j];
+ focal[j] = refPosition[j];
}
}
camera->SetFocalPoint(focal);
camera->SetPosition(position);
-
+
//Fix for bug #243
mSlicers[i]->ForceUpdateDisplayExtent();
}
void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)
{
if(actorType == "image")
- this->GetImage()->GetTransform()->Identity();
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
+ this->GetImage()->GetTransform()[i]->Identity();
else if(actorType == "overlay")
- this->GetSlicer(0)->GetOverlay()->GetTransform()->Identity();
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
+ this->GetSlicer(0)->GetOverlay()->GetTransform()[i]->Identity();
else if(actorType == "fusion")
- this->GetSlicer(0)->GetFusion()->GetTransform()->Identity();
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
+ this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
else if(actorType == "vf")
- this->GetVF()->GetTransform()->Identity();
+ for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
+ this->GetVF()->GetTransform()[i]->Identity();
else
return;
}
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)
+{
+ if(mSlicingPreset==preset)
+ return;
+
+ vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
+ mImage->GetTransform()[this->GetTSlice()]->GetInverse(imageTransformInverse);
+
+ for(int i=0; i< this->GetNumberOfSlicers(); i++){
+ vvSlicer *s = this->GetSlicer(i);
+ switch(preset)
+ {
+ case WORLD_SLICING:
+ s->GetSlicingTransform()->Identity();
+ break;
+ case VOXELS_SLICING:
+ s->GetSlicingTransform()->SetMatrix(imageTransformInverse);
+ break;
+ default:
+ imageTransformInverse->Delete();
+ return;
+ }
+ s->ForceUpdateDisplayExtent();
+ s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1]
+ +s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0);
+ s->ResetCamera();
+ s->Render();
+ }
+
+ imageTransformInverse->Delete();
+ mSlicingPreset = preset;
+}
+
+//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicerManager::SetPreset(int preset)
void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)
{
double min, max;
- int t = this->mSlicers[slicer]->GetTSlice();
+ int t = this->GetTSlice();
if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {
this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
this->mSlicers[slicer]->GetFusion()->GetVTKImages()[t],
- this->mSlicers[slicer]->GetFusion()->GetTransform());
+ this->mSlicers[slicer]->GetFusion()->GetTransform()[t]);
this->SetFusionWindow(max-min);
this->SetFusionLevel(0.5*(min+max));
this->SetColorMap(mColorMap);
else if(bCtrlKey && this->mSlicers[slicer]->GetOverlay()) {
this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
this->mSlicers[slicer]->GetOverlay()->GetVTKImages()[t],
- this->mSlicers[slicer]->GetOverlay()->GetTransform());
+ this->mSlicers[slicer]->GetOverlay()->GetTransform()[t]);
if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){
this->SetColorWindow(max-min);
this->SetColorLevel(0.5*(min+max));
else {
this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
this->mSlicers[slicer]->GetImage()->GetVTKImages()[t],
- this->mSlicers[slicer]->GetImage()->GetTransform());
+ this->mSlicers[slicer]->GetConcatenatedTransform());
this->SetColorWindow(max-min);
this->SetColorLevel(0.5*(min+max));
this->SetPreset(6);
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] &&
- x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1] &&
- y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2] &&
- y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3] &&
- z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4] &&
- z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]) {
+ 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);
this->GetLandmarks()->AddLandmark(x,y,z,t,value);
emit LandmarkAdded();
Q_OBJECT
public:
+ typedef enum {WORLD_SLICING, VOXELS_SLICING} SlicingPresetType;
vvSlicerManager(int numberOfSlicers);
~vvSlicerManager();
void SetFilename(std::string f, int number=0);
void SetSliceOrientation(int slicer, int orientation);
+ int GetTSlice();
void SetTSlice(int slice);
void SetNextTSlice(int originating_slicer);
void SetPreviousTSlice(int originating_slicer);
int GetPreset() {
return mPreset;
}
+ SlicingPresetType GetSlicingPreset() {
+ return mSlicingPreset;
+ }
int GetOverlayColor() const {
return mOverlayColor;
}
void UpdateSlice(int slicer);
void UpdateTSlice(int slicer);
void UpdateSliceRange(int slicer);
+ void SetSlicingPreset(SlicingPresetType preset);
vvLandmarks *GetLandmarks();
void AddLandmark(float x,float y,float z,float t);
bool mFusionShowLegend;
int mPreset;
+ SlicingPresetType mSlicingPreset;
vvImageReader::LoadedImageType mType;
std::string mVFComponent;
std::string mOverlayComponent;
zWorld = z;
break;
}
- this->SM->GetSlicer(VisibleInWindow)->SetCurrentPosition(xWorld,yWorld,zWorld,
+
+ double p[3]; p[0] = xWorld; p[1] = yWorld; p[2] = zWorld;
+ double pt[3];
+ this->SM->GetSlicer(VisibleInWindow)->GetSlicingTransform()->TransformPoint(p, pt);
+
+ this->SM->GetSlicer(VisibleInWindow)->SetCurrentPosition(pt[0],pt[1],pt[2],
this->SM->GetSlicer(VisibleInWindow)->GetTSlice());
if (newLandmark) {
this->SM->AddLandmark(xWorld,yWorld,zWorld,
//backup original matrix
for(int j=0; j<4; j++)
for(int i=0; i<4; i++)
- mInitialMatrix->SetElement(i,j, mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix()->GetElement(i,j));
+ // TODO SR and BP: check on the list of transforms and not the first only
+ mInitialMatrix->SetElement(i,j, mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j));
QString origTransformString = dynamic_cast<vvMainWindow*>(mMainWindow)->Get4x4MatrixDoubleAsString(mInitialMatrix);
transformationLabel->setText(origTransformString);
SetTransform(mInitialMatrix);
}
// Compute transform and set
- vtkSmartPointer<vtkTransform> transform_final=mInput->GetImage()->GetTransform();
+ // TODO SR and BP: check on the list of transforms and not the first only
+ vtkSmartPointer<vtkTransform> transform_final=mInput->GetImage()->GetTransform()[0];
transform_final->Identity();
transform_final->PostMultiply();
QFile file(filename);
if (file.open(QFile::WriteOnly | QFile::Truncate)) {
- vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix();
+ // TODO SR and BP: check on the list of transforms and not the first only
+ vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix();
QString matrixStr = dynamic_cast<vvMainWindow*>(mMainWindow)->Get4x4MatrixDoubleAsString(matrix,16);
QTextStream out(&file);
out << matrixStr;
//------------------------------------------------------------------------------
void vvToolRigidReg::ChangeOfRotationCenter()
{
- SetTransform(mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix());
+ // TODO SR and BP: check on the list of transforms and not the first only
+ SetTransform(mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix());
}
//------------------------------------------------------------------------------
void vvToolRigidReg::SetTransform(vtkMatrix4x4 *matrix)
{
vtkSmartPointer<vtkTransform> transform=vtkSmartPointer<vtkTransform>::New();
- mCurrentSlicerManager->GetImage()->GetTransform()->SetMatrix(matrix);
+ // TODO SR and BP: check on the list of transforms and not the first only
+ mCurrentSlicerManager->GetImage()->GetTransform()[0]->SetMatrix(matrix);
transform->Update();
Render();
dynamic_cast<vvMainWindow*>(mMainWindow)->ImageInfoChanged();