feat (wip): refactor of main func into actual organized classes

vtk/src/CMakeLists.txt

@@ -29,7 +29,18 @@ endif()
 # netcdf setup
 find_package(netCDF REQUIRED)
 
-add_executable(VtkBase MACOSX_BUNDLE main.cpp )
+add_executable(VtkBase MACOSX_BUNDLE main.cpp 
+  helperClasses/BackgroundImage.cpp 
+  helperClasses/BackgroundImage.h
+  helperClasses/EGlyphLayer.cpp
+  helperClasses/EGlyphLayer.h
+  helperClasses/Layer.cpp
+  helperClasses/Layer.h
+  helperClasses/LGlyphLayer.cpp
+  helperClasses/LGlyphLayer.h
+  helperClasses/Program.cpp
+  helperClasses/Program.h
+)
 
 execute_process(
     COMMAND nc-config --includedir

vtk/src/helperClasses/BackgroundImage.cpp

@@ -0,0 +1,62 @@
+#include "BackgroundImage.h"
+#include <vtkCamera.h>
+#include <vtkImageActor.h>
+#include <vtkImageData.h>
+#include <vtkImageReader2.h>
+
+using std::string;
+
+BackgroundImage::BackgroundImage(string imagePath) : imagePath(imagePath) {
+  this->ren = vtkSmartPointer<vtkRenderer>::New();
+  this->ren->SetLayer(0);
+  this->ren->InteractiveOff();
+  updateImage();
+}
+
+
+void BackgroundImage::updateImage() {
+  vtkSmartPointer<vtkImageData> imageData;
+
+  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);
+
+  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];
+  int extent[6];
+  imageData->GetOrigin(origin);
+  imageData->GetSpacing(spacing);
+  imageData->GetExtent(extent);
+
+  vtkCamera *camera = this->ren->GetActiveCamera();
+  camera->ParallelProjectionOn();
+
+  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);
+}
+
+
+string BackgroundImage::getImagePath() {
+  return this->imagePath;
+}
+
+void BackgroundImage::setImagePath(string imagePath) {
+  this->imagePath = imagePath;
+  updateImage();
+}

vtk/src/helperClasses/BackgroundImage.h

@@ -0,0 +1,22 @@
+#ifndef BACKGROUND_H
+#define BACKGROUND_H
+
+#include "Layer.h"
+#include <vtkImageReader2Factory.h>
+
+class BackgroundImage : public Layer {
+private:
+  std::string imagePath;
+  vtkSmartPointer<vtkImageReader2Factory> readerFactory;
+
+  void updateImage();
+
+
+public:
+  BackgroundImage(std::string imagePath);
+
+  std::string getImagePath();
+  void setImagePath(std::string imagePath);
+};
+
+#endif

vtk/src/helperClasses/EGlyphLayer.cpp

@@ -0,0 +1,8 @@
+#include "EGlyphLayer.h"
+
+
+EGlyphLayer::EGlyphLayer() {
+  this->ren = vtkSmartPointer<vtkRenderer>::New();
+  this->ren->SetLayer(1);
+  this->ren->InteractiveOff();
+}

vtk/src/helperClasses/EGlyphLayer.h

@@ -0,0 +1,15 @@
+#ifndef EGLYPHLAYER_H
+#define EGLYPHLAYER_H
+
+#include "Layer.h"
+
+
+
+class EGlyphLayer : public Layer {
+public:
+  EGlyphLayer();
+
+};
+
+
+#endif

vtk/src/helperClasses/LGlyphLayer.cpp

@@ -0,0 +1,7 @@
+#include "LGlyphLayer.h"
+
+
+LGlyphLayer::LGlyphLayer() {
+  this->ren = vtkSmartPointer<vtkRenderer>::New();
+  this->ren->SetLayer(2);
+}

vtk/src/helperClasses/LGlyphLayer.h

@@ -0,0 +1,12 @@
+#ifndef LGLYPHLAYER_H
+#define LGLYPHLAYER_H
+
+#include "Layer.h"
+
+class LGlyphLayer : public Layer {
+public:
+  LGlyphLayer();
+
+};
+
+#endif

