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 "vtkWeakPointer.h" // for ren context
#include "vtkRenderingLICOpenGL2Module.h" // for export macro
#include <deque> // for deque
 
class vtkFrameBufferObject2;
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);
 
  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);
 
  //BTX
 
  vtkTextureObject *Execute(
        const vtkPixelExtent &inputTexExtent,
        const std::deque<vtkPixelExtent> &vectorExtent,
        const std::deque<vtkPixelExtent> &licExtent,
        vtkTextureObject *vectorTex,
        vtkTextureObject *maskVectorTex,
        vtkTextureObject *noiseTex);
  //ETX
 
 
  static
  void SetVectorTexParameters(vtkTextureObject *vectors);
 
  static
  void SetNoiseTexParameters(vtkTextureObject *noise);
 
  //BTX
 
  virtual void SetCommunicator(vtkPainterCommunicator *){}
  virtual vtkPainterCommunicator *GetCommunicator();
 
 
 virtual void GetGlobalMinMax(
       vtkPainterCommunicator*,
       float&,
       float&) {}
  //ETX
 
  virtual void WriteTimerLog(const char *){}
 
protected:
  vtkLineIntegralConvolution2D();
  virtual ~vtkLineIntegralConvolution2D();
 
  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;
  vtkFrameBufferObject2 *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 &); // Not implemented.
  void operator = (const vtkLineIntegralConvolution2D &);             // Not implemented.
};
 
#endif