ENH: Use pose matrices instead of camera parameters for VR controllers

It is easier to manage controller pose as a matrix instead of the (pos,wxyz,ppos,wdir) variables that the ConvertPoseToWorldCoordinates function calculates. A function called ConvertOpenVRPoseToMatrices was added that calculates the matrix. It is used in various places in addition or instead of those variables.
A PhysicalToWorldMatrixModified event is added to vtkOpenVRRenderWindow to enable notifications to the application when the physical scaling, translation, etc. changes.

Small changes:
- Fix incorrect sign of VR physical to world matrix translation
- Fix gesture end event invocation (Trigger button release was checked instead of Grip, as it is done for press)
- Add comments for physical to world ivars and controller pose camera style variables for easier understanding
- Remove unused PoseTransform member variable from vtkOpenVRRenderWindowInteractor

Author: cpinter

Rendering/Core/vtkRenderWindowInteractor3D.cxx

@@ -25,9 +25,8 @@
 #include "vtkActor.h"
 #include "vtkObjectFactory.h"
 #include "vtkCommand.h"
-#include "vtkNew.h"
-// #include "vtkPropPicker.h"
 #include "vtkMath.h"
+#include "vtkMatrix4x4.h"
 
 vtkStandardNewMacro(vtkRenderWindowInteractor3D);
 
@@ -345,3 +344,113 @@ void vtkRenderWindowInteractor3D::RightButtonReleaseEvent()
   }
   this->InvokeEvent(vtkCommand::RightButtonReleaseEvent, nullptr);
 }
+
+//------------------------------------------------------------------
+void vtkRenderWindowInteractor3D::SetPhysicalEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex)
+{
+  if (!poseMatrix || pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
+  {
+    return;
+  }
+
+  bool poseDifferent = false;
+  for (int i = 0; i < 4; i++)
+  {
+    for (int j = 0; j < 4; j++)
+    {
+      if ( fabs(this->PhysicalEventPoses[pointerIndex]->GetElement(i, j) - poseMatrix->GetElement(i, j)) >= 1e-3 )
+      {
+        poseDifferent = true;
+        break;
+      }
+    }
+  }
+
+
+  if (poseDifferent)
+  {
+    this->LastPhysicalEventPoses[pointerIndex]->DeepCopy(PhysicalEventPoses[pointerIndex]);
+    this->PhysicalEventPoses[pointerIndex]->DeepCopy(poseMatrix);
+    this->Modified();
+  }
+}
+
+//------------------------------------------------------------------
+void vtkRenderWindowInteractor3D::SetWorldEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex)
+{
+  if (!poseMatrix || pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
+  {
+    return;
+  }
+
+  bool poseDifferent = false;
+  for (int i = 0; i < 4; i++)
+  {
+    for (int j = 0; j < 4; j++)
+    {
+      if ( fabs(this->WorldEventPoses[pointerIndex]->GetElement(i, j) - poseMatrix->GetElement(i, j)) >= 1e-3 )
+      {
+        poseDifferent = true;
+        break;
+      }
+    }
+  }
+
+
+  if (poseDifferent)
+  {
+    this->LastWorldEventPoses[pointerIndex]->DeepCopy(WorldEventPoses[pointerIndex]);
+    this->WorldEventPoses[pointerIndex]->DeepCopy(poseMatrix);
+    this->Modified();
+  }
+}
+
+//------------------------------------------------------------------
+void vtkRenderWindowInteractor3D::GetWorldEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex)
+{
+  if (pointerIndex >= VTKI_MAX_POINTERS || !poseMatrix)
+  {
+    return;
+  }
+  poseMatrix->DeepCopy(WorldEventPoses[pointerIndex]);
+}
+
+//------------------------------------------------------------------
+void vtkRenderWindowInteractor3D::GetLastWorldEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex)
+{
+  if (pointerIndex >= VTKI_MAX_POINTERS || !poseMatrix)
+  {
+    return;
+  }
+  poseMatrix->DeepCopy(LastWorldEventPoses[pointerIndex]);
+}
+
+//------------------------------------------------------------------
+void vtkRenderWindowInteractor3D::GetPhysicalEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex)
+{
+  if (pointerIndex >= VTKI_MAX_POINTERS || !poseMatrix)
+  {
+    return;
+  }
+  poseMatrix->DeepCopy(PhysicalEventPoses[pointerIndex]);
+}
+
+//------------------------------------------------------------------
+void vtkRenderWindowInteractor3D::GetLastPhysicalEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex)
+{
+  if (pointerIndex >= VTKI_MAX_POINTERS || !poseMatrix)
+  {
+    return;
+  }
+  poseMatrix->DeepCopy(LastPhysicalEventPoses[pointerIndex]);
+}
+
+//------------------------------------------------------------------
+void vtkRenderWindowInteractor3D::GetStartingPhysicalEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex)
+{
+  if (pointerIndex >= VTKI_MAX_POINTERS || !poseMatrix)
+  {
+    return;
+  }
+  poseMatrix->DeepCopy(StartingPhysicalEventPoses[pointerIndex]);
+}