vtk/src/helperClasses/Layer.cpp

@@ -0,0 +1,7 @@
+#include "Layer.h"
+
+using std::string;
+
+vtkSmartPointer<vtkRenderer> Layer::getLayer() {
+  return this->ren;
+}

vtk/src/helperClasses/Layer.h

@@ -0,0 +1,17 @@
+#ifndef LAYER_H
+#define LAYER_H
+
+#include <vtkRenderer.h>
+
+/** This class represents one abstract layer to be rendered to VTK.
+  * It exists to manage multiple different layers under the Program class.
+  */
+class Layer {
+protected:
+  vtkSmartPointer<vtkRenderer> ren;
+
+public:
+  virtual vtkSmartPointer<vtkRenderer> getLayer();
+};
+
+#endif

vtk/src/helperClasses/Program.cpp

@@ -0,0 +1,57 @@
+#include <vtkRenderWindow.h>
+#include <vtkNew.h>
+
+#include "Program.h"
+
+
+void Program::setWinProperties() {
+  this->win->SetWindowName("Simulation");
+  this->win->SetSize(661, 661);
+
+  this->interact->SetRenderWindow(this->win);
+}
+
+// Program::Program() : background(), euler(), lagrange(), win(), interact() {
+//   setWinProperties();
+// }
+
+Program::Program(Layer bg, Layer e, Layer l) : background(bg), euler(e), lagrange(l), win(), interact() {
+  this->win = vtkSmartPointer<vtkRenderWindow>::New();
+  this->interact = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+
+  this->win->SetNumberOfLayers(3);
+  this->win->AddRenderer(bg.getLayer());
+  this->win->AddRenderer(e.getLayer());
+  this->win->AddRenderer(l.getLayer());
+  setWinProperties();
+}
+
+
+void Program::setBackground(Layer bg) {
+  this->win->RemoveRenderer(this->background.getLayer());
+  this->background = bg;
+  this->win->AddRenderer(bg.getLayer());
+  
+}
+
+
+void Program::setEuler(Layer e) {
+  this->win->RemoveRenderer(this->euler.getLayer());
+  this->euler = e;
+  this->win->AddRenderer(e.getLayer());
+}
+
+
+void Program::setLagrange(Layer l) {
+  this->win->RemoveRenderer(this->lagrange.getLayer());
+  this->lagrange = l;
+  this->win->AddRenderer(l.getLayer());
+}
+
+// void Program::addInteractionStyle(vtkInteractorStyle style);
+
+
+void Program::render() {
+  this->win->Render();
+  this->interact->Start();
+}

vtk/src/helperClasses/Program.h

@@ -0,0 +1,35 @@
+#ifndef PROGRAM_H
+#define PROGRAM_H
+
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
+
+#include "Layer.h"
+
+class Program {
+private:
+  Layer background;
+  Layer euler;
+  Layer lagrange;
+  vtkSmartPointer<vtkRenderWindow> win;
+  vtkSmartPointer<vtkRenderWindowInteractor> interact;
+
+  void setWinProperties();
+  
+
+public:
+  // Program();
+  Program(Layer bg, Layer e, Layer l);
+
+  void setBackground(Layer bg);
+  void setEuler(Layer e);
+  void setLagrange(Layer l);
+
+
+  // void addInteractionStyle(vtkInteractorStyle style);
+
+  void render();
+};
+
+#endif

vtk/src/main.cpp

@@ -1,31 +1,17 @@
-#include <vtkActor.h>
-#include <vtkActor2D.h>
-#include <vtkCamera.h>
-#include <vtkDoubleArray.h>
-#include <vtkMapper2D.h>
-#include <vtkImageReader2.h>
-#include <vtkImageData.h>
-#include <vtkImageActor.h>
-#include <vtkImageReader2Factory.h>
-#include <vtkNamedColors.h>
-#include <vtkNew.h>
-#include <vtkPolyDataMapper.h>
-#include <vtkPolyDataMapper2D.h>
-#include <vtkProgrammableGlyphFilter.h>
-#include <vtkSmartPointer.h>
-#include <vtkProperty.h>
-#include <vtkProperty2D.h>
-#include <vtkRectilinearGrid.h>
-#include <vtkRectilinearGridGeometryFilter.h>
-#include <vtkRenderWindow.h>
-#include <vtkRenderWindowInteractor.h>
-#include <vtkRenderer.h>
-
 #include <netcdf>
