TeraVTK/main.cpp at main · Ursus14/TeraVTK · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <vtkAutoInit.h>

VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);


#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkCamera.h>
#include <vtkActor.h>
#include <vtkRenderer.h>
#include <vtkCallbackCommand.h>
#include <vtkPlotPoints.h>
#include <vtkTable.h>
#include <vtkDataObjectToTable.h>
#include <vtkFloatArray.h>
#include <vtkMapper.h>

#include "Grid.h"
#include "PlaneGrid.h"
#include "InteractorStyle.h"
#include "MainAxes.h"
#include "Point.h"


static void CameraModifiedCallback(vtkObject* caller,
	long unsigned int vtkNotUsed(eventId),
	void* vtkNotUsed(clientData),
	void* vtkNotUsed(callData))
{
	vtkCamera* camera = static_cast<vtkCamera*>(caller);
	camera->SetFocalPoint(camera->GetPosition()[0], camera->GetPosition()[1], 0);
}

int main(int, char* [])
{
	vtkSmartPointer<vtkCamera> camera = vtkSmartPointer<vtkCamera>::New();
	vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();

	double cell[2] = { 1,1 };
	double parallelScale = 4;
	int sizewin[2] = { 600,600 };


		PlaneGrid* plane = new PlaneGrid(cell, sizewin, parallelScale);
	MainAxes* axes = new MainAxes(sizewin, parallelScale);
	Point* marker = new Point(0.03 * cell[0]);
	marker->VisibilityOff();
	std::vector<Point> drawPoints;

	renderer->AddActor(plane->GetActor(0));
	renderer->AddActor(plane->GetActor(1));
	renderer->AddActor(plane->GetActor(2));
	renderer->AddActor(plane->GetActor(3));
	renderer->AddActor(axes->GetActor());
	renderer->AddActor(marker->GetActor());

	renderer->SetBackground(1, 1, 1);

	vtkSmartPointer<vtkRenderWindow> renderwindow =
		vtkSmartPointer<vtkRenderWindow>::New();
	renderwindow->AddRenderer(renderer);

	vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
		vtkSmartPointer<vtkRenderWindowInteractor>::New();
	renderWindowInteractor->SetRenderWindow(renderwindow);

	camera->ParallelProjectionOn();
	camera->SetParallelScale(parallelScale);

	vtkSmartPointer<vtkCallbackCommand> modifiedcallback =
		vtkSmartPointer<vtkCallbackCommand>::New();
	modifiedcallback->SetCallback(CameraModifiedCallback);

	renderer->SetActiveCamera(camera);
	renderer->GetActiveCamera()->AddObserver(vtkCommand::ModifiedEvent, modifiedcallback);

	renderer->AutomaticLightCreationOff();
	renderer->GradientEnvironmentalBGOff();

	InteractorStyle* newGrid = new InteractorStyle(plane, axes, marker, drawPoints, renderer);

	vtkSmartPointer<InteractorStyle> style =
		vtkSmartPointer<InteractorStyle>::Take(newGrid);
	renderWindowInteractor->SetInteractorStyle(style);

	renderwindow->SetSize(sizewin);
	renderwindow->Render();
	renderWindowInteractor->Initialize();
	renderWindowInteractor->EnableRenderOn();
	renderWindowInteractor->Start();

	return EXIT_SUCCESS;
}