DetectorChamber vtk handler

src/Vtk/HEP/Detectors/testing/CMakeLists.txt

@@ -13,3 +13,4 @@ set(LIBRARIES
 )
 
 uLib_add_tests(VtkDetectors)
+

src/Vtk/HEP/Detectors/testing/vtkDetectorChamberTest.cpp

@@ -33,11 +33,16 @@
 
 BOOST_AUTO_TEST_CASE(vtkDetectorChamberTest) {
   uLib::DetectorChamber d1, d2;
-  d1.SetSize(uLib::Vector3f(10, 20, 2));
+  d1.SetSize(uLib::Vector3f(1, 1, 1));
   d1.SetPosition(uLib::Vector3f(0, 0, 0));
+  d1.Scale(uLib::Vector3f(5, 10, 2));
+  d1.Translate(uLib::Vector3f(0, 0, 0));
+
+  d2.SetSize(uLib::Vector3f(1, 1, 1));
+  d2.SetPosition(uLib::Vector3f(0, 0, 0));
+  d2.Scale(uLib::Vector3f(5, 10, 2));
+  d2.Translate(uLib::Vector3f(0, 0, 10));
 
-  d2.SetSize(uLib::Vector3f(10, 20, 2));
-  d2.SetPosition(uLib::Vector3f(0, 0, 20));
 
   uLib::Vtk::vtkDetectorChamber vtkDetectorChamber(&d1);
   uLib::Vtk::vtkDetectorChamber vtkDetectorChamber2(&d2);

src/Vtk/HEP/Detectors/vtkDetectorChamber.cxx

@@ -23,6 +23,7 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
+#include <vtkAbstractTransform.h>
 #include <vtkAxes.h>
 #include <vtkCubeSource.h>
 #include <vtkLineSource.h>
@@ -38,23 +39,31 @@
 #include <vtkTransform.h>
 
 #include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
-#include "Vtk/vtkHandlerWidget.h"
+#include <vtkBoxWidget.h>
+#include <vtkTransformPolyDataFilter.h>
 
 namespace uLib {
 namespace Vtk {
 
 vtkDetectorChamber::vtkDetectorChamber(DetectorChamber *content)
-    : vtkContainerBox(content) {
-  m_Widget = vtkHandlerWidget::New();
+    : vtkContainerBox(content), m_Actor(vtkActor::New()),
+      m_Widget(vtkBoxWidget::New()) {
   m_Callback = vtkWidgetCallback::New();
   m_PickerCallback = vtkSelectionCallback::New();
 
   m_Callback->SetChamber(this);
   m_PickerCallback->SetChamber(this);
   m_Widget->AddObserver(vtkCommand::InteractionEvent, m_Callback);
+
+  m_InitialTransform = vtkSmartPointer<vtkTransform>::New();
+  m_RelativeTransform = vtkSmartPointer<vtkTransform>::New();
+  m_TotalTransform = vtkSmartPointer<vtkTransform>::New();
+
+  this->InstallPipe();
 }
 
 vtkDetectorChamber::~vtkDetectorChamber() {
+  m_Actor->Delete();
   m_Widget->Delete();
   m_Callback->Delete();
   m_PickerCallback->Delete();
@@ -68,94 +77,97 @@ void vtkDetectorChamber::PrintSelf(std::ostream &o) const {
   vtkContainerBox::PrintSelf(o);
 }
 
+/**
+ * Connect the interactor to the widget
+ */
 void vtkDetectorChamber::ConnectInteractor(
     vtkRenderWindowInteractor *interactor) {
   if (!interactor)
     return;
   m_Widget->SetInteractor(interactor);
-  m_Widget->SetProp3D(m_Cube);
-  m_Widget->PlaceWidget();
+  m_Widget->SetProp3D(m_Actor);
   interactor->AddObserver(vtkCommand::LeftButtonPressEvent, m_PickerCallback);
 }
 
-void vtkDetectorChamber::Update() {
-  if (!m_Content)
-    return;
-
-  Matrix4f mat = static_cast<Content *>(m_Content)->GetWorldMatrix();
-  vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
+void vtkDetectorChamber::SetTransform(vtkTransform *t) {
+  
+  
+  m_RelativeTransform->SetMatrix(t->GetMatrix());
+  m_RelativeTransform->Update();
+  
+  // Set content global transform (BaseClass of ContainerBox) //
+  vtkMatrix4x4 *vmat = m_TotalTransform->GetMatrix();
+  Matrix4f transform;
   for (int i = 0; i < 4; ++i)
     for (int j = 0; j < 4; ++j)
-      vmat->SetElement(i, j, mat(i, j));
+      transform(i, j) = vmat->GetElement(i, j);
+  this->GetContent()->SetMatrix(transform);
 
-  m_Cube->SetUserMatrix(vmat);
-  m_Axes->SetUserMatrix(vmat);
-  m_Pivot->SetUserMatrix(vmat);
+  this->Update();
+}
+
+vtkBoxWidget *vtkDetectorChamber::GetWidget() { return m_Widget; }
+
+void vtkDetectorChamber::Update() {
+  if (m_Actor->GetMapper())
+    m_Actor->GetMapper()->Update();
+  BaseClass::Update();
 }
 
 void vtkDetectorChamber::InstallPipe() {
   if (!m_Content)
     return;
 
-  // Cube: unit box (0,0,0) -> (1,1,1)
   vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
   cube->SetBounds(0, 1, 0, 1, 0, 1);
+
+  // 1. Initialize Global Transform (m_Transform) from Content's matrix (Base
+  // class AffineTransform)
+  vtkSmartPointer<vtkMatrix4x4> vmatGlobal =
+      vtkSmartPointer<vtkMatrix4x4>::New();
+  Matrix4f matGlobal = this->GetContent()->GetMatrix();
+  for (int i = 0; i < 4; ++i)
+    for (int j = 0; j < 4; ++j)
+      vmatGlobal->SetElement(i, j, matGlobal(i, j));
+
+  m_InitialTransform->SetMatrix(vmatGlobal);
+  m_InitialTransform->Update();
+
   vtkSmartPointer<vtkPolyDataMapper> mapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();
   mapper->SetInputConnection(cube->GetOutputPort());
-  m_Cube->SetMapper(mapper);
-  m_Cube->GetProperty()->SetRepresentationToWireframe();
-  m_Cube->GetProperty()->SetAmbient(0.7);
+  m_Actor->SetMapper(mapper);
 
-  // Axes: corner origin
-  vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New();
-  axes->SetOrigin(0, 0, 0);
-  axes->SetScaleFactor(0.2);
-  mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-  mapper->SetInputConnection(axes->GetOutputPort());
-  m_Axes->SetMapper(mapper);
-  m_Axes->GetProperty()->SetLineWidth(3);
-  m_Axes->GetProperty()->SetAmbient(0.4);
+  m_Actor->GetProperty()->SetRepresentationToSurface();
+  m_Actor->GetProperty()->SetEdgeVisibility(true);
+  m_Actor->GetProperty()->SetOpacity(0.4);
+  m_Actor->GetProperty()->SetAmbient(0.7);
 
-  // Pivot: center of unit box
-  vtkSmartPointer<vtkAxes> pivot = vtkSmartPointer<vtkAxes>::New();
-  pivot->SetOrigin(0.5, 0.5, 0.5);
-  pivot->SetScaleFactor(0.1);
-  mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-  mapper->SetInputConnection(pivot->GetOutputPort());
-  m_Pivot->SetMapper(mapper);
-  m_Pivot->GetProperty()->SetLineWidth(3);
-  m_Pivot->GetProperty()->SetAmbient(0.4);
+  // Temporarily disable UserTransform to place widget on local base
+  m_Widget->SetProp3D(m_Actor);
 
-  this->SetProp(m_Cube);
-  this->SetProp(m_Axes);
-  this->SetProp(m_Pivot);
+  m_TotalTransform->SetInput(m_RelativeTransform);
+  m_TotalTransform->Concatenate(m_InitialTransform);
+  m_Actor->SetUserTransform(m_TotalTransform);
+  m_TotalTransform->Update();
 
+  m_Widget->PlaceWidget();
+  m_Widget->SetPlaceFactor(2);
+
+  this->SetProp(m_Actor);
   this->Update();
 }
 
 void vtkDetectorChamber::vtkWidgetCallback::Execute(vtkObject *caller,
                                                     unsigned long, void *) {
-  vtkHandlerWidget *widget = reinterpret_cast<vtkHandlerWidget *>(caller);
+  vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget *>(caller);
+
+  // Get the Relative transform from the widget //
   vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
   widget->GetTransform(t);
+  chamber->SetTransform(t);
 
-  vtkMatrix4x4 *vmat = t->GetMatrix();
-  Matrix4f mat;
-  for (int i = 0; i < 4; ++i)
-    for (int j = 0; j < 4; ++j)
-      mat(i, j) = vmat->GetElement(i, j);
-
-  chamber->GetContent()->SetMatrix(mat);
-
-  // Reset internal matrix to identity to avoid double-transformation
-  vtkProp3D *prop = widget->GetProp3D();
-  if (prop) {
-    prop->SetPosition(0, 0, 0);
-    prop->SetOrientation(0, 0, 0);
-    prop->SetScale(1, 1, 1);
-  }
-
+  // Apply to both the content and the actor state //
   chamber->Update();
 }
 
@@ -170,22 +182,9 @@ void vtkDetectorChamber::vtkSelectionCallback::Execute(vtkObject *caller,
       interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer());
 
   vtkProp *picked = picker->GetViewProp();
-  if (picked == chamber->m_Cube || picked == chamber->m_Axes ||
-      picked == chamber->m_Pivot) {
+  if (picked == chamber->m_Actor) {
     if (!chamber->m_Widget->GetEnabled()) {
-      // Register current position/rotation/scale from content //
-      Matrix4f mat = chamber->GetContent()->GetWorldMatrix();
-      vtkSmartPointer<vtkMatrix4x4> vmat = vtkSmartPointer<vtkMatrix4x4>::New();
-      for (int i = 0; i < 4; ++i)
-        for (int j = 0; j < 4; ++j)
-          vmat->SetElement(i, j, mat(i, j));
-
-      vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
-      t->SetMatrix(vmat);
-      chamber->m_Widget->SetCurrentRenderer(
-          interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer());
-      chamber->m_Widget->SetTransform(t);
-      chamber->m_Widget->PlaceWidget();
+      chamber->m_Widget->SetInteractor(interactor);
       chamber->m_Widget->On();
     }
   } else {

src/Vtk/HEP/Detectors/vtkDetectorChamber.h

@@ -35,14 +35,18 @@
 #include "Math/Dense.h"
 #include "Vtk/uLibVtkInterface.h"
 #include "Vtk/vtkContainerBox.h"
+#include <vtkActor.h>
+#include <vtkBoxWidget.h>
+#include <vtkTransformPolyDataFilter.h>
 
 namespace uLib {
 namespace Vtk {
 
-class vtkHandlerWidget;
+// class vtkHandlerWidget; // Removed as we use vtkBoxWidget now
 
 class vtkDetectorChamber : public vtkContainerBox {
   typedef DetectorChamber Content;
+  typedef vtkContainerBox BaseClass;
 
 public:
   vtkDetectorChamber(DetectorChamber *content);
@@ -50,6 +54,10 @@ public:
 
   Content *GetContent();
 
+  void SetTransform(class vtkTransform *t);
+
+  class vtkBoxWidget *GetWidget();
+
   void Update();
 
   void ConnectInteractor(vtkRenderWindowInteractor *interactor) override;
@@ -80,9 +88,14 @@ private:
     uLib::Vtk::vtkDetectorChamber *chamber;
   };
 
-  vtkHandlerWidget *m_Widget;
+  vtkActor *m_Actor;
+  vtkBoxWidget *m_Widget;
   vtkWidgetCallback *m_Callback;
   vtkSelectionCallback *m_PickerCallback;
+
+  vtkSmartPointer<vtkTransform> m_InitialTransform;
+  vtkSmartPointer<vtkTransform> m_RelativeTransform;
+  vtkSmartPointer<vtkTransform> m_TotalTransform;
 };
 
 } // namespace Vtk