Rendering/Core/vtkRenderWindowInteractor3D.h

@@ -32,7 +32,10 @@
 #include "vtkRenderingCoreModule.h" // For export macro
 #include "vtkRenderWindowInteractor.h"
 
+#include "vtkNew.h" // ivars
+
 class vtkCamera;
+class vtkMatrix4x4;
 enum class vtkEventDataDevice;
 enum class vtkEventDataDeviceInput;
 
@@ -70,11 +73,9 @@ class VTKRENDERINGCORE_EXPORT vtkRenderWindowInteractor3D : public vtkRenderWind
 
   //@{
   /**
-   * With VR we know the world coordinate positions
-   * and orientations of events. These methods
-   * support querying them instead of going through
-   * a display X,Y coordinate approach as is standard
-   * for mouse/touch events
+   * With VR we know the world coordinate positions and orientations of events.
+   * These methods support querying them instead of going through a display X,Y
+   * coordinate approach as is standard for mouse/touch events
    */
   virtual double *GetWorldEventPosition(int pointerIndex)
   {
@@ -108,13 +109,15 @@ class VTKRENDERINGCORE_EXPORT vtkRenderWindowInteractor3D : public vtkRenderWind
     }
     return this->LastWorldEventOrientations[pointerIndex];
   }
+  virtual void GetWorldEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex);
+  virtual void GetLastWorldEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex);
   //@}
 
   //@{
   /**
    * With VR we know the physical/room coordinate positions
-   * and orientations of events. These methods
-   * support setting them.
+   * and orientations of events.
+   * These methods support setting them.
    */
   virtual void SetPhysicalEventPosition(double x, double y, double z, int pointerIndex)
   {
@@ -143,6 +146,18 @@ class VTKRENDERINGCORE_EXPORT vtkRenderWindowInteractor3D : public vtkRenderWind
       this->Modified();
     }
   }
+  virtual void SetPhysicalEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex);
+  //@}
+
+  //@{
+  /**
+   * With VR we know the physical/room coordinate positions
+   * and orientations of events.
+   * These methods support getting them.
+   */
+  virtual void GetPhysicalEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex);
+  virtual void GetLastPhysicalEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex);
+  virtual void GetStartingPhysicalEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex);
   //@}
 
   //@{
@@ -209,6 +224,7 @@ class VTKRENDERINGCORE_EXPORT vtkRenderWindowInteractor3D : public vtkRenderWind
       this->Modified();
     }
   }
+  virtual void SetWorldEventPose(vtkMatrix4x4* poseMatrix, int pointerIndex);
   //@}
 
   //@{
@@ -280,6 +296,11 @@ class VTKRENDERINGCORE_EXPORT vtkRenderWindowInteractor3D : public vtkRenderWind
   double   StartingPhysicalEventPositions[VTKI_MAX_POINTERS][3];
   double   WorldEventOrientations[VTKI_MAX_POINTERS][4];
   double   LastWorldEventOrientations[VTKI_MAX_POINTERS][4];
+  vtkNew<vtkMatrix4x4> WorldEventPoses[VTKI_MAX_POINTERS];
+  vtkNew<vtkMatrix4x4> LastWorldEventPoses[VTKI_MAX_POINTERS];
+  vtkNew<vtkMatrix4x4> PhysicalEventPoses[VTKI_MAX_POINTERS];
+  vtkNew<vtkMatrix4x4> LastPhysicalEventPoses[VTKI_MAX_POINTERS];
+  vtkNew<vtkMatrix4x4> StartingPhysicalEventPoses[VTKI_MAX_POINTERS];
   void RecognizeGesture(vtkCommand::EventIds) override;
 
 private:

Rendering/OpenVR/vtkOpenVRControlsHelper.cxx

@@ -30,7 +30,7 @@ PURPOSE.  See the above copyright notice for more information.
 #include "vtkWindow.h"
 #include "vtkCamera.h"
 #include "vtkLineSource.h"
-
+#include "vtkTransform.h"
 #include "vtkSmartPointer.h"
 
 vtkStandardNewMacro(vtkOpenVRControlsHelper);

Rendering/OpenVR/vtkOpenVRHardwarePicker.cxx

@@ -23,16 +23,7 @@ PURPOSE.  See the above copyright notice for more information.
 #include "vtkOpenVRRenderWindowInteractor.h"
 #include "vtkRenderer.h"
 #include "vtkSelection.h"
