// vv
#include "vvToolRigidReg.h"
#include "vvSlicer.h"
+#include <vvBlendImageActor.h>
// vtk
#include <vtkImageData.h>
#include <vtkSmartPointer.h>
+#include <vtkInformation.h>
#include <vtkTransform.h>
+#include <vtkImageActor.h>
+#include <vtkImageMapper3D.h>
+#include <vtkOpenGLImageSliceMapper.h>
// itk
#include <itkEuler3DTransform.h>
// clitk
#include "clitkTransformUtilities.h"
+#include "clitkMatrix.h"
// qt
#include <QMessageBox>
imageorigin=mInput->GetImage()->GetOrigin();
std::vector<int> imageSize = mInput->GetImage()->GetSize();
std::vector<double> imageSpacing = mInput->GetImage()->GetSpacing();
- xcord=xcord.setNum(imageorigin[0]+imageSize[0]*imageSpacing[0]/2, 'g', 3);
- ycord=ycord.setNum(imageorigin[1]+imageSize[1]*imageSpacing[1]/2, 'g', 3);
- zcord=zcord.setNum(imageorigin[2]+imageSize[2]*imageSpacing[2]/2, 'g', 3);
+ xcord=xcord.setNum(imageorigin[0]+(imageSize[0]-1)*imageSpacing[0]*0.5, 'g', 3);
+ ycord=ycord.setNum(imageorigin[1]+(imageSize[1]-1)*imageSpacing[1]*0.5, 'g', 3);
+ zcord=zcord.setNum(imageorigin[2]+(imageSize[2]-1)*imageSpacing[2]*0.5, 'g', 3);
Xval->setText(xcord);
Yval->setText(ycord);
Zval->setText(zcord);
//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));
- QString origTransformString = dynamic_cast<vvMainWindow*>(mMainWindow)->Get4x4MatrixDoubleAsString(mInitialMatrix);
+ // 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(clitk::Get4x4MatrixDoubleAsString(mInitialMatrix).c_str());
transformationLabel->setText(origTransformString);
SetTransform(mInitialMatrix);
for(int i=0; i<3; i++) {
if(transSBs[i] == QObject::sender()) {
transSliders[i]->blockSignals(true);
- transSliders[i]->setValue(itk::Math::Round(newVal));
+ transSliders[i]->setValue(itk::Math::Round<double,double>(newVal));
transSliders[i]->blockSignals(false);
}
if(rotSBs[i] == QObject::sender()) {
double rad = (checkBoxDegrees->checkState()==Qt::Unchecked)?180./itk::Math::pi:1.;
rotSliders[i]->blockSignals(true);
- rotSliders[i]->setValue(itk::Math::Round(newVal*rad));
+ rotSliders[i]->setValue(itk::Math::Round<double,double>(newVal*rad));
rotSliders[i]->blockSignals(false);
}
}
// 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();
- QString matrixStr = dynamic_cast<vvMainWindow*>(mMainWindow)->Get4x4MatrixDoubleAsString(matrix,16);
+ // TODO SR and BP: check on the list of transforms and not the first only
+ vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix();
+ QString matrixStr = clitk::Get4x4MatrixDoubleAsString(matrix,16).c_str();
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();
euler->SetMatrix(rotMat);
euler->SetOffset(transVec);
-
// Modify GUI according to the new parameters
std::vector<QSlider *> transSliders, rotSliders;
std::vector<QDoubleSpinBox *> transSBs, rotSBs;
GetSlidersAndSpinBoxes(transSliders, rotSliders, transSBs, rotSBs);
for(int i=0; i<3; i++) {
+ // Translations
transSBs[i]->blockSignals(true);
transSBs[i]->setValue( euler->GetParameters()[i+3] );
transSBs[i]->blockSignals(false);
transSliders[i]->blockSignals(true);
- transSliders[i]->setValue( itk::Math::Round(euler->GetParameters()[i+3]) );
+ transSliders[i]->setValue( itk::Math::Round<double,double>(euler->GetParameters()[i+3]) );
transSliders[i]->blockSignals(false);
+
+ // Rotations
double rad = (checkBoxDegrees->checkState()==Qt::Checked)?180./itk::Math::pi:1.;
- rotSBs[i]->blockSignals(true);
- rotSBs[i]->setValue( euler->GetParameters()[i]*rad );
- rotSBs[i]->blockSignals(false);
- rotSliders[i]->blockSignals(true);
- rotSliders[i]->setValue( itk::Math::Round(euler->GetParameters()[i]*180./itk::Math::pi) );
- rotSliders[i]->blockSignals(false);
+ double angleDiff = euler->GetParameters()[i]-rotSBs[i]->value()/rad+2*itk::Math::pi;
+ angleDiff = angleDiff - 2*itk::Math::pi*itk::Math::Round<double,double>(angleDiff/(2*itk::Math::pi));
+ if(angleDiff>1.e-4) {
+ rotSBs[i]->blockSignals(true);
+ rotSBs[i]->setValue( euler->GetParameters()[i]*rad );
+ rotSBs[i]->blockSignals(false);
+ }
+ int iAngle = itk::Math::Round<int,double>(euler->GetParameters()[i]*180./itk::Math::pi);
+ if((iAngle-rotSliders[i]->value()+360)%360!=0) {
+ rotSliders[i]->blockSignals(true);
+ rotSliders[i]->setValue(iAngle);
+ rotSliders[i]->blockSignals(false);
+ }
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-void vvToolRigidReg::Render()
+void vvToolRigidReg::ExtentMax(const double pointExtent[8][4], double maxExtent[2][3])
{
- for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++)
+ double max, min;
+ for (int i=0; i<3; ++i) {
+ max = pointExtent[0][i];
+ min = pointExtent[0][i];
+ for (int j=1; j<8; ++j) {
+ if (pointExtent[j][i] > max) {
+ max = pointExtent[j][i];
+ }
+ if (pointExtent[j][i] < min) {
+ min = pointExtent[j][i];
+ }
+ }
+ maxExtent[0][i] = min;
+ maxExtent[1][i] = max;
+ }
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvToolRigidReg::Render()
+{ //out << __func__ << endl;
+#if VTK_MAJOR_VERSION > 5
+double translationValues[4], translationValuesUpdate[4];
+mCurrentSlicerManager->GetImage()->GetTransform()[0]->Print(cout);
+vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix();
+vtkMatrix4x4* matrixTranspose = matrix->NewInstance();
+for (int i=0; i<3; ++i) {
+ for (int j=0; j<3; ++j)
{
+ matrixTranspose->SetElement(i,j,matrix->GetElement(j,i));
+ }
+}
+for (int j=0; j<3; ++j)
+{
+ translationValues[j] = matrix->GetElement(j,3);
+}
+translationValues[3] = 0.0;
+matrix->MultiplyPoint(translationValues, translationValuesUpdate);
+for (int i=0; i<3; ++i) {
+ matrixTranspose->SetElement(i,3,translationValuesUpdate[i]);
+}
+for (int i=0; i<4; ++i) {
+ matrixTranspose->SetElement(3,i,matrix->GetElement(3,i));
+}
+
+#endif
+for (int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
+#if VTK_MAJOR_VERSION > 5
+ double pointExtent[8][4], pointExtentUpdate[8][4], pointOverlayExtent[8][4], pointOverlayExtentUpdate[8][4], centre[3], translation[3];
+ std::vector<int> w_ext;
+ w_ext=mCurrentSlicerManager->GetImage()->GetSize();
+ pointExtent[0][0] = 0.0;
+ pointExtent[0][1] = 0.0;
+ pointExtent[0][2] = 0.0;
+ pointExtent[0][3] = 1.0;
+ pointExtent[1][0] = w_ext[0]-1;
+ pointExtent[1][1] = w_ext[1]-1;
+ pointExtent[1][2] = w_ext[2]-1;
+ pointExtent[1][3] = 1.0;
+ pointExtent[2][0] = 0.0;
+ pointExtent[2][1] = w_ext[1]-1;
+ pointExtent[2][2] = w_ext[2]-1;
+ pointExtent[2][3] = 1.0;
+ pointExtent[3][0] = w_ext[0]-1;
+ pointExtent[3][1] = 0.0;
+ pointExtent[3][2] = w_ext[2]-1;
+ pointExtent[3][3] = 1.0;
+ pointExtent[4][0] = w_ext[0]-1;
+ pointExtent[4][1] = w_ext[1]-1;
+ pointExtent[4][2] = 0.0;
+ pointExtent[4][3] = 1.0;
+ pointExtent[5][0] = 0.0;
+ pointExtent[5][1] = 0.0;
+ pointExtent[5][2] = w_ext[2]-1;
+ pointExtent[5][3] = 1.0;
+ pointExtent[6][0] = 0.0;
+ pointExtent[6][1] = w_ext[1]-1;
+ pointExtent[6][2] = 0.0;
+ pointExtent[6][3] = 1.0;
+ pointExtent[7][0] = w_ext[0]-1;
+ pointExtent[7][1] = 0.0;
+ pointExtent[7][2] = 0.0;
+ pointExtent[7][3] = 1.0;
+
+ centre[0] = Xval->text().toDouble();
+ centre[1] = Yval->text().toDouble();
+ centre[2] = Zval->text().toDouble();
+
+ for (int k=0; k<8; ++k) {
+ for (int j=0; j<3; ++j)
+ {
+ pointOverlayExtent[k][j] = mCurrentSlicerManager->GetImage()->GetSpacing()[j]*pointExtent[k][j] - centre[j];
+ }
+ pointOverlayExtent[k][3] = 0.0;
+ matrixTranspose->MultiplyPoint(pointOverlayExtent[k], pointOverlayExtentUpdate[k]);
+ for (int j=0; j<3; ++j)
+ {
+ pointOverlayExtentUpdate[k][j] = (pointOverlayExtentUpdate[k][j] + centre[j])/mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+ cout << pointOverlayExtentUpdate[k][j] << " ";
+ }
+ cout << endl;
+ }
+ cout << endl;
+ for (int k=0; k<8; ++k) {
+ for (int j=0; j<3; ++j)
+ {
+ pointExtent[k][j] = mCurrentSlicerManager->GetImage()->GetSpacing()[j] * pointExtent[k][j];
+ }
+ matrixTranspose->MultiplyPoint(pointExtent[k], pointExtentUpdate[k]);
+ for (int j=0; j<3; ++j)
+ {
+ pointExtentUpdate[k][j] = (pointExtentUpdate[k][j])/mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+ cout << pointExtentUpdate[k][j] << " ";
+ }
+ cout << endl;
+ }
+ double extUpdateTemp[2][3], extOverlayUpdateTemp[2][3];
+ int extUpdate[6];
+ ExtentMax(pointExtentUpdate, extUpdateTemp);
+ ExtentMax(pointOverlayExtentUpdate, extOverlayUpdateTemp);
+ for (int j=0; j<3; ++j) {
+ extUpdate[2*j] = 0;
+ extUpdate[2*j+1] = itk::Math::Round<double>(extUpdateTemp[1][j] - extUpdateTemp[0][j]);
+ }
+ mCurrentSlicerManager->GetSlicer(i)->SetRegisterExtent(extUpdate);
+ extUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()] = mCurrentSlicerManager->GetSlicer(i)->GetSlice();
+ extUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()+1] = mCurrentSlicerManager->GetSlicer(i)->GetSlice();
+
+ vtkSmartPointer<vtkOpenGLImageSliceMapper> mapperOpenGL= vtkSmartPointer<vtkOpenGLImageSliceMapper>::New();
+ try {
+ mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(mCurrentSlicerManager->GetSlicer(i)->GetImageActor()->GetMapper());
+ } catch (const std::bad_cast& e) {
+ std::cerr << e.what() << std::endl;
+ std::cerr << "Conversion error" << std::endl;
+ return;
+ }
+ cout << extUpdate[0] << " " << extUpdate[1] << " " << extUpdate[2] << " " << extUpdate[3] << " " << extUpdate[4] << " " << extUpdate[5] << endl;
+ mapperOpenGL->SetCroppingRegion(extUpdate);
+
+ if (mCurrentSlicerManager->GetSlicer(i)->GetOverlay() && mCurrentSlicerManager->GetSlicer(i)->GetOverlayActor()->GetVisibility()) {
+ int extOverlayUpdate[6];
+ for (int j=0; j<3; ++j) { //Rotation
+ if (extOverlayUpdateTemp[1][j] - extOverlayUpdateTemp[0][j] > w_ext[j]-1) {
+ extOverlayUpdate[2*j] = 0;
+ extOverlayUpdate[2*j+1] = w_ext[j]-1;
+ } else {
+ extOverlayUpdate[2*j] = itk::Math::Round<double>(extOverlayUpdateTemp[0][j]);
+ extOverlayUpdate[2*j+1] = itk::Math::Round<double>(extOverlayUpdateTemp[1][j]);
+ }
+ }
+
+ //Compute translation
+ double pointOrigin[4], pointOriginUpdate[4];
+ for (int j=0; j<3; ++j)
+ {
+ pointOrigin[j] = 0 - centre[j];
+ }
+ pointOrigin[3] = 0.0;
+ matrix->MultiplyPoint(pointOrigin, pointOriginUpdate);
+ for (int j=0; j<3; ++j)
+ {
+ pointOriginUpdate[j] = (pointOriginUpdate[j] + centre[j])/mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+ translation[j] = matrix->GetElement(j,3) - pointOriginUpdate[j]*mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+ pointOrigin[j] = translation[j];
+ }
+ pointOrigin[3] = 0.0;
+ matrixTranspose->MultiplyPoint(pointOrigin, pointOriginUpdate);
+ for (int j=0; j<3; ++j)
+ {
+ translation[j] = pointOriginUpdate[j]/mCurrentSlicerManager->GetImage()->GetSpacing()[j];
+ }
+
+ for (int j=0; j<3; ++j) { //Translation
+ if (0 < extOverlayUpdateTemp[0][j] - translation[j]) {
+ extOverlayUpdate[2*j] = itk::Math::Round<double>(extOverlayUpdateTemp[0][j] - translation[j]);
+ } else {
+ extOverlayUpdate[2*j] = 0;
+ }
+ if (extOverlayUpdateTemp[1][j] - translation[j] < w_ext[j]-1) {
+ extOverlayUpdate[2*j+1] = itk::Math::Round<double>(extOverlayUpdateTemp[1][j] - translation[j]);
+ } else {
+ extOverlayUpdate[2*j+1] = w_ext[j]-1;
+ }
+ }
+ extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()] += mCurrentSlicerManager->GetSlicer(i)->GetSlice();
+ extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()+1] = extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()];
+ vtkSmartPointer<vtkOpenGLImageSliceMapper> mapperOpenGL= vtkSmartPointer<vtkOpenGLImageSliceMapper>::New();
+ try {
+ mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(mCurrentSlicerManager->GetSlicer(i)->GetOverlayActor()->GetMapper());
+ } catch (const std::bad_cast& e) {
+ std::cerr << e.what() << std::endl;
+ std::cerr << "Conversion error" << std::endl;
+ return;
+ }
+
+ //Slice number
+ double spacing[4],spacingUpdate[4];
+ int sliceNumber;
+ spacing[0] = 240*mCurrentSlicerManager->GetImage()->GetSpacing()[0]-centre[0];
+ spacing[1] = 179*mCurrentSlicerManager->GetImage()->GetSpacing()[1]-centre[1];
+ spacing[2] = 22*mCurrentSlicerManager->GetImage()->GetSpacing()[2]-centre[2];
+ spacing[3] = 0;
+ matrixTranspose->MultiplyPoint(spacing, spacingUpdate);
+ spacingUpdate[0] = (spacingUpdate[0]+centre[0])/mCurrentSlicerManager->GetImage()->GetSpacing()[0];
+ spacingUpdate[1] = (spacingUpdate[1]+centre[1])/mCurrentSlicerManager->GetImage()->GetSpacing()[1];
+ spacingUpdate[2] = (spacingUpdate[2]+centre[2])/mCurrentSlicerManager->GetImage()->GetSpacing()[2];
+ cout << spacingUpdate[0] << " " << spacingUpdate[1] << " " << spacingUpdate[2] << endl;
+ sliceNumber = mCurrentSlicerManager->GetSlicer(i)->GetSlice()*spacingUpdate[mCurrentSlicerManager->GetSlicer(i)->GetOrientation()]/mCurrentSlicerManager->GetImage()->GetSpacing()[mCurrentSlicerManager->GetSlicer(i)->GetOrientation()];
+ extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()] = 12;//sliceNumber;
+ extOverlayUpdate[2*mCurrentSlicerManager->GetSlicer(i)->GetOrientation()+1] = 12;//sliceNumber;
+
+ mapperOpenGL->SetCroppingRegion(extOverlayUpdate);
+ }
+#endif
mCurrentSlicerManager->GetSlicer(i)->ForceUpdateDisplayExtent();
mCurrentSlicerManager->GetSlicer(i)->Render();
- }
+}
}
//------------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff