vtkLineIntegralConvolution2D.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkLineIntegralConvolution2D.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm 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.
 
=========================================================================*/
#ifndef vtkLineIntegralConvolution2D_h
#define vtkLineIntegralConvolution2D_h
 
#include "vtkObject.h"
#include "vtkRenderingLICOpenGL2Module.h" // for export macro
#include "vtkWeakPointer.h"               // for ren context
#include <deque>                          // for deque
 
class vtkOpenGLFramebufferObject;
class vtkOpenGLHelper;
class vtkOpenGLRenderWindow;
class vtkPainterCommunicator;
class vtkPixelExtent;
class vtkRenderWindow;
class vtkShaderProgram;
class vtkTextureObject;
 
class VTKRENDERINGLICOPENGL2_EXPORT vtkLineIntegralConvolution2D : public vtkObject
{
public:
  static vtkLineIntegralConvolution2D* New();
  vtkTypeMacro(vtkLineIntegralConvolution2D, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static bool IsSupported(vtkRenderWindow* renWin);
 
 
  void SetContext(vtkOpenGLRenderWindow* context);
  vtkOpenGLRenderWindow* GetContext();
 
 
  vtkSetClampMacro(EnhancedLIC, int, 0, 1);
  vtkGetMacro(EnhancedLIC, int);
  vtkBooleanMacro(EnhancedLIC, int);
 
 
  enum
  {
    ENHANCE_CONTRAST_OFF = 0,
    ENHANCE_CONTRAST_ON = 1
  };
  vtkSetClampMacro(EnhanceContrast, int, 0, 2);
  vtkGetMacro(EnhanceContrast, int);
  vtkBooleanMacro(EnhanceContrast, int);
 
 
  vtkSetClampMacro(LowContrastEnhancementFactor, double, 0.0, 1.0);
  vtkGetMacro(LowContrastEnhancementFactor, double);
  vtkSetClampMacro(HighContrastEnhancementFactor, double, 0.0, 1.0);
  vtkGetMacro(HighContrastEnhancementFactor, double);
 
 
  vtkSetClampMacro(AntiAlias, int, 0, VTK_INT_MAX);
  vtkGetMacro(AntiAlias, int);
  vtkBooleanMacro(AntiAlias, int);
 
 
  vtkSetClampMacro(NumberOfSteps, int, 0, VTK_INT_MAX);
  vtkGetMacro(NumberOfSteps, int);
 
 
  vtkSetClampMacro(StepSize, double, 0.0, VTK_FLOAT_MAX);
  vtkGetMacro(StepSize, double);
 
 
  void SetComponentIds(int c0, int c1);
  void SetComponentIds(int c[2]) { this->SetComponentIds(c[0], c[1]); }
  vtkGetVector2Macro(ComponentIds, int);
 
 
  vtkSetClampMacro(MaxNoiseValue, double, 0.0, 1.0);
  vtkGetMacro(MaxNoiseValue, double);
 
 
  void SetTransformVectors(int val);
  vtkGetMacro(TransformVectors, int);
 
 
  void SetNormalizeVectors(int val);
  vtkGetMacro(NormalizeVectors, int);
 
 
  vtkSetClampMacro(MaskThreshold, double, -1.0, VTK_FLOAT_MAX);
  vtkGetMacro(MaskThreshold, double);
 
  vtkTextureObject* Execute(vtkTextureObject* vectorTex, vtkTextureObject* noiseTex);
 
  vtkTextureObject* Execute(
    const int extent[4], vtkTextureObject* vectorTex, vtkTextureObject* noiseTex);
 
  vtkTextureObject* Execute(const vtkPixelExtent& inputTexExtent,
    const std::deque<vtkPixelExtent>& vectorExtent, const std::deque<vtkPixelExtent>& licExtent,
    vtkTextureObject* vectorTex, vtkTextureObject* maskVectorTex, vtkTextureObject* noiseTex);
 
  static void SetVectorTexParameters(vtkTextureObject* vectors);
 
  static void SetNoiseTexParameters(vtkTextureObject* noise);
 
  virtual void SetCommunicator(vtkPainterCommunicator*) {}
  virtual vtkPainterCommunicator* GetCommunicator();
 
  virtual void GetGlobalMinMax(vtkPainterCommunicator*, float&, float&) {}
 
  virtual void WriteTimerLog(const char*) {}
 
protected:
  vtkLineIntegralConvolution2D();
  ~vtkLineIntegralConvolution2D() override;
 
  vtkPainterCommunicator* Comm;
 
  void SetVTShader(vtkShaderProgram* prog);
  void SetLIC0Shader(vtkShaderProgram* prog);
  void SetLICIShader(vtkShaderProgram* prog);
  void SetLICNShader(vtkShaderProgram* prog);
  void SetEEShader(vtkShaderProgram* prog);
  void SetCEShader(vtkShaderProgram* prog);
  void SetAAHShader(vtkShaderProgram* prog);
  void SetAAVShader(vtkShaderProgram* prog);
 
  void BuildShaders();
 
  void RenderQuad(float computeBounds[4], vtkPixelExtent computeExtent);
 
  vtkTextureObject* AllocateBuffer(unsigned int texSize[2]);
 
  void SetNoise2TexParameters(vtkTextureObject* noise);
 
  virtual void StartTimerEvent(const char*) {}
  virtual void EndTimerEvent(const char*) {}
 
protected:
  vtkWeakPointer<vtkOpenGLRenderWindow> Context;
  vtkOpenGLFramebufferObject* FBO;
 
  int ShadersNeedBuild;
  vtkOpenGLHelper* FinalBlendProgram;
  vtkOpenGLHelper* IntermediateBlendProgram;
  vtkOpenGLHelper* VTShader;
  vtkOpenGLHelper* LIC0Shader;
  vtkOpenGLHelper* LICIShader;
  vtkOpenGLHelper* LICNShader;
  vtkOpenGLHelper* EEShader;
  vtkOpenGLHelper* CEShader;
  vtkOpenGLHelper* AAHShader;
  vtkOpenGLHelper* AAVShader;
 
  int NumberOfSteps;
  double StepSize;
  int EnhancedLIC;
  int EnhanceContrast;
  double LowContrastEnhancementFactor;
  double HighContrastEnhancementFactor;
  int AntiAlias;
  int NoiseTextureLookupCompatibilityMode;
  double MaskThreshold;
  int TransformVectors;
  int NormalizeVectors;
  int ComponentIds[2];
  double MaxNoiseValue;
 
private:
  vtkLineIntegralConvolution2D(const vtkLineIntegralConvolution2D&) = delete;
  void operator=(const vtkLineIntegralConvolution2D&) = delete;
};
 
#endif