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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
/*=========================================================================
Program: ParaView
Module: vtkUnstructuredGridVolumeRepresentation.h
Copyright (c) Kitware, Inc.
All rights reserved.
See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
/**
* @class vtkUnstructuredGridVolumeRepresentation
* @brief representation for showing
* vtkUnstructuredGrid datasets as volumes.
*
* vtkUnstructuredGridVolumeRepresentation is a representation for volume
* rendering vtkUnstructuredGrid datasets. It simply renders a translucent
* surface for LOD i.e. interactive rendering.
*/
#ifndef vtkUnstructuredGridVolumeRepresentation_h
#define vtkUnstructuredGridVolumeRepresentation_h
#include "vtkPVClientServerCoreRenderingModule.h" //needed for exports
#include "vtkPVDataRepresentation.h"
class vtkAbstractVolumeMapper;
class vtkColorTransferFunction;
class vtkOutlineSource;
class vtkPExtentTranslator;
class vtkPiecewiseFunction;
class vtkPolyDataMapper;
class vtkProjectedTetrahedraMapper;
class vtkPVCacheKeeper;
class vtkPVGeometryFilter;
class vtkPVLODVolume;
class vtkResampleToImage;
class vtkVolumeProperty;
class vtkVolumeRepresentationPreprocessor;
class VTKPVCLIENTSERVERCORERENDERING_EXPORT vtkUnstructuredGridVolumeRepresentation
: public vtkPVDataRepresentation
{
public:
static vtkUnstructuredGridVolumeRepresentation* New();
vtkTypeMacro(vtkUnstructuredGridVolumeRepresentation, vtkPVDataRepresentation);
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
/**
* Register a volume mapper with the representation.
*/
void AddVolumeMapper(const char* name, vtkAbstractVolumeMapper*);
//@{
/**
* Set the active volume mapper to use.
*/
virtual void SetActiveVolumeMapper(const char*);
vtkAbstractVolumeMapper* GetActiveVolumeMapper();
//@}
/**
* vtkAlgorithm::ProcessRequest() equivalent for rendering passes. This is
* typically called by the vtkView to request meta-data from the
* representations or ask them to perform certain tasks e.g.
* PrepareForRendering.
*/
virtual int ProcessViewRequest(vtkInformationRequestKey* request_type, vtkInformation* inInfo,
vtkInformation* outInfo) VTK_OVERRIDE;
/**
* This needs to be called on all instances of vtkGeometryRepresentation when
* the input is modified. This is essential since the geometry filter does not
* have any real-input on the client side which messes with the Update
* requests.
*/
virtual void MarkModified() VTK_OVERRIDE;
/**
* Get/Set the visibility for this representation. When the visibility of
* representation of false, all view passes are ignored.
* Overridden to propagate to the active representation.
*/
virtual void SetVisibility(bool val) VTK_OVERRIDE;
//***************************************************************************
// Forwarded to vtkVolumeRepresentationPreprocessor
void SetExtractedBlockIndex(unsigned int index);
//***************************************************************************
// Forwarded to vtkResampleToImage
void SetSamplingDimensions(int dims[3])
{
this->SetSamplingDimensions(dims[0], dims[1], dims[2]);
}
void SetSamplingDimensions(int xdim, int ydim, int zdim);
//***************************************************************************
// Forwarded to Actor.
void SetOrientation(double, double, double);
void SetOrigin(double, double, double);
void SetPickable(int val);
void SetPosition(double, double, double);
void SetScale(double, double, double);
//***************************************************************************
// Forwarded to vtkVolumeProperty and vtkProperty (when applicable).
void SetInterpolationType(int val);
void SetColor(vtkColorTransferFunction* lut);
void SetScalarOpacity(vtkPiecewiseFunction* pwf);
void SetScalarOpacityUnitDistance(double val);
/**
* Provides access to the actor used by this representation.
*/
vtkPVLODVolume* GetActor() { return this->Actor; }
//@{
/**
* Specify whether or not to redistribute the data. The default is false
* since that is the only way in general to guarantee correct rendering.
* Can set to true if all rendered data sets are based on the same
* data partitioning in order to save on the data redistribution.
*/
virtual void SetUseDataPartitions(bool);
vtkGetMacro(UseDataPartitions, bool);
//@}
protected:
vtkUnstructuredGridVolumeRepresentation();
~vtkUnstructuredGridVolumeRepresentation();
/**
* Fill input port information.
*/
virtual int FillInputPortInformation(int port, vtkInformation* info) VTK_OVERRIDE;
virtual int RequestData(
vtkInformation*, vtkInformationVector**, vtkInformationVector*) VTK_OVERRIDE;
/**
* Adds the representation to the view. This is called from
* vtkView::AddRepresentation(). Subclasses should override this method.
* Returns true if the addition succeeds.
*/
virtual bool AddToView(vtkView* view) VTK_OVERRIDE;
/**
* Removes the representation to the view. This is called from
* vtkView::RemoveRepresentation(). Subclasses should override this method.
* Returns true if the removal succeeds.
*/
virtual bool RemoveFromView(vtkView* view) VTK_OVERRIDE;
/**
* Overridden to check with the vtkPVCacheKeeper to see if the key is cached.
*/
virtual bool IsCached(double cache_key) VTK_OVERRIDE;
/**
* Passes on parameters to the active volume mapper
*/
virtual void UpdateMapperParameters();
int ProcessViewRequestResampleToImage(
vtkInformationRequestKey* request_type, vtkInformation* inInfo, vtkInformation* outInfo);
int RequestDataResampleToImage(vtkInformation* request, vtkInformationVector** inputVector,
vtkInformationVector* outputVector);
vtkVolumeRepresentationPreprocessor* Preprocessor;
vtkPVCacheKeeper* CacheKeeper;
vtkProjectedTetrahedraMapper* DefaultMapper;
vtkVolumeProperty* Property;
vtkPVLODVolume* Actor;
vtkResampleToImage* ResampleToImageFilter;
unsigned long DataSize;
vtkPExtentTranslator* PExtentTranslator;
double Origin[3];
double Spacing[3];
int WholeExtent[6];
vtkOutlineSource* OutlineSource;
vtkPVGeometryFilter* LODGeometryFilter;
vtkPolyDataMapper* LODMapper;
double DataBounds[6];
bool UseDataPartitions;
private:
vtkUnstructuredGridVolumeRepresentation(
const vtkUnstructuredGridVolumeRepresentation&) VTK_DELETE_FUNCTION;
void operator=(const vtkUnstructuredGridVolumeRepresentation&) VTK_DELETE_FUNCTION;
class vtkInternals;
vtkInternals* Internals;
};
#endif
|