-
-// #include "vtkAssemblyNode.h"
-// #include "vtkAssemblyPath.h"
-// #include "vtkRenderer.h"
-// #include "vtkMath.h"
-// #include "vtkCamera.h"
-// #include "vtkBox.h"
-// #include "vtkRenderWindow.h"
-// #include "vtkRenderWindowInteractor3D.h"
-// #include "vtkTransform.h"
+#include "vtkTransform.h"
 
 vtkStandardNewMacro(vtkOpenVRHardwarePicker);
 

Rendering/OpenVR/vtkOpenVRPanelRepresentation.cxx

@@ -394,21 +394,10 @@ void vtkOpenVRPanelRepresentation::ComputeMatrix(vtkRenderer *ren)
       rw->GetTrackedDevicePose(vtkEventDataDevice::LeftController, &tdPose);
       if (tdPose && tdPose->bPoseIsValid)
       {
-        double pos[3];
-        double ppos[3];
-        double wxyz[4];
-        double wdir[3];
+        vtkNew<vtkMatrix4x4> poseMatrixWorld;
         static_cast<vtkOpenVRRenderWindowInteractor *>(rw->GetInteractor())
-          ->ConvertPoseToWorldCoordinates(*tdPose, pos, wxyz, ppos, wdir);
-
-        double scale = rw->GetPhysicalScale();
-
-        this->TempTransform->Identity();
-        this->TempTransform->PreMultiply();
-        this->TempTransform->Translate(pos[0], pos[1], pos[2]);
-        this->TempTransform->Scale(scale, scale, scale);
-        this->TempTransform->RotateWXYZ(wxyz[0], wxyz[1], wxyz[2], wxyz[3]);
-        this->TextActor->GetUserMatrix()->DeepCopy(this->TempTransform->GetMatrix());
+          ->ConvertOpenVRPoseToMatrices(*tdPose, poseMatrixWorld);
+        this->TextActor->GetUserMatrix()->DeepCopy(poseMatrixWorld);
       }
     }
 
@@ -418,21 +407,10 @@ void vtkOpenVRPanelRepresentation::ComputeMatrix(vtkRenderer *ren)
       rw->GetTrackedDevicePose(vtkEventDataDevice::RightController, &tdPose);
       if (tdPose && tdPose->bPoseIsValid)
       {
-        double pos[3];
-        double ppos[3];
-        double wxyz[4];
-        double wdir[3];
+        vtkNew<vtkMatrix4x4> poseMatrixWorld;
         static_cast<vtkOpenVRRenderWindowInteractor *>(rw->GetInteractor())
-          ->ConvertPoseToWorldCoordinates(*tdPose, pos, wxyz, ppos, wdir);
-
-        double scale = rw->GetPhysicalScale();
-
-        this->TempTransform->Identity();
-        this->TempTransform->PreMultiply();
-        this->TempTransform->Translate(pos[0], pos[1], pos[2]);
-        this->TempTransform->Scale(scale, scale, scale);
-        this->TempTransform->RotateWXYZ(wxyz[0], wxyz[1], wxyz[2], wxyz[3]);
-        this->TextActor->GetUserMatrix()->DeepCopy(this->TempTransform->GetMatrix());
+          ->ConvertOpenVRPoseToMatrices(*tdPose, poseMatrixWorld);
+        this->TextActor->GetUserMatrix()->DeepCopy(poseMatrixWorld);
       }
     }
   }

Rendering/OpenVR/vtkOpenVRRenderWindow.cxx

@@ -425,7 +425,6 @@ void vtkOpenVRRenderWindow::UpdateHMDMatrixPose()
       double hmdY_Physical[3] = { tdPose.mDeviceToAbsoluteTracking.m[0][1],
                                   tdPose.mDeviceToAbsoluteTracking.m[1][1],
                                   tdPose.mDeviceToAbsoluteTracking.m[2][1] };
-      double hmdZ_Physical[3] = {0.0};
       double hmdPosition_Physical[3] = { tdPose.mDeviceToAbsoluteTracking.m[0][3],
                                          tdPose.mDeviceToAbsoluteTracking.m[1][3],
                                          tdPose.mDeviceToAbsoluteTracking.m[2][3] };
@@ -787,6 +786,73 @@ void vtkOpenVRRenderWindow::GetTrackedDevicePose(
   }
 }
 
