Skip to content
Find file
Fetching contributors…
Cannot retrieve contributors at this time
1446 lines (1248 sloc) 39.2 KB
/*=========================================================================
Program: Visualization Toolkit
Module: vtkBoxWidget.cxx
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkBoxWidget.h"
#include "vtkActor.h"
#include "vtkAssemblyNode.h"
#include "vtkAssemblyPath.h"
#include "vtkCallbackCommand.h"
#include "vtkCamera.h"
#include "vtkCellArray.h"
#include "vtkCellPicker.h"
#include "vtkDoubleArray.h"
#include "vtkFloatArray.h"
#include "vtkMath.h"
#include "vtkObjectFactory.h"
#include "vtkPlanes.h"
#include "vtkPolyData.h"
#include "vtkPolyDataMapper.h"
#include "vtkProperty.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRenderer.h"
#include "vtkSphereSource.h"
#include "vtkTransform.h"
vtkStandardNewMacro(vtkBoxWidget);
vtkBoxWidget::vtkBoxWidget()
{
this->State = vtkBoxWidget::Start;
this->EventCallbackCommand->SetCallback(vtkBoxWidget::ProcessEvents);
// Enable/disable the translation, rotation, and scaling of the widget
this->TranslationEnabled = 1;
this->RotationEnabled = 1;
this->ScalingEnabled = 1;
//Build the representation of the widget
int i;
// Control orientation of normals
this->InsideOut = 0;
this->OutlineFaceWires = 0;
this->OutlineCursorWires = 1;
// Construct the poly data representing the hex
this->HexPolyData = vtkPolyData::New();
this->HexMapper = vtkPolyDataMapper::New();
this->HexMapper->SetInput(HexPolyData);
this->HexActor = vtkActor::New();
this->HexActor->SetMapper(this->HexMapper);
// Construct initial points
this->Points = vtkPoints::New(VTK_DOUBLE);
this->Points->SetNumberOfPoints(15);//8 corners; 6 faces; 1 center
this->HexPolyData->SetPoints(this->Points);
// Construct connectivity for the faces. These are used to perform
// the picking.
vtkIdType pts[4];
vtkCellArray *cells = vtkCellArray::New();
cells->Allocate(cells->EstimateSize(6,4));
pts[0] = 3; pts[1] = 0; pts[2] = 4; pts[3] = 7;
cells->InsertNextCell(4,pts);
pts[0] = 1; pts[1] = 2; pts[2] = 6; pts[3] = 5;
cells->InsertNextCell(4,pts);
pts[0] = 0; pts[1] = 1; pts[2] = 5; pts[3] = 4;
cells->InsertNextCell(4,pts);
pts[0] = 2; pts[1] = 3; pts[2] = 7; pts[3] = 6;
cells->InsertNextCell(4,pts);
pts[0] = 0; pts[1] = 3; pts[2] = 2; pts[3] = 1;
cells->InsertNextCell(4,pts);
pts[0] = 4; pts[1] = 5; pts[2] = 6; pts[3] = 7;
cells->InsertNextCell(4,pts);
this->HexPolyData->SetPolys(cells);
cells->Delete();
this->HexPolyData->BuildCells();
// The face of the hexahedra
cells = vtkCellArray::New();
cells->Allocate(cells->EstimateSize(1,4));
cells->InsertNextCell(4,pts); //temporary, replaced later
this->HexFacePolyData = vtkPolyData::New();
this->HexFacePolyData->SetPoints(this->Points);
this->HexFacePolyData->SetPolys(cells);
this->HexFaceMapper = vtkPolyDataMapper::New();
this->HexFaceMapper->SetInput(HexFacePolyData);
this->HexFace = vtkActor::New();
this->HexFace->SetMapper(this->HexFaceMapper);
cells->Delete();
// Create the outline for the hex
this->OutlinePolyData = vtkPolyData::New();
this->OutlinePolyData->SetPoints(this->Points);
this->OutlineMapper = vtkPolyDataMapper::New();
this->OutlineMapper->SetInput(this->OutlinePolyData);
this->HexOutline = vtkActor::New();
this->HexOutline->SetMapper(this->OutlineMapper);
cells = vtkCellArray::New();
cells->Allocate(cells->EstimateSize(15,2));
this->OutlinePolyData->SetLines(cells);
cells->Delete();
// Set up the initial properties
this->CreateDefaultProperties();
// Create the outline
this->GenerateOutline();
// Create the handles
this->Handle = new vtkActor* [7];
this->HandleMapper = new vtkPolyDataMapper* [7];
this->HandleGeometry = new vtkSphereSource* [7];
for (i=0; i<7; i++)
{
this->HandleGeometry[i] = vtkSphereSource::New();
this->HandleGeometry[i]->SetThetaResolution(16);
this->HandleGeometry[i]->SetPhiResolution(8);
this->HandleMapper[i] = vtkPolyDataMapper::New();
this->HandleMapper[i]->SetInput(this->HandleGeometry[i]->GetOutput());
this->Handle[i] = vtkActor::New();
this->Handle[i]->SetMapper(this->HandleMapper[i]);
}
// Define the point coordinates
double bounds[6];
bounds[0] = -0.5;
bounds[1] = 0.5;
bounds[2] = -0.5;
bounds[3] = 0.5;
bounds[4] = -0.5;
bounds[5] = 0.5;
// Points 8-14 are down by PositionHandles();
this->PlaceWidget(bounds);
//Manage the picking stuff
this->HandlePicker = vtkCellPicker::New();
this->HandlePicker->SetTolerance(0.001);
for (i=0; i<7; i++)
{
this->HandlePicker->AddPickList(this->Handle[i]);
}
this->HandlePicker->PickFromListOn();
this->HexPicker = vtkCellPicker::New();
this->HexPicker->SetTolerance(0.001);
this->HexPicker->AddPickList(HexActor);
this->HexPicker->PickFromListOn();
this->CurrentHandle = NULL;
this->Transform = vtkTransform::New();
}
vtkBoxWidget::~vtkBoxWidget()
{
this->HexActor->Delete();
this->HexMapper->Delete();
this->HexPolyData->Delete();
this->Points->Delete();
this->HexFace->Delete();
this->HexFaceMapper->Delete();
this->HexFacePolyData->Delete();
this->HexOutline->Delete();
this->OutlineMapper->Delete();
this->OutlinePolyData->Delete();
for (int i=0; i<7; i++)
{
this->HandleGeometry[i]->Delete();
this->HandleMapper[i]->Delete();
this->Handle[i]->Delete();
}
delete [] this->Handle;
delete [] this->HandleMapper;
delete [] this->HandleGeometry;
this->HandlePicker->Delete();
this->HexPicker->Delete();
this->Transform->Delete();
this->HandleProperty->Delete();
this->SelectedHandleProperty->Delete();
this->FaceProperty->Delete();
this->SelectedFaceProperty->Delete();
this->OutlineProperty->Delete();
this->SelectedOutlineProperty->Delete();
}
void vtkBoxWidget::SetEnabled(int enabling)
{
if ( ! this->Interactor )
{
vtkErrorMacro(<<"The interactor must be set prior to enabling/disabling widget");
return;
}
if ( enabling ) //------------------------------------------------------------
{
vtkDebugMacro(<<"Enabling widget");
if ( this->Enabled ) //already enabled, just return
{
return;
}
if ( ! this->CurrentRenderer )
{
this->SetCurrentRenderer(this->Interactor->FindPokedRenderer(
this->Interactor->GetLastEventPosition()[0],
this->Interactor->GetLastEventPosition()[1]));
if (this->CurrentRenderer == NULL)
{
return;
}
}
this->Enabled = 1;
// listen to the following events
vtkRenderWindowInteractor *i = this->Interactor;
i->AddObserver(vtkCommand::MouseMoveEvent, this->EventCallbackCommand,
this->Priority);
i->AddObserver(vtkCommand::LeftButtonPressEvent,
this->EventCallbackCommand, this->Priority);
i->AddObserver(vtkCommand::LeftButtonReleaseEvent,
this->EventCallbackCommand, this->Priority);
i->AddObserver(vtkCommand::MiddleButtonPressEvent,
this->EventCallbackCommand, this->Priority);
i->AddObserver(vtkCommand::MiddleButtonReleaseEvent,
this->EventCallbackCommand, this->Priority);
i->AddObserver(vtkCommand::RightButtonPressEvent,
this->EventCallbackCommand, this->Priority);
i->AddObserver(vtkCommand::RightButtonReleaseEvent,
this->EventCallbackCommand, this->Priority);
// Add the various actors
// Add the outline
this->CurrentRenderer->AddActor(this->HexActor);
this->CurrentRenderer->AddActor(this->HexOutline);
this->HexActor->SetProperty(this->OutlineProperty);
this->HexOutline->SetProperty(this->OutlineProperty);
// Add the hex face
this->CurrentRenderer->AddActor(this->HexFace);
this->HexFace->SetProperty(this->FaceProperty);
// turn on the handles
for (int j=0; j<7; j++)
{
this->CurrentRenderer->AddActor(this->Handle[j]);
this->Handle[j]->SetProperty(this->HandleProperty);
}
this->InvokeEvent(vtkCommand::EnableEvent,NULL);
}
else //disabling-------------------------------------------------------------
{
vtkDebugMacro(<<"Disabling widget");
if ( ! this->Enabled ) //already disabled, just return
{
return;
}
this->Enabled = 0;
// don't listen for events any more
this->Interactor->RemoveObserver(this->EventCallbackCommand);
// turn off the outline
this->CurrentRenderer->RemoveActor(this->HexActor);
this->CurrentRenderer->RemoveActor(this->HexOutline);
// turn off the hex face
this->CurrentRenderer->RemoveActor(this->HexFace);
// turn off the handles
for (int i=0; i<7; i++)
{
this->CurrentRenderer->RemoveActor(this->Handle[i]);
}
this->CurrentHandle = NULL;
this->InvokeEvent(vtkCommand::DisableEvent,NULL);
this->SetCurrentRenderer(NULL);
}
this->Interactor->Render();
}
void vtkBoxWidget::ProcessEvents(vtkObject* vtkNotUsed(object),
unsigned long event,
void* clientdata,
void* vtkNotUsed(calldata))
{
vtkBoxWidget* self = reinterpret_cast<vtkBoxWidget *>( clientdata );
//okay, let's do the right thing
switch(event)
{
case vtkCommand::LeftButtonPressEvent:
self->OnLeftButtonDown();
break;
case vtkCommand::LeftButtonReleaseEvent:
self->OnLeftButtonUp();
break;
case vtkCommand::MiddleButtonPressEvent:
self->OnMiddleButtonDown();
break;
case vtkCommand::MiddleButtonReleaseEvent:
self->OnMiddleButtonUp();
break;
case vtkCommand::RightButtonPressEvent:
self->OnRightButtonDown();
break;
case vtkCommand::RightButtonReleaseEvent:
self->OnRightButtonUp();
break;
case vtkCommand::MouseMoveEvent:
self->OnMouseMove();
break;
}
}
void vtkBoxWidget::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os,indent);
double *bounds=this->InitialBounds;
os << indent << "Initial Bounds: "
<< "(" << bounds[0] << "," << bounds[1] << ") "
<< "(" << bounds[2] << "," << bounds[3] << ") "
<< "(" << bounds[4] << "," << bounds[5] << ")\n";
if ( this->HandleProperty )
{
os << indent << "Handle Property: " << this->HandleProperty << "\n";
}
else
{
os << indent << "Handle Property: (none)\n";
}
if ( this->SelectedHandleProperty )
{
os << indent << "Selected Handle Property: "
<< this->SelectedHandleProperty << "\n";
}
else
{
os << indent << "SelectedHandle Property: (none)\n";
}
if ( this->FaceProperty )
{
os << indent << "Face Property: " << this->FaceProperty << "\n";
}
else
{
os << indent << "Face Property: (none)\n";
}
if ( this->SelectedFaceProperty )
{
os << indent << "Selected Face Property: "
<< this->SelectedFaceProperty << "\n";
}
else
{
os << indent << "Selected Face Property: (none)\n";
}
if ( this->OutlineProperty )
{
os << indent << "Outline Property: " << this->OutlineProperty << "\n";
}
else
{
os << indent << "Outline Property: (none)\n";
}
if ( this->SelectedOutlineProperty )
{
os << indent << "Selected Outline Property: "
<< this->SelectedOutlineProperty << "\n";
}
else
{
os << indent << "Selected Outline Property: (none)\n";
}
os << indent << "Outline Face Wires: " << (this->OutlineFaceWires ? "On\n" : "Off\n");
os << indent << "Outline Cursor Wires: " << (this->OutlineCursorWires ? "On\n" : "Off\n");
os << indent << "Inside Out: " << (this->InsideOut ? "On\n" : "Off\n");
os << indent << "Translation Enabled: " << (this->TranslationEnabled ? "On\n" : "Off\n");
os << indent << "Scaling Enabled: " << (this->ScalingEnabled ? "On\n" : "Off\n");
os << indent << "Rotation Enabled: " << (this->RotationEnabled ? "On\n" : "Off\n");
}
#define VTK_AVERAGE(a,b,c) \
c[0] = (a[0] + b[0])/2.0; \
c[1] = (a[1] + b[1])/2.0; \
c[2] = (a[2] + b[2])/2.0;
void vtkBoxWidget::PositionHandles()
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *p0 = pts;
double *p1 = pts + 3*1;
double *p2 = pts + 3*2;
double *p3 = pts + 3*3;
//double *p4 = pts + 3*4;
double *p5 = pts + 3*5;
double *p6 = pts + 3*6;
double *p7 = pts + 3*7;
double x[3];
VTK_AVERAGE(p0,p7,x);
this->Points->SetPoint(8, x);
VTK_AVERAGE(p1,p6,x);
this->Points->SetPoint(9, x);
VTK_AVERAGE(p0,p5,x);
this->Points->SetPoint(10, x);
VTK_AVERAGE(p2,p7,x);
this->Points->SetPoint(11, x);
VTK_AVERAGE(p1,p3,x);
this->Points->SetPoint(12, x);
VTK_AVERAGE(p5,p7,x);
this->Points->SetPoint(13, x);
VTK_AVERAGE(p0,p6,x);
this->Points->SetPoint(14, x);
int i;
for (i = 0; i < 7; ++i)
{
this->HandleGeometry[i]->SetCenter(this->Points->GetPoint(8+i));
}
this->Points->GetData()->Modified();
this->HexFacePolyData->Modified();
this->HexPolyData->Modified();
this->GenerateOutline();
}
#undef VTK_AVERAGE
void vtkBoxWidget::HandlesOn()
{
for (int i=0; i<7; i++)
{
this->Handle[i]->VisibilityOn();
}
}
void vtkBoxWidget::HandlesOff()
{
for (int i=0; i<7; i++)
{
this->Handle[i]->VisibilityOff();
}
}
void vtkBoxWidget::SizeHandles()
{
double radius = this->vtk3DWidget::SizeHandles(1.5);
for(int i=0; i<7; i++)
{
this->HandleGeometry[i]->SetRadius(radius);
}
}
int vtkBoxWidget::HighlightHandle(vtkProp *prop)
{
// first unhighlight anything picked
this->HighlightOutline(0);
if ( this->CurrentHandle )
{
this->CurrentHandle->SetProperty(this->HandleProperty);
}
this->CurrentHandle = static_cast<vtkActor *>(prop);
if ( this->CurrentHandle )
{
this->CurrentHandle->SetProperty(this->SelectedHandleProperty);
for (int i=0; i<6; i++) //find attached face
{
if ( this->CurrentHandle == this->Handle[i] )
{
return i;
}
}
}
if ( this->CurrentHandle == this->Handle[6] )
{
this->HighlightOutline(1);
}
return -1;
}
void vtkBoxWidget::HighlightFace(int cellId)
{
if ( cellId >= 0 )
{
vtkIdType npts;
vtkIdType *pts;
vtkCellArray *cells = this->HexFacePolyData->GetPolys();
this->HexPolyData->GetCellPoints(cellId, npts, pts);
this->HexFacePolyData->Modified();
cells->ReplaceCell(0,npts,pts);
this->CurrentHexFace = cellId;
this->HexFace->SetProperty(this->SelectedFaceProperty);
if ( !this->CurrentHandle )
{
this->CurrentHandle = this->HexFace;
}
}
else
{
this->HexFace->SetProperty(this->FaceProperty);
this->CurrentHexFace = -1;
}
}
void vtkBoxWidget::HighlightOutline(int highlight)
{
if ( highlight )
{
this->HexActor->SetProperty(this->SelectedOutlineProperty);
this->HexOutline->SetProperty(this->SelectedOutlineProperty);
}
else
{
this->HexActor->SetProperty(this->OutlineProperty);
this->HexOutline->SetProperty(this->OutlineProperty);
}
}
void vtkBoxWidget::OnLeftButtonDown()
{
int X = this->Interactor->GetEventPosition()[0];
int Y = this->Interactor->GetEventPosition()[1];
// Okay, we can process this. Try to pick handles first;
// if no handles picked, then pick the bounding box.
if (!this->CurrentRenderer || !this->CurrentRenderer->IsInViewport(X, Y))
{
this->State = vtkBoxWidget::Outside;
return;
}
vtkAssemblyPath *path;
this->HandlePicker->Pick(X,Y,0.0,this->CurrentRenderer);
path = this->HandlePicker->GetPath();
if ( path != NULL )
{
this->State = vtkBoxWidget::Moving;
this->HighlightFace(
this->HighlightHandle(path->GetFirstNode()->GetViewProp()));
this->HandlePicker->GetPickPosition(this->LastPickPosition);
this->ValidPick = 1;
}
else
{
this->HexPicker->Pick(X,Y,0.0,this->CurrentRenderer);
path = this->HexPicker->GetPath();
if ( path != NULL )
{
this->State = vtkBoxWidget::Moving;
this->HexPicker->GetPickPosition(this->LastPickPosition);
this->ValidPick = 1;
if ( !this->Interactor->GetShiftKey() )
{
this->HighlightHandle(NULL);
this->HighlightFace(this->HexPicker->GetCellId());
}
else
{
this->CurrentHandle = this->Handle[6];
this->HighlightOutline(1);
}
}
else
{
this->HighlightFace(this->HighlightHandle(NULL));
this->State = vtkBoxWidget::Outside;
return;
}
}
this->EventCallbackCommand->SetAbortFlag(1);
this->StartInteraction();
this->InvokeEvent(vtkCommand::StartInteractionEvent, NULL);
this->Interactor->Render();
}
void vtkBoxWidget::OnLeftButtonUp()
{
if ( this->State == vtkBoxWidget::Outside ||
this->State == vtkBoxWidget::Start )
{
return;
}
this->State = vtkBoxWidget::Start;
this->HighlightFace(this->HighlightHandle(NULL));
this->SizeHandles();
this->EventCallbackCommand->SetAbortFlag(1);
this->EndInteraction();
this->InvokeEvent(vtkCommand::EndInteractionEvent, NULL);
this->Interactor->Render();
}
void vtkBoxWidget::OnMiddleButtonDown()
{
int X = this->Interactor->GetEventPosition()[0];
int Y = this->Interactor->GetEventPosition()[1];
// Okay, we can process this. Try to pick handles first;
// if no handles picked, then pick the bounding box.
if (!this->CurrentRenderer || !this->CurrentRenderer->IsInViewport(X, Y))
{
this->State = vtkBoxWidget::Outside;
return;
}
vtkAssemblyPath *path;
this->HandlePicker->Pick(X,Y,0.0,this->CurrentRenderer);
path = this->HandlePicker->GetPath();
if ( path != NULL )
{
this->State = vtkBoxWidget::Moving;
this->CurrentHandle = this->Handle[6];
this->HighlightOutline(1);
this->HandlePicker->GetPickPosition(this->LastPickPosition);
this->ValidPick = 1;
}
else
{
this->HexPicker->Pick(X,Y,0.0,this->CurrentRenderer);
path = this->HexPicker->GetPath();
if ( path != NULL )
{
this->State = vtkBoxWidget::Moving;
this->CurrentHandle = this->Handle[6];
this->HighlightOutline(1);
this->HexPicker->GetPickPosition(this->LastPickPosition);
this->ValidPick = 1;
}
else
{
this->HighlightFace(this->HighlightHandle(NULL));
this->State = vtkBoxWidget::Outside;
return;
}
}
this->EventCallbackCommand->SetAbortFlag(1);
this->StartInteraction();
this->InvokeEvent(vtkCommand::StartInteractionEvent, NULL);
this->Interactor->Render();
}
void vtkBoxWidget::OnMiddleButtonUp()
{
if ( this->State == vtkBoxWidget::Outside ||
this->State == vtkBoxWidget::Start )
{
return;
}
this->State = vtkBoxWidget::Start;
this->HighlightFace(this->HighlightHandle(NULL));
this->SizeHandles();
this->EventCallbackCommand->SetAbortFlag(1);
this->EndInteraction();
this->InvokeEvent(vtkCommand::EndInteractionEvent, NULL);
this->Interactor->Render();
}
void vtkBoxWidget::OnRightButtonDown()
{
int X = this->Interactor->GetEventPosition()[0];
int Y = this->Interactor->GetEventPosition()[1];
// Okay, we can process this. Try to pick handles first;
// if no handles picked, then pick the bounding box.
if (!this->CurrentRenderer || !this->CurrentRenderer->IsInViewport(X, Y))
{
this->State = vtkBoxWidget::Outside;
return;
}
vtkAssemblyPath *path;
this->HandlePicker->Pick(X,Y,0.0,this->CurrentRenderer);
path = this->HandlePicker->GetPath();
if ( path != NULL )
{
this->State = vtkBoxWidget::Scaling;
this->HighlightOutline(1);
this->HandlePicker->GetPickPosition(this->LastPickPosition);
this->ValidPick = 1;
}
else
{
this->HexPicker->Pick(X,Y,0.0,this->CurrentRenderer);
path = this->HexPicker->GetPath();
if ( path != NULL )
{
this->State = vtkBoxWidget::Scaling;
this->HighlightOutline(1);
this->HexPicker->GetPickPosition(this->LastPickPosition);
this->ValidPick = 1;
}
else
{
this->State = vtkBoxWidget::Outside;
return;
}
}
this->EventCallbackCommand->SetAbortFlag(1);
this->StartInteraction();
this->InvokeEvent(vtkCommand::StartInteractionEvent, NULL);
this->Interactor->Render();
}
void vtkBoxWidget::OnRightButtonUp()
{
if ( this->State == vtkBoxWidget::Outside )
{
return;
}
this->State = vtkBoxWidget::Start;
this->HighlightOutline(0);
this->SizeHandles();
this->EventCallbackCommand->SetAbortFlag(1);
this->EndInteraction();
this->InvokeEvent(vtkCommand::EndInteractionEvent, NULL);
this->Interactor->Render();
}
void vtkBoxWidget::OnMouseMove()
{
// See whether we're active
if ( this->State == vtkBoxWidget::Outside ||
this->State == vtkBoxWidget::Start )
{
return;
}
int X = this->Interactor->GetEventPosition()[0];
int Y = this->Interactor->GetEventPosition()[1];
// Do different things depending on state
// Calculations everybody does
double focalPoint[4], pickPoint[4], prevPickPoint[4];
double z, vpn[3];
vtkCamera *camera = this->CurrentRenderer->GetActiveCamera();
if ( !camera )
{
return;
}
// Compute the two points defining the motion vector
this->ComputeWorldToDisplay(this->LastPickPosition[0], this->LastPickPosition[1],
this->LastPickPosition[2], focalPoint);
z = focalPoint[2];
this->ComputeDisplayToWorld(double(this->Interactor->GetLastEventPosition()[0]),
double(this->Interactor->GetLastEventPosition()[1]),
z, prevPickPoint);
this->ComputeDisplayToWorld(double(X), double(Y), z, pickPoint);
// Process the motion
if ( this->State == vtkBoxWidget::Moving )
{
// Okay to process
if ( this->CurrentHandle )
{
if ( this->RotationEnabled && this->CurrentHandle == this->HexFace )
{
camera->GetViewPlaneNormal(vpn);
this->Rotate(X, Y, prevPickPoint, pickPoint, vpn);
}
else if ( this->TranslationEnabled && this->CurrentHandle == this->Handle[6] )
{
this->Translate(prevPickPoint, pickPoint);
}
else if ( this->TranslationEnabled && this->ScalingEnabled )
{
if ( this->CurrentHandle == this->Handle[0] )
{
this->MoveMinusXFace(prevPickPoint, pickPoint);
}
else if ( this->CurrentHandle == this->Handle[1] )
{
this->MovePlusXFace(prevPickPoint, pickPoint);
}
else if ( this->CurrentHandle == this->Handle[2] )
{
this->MoveMinusYFace(prevPickPoint, pickPoint);
}
else if ( this->CurrentHandle == this->Handle[3] )
{
this->MovePlusYFace(prevPickPoint, pickPoint);
}
else if ( this->CurrentHandle == this->Handle[4] )
{
this->MoveMinusZFace(prevPickPoint, pickPoint);
}
else if ( this->CurrentHandle == this->Handle[5] )
{
this->MovePlusZFace(prevPickPoint, pickPoint);
}
}
}
}
else if ( this->ScalingEnabled && this->State == vtkBoxWidget::Scaling )
{
this->Scale(prevPickPoint, pickPoint, X, Y);
}
// Interact, if desired
this->EventCallbackCommand->SetAbortFlag(1);
this->InvokeEvent(vtkCommand::InteractionEvent, NULL);
this->Interactor->Render();
}
void vtkBoxWidget::MoveFace(double *p1, double *p2, double *dir,
double *x1, double *x2, double *x3, double *x4,
double *x5)
{
int i;
double v[3], v2[3];
for (i=0; i<3; i++)
{
v[i] = p2[i] - p1[i];
v2[i] = dir[i];
}
vtkMath::Normalize(v2);
double f = vtkMath::Dot(v,v2);
for (i=0; i<3; i++)
{
v[i] = f*v2[i];
x1[i] += v[i];
x2[i] += v[i];
x3[i] += v[i];
x4[i] += v[i];
x5[i] += v[i];
}
this->PositionHandles();
}
void vtkBoxWidget::GetDirection(const double Nx[3],const double Ny[3], const double Nz[3], double dir[3])
{
double dotNy, dotNz;
double y[3];
if(vtkMath::Dot(Nx,Nx)!=0)
{
dir[0] = Nx[0];
dir[1] = Nx[1];
dir[2] = Nx[2];
}
else
{
dotNy = vtkMath::Dot(Ny,Ny);
dotNz = vtkMath::Dot(Nz,Nz);
if(dotNy != 0 && dotNz != 0)
{
vtkMath::Cross(Ny,Nz,dir);
}
else if(dotNy != 0)
{
//dir must have been initialized to the
//corresponding coordinate direction before calling
//this method
vtkMath::Cross(Ny,dir,y);
vtkMath::Cross(y,Ny,dir);
}
else if(dotNz != 0)
{
//dir must have been initialized to the
//corresponding coordinate direction before calling
//this method
vtkMath::Cross(Nz,dir,y);
vtkMath::Cross(y,Nz,dir);
}
}
}
void vtkBoxWidget::MovePlusXFace(double *p1, double *p2)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *h1 = pts + 3*9;
double *x1 = pts + 3*1;
double *x2 = pts + 3*2;
double *x3 = pts + 3*5;
double *x4 = pts + 3*6;
double dir[3] = { 1 , 0 , 0};
this->ComputeNormals();
this->GetDirection(this->N[1],this->N[3],this->N[5],dir);
this->MoveFace(p1,p2,dir,x1,x2,x3,x4,h1);
}
void vtkBoxWidget::MoveMinusXFace(double *p1, double *p2)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *h1 = pts + 3*8;
double *x1 = pts + 3*0;
double *x2 = pts + 3*3;
double *x3 = pts + 3*4;
double *x4 = pts + 3*7;
double dir[3]={-1,0,0};
this->ComputeNormals();
this->GetDirection(this->N[0],this->N[4],this->N[2],dir);
this->MoveFace(p1,p2,dir,x1,x2,x3,x4,h1);
}
void vtkBoxWidget::MovePlusYFace(double *p1, double *p2)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *h1 = pts + 3*11;
double *x1 = pts + 3*2;
double *x2 = pts + 3*3;
double *x3 = pts + 3*6;
double *x4 = pts + 3*7;
double dir[3]={0,1,0};
this->ComputeNormals();
this->GetDirection(this->N[3],this->N[5],this->N[1],dir);
this->MoveFace(p1,p2,dir,x1,x2,x3,x4,h1);
}
void vtkBoxWidget::MoveMinusYFace(double *p1, double *p2)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *h1 = pts + 3*10;
double *x1 = pts + 3*0;
double *x2 = pts + 3*1;
double *x3 = pts + 3*4;
double *x4 = pts + 3*5;
double dir[3] = {0, -1, 0};
this->ComputeNormals();
this->GetDirection(this->N[2],this->N[0],this->N[4],dir);
this->MoveFace(p1,p2,dir,x1,x2,x3,x4,h1);
}
void vtkBoxWidget::MovePlusZFace(double *p1, double *p2)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *h1 = pts + 3*13;
double *x1 = pts + 3*4;
double *x2 = pts + 3*5;
double *x3 = pts + 3*6;
double *x4 = pts + 3*7;
double dir[3]={0,0,1};
this->ComputeNormals();
this->GetDirection(this->N[5],this->N[1],this->N[3],dir);
this->MoveFace(p1,p2,dir,x1,x2,x3,x4,h1);
}
void vtkBoxWidget::MoveMinusZFace(double *p1, double *p2)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *h1 = pts + 3*12;
double *x1 = pts + 3*0;
double *x2 = pts + 3*1;
double *x3 = pts + 3*2;
double *x4 = pts + 3*3;
double dir[3]={0,0,-1};
this->ComputeNormals();
this->GetDirection(this->N[4],this->N[2],this->N[0],dir);
this->MoveFace(p1,p2,dir,x1,x2,x3,x4,h1);
}
// Loop through all points and translate them
void vtkBoxWidget::Translate(double *p1, double *p2)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double v[3];
v[0] = p2[0] - p1[0];
v[1] = p2[1] - p1[1];
v[2] = p2[2] - p1[2];
// Move the corners
for (int i=0; i<8; i++)
{
*pts++ += v[0];
*pts++ += v[1];
*pts++ += v[2];
}
this->PositionHandles();
}
void vtkBoxWidget::Scale(double* vtkNotUsed(p1), double* vtkNotUsed(p2),
int vtkNotUsed(X), int Y)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *center
= static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(3*14);
double sf;
if ( Y > this->Interactor->GetLastEventPosition()[1] )
{
sf = 1.03;
}
else
{
sf = 0.97;
}
// Move the corners
for (int i=0; i<8; i++, pts+=3)
{
pts[0] = sf * (pts[0] - center[0]) + center[0];
pts[1] = sf * (pts[1] - center[1]) + center[1];
pts[2] = sf * (pts[2] - center[2]) + center[2];
}
this->PositionHandles();
}
void vtkBoxWidget::ComputeNormals()
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *p0 = pts;
double *px = pts + 3*1;
double *py = pts + 3*3;
double *pz = pts + 3*4;
int i;
for (i=0; i<3; i++)
{
this->N[0][i] = p0[i] - px[i];
this->N[2][i] = p0[i] - py[i];
this->N[4][i] = p0[i] - pz[i];
}
vtkMath::Normalize(this->N[0]);
vtkMath::Normalize(this->N[2]);
vtkMath::Normalize(this->N[4]);
for (i=0; i<3; i++)
{
this->N[1][i] = -this->N[0][i];
this->N[3][i] = -this->N[2][i];
this->N[5][i] = -this->N[4][i];
}
}
void vtkBoxWidget::GetPlanes(vtkPlanes *planes)
{
if ( ! planes )
{
return;
}
this->ComputeNormals();
vtkPoints *pts = vtkPoints::New(VTK_DOUBLE);
pts->SetNumberOfPoints(6);
vtkDoubleArray *normals = vtkDoubleArray::New();
normals->SetNumberOfComponents(3);
normals->SetNumberOfTuples(6);
// Set the normals and coordinate values
double factor = (this->InsideOut ? -1.0 : 1.0);
for (int i=0; i<6; i++)
{
pts->SetPoint(i,this->Points->GetPoint(8+i));
normals->SetTuple3(i, factor*this->N[i][0], factor*this->N[i][1],
factor*this->N[i][2]);
}
planes->SetPoints(pts);
planes->SetNormals(normals);
pts->Delete();
normals->Delete();
}
void vtkBoxWidget::Rotate(int X, int Y, double *p1, double *p2, double *vpn)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *center =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(3*14);
double v[3]; //vector of motion
double axis[3]; //axis of rotation
double theta; //rotation angle
int i;
v[0] = p2[0] - p1[0];
v[1] = p2[1] - p1[1];
v[2] = p2[2] - p1[2];
// Create axis of rotation and angle of rotation
vtkMath::Cross(vpn,v,axis);
if ( vtkMath::Normalize(axis) == 0.0 )
{
return;
}
int *size = this->CurrentRenderer->GetSize();
double l2 = (X-this->Interactor->GetLastEventPosition()[0])*(X-this->Interactor->GetLastEventPosition()[0]) + (Y-this->Interactor->GetLastEventPosition()[1])*(Y-this->Interactor->GetLastEventPosition()[1]);
theta = 360.0 * sqrt(l2/(size[0]*size[0]+size[1]*size[1]));
//Manipulate the transform to reflect the rotation
this->Transform->Identity();
this->Transform->Translate(center[0],center[1],center[2]);
this->Transform->RotateWXYZ(theta,axis);
this->Transform->Translate(-center[0],-center[1],-center[2]);
//Set the corners
vtkPoints *newPts = vtkPoints::New(VTK_DOUBLE);
this->Transform->TransformPoints(this->Points,newPts);
for (i=0; i<8; i++, pts+=3)
{
this->Points->SetPoint(i, newPts->GetPoint(i));
}
newPts->Delete();
this->PositionHandles();
}
void vtkBoxWidget::CreateDefaultProperties()
{
// Handle properties
this->HandleProperty = vtkProperty::New();
this->HandleProperty->SetColor(1,1,1);
this->SelectedHandleProperty = vtkProperty::New();
this->SelectedHandleProperty->SetColor(1,0,0);
// Face properties
this->FaceProperty = vtkProperty::New();
this->FaceProperty->SetColor(1,1,1);
this->FaceProperty->SetOpacity(0.0);
this->SelectedFaceProperty = vtkProperty::New();
this->SelectedFaceProperty->SetColor(1,1,0);
this->SelectedFaceProperty->SetOpacity(0.25);
// Outline properties
this->OutlineProperty = vtkProperty::New();
this->OutlineProperty->SetRepresentationToWireframe();
this->OutlineProperty->SetAmbient(1.0);
this->OutlineProperty->SetAmbientColor(1.0,1.0,1.0);
this->OutlineProperty->SetLineWidth(2.0);
this->SelectedOutlineProperty = vtkProperty::New();
this->SelectedOutlineProperty->SetRepresentationToWireframe();
this->SelectedOutlineProperty->SetAmbient(1.0);
this->SelectedOutlineProperty->SetAmbientColor(0.0,1.0,0.0);
this->SelectedOutlineProperty->SetLineWidth(2.0);
}
void vtkBoxWidget::PlaceWidget(double bds[6])
{
int i;
double bounds[6], center[3];
this->AdjustBounds(bds,bounds,center);
this->Points->SetPoint(0, bounds[0], bounds[2], bounds[4]);
this->Points->SetPoint(1, bounds[1], bounds[2], bounds[4]);
this->Points->SetPoint(2, bounds[1], bounds[3], bounds[4]);
this->Points->SetPoint(3, bounds[0], bounds[3], bounds[4]);
this->Points->SetPoint(4, bounds[0], bounds[2], bounds[5]);
this->Points->SetPoint(5, bounds[1], bounds[2], bounds[5]);
this->Points->SetPoint(6, bounds[1], bounds[3], bounds[5]);
this->Points->SetPoint(7, bounds[0], bounds[3], bounds[5]);
for (i=0; i<6; i++)
{
this->InitialBounds[i] = bounds[i];
}
this->InitialLength = sqrt((bounds[1]-bounds[0])*(bounds[1]-bounds[0]) +
(bounds[3]-bounds[2])*(bounds[3]-bounds[2]) +
(bounds[5]-bounds[4])*(bounds[5]-bounds[4]));
this->PositionHandles();
this->ComputeNormals();
this->SizeHandles();
}
void vtkBoxWidget::GetTransform(vtkTransform *t)
{
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double *p0 = pts;
double *p1 = pts + 3*1;
double *p3 = pts + 3*3;
double *p4 = pts + 3*4;
double *p14 = pts + 3*14;
double center[3], translate[3], scale[3], scaleVec[3][3];
double InitialCenter[3];
int i;
// The transformation is relative to the initial bounds.
// Initial bounds are set when PlaceWidget() is invoked.
t->Identity();
// Translation
for (i=0; i<3; i++)
{
InitialCenter[i] =
(this->InitialBounds[2*i+1]+this->InitialBounds[2*i]) / 2.0;
center[i] = p14[i] - InitialCenter[i];
}
translate[0] = center[0] + InitialCenter[0];
translate[1] = center[1] + InitialCenter[1];
translate[2] = center[2] + InitialCenter[2];
t->Translate(translate[0], translate[1], translate[2]);
// Orientation
vtkMatrix4x4 *matrix = vtkMatrix4x4::New();
this->PositionHandles();
this->ComputeNormals();
for (i=0; i<3; i++)
{
matrix->SetElement(i,0,this->N[1][i]);
matrix->SetElement(i,1,this->N[3][i]);
matrix->SetElement(i,2,this->N[5][i]);
}
t->Concatenate(matrix);
matrix->Delete();
// Scale
for (i=0; i<3; i++)
{
scaleVec[0][i] = (p1[i] - p0[i]);
scaleVec[1][i] = (p3[i] - p0[i]);
scaleVec[2][i] = (p4[i] - p0[i]);
}
scale[0] = vtkMath::Norm(scaleVec[0]);
if (this->InitialBounds[1] != this->InitialBounds[0])
{
scale[0] = scale[0] / (this->InitialBounds[1]-this->InitialBounds[0]);
}
scale[1] = vtkMath::Norm(scaleVec[1]);
if (this->InitialBounds[3] != this->InitialBounds[2])
{
scale[1] = scale[1] / (this->InitialBounds[3]-this->InitialBounds[2]);
}
scale[2] = vtkMath::Norm(scaleVec[2]);
if (this->InitialBounds[5] != this->InitialBounds[4])
{
scale[2] = scale[2] / (this->InitialBounds[5]-this->InitialBounds[4]);
}
t->Scale(scale[0],scale[1],scale[2]);
// Add back in the contribution due to non-origin center
t->Translate(-InitialCenter[0], -InitialCenter[1], -InitialCenter[2]);
}
void vtkBoxWidget::SetTransform(vtkTransform* t)
{
if (!t)
{
vtkErrorMacro(<<"vtkTransform t must be non-NULL");
return;
}
double *pts =
static_cast<vtkDoubleArray *>(this->Points->GetData())->GetPointer(0);
double xIn[3];
// make sure the transform is up-to-date before using it
t->Update();
// Position the eight points of the box and then update the
// position of the other handles.
double *bounds=this->InitialBounds;
xIn[0] = bounds[0]; xIn[1] = bounds[2]; xIn[2] = bounds[4];
t->InternalTransformPoint(xIn,pts);
xIn[0] = bounds[1]; xIn[1]= bounds[2]; xIn[2] = bounds[4];
t->InternalTransformPoint(xIn,pts+3);
xIn[0] = bounds[1]; xIn[1]= bounds[3]; xIn[2] = bounds[4];
t->InternalTransformPoint(xIn,pts+6);
xIn[0] = bounds[0]; xIn[1]= bounds[3]; xIn[2] = bounds[4];
t->InternalTransformPoint(xIn,pts+9);
xIn[0] = bounds[0]; xIn[1]= bounds[2]; xIn[2] = bounds[5];
t->InternalTransformPoint(xIn,pts+12);
xIn[0] = bounds[1]; xIn[1]= bounds[2]; xIn[2] = bounds[5];
t->InternalTransformPoint(xIn,pts+15);
xIn[0] = bounds[1]; xIn[1]= bounds[3]; xIn[2] = bounds[5];
t->InternalTransformPoint(xIn,pts+18);
xIn[0] = bounds[0]; xIn[1]= bounds[3]; xIn[2] = bounds[5];
t->InternalTransformPoint(xIn,pts+21);
this->PositionHandles();
}
void vtkBoxWidget::GetPolyData(vtkPolyData *pd)
{
pd->SetPoints(this->HexPolyData->GetPoints());
pd->SetPolys(this->HexPolyData->GetPolys());
}
void vtkBoxWidget::SetOutlineFaceWires(int newValue)
{
if (this->OutlineFaceWires != newValue)
{
this->OutlineFaceWires = newValue;
this->Modified();
// the outline is dependent on this value, so we have to regen
this->GenerateOutline();
}
}
void vtkBoxWidget::SetOutlineCursorWires(int newValue)
{
if (this->OutlineCursorWires != newValue)
{
this->OutlineCursorWires = newValue;
this->Modified();
// the outline is dependent on this value, so we have to regen
this->GenerateOutline();
}
}
void vtkBoxWidget::GenerateOutline()
{
// Whatever the case may be, we have to reset the Lines of the
// OutlinePolyData (i.e. nuke all current line data)
vtkCellArray *cells = this->OutlinePolyData->GetLines();
cells->Reset();
// Now the outline lines
if ( ! this->OutlineFaceWires && ! this->OutlineCursorWires )
{
return;
}
vtkIdType pts[2];
if ( this->OutlineFaceWires )
{
pts[0] = 0; pts[1] = 7; //the -x face
cells->InsertNextCell(2,pts);
pts[0] = 3; pts[1] = 4;
cells->InsertNextCell(2,pts);
pts[0] = 1; pts[1] = 6; //the +x face
cells->InsertNextCell(2,pts);
pts[0] = 2; pts[1] = 5;
cells->InsertNextCell(2,pts);
pts[0] = 1; pts[1] = 4; //the -y face
cells->InsertNextCell(2,pts);
pts[0] = 0; pts[1] = 5;
cells->InsertNextCell(2,pts);
pts[0] = 3; pts[1] = 6; //the +y face
cells->InsertNextCell(2,pts);
pts[0] = 2; pts[1] = 7;
cells->InsertNextCell(2,pts);
pts[0] = 0; pts[1] = 2; //the -z face
cells->InsertNextCell(2,pts);
pts[0] = 1; pts[1] = 3;
cells->InsertNextCell(2,pts);
pts[0] = 4; pts[1] = 6; //the +Z face
cells->InsertNextCell(2,pts);
pts[0] = 5; pts[1] = 7;
cells->InsertNextCell(2,pts);
}
if ( this->OutlineCursorWires )
{
pts[0] = 8; pts[1] = 9; //the x cursor line
cells->InsertNextCell(2,pts);
pts[0] = 10; pts[1] = 11; //the y cursor line
cells->InsertNextCell(2,pts);
pts[0] = 12; pts[1] = 13; //the z cursor line
cells->InsertNextCell(2,pts);
}
this->OutlinePolyData->Modified();
if ( this->OutlineProperty)
{
this->OutlineProperty->SetRepresentationToWireframe();
this->SelectedOutlineProperty->SetRepresentationToWireframe();
}
}
Something went wrong with that request. Please try again.