--- /dev/null
+/**
+* Progam made by Olivier Bernard, associate professor
+* at Institut National des Sciences Appliquees (INSA) Lyon,
+* CREATIS Laboratory,
+* 69621 Villeurbanne, France,
+* 07th of May 2014
+*/
+
+#include "OpenHeartGui.h"
+
+#include <vtkObjectFactory.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderer.h>
+#include <vtkImageData.h>
+#include <vtkTextProperty.h>
+#include <vtkProperty.h>
+#include <vtkRendererCollection.h>
+#include <vtkRenderer.h>
+#include <vtkInteractorStyleTrackballCamera.h>
+#include <vtkCamera.h>
+#include <vtkImageGaussianSmooth.h>
+#include <vtkMarchingCubes.h>
+#include <vtkDataSetMapper.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkCutter.h>
+#include <vtkSphereSource.h>
+#include <vtkInteractorStyleSwitch.h>
+#include <vtkTextMapper.h>
+#include <vtkMath.h>
+#include <vtkMetaImageWriter.h>
+#include <vtkDepthSortPolyData.h>
+#include <vtkTimerLog.h>
+#include <vtkTransform.h>
+#include <vtkTransformPolyDataFilter.h>
+#include <vtkContextView.h>
+#include <vtkTable.h>
+#include <vtkFloatArray.h>
+#include <vtkChartXY.h>
+#include <vtkPlot.h>
+#include <vtkContextScene.h>
+#include <vtkAxis.h>
+#include <vtkCamera.h>
+#include <vtkAxesActor.h>
+#include <vtkOrientationMarkerWidget.h>
+#include <vtkCaptionActor2D.h>
+#include <vtkMetaImageReader.h>
+#include <vtkImageCast.h>
+#include <vtkUnstructuredGridReader.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkGenericDataObjectReader.h>
+#include <vtkCellArray.h>
+#include <vtkXMLPolyDataReader.h>
+#include <vtkPolyDataReader.h>
+#include <vtkUnstructuredGridGeometryFilter.h>
+#include <vtkDepthSortPolyData.h>
+#include <vtkLineSource.h>
+#include <vtkSmartPointer.h>
+#include <vtkIntersectionPolyDataFilter.h>
+#include <vtkTriangleFilter.h>
+#include <vtkImageData.h>
+#include <vtkImageReslice.h>
+#include <vtkImageMapper.h>
+#include <vtkSphereSource.h>
+#include <vtkLine.h>
+#include <vtkOutlineFilter.h>
+#include "vtkMyInteractorStyleTrackballCameraOpenHeart.h"
+#include "vtkMyInteractorStyleTrackballCameraOpenHeartXY.h"
+#include "vtkMyInteractorStyleTrackballCameraOpenHeartXZ.h"
+#include "vtkMyInteractorStyleTrackballCameraOpenHeartYZ.h"
+#include <QResizeEvent>
+#include <QPalette>
+
+
+#define CONFIG_FILE "../../Config/ConfigOpenHeart.txt"
+
+
+// ****************************************************************
+// ****************************************************************
+// ****************************************************************
+class vtkMyChartXY : public vtkChartXY
+{
+
+ bool MouseButtonPressEvent(const vtkContextMouseEvent &mouse) { return true; }
+ bool MouseWheelEvent(const vtkContextMouseEvent &mouse, int delta) { return true; }
+ bool MouseMoveEvent(const vtkContextMouseEvent &mouse) { return true; }
+ bool MouseButtonReleaseEvent(const vtkContextMouseEvent &mouse) { return true; }
+
+};
+
+
+// ****************************************************************
+// ****************************************************************
+// ****************************************************************
+OpenHeartGui::OpenHeartGui()
+{
+
+ /// Initialize window
+ this->setupUi(this);
+ this->InstantiateQtVtkRenderers();
+
+ /// Set colors of the interface
+ this->SetInterfaceColors();
+
+ /// Allocate attributes
+ for ( int k=0; k<3; k++ )
+ this->Dims[k] = 0;
+ this->PreviousFrame = 0;
+ this->CurrentFrame = 0;
+ this->NumberOfVolumes = 0;
+ this->ImageData = 0;
+ this->TableChart = 0;
+ this->Properties = new RendererProperties;
+ this->ViewButton = 0;
+ this->MeshRepresentation = 0;
+ this->MeshColor = 0;
+ this->ZoomLabel = 1.6;
+ this->ZoomMain = 1.5;
+ this->RotationMatrix = vtkSmartPointer<vtkMatrix4x4>::New();
+ this->RotationMatrix->Identity();
+ this->TransformViewOrientation = vtkSmartPointer<vtkTransform>::New();
+ this->RotationMatrixInv = vtkSmartPointer<vtkMatrix4x4>::New();
+ this->RotationMatrixInv->Identity();
+ this->TransformViewOrientationInv = vtkSmartPointer<vtkTransform>::New();
+ this->OrientationWidget = vtkSmartPointer<vtkOrientationMarkerWidget>::New();
+
+ /// Flag management
+ this->FlagInterpolation = 0;
+ this->FlagDisplayMesh = 0;
+ this->FlagDisplayMeshContours = 0;
+ this->FlagDisplayMeshContourX = 0;
+ this->FlagDisplayMeshContourY = 0;
+ this->FlagDisplayMeshContourZ = 0;
+ this->FlagLoopEndToBegin = 0;
+ this->FlagLoopBeginToEnd = 0;
+ this->FlagPlay = 0;
+ this->FlagDisplayText = 1;
+ this->FlagHidePlan = 0;
+ this->FlagLongAxis = 0;
+ this->FlagDisplayApexPoint = 0;
+ this->FlagDisplayBasalPoint = 0;
+ this->FlagDisplayMeshContours = 1;
+ this->FlagDisplayLongAxis = 0;
+ this->FlagReslice = 0;
+
+ /// Widget management
+ this->InitPickers();
+ this->InitProperties();
+ this->InitWidgets();
+ this->SetCustomInteractorStyle();
+
+ /// Read 3D volume and create corresponding OpenHeart
+ std::ifstream file(CONFIG_FILE, std::ifstream::in);
+ std::string inputFilename;
+ file >> inputFilename;
+ file >> this->NumberOfVolumes;
+
+ /// Load sequence of volumes
+ this->CreateFromSequenceDataPointer(inputFilename);
+
+ /// Manage main window display
+ /// Force to view XZ orientation at initialization
+ this->ForceXZView();
+
+ /// Initialize text displayed in the main window
+ this->InitTexts();
+
+ /// Initialize the orientation axes after rendering the volume
+ this->InitOrientationAxes();
+
+ /// Manage XY window display
+ this->qVTKXY->GetRenderWindow()->Render();
+
+ /// Manage XZ window display
+ this->qVTKXZ->GetRenderWindow()->Render();
+
+ /// Manage YZ window display
+ this->qVTKYZ->GetRenderWindow()->Render();
+
+ /// Manage scrollbar
+ this->scrollBar->setMaximum(this->NumberOfVolumes-1);
+ this->SliderMeshAlpha->setMaximum(100);
+ this->SliderMeshAlpha->setSingleStep(1);
+ this->SliderMeshAlpha->setValue(20);
+
+ /// Initialized the chart part of the interface
+ this->ViewChart = vtkSmartPointer<vtkContextView>::New();
+ this->ViewChart->SetInteractor(this->qVTKChart->GetInteractor());
+ this->qVTKChart->SetRenderWindow(this->ViewChart->GetRenderWindow());
+ this->qVTKChart->GetRenderWindow()->SetSize(478,478);
+ this->ViewChart->GetRenderer()->SetBackground(255./255.,255./255.,255./255.);
+ this->InitChar();
+
+ /// Instantiate timer for the player
+ Timer = new QTimer(this);
+
+ /// Instantiate Qt events
+ connect(this->scrollBar, SIGNAL(valueChanged(int)), this, SLOT(slotRefreshViewer(int)));
+ connect(this->SliderMeshAlpha, SIGNAL(valueChanged(int)), this, SLOT(slotMeshAlpha(int)));
+ connect(this->pushButtonPlay, SIGNAL(clicked()), this, SLOT(slotPlay()));
+ connect(this->pushButtonXY, SIGNAL(clicked()), this, SLOT(slotXYView()));
+ connect(this->pushButtonXZ, SIGNAL(clicked()), this, SLOT(slotXZView()));
+ connect(this->pushButtonYZ, SIGNAL(clicked()), this, SLOT(slotYZView()));
+ connect(this->pushButton3D, SIGNAL(clicked()), this, SLOT(slot3DView()));
+ connect(this->pushButtonMesh, SIGNAL(clicked()), this, SLOT(slotMeshView()));
+ connect(this->pushButtonMeshRepresentation, SIGNAL(clicked()), this, SLOT(slotMeshRepresentation()));
+ connect(this->pushButtonMeshColor, SIGNAL(clicked()), this, SLOT(slotMeshColor()));
+ connect(this->pushButtonCutter, SIGNAL(clicked()), this, SLOT(slotMeshCutter()));
+ connect(this->Timer, SIGNAL(timeout()), this, SLOT(slotTimerEvent()));
+ connect(this->tabWidgetOption, SIGNAL(currentChanged(int)), this, SLOT(slotTabChange(int)));
+ connect(this->pushButtonBasalPoint, SIGNAL(clicked()), this, SLOT(slotBasalPoint()));
+ connect(this->pushButtonApexPoint, SIGNAL(clicked()), this, SLOT(slotApexPoint()));
+ connect(this->pushButtonReslice, SIGNAL(clicked()), this, SLOT(slotReslice()));
+
+ /// Update coords as we move through the window
+ Connections = vtkEventQtSlotConnect::New();
+ Connections->Connect(this->qVTK->GetRenderWindow()->GetInteractor(),
+ vtkCommand::MouseMoveEvent,
+ this,
+ SLOT(slotUpdateCoords(vtkObject*)));
+
+}
+
+
+OpenHeartGui::~OpenHeartGui()
+{
+
+ Connections->Delete();
+
+}
+
+
+void OpenHeartGui::InstantiateQtVtkRenderers()
+{
+
+ /// ****************************************************************
+ /// Create the main window
+ vtkSmartPointer<vtkRenderWindow> renwin = vtkSmartPointer<vtkRenderWindow>::New();
+ renwin->StereoCapableWindowOn();
+
+ /// Activate 3DConnexion device
+ this->qVTK->SetUseTDx(true);
+ this->qVTK->SetRenderWindow(renwin);
+
+ /// Initialize interactor
+ this->Interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ this->Interactor = static_cast<vtkRenderWindowInteractor *>(this->qVTK->GetInteractor()->GetRenderWindow()->GetInteractor());
+
+ /// Add a renderer
+ this->Ren = vtkSmartPointer<vtkRenderer>::New();
+ this->qVTK->GetRenderWindow()->AddRenderer(this->Ren);
+ this->Ren->SetBackground(0,0,0);
+ this->Ren->GetActiveCamera()->SetParallelProjection(1);
+
+
+ /// ****************************************************************
+ /// Create XY window
+ vtkSmartPointer<vtkRenderWindow> renwinXY = vtkSmartPointer<vtkRenderWindow>::New();
+ renwinXY->StereoCapableWindowOn();
+
+ /// Activate 3DConnexion device
+ this->qVTKXY->SetUseTDx(true);
+ this->qVTKXY->SetRenderWindow(renwinXY);
+
+ /// Initialize interactor
+ this->InteractorXY = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ this->InteractorXY = static_cast<vtkRenderWindowInteractor *>(this->qVTKXY->GetInteractor()->GetRenderWindow()->GetInteractor());
+
+ /// Add a renderer
+ this->RenXY = vtkSmartPointer<vtkRenderer>::New();
+ this->qVTKXY->GetRenderWindow()->AddRenderer(this->RenXY);
+ this->RenXY->SetBackground(0,0,0);
+ this->RenXY->GetActiveCamera()->SetParallelProjection(1);
+
+
+ /// ****************************************************************
+ /// Create XZ window
+ vtkSmartPointer<vtkRenderWindow> renwinXZ = vtkSmartPointer<vtkRenderWindow>::New();
+ renwinXZ->StereoCapableWindowOn();
+
+ /// Activate 3DConnexion device
+ this->qVTKXZ->SetUseTDx(true);
+ this->qVTKXZ->SetRenderWindow(renwinXZ);
+
+ /// Initialize interactor
+ this->InteractorXZ = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ this->InteractorXZ = static_cast<vtkRenderWindowInteractor *>(this->qVTKXZ->GetInteractor()->GetRenderWindow()->GetInteractor());
+
+ /// Add a renderer
+ this->RenXZ = vtkSmartPointer<vtkRenderer>::New();
+ this->qVTKXZ->GetRenderWindow()->AddRenderer(this->RenXZ);
+ this->RenXZ->SetBackground(0,0,0);
+ this->RenXZ->GetActiveCamera()->SetParallelProjection(1);
+
+
+ /// ****************************************************************
+ /// Create YZ window
+ vtkSmartPointer<vtkRenderWindow> renwinYZ = vtkSmartPointer<vtkRenderWindow>::New();
+ renwinYZ->StereoCapableWindowOn();
+
+ /// Activate 3DConnexion device
+ this->qVTKYZ->SetUseTDx(true);
+ this->qVTKYZ->SetRenderWindow(renwinYZ);
+
+ /// Initialize interactor
+ this->InteractorYZ = static_cast<vtkRenderWindowInteractor *>(this->qVTKYZ->GetInteractor()->GetRenderWindow()->GetInteractor());
+
+ /// Add a renderer
+ this->RenYZ = vtkSmartPointer<vtkRenderer>::New();
+ this->qVTKYZ->GetRenderWindow()->AddRenderer(this->RenYZ);
+ this->RenYZ->SetBackground(0,0,0);
+ this->RenYZ->GetActiveCamera()->SetParallelProjection(1);
+
+}
+
+
+void OpenHeartGui::slotMeshView()
+{
+ this->HidePlanModeManagement();
+}
+
+
+void OpenHeartGui::slotYZView()
+{
+
+ this->ViewButton = 1;
+ this->Properties->xIPW->SetTextureVisibility(1);
+ this->Properties->xIPW->GetPlaneProperty()->SetOpacity(1);
+ this->Properties->xIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->yIPW->SetTextureVisibility(0);
+ this->Properties->yIPW->GetPlaneProperty()->SetOpacity(0);
+ this->Properties->yIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->zIPW->SetTextureVisibility(0);
+ this->Properties->zIPW->GetPlaneProperty()->SetOpacity(0);
+ this->Properties->zIPW->GetPlaneProperty()->SetColor(0,0,0);
+
+ if ( this->FlagHidePlan == 0 )
+ {
+
+ /// Update corresponding viewer
+ int view = 2;
+ this->UpdateViewer(view,this->ZoomMain,this->Ren);
+
+ /// Also update Slice text
+ int slice = (int)( (this->Properties->position[0] - this->ImageData->GetOrigin()[0]) / this->ImageData->GetSpacing()[0] + 0.5f );
+ QString strSlice;
+ strSlice.sprintf("Slice: %d",slice);
+ this->Properties->TextMapperSlice->SetInput(strSlice.toStdString().c_str());
+
+ }
+ else {
+ this->FlagHidePlan = 0;
+ }
+
+ if ( this->FlagDisplayMeshContours == 1 )
+ {
+ this->GetMeshRenderer()->AddActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->zCutActor);
+ this->GetRenderWindow()->Render();
+ }
+
+}
+
+
+void OpenHeartGui::slotXZView()
+{
+
+ this->ViewButton = 2;
+ this->Properties->xIPW->SetTextureVisibility(0);
+ this->Properties->xIPW->GetPlaneProperty()->SetOpacity(0);
+ this->Properties->xIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->yIPW->SetTextureVisibility(1);
+ this->Properties->yIPW->GetPlaneProperty()->SetOpacity(1);
+ this->Properties->yIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->zIPW->SetTextureVisibility(0);
+ this->Properties->zIPW->GetPlaneProperty()->SetOpacity(0);
+ this->Properties->zIPW->GetPlaneProperty()->SetColor(0,0,0);
+
+ if ( this->FlagHidePlan == 0 )
+ {
+
+ /// Update corresponding viewer
+ int view = 1;
+ this->UpdateViewer(view,this->ZoomMain,this->Ren);
+
+ /// Also update Slice text
+ int slice = (int)( (this->Properties->position[1] - this->ImageData->GetOrigin()[1]) / this->ImageData->GetSpacing()[1] + 0.5f );
+ QString strSlice;
+ strSlice.sprintf("Slice: %d",slice);
+ this->Properties->TextMapperSlice->SetInput(strSlice.toStdString().c_str());
+
+ }
+ else {
+ this->FlagHidePlan = 0;
+ }
+
+ if ( this->FlagDisplayMeshContours == 1 )
+ {
+ this->GetMeshRenderer()->RemoveActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->AddActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->zCutActor);
+ this->GetRenderWindow()->Render();
+ }
+
+}
+
+
+void OpenHeartGui::slotXYView()
+{
+
+ this->ViewButton = 3;
+ this->Properties->xIPW->SetTextureVisibility(0);
+ this->Properties->xIPW->GetPlaneProperty()->SetOpacity(0);
+ this->Properties->xIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->yIPW->SetTextureVisibility(0);
+ this->Properties->yIPW->GetPlaneProperty()->SetOpacity(0);
+ this->Properties->yIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->zIPW->SetTextureVisibility(1);
+ this->Properties->zIPW->GetPlaneProperty()->SetOpacity(1);
+ this->Properties->zIPW->GetPlaneProperty()->SetColor(0,0,0);
+
+ if ( this->FlagHidePlan == 0 )
+ {
+
+ /// Update corresponding viewer
+ int view = 0;
+ this->UpdateViewer(view,this->ZoomMain,this->Ren);
+
+ /// Also update Slice text
+ int slice = (int)( (this->Properties->position[2] - this->ImageData->GetOrigin()[2]) / this->ImageData->GetSpacing()[2] + 0.5f );
+ QString strSlice;
+ strSlice.sprintf("Slice: %d",slice);
+ this->Properties->TextMapperSlice->SetInput(strSlice.toStdString().c_str());
+
+ }
+ else {
+ this->FlagHidePlan = 0;
+ }
+
+ if ( this->FlagDisplayMeshContours == 1 )
+ {
+ this->GetMeshRenderer()->RemoveActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->AddActor(this->Properties->zCutActor);
+ this->GetRenderWindow()->Render();
+ }
+
+}
+
+
+void OpenHeartGui::slot3DView()
+{
+
+ this->ViewButton = 0;
+ this->Properties->xIPW->SetTextureVisibility(1);
+ this->Properties->xIPW->GetPlaneProperty()->SetOpacity(1);
+ this->Properties->xIPW->GetPlaneProperty()->SetColor(1,0,0);
+ this->Properties->yIPW->SetTextureVisibility(1);
+ this->Properties->yIPW->GetPlaneProperty()->SetOpacity(1);
+ this->Properties->yIPW->GetPlaneProperty()->SetColor(1,1,0);
+ this->Properties->zIPW->SetTextureVisibility(1);
+ this->Properties->zIPW->GetPlaneProperty()->SetOpacity(1);
+ this->Properties->zIPW->GetTextProperty()->SetColor(1,0,0);
+ this->Properties->zIPW->GetPlaneProperty()->SetColor(0,0,1);
+
+ if ( this->FlagHidePlan == 0 )
+ {
+
+ this->Ren->ResetCamera();
+ this->Ren->GetActiveCamera()->Zoom(1.);
+
+ if ( this->Properties->MeshActor != 0 )
+ {
+ if ( this->FlagDisplayMesh == 0 ) {
+ this->FlagDisplayMesh = 1;
+ this->GetMeshRenderer()->AddActor(this->Properties->MeshActor);
+ }
+ }
+
+ }
+ else {
+ this->FlagHidePlan = 0;
+ }
+ this->GetRenderWindow()->Render();
+
+}
+
+
+void OpenHeartGui::slotMeshRepresentation()
+{
+
+ if ( this->Properties->MeshActor )
+ {
+
+ if ( this->FlagDisplayMeshContours == 1 )
+ {
+ this->GetMeshRenderer()->RemoveActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->zCutActor);
+ this->FlagDisplayMeshContours = 0;
+ this->GetMeshRenderer()->AddActor(this->Properties->MeshActor);
+ this->FlagDisplayMesh = 1;
+ }
+ switch (this->MeshRepresentation) {
+ case 0:
+ this->MeshRepresentation = 1;
+ this->pushButtonMeshRepresentation->setText("Surface");
+ this->Properties->MeshActor->GetProperty()->SetRepresentationToPoints();
+ break;
+ case 1:
+ this->MeshRepresentation = 2;
+ this->pushButtonMeshRepresentation->setText("No mesh");
+ this->Properties->MeshActor->GetProperty()->SetRepresentationToSurface();
+ break;
+ case 2:
+ this->MeshRepresentation = 3;
+ this->pushButtonMeshRepresentation->setText("Wire");
+ this->GetMeshRenderer()->RemoveActor(this->Properties->MeshActor);
+ this->FlagDisplayMesh = 0;
+ break;
+ case 3:
+ this->MeshRepresentation = 0;
+ this->pushButtonMeshRepresentation->setText("Points");
+ this->Properties->MeshActor->GetProperty()->SetRepresentationToWireframe();
+ this->GetMeshRenderer()->AddActor(this->Properties->MeshActor);
+ this->FlagDisplayMesh = 1;
+ break;
+ default:
+ break;
+ }
+ this->GetRenderWindow()->Render();
+
+ }
+
+}
+
+
+
+void OpenHeartGui::slotMeshColor()
+{
+
+ if ( this->Properties->MeshActor ) {
+ if ( this->MeshColor == 0 ) {
+ this->MeshColor = 1;
+ this->pushButtonMeshColor->setText("Color R");
+ this->Properties->MeshActor->GetProperty()->SetColor(1,1,0);
+ //this->Properties->xCutActor->GetProperty()->SetColor(1,1,0);
+ //this->Properties->yCutActor->GetProperty()->SetColor(1,1,0);
+ //this->Properties->zCutActor->GetProperty()->SetColor(1,1,0);
+ }
+ else if ( this->MeshColor == 1 ) {
+ this->MeshColor = 2;
+ this->pushButtonMeshColor->setText("Color G");
+ this->Properties->MeshActor->GetProperty()->SetColor(1,0,0);
+ //this->Properties->xCutActor->GetProperty()->SetColor(1,0,0);
+ //this->Properties->yCutActor->GetProperty()->SetColor(1,0,0);
+ //this->Properties->zCutActor->GetProperty()->SetColor(1,0,0);
+ }
+ else if ( this->MeshColor == 2 ) {
+ this->MeshColor = 3;
+ this->pushButtonMeshColor->setText("Color B");
+ this->Properties->MeshActor->GetProperty()->SetColor(0,1,0);
+ //this->Properties->xCutActor->GetProperty()->SetColor(0,1,0);
+ //this->Properties->yCutActor->GetProperty()->SetColor(0,1,0);
+ //this->Properties->zCutActor->GetProperty()->SetColor(0,1,0);
+ }
+ else if ( this->MeshColor == 3 ) {
+ this->MeshColor = 4;
+ this->pushButtonMeshColor->setText("Color W");
+ this->Properties->MeshActor->GetProperty()->SetColor(0,0,1);
+ //this->Properties->xCutActor->GetProperty()->SetColor(0,0,1);
+ //this->Properties->yCutActor->GetProperty()->SetColor(0,0,1);
+ //this->Properties->zCutActor->GetProperty()->SetColor(0,0,1);
+ }
+ else if ( this->MeshColor == 4 ) {
+ this->MeshColor = 0;
+ this->pushButtonMeshColor->setText("Color Y");
+ this->Properties->MeshActor->GetProperty()->SetColor(1,1,1);
+ //this->Properties->xCutActor->GetProperty()->SetColor(1,1,1);
+ //this->Properties->yCutActor->GetProperty()->SetColor(1,1,1);
+ //this->Properties->zCutActor->GetProperty()->SetColor(1,1,1);
+ }
+ this->GetRenderWindow()->Render();
+ }
+
+}
+
+
+void OpenHeartGui::slotMeshCutter()
+{
+
+ if ( this->Properties->MeshActor )
+ {
+ if ( this->FlagDisplayMeshContours == 1 )
+ {
+ this->FlagDisplayMeshContours = 0;
+ this->pushButtonCutter->setText("Cut on");
+ this->GetMeshRenderer()->RemoveActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->zCutActor);
+ if ( this->FlagDisplayMesh == 0 ) {
+ this->FlagDisplayMesh = 1;
+ this->GetMeshRenderer()->AddActor(this->Properties->MeshActor);
+ }
+ }
+ else
+ {
+ if ( this->FlagDisplayMesh == 1 ) {
+ this->FlagDisplayMesh = 0;
+ this->GetMeshRenderer()->RemoveActor(this->Properties->MeshActor);
+ }
+ this->FlagDisplayMeshContours = 1;
+ this->pushButtonCutter->setText("Cut off");
+ switch (this->ViewButton) {
+ case 0:
+ this->GetMeshRenderer()->AddActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->AddActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->AddActor(this->Properties->zCutActor);
+ break;
+ case 1:
+ this->GetMeshRenderer()->AddActor(this->Properties->xCutActor);
+ break;
+ case 2:
+ this->GetMeshRenderer()->AddActor(this->Properties->yCutActor);
+ break;
+ case 3:
+ this->GetMeshRenderer()->AddActor(this->Properties->zCutActor);
+ break;
+ default:
+ break;
+ }
+ /*
+ if (this->ViewButton == 0) {
+ this->GetMeshRenderer()->AddActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->AddActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->AddActor(this->Properties->zCutActor);
+ }
+ else if (this->ViewButton == 1) {
+ this->GetMeshRenderer()->AddActor(this->Properties->xCutActor);
+ }
+ else if (this->ViewButton == 2) {
+ this->GetMeshRenderer()->AddActor(this->Properties->yCutActor);
+ }
+ else if (this->ViewButton == 3) {
+ this->GetMeshRenderer()->AddActor(this->Properties->zCutActor);
+ }
+ */
+ }
+ this->GetRenderWindow()->Render();
+ }
+
+
+}
+
+
+void OpenHeartGui::ForceXZView()
+{
+
+ this->ViewButton = 2;
+ this->Properties->xIPW->SetTextureVisibility(0);
+ this->Properties->xIPW->GetPlaneProperty()->SetOpacity(0);
+ this->Properties->yIPW->SetTextureVisibility(1);
+ this->Properties->yIPW->GetPlaneProperty()->SetOpacity(1);
+ this->Properties->zIPW->SetTextureVisibility(0);
+ this->Properties->zIPW->GetPlaneProperty()->SetOpacity(0);
+
+ this->Ren->GetActiveCamera()->SetFocalPoint( this->ImageData->GetDimensions()[0]/2,
+ this->ImageData->GetDimensions()[0]/2,
+ this->ImageData->GetDimensions()[2]/2 );
+ this->Ren->GetActiveCamera()->SetPosition( this->ImageData->GetDimensions()[0]/2,
+ this->ImageData->GetDimensions()[1]*10,
+ this->ImageData->GetDimensions()[0]/2 );
+ this->Ren->GetActiveCamera()->SetViewUp(0,0,-1);
+ this->Ren->ResetCamera();
+ this->Ren->GetActiveCamera()->Zoom(this->ZoomMain);
+ this->GetRenderWindow()->Render();
+
+}
+
+void OpenHeartGui::slotUpdateCoords(vtkObject* obj)
+{
+
+ if (this->FlagPlay == 0)
+ {
+
+ if ( (this->FlagDisplayText) && (this->Properties->TextMapperPixel) )
+ {
+
+ /// Get interactor
+ vtkRenderWindowInteractor* iren = vtkRenderWindowInteractor::SafeDownCast(obj);
+
+ // Get intensity value at the corresponding position
+ int X = iren->GetEventPosition()[0];
+ int Y = iren->GetEventPosition()[1];
+ this->Picker->Pick(X,Y,0.0,this->GetMeshRenderer());
+ double pos[3];
+ this->Picker->GetPickPosition( pos );
+ int pixel[3];
+ for ( int i=0; i<3; i++) {
+ pixel[i] = (int)( (pos[i] - this->ImageData->GetOrigin()[i]) / this->ImageData->GetSpacing()[i] + 0.5f );
+ }
+
+ if ( (pixel[0]>=0) && (pixel[0]<this->Dims[0]) &&
+ (pixel[1]>=0) && (pixel[1]<this->Dims[1]) &&
+ (pixel[2]>=0) && (pixel[2]<this->Dims[2]) )
+ {
+
+ /// Display Pixel coordinates
+ QString strPixel;
+ strPixel.sprintf("pixel: (%d %d %d)", pixel[0], pixel[1], pixel[2]);
+ this->Properties->TextMapperPixel->SetInput(strPixel.toStdString().c_str());
+
+ /// Display Pixel coordinates
+ QString strMM;
+ strMM.sprintf("mm: (%.0f %.0f %.0f)", pos[0]*1000, pos[1]*1000, pos[2]*1000);
+ this->Properties->TextMapperMM->SetInput(strMM.toStdString().c_str());
+
+ QString strValue;
+ switch (this->ImageData->GetScalarType())
+ {
+ case VTK_UNSIGNED_CHAR: {
+ strValue.sprintf("data value: %u", static_cast<unsigned char*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+ case VTK_UNSIGNED_SHORT: {
+ strValue.sprintf("data value: %u", static_cast<unsigned short*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+ case VTK_INT: {
+ strValue.sprintf("data value: %d", static_cast<int*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+ case VTK_FLOAT: {
+ strValue.sprintf("data value: %.1f", static_cast<float*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+ case VTK_DOUBLE: {
+ strValue.sprintf("data value: %.1f", static_cast<double*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+
+ }
+ this->Properties->TextMapperValue->SetInput(strValue.toStdString().c_str());
+
+ }
+
+ else {
+ this->Properties->TextMapperPixel->SetInput("");
+ this->Properties->TextMapperMM->SetInput("");
+ this->Properties->TextMapperValue->SetInput("");
+ }
+
+ }
+
+ else
+ {
+ if ( this->Properties->TextMapperPixel )
+ {
+ this->Properties->TextMapperPixel->SetInput("");
+ this->Properties->TextMapperMM->SetInput("");
+ this->Properties->TextMapperValue->SetInput("");
+ }
+ }
+
+ this->GetRenderWindow()->Render();
+
+ }
+
+}
+
+
+void OpenHeartGui::UpdateCoords(double *pos)
+{
+
+ if (this->FlagPlay == 0)
+ {
+
+ if ( (this->FlagDisplayText) && (this->Properties->TextMapperPixel) )
+ {
+
+ int pixel[3];
+ for ( int i=0; i<3; i++) {
+ pixel[i] = (int)( (pos[i] - this->ImageData->GetOrigin()[i]) / this->ImageData->GetSpacing()[i] + 0.5f );
+ }
+
+ if ( (pixel[0]>=0) && (pixel[0]<this->Dims[0]) &&
+ (pixel[1]>=0) && (pixel[1]<this->Dims[1]) &&
+ (pixel[2]>=0) && (pixel[2]<this->Dims[2]) )
+ {
+
+ /// Display Pixel coordinates
+ QString strPixel;
+ strPixel.sprintf("pixel: (%d %d %d)", pixel[0], pixel[1], pixel[2]);
+ this->Properties->TextMapperPixel->SetInput(strPixel.toStdString().c_str());
+
+ /// Display Pixel coordinates
+ QString strMM;
+ strMM.sprintf("mm: (%.0f %.0f %.0f)", pos[0]*1000, pos[1]*1000, pos[2]*1000);
+ this->Properties->TextMapperMM->SetInput(strMM.toStdString().c_str());
+
+ QString strValue;
+ switch (this->ImageData->GetScalarType())
+ {
+ case VTK_UNSIGNED_CHAR: {
+ strValue.sprintf("data value: %u", static_cast<unsigned char*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+ case VTK_UNSIGNED_SHORT: {
+ strValue.sprintf("data value: %u", static_cast<unsigned short*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+ case VTK_INT: {
+ strValue.sprintf("data value: %d", static_cast<int*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+ case VTK_FLOAT: {
+ strValue.sprintf("data value: %.1f", static_cast<float*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+ case VTK_DOUBLE: {
+ strValue.sprintf("data value: %.1f", static_cast<double*>(this->ImageData->GetScalarPointer(pixel))[0]);
+ break;
+ }
+ }
+ this->Properties->TextMapperValue->SetInput(strValue.toStdString().c_str());
+
+ }
+
+ else {
+ this->Properties->TextMapperPixel->SetInput("");
+ this->Properties->TextMapperMM->SetInput("");
+ this->Properties->TextMapperValue->SetInput("");
+ }
+
+ }
+ else
+ {
+ if ( this->Properties->TextMapperPixel )
+ {
+ this->Properties->TextMapperPixel->SetInput("");
+ this->Properties->TextMapperMM->SetInput("");
+ this->Properties->TextMapperValue->SetInput("");
+ }
+ }
+
+ this->GetRenderWindow()->Render();
+
+ }
+
+}
+
+
+void OpenHeartGui::InitChar()
+{
+
+ this->TableChart = vtkSmartPointer<vtkTable>::New();
+ vtkSmartPointer<vtkFloatArray> arrX = vtkSmartPointer<vtkFloatArray>::New();
+ arrX->SetName("Number of frames");
+ this->TableChart->AddColumn(arrX);
+ vtkSmartPointer<vtkFloatArray> arrY = vtkSmartPointer<vtkFloatArray>::New();
+ arrY->SetName("Volume");
+ this->TableChart->AddColumn(arrY);
+
+ int numPoints = this->NumberOfVolumes;
+ this->TableChart->SetNumberOfRows(numPoints);
+ for (int i=0; i<numPoints; ++i)
+ {
+ this->TableChart->SetValue(i, 0, i);
+ this->TableChart->SetValue(i, 1, 0);
+ }
+ // Add multiple line plots, setting the colors etc
+ vtkSmartPointer<vtkChartXY> chart = vtkSmartPointer<vtkChartXY>::New();
+ ViewChart->GetScene()->AddItem(chart);
+ chart->AddPlot(vtkChart::LINE);
+ vtkPlot *line = chart->AddPlot(vtkChart::LINE);
+ line->SetInput(this->TableChart, 0, 1);
+ line->SetColor(0, 0, 255, 255);
+ line->SetWidth(3.0);
+ chart->GetAxis(vtkAxis::LEFT)->SetTitle("Volume (mL)");
+ chart->GetAxis(vtkAxis::BOTTOM)->SetTitle("Frames");
+ chart->GetAxis(vtkAxis::LEFT)->SetNotation(2);
+ chart->GetAxis(vtkAxis::LEFT)->SetPrecision(1);
+
+}
+
+
+void OpenHeartGui::InitPickers()
+{
+ this->Picker = vtkSmartPointer<vtkCellPicker>::New();
+ this->Picker->SetTolerance(0.005);
+ this->Interactor->SetPicker(this->Picker);
+ this->PickerXY = vtkSmartPointer<vtkCellPicker>::New();
+ this->PickerXY->SetTolerance(0.005);
+ this->InteractorXY->SetPicker(this->PickerXY);
+ this->PickerXZ = vtkSmartPointer<vtkCellPicker>::New();
+ this->PickerXZ->SetTolerance(0.005);
+ this->InteractorXZ->SetPicker(this->PickerXZ);
+ this->PickerYZ = vtkSmartPointer<vtkCellPicker>::New();
+ this->PickerYZ->SetTolerance(0.005);
+ this->InteractorYZ->SetPicker(this->PickerYZ);
+
+}
+
+
+
+void OpenHeartGui::InitWidgets()
+{
+ /// ImagePlane Widget
+ this->InitPlaneWidget();
+}
+
+
+void OpenHeartGui::InitOrientationAxes()
+{
+ vtkSmartPointer<vtkAxesActor> axes = vtkSmartPointer<vtkAxesActor>::New();
+ axes->GetYAxisTipProperty()->SetColor(1,1,0);
+ axes->GetYAxisShaftProperty()->SetColor(1,1,0);
+ this->OrientationWidget->SetOrientationMarker( axes );
+ this->OrientationWidget->SetInteractor( this->qVTK->GetRenderWindow()->GetInteractor() );
+ this->OrientationWidget->SetViewport( 0.8, 0.0, 1.0, 0.2 );
+ this->OrientationWidget->SetEnabled( 1 );
+ this->OrientationWidget->InteractiveOff();
+}
+
+
+void OpenHeartGui::InitProperties()
+{
+ this->Properties->lut = 0;
+ this->Properties->xIPW = 0;
+ this->Properties->yIPW = 0;
+ this->Properties->zIPW = 0;
+ this->Properties->xyIPW = 0;
+ this->Properties->xzIPW = 0;
+ this->Properties->yzIPW = 0;
+ this->Properties->TextActorPixel = 0;
+ this->Properties->TextMapperPixel = 0;
+ this->Properties->TextActorMM = 0;
+ this->Properties->TextMapperMM = 0;
+ this->Properties->TextActorValue = 0;
+ this->Properties->TextMapperValue = 0;
+ this->Properties->TextActorSlice = 0;
+ this->Properties->TextMapperSlice = 0;
+ this->Properties->TextActorNumFrame = 0;
+ this->Properties->TextMapperNumFrame = 0;
+ this->Properties->TextActorResolution = 0;
+ this->Properties->TextMapperResolution = 0;
+ this->Properties->MeshActor = 0;
+ this->Properties->xCutActor = 0;
+ this->Properties->yCutActor = 0;
+ this->Properties->zCutActor = 0;
+ this->Properties->BasalPointActor = 0;
+ this->Properties->ApexPointActor = 0;
+ this->Properties->LongAxisActor = 0;
+ this->Properties->BoundingBoxActor = 0;
+ this->Properties->position = new double[3];
+}
+
+
+void OpenHeartGui::InitPlaneWidget()
+{
+
+ /// Manage main window
+ this->Properties->xIPW = vtkSmartPointer<vtkImagePlaneWidget>::New();
+ this->Properties->yIPW = vtkSmartPointer<vtkImagePlaneWidget>::New();
+ this->Properties->zIPW = vtkSmartPointer<vtkImagePlaneWidget>::New();
+
+ this->Properties->xIPW->SetInteractor(vtkRenderWindowInteractor::New());
+ this->Properties->yIPW->SetInteractor(this->Properties->xIPW->GetInteractor());
+ this->Properties->zIPW->SetInteractor(this->Properties->xIPW->GetInteractor());
+
+ this->Properties->xIPW->DisplayTextOn();
+ this->Properties->xIPW->GetTextProperty()->SetColor(0,0,0);
+ this->Properties->xIPW->SetPicker(this->Picker);
+ this->Properties->xIPW->RestrictPlaneToVolumeOn();
+ this->Properties->xIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->xIPW->SetResliceInterpolateToNearestNeighbour();
+ this->Properties->xIPW->TextureInterpolateOff();
+
+ this->Properties->yIPW->DisplayTextOn();
+ this->Properties->yIPW->GetTextProperty()->SetColor(0,0,0);
+ this->Properties->yIPW->SetPicker(this->Picker);
+ this->Properties->yIPW->RestrictPlaneToVolumeOn();
+ this->Properties->yIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->yIPW->SetTexturePlaneProperty(this->Properties->xIPW->GetTexturePlaneProperty());
+ this->Properties->yIPW->SetResliceInterpolateToNearestNeighbour();
+ this->Properties->yIPW->TextureInterpolateOff();
+
+ this->Properties->zIPW->DisplayTextOn();
+ this->Properties->zIPW->GetTextProperty()->SetColor(0,0,0);
+ this->Properties->zIPW->SetPicker(this->Picker);
+ this->Properties->zIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->zIPW->SetTexturePlaneProperty(this->Properties->xIPW->GetTexturePlaneProperty());
+ this->Properties->zIPW->SetResliceInterpolateToNearestNeighbour();
+ this->Properties->zIPW->TextureInterpolateOff();
+
+
+ /// Manage XY window
+ this->Properties->xyIPW = vtkImagePlaneWidget::New();
+ this->Properties->xyIPW->SetInteractor(vtkRenderWindowInteractor::New());
+ this->Properties->xyIPW->DisplayTextOn();
+ this->Properties->xyIPW->GetTextProperty()->SetColor(0,0,0);
+ this->Properties->xyIPW->SetPicker(this->PickerXY);
+ this->Properties->xyIPW->RestrictPlaneToVolumeOn();
+ this->Properties->xyIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->xyIPW->SetResliceInterpolateToNearestNeighbour();
+ this->Properties->xyIPW->TextureInterpolateOff();
+
+ /// Manage XZ window
+ this->Properties->xzIPW = vtkImagePlaneWidget::New();
+ this->Properties->xzIPW->SetInteractor(vtkRenderWindowInteractor::New());
+ this->Properties->xzIPW->DisplayTextOn();
+ this->Properties->xzIPW->GetTextProperty()->SetColor(0,0,0);
+ this->Properties->xzIPW->RestrictPlaneToVolumeOn();
+ this->Properties->xzIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->xzIPW->SetResliceInterpolateToNearestNeighbour();
+ this->Properties->xzIPW->TextureInterpolateOff();
+
+ /// Manage YZ window
+ this->Properties->yzIPW = vtkImagePlaneWidget::New();
+ this->Properties->yzIPW->SetInteractor(vtkRenderWindowInteractor::New());
+ this->Properties->yzIPW->DisplayTextOn();
+ this->Properties->yzIPW->GetTextProperty()->SetColor(0,0,0);
+ this->Properties->yzIPW->RestrictPlaneToVolumeOn();
+ this->Properties->yzIPW->GetPlaneProperty()->SetColor(0,0,0);
+ this->Properties->yzIPW->SetResliceInterpolateToNearestNeighbour();
+ this->Properties->yzIPW->TextureInterpolateOff();
+
+}
+
+void OpenHeartGui::InitTexts()
+{
+
+ /// Display pixel coordinates
+ this->Properties->TextActorPixel = vtkSmartPointer<vtkActor2D>::New();
+ this->Properties->TextMapperPixel = vtkSmartPointer<vtkTextMapper>::New();
+ this->Properties->TextMapperPixel->GetTextProperty()->SetColor(0, 1, 0);
+ this->Properties->TextMapperPixel->GetTextProperty()->SetFontSize(15);
+ if ( this->FlagDisplayText ) {
+ this->Properties->TextMapperPixel->SetInput("");
+ }
+ this->Properties->TextMapperPixel->GetTextProperty()->SetJustificationToRight();
+ this->Properties->TextMapperPixel->GetTextProperty()->ShadowOff();
+ this->Properties->TextActorPixel->SetPosition(490,520);
+ this->Properties->TextActorPixel->SetMapper(this->Properties->TextMapperPixel);
+ this->GetMeshRenderer()->AddActor(this->Properties->TextActorPixel);
+
+ /// Display mm coordinates
+ this->Properties->TextActorMM = vtkSmartPointer<vtkActor2D>::New();
+ this->Properties->TextMapperMM= vtkSmartPointer<vtkTextMapper>::New();
+ this->Properties->TextMapperMM->GetTextProperty()->SetColor(0, 1, 0);
+ this->Properties->TextMapperMM->GetTextProperty()->SetFontSize(15);
+ if ( this->FlagDisplayText ) {
+ this->Properties->TextMapperMM->SetInput("");
+ }
+ this->Properties->TextMapperMM->GetTextProperty()->SetJustificationToRight();
+ this->Properties->TextMapperMM->GetTextProperty()->ShadowOff();
+ this->Properties->TextActorMM->SetPosition(490,495);
+ this->Properties->TextActorMM->SetMapper(this->Properties->TextMapperMM);
+ this->GetMeshRenderer()->AddActor(this->Properties->TextActorMM);
+
+ /// Display data value
+ this->Properties->TextActorValue = vtkSmartPointer<vtkActor2D>::New();
+ this->Properties->TextMapperValue = vtkSmartPointer<vtkTextMapper>::New();
+ this->Properties->TextMapperValue->GetTextProperty()->SetColor(0, 1, 0);
+ this->Properties->TextMapperValue->GetTextProperty()->SetFontSize(15);
+ if ( this->FlagDisplayText ) {
+ this->Properties->TextMapperValue->SetInput("");
+ }
+ this->Properties->TextMapperValue->GetTextProperty()->SetJustificationToRight();
+ this->Properties->TextMapperValue->GetTextProperty()->ShadowOff();
+ this->Properties->TextActorValue->SetPosition(490,470);
+ this->Properties->TextActorValue->SetMapper(this->Properties->TextMapperValue);
+ this->GetMeshRenderer()->AddActor(this->Properties->TextActorValue);
+
+ /// Display Slice
+ this->Properties->TextActorSlice = vtkSmartPointer<vtkActor2D>::New();
+ this->Properties->TextMapperSlice = vtkSmartPointer<vtkTextMapper>::New();
+ this->Properties->TextMapperSlice->GetTextProperty()->SetColor(0, 1, 0);
+ this->Properties->TextMapperSlice->GetTextProperty()->SetFontSize(15);
+ if ( this->FlagDisplayText ) {
+ int slice = (int)( (this->Properties->position[1] - this->ImageData->GetOrigin()[1]) / this->ImageData->GetSpacing()[1] + 0.5f );
+ //cout << this->Properties->position[1] << endl;
+ QString strSlice;
+ strSlice.sprintf("Slice: %d",slice);
+ this->Properties->TextMapperSlice->SetInput(strSlice.toStdString().c_str());
+ }
+ this->Properties->TextMapperSlice->GetTextProperty()->SetJustificationToLeft();
+ this->Properties->TextMapperSlice->GetTextProperty()->ShadowOff();
+ this->Properties->TextActorSlice->SetPosition(10,520);
+ this->Properties->TextActorSlice->SetMapper(this->Properties->TextMapperSlice);
+ this->GetMeshRenderer()->AddActor(this->Properties->TextActorSlice);
+
+ /// Display frame number
+ this->Properties->TextActorNumFrame = vtkSmartPointer<vtkActor2D>::New();
+ this->Properties->TextMapperNumFrame = vtkSmartPointer<vtkTextMapper>::New();
+ this->Properties->TextMapperNumFrame->GetTextProperty()->SetColor(0, 1, 0);
+ this->Properties->TextMapperNumFrame->GetTextProperty()->SetFontSize(15);
+ if ( this->FlagDisplayText ) {
+ QString str;
+ str.sprintf("Frame: %d",this->CurrentFrame);
+ this->Properties->TextMapperNumFrame->SetInput(str.toStdString().c_str());
+ }
+ this->Properties->TextMapperNumFrame->GetTextProperty()->SetJustificationToLeft();
+ this->Properties->TextMapperNumFrame->GetTextProperty()->ShadowOff();
+ this->Properties->TextActorNumFrame->SetPosition(10, 45);
+ this->Properties->TextActorNumFrame->SetMapper(this->Properties->TextMapperNumFrame);
+ this->GetMeshRenderer()->AddActor(this->Properties->TextActorNumFrame);
+
+ /// Display resolution value
+ this->Properties->TextActorResolution = vtkSmartPointer<vtkActor2D>::New();
+ this->Properties->TextMapperResolution = vtkSmartPointer<vtkTextMapper>::New();
+ this->Properties->TextMapperResolution->GetTextProperty()->SetColor(0, 1, 0);
+ this->Properties->TextMapperResolution->GetTextProperty()->SetFontSize(15);
+ if ( this->FlagDisplayText ) {
+ QString str;
+ str.sprintf("Resolution: %.2f x %.2f x %.2f mm",this->ImageData->GetSpacing()[0]*1000,this->ImageData->GetSpacing()[1]*1000,this->ImageData->GetSpacing()[2]*1000);
+ this->Properties->TextMapperResolution->SetInput(str.toStdString().c_str());
+ }
+ this->Properties->TextMapperResolution->GetTextProperty()->SetJustificationToLeft();
+ this->Properties->TextMapperResolution->GetTextProperty()->ShadowOff();
+ this->Properties->TextActorResolution->SetPosition(10, 20);
+ this->Properties->TextActorResolution->SetMapper(this->Properties->TextMapperResolution);
+ this->GetMeshRenderer()->AddActor(this->Properties->TextActorResolution);
+
+}
+
+
+void OpenHeartGui::SetCustomInteractorStyle()
+{
+
+ /// customize main interactor
+ vtkSmartPointer<vtkMyInteractorStyleTrackballCameraOpenHeart> CustomInteractorStyle =
+ vtkSmartPointer<vtkMyInteractorStyleTrackballCameraOpenHeart>::New();
+ CustomInteractorStyle->SetOpenHeartGui( this );
+ this->Interactor->SetInteractorStyle(CustomInteractorStyle);
+
+ /// customize XY interactor
+ vtkSmartPointer<vtkMyInteractorStyleTrackballCameraOpenHeartXY> CustomInteractorStyleXY =
+ vtkSmartPointer<vtkMyInteractorStyleTrackballCameraOpenHeartXY>::New();
+ CustomInteractorStyleXY->SetOpenHeartGui( this );
+ this->InteractorXY->SetInteractorStyle(CustomInteractorStyleXY);
+
+ /// customize XZ interactor
+ vtkSmartPointer<vtkMyInteractorStyleTrackballCameraOpenHeartXZ> CustomInteractorStyleXZ =
+ vtkSmartPointer<vtkMyInteractorStyleTrackballCameraOpenHeartXZ>::New();
+ CustomInteractorStyleXZ->SetOpenHeartGui( this );
+ this->InteractorXZ->SetInteractorStyle(CustomInteractorStyleXZ);
+
+ /// customize YZ interactor
+ vtkSmartPointer<vtkMyInteractorStyleTrackballCameraOpenHeartYZ> CustomInteractorStyleYZ =
+ vtkSmartPointer<vtkMyInteractorStyleTrackballCameraOpenHeartYZ>::New();
+ CustomInteractorStyleYZ->SetOpenHeartGui( this );
+ this->InteractorYZ->SetInteractorStyle(CustomInteractorStyleYZ);
+
+}
+
+
+void OpenHeartGui::CreateFromSequenceDataPointer(std::string inputFilename)
+{
+
+ /// Read 3D volume
+ QString str;
+ for (int i=1; i<=this->NumberOfVolumes; i++)
+ {
+ if (i<10)
+ str.sprintf("%s0%d.mhd",inputFilename.c_str(),i);
+ else
+ str.sprintf("%s%d.mhd",inputFilename.c_str(),i);
+ vtkMetaImageReader *reader = vtkMetaImageReader::New();
+ reader->SetFileName(str.toStdString().c_str());
+ reader->Update();
+ this->StackVolume.push_back(reader->GetOutput());
+ }
+
+ /// Initialize attibute related to stack of volumes
+ this->itStackVolume = this->StackVolume.begin();
+ this->CurrentFrame = 0;
+ this->ImageData = (*this->itStackVolume);
+ double center[3];
+ for ( unsigned int k=0; k<3; k++ ) {
+ this->Dims[k] = this->ImageData->GetDimensions()[k];
+ center[k] = ((this->ImageData->GetDimensions()[k])*(this->ImageData->GetSpacing()[k]))/2;
+ }
+
+ /// Allocate lookuptable
+ double range[2];
+ this->ImageData->GetScalarRange(range);
+ int NumberOfColors = vtkMath::Round(range[1]-range[0]);
+ NumberOfColors++;
+ this->Properties->lut = vtkSmartPointer<vtkLookupTable>::New();
+ this->Properties->lut->SetNumberOfColors(NumberOfColors);
+ this->Properties->lut->SetValueRange(range[0]/NumberOfColors,range[1]/NumberOfColors);
+ this->Properties->lut->SetRampToLinear();
+ this->Properties->lut->SetSaturationRange(0.,0.);
+ this->Properties->lut->SetHueRange(0.,0.);
+
+ /// Manage main window
+ this->Properties->xIPW->SetCurrentRenderer(this->GetMainRenderer());
+ this->Properties->yIPW->SetCurrentRenderer(this->GetMainRenderer());
+ this->Properties->zIPW->SetCurrentRenderer(this->GetMainRenderer());
+
+ /// The 3 image plane widgets are used.
+ this->Properties->xIPW->SetInput(this->ImageData);
+ this->Properties->yIPW->SetInput(this->ImageData);
+ this->Properties->zIPW->SetInput(this->ImageData);
+
+ this->Properties->xIPW->SetPlaneOrientationToXAxes();
+ this->Properties->yIPW->SetPlaneOrientationToYAxes();
+ this->Properties->zIPW->SetPlaneOrientationToZAxes();
+
+ this->Properties->xIPW->SetSlicePosition(center[0]);
+ this->Properties->yIPW->SetSlicePosition(center[1]);
+ this->Properties->zIPW->SetSlicePosition(center[2]);
+
+ this->Properties->xIPW->SetLookupTable(this->Properties->lut);
+ this->Properties->yIPW->SetLookupTable(this->Properties->lut);
+ this->Properties->zIPW->SetLookupTable(this->Properties->lut);
+
+ this->Properties->position[0] = center[0];
+ this->Properties->position[1] = center[1];
+ this->Properties->position[2] = center[2];
+
+ this->Properties->xIPW->On();
+ this->Properties->yIPW->On();
+ this->Properties->zIPW->On();
+
+ /// Manage XY window
+ this->Properties->xyIPW->SetCurrentRenderer(this->GetXYRenderer());
+ this->Properties->xyIPW->SetInput(this->ImageData);
+ this->Properties->xyIPW->SetPlaneOrientationToZAxes();
+ this->Properties->xyIPW->SetSlicePosition(center[2]);
+ this->Properties->xyIPW->SetLookupTable(this->Properties->lut);
+ this->Properties->xyIPW->On();
+ this->RenXY->GetActiveCamera()->SetFocalPoint( this->ImageData->GetDimensions()[0]/2,
+ this->ImageData->GetDimensions()[1]/2,
+ this->ImageData->GetDimensions()[2]/2 );
+ this->RenXY->GetActiveCamera()->SetPosition( this->ImageData->GetDimensions()[0]/2,
+ this->ImageData->GetDimensions()[1]/2,
+ this->ImageData->GetDimensions()[2]*10 );
+ this->RenXY->GetActiveCamera()->SetViewUp(0,0,-1);
+ this->RenXY->ResetCamera();
+ this->RenXY->GetActiveCamera()->Zoom(this->ZoomLabel);
+ this->GetRenderWindowXY()->Render();
+
+ /// Manage XZ window
+ this->Properties->xzIPW->SetCurrentRenderer(this->GetXZRenderer());
+ this->Properties->xzIPW->SetInput(this->ImageData);
+ this->Properties->xzIPW->SetPlaneOrientationToYAxes();
+ this->Properties->xzIPW->SetSlicePosition(center[1]);
+ this->Properties->xzIPW->SetLookupTable(this->Properties->lut);
+ this->Properties->xzIPW->On();
+ this->RenXZ->GetActiveCamera()->SetFocalPoint( this->ImageData->GetDimensions()[0]/2,
+ this->ImageData->GetDimensions()[1]/2,
+ this->ImageData->GetDimensions()[2]/2 );
+ this->RenXZ->GetActiveCamera()->SetPosition( this->ImageData->GetDimensions()[0]/2,
+ this->ImageData->GetDimensions()[1]*10,
+ this->ImageData->GetDimensions()[2]/2 );
+ this->RenXZ->GetActiveCamera()->SetViewUp(0,0,-1);
+
+ this->RenXZ->ResetCamera();
+ this->RenXZ->GetActiveCamera()->Zoom(this->ZoomLabel);
+
+
+ /// Manage YZ window
+ this->Properties->yzIPW->SetCurrentRenderer(this->GetYZRenderer());
+ this->Properties->yzIPW->SetInput(this->ImageData);
+ this->Properties->yzIPW->SetPlaneOrientationToXAxes();
+ this->Properties->yzIPW->SetSlicePosition(center[0]);
+ this->Properties->yzIPW->SetLookupTable(this->Properties->lut);
+ this->Properties->yzIPW->On();
+ this->RenYZ->GetActiveCamera()->SetFocalPoint( this->ImageData->GetDimensions()[0]/2,
+ this->ImageData->GetDimensions()[1]/2,
+ this->ImageData->GetDimensions()[2]/2 );
+ this->RenYZ->GetActiveCamera()->SetPosition( this->ImageData->GetDimensions()[0]*10,
+ this->ImageData->GetDimensions()[1]/2,
+ this->ImageData->GetDimensions()[2]/2 );
+ this->RenYZ->GetActiveCamera()->SetViewUp(0,0,-1);
+ this->RenYZ->ResetCamera();
+ this->RenYZ->GetActiveCamera()->Zoom(this->ZoomLabel);
+
+ /// Manage Bounding box around the volume for the 3D display
+ vtkSmartPointer<vtkOutlineFilter> outlineData = vtkSmartPointer<vtkOutlineFilter>::New();
+ outlineData->SetInput(this->ImageData);
+ vtkSmartPointer<vtkPolyDataMapper> mapOutline = vtkSmartPointer<vtkPolyDataMapper>::New();
+ mapOutline->SetInput(outlineData->GetOutput());
+ this->Properties->BoundingBoxActor = vtkSmartPointer<vtkActor>::New();
+ this->Properties->BoundingBoxActor->SetMapper(mapOutline);
+
+ /// Refresh YZ viewer
+ this->GetRenderWindowYZ()->Render();
+
+}
+
+
+void OpenHeartGui::InterpolationManagement()
+{
+
+ if ( this->FlagReslice == 0 )
+ {
+ if ( this->FlagInterpolation == 0 )
+ {
+ this->FlagInterpolation = 1;
+ this->Properties->xIPW->TextureInterpolateOn();
+ this->Properties->yIPW->TextureInterpolateOn();
+ this->Properties->zIPW->TextureInterpolateOn();
+ }
+ else
+ {
+ this->FlagInterpolation = 0;
+ this->Properties->xIPW->TextureInterpolateOff();
+ this->Properties->yIPW->TextureInterpolateOff();
+ this->Properties->zIPW->TextureInterpolateOff();
+ }
+
+ /// Force to display the change on the XYZ planes
+ this->Properties->xIPW->SetInput(this->ImageData);
+ this->Properties->yIPW->SetInput(this->ImageData);
+ this->Properties->zIPW->SetInput(this->ImageData);
+ this->Properties->xIPW->SetSlicePosition(this->Properties->position[0]);
+ this->Properties->yIPW->SetSlicePosition(this->Properties->position[1]);
+ this->Properties->zIPW->SetSlicePosition(this->Properties->position[2]);
+
+ this->GetRenderWindow()->Render();
+ }
+
+}
+
+
+void OpenHeartGui::UpdateForwardViewers()
+{
+
+ if ( this->ImageData )
+ {
+
+ ++(this->itStackVolume);
+ ++(this->CurrentFrame);
+ if (this->Properties->MeshActor) {
+ ++(this->itStackMesh);
+ ++(this->Properties->itStackMapperList);
+ ++(this->Properties->itStackMapXCutter);
+ ++(this->Properties->itStackMapYCutter);
+ ++(this->Properties->itStackMapZCutter);
+ }
+
+ if ( this->itStackVolume == this->StackVolume.end() ) {
+ this->itStackVolume = this->StackVolume.begin();
+ this->CurrentFrame = 0;
+ if (this->Properties->MeshActor) {
+ this->itStackMesh = this->StackMesh.begin();
+ this->Properties->itStackMapperList = this->Properties->StackMapperList.begin();
+ this->Properties->itStackMapXCutter = this->Properties->StackMapXCutter.begin();
+ this->Properties->itStackMapYCutter = this->Properties->StackMapYCutter.begin();
+ this->Properties->itStackMapZCutter = this->Properties->StackMapZCutter.begin();
+ }
+ }
+
+ /// Update image data pointer
+ this->ImageData = (*this->itStackVolume);
+
+ if ( this->FlagReslice == 0 )
+ {
+
+ /// Update the 3 planes and the corresponding 2D plane windows
+ this->Properties->xIPW->SetInput(this->ImageData);
+ this->Properties->yIPW->SetInput(this->ImageData);
+ this->Properties->zIPW->SetInput(this->ImageData);
+ this->Properties->xyIPW->SetInput(this->ImageData);
+ this->Properties->xzIPW->SetInput(this->ImageData);
+ this->Properties->yzIPW->SetInput(this->ImageData);
+ this->Properties->xIPW->SetSlicePosition(this->Properties->position[0]);
+ this->Properties->yIPW->SetSlicePosition(this->Properties->position[1]);
+ this->Properties->zIPW->SetSlicePosition(this->Properties->position[2]);
+ this->Properties->xyIPW->SetSlicePosition(this->Properties->position[2]);
+ this->Properties->xzIPW->SetSlicePosition(this->Properties->position[1]);
+ this->Properties->yzIPW->SetSlicePosition(this->Properties->position[0]);
+
+ }
+ else
+ {
+
+ /// Update X plan
+ double pto[3];
+ double pt1[3];
+ double pt2[3];
+ for (int i=0;i<3; i++) {
+ pto[i] = this->Properties->xIPW->GetOrigin()[i];
+ pt1[i] = this->Properties->xIPW->GetPoint1()[i];
+ pt2[i] = this->Properties->xIPW->GetPoint2()[i];
+ }
+ double position = this->Properties->xIPW->GetSlicePosition();
+ this->Properties->xIPW->SetInput(this->ImageData);
+ this->Properties->yzIPW->SetInput(this->ImageData);
+ this->Properties->xIPW->SetOrigin(pto);
+ this->Properties->xIPW->SetPoint1(pt1);
+ this->Properties->xIPW->SetPoint2(pt2);
+ this->Properties->xIPW->UpdatePlacement();
+ this->Properties->yzIPW->SetOrigin(pto);
+ this->Properties->yzIPW->SetPoint1(pt1);
+ this->Properties->yzIPW->SetPoint2(pt2);
+ this->Properties->yzIPW->UpdatePlacement();
+ this->Properties->xIPW->SetSlicePosition(position);
+ this->Properties->yzIPW->SetSlicePosition(position);
+
+ /// Update Y plan
+ for (int i=0;i<3; i++) {
+ pto[i] = this->Properties->yIPW->GetOrigin()[i];
+ pt1[i] = this->Properties->yIPW->GetPoint1()[i];
+ pt2[i] = this->Properties->yIPW->GetPoint2()[i];
+ }
+ position = this->Properties->yIPW->GetSlicePosition();
+ this->Properties->yIPW->SetInput(this->ImageData);
+ this->Properties->xzIPW->SetInput(this->ImageData);
+ this->Properties->yIPW->SetOrigin(pto);
+ this->Properties->yIPW->SetPoint1(pt1);
+ this->Properties->yIPW->SetPoint2(pt2);
+ this->Properties->yIPW->UpdatePlacement();
+ this->Properties->xzIPW->SetOrigin(pto);
+ this->Properties->xzIPW->SetPoint1(pt1);
+ this->Properties->xzIPW->SetPoint2(pt2);
+ this->Properties->xzIPW->UpdatePlacement();
+ this->Properties->yIPW->SetSlicePosition(position);
+ this->Properties->xzIPW->SetSlicePosition(position);
+
+ /// Update Z plan
+ for (int i=0;i<3; i++) {
+ pto[i] = this->Properties->zIPW->GetOrigin()[i];
+ pt1[i] = this->Properties->zIPW->GetPoint1()[i];
+ pt2[i] = this->Properties->zIPW->GetPoint2()[i];
+ }
+ position = this->Properties->zIPW->GetSlicePosition();
+ this->Properties->zIPW->SetInput(this->ImageData);
+ this->Properties->xyIPW->SetInput(this->ImageData);
+ this->Properties->zIPW->SetOrigin(pto);
+ this->Properties->zIPW->SetPoint1(pt1);
+ this->Properties->zIPW->SetPoint2(pt2);
+ this->Properties->zIPW->UpdatePlacement();
+ this->Properties->xyIPW->SetOrigin(pto);
+ this->Properties->xyIPW->SetPoint1(pt1);
+ this->Properties->xyIPW->SetPoint2(pt2);
+ this->Properties->xyIPW->UpdatePlacement();
+ this->Properties->zIPW->SetSlicePosition(position);
+ this->Properties->xyIPW->SetSlicePosition(position);
+
+ }
+
+ /// Update the segmented mesh if needed
+ if (this->Properties->MeshActor)
+ {
+ this->Properties->MeshActor->SetMapper(*this->Properties->itStackMapperList);
+ vtkPolyDataMapper* cutMapperX = vtkPolyDataMapper::New();
+ cutMapperX->SetInputConnection((*this->Properties->itStackMapXCutter)->GetOutputPort());
+ this->Properties->xCutActor->SetMapper(cutMapperX);
+ vtkPolyDataMapper* cutMapperY = vtkPolyDataMapper::New();
+ cutMapperY->SetInputConnection((*this->Properties->itStackMapYCutter)->GetOutputPort());
+ this->Properties->yCutActor->SetMapper(cutMapperY);
+ vtkPolyDataMapper* cutMapperZ = vtkPolyDataMapper::New();
+ cutMapperZ->SetInputConnection((*this->Properties->itStackMapZCutter)->GetOutputPort());
+ this->Properties->zCutActor->SetMapper(cutMapperZ);
+ }
+
+ /// Update viewers
+ this->GetRenderWindow()->Render();
+ this->GetXYRenderer()->ResetCameraClippingRange();
+ this->GetRenderWindowXY()->Render();
+ this->GetXZRenderer()->ResetCameraClippingRange();
+ this->GetRenderWindowXZ()->Render();
+ this->GetYZRenderer()->ResetCameraClippingRange();
+ this->GetRenderWindowYZ()->Render();
+
+ }
+
+}
+
+
+void OpenHeartGui::UpdateBackwardViewers()
+{
+
+ if ( this->ImageData )
+ {
+
+ if ( this->itStackVolume == this->StackVolume.begin() )
+ {
+ this->itStackVolume = this->StackVolume.end();
+ this->CurrentFrame = this->NumberOfVolumes;
+ if (this->Properties->MeshActor) {
+ this->itStackMesh = this->StackMesh.end();
+ this->Properties->itStackMapperList = this->Properties->StackMapperList.end();
+ this->Properties->itStackMapXCutter = this->Properties->StackMapXCutter.end();
+ this->Properties->itStackMapYCutter = this->Properties->StackMapYCutter.end();
+ this->Properties->itStackMapZCutter = this->Properties->StackMapZCutter.end();
+ }
+ }
+
+ --(this->itStackVolume);
+ --(this->CurrentFrame);
+ if (this->Properties->MeshActor) {
+ --(this->itStackMesh);
+ --(this->Properties->itStackMapperList);
+ --(this->Properties->itStackMapXCutter);
+ --(this->Properties->itStackMapYCutter);
+ --(this->Properties->itStackMapZCutter);
+ }
+
+ /// Update image data pointer
+ this->ImageData = (*this->itStackVolume);
+
+ if ( this->FlagReslice == 0 )
+ {
+
+ /// Update the 3 planes
+ this->Properties->xIPW->SetInput(this->ImageData);
+ this->Properties->yIPW->SetInput(this->ImageData);
+ this->Properties->zIPW->SetInput(this->ImageData);
+ this->Properties->xyIPW->SetInput(this->ImageData);
+ this->Properties->xzIPW->SetInput(this->ImageData);
+ this->Properties->yzIPW->SetInput(this->ImageData);
+ this->Properties->xIPW->SetSlicePosition(this->Properties->position[0]);
+ this->Properties->yIPW->SetSlicePosition(this->Properties->position[1]);
+ this->Properties->zIPW->SetSlicePosition(this->Properties->position[2]);
+ this->Properties->xyIPW->SetSlicePosition(this->Properties->position[2]);
+ this->Properties->xzIPW->SetSlicePosition(this->Properties->position[1]);
+ this->Properties->yzIPW->SetSlicePosition(this->Properties->position[0]);
+
+ }
+ else
+ {
+
+ /// Update X plan
+ double pto[3];
+ double pt1[3];
+ double pt2[3];
+ for (int i=0;i<3; i++) {
+ pto[i] = this->Properties->xIPW->GetOrigin()[i];
+ pt1[i] = this->Properties->xIPW->GetPoint1()[i];
+ pt2[i] = this->Properties->xIPW->GetPoint2()[i];
+ }
+ double position = this->Properties->xIPW->GetSlicePosition();
+ this->Properties->xIPW->SetInput(this->ImageData);
+ this->Properties->yzIPW->SetInput(this->ImageData);
+ this->Properties->xIPW->SetOrigin(pto);
+ this->Properties->xIPW->SetPoint1(pt1);
+ this->Properties->xIPW->SetPoint2(pt2);
+ this->Properties->xIPW->UpdatePlacement();
+ this->Properties->yzIPW->SetOrigin(pto);
+ this->Properties->yzIPW->SetPoint1(pt1);
+ this->Properties->yzIPW->SetPoint2(pt2);
+ this->Properties->yzIPW->UpdatePlacement();
+ this->Properties->xIPW->SetSlicePosition(position);
+ this->Properties->yzIPW->SetSlicePosition(position);
+
+ /// Update Y plan
+ for (int i=0;i<3; i++) {
+ pto[i] = this->Properties->yIPW->GetOrigin()[i];
+ pt1[i] = this->Properties->yIPW->GetPoint1()[i];
+ pt2[i] = this->Properties->yIPW->GetPoint2()[i];
+ }
+ position = this->Properties->yIPW->GetSlicePosition();
+ this->Properties->yIPW->SetInput(this->ImageData);
+ this->Properties->xzIPW->SetInput(this->ImageData);
+ this->Properties->yIPW->SetOrigin(pto);
+ this->Properties->yIPW->SetPoint1(pt1);
+ this->Properties->yIPW->SetPoint2(pt2);
+ this->Properties->yIPW->UpdatePlacement();
+ this->Properties->xzIPW->SetOrigin(pto);
+ this->Properties->xzIPW->SetPoint1(pt1);
+ this->Properties->xzIPW->SetPoint2(pt2);
+ this->Properties->xzIPW->UpdatePlacement();
+ this->Properties->yIPW->SetSlicePosition(position);
+ this->Properties->xzIPW->SetSlicePosition(position);
+
+ /// Update Z plan
+ for (int i=0;i<3; i++) {
+ pto[i] = this->Properties->zIPW->GetOrigin()[i];
+ pt1[i] = this->Properties->zIPW->GetPoint1()[i];
+ pt2[i] = this->Properties->zIPW->GetPoint2()[i];
+ }
+ position = this->Properties->zIPW->GetSlicePosition();
+ this->Properties->zIPW->SetInput(this->ImageData);
+ this->Properties->xyIPW->SetInput(this->ImageData);
+ this->Properties->zIPW->SetOrigin(pto);
+ this->Properties->zIPW->SetPoint1(pt1);
+ this->Properties->zIPW->SetPoint2(pt2);
+ this->Properties->zIPW->UpdatePlacement();
+ this->Properties->xyIPW->SetOrigin(pto);
+ this->Properties->xyIPW->SetPoint1(pt1);
+ this->Properties->xyIPW->SetPoint2(pt2);
+ this->Properties->xyIPW->UpdatePlacement();
+ this->Properties->zIPW->SetSlicePosition(position);
+ this->Properties->xyIPW->SetSlicePosition(position);
+
+ }
+
+ /// Update the segmented mesh if needed
+ if (this->Properties->MeshActor)
+ {
+ this->Properties->MeshActor->SetMapper(*this->Properties->itStackMapperList);
+ vtkPolyDataMapper* cutMapperX = vtkPolyDataMapper::New();
+ cutMapperX->SetInputConnection((*this->Properties->itStackMapXCutter)->GetOutputPort());
+ this->Properties->xCutActor->SetMapper(cutMapperX);
+ vtkPolyDataMapper* cutMapperY = vtkPolyDataMapper::New();
+ cutMapperY->SetInputConnection((*this->Properties->itStackMapYCutter)->GetOutputPort());
+ this->Properties->yCutActor->SetMapper(cutMapperY);
+ vtkPolyDataMapper* cutMapperZ = vtkPolyDataMapper::New();
+ cutMapperZ->SetInputConnection((*this->Properties->itStackMapZCutter)->GetOutputPort());
+ this->Properties->zCutActor->SetMapper(cutMapperZ);
+ }
+
+ this->GetRenderWindow()->Render();
+ this->GetRenderWindowXY()->Render();
+ this->GetRenderWindowXZ()->Render();
+ this->GetRenderWindowYZ()->Render();
+
+ }
+
+}
+
+
+void OpenHeartGui::slotMeshAlpha(int val)
+{
+
+ if ( this->Properties->MeshActor )
+ {
+ this->Properties->MeshActor->GetProperty()->SetOpacity(val/100.);
+ this->GetRenderWindow()->Render();
+ }
+
+}
+
+
+void OpenHeartGui::slotRefreshViewer(int val)
+{
+
+ /// Loop cases
+ while ( val != this->CurrentFrame )
+ {
+ if ( (this->FlagLoopEndToBegin == 0) && (this->FlagLoopBeginToEnd == 0) )
+ {
+ /// Normal transition
+ if ( ( val-this->CurrentFrame ) > 0 )
+ UpdateForwardViewers();
+ else
+ UpdateBackwardViewers();
+ }
+ else
+ {
+ /// Loop end to begin
+ if ( this->FlagLoopEndToBegin == 1 ) {
+ this->FlagLoopEndToBegin = 0;
+ UpdateForwardViewers();
+ }
+ /// Loop begin to end
+ if ( this->FlagLoopBeginToEnd == 1 ) {
+ this->FlagLoopBeginToEnd = 0;
+ UpdateBackwardViewers();
+ }
+ }
+ }
+
+ /// Update Frame text
+ if ( (this->FlagDisplayText) && (this->Properties->TextMapperNumFrame) )
+ {
+ QString str;
+ str.sprintf("Frame: %d",this->CurrentFrame);
+ this->Properties->TextMapperNumFrame->SetInput(str.toStdString().c_str());
+ this->GetRenderWindow()->Render();
+ }
+
+}
+
+
+void OpenHeartGui::slotTabChange(int val)
+{
+
+ if (val==3)
+ {
+
+ if ( this->Properties->ApexPointActor != 0 ) {
+ this->GetMainRenderer()->AddActor(this->Properties->ApexPointActor);
+ this->FlagDisplayApexPoint = 1;
+ }
+ if ( this->Properties->BasalPointActor != 0 ) {
+ this->GetMainRenderer()->AddActor(this->Properties->BasalPointActor);
+ this->FlagDisplayBasalPoint = 1;
+ }
+ if ( this->Properties->LongAxisActor != 0 ) {
+ this->GetMainRenderer()->AddActor(this->Properties->LongAxisActor);
+ this->FlagDisplayLongAxis = 1;
+ }
+
+ this->slot3DView();
+ }
+ else
+ {
+
+ if ( this->FlagDisplayApexPoint == 1 ) {
+ this->GetMainRenderer()->RemoveActor(this->Properties->ApexPointActor);
+ this->FlagDisplayApexPoint = 0;
+ this->GetRenderWindow()->Render();
+ }
+ if ( this->FlagDisplayBasalPoint == 1 ) {
+ this->GetMainRenderer()->RemoveActor(this->Properties->BasalPointActor);
+ this->FlagDisplayBasalPoint = 0;
+ this->GetRenderWindow()->Render();
+ }
+ if ( this->FlagDisplayLongAxis == 1 ) {
+ this->GetMainRenderer()->RemoveActor(this->Properties->LongAxisActor);
+ this->FlagDisplayLongAxis = 0;
+ this->GetRenderWindow()->Render();
+ }
+
+ }
+
+}
+
+
+
+void OpenHeartGui::slotPlay()
+{
+ if ( this->FlagPlay == 0 ) {
+ this->FlagPlay = 1;
+ this->pushButtonPlay->setText("Pause");
+ this->scrollBar->setEnabled(false);
+ this->Timer->start(40);
+ }
+ else {
+ this->FlagPlay = 0;
+ this->Timer->stop();
+ this->pushButtonPlay->setText("Play");
+ this->scrollBar->setEnabled(true);
+ }
+}
+
+
+void OpenHeartGui::slotTimerEvent()
+{
+
+ int val = this->CurrentFrame;
+ if ( val < (this->NumberOfVolumes-1) )
+ this->scrollBar->setSliderPosition(val+1);
+ else {
+ this->FlagLoopEndToBegin = 1;
+ this->scrollBar->setSliderPosition(0);
+ }
+
+}
+
+
+void OpenHeartGui::slotBasalPoint()
+{
+
+ if ( this->Properties->BasalPointActor == 0 ) {
+ this->Properties->BasalPointActor = vtkSmartPointer<vtkActor>::New();
+ }
+ else {
+ this->GetMainRenderer()->RemoveActor(this->Properties->BasalPointActor);
+ }
+
+ vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
+ sphereSource->SetCenter(this->Properties->position[0],
+ this->Properties->position[1],
+ this->Properties->position[2]);
+ sphereSource->SetRadius(5.0*this->ImageData->GetSpacing()[0]);
+ sphereSource->Update();
+
+ for (int i=0; i<3; i++)
+ this->BasalPoint[i] = this->Properties->position[i];
+
+ vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+ mapper->SetInput(sphereSource->GetOutput());
+
+ this->Properties->BasalPointActor->SetMapper(mapper);
+ this->Properties->BasalPointActor->GetProperty()->SetColor(0,1,0);
+
+ this->GetMainRenderer()->AddActor(this->Properties->BasalPointActor);
+ this->FlagDisplayBasalPoint = 1;
+
+ if ( this->Properties->ApexPointActor != 0 )
+ {
+ this->CreateLongAxisActor();
+ this->FlagLongAxis = 1;
+ this->GetMainRenderer()->AddActor(this->Properties->LongAxisActor);
+ this->FlagDisplayLongAxis = 1;
+ this->pushButtonReslice->setEnabled(true);
+ }
+
+ this->GetRenderWindow()->Render();
+
+}
+
+
+void OpenHeartGui::slotApexPoint()
+{
+
+ if ( this->Properties->ApexPointActor == 0 ) {
+ this->Properties->ApexPointActor = vtkSmartPointer<vtkActor>::New();
+ }
+ else {
+ this->GetMainRenderer()->RemoveActor(this->Properties->ApexPointActor);
+ }
+
+ vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
+ sphereSource->SetCenter(this->Properties->position[0],
+ this->Properties->position[1],
+ this->Properties->position[2]);
+ sphereSource->SetRadius(5.0*this->ImageData->GetSpacing()[0]);
+ sphereSource->Update();
+
+ for (int i=0; i<3; i++)
+ this->ApexPoint[i] = this->Properties->position[i];
+
+ vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+ mapper->SetInput(sphereSource->GetOutput());
+
+ this->Properties->ApexPointActor->SetMapper(mapper);
+ this->Properties->ApexPointActor->GetProperty()->SetColor(0,1,0);
+
+ this->GetMainRenderer()->AddActor(this->Properties->ApexPointActor);
+ this->FlagDisplayApexPoint = 1;
+
+ if ( this->Properties->BasalPointActor != 0 )
+ {
+ this->CreateLongAxisActor();
+ this->FlagLongAxis = 1;
+ this->GetMainRenderer()->AddActor(this->Properties->LongAxisActor);
+ this->FlagDisplayLongAxis = 1;
+ this->pushButtonReslice->setEnabled(true);
+ }
+
+ this->GetRenderWindow()->Render();
+
+}
+
+
+void OpenHeartGui::CreateLongAxisActor()
+{
+
+ if ( this->Properties->LongAxisActor == 0 ) {
+ this->Properties->LongAxisActor = vtkSmartPointer<vtkActor>::New();
+ }
+ else {
+ this->GetMainRenderer()->RemoveActor(this->Properties->LongAxisActor);
+ }
+
+ vtkSmartPointer<vtkLineSource> lineSource = vtkSmartPointer<vtkLineSource>::New();
+ lineSource->SetPoint1(this->BasalPoint);
+ lineSource->SetPoint2(this->ApexPoint);
+ lineSource->Update();
+
+ vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+ mapper->SetInputConnection(lineSource->GetOutputPort());
+
+ this->Properties->LongAxisActor->SetMapper(mapper);
+ this->Properties->LongAxisActor->GetProperty()->SetLineWidth(2);
+ this->Properties->LongAxisActor->GetProperty()->SetColor(0,1,0);
+
+}
+
+
+void OpenHeartGui::DisplayMainAxisManagement()
+{
+
+}
+
+
+void OpenHeartGui::DisplayMeshManagement()
+{
+
+ if ( this->Properties->MeshActor != 0 )
+ {
+
+ if ( this->FlagDisplayMesh == 0 )
+ {
+ this->GetMeshRenderer()->AddActor(this->Properties->MeshActor);
+ this->FlagDisplayMesh = 1;
+ }
+ else
+ {
+ this->GetMeshRenderer()->RemoveActor(this->Properties->MeshActor);
+ this->FlagDisplayMesh = 0;
+ }
+ this->GetRenderWindow()->Render();
+
+ }
+
+}
+
+void OpenHeartGui::DisplayModeManagement()
+{
+
+ if ( this->FlagDisplayText == 0 )
+ {
+
+ this->FlagDisplayText = 1;
+ if ( this->Properties->TextMapperPixel ) {
+ this->Properties->TextMapperPixel->SetInput("Display on");
+ }
+ if ( this->Properties->TextMapperNumFrame ) {
+ QString str;
+ str.sprintf("f = %d",this->CurrentFrame);
+ this->Properties->TextMapperNumFrame->SetInput(str.toStdString().c_str());
+ }
+ if ( this->Properties->TextMapperResolution ) {
+ QString str;
+ str.sprintf("Resolution: %.2f x %.2f x %.2f mm",this->ImageData->GetSpacing()[0]*1000,this->ImageData->GetSpacing()[1]*1000,this->ImageData->GetSpacing()[2]*1000);
+ this->Properties->TextMapperResolution->SetInput(str.toStdString().c_str());
+ }
+ if ( this->Properties->TextMapperSlice ) {
+ int slice = (int)( (this->Properties->position[1] - this->ImageData->GetOrigin()[1]) / this->ImageData->GetSpacing()[1] + 0.5f );
+ QString strSlice;
+ strSlice.sprintf("Slice: %d",slice);
+ this->Properties->TextMapperSlice->SetInput(strSlice.toStdString().c_str());
+ }
+
+ this->GetRenderWindow()->Render();
+
+ }
+ else
+ {
+
+ this->FlagDisplayText = 0;
+ if ( this->Properties->TextMapperPixel ) {
+ this->Properties->TextMapperPixel->SetInput("Display off");
+ }
+ if ( this->Properties->TextMapperNumFrame ) {
+ this->Properties->TextMapperNumFrame->SetInput("");
+ }
+ if ( this->Properties->TextMapperResolution ) {
+ this->Properties->TextMapperResolution->SetInput("");
+ }
+ if ( this->Properties->TextMapperSlice ) {
+ this->Properties->TextMapperSlice->SetInput("");
+ }
+ if ( this->Properties->TextMapperMM ) {
+ this->Properties->TextMapperMM->SetInput("");
+ }
+ if ( this->Properties->TextMapperValue ) {
+ this->Properties->TextMapperValue->SetInput("");
+ }
+ this->GetRenderWindow()->Render();
+
+ }
+
+}
+
+
+vtkActor2D* OpenHeartGui::AddFixedText(const char *text, float x, float y, float R,float G, float B, int Size)
+{
+
+ vtkTextMapper *Mapper = vtkTextMapper::New();
+ vtkActor2D *Actor = vtkActor2D::New();
+ Mapper->SetInput(text);
+ Mapper->GetTextProperty()->SetColor(R, G, B);
+ Mapper->GetTextProperty()->SetFontSize(Size);
+ Mapper->GetTextProperty()->SetJustificationToLeft();
+ Mapper->GetTextProperty()->ShadowOff();
+ Actor->SetPosition(x, y);
+ Actor->SetMapper(Mapper);
+ return Actor;
+
+}
+
+
+void OpenHeartGui::resizeEvent(QResizeEvent* event)
+{
+ int sizeX = this->qVTK->GetRenderWindow()->GetSize()[0];
+ int sizeY = this->qVTK->GetRenderWindow()->GetSize()[1];
+ if ( (sizeX!=382) || (sizeY!=462) ) {
+ this->Properties->TextActorSlice->SetPosition(10,this->GetRenderWindow()->GetSize()[1]-20);
+ this->Properties->TextActorPixel->SetPosition(this->GetRenderWindow()->GetSize()[0]-10,this->GetRenderWindow()->GetSize()[1]-20);
+ this->Properties->TextActorMM->SetPosition(this->GetRenderWindow()->GetSize()[0]-10,this->GetRenderWindow()->GetSize()[1]-45);
+ this->Properties->TextActorValue->SetPosition(this->GetRenderWindow()->GetSize()[0]-10,this->GetRenderWindow()->GetSize()[1]-70);
+ this->GetRenderWindow()->Render();
+ QMainWindow::resizeEvent(event);
+ }
+}
+
+
+void OpenHeartGui::HidePlanModeManagement()
+{
+
+ if ( this->FlagHidePlan == 0 )
+ {
+ this->FlagHidePlan = 1;
+ this->Properties->xIPW->SetTextureVisibility(0);
+ this->Properties->xIPW->GetPlaneProperty()->SetOpacity(0);
+ this->Properties->yIPW->SetTextureVisibility(0);
+ this->Properties->yIPW->GetPlaneProperty()->SetOpacity(0);
+ this->Properties->zIPW->SetTextureVisibility(0);
+ this->Properties->zIPW->GetPlaneProperty()->SetOpacity(0);
+
+ if ( (this->FlagDisplayMesh==0) && (this->FlagDisplayMeshContours==0) ) {
+ this->GetMeshRenderer()->AddActor(this->Properties->MeshActor);
+ this->FlagDisplayMesh = 1;
+ }
+ /*
+ if ( this->FlagDisplayMeshContours == 1 ) {
+ this->GetMeshRenderer()->RemoveActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->zCutActor);
+ this->FlagDisplayMeshContours = 0;
+ }
+ */
+ this->GetRenderWindow()->Render();
+
+ }
+ else
+ {
+ if ( this->FlagDisplayMesh == 1 )
+ this->GetMeshRenderer()->RemoveActor(this->Properties->MeshActor);
+ if ( this->FlagDisplayMeshContours == 1 ) {
+ this->GetMeshRenderer()->RemoveActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->RemoveActor(this->Properties->zCutActor);
+ }
+ this->FlagHidePlan = 0;
+
+ switch (this->ViewButton) {
+ case 0: /// 3D view
+ this->Properties->xIPW->SetTextureVisibility(1);
+ this->Properties->xIPW->GetPlaneProperty()->SetOpacity(1);
+ this->Properties->yIPW->SetTextureVisibility(1);
+ this->Properties->yIPW->GetPlaneProperty()->SetOpacity(1);
+ this->Properties->zIPW->SetTextureVisibility(1);
+ this->Properties->zIPW->GetPlaneProperty()->SetOpacity(1);
+ if ( this->FlagDisplayMeshContours == 1 ) {
+ this->GetMeshRenderer()->AddActor(this->Properties->xCutActor);
+ this->GetMeshRenderer()->AddActor(this->Properties->yCutActor);
+ this->GetMeshRenderer()->AddActor(this->Properties->zCutActor);
+ }
+ break;
+ case 1: /// XY view
+ this->Properties->xIPW->SetTextureVisibility(1);
+ this->Properties->xIPW->GetPlaneProperty()->SetOpacity(1);
+ if ( this->FlagDisplayMeshContours == 1 ) {
+ this->GetMeshRenderer()->AddActor(this->Properties->xCutActor);
+ }
+ break;
+ case 2: /// XZ view
+ this->Properties->yIPW->SetTextureVisibility(1);
+ this->Properties->yIPW->GetPlaneProperty()->SetOpacity(1);
+ if ( this->FlagDisplayMeshContours == 1 ) {
+ this->GetMeshRenderer()->AddActor(this->Properties->yCutActor);
+ }
+ break;
+ case 3: /// YZ view
+ this->Properties->zIPW->SetTextureVisibility(1);
+ this->Properties->zIPW->GetPlaneProperty()->SetOpacity(1);
+ if ( this->FlagDisplayMeshContours == 1 ) {
+ this->GetMeshRenderer()->AddActor(this->Properties->zCutActor);
+ }
+ break;
+ default:
+ break;
+ }
+
+ if ( this->FlagDisplayMesh == 1 )
+ this->GetMeshRenderer()->AddActor(this->Properties->MeshActor);
+ this->GetRenderWindow()->Render();
+ }
+
+}
+
+
+void OpenHeartGui::UpdateClinicalIndices()
+{
+
+ float EDV = 0;
+ float ESV = 1000000;
+ int NbElements = this->TableChart->GetNumberOfRows();
+ for ( int k=0; k<NbElements; k++)
+ {
+ float val = this->TableChart->GetValue(k,1).ToFloat();
+ if ( val > EDV )
+ EDV = val;
+ if ( val < ESV )
+ ESV = val;
+ }
+ /// End Diastolic and End systolic volume
+ QString strESV;
+ strESV.sprintf("%2.1f ml",ESV);
+ QString strEDV;
+ strEDV.sprintf("%2.1f ml",EDV);
+ this->labelESVValue->setText(strESV);
+ this->labelEDVValue->setText(strEDV);
+ /// Ejection fraction indice
+ float EF = 100 * (EDV-ESV) / (EDV+1e-6);
+ QString strEF;
+ strEF.sprintf("%2.1f %%",EF);
+ this->labelEFValue->setText(strEF);
+ /// Stroke volume indice
+ float SV = EDV-ESV;
+ QString strSV;
+ strSV.sprintf("%2.1f ml",SV);
+ this->labelSVValue->setText(strSV);
+
+}
+
+
+/// Custimize interface colors
+void OpenHeartGui::SetInterfaceColors()
+{
+ this->tabMesh->setStyleSheet("background-color: rgb(0,0,0);");
+ this->widgetXY->setStyleSheet("border-style: solid; border-width: 2px; border-color: blue;");
+ this->widgetXZ->setStyleSheet("border-style: solid; border-width: 2px; border-color: yellow;");
+ this->widgetYZ->setStyleSheet("border-style: solid; border-width: 2px; border-color: red;");
+}
+
+
+void OpenHeartGui::slotReslice()
+{
+
+ if ( this->pushButtonReslice->isEnabled() )
+ {
+ if ( this->FlagReslice == 0 )
+ {
+ /// Reslice planes according to the main axis
+ this->SetLongAxisView();
+ /// Display off the Slice text actor
+ this->GetMainRenderer()->RemoveActor(this->Properties->TextActorSlice);
+ /// Replace Reslice text by Reset one into the push button
+ this->pushButtonReslice->setText("Reset");
+ /// Set corresponding flag to 1
+ this->FlagReslice = 1;
+ }
+ else
+ {
+ /// Reset the reslicing operation
+ this->ResetReslicing();
+ /// Display on the Slice text actor
+ this->GetMainRenderer()->AddActor(this->Properties->TextActorSlice);
+ /// Replace Reslice text by Reset one into the push button
+ this->pushButtonReslice->setText("Reslice");
+ /// Set corresponding flag to 0
+ this->FlagReslice = 0;
+ }
+
+ }
+
+}
+
+
+void OpenHeartGui::SetLongAxisView()
+{
+
+ /// Compute the rotation matrix between the Z-axis and the long axis of the heart
+ this->ComputeRotationMatrix();
+
+ /// Set the corresponding vtkTransform object
+ this->TransformViewOrientation->SetMatrix(this->RotationMatrix);
+ this->TransformViewOrientationInv->SetMatrix(this->RotationMatrixInv);
+
+ /// Set the plans at the center of the volume
+ double center[3];
+ for ( int i=0; i<3; i++ )
+ center[i] = 0.5*(this->ImageData->GetDimensions()[i])*(this->ImageData->GetSpacing()[i]);
+ this->Properties->xIPW->SetSlicePosition(center[0]);
+ this->Properties->yIPW->SetSlicePosition(center[1]);
+ this->Properties->zIPW->SetSlicePosition(center[2]);
+ this->Properties->yzIPW->SetSlicePosition(center[0]);
+ this->Properties->xzIPW->SetSlicePosition(center[1]);
+ this->Properties->xyIPW->SetSlicePosition(center[2]);
+
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /// Process XZ-plans
+
+ /// Apply the rotation to the points defining the cartesian plan of interest
+ //double *cy = this->Properties->yIPW->GetCenter();
+ double *pt1 = this->Properties->yIPW->GetPoint1();
+ double *pt2 = this->Properties->yIPW->GetPoint2();
+ double *pto = this->Properties->yIPW->GetOrigin();
+ double newpt1[3];
+ double newpt2[3];
+ double newpto[3];
+
+ /// Do this to ensure that the center of the rotation corresponds to the center of the volume
+ for (int i=0; i<3; i++) {
+ pt1[i] -= center[i];
+ pt2[i] -= center[i];
+ pto[i] -= center[i];
+ }
+
+ /// Apply transformation
+ this->TransformViewOrientation->TransformPoint(pt1,newpt1);
+ this->TransformViewOrientation->TransformPoint(pt2,newpt2);
+ this->TransformViewOrientation->TransformPoint(pto,newpto);
+ for (int i=0; i<3; i++) {
+ newpt1[i] += center[i];
+ newpt2[i] += center[i];
+ newpto[i] += center[i];
+ }
+ ///
+ this->Properties->yIPW->SetOrigin(newpto);
+ this->Properties->yIPW->SetPoint1(newpt1);
+ this->Properties->yIPW->SetPoint2(newpt2);
+ this->Properties->yIPW->UpdatePlacement();
+ ///
+ this->Properties->xzIPW->SetOrigin(newpto);
+ this->Properties->xzIPW->SetPoint1(newpt1);
+ this->Properties->xzIPW->SetPoint2(newpt2);
+ this->Properties->xzIPW->UpdatePlacement();
+
+
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /// Process YZ-plans
+
+ pt1 = this->Properties->xIPW->GetPoint1();
+ pt2 = this->Properties->xIPW->GetPoint2();
+ pto = this->Properties->xIPW->GetOrigin();
+
+ /// Do this to ensure that the center of the rotation corresponds to the center of the volume
+ for (int i=0; i<3; i++) {
+ pt1[i] -= center[i];
+ pt2[i] -= center[i];
+ pto[i] -= center[i];
+ }
+
+ /// Apply transformation
+ this->TransformViewOrientation->TransformPoint(pt1,newpt1);
+ this->TransformViewOrientation->TransformPoint(pt2,newpt2);
+ this->TransformViewOrientation->TransformPoint(pto,newpto);
+ for (int i=0; i<3; i++) {
+ newpt1[i] += center[i];
+ newpt2[i] += center[i];
+ newpto[i] += center[i];
+ }
+ ///
+ this->Properties->xIPW->SetOrigin(newpto);
+ this->Properties->xIPW->SetPoint1(newpt1);
+ this->Properties->xIPW->SetPoint2(newpt2);
+ this->Properties->xIPW->UpdatePlacement();
+ ///
+ this->Properties->yzIPW->SetOrigin(newpto);
+ this->Properties->yzIPW->SetPoint1(newpt1);
+ this->Properties->yzIPW->SetPoint2(newpt2);
+ this->Properties->yzIPW->UpdatePlacement();
+
+
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /// Process XY-plans
+
+ pt1 = this->Properties->zIPW->GetPoint1();
+ pt2 = this->Properties->zIPW->GetPoint2();
+ pto = this->Properties->zIPW->GetOrigin();
+
+ /// Do this to ensure that the center of the rotation corresponds to the center of the volume
+ for (int i=0; i<3; i++) {
+ pt1[i] -= center[i];
+ pt2[i] -= center[i];
+ pto[i] -= center[i];
+ }
+
+ /// Apply transformation
+ this->TransformViewOrientation->TransformPoint(pt1,newpt1);
+ this->TransformViewOrientation->TransformPoint(pt2,newpt2);
+ this->TransformViewOrientation->TransformPoint(pto,newpto);
+ for (int i=0; i<3; i++) {
+ newpt1[i] += center[i];
+ newpt2[i] += center[i];
+ newpto[i] += center[i];
+ }
+ ///
+ this->Properties->zIPW->SetOrigin(newpto);
+ this->Properties->zIPW->SetPoint1(newpt1);
+ this->Properties->zIPW->SetPoint2(newpt2);
+ this->Properties->zIPW->UpdatePlacement();
+ ///
+ this->Properties->xyIPW->SetOrigin(newpto);
+ this->Properties->xyIPW->SetPoint1(newpt1);
+ this->Properties->xyIPW->SetPoint2(newpt2);
+ this->Properties->xyIPW->UpdatePlacement();
+
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /// Final translation to match the Long axis
+
+ /// XZ plan translation
+ double *ncy = this->Properties->yIPW->GetCenter();
+ double t;
+ double closest[3];
+ vtkLine::DistanceToLine(ncy, this->BasalPoint, this->ApexPoint, t, closest);
+ double offset = this->Properties->yIPW->GetSlicePosition() + (closest[1] - ncy[1]);
+ this->Properties->yIPW->SetSlicePosition(offset);
+ this->Properties->xzIPW->SetSlicePosition(offset);
+
+ /// YZ plan translation
+ double *ncx = this->Properties->xIPW->GetCenter();
+ vtkLine::DistanceToLine(ncx, this->BasalPoint, this->ApexPoint, t, closest);
+ offset = this->Properties->xIPW->GetSlicePosition() + (closest[0] - ncx[0]);
+ this->Properties->xIPW->SetSlicePosition(offset);
+ this->Properties->yzIPW->SetSlicePosition(offset);
+
+ /// XY plan translation
+ double *ncz = this->Properties->zIPW->GetCenter();
+ double mid[3];
+ for (int i=0; i<3; i++)
+ mid[i] = this->BasalPoint[i] + 0.5 * (this->ApexPoint[i]-this->BasalPoint[i]);
+ offset = this->Properties->zIPW->GetSlicePosition() + (mid[2] - ncz[2]);
+ this->Properties->zIPW->SetSlicePosition(offset);
+ this->Properties->xyIPW->SetSlicePosition(offset);
+
+ /// Update Properties->position to fit to the new position
+ this->Properties->position[0] = this->Properties->xIPW->GetSlicePosition();
+ this->Properties->position[1] = this->Properties->yIPW->GetSlicePosition();
+ this->Properties->position[2] = this->Properties->zIPW->GetSlicePosition();
+
+
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /////////////////////////////////////////////////
+ /// Update renderer
+ this->UpdateViewer(0,this->ZoomLabel,this->RenXY);
+ this->UpdateViewer(1,this->ZoomLabel,this->RenXZ);
+ this->UpdateViewer(2,this->ZoomLabel,this->RenYZ);
+ this->GetRenderWindow()->Render();
+
+}
+
+
+/// Compute the rotation matrix between the Z-axis and the long axis of the heart
+void OpenHeartGui::ComputeRotationMatrix()
+{
+
+ double ZAxis[] = {0,0,1};
+ double MainAxis[3];
+ for (int i=0; i<3; i++)
+ MainAxis[i] = this->BasalPoint[i] - this->ApexPoint[i];
+ vtkMath::Normalize(MainAxis);
+
+ /// Compute rotation matrix between two vectors: MainAxis and ZAxis
+ double normal1[3];
+ double normal2[3];
+ for (int i=0; i<3; i++) {
+ normal1[i] = ZAxis[i];
+ normal2[i] = MainAxis[i];
+ }
+
+ double vec[3];
+ vtkMath::Cross(normal1, normal2, vec);
+ double costheta = vtkMath::Dot(normal1, normal2);
+ double sintheta = vtkMath::Norm(vec);
+ double theta = atan2(sintheta, costheta);
+ if (sintheta != 0)
+ {
+ vec[0] /= sintheta;
+ vec[1] /= sintheta;
+ vec[2] /= sintheta;
+ }
+
+ /// convert to quaternion
+ costheta = cos(0.5*theta);
+ sintheta = sin(0.5*theta);
+ double quat[4];
+ quat[0] = costheta;
+ quat[1] = vec[0]*sintheta;
+ quat[2] = vec[1]*sintheta;
+ quat[3] = vec[2]*sintheta;
+
+ /// convert to matrix
+ double mat[3][3];
+ vtkMath::QuaternionToMatrix3x3(quat,mat);
+
+ /// Create corresponding 4x4 matrix
+ this->RotationMatrix->Identity();
+ this->RotationMatrixInv->Identity();
+ for (unsigned int i = 0; i < 3; i++) {
+ for (unsigned int j = 0; j < 3; j++) {
+ this->RotationMatrix->SetElement(i, j, mat[i][j]);
+ this->RotationMatrixInv->SetElement(i, j, mat[i][j]);
+ }
+ }
+ this->RotationMatrixInv->Invert();
+
+}
+
+
+/// Reset the reslicing operation
+void OpenHeartGui::ResetReslicing()
+{
+
+ /// Set the rotation matrix to identity
+ this->RotationMatrix->Identity();
+ this->RotationMatrixInv->Identity();
+
+ /// Set the corresponding vtkTransform object
+ this->TransformViewOrientation->SetMatrix(this->RotationMatrix);
+ this->TransformViewOrientationInv->SetMatrix(this->RotationMatrixInv);
+
+ /// Switch off the oblique orientation of each plan
+ this->Properties->xIPW->SetPlaneOrientationToXAxes();
+ this->Properties->yzIPW->SetPlaneOrientationToXAxes();
+ this->Properties->yIPW->SetPlaneOrientationToYAxes();
+ this->Properties->xzIPW->SetPlaneOrientationToYAxes();
+ this->Properties->zIPW->SetPlaneOrientationToZAxes();
+ this->Properties->xyIPW->SetPlaneOrientationToZAxes();
+
+ /// Set the plans at the center of the volume
+ double center[3];
+ for ( unsigned int k=0; k<3; k++ )
+ center[k] = ((this->ImageData->GetDimensions()[k])*(this->ImageData->GetSpacing()[k]))/2;
+
+ this->Properties->xIPW->SetSlicePosition(center[0]);
+ this->Properties->yzIPW->SetSlicePosition(center[0]);
+ this->Properties->yIPW->SetSlicePosition(center[1]);
+ this->Properties->xzIPW->SetSlicePosition(center[1]);
+ this->Properties->zIPW->SetSlicePosition(center[2]);
+ this->Properties->xyIPW->SetSlicePosition(center[2]);
+
+ /// Update Properties->position to fit to the new position
+ this->Properties->position[0] = center[0];
+ this->Properties->position[1] = center[1];
+ this->Properties->position[2] = center[2];
+
+ /// Update renderer
+ this->UpdateViewer(0,this->ZoomLabel,this->RenXY);
+ this->UpdateViewer(1,this->ZoomLabel,this->RenXZ);
+ this->UpdateViewer(2,this->ZoomLabel,this->RenYZ);
+ this->GetRenderWindow()->Render();
+
+}
+
+
+void OpenHeartGui::UpdateViewer(int view, double zoom, vtkRenderer *ren)
+{
+
+ /// Set Focal Point
+ double center[3];
+ for (int i=0; i<3; i++)
+ center[i] = 0.5 * this->ImageData->GetDimensions()[i] * this->ImageData->GetSpacing()[i];
+ ren->GetActiveCamera()->SetFocalPoint(center);
+
+ /// Set Position
+ double position[3];
+ double newPosition[3];
+ switch (view)
+ {
+ case 0: /// XY view
+ position[0] = 0.5 * this->ImageData->GetDimensions()[0] * this->ImageData->GetSpacing()[0];
+ position[1] = 0.5 * this->ImageData->GetDimensions()[1] * this->ImageData->GetSpacing()[1];
+ position[2] = 10 * this->ImageData->GetDimensions()[2] * this->ImageData->GetSpacing()[2];
+ break;
+ case 1: /// XZ view
+ position[0] = 0.5 * this->ImageData->GetDimensions()[0] * this->ImageData->GetSpacing()[0];
+ position[1] = 10 * this->ImageData->GetDimensions()[1] * this->ImageData->GetSpacing()[1];
+ position[2] = 0.5 * this->ImageData->GetDimensions()[2] * this->ImageData->GetSpacing()[2];
+ break;
+ case 2: /// YZ view
+ position[0] = 10 * this->ImageData->GetDimensions()[0] * this->ImageData->GetSpacing()[0];
+ position[1] = 0.5 * this->ImageData->GetDimensions()[1] * this->ImageData->GetSpacing()[1];
+ position[2] = 0.5 * this->ImageData->GetDimensions()[2] * this->ImageData->GetSpacing()[2];
+ }
+ for (int i=0; i<3; i++)
+ position[i] = position[i] - center[i];
+ this->TransformViewOrientation->TransformPoint(position,newPosition);
+ for (int i=0; i<3; i++)
+ newPosition[i] = newPosition[i] + center[i];
+ ren->GetActiveCamera()->SetPosition(newPosition);
+
+ /// Set ViewUp
+ double pt[] = {0,0,-1};
+ double viewup[3];
+ this->TransformViewOrientation->TransformPoint(pt,viewup);
+ ren->GetActiveCamera()->SetViewUp(viewup);
+ ren->ResetCamera();
+ ren->GetActiveCamera()->Zoom(zoom);
+ ren->GetRenderWindow()->Render();
+
+}
+
+
+void OpenHeartGui::ComputePointBeforeRotation(double *position)
+{
+
+ double center[3];
+ double newPosition[3];
+ for (int i=0; i<3; i++)
+ center[i] = 0.5 * this->ImageData->GetDimensions()[i] * this->ImageData->GetSpacing()[i];
+
+ for (int i=0; i<3; i++)
+ position[i] = position[i] - center[i];
+ this->TransformViewOrientationInv->TransformPoint(position,newPosition);
+ for (int i=0; i<3; i++)
+ position[i] = newPosition[i] + center[i];
+
+}
git://git.creatis.insa-lyon.fr / openheart.git / blobdiff