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 "vtkRenderingLICModule.h" // for export macro
#include <deque> // for deque
 
class vtkRenderWindow;
class vtkTextureObject;
class vtkPixelExtent;
class vtkShaderProgram2;
class vtkFrameBufferObject2;
class vtkPainterCommunicator;
 
class VTKRENDERINGLIC_EXPORT vtkLineIntegralConvolution2D : public vtkObject
{
public:
  static vtkLineIntegralConvolution2D *New();
  vtkTypeMacro(vtkLineIntegralConvolution2D, vtkObject);
  void PrintSelf(ostream & os, vtkIndent indent);
 
  static bool IsSupported(vtkRenderWindow * renWin);
 
 
  void SetContext(vtkRenderWindow *context);
  vtkRenderWindow *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();
 
  void SetVTShader(vtkShaderProgram2 *prog);
  void SetLIC0Shader(vtkShaderProgram2 *prog);
  void SetLICIShader(vtkShaderProgram2 *prog);
  void SetLICNShader(vtkShaderProgram2 *prog);
  void SetEEShader(vtkShaderProgram2 *prog);
  void SetCEShader(vtkShaderProgram2 *prog);
  void SetAAHShader(vtkShaderProgram2 *prog);
  void SetAAVShader(vtkShaderProgram2 *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:
  vtkPainterCommunicator *Comm;
 
  vtkWeakPointer<vtkRenderWindow> Context;
  vtkFrameBufferObject2 *FBO;
 
  int ShadersNeedBuild;
  vtkShaderProgram2 *VTShader;
  vtkShaderProgram2 *LIC0Shader;
  vtkShaderProgram2 *LICIShader;
  vtkShaderProgram2 *LICNShader;
  vtkShaderProgram2 *EEShader;
  vtkShaderProgram2 *CEShader;
  vtkShaderProgram2 *AAHShader;
  vtkShaderProgram2 *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