uLib/src/Vtk/HEP/Detectors/vtkDetectorChamber.cxx

/*//////////////////////////////////////////////////////////////////////////////
// CMT Cosmic Muon Tomography project //////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
  All rights reserved

  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >

  ------------------------------------------------------------------
  This library is free software;  you  can  redistribute  it  and/or
  modify it  under the  terms  of  the  GNU  Lesser  General  Public
  License as published  by  the  Free  Software  Foundation;  either
  version 3.0 of the License, or (at your option) any later version.

  This library is  distributed in  the hope that it will  be useful,
  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of  the GNU Lesser General  Public
  License along with this library.

//////////////////////////////////////////////////////////////////////////////*/

#include <vtkAbstractTransform.h>
#include <vtkAxes.h>
#include <vtkCubeSource.h>
#include <vtkLineSource.h>
#include <vtkMatrix4x4.h>
#include <vtkPolyDataMapper.h>
#include <vtkPropPicker.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkRendererCollection.h>
#include <vtkSmartPointer.h>
#include <vtkTransform.h>

#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
#include <vtkBoxWidget.h>
#include <vtkTransformPolyDataFilter.h>

namespace uLib {
namespace Vtk {

vtkDetectorChamber::vtkDetectorChamber(DetectorChamber *content)
    : 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();
}

DetectorChamber *vtkDetectorChamber::GetContent() {
  return static_cast<DetectorChamber *>(m_Content);
}

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_Actor);
  interactor->AddObserver(vtkCommand::LeftButtonPressEvent, m_PickerCallback);
}

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)
      transform(i, j) = vmat->GetElement(i, j);
  this->GetContent()->SetMatrix(transform);
  this->GetContent()->Updated(); // emit signal
  
  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;

  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_Actor->SetMapper(mapper);

  m_Actor->GetProperty()->SetRepresentationToSurface();
  m_Actor->GetProperty()->SetEdgeVisibility(true);
  m_Actor->GetProperty()->SetOpacity(0.4);
  m_Actor->GetProperty()->SetAmbient(0.7);

  // Temporarily disable UserTransform to place widget on local base
  m_Widget->SetProp3D(m_Actor);

  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 *) {
  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);

  // Apply to both the content and the actor state //
  chamber->Update();
}

void vtkDetectorChamber::vtkSelectionCallback::Execute(vtkObject *caller,
                                                       unsigned long, void *) {
  vtkRenderWindowInteractor *interactor =
      reinterpret_cast<vtkRenderWindowInteractor *>(caller);
  vtkSmartPointer<vtkPropPicker> picker = vtkSmartPointer<vtkPropPicker>::New();
  int *pos = interactor->GetEventPosition();
  picker->Pick(
      pos[0], pos[1], 0,
      interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer());

  vtkProp *picked = picker->GetViewProp();
  if (picked == chamber->m_Actor) {
    if (!chamber->m_Widget->GetEnabled()) {
      chamber->m_Widget->SetInteractor(interactor);
      chamber->m_Widget->On();
    }
  } else {
    if (chamber->m_Widget->GetEnabled()) {
      chamber->m_Widget->Off();
    }
  }
}

} // namespace Vtk
} // namespace uLib