VTK  9.1.0
vtkSurfaceLICInterface.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkSurfaceLICMapper.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================*/
56#ifndef vtkSurfaceLICInterface_h
57#define vtkSurfaceLICInterface_h
58
59#include "vtkObject.h"
60#include "vtkRenderingLICOpenGL2Module.h" // For export macro
61
62class vtkRenderWindow;
63class vtkRenderer;
64class vtkActor;
65class vtkImageData;
66class vtkDataObject;
67class vtkDataArray;
70class vtkWindow;
71
72class VTKRENDERINGLICOPENGL2_EXPORT vtkSurfaceLICInterface : public vtkObject
73{
74public:
77 void PrintSelf(ostream& os, vtkIndent indent) override;
78
80
83 void SetNumberOfSteps(int val);
84 vtkGetMacro(NumberOfSteps, int);
86
88
91 void SetStepSize(double val);
92 vtkGetMacro(StepSize, double);
94
96
107 void SetNormalizeVectors(int val);
108 vtkBooleanMacro(NormalizeVectors, int);
109 vtkGetMacro(NormalizeVectors, int);
111
113
118 void SetMaskOnSurface(int val);
119 vtkBooleanMacro(MaskOnSurface, int);
120 vtkGetMacro(MaskOnSurface, int);
122
124
140 void SetMaskThreshold(double val);
141 vtkGetMacro(MaskThreshold, double);
143
145
150 void SetMaskColor(double* val);
151 void SetMaskColor(double r, double g, double b)
152 {
153 double rgb[3] = { r, g, b };
154 this->SetMaskColor(rgb);
155 }
156 vtkGetVector3Macro(MaskColor, double);
158
160
168 void SetMaskIntensity(double val);
169 vtkGetMacro(MaskIntensity, double);
171
173
178 void SetEnhancedLIC(int val);
179 vtkGetMacro(EnhancedLIC, int);
180 vtkBooleanMacro(EnhancedLIC, int);
182
184
217 enum
218 {
219 ENHANCE_CONTRAST_OFF = 0,
220 ENHANCE_CONTRAST_LIC = 1,
221 ENHANCE_CONTRAST_COLOR = 3,
222 ENHANCE_CONTRAST_BOTH = 4
223 };
224 void SetEnhanceContrast(int val);
225 vtkGetMacro(EnhanceContrast, int);
227
229
245 vtkGetMacro(LowLICContrastEnhancementFactor, double);
246 vtkGetMacro(HighLICContrastEnhancementFactor, double);
249 //
250 vtkGetMacro(LowColorContrastEnhancementFactor, double);
251 vtkGetMacro(HighColorContrastEnhancementFactor, double);
255
257
263 void SetAntiAlias(int val);
264 vtkBooleanMacro(AntiAlias, int);
265 vtkGetMacro(AntiAlias, int);
267
269
278 enum
279 {
280 COLOR_MODE_BLEND = 0,
281 COLOR_MODE_MAP
282 };
283 void SetColorMode(int val);
284 vtkGetMacro(ColorMode, int);
286
288
297 void SetLICIntensity(double val);
298 vtkGetMacro(LICIntensity, double);
300
302
309 void SetMapModeBias(double val);
310 vtkGetMacro(MapModeBias, double);
312
314
322
324
343 void SetGenerateNoiseTexture(int shouldGenerate);
344 vtkGetMacro(GenerateNoiseTexture, int);
346
348
353 enum
354 {
355 NOISE_TYPE_UNIFORM = 0,
356 NOISE_TYPE_GAUSSIAN = 1,
357 NOISE_TYPE_PERLIN = 2
358 };
359 void SetNoiseType(int type);
360 vtkGetMacro(NoiseType, int);
362
364
368 void SetNoiseTextureSize(int length);
369 vtkGetMacro(NoiseTextureSize, int);
371
373
376 void SetNoiseGrainSize(int val);
377 vtkGetMacro(NoiseGrainSize, int);
379
381
387 void SetMinNoiseValue(double val);
388 void SetMaxNoiseValue(double val);
389 vtkGetMacro(MinNoiseValue, double);
390 vtkGetMacro(MaxNoiseValue, double);
392
394
399 vtkGetMacro(NumberOfNoiseLevels, int);
401
403
408 vtkGetMacro(ImpulseNoiseProbability, double);
410
412
416 vtkGetMacro(ImpulseNoiseBackgroundValue, double);
418
420
424 vtkGetMacro(NoiseGeneratorSeed, int);
426
428
431 enum
432 {
433 COMPOSITE_INPLACE = 0,
434 COMPOSITE_INPLACE_DISJOINT = 1,
435 COMPOSITE_BALANCED = 2,
436 COMPOSITE_AUTO = 3
437 };
438 void SetCompositeStrategy(int val);
439 vtkGetMacro(CompositeStrategy, int);
441
446 static bool IsSupported(vtkRenderWindow* context);
447
454 virtual void WriteTimerLog(const char*) {}
455
460
467
472
477
485
491
493
498 void UpdateCommunicator(vtkRenderer* renderer, vtkActor* actor, vtkDataObject* data);
499
501
504 void SetHasVectors(bool val);
507
512
516 void ApplyLIC();
519
525 virtual void GetGlobalMinMax(vtkPainterCommunicator*, float&, float&) {}
526
528
531 vtkSetMacro(Enable, int);
532 vtkGetMacro(Enable, int);
533 vtkBooleanMacro(Enable, int);
535
536protected:
539
544
546
556
558
559 // Unit is a pixel length.
561 double StepSize;
563
571
575 double MaskColor[3];
576
580
591
594
596
597private:
599 void operator=(const vtkSurfaceLICInterface&) = delete;
600};
601
602#endif
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:155
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:159
general representation of visualization data
topologically and geometrically regular array of data
Definition: vtkImageData.h:157
a simple class to control print indentation
Definition: vtkIndent.h:113
abstract base class for most VTK objects
Definition: vtkObject.h:82
A communicator that can safely be used inside a painter.
create a window for renderers to draw into
abstract specification for renderers
Definition: vtkRenderer.h:182
A small collection of noise routines for LIC.
public API for surface lic parameters arbitrary geometry.
void SetNormalizeVectors(int val)
Normalize vectors during integration.
virtual void GetGlobalMinMax(vtkPainterCommunicator *, float &, float &)
Get the min/max across all ranks.
void SetCompositeStrategy(int val)
Control the screen space decomposition where LIC is computed.
void SetNoiseTextureSize(int length)
Set/Get the side length in pixels of the noise texture.
void SetHasVectors(bool val)
Does the data have vectors which we require.
void SetNoiseGeneratorSeed(int val)
Set/Get the seed value used by the random number generator.
void InitializeResources()
resoucre allocators
void SetAntiAlias(int val)
Enable/Disable the anti-aliasing pass.
virtual bool NeedToUpdateCommunicator()
Return false if stage can be skipped.
void SetImpulseNoiseBackgroundValue(double val)
The color to use for untouched pixels when impulse noise probability < 1.
vtkImageData * GetNoiseDataSet()
Set the data containing a noise array as active scalars.
void UpdateCommunicator(vtkRenderer *renderer, vtkActor *actor, vtkDataObject *data)
Called from a mapper, does what is needed to make sure the communicators are ready.
vtkSurfaceLICHelper * Internals
void SetMapModeBias(double val)
Factor used when blend mode is set to COLOR_MODE_MAP.
bool NeedToComputeLIC()
Return false if stage can be skipped.
void SetLICIntensity(double val)
Factor used when blend mode is set to COLOR_MODE_BLEND.
void SetNumberOfSteps(int val)
Get/Set the number of integration steps in each direction.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
bool NeedToColorLIC()
Return false if stage can be skipped.
void SetLowColorContrastEnhancementFactor(double val)
This feature is used to fine tune the contrast enhancement.
~vtkSurfaceLICInterface() override
void ShallowCopy(vtkSurfaceLICInterface *m)
Make a shallow copy of this interface.
void SetMaxNoiseValue(double val)
Set/Get the minimum and mximum gray scale values that the generated noise can take on.
virtual vtkPainterCommunicator * CreateCommunicator(int)
Creates a new communicator with/without the calling processes as indicated by the passed in flag,...
void SetNoiseGrainSize(int val)
Each noise value will be length^2 pixels in area.
bool GetHasVectors()
Does the data have vectors which we require.
void SetUpdateAll()
Return false if stage can be skipped.
static bool IsSupported(vtkRenderWindow *context)
Returns true if the rendering context supports extensions needed by this painter.
void SetImpulseNoiseProbability(double val)
Control the density of the noise.
bool NeedToRenderGeometry(vtkRenderer *renderer, vtkActor *actor)
Return false if stage can be skipped.
bool NeedToGatherVectors()
Return false if stage can be skipped.
void SetMaskColor(double r, double g, double b)
The MaskColor is used on masked fragments.
static vtkSurfaceLICInterface * New()
void SetEnhancedLIC(int val)
EnhancedLIC mean compute the LIC twice with the second pass using the edge-enhanced result of the fir...
void SetHighColorContrastEnhancementFactor(double val)
This feature is used to fine tune the contrast enhancement.
vtkPainterCommunicator * GetCommunicator()
void SetColorMode(int val)
Set/Get the color mode.
virtual void ReleaseGraphicsResources(vtkWindow *win)
Release any graphics resources that are being consumed by this mapper.
void SetStepSize(double val)
Get/Set the step size (in pixels).
bool CanRenderSurfaceLIC(vtkActor *actor)
Returns true when rendering LIC is possible.
void SetNoiseType(int type)
Select the statistical distribution of randomly generated noise values.
void SetHighLICContrastEnhancementFactor(double val)
This feature is used to fine tune the contrast enhancement.
void SetEnhanceContrast(int val)
Enable/Disable contrast and dynamic range correction stages.
void SetNoiseDataSet(vtkImageData *data)
Set the data containing a noise array as active scalars.
void SetLowLICContrastEnhancementFactor(double val)
This feature is used to fine tune the contrast enhancement.
void SetNumberOfNoiseLevels(int val)
Set/Get the number of discrete values a noise pixel may take on.
void ValidateContext(vtkRenderer *renderer)
Look for changes that would trigger stage updates.
void SetMinNoiseValue(double val)
Set/Get the minimum and mximum gray scale values that the generated noise can take on.
virtual void WriteTimerLog(const char *)
Methods used for parallel benchmarks.
void SetMaskColor(double *val)
The MaskColor is used on masked fragments.
void SetMaskIntensity(double val)
The MaskIntensity controls the blending of the mask color and the geometry color.
void SetGenerateNoiseTexture(int shouldGenerate)
Set/Get the noise texture source.
void SetMaskThreshold(double val)
The MaskThreshold controls the rendering of fragments in stagnant regions of flow.
void CreateCommunicator(vtkRenderer *, vtkActor *, vtkDataObject *data)
Creates a new communicator for internal use based on this rank's visible data.
void UpdateNoiseImage(vtkRenderWindow *renWin)
Updates the noise texture, downsampling by the requested sample rate.
void SetMaskOnSurface(int val)
When set MaskOnSurface computes |V| for use in the fragment masking tests on the surface.
window superclass for vtkRenderWindow
Definition: vtkWindow.h:39