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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
/**
* @class vtkImageViewer
* @brief Display a 2d image.
*
* vtkImageViewer is a convenience class for displaying a 2d image. It
* packages up the functionality found in vtkRenderWindow, vtkRenderer,
* vtkActor2D and vtkImageMapper into a single easy to use class. Behind the
* scenes these four classes are actually used to to provide the required
* functionality. vtkImageViewer is simply a wrapper around them.
*
* @sa
* vtkRenderWindow vtkRenderer vtkImageMapper vtkActor2D
*/
#ifndef vtkImageViewer_h
#define vtkImageViewer_h
#include "vtkInteractionImageModule.h" // For export macro
#include "vtkObject.h"
#include "vtkImageMapper.h" // For all the inline methods
#include "vtkRenderWindow.h" // For all the inline methods
VTK_ABI_NAMESPACE_BEGIN
class vtkInteractorStyleImage;
class VTKINTERACTIONIMAGE_EXPORT vtkImageViewer : public vtkObject
{
public:
static vtkImageViewer* New();
vtkTypeMacro(vtkImageViewer, vtkObject);
void PrintSelf(ostream& os, vtkIndent indent) override;
/**
* Get name of rendering window
*/
char* GetWindowName() { return this->RenderWindow->GetWindowName(); }
/**
* Render the resulting image.
*/
virtual void Render();
///@{
/**
* Set/Get the input to the viewer.
*/
void SetInputData(vtkImageData* in) { this->ImageMapper->SetInputData(in); }
vtkImageData* GetInput() { return this->ImageMapper->GetInput(); }
virtual void SetInputConnection(vtkAlgorithmOutput* input)
{
this->ImageMapper->SetInputConnection(input);
}
///@}
///@{
/**
* What is the possible Min/ Max z slices available.
*/
int GetWholeZMin() { return this->ImageMapper->GetWholeZMin(); }
int GetWholeZMax() { return this->ImageMapper->GetWholeZMax(); }
///@}
///@{
/**
* Set/Get the current Z Slice to display
*/
int GetZSlice() { return this->ImageMapper->GetZSlice(); }
void SetZSlice(int s) { this->ImageMapper->SetZSlice(s); }
///@}
///@{
/**
* Sets window/level for mapping pixels to colors.
*/
double GetColorWindow() { return this->ImageMapper->GetColorWindow(); }
double GetColorLevel() { return this->ImageMapper->GetColorLevel(); }
void SetColorWindow(double s) { this->ImageMapper->SetColorWindow(s); }
void SetColorLevel(double s) { this->ImageMapper->SetColorLevel(s); }
///@}
///@{
/**
* These are here for using a tk window.
*/
void SetDisplayId(void* a) { this->RenderWindow->SetDisplayId(a); }
void SetWindowId(void* a) { this->RenderWindow->SetWindowId(a); }
void SetParentId(void* a) { this->RenderWindow->SetParentId(a); }
///@}
///@{
/**
* Get the position (x and y) of the rendering window in
* screen coordinates (in pixels).
*/
int* GetPosition() VTK_SIZEHINT(2) { return this->RenderWindow->GetPosition(); }
/**
* Set the position (x and y) of the rendering window in
* screen coordinates (in pixels). This resizes the operating
* system's view/window and redraws it.
*/
void SetPosition(int x, int y) { this->RenderWindow->SetPosition(x, y); }
virtual void SetPosition(int a[2]);
///@}
///@{
/**
* Get the size (width and height) of the rendering window in
* screen coordinates (in pixels).
*/
int* GetSize() VTK_SIZEHINT(2) { return this->RenderWindow->GetSize(); }
/**
* Set the size (width and height) of the rendering window in
* screen coordinates (in pixels). This resizes the operating
* system's view/window and redraws it.
*
* If the size has changed, this method will fire
* vtkCommand::WindowResizeEvent.
*/
void SetSize(int width, int height) { this->RenderWindow->SetSize(width, height); }
virtual void SetSize(int a[2]);
///@}
///@{
/**
* Get the internal objects
*/
vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
void SetRenderWindow(vtkRenderWindow* renWin);
vtkGetObjectMacro(Renderer, vtkRenderer);
vtkGetObjectMacro(ImageMapper, vtkImageMapper);
vtkGetObjectMacro(Actor2D, vtkActor2D);
///@}
/**
* Create and attach an interactor for this window
*/
void SetupInteractor(vtkRenderWindowInteractor*);
///@{
/**
* Create a window in memory instead of on the screen. This may not
* be supported for every type of window and on some windows you may
* need to invoke this prior to the first render.
*/
void SetOffScreenRendering(vtkTypeBool);
vtkTypeBool GetOffScreenRendering();
void OffScreenRenderingOn();
void OffScreenRenderingOff();
///@}
protected:
vtkImageViewer();
~vtkImageViewer() override;
vtkRenderWindow* RenderWindow;
vtkRenderer* Renderer;
vtkImageMapper* ImageMapper;
vtkActor2D* Actor2D;
int FirstRender;
vtkRenderWindowInteractor* Interactor;
vtkInteractorStyleImage* InteractorStyle;
friend class vtkImageViewerCallback;
vtkAlgorithm* GetInputAlgorithm();
private:
vtkImageViewer(const vtkImageViewer&) = delete;
void operator=(const vtkImageViewer&) = delete;
};
VTK_ABI_NAMESPACE_END
#endif
|
