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 
62 class vtkRenderWindow;
63 class vtkRenderer;
64 class vtkActor;
65 class vtkImageData;
66 class vtkDataObject;
67 class vtkDataArray;
70 class vtkWindow;
71 
72 class VTKRENDERINGLICOPENGL2_EXPORT vtkSurfaceLICInterface : public vtkObject
73 {
74 public:
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 
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 
398  void SetNumberOfNoiseLevels(int val);
399  vtkGetMacro(NumberOfNoiseLevels, int);
401 
403 
407  void SetImpulseNoiseProbability(double val);
408  vtkGetMacro(ImpulseNoiseProbability, double);
410 
412 
416  vtkGetMacro(ImpulseNoiseBackgroundValue, double);
418 
420 
423  void SetNoiseGeneratorSeed(int val);
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 
476  void ValidateContext(vtkRenderer* renderer);
477 
485 
491 
493 
499 
501 
504  void SetHasVectors(bool val);
507 
512 
516  void ApplyLIC();
518  void CopyToScreen();
519 
525  virtual void GetGlobalMinMax(vtkPainterCommunicator*, float&, float&) {}
526 
528 
531  vtkSetMacro(Enable, int);
532  vtkGetMacro(Enable, int);
533  vtkBooleanMacro(Enable, int);
535 
536 protected:
539 
544 
546 
549  virtual bool NeedToUpdateCommunicator();
550  bool NeedToRenderGeometry(vtkRenderer* renderer, vtkActor* actor);
554  void SetUpdateAll();
556 
557  int Enable;
558 
559  // Unit is a pixel length.
561  double StepSize;
563 
571 
575  double MaskColor[3];
576 
578  double LICIntensity;
579  double MapModeBias;
580 
591 
594 
596 
597 private:
599  void operator=(const vtkSurfaceLICInterface&) = delete;
600 };
601 
602 #endif
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:46
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
general representation of visualization data
Definition: vtkDataObject.h:60
topologically and geometrically regular array of data
Definition: vtkImageData.h:48
a simple class to control print indentation
Definition: vtkIndent.h:34
abstract base class for most VTK objects
Definition: vtkObject.h:63
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:73
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.
static vtkSurfaceLICInterface * New()
vtkImageData * GetNoiseDataSet()
Set the data containing a noise array as active scalars.
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.
void UpdateCommunicator(vtkRenderer *renderer, vtkActor *actor, vtkDataObject *data)
Called from a mapper, does what is needed to make sure the communicators are ready.
virtual vtkPainterCommunicator * CreateCommunicator(int)
Creates a new communicator with/without the calling processes as indicated by the passed in flag,...
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.
vtkPainterCommunicator * GetCommunicator()
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.
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.
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.
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
@ length
Definition: vtkX3D.h:399
@ type
Definition: vtkX3D.h:522
@ data
Definition: vtkX3D.h:321