+#include <vector>
+#include <vtkActor2D.h>
+#include <vtkNamedColors.h>
+#include <vtkPoints.h>
+#include <vtkPolyData.h>
+#include <vtkPolyDataMapper2D.h>
+#include <vtkProperty2D.h>
+#include <vtkRenderer.h>
 #include <vtkVertexGlyphFilter.h>
 
-#define NLATS 67
+#include "helperClasses/BackgroundImage.h"
-#define NLONS 116
+#include "helperClasses/EGlyphLayer.h"
+#include "helperClasses/Program.h"
 
 using namespace std;
 using namespace netCDF;
@@ -71,6 +57,7 @@ void renderCoordinates(vtkRenderer *ren, vtkNamedColors *colors) {
   vtkNew<vtkPolyData> polydata;
   polydata->SetPoints(points);
 
+
   vtkNew<vtkVertexGlyphFilter> glyphFilter;
   glyphFilter->SetInputData(polydata);
   glyphFilter->Update();
@@ -87,73 +74,21 @@ void renderCoordinates(vtkRenderer *ren, vtkNamedColors *colors) {
   ren->AddActor(actor);
 }
 
-void renderBackground(vtkRenderer *background) {
-  vtkSmartPointer<vtkImageData> imageData;
-
-  vtkNew<vtkImageReader2Factory> readerFactory;
-  vtkSmartPointer<vtkImageReader2> imageReader;
-  
-  imageReader.TakeReference(readerFactory->CreateImageReader2("../../../../data/map_661-661.png"));
-  imageReader->SetFileName("../../../../data/map_661-661.png");
-  imageReader->Update();
-  imageData = imageReader->GetOutput();
-
-  vtkNew<vtkImageActor> imageActor;
-  imageActor->SetInputData(imageData);
-
-  background->AddActor(imageActor);
-
-
-  // camera stuff
-  // essentially sets the camera to the middle of the background, and points it at the background
-  double origin[3], spacing[3];
-  int extent[6];
-  imageData->GetOrigin(origin);
-  imageData->GetSpacing(spacing);
-  imageData->GetExtent(extent);
-
-  vtkCamera *camera = background->GetActiveCamera();
-  camera->ParallelProjectionOn();
-
-  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);
-}
 
 int main() {
-  vtkNew<vtkNamedColors> colors;
+  auto bg = new BackgroundImage("../../../../data/map_661-661.png");
-  vtkNew<vtkRenderer> Euler, Background, Lagrange;
+  auto e = new EGlyphLayer();
-  Euler->SetBackground(colors->GetColor3d("DarkSlateGray").GetData());
+  auto l = new EGlyphLayer();
+  auto program = new Program(*bg, *e, *l);
+  program->render();
 
 
-  Background->SetLayer(0);
+  // vtkNew<vtkNamedColors> colors;
-  Background->InteractiveOff();
+  // vtkNew<vtkRenderer> Euler, Background, Lagrange;
-  Euler->SetLayer(1);
+  // Euler->SetBackground(colors->GetColor3d("DarkSlateGray").GetData());
-  Euler->InteractiveOff();
-  Lagrange->SetLayer(2);
 
-  renderCoordinates(Euler, colors);
-  renderBackground(Background);
-
-  vtkNew<vtkRenderWindow> renWin;
-  renWin->SetNumberOfLayers(3);
-  // renWin->SetNumberOfLayers(2);
-  renWin->AddRenderer(Background);
-  renWin->AddRenderer(Euler);
-  renWin->AddRenderer(Lagrange);
-  renWin->SetWindowName("Simulation");
-  renWin->SetSize(661, 661);
-
-  vtkNew<vtkRenderWindowInteractor> iren;
-  iren->SetRenderWindow(renWin);
-
-  renWin->Render();
-  iren->Start();
 
+  // renderCoordinates(Euler, colors);
 
   return EXIT_SUCCESS;
 }