+void vtkOpenVRRenderWindow::SetPhysicalViewDirection(double x, double y, double z)
+{
+  if ( this->PhysicalViewDirection[0] != x
+    || this->PhysicalViewDirection[1] != y
+    || this->PhysicalViewDirection[2] != z )
+  {
+    this->PhysicalViewDirection[0] = x;
+    this->PhysicalViewDirection[1] = y;
+    this->PhysicalViewDirection[2] = z;
+    this->InvokeEvent(vtkOpenVRRenderWindow::PhysicalToWorldMatrixModified);
+    this->Modified();
+  }
+}
+
+void vtkOpenVRRenderWindow::SetPhysicalViewDirection(double dir[3])
+{
+  this->SetPhysicalViewDirection(dir[0], dir[1], dir[2]);
+}
+
+void vtkOpenVRRenderWindow::SetPhysicalViewUp(double x, double y, double z)
+{
+  if ( this->PhysicalViewUp[0] != x
+    || this->PhysicalViewUp[1] != y
+    || this->PhysicalViewUp[2] != z )
+  {
+    this->PhysicalViewUp[0] = x;
+    this->PhysicalViewUp[1] = y;
+    this->PhysicalViewUp[2] = z;
+    this->InvokeEvent(vtkOpenVRRenderWindow::PhysicalToWorldMatrixModified);
+    this->Modified();
+  }
+}
+
+void vtkOpenVRRenderWindow::SetPhysicalViewUp(double dir[3])
+{
+  this->SetPhysicalViewUp(dir[0], dir[1], dir[2]);
+}
+
+void vtkOpenVRRenderWindow::SetPhysicalTranslation(double x, double y, double z)
+{
+  if ( this->PhysicalTranslation[0] != x
+    || this->PhysicalTranslation[1] != y
+    || this->PhysicalTranslation[2] != z )
+  {
+    this->PhysicalTranslation[0] = x;
+    this->PhysicalTranslation[1] = y;
+    this->PhysicalTranslation[2] = z;
+    this->InvokeEvent(vtkOpenVRRenderWindow::PhysicalToWorldMatrixModified);
+    this->Modified();
+  }
+}
+
+void vtkOpenVRRenderWindow::SetPhysicalTranslation(double trans[3])
+{
+  this->SetPhysicalTranslation(trans[0], trans[1], trans[2]);
+}
+
+void vtkOpenVRRenderWindow::SetPhysicalScale(double scale)
+{
+  if (this->PhysicalScale != scale)
+  {
+    this->PhysicalScale = scale;
+    this->InvokeEvent(vtkOpenVRRenderWindow::PhysicalToWorldMatrixModified);
+    this->Modified();
+  }
+}
+
 void vtkOpenVRRenderWindow::SetPhysicalToWorldMatrix(vtkMatrix4x4* matrix)
 {
   if (!matrix)
@@ -797,7 +863,11 @@ void vtkOpenVRRenderWindow::SetPhysicalToWorldMatrix(vtkMatrix4x4* matrix)
   vtkNew<vtkTransform> hmdToWorldTransform;
   hmdToWorldTransform->SetMatrix(matrix);
 
-  hmdToWorldTransform->GetPosition(this->PhysicalTranslation);
+  double translation[3] = {0.0};
+  hmdToWorldTransform->GetPosition(translation);
+  this->PhysicalTranslation[0] = (-1.0) * translation[0];
+  this->PhysicalTranslation[1] = (-1.0) * translation[1];
+  this->PhysicalTranslation[2] = (-1.0) * translation[2];
 
   double scale[3] = {0.0};
   hmdToWorldTransform->GetScale(scale);
@@ -811,6 +881,9 @@ void vtkOpenVRRenderWindow::SetPhysicalToWorldMatrix(vtkMatrix4x4* matrix)
   this->PhysicalViewDirection[1] = (-1.0) * matrix->GetElement(1,2);
   this->PhysicalViewDirection[2] = (-1.0) * matrix->GetElement(2,2);
   vtkMath::Normalize(this->PhysicalViewDirection);
+
+  this->InvokeEvent(vtkOpenVRRenderWindow::PhysicalToWorldMatrixModified);
+  this->Modified();
 }
 
 void vtkOpenVRRenderWindow::GetPhysicalToWorldMatrix(vtkMatrix4x4* physicalToWorldMatrix)
@@ -835,6 +908,6 @@ void vtkOpenVRRenderWindow::GetPhysicalToWorldMatrix(vtkMatrix4x4* physicalToWor
     physicalToWorldMatrix->SetElement(row, 0, physicalX_NonscaledWorld[row]*this->PhysicalScale);
     physicalToWorldMatrix->SetElement(row, 1, physicalY_NonscaledWorld[row]*this->PhysicalScale);
     physicalToWorldMatrix->SetElement(row, 2, physicalZ_NonscaledWorld[row]*this->PhysicalScale);
-    physicalToWorldMatrix->SetElement(row, 3, this->PhysicalTranslation[row]);
+    physicalToWorldMatrix->SetElement(row, 3, -this->PhysicalTranslation[row]);
   }
 }