MPR Reslice hair cross moving and slicing.

src/src/Interaction/ResliceImageInteractorStyle.cpp

@@ -13,6 +13,7 @@
 #include <vtkPropCollection.h>
 #include <vtkPropPicker.h>
 
+#include "Rendering/Core/RenderingDefines.h"
 #include "Rendering/Legend/ResliceCursorLegendActor.h"
 
 vtkStandardNewMacro(ResliceImageInteractorStyle)
@@ -21,7 +22,7 @@ ResliceImageInteractorStyle::ResliceImageInteractorStyle():vtkInteractorStyleIma
     picker = vtkPropPicker::New();
     picker->Register(this);
     picker->Delete();
-    this->InteractionMode = VTKIS_IMAGE2D;
+    this->InteractionMode = VTKIS_IMAGE_SLICING;
     SetCurrentImageNumber(0);
 }
 
@@ -61,6 +62,7 @@ void ResliceImageInteractorStyle::OnMouseMove() {
         case VTKIS_SLICE:
             this->FindPokedRenderer(x, y);
             this->Slice();
+            this->InvokeEvent(SliceEvent, nullptr);
             this->InvokeEvent(vtkCommand::InteractionEvent, nullptr);
             break;
     }
@@ -111,7 +113,7 @@ void ResliceImageInteractorStyle::OnLeftButtonDown() {
 }
 
 void ResliceImageInteractorStyle::OnLeftButtonUp() {
-    this->InvokeEvent(ResliceCursorLegendActor::IMAGE_INTERACT_OFF);
+
 
     if (this->CurrentProp){
         StopCursorInteractive();
@@ -121,6 +123,7 @@ void ResliceImageInteractorStyle::OnLeftButtonUp() {
     else {
         vtkInteractorStyleImage::OnLeftButtonUp();
     }
+    this->InvokeEvent(ResliceCursorLegendActor::IMAGE_INTERACT_OFF);
 }
 
 void ResliceImageInteractorStyle::NoneStatePick() {

src/src/Rendering/Legend/ResliceCursorLegendActor.cpp

@@ -297,12 +297,8 @@ void ResliceCursorLegendActor::ApplyRoll(vtkRenderer * renderer) {
 
 void ResliceCursorLegendActor::ApplyMove(vtkRenderer * renderer) {
     int *pos = renderer->GetRenderWindow()->GetInteractor()->GetEventPosition();
-    if (!Moving){
+    double pt1[4] = {pos[0] + 0.5 ,
-        LastSliceDisplayPoint[0]=SliceDisplayPoint[0];
+                     pos[1] + 0.5 ,
-        LastSliceDisplayPoint[1]=SliceDisplayPoint[1];
-    }
-    double pt1[4] = {LastSliceDisplayPoint[0]+(pos[0]-DragStartPosition[0]) + 0.5 ,
-                     LastSliceDisplayPoint[1]+(pos[1]-DragStartPosition[1]) + 0.5 ,
                      0,
                      1.0};
     renderer->SetDisplayPoint(pt1);
@@ -320,7 +316,6 @@ void ResliceCursorLegendActor::ApplyMove(vtkRenderer * renderer) {
         if (ReferenceCursor){
             ReferenceCursor->SetSlicePoint(intersectPoint);
         }
-        this->InvokeEvent(MOVE);
     }
 }
 
@@ -349,24 +344,6 @@ void ResliceCursorLegendActor::UpdateCursor3DPoint(vtkRenderer * renderer) {
     renderer->DisplayToWorld();
     renderer->GetWorldPoint(worldPt2);
 
-    vtkNew<vtkPlane> plane;
-    plane->SetOrigin(GetSlicePoint());
-    plane->SetNormal(GetProjectDirectionVector());
-    double t;
-    double wpt_end[4] = {worldPt1[0] + 10000.0 * ProjectDirectionVector[0],
-                         worldPt1[1] + 10000.0 * ProjectDirectionVector[1],
-                         worldPt1[2] + 10000.0 * ProjectDirectionVector[2],
-                     1.0};
-    double newPt1[4] = {.0,.0,.0,1.};
-    int ret = plane->IntersectWithLine(worldPt1,wpt_end,t,newPt1);
-
-    double wpt_end2[4] = {worldPt2[0] + 10000.0 * ProjectDirectionVector[0],
-                  worldPt2[1] + 10000.0 * ProjectDirectionVector[1],
-                  worldPt2[2] + 10000.0 * ProjectDirectionVector[2],
-                  1.0};
-    double newPt2[4] = {.0,.0,.0,1.};
-    ret = plane->IntersectWithLine(worldPt2,wpt_end2,t,newPt2);
-
     double vector[3] = {worldPt2[0]-worldPt1[0],worldPt2[1]-worldPt1[1],worldPt2[2]-worldPt1[2]};
     vtkMath::Cross(vector, GetProjectDirectionVector(), vector);
     this->SetSliceDirectionVector(vector);

src/src/Rendering/Viewer/ResliceImageViewer.cpp

@@ -22,6 +22,7 @@
 #include "Rendering/Legend/FastCornerAnnotationActor.h"
 #include "Rendering/Legend/ResliceSquareLegendActor.h"
 #include "Interaction/ResliceImageInteractorStyle.h"
+#include "Rendering/Core/RenderingDefines.h"
 
 namespace {
     void GetDirectionString(const double *directionVector, std::string &str) {
@@ -224,8 +225,10 @@ void ResliceImageViewer::Render() {
             cursor2->SetSliceDirectionVector(sliceDirection2);
             this->InteractorStyle->AddObserver(ResliceCursorLegendActor::MOUSE_FREE_MOVE,this,&ResliceImageViewer::updateHandle);
             this->InteractorStyle->AddObserver(ResliceCursorLegendActor::IMAGE_INTERACT_ON,cursor1,&ResliceCursorLegendActor::ActiveControlPointOff);
+            this->InteractorStyle->AddObserver(ResliceCursorLegendActor::IMAGE_INTERACT_ON,this,&ResliceImageViewer::InvokeClick);
             this->InteractorStyle->AddObserver(ResliceCursorLegendActor::IMAGE_INTERACT_OFF,this,&ResliceImageViewer::ResetHandle);
             this->InteractorStyle->AddObserver(ResliceCursorLegendActor::END_DRAG,this,&ResliceImageViewer::EndDrag);
+            this->InteractorStyle->AddObserver(SliceEvent,this, &ResliceImageViewer::SliceCallback);
 
             this->RenderWindow->AddObserver(vtkCommand::WindowResizeEvent,this,&ResliceImageViewer::handleResize);
             cursor1->AddObserver(ResliceCursorLegendActor::ROLL,this, &ResliceImageViewer::handleRoll);
@@ -328,7 +331,32 @@ void ResliceImageViewer::ChangeSliceNormal(double *normal) {
 }
 
 void ResliceImageViewer::ChangeSlicePoint(double *point) {
+    SetCameraFocalPoint(point);
+    //avoid cursor update by camera modified
+    cursor1->SetSlicePoint(point);
+    cursor2->SetSlicePoint(point);
+}
 
+void ResliceImageViewer::SetCameraFocalPoint(const double *point) const {
+    auto camera = Renderer->GetActiveCamera();
+    double focalPt[3] = {.0, .0, .0};
+    camera->GetFocalPoint(focalPt);
+    double position[3] = {.0, .0, .0};
+    camera->GetPosition(position);
+    double vector[3] = {point[0] - focalPt[0],
+                        point[1] - focalPt[1],
+                        point[2] - focalPt[2]};
+    for (int i = 0; i < 3; ++i) {
+        position[i] += vector[i];
+    }
+    camera->SetPosition(position);
+    camera->SetFocalPoint(point);
+    Renderer->ResetCameraClippingRange();
+}
+
+void ResliceImageViewer::AdjustCameraFollowCursor() {
+    this->SetCameraFocalPoint(this->GetCursorSlicePoint());
+    Render();
 }
 
 void ResliceImageViewer::UpdateSliceCursor() {
@@ -336,7 +364,7 @@ void ResliceImageViewer::UpdateSliceCursor() {
     cursor1->UpdateCursor3DPoint(Renderer);
     cursor2->SetProjectDirectionVector(Renderer->GetActiveCamera()->GetDirectionOfProjection());
     cursor2->UpdateCursor3DPoint(Renderer);
-    Renderer->Render();
+    Render();
 }
 
 void ResliceImageViewer::EndDrag() {
@@ -389,3 +417,25 @@ void ResliceImageViewer::ResetHandle() {
     cursor1->UpdateMousePosition(pos);
     cursor2->UpdateMousePosition(pos);
 }
+
+void ResliceImageViewer::SetChecked(bool checked) {
+    if (Square->GetChecked()!= checked){
+        Square->SetChecked(checked);
+        Render();
+    }
+
+}
+
+void ResliceImageViewer::InvokeClick() {
+    this->InvokeEvent(vtkCommand::LeftButtonPressEvent);
+}
+
+void ResliceImageViewer::SliceCallback() {
+    if (this->InteractorStyle->GetState() == VTKIS_SLICE)
+    {
+        auto camera = Renderer->GetActiveCamera();
+        cursor1->SetSlicePoint(camera->GetFocalPoint());
+        cursor2->SetSlicePoint(camera->GetFocalPoint());
+        this->InvokeEvent(SliceEvent);
+    }
+}

src/src/Rendering/Viewer/ResliceImageViewer.h

@@ -6,6 +6,7 @@
 #define OMEGAV_RESLICEIMAGEVIEWER_H
 
 #include "vtkObject.h"
+#include "vtkCommand.h"
 
 class vtkImageData;
 
@@ -54,7 +55,11 @@ public:
     void ChangeSliceNormal(double * normal);
     void EndDrag();
     void UpdateSliceCursor();
+    void AdjustCameraFollowCursor();
 
+    void SetChecked(bool checked);
+    void InvokeClick();
+    void SliceCallback();
 protected:
     ResliceImageViewer();
 
@@ -91,6 +96,8 @@ private:
     vtkMatrix4x4* OrientationMatrix;
     int DefaultOrientation;
     bool FirstRender;
+
+    void SetCameraFocalPoint(const double *point) const;
 };
 
 

src/src/UI/Manager/ResliceImageManager.cpp

@@ -8,6 +8,7 @@
 
 #include "Rendering/Viewer/ResliceImageViewer.h"
 #include "Rendering/Legend/ResliceCursorLegendActor.h"
+#include "Rendering/Core/RenderingDefines.h"
 
 ResliceImageManager::ResliceImageManager(QObject *parent) : QObject(parent) {
 
@@ -34,9 +35,18 @@ void ResliceImageManager::InitEvents() {
     viewerA->AddObserver(ResliceCursorLegendActor::ROLL,this,&ResliceImageManager::RollCallback);
     viewerS->AddObserver(ResliceCursorLegendActor::ROLL,this,&ResliceImageManager::RollCallback);
     viewerC->AddObserver(ResliceCursorLegendActor::ROLL,this,&ResliceImageManager::RollCallback);
+    viewerA->AddObserver(ResliceCursorLegendActor::MOVE,this,&ResliceImageManager::MoveCallback);
+    viewerS->AddObserver(ResliceCursorLegendActor::MOVE,this,&ResliceImageManager::MoveCallback);
+    viewerC->AddObserver(ResliceCursorLegendActor::MOVE,this,&ResliceImageManager::MoveCallback);
     viewerA->AddObserver(ResliceCursorLegendActor::END_DRAG,this,&ResliceImageManager::EndDrag);
     viewerS->AddObserver(ResliceCursorLegendActor::END_DRAG,this,&ResliceImageManager::EndDrag);
     viewerC->AddObserver(ResliceCursorLegendActor::END_DRAG,this,&ResliceImageManager::EndDrag);
+    viewerA->AddObserver(vtkCommand::LeftButtonPressEvent,this,&ResliceImageManager::ClickCallback);
+    viewerS->AddObserver(vtkCommand::LeftButtonPressEvent,this,&ResliceImageManager::ClickCallback);
+    viewerC->AddObserver(vtkCommand::LeftButtonPressEvent,this,&ResliceImageManager::ClickCallback);
+    viewerA->AddObserver(SliceEvent,this,&ResliceImageManager::MoveCallback);
+    viewerS->AddObserver(SliceEvent,this,&ResliceImageManager::MoveCallback);
+    viewerC->AddObserver(SliceEvent,this,&ResliceImageManager::MoveCallback);
 }
 
 void ResliceImageManager::RollCallback(vtkObject *sender, unsigned long eventID, void *data) {
@@ -64,20 +74,46 @@ void ResliceImageManager::RollCallback(vtkObject *sender, unsigned long eventID,
 
 }
 
-void ResliceImageManager::EndDrag(vtkObject *sender, unsigned long eventID, void *data) {
+void ResliceImageManager::MoveCallback(vtkObject *sender, unsigned long eventID, void *data) {
     auto viewer = ResliceImageViewer::SafeDownCast(sender);
     if (viewer){
         if (viewer!=viewerA){
-            viewerA->UpdateSliceCursor();
+            viewerA->ChangeSlicePoint(viewer->GetCursorSlicePoint());
             viewerA->Render();
         }
-        if (viewer!=viewerC){
-            viewerC->UpdateSliceCursor();
-            viewerC->Render();
-        }
         if (viewer!=viewerS){
-            viewerS->UpdateSliceCursor();
+            viewerS->ChangeSlicePoint(viewer->GetCursorSlicePoint());
             viewerS->Render();
         }
+        if (viewer!=viewerC){
+            viewerC->ChangeSlicePoint(viewer->GetCursorSlicePoint());
+            viewerC->Render();
+        }
     }
 }
+
+void ResliceImageManager::EndDrag(vtkObject *sender, unsigned long eventID, void *data) {
+    auto viewer = ResliceImageViewer::SafeDownCast(sender);
+    if (viewer){
+        viewer->AdjustCameraFollowCursor();
+        if (viewer!=viewerA){
+            viewerA->UpdateSliceCursor();
+        }
+        if (viewer!=viewerC){
+            viewerC->UpdateSliceCursor();
+        }
+        if (viewer!=viewerS){
+            viewerS->UpdateSliceCursor();
+        }
+    }
+}
+
+void ResliceImageManager::ClickCallback(vtkObject *sender, unsigned long eventID, void *data) {
+    auto viewer = ResliceImageViewer::SafeDownCast(sender);
+    if (viewer){
+            viewerA->SetChecked(viewer==viewerA);
+            viewerS->SetChecked(viewer==viewerS);
+            viewerC->SetChecked(viewer==viewerC);
+    }
+}
+

src/src/UI/Manager/ResliceImageManager.h

@@ -28,6 +28,9 @@ private:
     ResliceImageViewer * viewerC;
 
     void RollCallback(vtkObject* sender, unsigned long eventID, void* data);
+    void MoveCallback(vtkObject* sender, unsigned long eventID, void* data);
+    void ClickCallback(vtkObject* sender, unsigned long eventID, void* data);
+//    void SliceCallback(vtkObject* sender, unsigned long eventID, void* data);
     void EndDrag(vtkObject* sender, unsigned long eventID, void* data);
 };