djairoh
/
interactive-track-and-trace
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #23 from MakeNEnjoy/djairo-vtk-camera 

Djairo vtk camera
This commit is contained in:
Robin Sachsenweger Ballantyne 2024-05-06 17:00:08 +02:00 committed by GitHub
parent 2d934137df 5ac8ad40ee
commit 31d5faec06
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 327 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
vtk/src/CMakeLists.txt
View File

@ -17,6 +17,8 @@ find_package(VTK COMPONENTS
FiltersProgrammable
FiltersSources
ImagingSources
ImagingGeneral
ImagingCore
InteractionStyle
IOImage
RenderingContextOpenGL2
@ -35,20 +37,23 @@ endif()
find_package(netCDF REQUIRED)
add_executable(VtkBase MACOSX_BUNDLE main.cpp
layers/BackgroundImage.cpp
layers/BackgroundImage.h
layers/EGlyphLayer.cpp
layers/EGlyphLayer.h
layers/Layer.cpp
layers/Layer.h
layers/LGlyphLayer.cpp
layers/LGlyphLayer.h
Program.cpp
Program.h
commands/TimerCallbackCommand.h
CartographicTransformation.cpp
commands/CameraMoveCallback.cpp
commands/CameraMoveCallback.h
commands/SpawnPointCallback.cpp
commands/SpawnPointCallback.h
commands/TimerCallbackCommand.cpp
commands/SpawnPointCallback.h
commands/SpawnPointCallback.cpp
commands/TimerCallbackCommand.h
layers/BackgroundImage.cpp
layers/BackgroundImage.h
layers/EGlyphLayer.cpp
layers/EGlyphLayer.h
layers/Layer.cpp
layers/Layer.h
layers/LGlyphLayer.cpp
layers/LGlyphLayer.h
Program.cpp
Program.h
CartographicTransformation.cpp
advection/AdvectionKernel.h
advection/EulerAdvectionKernel.cpp

16
vtk/src/Program.cpp
View File

@ -19,7 +19,8 @@
#include "Program.h"
#include "commands/TimerCallbackCommand.h"
#include "commands/SpawnPointCallback.h"
#include "CartographicTransformation.h"
#include "commands/CameraMoveCallback.h"
void Program::setWinProperties() {
this->win->SetWindowName("Simulation");
@ -42,17 +43,29 @@ void Program::setupTimer(int dt) {
this->interact->CreateRepeatingTimer(17); // 60 fps == 1000 / 60 == 16.7 ms per frame
}
void Program::setupCameraCallback() {
auto callback = vtkSmartPointer<CameraMoveCallback>::New(this->cam);
this->interact->AddObserver(vtkCommand::MouseWheelForwardEvent, callback);
this->interact->AddObserver(vtkCommand::MouseWheelBackwardEvent, callback);
this->interact->AddObserver(vtkCommand::KeyPressEvent, callback);
}
Program::Program(int timerDT) {
this->win = vtkSmartPointer<vtkRenderWindow>::New();
this->interact = vtkSmartPointer<vtkRenderWindowInteractor>::New();
this->cam = createNormalisedCamera();
this->win->SetNumberOfLayers(0);
setWinProperties();
setupTimer(timerDT);
setupCameraCallback();
}
void Program::addLayer(Layer *layer) {
layer->setCamera(this->cam);
this->layers.push_back(layer);
this->win->AddRenderer(layer->getLayer());
this->win->SetNumberOfLayers(this->win->GetNumberOfLayers() + 1);
@ -68,6 +81,7 @@ void Program::removeLayer(Layer *layer) {
}
}
void Program::updateData(int t) {
win->Render();
for (Layer *l: layers) {

12
vtk/src/Program.h
View File

@ -6,7 +6,6 @@
#include <vtkRenderer.h>
#include "layers/Layer.h"
#include "commands/SpawnPointCallback.h"
/** This class manages the upper levels of the vtk pipeline; it has attributes for the vtkrenderWindow and a vector of Layers to represent a variable number of vtkRenderers.
* It can also set up a vtkTimer by connecting an instance of TimerCallbackCommand with its contained vtkRenderWindowInteractor.
@ -25,6 +24,11 @@ private:
*/
vtkSmartPointer<vtkRenderWindowInteractor> interact;
/** The camera used by all layers for this program.
*/
vtkSmartPointer<vtkCamera> cam;
/** This function sets some default properties on the vtkRenderWindow. Extracted to its' own function to keep the constructor from becoming cluttered.
*/
void setWinProperties();
@ -33,8 +37,14 @@ private:
*/
void setupTimer(int dt);
/** This function adds all interactors of each layer to the interactor/window
*/
void setupInteractions();
/** This function sets up the camera's associated movement callbacks..
*/
void setupCameraCallback();
public:
/** Constructor.
*/

104
vtk/src/commands/CameraMoveCallback.cpp Normal file
View File

@ -0,0 +1,104 @@
#include "CameraMoveCallback.h"
#include <vtkVertex.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>
#include <vtkCommand.h>
#include <vtkRenderWindow.h>
using std::string;
void CameraMoveCallback::Execute(vtkObject *caller, unsigned long evId,
void *callData) {
// Note the use of reinterpret_cast to cast the caller to the expected type.
auto intr = reinterpret_cast<vtkRenderWindowInteractor *>(caller);
switch (evId) {
case vtkCommand::KeyPressEvent:
if (not strcmp("minus", intr->GetKeySym())) {
zoom(false);
} else if (not strcmp("equal", intr->GetKeySym())) {
zoom(true);
} else {
pan(intr->GetKeySym());
}
break;
case vtkCommand::MouseWheelForwardEvent:
zoom(true);
break;
case vtkCommand::MouseWheelBackwardEvent:
zoom(false);
break;
default:
break;
}
// also calls the render function when the camera's position has not actually changed. This is a negligble inefficiency.
intr->GetRenderWindow()->Render();
}
void CameraMoveCallback::clampCamera(double pos[3]) {
double scale = this->cam->GetParallelScale();
// only check the x,y coords of the camera; we don't care about z
for (int i=0; i < 2; i++) {
//boundary cond: scale+|pos| < 1.
if (abs(pos[i])+scale > 1.01) {
if (pos[i] >= 0) {
pos[i] = 1 - scale;
} else {
pos[i] = scale - 1;
}
}
}
this->cam->SetPosition(pos);
this->cam->SetFocalPoint(pos[0], pos[1], 0);
}
void CameraMoveCallback::zoom(const bool in) {
double scale = this->cam->GetParallelScale();
if (in) {
if (scale >= 0.2)
scale -= 0.1;
} else {
if (scale <= 0.9)
scale += 0.1;
}
this->cam->SetParallelScale(scale);
clampCamera(this->cam->GetPosition());
}
// we use the interactor's getKeySym instead of getKeyCode because getKeyCode is platform-dependent.
void CameraMoveCallback::pan(const string dir) {
double pos[3];
this->cam->GetPosition(pos);
if (dir == "Left" or dir == "h") {
pos[0] -= 0.1;
} else if (dir == "Up" or dir == "k" ) {
pos[1] += 0.1;
} else if (dir == "Right" or dir == "l" ) {
pos[0] += 0.1;
} else if (dir == "Down" or dir == "j" ) {
pos[1] -= 0.1;
}
clampCamera(pos);
}
CameraMoveCallback::CameraMoveCallback() : cam(nullptr) {}
CameraMoveCallback *CameraMoveCallback::New(vtkCamera *cam) {
auto me = new CameraMoveCallback;
me->setCam(cam);
return me;
}
void CameraMoveCallback::setCam(const vtkSmartPointer<vtkCamera> &cam) {
this->cam = cam;
}

56
vtk/src/commands/CameraMoveCallback.h Normal file
View File

@ -0,0 +1,56 @@
#ifndef VTKBASE_CAMERAMOVECALLBACK_H
#define VTKBASE_CAMERAMOVECALLBACK_H
#include <vtkCallbackCommand.h>
#include <vtkCamera.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkMatrix4x4.h>
class CameraMoveCallback : public vtkCallbackCommand {
public:
/** Create new instance using the vtk New template.
*/
static CameraMoveCallback *New(vtkCamera *cam);
/** Constructor.
*/
CameraMoveCallback();
/** Sets the camera to operate on.
*/
void setCam(const vtkSmartPointer<vtkCamera> &cam);
private:
/** The camera to operate on.
*/
vtkSmartPointer<vtkCamera> cam;
/** Event callback. Should be subscribed to keyPressEvent and MouseWheelForward/MouseWheelBackward events.
*/
void Execute(vtkObject *caller, unsigned long evId, void *callData) override;
/** Zooms the camera in or out.
* @param in : whether to zoom in or out.
*/
void zoom(const bool in);
/** Pans the camera in a direction, determined by the parameter.
* 'h' and 'left' : pan left
* 'j' and 'up' : pan up
* 'k' and 'down' : pan down
* 'l' and 'right' : pan right
* @param dir : string of the pressed keycode.
*/
void pan(const std::string dir);
/** Edits the camera such that it only ever renders within the [-1,1] normalised coordinate field.
* Does so by making sure that the position of the camera (on the x,y axes), combined with the parallel scale, is never > 1.
* @param pos : pointer to new desired camera position. This will be changed if it would cause points outside [-1,1] to be displayed.
*/
void clampCamera(double *pos);
};
#endif

56
vtk/src/commands/SpawnPointCallback.cpp
View File

@ -17,40 +17,40 @@ void convertDisplayToWorld(vtkRenderer *renderer, int x, int y, double *worldPos
}
void SpawnPointCallback::Execute(vtkObject *caller, unsigned long evId, void *callData) {
// Note the use of reinterpret_cast to cast the caller to the expected type.
auto interactor = reinterpret_cast<vtkRenderWindowInteractor *>(caller);
// Note the use of reinterpret_cast to cast the caller to the expected type.
auto interactor = reinterpret_cast<vtkRenderWindowInteractor *>(caller);
if (evId == vtkCommand::LeftButtonPressEvent) {
dragging = true;
}
if (evId == vtkCommand::LeftButtonReleaseEvent) {
dragging = false;
}
if (!dragging) {
return;
}
if (evId == vtkCommand::LeftButtonPressEvent) {
dragging = true;
}
if (evId == vtkCommand::LeftButtonReleaseEvent) {
dragging = false;
}
if (!dragging) {
return;
}
int x, y;
interactor->GetEventPosition(x, y);
int x, y;
interactor->GetEventPosition(x, y);
double worldPos[4] = {2, 0, 0, 0};
double displayPos[3] = {static_cast<double>(x), static_cast<double>(y), 0.0};
ren->SetDisplayPoint(displayPos);
ren->DisplayToWorld();
ren->GetWorldPoint(worldPos);
inverseCartographicProjection->MultiplyPoint(worldPos, worldPos);
cout << "clicked on lon = " << worldPos[0] << " and lat = " << worldPos[1] << endl;
double worldPos[4] = {2, 0 ,0, 0};
double displayPos[3] = {static_cast<double>(x), static_cast<double>(y), 0.0};
ren->SetDisplayPoint(displayPos);
ren->DisplayToWorld();
ren->GetWorldPoint(worldPos);
inverseCartographicProjection->MultiplyPoint(worldPos, worldPos);
// cout << "clicked on lon = " << worldPos[0] << " and lat = " << worldPos[1] << endl;
vtkIdType id = points->InsertNextPoint(worldPos[0], worldPos[1], 0);
data->SetPoints(points);
vtkIdType id = points->InsertNextPoint(worldPos[0], worldPos[1], 0);
data->SetPoints(points);
vtkSmartPointer<vtkVertex> vertex = vtkSmartPointer<vtkVertex>::New();
vertex->GetPointIds()->SetId(0, id);
vtkSmartPointer<vtkVertex> vertex = vtkSmartPointer<vtkVertex>::New();
vertex->GetPointIds()->SetId(0, id);
vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New();
vertices->InsertNextCell(vertex);
data->SetVerts(vertices);
ren->GetRenderWindow()->Render();
vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New();
vertices->InsertNextCell(vertex);
data->SetVerts(vertices);
ren->GetRenderWindow()->Render();
}

19
vtk/src/commands/TimerCallbackCommand.cpp
View File

@ -2,12 +2,13 @@
#include "../Program.h"
// TODO: add getter/setters to attributes for customizability.
TimerCallbackCommand::TimerCallbackCommand() : dt(3600), maxTime(3600*24*365), time(0) {}
TimerCallbackCommand* TimerCallbackCommand::New(Program *program) {
TimerCallbackCommand *cb = new TimerCallbackCommand();
cb->setProgram(program);
cb->setPaused(false);
cb->setPaused(true);
return cb;
}
@ -17,19 +18,17 @@ void TimerCallbackCommand::Execute(vtkObject* caller, unsigned long eventId, voi
if (eventId == vtkCommand::KeyPressEvent and not strcmp("space", intr->GetKeySym())) {
this->paused = ! this->paused;
} else if (eventId == vtkCommand::TimerEvent and not this->paused) {
this->time += this->dt;
this->time += this->dt;
if (this->time >= this->maxTime) {
return;
// TODO: how do we deal with reaching the end of the simulated dataset? Do we just stop simulating, loop back around? What about the location of the particles in this case? Just some ideas to consider, but we should iron this out pretty soon.
if (this->time >= this->maxTime) {
return;
// TODO: how do we deal with reaching the end of the simulated dataset? Do we just stop simulating, loop back around? What about the location of the particles in this case? Just some ideas to consider, but we should iron this out pretty soon.
}
this->program->updateData(this->time);
}
this->program->updateData(this->time);
}
}
void TimerCallbackCommand::setProgram(Program *program) {
this->program = program;
}

74
vtk/src/layers/BackgroundImage.cpp
View File

@ -1,8 +1,17 @@
#include "BackgroundImage.h"
#include <vtkImageDataGeometryFilter.h>
#include <vtkImageChangeInformation.h>
#include <vtkImageSliceMapper.h>
#include <vtkCamera.h>
#include <vtkImageActor.h>
#include <vtkImageData.h>
#include <vtkImageMapper3D.h>
#include <vtkImageReader2.h>
#include <vtkImageShiftScale.h>
#include <vtkMatrix4x4.h>
#include <vtkPolyDataMapper.h>
#include <vtkTransform.h>
#include <vtkTransformFilter.h>
using std::string;
@ -14,41 +23,61 @@ BackgroundImage::BackgroundImage(string imagePath) : imagePath(imagePath) {
}
vtkSmartPointer<vtkMatrix4x4> BackgroundImage::getMatrix(const double x0, const double y0, const int xMax, const int yMax) {
double eyeTransform[] = {
2/(xMax-x0), 0, 0, -(xMax+x0)/(xMax-x0),
0, 2/(yMax-y0), 0, -(yMax+y0)/(yMax-y0),
0, 0, 1, 0,
0, 0, 0, 1
};
auto matrix = vtkSmartPointer<vtkMatrix4x4>::New();
matrix->DeepCopy(eyeTransform);
return matrix;
}
void BackgroundImage::updateImage() {
vtkSmartPointer<vtkImageData> imageData;
// read image data
vtkSmartPointer<vtkImageReader2> imageReader;
imageReader.TakeReference(this->readerFactory->CreateImageReader2(this->imagePath.c_str()));
imageReader->SetFileName(this->imagePath.c_str());
imageReader->Update();
imageData = imageReader->GetOutput();
vtkNew<vtkImageActor> imageActor;
imageActor->SetInputData(imageData);
// translate image such that the middle is at (0,0)
vtkNew<vtkImageChangeInformation> imageCenterer;
imageCenterer->SetInputConnection(imageReader->GetOutputPort());
imageCenterer->CenterImageOn();
imageCenterer->Update();
this->ren->AddActor(imageActor);
// camera stuff
// essentially sets the camera to the middle of the background, and points it at the background
// TODO: extract this to its own function, separate from the background class.
double origin[3], spacing[3];
// get some info from the data we'll need in a second
vtkSmartPointer<vtkImageData> imageData = imageCenterer->GetOutput();
double origin[3];
int extent[6];
imageData->GetOrigin(origin);
imageData->GetSpacing(spacing);
imageData->GetExtent(extent);
vtkCamera *camera = this->ren->GetActiveCamera();
camera->ParallelProjectionOn();
// map the imageData to a vtkPolydata so we can use a vtkTransform
vtkNew<vtkImageDataGeometryFilter> imageDataGeometryFilter;
imageDataGeometryFilter->SetInputData(imageData);
imageDataGeometryFilter->Update();
double xc = origin[0] + 0.5 * (extent[0] + extent[1]) * spacing[0];
double yc = origin[1] + 0.5 * (extent[2] + extent[3]) * spacing[1];
double yd = (extent[3] - extent[2] + 1) * spacing[1];
double d = camera->GetDistance();
camera->SetParallelScale(0.5 * yd);
camera->SetFocalPoint(xc, yc, 0.0);
camera->SetPosition(xc, yc, d);
// setup the vtkTransform - this is where use the data from imageData we got earlier
vtkNew<vtkTransform> transform;
transform->SetMatrix(getMatrix(origin[0], origin[1], extent[1]+origin[0], extent[3]+origin[1]));
vtkSmartPointer<vtkTransformFilter> transformFilter = vtkSmartPointer<vtkTransformFilter>::New();
transformFilter->SetTransform(transform);
transformFilter->SetInputConnection(imageDataGeometryFilter->GetOutputPort());
transformFilter->Update();
// Create a mapper and actor
vtkNew<vtkPolyDataMapper> mapper;
mapper->SetInputConnection(transformFilter->GetOutputPort());
vtkNew<vtkActor> actor;
actor->SetMapper(mapper);
this->ren->AddActor(actor);
}
@ -60,3 +89,4 @@ void BackgroundImage::setImagePath(string imagePath) {
this->imagePath = imagePath;
updateImage();
}

9
vtk/src/layers/BackgroundImage.h
View File

@ -16,6 +16,15 @@ private:
*/
void updateImage();
/** This function returns a 4x4matrix which maps the given square of [x0,w] x [y0,h] to the range [-1,1].
* @param x0 : x coordinate of leftmost edge of image
* @param y0 : y coordinate of bottommost edge of image
* @param xMax : x coordinate of rightmost edge of image
* @param yMax : y coordinate of topmost edge of image
* @return a 4x4 matrix which transforms the image from its original geometry to the range [-1,1]
*/
vtkSmartPointer<vtkMatrix4x4> getMatrix(const double x0, const double y0, const int xMax, const int yMax);
public:
/** Constructor.

7
vtk/src/layers/EGlyphLayer.cpp
View File

@ -41,9 +41,6 @@ void EGlyphLayer::readCoordinates() {
this->direction->SetNumberOfTuples(numLats * numLons);
points->Allocate(numLats * numLons);
auto camera = createNormalisedCamera();
ren->SetActiveCamera(camera);
int i = 0;
int latIndex = 0;
for (double lat: uvGrid->lats) {
@ -77,11 +74,7 @@ void EGlyphLayer::readCoordinates() {
glyph2D->SetVectorModeToUseVector();
glyph2D->Update();
// vtkNew<vtkCoordinate> coordinate;
// coordinate->SetCoordinateSystemToWorld();
vtkNew<vtkPolyDataMapper>(mapper);
// mapper->SetTransformCoordinate(coordinate);
mapper->SetInputConnection(glyph2D->GetOutputPort());
mapper->Update();

20
vtk/src/layers/LGlyphLayer.cpp
View File

@ -5,6 +5,7 @@
#include <vtkGlyphSource2D.h>
#include <vtkNamedColors.h>
#include <vtkPolyDataMapper2D.h>
#include <vtkProperty.h>
#include <vtkProperty2D.h>
#include <vtkVertexGlyphFilter.h>
#include <vtkInteractorStyle.h>
@ -42,9 +43,6 @@ LGlyphLayer::LGlyphLayer(std::shared_ptr<UVGrid> uvGrid, std::unique_ptr<Advecti
advector = std::move(advectionKernel);
this->uvGrid = uvGrid;
auto camera = createNormalisedCamera();
ren->SetActiveCamera(camera);
vtkSmartPointer<vtkTransformFilter> transformFilter = createCartographicTransformFilter(uvGrid);
transformFilter->SetInputData(data);
@ -71,11 +69,17 @@ LGlyphLayer::LGlyphLayer(std::shared_ptr<UVGrid> uvGrid, std::unique_ptr<Advecti
// creates a few points so we can test the updateData function
void LGlyphLayer::spoofPoints() {
this->points->InsertNextPoint(-4.125, 61.375, 0);
this->points->InsertNextPoint(6.532949683882039, 53.24308582564463, 0); // Coordinates of Zernike
this->points->InsertNextPoint(5.315307819255385, 60.40001057122271, 0); // Coordinates of Bergen
this->points->InsertNextPoint(6.646210231365825, 46.52346296009023, 0); // Coordinates of Lausanne
this->points->InsertNextPoint(-6.553894313570932, 62.39522131195857,0); // Coordinates of the top of the Faroe islands
this->points->InsertNextPoint(-4.125, 61.375 , 0);
// this->points->InsertNextPoint(6.532949683882039, 53.24308582564463, 0); // Coordinates of Zernike
// this->points->InsertNextPoint(5.315307819255385, 60.40001057122271, 0); // Coordinates of Bergen
// this->points->InsertNextPoint( 6.646210231365825, 46.52346296009023, 0); // Coordinates of Lausanne
// this->points->InsertNextPoint(-6.553894313570932, 62.39522131195857, 0); // Coordinates of the top of the Faroe islands
for (int i=0; i < 330; i+=5) {
for (int j=0; j < 330; j+=5) {
this->points->InsertNextPoint(-15.875+(12.875+15.875)/330*j, 46.125+(62.625-46.125)/330*i, 0);
}
}
this->points->Modified();
}

5
vtk/src/layers/Layer.cpp
View File

@ -15,3 +15,8 @@ void Layer::updateData(int t) {
void Layer::addObservers(vtkSmartPointer<vtkRenderWindowInteractor> interactor) {
// By default, do nothing
}
void Layer::setCamera(vtkCamera *camera) {
this->getLayer()->SetActiveCamera(camera);
}

5
vtk/src/layers/Layer.h
View File

@ -27,6 +27,11 @@ public:
* @param interactor : pointer to the interactor that observers can be added to.
*/
virtual void addObservers(vtkSmartPointer<vtkRenderWindowInteractor> interactor);
/** Sets the active camera for the vtkRenderer associated with this layer.
* Used to share one camera between multiple layers.
*/
virtual void setCamera(vtkCamera *camera);
};
#endif