View difference between Paste ID: EcMyVBRH and fkDDf5k5

 // The original code is from VTK's Examples from here:
 // https://github.com/Kitware/VTK/tree/master/Examples/GUI/Qt/FourPaneViewer
 // This link also includes the necessary .ui file for Qt
 // and the cmake file.
 //
 // Note: In QtVTKRenderWindows.cxx you may want to change
 // the path to the Dicom directory to an appropriate location.
 
 //==========================
 //QtVTKRenderWindows.h
 //==========================
 
 #ifndef QtVTKRenderWindows_H
 #define QtVTKRenderWindows_H
 
 #include "vtkSmartPointer.h"
 #include "vtkResliceImageViewer.h"
 #include "vtkImagePlaneWidget.h"
 #include "vtkDistanceWidget.h"
 #include "vtkResliceImageViewerMeasurements.h"
 #include <QMainWindow>
 
 // Forward Qt class declarations
 class Ui_QtVTKRenderWindows;
 
 class QtVTKRenderWindows : public QMainWindow
 {
   Q_OBJECT
 public:
 
   // Constructor/Destructor
   QtVTKRenderWindows(int argc, char *argv[]);
   ~QtVTKRenderWindows() {};
 
 public slots:
   virtual void resliceMode(int);
   virtual void Render();
 
 protected:
   vtkSmartPointer< vtkResliceImageViewer > riw[3];
   vtkSmartPointer< vtkImagePlaneWidget > planeWidget[3];
   vtkSmartPointer< vtkDistanceWidget > DistanceWidget[3];
   vtkSmartPointer< vtkResliceImageViewerMeasurements > ResliceMeasurements;
 
 private:
 
   // Designer form
   Ui_QtVTKRenderWindows *ui;
 };
 
 #endif // QtVTKRenderWindows_H
 
 //============================
 //QtVTKRenderWindows.cxx
 //============================
 
 #include "ui_QtVTKRenderWindows.h"
 #include "QtVTKRenderWindows.h"
 
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
 #include "vtkResliceImageViewer.h"
 #include "vtkResliceCursorLineRepresentation.h"
 #include "vtkResliceCursorThickLineRepresentation.h"
 #include "vtkResliceCursorWidget.h"
 #include "vtkResliceCursorActor.h"
 #include "vtkResliceCursorPolyDataAlgorithm.h"
 #include "vtkResliceCursor.h"
 #include "vtkDICOMImageReader.h"
 #include "vtkCellPicker.h"
 #include "vtkProperty.h"
 #include "vtkPlane.h"
 #include "vtkImageData.h"
 #include "vtkCommand.h"
 #include "vtkPlaneSource.h"
 #include "vtkLookupTable.h"
 #include "vtkImageMapToWindowLevelColors.h"
 #include "vtkInteractorStyleImage.h"
 #include "vtkImageSlabReslice.h"
 #include "vtkBoundedPlanePointPlacer.h"
 #include "vtkDistanceWidget.h"
 #include "vtkDistanceRepresentation.h"
 #include "vtkHandleRepresentation.h"
 #include "vtkResliceImageViewerMeasurements.h"
 #include "vtkDistanceRepresentation2D.h"
 #include "vtkPointHandleRepresentation3D.h"
 #include "vtkPointHandleRepresentation2D.h"
 #include <qdebug.h>
 
 #include <vtkPolyDataMapper.h>
 #include <vtkObjectFactory.h>
 #include <vtkActor.h>
 #include <vtkSmartPointer.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkPolyData.h>
 #include <vtkSphereSource.h>
 #include <vtkInteractorStyleTrackballCamera.h>
 #include "QVTKWidget.h"
 #include <QKeyEvent>
 
 //----------------------------------------------------------------------------
 // NEW: Define interactor
 class myRenderWindowInteractor : public QVTKInteractor  //vtkRenderWindowInteractor
 {
 public:
 	static myRenderWindowInteractor* New(); //return new KeyPressInteractorStyle;
 	vtkTypeMacro(myRenderWindowInteractor, QVTKInteractor);
 
 	virtual void OnChar(){qDebug()<<"OnChar() event stopped";};
 	virtual void OnKeyDown(){qDebug()<<"OnKeyDown() event stopped";};
 	virtual void OnKeyUp(){qDebug()<<"OnKeyUp() event stopped";};
 	virtual void OnKeyPress(){qDebug()<<"OnKeyPress() event stopped";};
 	virtual void OnKeyRelease(){qDebug()<<"OnKeyRelease() event stopped";};
 };
 vtkStandardNewMacro(myRenderWindowInteractor);
 
 // Define interaction style
 class KeyPressInteractorStyle : public vtkInteractorStyle
 {
 public:
 	static KeyPressInteractorStyle* New();
 	vtkTypeMacro(KeyPressInteractorStyle, vtkInteractorStyle);
 
 	virtual void OnKeyPress()
 	{
 		// Get the keypress
 		vtkRenderWindowInteractor *rwi = this->Interactor;
 		std::string key = rwi->GetKeySym();
 
 		// Output the key that was pressed
 		std::cout << "Pressed " << key << std::endl;
 		qDebug()<< "Pressed " << rwi->GetKeySym();
 
 		// Forward events
 		vtkInteractorStyle::OnKeyPress();
 	}
 
 	virtual void OnChar()
 	{
 
 		qDebug()<<"keeeey";
 	}
 
 };
 vtkStandardNewMacro(KeyPressInteractorStyle);
 
 class MouseInteractorStyleDoubleClick : public vtkInteractorStyleTrackballCamera
 {
 public:
 
 	static MouseInteractorStyleDoubleClick* New();
 	vtkTypeMacro(MouseInteractorStyleDoubleClick, vtkInteractorStyleTrackballCamera);
 
 	MouseInteractorStyleDoubleClick() : NumberOfClicks(0), ResetPixelDistance(5)
 	{
 		this->PreviousPosition[0] = 0;
 		this->PreviousPosition[1] = 0;
 	}
 
 	virtual void OnLeftButtonDown()
 	{
 		//std::cout << "Pressed left mouse button." << std::endl;
 		this->NumberOfClicks++;
 		//std::cout << "NumberOfClicks = " << this->NumberOfClicks << std::endl;
 		int pickPosition[2];
 		this->GetInteractor()->GetEventPosition(pickPosition);
 
 		int xdist = pickPosition[0] - this->PreviousPosition[0];
 		int ydist = pickPosition[1] - this->PreviousPosition[1];
 
 		this->PreviousPosition[0] = pickPosition[0];
 		this->PreviousPosition[1] = pickPosition[1];
 
 		int moveDistance = (int)sqrt((double)(xdist*xdist + ydist*ydist));
 
 		// Reset numClicks - If mouse moved further than resetPixelDistance
 		if(moveDistance > this->ResetPixelDistance)
 		{
 			this->NumberOfClicks = 1;
 		}
 
 
 		if(this->NumberOfClicks == 2)
 		{
 			std::cout << "Double clicked." << std::endl;
 			this->NumberOfClicks = 0;
 		}
 		// forward events
 		vtkInteractorStyleTrackballCamera::OnLeftButtonDown();
 	}
 
 private:
 	unsigned int NumberOfClicks;
 	int PreviousPosition[2];
 	int ResetPixelDistance;
 };
 vtkStandardNewMacro(MouseInteractorStyleDoubleClick);
 
 
 //----------------------------------------------------------------------------
 class vtkResliceCursorCallback : public vtkCommand
 {
 public:
 
 	static vtkResliceCursorCallback *New()
 	{
 		return new vtkResliceCursorCallback; }
 
 	void Execute( vtkObject *caller, unsigned long ev,
 		void *callData )
 	{
 
 		if (ev == vtkCommand::KeyPressEvent)
 		{
 			QKeyEvent* keyPressed = static_cast<QKeyEvent*>(callData);
 
 			qDebug()<<"key pressed: "<<keyPressed->text();
 		}
 
 		if (ev == vtkResliceCursorWidget::WindowLevelEvent ||
 			ev == vtkCommand::WindowLevelEvent ||
 			ev == vtkResliceCursorWidget::ResliceThicknessChangedEvent||
 			ev == vtkResliceCursorWidget::ResliceAxesChangedEvent||
 			ev == vtkResliceCursorWidget::ResetCursorEvent)
 		{
 			//do nothing
 		}
 
 		vtkImagePlaneWidget* ipw =
 			dynamic_cast< vtkImagePlaneWidget* >( caller );
 		if (ipw)
 		{
 			double* wl = static_cast<double*>( callData );
 
 			if ( ipw == this->IPW[0] )
 			{
 
 				this->IPW[1]->SetWindowLevel(wl[0],wl[1],1);
 				this->IPW[2]->SetWindowLevel(wl[0],wl[1],1);
 
 			}
 			else if( ipw == this->IPW[1] )
 			{
 				this->IPW[0]->SetWindowLevel(wl[0],wl[1],1);
 				this->IPW[2]->SetWindowLevel(wl[0],wl[1],1);
 			}
 			else if (ipw == this->IPW[2])
 			{
 				this->IPW[0]->SetWindowLevel(wl[0],wl[1],1);
 				this->IPW[1]->SetWindowLevel(wl[0],wl[1],1);
 			}
 		}
 
 		vtkResliceCursorWidget *rcw = dynamic_cast<
 			vtkResliceCursorWidget * >(caller);
 		if (rcw)
 		{
 			vtkResliceCursorLineRepresentation *rep = dynamic_cast<
 				vtkResliceCursorLineRepresentation * >(rcw->GetRepresentation());
 			// Although the return value is not used, we keep the get calls
 			// in case they had side-effects
-	vtkSmartPointer<KeyPressInteractorStyle> style = vtkSmartPointer<KeyPressInteractorStyle>::New();
+
 			for (int i = 0; i < 3; i++)
-	this->ui->view1->GetInteractor()->SetInteractorStyle(style);
+
-	//this->ui->view1->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
+
-	//this->ui->view1->GetRenderWindow()->AddRenderer(riw[0]->GetRenderer());
+
-	style->SetCurrentRenderer(riw[0]->GetRenderer());
+
 					GetPlaneSource()->GetOrigin());
 				ps->SetPoint1(this->RCW[i]->GetResliceCursorRepresentation()->
-	riw[0]->SetupInteractor(
+
-		this->ui->view1->GetRenderWindow()->GetInteractor());
+
-
+
-	this->ui->view2->SetRenderWindow(riw[1]->GetRenderWindow());
+
-	riw[1]->SetupInteractor(
+
-		this->ui->view2->GetRenderWindow()->GetInteractor());
+
 			}
 		}
-	riw[2]->SetupInteractor(
+
-		this->ui->view3->GetRenderWindow()->GetInteractor());
+
 		{
 			for (int i = 0; i < 3; i++)
 			{
 				vtkPlaneSource *ps = static_cast< vtkPlaneSource * >(
 					this->IPW[i]->GetPolyDataAlgorithm());
 				ps->SetOrigin(this->RCW[i]->GetResliceCursorRepresentation()->
 					GetPlaneSource()->GetOrigin());
 				ps->SetPoint1(this->RCW[i]->GetResliceCursorRepresentation()->
 					GetPlaneSource()->GetPoint1());
 				ps->SetPoint2(this->RCW[i]->GetResliceCursorRepresentation()->
 					GetPlaneSource()->GetPoint2());
 
 				// If the reslice plane has modified, update it on the 3D widget
 				this->IPW[i]->UpdatePlacement();
 			}
 		}
 
 		// Render everything
 		for (int i = 0; i < 3; i++)
 		{
 			this->RCW[i]->Render();
 		}
 		this->IPW[0]->GetInteractor()->GetRenderWindow()->Render();
 	}
 
 	vtkResliceCursorCallback() {}
 	vtkImagePlaneWidget* IPW[3];
 	vtkResliceCursorWidget *RCW[3];
 };
 
 
 QtVTKRenderWindows::QtVTKRenderWindows( int vtkNotUsed(argc), char *argv[])
 {
 	this->ui = new Ui_QtVTKRenderWindows;
 	this->ui->setupUi(this);
 
 	vtkSmartPointer< vtkDICOMImageReader > reader =
 		vtkSmartPointer< vtkDICOMImageReader >::New();
 	//reader->SetDirectoryName(argv[1]);
 	reader->SetDirectoryName("C:/Users/Panayiotis/DentalCEsse/qt_interface/build/Release/temp_dental/2/dicom");
 	reader->Update();
 	int imageDims[3];
 	reader->GetOutput()->GetDimensions(imageDims);
 
 
 	for (int i = 0; i < 3; i++)
 	{
 		riw[i] = vtkSmartPointer< vtkResliceImageViewer >::New();
 	}
 
 	vtkSmartPointer<myRenderWindowInteractor> myInteractor1 = vtkSmartPointer<myRenderWindowInteractor>::New();
 	vtkSmartPointer<myRenderWindowInteractor> myInteractor2 = vtkSmartPointer<myRenderWindowInteractor>::New();
 	vtkSmartPointer<myRenderWindowInteractor> myInteractor3 = vtkSmartPointer<myRenderWindowInteractor>::New();
 
 	this->ui->view1->SetRenderWindow(riw[0]->GetRenderWindow());
 	this->ui->view2->SetRenderWindow(riw[1]->GetRenderWindow());
 	this->ui->view3->SetRenderWindow(riw[2]->GetRenderWindow());
 
 	riw[2]->SetupInteractor(this->ui->view3->GetRenderWindow()->GetInteractor());
 	riw[1]->SetupInteractor(this->ui->view2->GetRenderWindow()->GetInteractor());
 	riw[0]->SetupInteractor(this->ui->view1->GetRenderWindow()->GetInteractor());
 
 	myInteractor1->SetRenderWindow(this->ui->view1->GetRenderWindow());
 	myInteractor2->SetRenderWindow(this->ui->view2->GetRenderWindow());
 	myInteractor3->SetRenderWindow(this->ui->view3->GetRenderWindow());
 
 	for (int i = 0; i < 3; i++)
 	{
 		// make them all share the same reslice cursor object.
 		vtkResliceCursorLineRepresentation *rep =
 			vtkResliceCursorLineRepresentation::SafeDownCast(
 			riw[i]->GetResliceCursorWidget()->GetRepresentation());
 		riw[i]->SetResliceCursor(riw[0]->GetResliceCursor());
 
 		rep->GetResliceCursorActor()->
 			GetCursorAlgorithm()->SetReslicePlaneNormal(i);
 
 		riw[i]->SetInput(reader->GetOutput());
 		riw[i]->SetSliceOrientation(i);
 		riw[i]->SetResliceModeToAxisAligned();
 	}
 
 	vtkSmartPointer<vtkCellPicker> picker =
 		vtkSmartPointer<vtkCellPicker>::New();
 	picker->SetTolerance(0.005);
 
 	vtkSmartPointer<vtkProperty> ipwProp =
 		vtkSmartPointer<vtkProperty>::New();
 
 	vtkSmartPointer< vtkRenderer > ren =
 		vtkSmartPointer< vtkRenderer >::New();
 
 
 
 	this->ui->view4->GetRenderWindow()->AddRenderer(ren);
 	vtkRenderWindowInteractor *iren = this->ui->view4->GetInteractor();
 	//commenting out the following code succesfully applies the
 	//'style' to view4
 	//iren->SetInteractorStyle(style);
 	//style->SetCurrentRenderer(ren);
 
 
 	//vtkSmartPointer<MouseInteractorStyleDoubleClick> style2 =   vtkSmartPointer<MouseInteractorStyleDoubleClick>::New();
 	//this->ui->view4->GetRenderWindow()->GetInteractor()->SetInteractorStyle( style2 );
 
 	for (int i = 0; i < 3; i++)
 	{
 		planeWidget[i] = vtkSmartPointer<vtkImagePlaneWidget>::New();
 		planeWidget[i]->SetInteractor( iren );
 		planeWidget[i]->SetPicker(picker);
 		planeWidget[i]->RestrictPlaneToVolumeOn();
 		double color[3] = {0, 0, 0};
 		color[i] = 1;
 		planeWidget[i]->GetPlaneProperty()->SetColor(color);
 
 		color[i] = 0.25;
 		riw[i]->GetRenderer()->SetBackground( color );
 
 		planeWidget[i]->SetTexturePlaneProperty(ipwProp);
 		planeWidget[i]->TextureInterpolateOff();
 		planeWidget[i]->SetResliceInterpolateToCubic();
 		planeWidget[i]->SetInput(reader->GetOutput());
 		planeWidget[i]->SetPlaneOrientation(i);
 		planeWidget[i]->SetSliceIndex(imageDims[i]/2);
 		planeWidget[i]->DisplayTextOn();
 		planeWidget[i]->SetDefaultRenderer(ren);
 		planeWidget[i]->On();
 		planeWidget[i]->InteractionOn();
 		planeWidget[i]->SetTextureVisibility(0);
 	}
 
 	vtkSmartPointer<vtkResliceCursorCallback> cbk =
 		vtkSmartPointer<vtkResliceCursorCallback>::New();
 
 	for (int i = 0; i < 3; i++)
 	{
 		cbk->IPW[i] = planeWidget[i];
 		cbk->RCW[i] = riw[i]->GetResliceCursorWidget();
 		riw[i]->GetResliceCursorWidget()->AddObserver(
 			vtkResliceCursorWidget::ResliceAxesChangedEvent, cbk );
 
 		riw[i]->GetResliceCursorWidget()->AddObserver(
 			vtkResliceCursorWidget::WindowLevelEvent, cbk );
 
 		riw[i]->GetResliceCursorWidget()->AddObserver(
 			vtkResliceCursorWidget::ResliceThicknessChangedEvent, cbk );
 
 		riw[i]->GetResliceCursorWidget()->AddObserver(
 			vtkResliceCursorWidget::ResetCursorEvent, cbk );
 
 		riw[i]->GetInteractorStyle()->AddObserver(
 			vtkCommand::WindowLevelEvent, cbk );
 
 		riw[i]->AddObserver(vtkResliceImageViewer::SliceChangedEvent,cbk);
 
 		// Make them all share the same color map.
 		riw[i]->SetLookupTable(riw[0]->GetLookupTable());
 		planeWidget[i]->GetColorMap()->SetLookupTable(riw[0]->GetLookupTable());
 		planeWidget[i]->SetColorMap(riw[i]->GetResliceCursorWidget()->GetResliceCursorRepresentation()->GetColorMap());
 
 	}
 
 	//riw[0]->GetRenderWindow()->GetInteractor()->AddObserver(vtkCommand::KeyPressEvent,cbk);
 
 	resliceMode(1);
 	this->ui->resliceModeCheckBox->setChecked(true);
 
 	vtkSmartPointer<KeyPressInteractorStyle> style1 = vtkSmartPointer<KeyPressInteractorStyle>::New();
 	vtkSmartPointer<KeyPressInteractorStyle> style2 = vtkSmartPointer<KeyPressInteractorStyle>::New();
 	vtkSmartPointer<KeyPressInteractorStyle> style3 = vtkSmartPointer<KeyPressInteractorStyle>::New();
 	vtkSmartPointer<KeyPressInteractorStyle> style4 = vtkSmartPointer<KeyPressInteractorStyle>::New();
 
 	this->ui->view1->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style1);
 	this->ui->view2->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style2);
 	this->ui->view3->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style3);
 	//this->ui->view4->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style4);  //don't need it on 4th view
 
 	this->ui->view1->show();
 	this->ui->view2->show();
 	this->ui->view3->show();
 
 	// Set up action signals and slots
 	this->ui->thickModeCheckBox->setEnabled(0);
 	this->ui->resliceModeCheckBox->setEnabled(0);
 
 	this->ui->blendModeGroupBox->setEnabled(0);
 	this->ui->resetButton->setEnabled(0);
 	this->ui->AddDistance1Button->setEnabled(0);
 };
 
 void QtVTKRenderWindows::resliceMode(int mode)
 {
 	for (int i = 0; i < 3; i++)
 	{
 		riw[i]->SetResliceMode(mode ? 1 : 0);
 		riw[i]->GetRenderer()->ResetCamera();
 		riw[i]->Render();
 	}
 }
 
 void QtVTKRenderWindows::Render()
 {
 	for (int i = 0; i < 3; i++)
 	{
 		riw[i]->Render();
 	}
 	this->ui->view3->GetRenderWindow()->Render();
 }
 
 //==================================
 //QtVTKRenderWindowsApp.cxx
 //==================================
 
 #include <QApplication>
 #include "QtVTKRenderWindows.h"
 
 int main( int argc, char** argv )
 {
   // QT Stuff
   QApplication app( argc, argv );
 
   QtVTKRenderWindows myQtVTKRenderWindows(argc, argv);
   myQtVTKRenderWindows.show();
 
   return app.exec();
 }