OpenCMT/uLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3b02bb26acc9514e74e10ba45c7c79df504ad597
uLib/src/Vtk/vtkHandlerWidget.cpp

771 lines
26 KiB
C++
Raw Blame History

/*//////////////////////////////////////////////////////////////////////////////
// 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 "vtkHandlerWidget.h"
#include <iostream>
#include <vtkArcSource.h>
#include <vtkArrowSource.h>
#include <vtkCallbackCommand.h>
#include <vtkCamera.h>
#include <vtkCellPicker.h>
#include <vtkConeSource.h>
#include <vtkCubeSource.h>
#include <vtkInteractorObserver.h>
#include <vtkMath.h>
#include <vtkMatrix4x4.h>
#include <vtkObjectFactory.h>
#include <vtkPlane.h>
#include <vtkPolyDataMapper.h>
#include <vtkProp3D.h>
#include <vtkPropPicker.h>
#include <vtkProperty.h>
#include <vtkRegularPolygonSource.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
namespace uLib {
namespace Vtk {
vtkStandardNewMacro(vtkHandlerWidget);
vtkHandlerWidget::vtkHandlerWidget() {
this->Interaction = IDLE;
this->m_Picker = vtkSmartPointer<::vtkCellPicker>::New();
this->m_Picker->SetTolerance(0.01); // Increased tolerance for thin gizmos
this->m_InitialTransform = vtkSmartPointer<::vtkTransform>::New();
this->EventCallbackCommand->SetCallback(vtkHandlerWidget::ProcessEvents);
this->EventCallbackCommand->SetClientData(this);
this->m_Frame = LOCAL;
this->m_HighlightedProp = nullptr;
this->m_ClipPlane = vtkSmartPointer<::vtkPlane>::New();
this->m_OverlayRenderer = vtkSmartPointer<::vtkRenderer>::New();
this->m_OverlayRenderer->SetLayer(1);
this->m_OverlayRenderer->EraseOff();
this->m_OverlayRenderer->InteractiveOff();
this->Priority = 50.0; // Higher priority to beat camera style
this->CreateGizmos();
}
vtkHandlerWidget::~vtkHandlerWidget() {}
void vtkHandlerWidget::SetEnabled(int enabling) {
if (enabling) {
if (this->Enabled)
return;
if (!this->Interactor) {
vtkErrorMacro(
<< "The interactor must be set prior to enabling the widget");
return;
}
if (!this->CurrentRenderer) {
this->CurrentRenderer = this->Interactor->FindPokedRenderer(
this->Interactor->GetLastEventPosition()[0],
this->Interactor->GetLastEventPosition()[1]);
}
if (!this->CurrentRenderer) {
return;
}
this->Enabled = 1;
// Add observers
::vtkRenderWindowInteractor *i = this->Interactor;
this->SetPriority(this->Priority);
i->AddObserver(::vtkCommand::LeftButtonPressEvent,
this->EventCallbackCommand, this->Priority);
i->AddObserver(::vtkCommand::LeftButtonReleaseEvent,
this->EventCallbackCommand, this->Priority);
i->AddObserver(::vtkCommand::MouseMoveEvent, this->EventCallbackCommand,
this->Priority);
i->AddObserver(::vtkCommand::RenderEvent, this->EventCallbackCommand,
this->Priority);
this->UpdateGizmoPosition();
// Manage Layers
auto win = this->Interactor->GetRenderWindow();
if (win->GetNumberOfLayers() < 2) {
win->SetNumberOfLayers(2);
}
// Sync Viewport and Camera
this->m_OverlayRenderer->SetViewport(this->CurrentRenderer->GetViewport());
this->m_OverlayRenderer->SetActiveCamera(this->CurrentRenderer->GetActiveCamera());
win->AddRenderer(this->m_OverlayRenderer);
this->m_OverlayRenderer->AddActor(m_AxesX);
this->m_OverlayRenderer->AddActor(m_AxesY);
this->m_OverlayRenderer->AddActor(m_AxesZ);
this->m_OverlayRenderer->AddActor(m_RotX);
this->m_OverlayRenderer->AddActor(m_RotY);
this->m_OverlayRenderer->AddActor(m_RotZ);
this->m_OverlayRenderer->AddActor(m_RotCam);
this->m_OverlayRenderer->AddActor(m_ScaleX);
this->m_OverlayRenderer->AddActor(m_ScaleY);
this->m_OverlayRenderer->AddActor(m_ScaleZ);
this->InvokeEvent(::vtkCommand::EnableEvent, nullptr);
} else {
if (!this->Enabled)
return;
this->Enabled = 0;
this->Highlight(nullptr);
this->Interactor->RemoveObserver(this->EventCallbackCommand);
if (this->Interactor->GetRenderWindow()) {
this->Interactor->GetRenderWindow()->RemoveRenderer(this->m_OverlayRenderer);
}
this->m_OverlayRenderer->RemoveAllViewProps();
this->InvokeEvent(::vtkCommand::DisableEvent, nullptr);
}
if (this->Interactor) {
this->Interactor->Render();
}
}
void vtkHandlerWidget::ProcessEvents(::vtkObject *caller, unsigned long event,
void *clientdata, void *calldata) {
(void)caller;
(void)calldata;
vtkHandlerWidget *self = reinterpret_cast<vtkHandlerWidget *>(clientdata);
switch (event) {
case ::vtkCommand::LeftButtonPressEvent:
self->OnLeftButtonDown();
if (self->Interaction != ::uLib::Vtk::vtkHandlerWidget::IDLE)
self->EventCallbackCommand->SetAbortFlag(1);
break;
case ::vtkCommand::LeftButtonReleaseEvent:
self->OnLeftButtonUp();
if (self->EventCallbackCommand->GetAbortFlag()) {
// Don't let release bleed if press was captured
}
break;
case ::vtkCommand::MouseMoveEvent:
self->OnMouseMove();
if (self->Interaction != ::uLib::Vtk::vtkHandlerWidget::IDLE)
self->EventCallbackCommand->SetAbortFlag(1);
break;
case ::vtkCommand::RenderEvent:
self->UpdateGizmoPosition();
break;
}
}
void vtkHandlerWidget::OnLeftButtonDown() {
int X = this->Interactor->GetEventPosition()[0];
int Y = this->Interactor->GetEventPosition()[1];
if (!this->CurrentRenderer) {
this->CurrentRenderer = this->Interactor->FindPokedRenderer(X, Y);
}
this->m_Picker->Pick(X, Y, 0.0, this->m_OverlayRenderer);
::vtkProp *prop = this->m_Picker->GetViewProp();
this->m_Picker->GetPickPosition(this->m_StartPickPosition);
if (!prop)
return;
this->Interaction = IDLE;
if (prop == m_AxesX)
this->Interaction = TRANS_X;
else if (prop == m_AxesY)
this->Interaction = TRANS_Y;
else if (prop == m_AxesZ)
this->Interaction = TRANS_Z;
else if (prop == m_RotX)
this->Interaction = ROT_X;
else if (prop == m_RotY)
this->Interaction = ROT_Y;
else if (prop == m_RotZ)
this->Interaction = ROT_Z;
else if (prop == m_ScaleX)
this->Interaction = SCALE_X;
else if (prop == m_ScaleY)
this->Interaction = SCALE_Y;
else if (prop == m_ScaleZ)
this->Interaction = SCALE_Z;
else if (prop == m_RotCam)
this->Interaction = ROT_CAM;
if (this->Interaction != IDLE) {
this->StartEventPosition[0] = X;
this->StartEventPosition[1] = Y;
if (this->Prop3D) {
if (!this->Prop3D->GetUserMatrix()) {
vtkNew<vtkMatrix4x4> vmat;
this->Prop3D->SetUserMatrix(vmat);
}
this->m_InitialTransform->SetMatrix(this->Prop3D->GetUserMatrix());
}
this->EventCallbackCommand->SetAbortFlag(1);
this->InvokeEvent(::vtkCommand::StartInteractionEvent, nullptr);
this->Interactor->Render();
}
}
void vtkHandlerWidget::OnLeftButtonUp() {
if (this->Interaction == IDLE)
return;
this->Interaction = IDLE;
this->EventCallbackCommand->SetAbortFlag(1);
this->InvokeEvent(::vtkCommand::EndInteractionEvent, nullptr);
this->Interactor->Render();
}
void vtkHandlerWidget::OnMouseMove() {
if (!this->Prop3D || !this->CurrentRenderer)
return;
int X = this->Interactor->GetEventPosition()[0];
int Y = this->Interactor->GetEventPosition()[1];
if (this->Interaction == IDLE) {
this->m_Picker->Pick(X, Y, 0.0, this->m_OverlayRenderer);
::vtkProp *prop = this->m_Picker->GetViewProp();
this->Highlight(prop);
this->UpdateGizmoPosition(); // Ensure camera adjustments happen
return;
}
double dx = X - this->StartEventPosition[0];
double dy = Y - this->StartEventPosition[1];
if (dx == 0 && dy == 0) return;
std::cout << "Interaction " << this->Interaction << " dx=" << dx << " dy=" << dy << std::endl;
// Get current gizmo properties from its actors
vtkMatrix4x4 *gizmo_mat = m_AxesX->GetUserMatrix();
if (!gizmo_mat)
return;
double gpos[3] = {gizmo_mat->GetElement(0, 3), gizmo_mat->GetElement(1, 3),
gizmo_mat->GetElement(2, 3)};
// Normalized gizmo axes
double gx[3] = {gizmo_mat->GetElement(0, 0), gizmo_mat->GetElement(1, 0),
gizmo_mat->GetElement(2, 0)};
double gy[3] = {gizmo_mat->GetElement(0, 1), gizmo_mat->GetElement(1, 1),
gizmo_mat->GetElement(2, 1)};
double gz[3] = {gizmo_mat->GetElement(0, 2), gizmo_mat->GetElement(1, 2),
gizmo_mat->GetElement(2, 2)};
auto get_motion_magnitude = [&](double axis[3], double origin[3]) {
double p1[3] = {origin[0], origin[1], origin[2]};
double p2[3] = {origin[0] + axis[0], origin[1] + axis[1],
origin[2] + axis[2]};
double d1[3], d2[3];
this->ComputeWorldToDisplay(this->CurrentRenderer, p1[0], p1[1], p1[2], d1);
this->ComputeWorldToDisplay(this->CurrentRenderer, p2[0], p2[1], p2[2], d2);
double v[2] = {d2[0] - d1[0], d2[1] - d1[1]};
double v_mag_sq = v[0] * v[0] + v[1] * v[1];
if (v_mag_sq < 1.0)
return 0.0;
return (dx * v[0] + dy * v[1]) / v_mag_sq;
};
auto get_rotation_magnitude = [&](double axis[3]) -> double {
// 1. Get Mouse Ray in World Space
double worldNear[4], worldFar[4];
this->ComputeDisplayToWorld(static_cast<double>(X), static_cast<double>(Y), 0.0, worldNear);
this->ComputeDisplayToWorld(static_cast<double>(X), static_cast<double>(Y), 1.0, worldFar);
double camPos[3];
this->CurrentRenderer->GetActiveCamera()->GetPosition(camPos);
double rayDir[3];
for(int i=0; i<3; ++i) rayDir[i] = worldFar[i] - worldNear[i];
vtkMath::Normalize(rayDir);
// 2. Intersect Ray with Rotation Plane (Center = gpos, Normal = axis)
double planeNormal[3] = {axis[0], axis[1], axis[2]};
vtkMath::Normalize(planeNormal);
double denom = vtkMath::Dot(rayDir, planeNormal);
if (std::abs(denom) < 1e-6) return 0.0;
double t = (vtkMath::Dot(gpos, planeNormal) - vtkMath::Dot(camPos, planeNormal)) / denom;
double p_current[3];
for(int i=0; i<3; ++i) p_current[i] = camPos[i] + t * rayDir[i];
// 3. Calculate Angular Displacement in Plane
double v_start[3] = {this->m_StartPickPosition[0] - gpos[0],
this->m_StartPickPosition[1] - gpos[1],
this->m_StartPickPosition[2] - gpos[2]};
double v_end[3] = {p_current[0] - gpos[0],
p_current[1] - gpos[1],
p_current[2] - gpos[2]};
double r_start = vtkMath::Norm(v_start);
double r_end = vtkMath::Norm(v_end);
if (r_start < 1e-9 || r_end < 1e-9) return 0.0;
for(int i=0; i<3; ++i) { v_start[i] /= r_start; v_end[i] /= r_end; }
double cross[3];
vtkMath::Cross(v_start, v_end, cross);
double sinAng = vtkMath::Dot(cross, planeNormal);
double cosAng = vtkMath::Dot(v_start, v_end);
return vtkMath::DegreesFromRadians(atan2(sinAng, cosAng));
};
// Create a transform that represents the operation in world space around gpos
vtkNew<vtkTransform> op;
op->PostMultiply();
op->Translate(-gpos[0], -gpos[1], -gpos[2]);
double mag = 0;
switch (this->Interaction) {
case TRANS_X:
mag = get_motion_magnitude(gx, gpos);
op->Translate(mag * gx[0], mag * gx[1], mag * gx[2]);
break;
case TRANS_Y:
mag = get_motion_magnitude(gy, gpos);
op->Translate(mag * gy[0], mag * gy[1], mag * gy[2]);
break;
case TRANS_Z:
mag = get_motion_magnitude(gz, gpos);
op->Translate(mag * gz[0], mag * gz[1], mag * gz[2]);
break;
case ROT_X:
mag = get_rotation_magnitude(gx);
{
double ax[3] = {gx[0], gx[1], gx[2]};
vtkMath::Normalize(ax);
op->RotateWXYZ(mag, ax[0], ax[1], ax[2]);
}
break;
case ROT_Y:
mag = get_rotation_magnitude(gy);
{
double ax[3] = {gy[0], gy[1], gy[2]};
vtkMath::Normalize(ax);
op->RotateWXYZ(mag, ax[0], ax[1], ax[2]);
}
break;
case ROT_Z:
mag = get_rotation_magnitude(gz);
{
double ax[3] = {gz[0], gz[1], gz[2]};
vtkMath::Normalize(ax);
op->RotateWXYZ(mag, ax[0], ax[1], ax[2]);
}
break;
case SCALE_X:
mag = get_motion_magnitude(gx, gpos);
op->Scale(std::max(0.1, 1.0 + mag), 1.0, 1.0);
// Note: Scale might need orient_inv/orient if we want to scale along local axes nicely
// but the current logic for scale already handles this if we concatenated basis.
// For now we keep it simple since user only reported rotation issue.
break;
case SCALE_Y:
mag = get_motion_magnitude(gy, gpos);
op->Scale(1.0, std::max(0.1, 1.0 + mag), 1.0);
break;
case SCALE_Z:
mag = get_motion_magnitude(gz, gpos);
op->Scale(1.0, 1.0, std::max(0.1, 1.0 + mag));
break;
case ROT_CAM: {
double camPos[3];
this->CurrentRenderer->GetActiveCamera()->GetPosition(camPos);
double dir[3] = {camPos[0] - gpos[0], camPos[1] - gpos[1], camPos[2] - gpos[2]};
vtkMath::Normalize(dir);
// For camera ring, use screen-space angular delta
double c_disp[3];
this->ComputeWorldToDisplay(gpos[0], gpos[1], gpos[2], c_disp);
double v1[2] = {this->StartEventPosition[0] - c_disp[0], this->StartEventPosition[1] - c_disp[1]};
double v2[2] = {static_cast<double>(X) - c_disp[0], static_cast<double>(Y) - c_disp[1]};
if (vtkMath::Norm2D(v1) > 1.0 && vtkMath::Norm2D(v2) > 1.0) {
double d_ang = vtkMath::DegreesFromRadians(atan2(v2[1], v2[0]) - atan2(v1[1], v1[0]));
while (d_ang > 180) d_ang -= 360;
while (d_ang < -180) d_ang += 360;
mag = d_ang;
}
op->RotateWXYZ(mag, dir[0], dir[1], dir[2]);
break;
}
}
op->Translate(gpos[0], gpos[1], gpos[2]);
// Apply op on top of the initial object state
vtkNew<vtkTransform> final_t;
final_t->PostMultiply();
final_t->SetMatrix(this->m_InitialTransform->GetMatrix());
final_t->Concatenate(op);
vtkMatrix4x4* targetMat = this->Prop3D->GetUserMatrix();
if (targetMat) {
targetMat->DeepCopy(final_t->GetMatrix());
// std::cout << "Updated UserMatrix for interaction " << this->Interaction << std::endl;
}
this->Prop3D->Modified();
this->UpdateGizmoPosition();
// HIGH VISIBILITY LOG
std::printf("--- WIDGET Interaction: %d, Mag: %f, Pos: %f %f %f\n", Interaction, mag, gpos[0], gpos[1], gpos[2]);
this->InvokeEvent(::vtkCommand::InteractionEvent, nullptr);
this->Interactor->Render();
}
void vtkHandlerWidget::SetReferenceFrame(ReferenceFrame frame) {
this->m_Frame = frame;
this->UpdateGizmoPosition();
if (this->Interactor)
this->Interactor->Render();
}
void vtkHandlerWidget::PlaceWidget(double bounds[6]) {
(void)bounds;
this->UpdateGizmoPosition();
}
void vtkHandlerWidget::PlaceWidget() { this->UpdateGizmoPosition(); }
void vtkHandlerWidget::SetTransform(::vtkTransform *t) {
if (!t || !this->Prop3D)
return;
this->Prop3D->SetUserMatrix(t->GetMatrix());
this->UpdateGizmoPosition();
}
void vtkHandlerWidget::GetTransform(::vtkTransform *t) {
if (!t || !this->Prop3D)
return;
t->SetMatrix(this->Prop3D->GetUserMatrix());
}
void vtkHandlerWidget::CreateGizmos() {
auto create_arrow = [](double dir[3], double color[3]) {
auto arrow = vtkSmartPointer<::vtkArrowSource>::New();
arrow->SetTipLength(0.2);
arrow->SetTipRadius(0.06);
arrow->SetShaftRadius(0.015);
auto mapper = vtkSmartPointer<::vtkPolyDataMapper>::New();
mapper->SetInputConnection(arrow->GetOutputPort());
auto actor = vtkSmartPointer<::vtkActor>::New();
actor->SetMapper(mapper);
actor->GetProperty()->SetColor(color);
actor->GetProperty()->SetLighting(0); // Saturated colors, no shadows
if (dir[1] > 0)
actor->RotateZ(90);
else if (dir[2] > 0)
actor->RotateY(-90);
return actor;
};
auto create_ring = [&](int axis, double color[3]) {
auto circle = vtkSmartPointer<::vtkRegularPolygonSource>::New();
circle->SetNumberOfSides(64);
circle->SetRadius(1.0);
circle->SetCenter(0, 0, 0);
circle->GeneratePolygonOff();
circle->GeneratePolylineOn();
if (axis == 0) circle->SetNormal(1, 0, 0);
else if (axis == 1) circle->SetNormal(0, 1, 0);
else if (axis == 2) circle->SetNormal(0, 0, 1);
auto mapper = vtkSmartPointer<::vtkPolyDataMapper>::New();
mapper->SetInputConnection(circle->GetOutputPort());
mapper->AddClippingPlane(this->m_ClipPlane);
auto actor = vtkSmartPointer<::vtkActor>::New();
actor->SetMapper(mapper);
actor->GetProperty()->SetColor(color);
actor->GetProperty()->SetLineWidth(3);
actor->GetProperty()->SetLighting(0);
return actor;
};
double red[] = {1.0, 0.0, 0.0}, green[] = {0.0, 1.0, 0.0},
blue[] = {0.0, 0.0, 1.0}, white[] = {1.0, 1.0, 1.0};
double x[] = {1, 0, 0}, y[] = {0, 1, 0}, z[] = {0, 0, 1};
m_AxesX = create_arrow(x, red);
m_AxesY = create_arrow(y, green);
m_AxesZ = create_arrow(z, blue);
m_RotX = create_ring(0, red);
m_RotY = create_ring(1, green);
m_RotZ = create_ring(2, blue);
m_RotCam = vtkSmartPointer<::vtkActor>::New();
{
auto circle = vtkSmartPointer<::vtkRegularPolygonSource>::New();
circle->SetNumberOfSides(64);
circle->SetRadius(1.3); // Slightly larger
circle->SetCenter(0, 0, 0);
circle->GeneratePolygonOff();
circle->GeneratePolylineOn();
auto mapper = vtkSmartPointer<::vtkPolyDataMapper>::New();
mapper->SetInputConnection(circle->GetOutputPort());
m_RotCam->SetMapper(mapper);
m_RotCam->GetProperty()->SetColor(white);
m_RotCam->GetProperty()->SetLineWidth(2);
m_RotCam->GetProperty()->SetLighting(0);
}
auto create_cube = [](double pos[3], double color[3]) {
auto cube = vtkSmartPointer<::vtkCubeSource>::New();
cube->SetCenter(pos[0], pos[1], pos[2]);
cube->SetXLength(0.08);
cube->SetYLength(0.08);
cube->SetZLength(0.08);
auto mapper = vtkSmartPointer<::vtkPolyDataMapper>::New();
mapper->SetInputConnection(cube->GetOutputPort());
auto actor = vtkSmartPointer<::vtkActor>::New();
actor->SetMapper(mapper);
actor->GetProperty()->SetColor(color);
actor->GetProperty()->SetLighting(0);
return actor;
};
double px[] = {1.2, 0, 0}, py[] = {0, 1.2, 0}, pz[] = {0, 0, 1.2};
m_ScaleX = create_cube(px, red);
m_ScaleY = create_cube(py, green);
m_ScaleZ = create_cube(pz, blue);
// Configure picker to only see gizmo actors (Pick-Through)
m_Picker->InitializePickList();
m_Picker->AddPickList(m_AxesX);
m_Picker->AddPickList(m_AxesY);
m_Picker->AddPickList(m_AxesZ);
m_Picker->AddPickList(m_RotX);
m_Picker->AddPickList(m_RotY);
m_Picker->AddPickList(m_RotZ);
m_Picker->AddPickList(m_RotCam);
m_Picker->AddPickList(m_ScaleX);
m_Picker->AddPickList(m_ScaleY);
m_Picker->AddPickList(m_ScaleZ);
m_Picker->PickFromListOn();
}
void vtkHandlerWidget::UpdateGizmoPosition() {
if (!this->Prop3D)
return;
// Calculate scaling factor: min(object_bbox, 1/5 of viewport)
double bboxSize = 1.0;
double bounds[6];
this->Prop3D->GetBounds(bounds);
if (vtkMath::AreBoundsInitialized(bounds)) {
bboxSize = std::max({bounds[1] - bounds[0], bounds[3] - bounds[2], bounds[5] - bounds[4]});
}
if (bboxSize < 1e-6) bboxSize = 1.0;
double screenLimit = bboxSize * 2.0; // Default if no renderer
if (this->CurrentRenderer) {
int *sz = this->CurrentRenderer->GetSize();
if (sz[1] > 0) {
double pixelSize = std::min(sz[0], sz[1]) / 5.0;
vtkCamera *cam = this->CurrentRenderer->GetActiveCamera();
if (cam->GetParallelProjection()) {
screenLimit = (pixelSize / (double)sz[1]) * 2.0 * cam->GetParallelScale();
} else {
double dist = cam->GetDistance();
double angleRad = vtkMath::Pi() * cam->GetViewAngle() / 180.0;
double viewHeightAtDist = 2.0 * dist * tan(angleRad / 2.0);
screenLimit = (pixelSize / (double)sz[1]) * viewHeightAtDist;
}
}
}
double scaleFactor = std::min(bboxSize, screenLimit);
vtkNew<vtkMatrix4x4> mat_gizmo;
mat_gizmo->Identity();
double center[3];
center[0] = (bounds[0] + bounds[1]) / 2.0;
center[1] = (bounds[2] + bounds[3]) / 2.0;
center[2] = (bounds[4] + bounds[5]) / 2.0;
double pos[3];
this->Prop3D->GetPosition(pos);
if (m_Frame == LOCAL) {
::vtkMatrix4x4 *mat = this->Prop3D->GetMatrix();
mat_gizmo->DeepCopy(mat);
// Remove scaling
for (int j = 0; j < 3; ++j) {
double v[3] = {mat->GetElement(0, j), mat->GetElement(1, j),
mat->GetElement(2, j)};
double len = vtkMath::Norm(v);
if (len > 1e-6) {
mat_gizmo->SetElement(0, j, v[0] / len);
mat_gizmo->SetElement(1, j, v[1] / len);
mat_gizmo->SetElement(2, j, v[2] / len);
}
}
} else if (m_Frame == CENTER_LOCAL) {
::vtkMatrix4x4 *mat = this->Prop3D->GetMatrix();
mat_gizmo->DeepCopy(mat);
// Remove scaling
for (int j = 0; j < 3; ++j) {
double v[3] = {mat->GetElement(0, j), mat->GetElement(1, j),
mat->GetElement(2, j)};
double len = vtkMath::Norm(v);
if (len > 1e-6) {
mat_gizmo->SetElement(0, j, v[0] / len);
mat_gizmo->SetElement(1, j, v[1] / len);
mat_gizmo->SetElement(2, j, v[2] / len);
}
}
// Set position to center
mat_gizmo->SetElement(0, 3, center[0]);
mat_gizmo->SetElement(1, 3, center[1]);
mat_gizmo->SetElement(2, 3, center[2]);
} else if (m_Frame == GLOBAL) {
::vtkMatrix4x4 *mat = this->Prop3D->GetMatrix();
mat_gizmo->Identity();
mat_gizmo->SetElement(0, 3, mat->GetElement(0, 3));
mat_gizmo->SetElement(1, 3, mat->GetElement(1, 3));
mat_gizmo->SetElement(2, 3, mat->GetElement(2, 3));
} else if (m_Frame == CENTER) {
mat_gizmo->Identity();
mat_gizmo->SetElement(0, 3, center[0]);
mat_gizmo->SetElement(1, 3, center[1]);
mat_gizmo->SetElement(2, 3, center[2]);
}
// Apply scaleFactor to the gizmo matrix (only top-left 3x3)
for (int j = 0; j < 3; ++j) {
for (int i = 0; i < 3; ++i) {
mat_gizmo->SetElement(i, j, mat_gizmo->GetElement(i, j) * scaleFactor);
}
}
m_AxesX->SetUserMatrix(mat_gizmo);
m_AxesY->SetUserMatrix(mat_gizmo);
m_AxesZ->SetUserMatrix(mat_gizmo);
m_RotX->SetUserMatrix(mat_gizmo);
m_RotY->SetUserMatrix(mat_gizmo);
m_RotZ->SetUserMatrix(mat_gizmo);
m_ScaleX->SetUserMatrix(mat_gizmo);
m_ScaleY->SetUserMatrix(mat_gizmo);
m_ScaleZ->SetUserMatrix(mat_gizmo);
// Sync Overlay Renderer with Main Renderer
if (this->CurrentRenderer && this->m_OverlayRenderer) {
this->m_OverlayRenderer->SetViewport(this->CurrentRenderer->GetViewport());
this->m_OverlayRenderer->SetAspect(this->CurrentRenderer->GetAspect());
this->m_OverlayRenderer->ComputeAspect();
if (this->m_OverlayRenderer->GetActiveCamera() != this->CurrentRenderer->GetActiveCamera()) {
this->m_OverlayRenderer->SetActiveCamera(this->CurrentRenderer->GetActiveCamera());
}
}
// Camera ring always faces camera
if (this->CurrentRenderer) {
double camPos[3];
this->CurrentRenderer->GetActiveCamera()->GetPosition(camPos);
double dir[3] = {camPos[0] - mat_gizmo->GetElement(0, 3),
camPos[1] - mat_gizmo->GetElement(1, 3),
camPos[2] - mat_gizmo->GetElement(2, 3)};
vtkMath::Normalize(dir);
// Orient RotCam actor to face 'dir'
vtkNew<vtkTransform> tcam;
tcam->PostMultiply();
tcam->Scale(scaleFactor, scaleFactor, scaleFactor);
// Default circle is in XY plane (Normal Z: 0,0,1)
double z[3] = {0, 0, 1};
double cross[3];
vtkMath::Cross(z, dir, cross);
double cross_mag = vtkMath::Norm(cross);
if (cross_mag > 1e-6) {
double angle = vtkMath::DegreesFromRadians(acos(vtkMath::Dot(z, dir)));
tcam->RotateWXYZ(angle, cross[0], cross[1], cross[2]);
} else if (vtkMath::Dot(z, dir) < 0) {
tcam->RotateX(180);
}
tcam->Translate(mat_gizmo->GetElement(0, 3), mat_gizmo->GetElement(1, 3),
mat_gizmo->GetElement(2, 3));
m_RotCam->SetUserMatrix(tcam->GetMatrix());
// Update clipping plane for axes rings
this->m_ClipPlane->SetOrigin(mat_gizmo->GetElement(0, 3),
mat_gizmo->GetElement(1, 3),
mat_gizmo->GetElement(2, 3));
this->m_ClipPlane->SetNormal(dir);
}
}
void vtkHandlerWidget::Highlight(::vtkProp *prop) {
if (this->m_HighlightedProp == prop)
return;
// Restore previous
if (this->m_HighlightedProp) {
::vtkActor *actor = ::vtkActor::SafeDownCast(this->m_HighlightedProp);
if (actor) {
actor->GetProperty()->SetColor(m_OriginalColor);
actor->GetProperty()->SetLineWidth(3);
}
}
this->m_HighlightedProp = nullptr;
// Highlight new if it belongs to us
if (prop == m_AxesX || prop == m_AxesY || prop == m_AxesZ || prop == m_RotX ||
prop == m_RotY || prop == m_RotZ || prop == m_RotCam || prop == m_ScaleX ||
prop == m_ScaleY || prop == m_ScaleZ) {
this->m_HighlightedProp = prop;
::vtkActor *actor = ::vtkActor::SafeDownCast(prop);
if (actor) {
actor->GetProperty()->GetColor(m_OriginalColor);
double h[3] = {m_OriginalColor[0] + 0.2, m_OriginalColor[1] + 0.2,
m_OriginalColor[2] + 0.2};
for (int i = 0; i < 3; ++i)
h[i] = std::min(1.0, h[i]);
actor->GetProperty()->SetColor(h);
actor->GetProperty()->SetLineWidth(5);
}
}
if (this->Interactor)
this->Interactor->Render();
}
} // namespace Vtk
} // namespace uLib
Reference in New Issue View Git Blame Copy Permalink