renamed and stuff

particle-track-and-trace/src/commands/SpawnPointCallback.cpp

@@ -0,0 +1,82 @@
+#include "SpawnPointCallback.h"
+
+#include <vtkVertex.h>
+#include <vtkRenderer.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkSmartPointer.h>
+#include <vtkCommand.h>
+#include <vtkRenderWindow.h>
+
+#include "../CartographicTransformation.h"
+
+void convertDisplayToWorld(vtkRenderer *renderer, int x, int y, double *worldPos) {
+  double displayPos[3] = {static_cast<double>(x), static_cast<double>(y), 0.0};
+  renderer->SetDisplayPoint(displayPos);
+  renderer->DisplayToWorld();
+  renderer->GetWorldPoint(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);
+
+  if (evId == vtkCommand::LeftButtonPressEvent) {
+    dragging = true;
+  }
+  if (evId == vtkCommand::LeftButtonReleaseEvent) {
+    dragging = false;
+  }
+  if (!dragging) {
+    return;
+  }
+
+  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;
+
+  vtkIdType id = points->InsertNextPoint(worldPos[0], worldPos[1], 0);
+  data->SetPoints(points);
+
+  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();
+}
+
+
+SpawnPointCallback::SpawnPointCallback() : data(nullptr),
+                                           points(nullptr),
+                                           inverseCartographicProjection(nullptr),
+                                           uvGrid(nullptr) { }
+
+SpawnPointCallback *SpawnPointCallback::New() {
+    return new SpawnPointCallback;
+}
+
+void SpawnPointCallback::setData(const vtkSmartPointer<vtkPolyData> &data) {
+  this->data = data;
+}
+
+void SpawnPointCallback::setPoints(const vtkSmartPointer<vtkPoints> &points) {
+  this->points = points;
+}
+
+void SpawnPointCallback::setRen(const vtkSmartPointer<vtkRenderer> &ren) {
+  this->ren = ren;
+}
+
+void SpawnPointCallback::setUVGrid(const std::shared_ptr<UVGrid> &uvGrid) {
+  this->uvGrid = uvGrid;
+  inverseCartographicProjection = getCartographicTransformMatrix(uvGrid);
+  inverseCartographicProjection->Invert();
+}

particle-track-and-trace/src/commands/SpawnPointCallback.h

@@ -0,0 +1,40 @@
+#ifndef SPAWNPOINTCALLBACK_H
+#define SPAWNPOINTCALLBACK_H
+
+
+#include <vtkCallbackCommand.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkPoints.h>
+#include <vtkPolyData.h>
+#include <vtkMatrix4x4.h>
+#include "../advection/UVGrid.h"
+
+class SpawnPointCallback : public vtkCallbackCommand {
+
+public:
+  static SpawnPointCallback *New();
+
+  SpawnPointCallback();
+
+  void setPoints(const vtkSmartPointer<vtkPoints> &points);
+
+  void setData(const vtkSmartPointer<vtkPolyData> &data);
+
+  void setRen(const vtkSmartPointer<vtkRenderer> &ren);
+
+  void setUVGrid(const std::shared_ptr<UVGrid> &uvGrid);
+
+private:
+  vtkSmartPointer<vtkPolyData> data;
+  vtkSmartPointer<vtkPoints> points;
+  vtkSmartPointer<vtkRenderer> ren;
+  std::shared_ptr<UVGrid> uvGrid;
+  vtkSmartPointer<vtkMatrix4x4> inverseCartographicProjection;
+
+  void Execute(vtkObject *caller, unsigned long evId, void *callData) override;
+
+  bool dragging = false;
+};
+
+
+#endif //SPAWNPOINTCALLBACK_H

particle-track-and-trace/src/commands/TimerCallbackCommand.cpp

@@ -0,0 +1,44 @@
+#include "TimerCallbackCommand.h"
+#include "../Program.h"
+
+
+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);
+  return cb;
+}
+
+void TimerCallbackCommand::Execute(vtkObject* caller, unsigned long eventId, void* vtkNotUsed(callData)) {
+  auto intr = reinterpret_cast<vtkRenderWindowInteractor *>(caller);
+  
+  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;
+
+  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);
+  }
+
+}
+
+
+void TimerCallbackCommand::setProgram(Program *program) {
+  this->program = program;
+}
+
+
+void TimerCallbackCommand::setPaused(const bool val) {
+  this->paused = val;
+}
+
+void TimerCallbackCommand::setDt(int dt) {
+  this->dt = dt;
+}

particle-track-and-trace/src/commands/TimerCallbackCommand.h

@@ -0,0 +1,26 @@
+#ifndef TIMERCALLBACKCOMMAND_H
+#define TIMERCALLBACKCOMMAND_H
+
+#include <vtkCallbackCommand.h>
+#include "../Program.h"
+
+class TimerCallbackCommand : public vtkCallbackCommand {
+public:
+  TimerCallbackCommand();
+  static TimerCallbackCommand* New(Program *program);
+  void Execute(vtkObject* caller, unsigned long eventId, void* vtkNotUsed(callData)) override;
+
+  void setProgram(Program *program);
+  void setPaused(const bool val);
+
+  void setDt(int dt);
+
+private:
+  int time;
+  int dt;
+  int maxTime;
+  bool paused;
+  Program *program;
+};
+
+#endif