vtkSurfaceLICInterface.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkSurfaceLICMapper.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 vtkSurfaceLICInterface_h
#define vtkSurfaceLICInterface_h

#include "vtkRenderingLICOpenGL2Module.h" // For export macro
#include "vtkOpenGLPolyDataMapper.h"

class vtkRenderWindow;
class vtkRenderer;
class vtkActor;
class vtkImageData;
class vtkDataObject;
class vtkDataArray;
class vtkPainterCommunicator;
class vtkSurfaceLICHelper;

class VTKRENDERINGLICOPENGL2_EXPORT vtkSurfaceLICInterface : public vtkObject
{
public:
  static vtkSurfaceLICInterface* New();
  vtkTypeMacro(vtkSurfaceLICInterface, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);


  void SetNumberOfSteps(int val);
  vtkGetMacro(NumberOfSteps, int);


  void SetStepSize(double val);
  vtkGetMacro(StepSize, double);


  void SetNormalizeVectors(int val);
  vtkBooleanMacro(NormalizeVectors, int);
  vtkGetMacro(NormalizeVectors, int);


  void SetMaskOnSurface(int val);
  vtkBooleanMacro(MaskOnSurface, int);
  vtkGetMacro(MaskOnSurface, int);


  void SetMaskThreshold(double val);
  vtkGetMacro(MaskThreshold, double);


  void SetMaskColor(double *val);
  void SetMaskColor(double r, double g, double b)
    { double rgb[3]={r,g,b}; this->SetMaskColor(rgb); }
  vtkGetVector3Macro(MaskColor, double);


  void SetMaskIntensity(double val);
  vtkGetMacro(MaskIntensity, double);


  void SetEnhancedLIC(int val);
  vtkGetMacro(EnhancedLIC, int);
  vtkBooleanMacro(EnhancedLIC, int);


  enum {
    ENHANCE_CONTRAST_OFF=0,
    ENHANCE_CONTRAST_LIC=1,
    ENHANCE_CONTRAST_COLOR=3,
    ENHANCE_CONTRAST_BOTH=4
  };
  void SetEnhanceContrast(int val);
  vtkGetMacro(EnhanceContrast, int);


  vtkGetMacro(LowLICContrastEnhancementFactor, double);
  vtkGetMacro(HighLICContrastEnhancementFactor, double);
  void SetLowLICContrastEnhancementFactor(double val);
  void SetHighLICContrastEnhancementFactor(double val);
  //
  vtkGetMacro(LowColorContrastEnhancementFactor, double);
  vtkGetMacro(HighColorContrastEnhancementFactor, double);
  void SetLowColorContrastEnhancementFactor(double val);
  void SetHighColorContrastEnhancementFactor(double val);


  void SetAntiAlias(int val);
  vtkBooleanMacro(AntiAlias, int);
  vtkGetMacro(AntiAlias, int);


  enum {
    COLOR_MODE_BLEND=0,
    COLOR_MODE_MAP
  };
  void SetColorMode(int val);
  vtkGetMacro(ColorMode, int);


  void SetLICIntensity(double val);
  vtkGetMacro(LICIntensity, double);


  void SetMapModeBias(double val);
  vtkGetMacro(MapModeBias, double);


  void SetNoiseDataSet(vtkImageData *data);
  vtkImageData *GetNoiseDataSet();


  void SetGenerateNoiseTexture(int shouldGenerate);
  vtkGetMacro(GenerateNoiseTexture, int);


  enum {
    NOISE_TYPE_UNIFORM=0,
    NOISE_TYPE_GAUSSIAN=1,
    NOISE_TYPE_PERLIN=2
  };
  void SetNoiseType(int type);
  vtkGetMacro(NoiseType, int);


  void SetNoiseTextureSize(int length);
  vtkGetMacro(NoiseTextureSize, int);


  void SetNoiseGrainSize(int val);
  vtkGetMacro(NoiseGrainSize, int);


  void SetMinNoiseValue(double val);
  void SetMaxNoiseValue(double val);
  vtkGetMacro(MinNoiseValue, double);
  vtkGetMacro(MaxNoiseValue, double);


  void SetNumberOfNoiseLevels(int val);
  vtkGetMacro(NumberOfNoiseLevels, int);


  void SetImpulseNoiseProbability(double val);
  vtkGetMacro(ImpulseNoiseProbability, double);


  void SetImpulseNoiseBackgroundValue(double val);
  vtkGetMacro(ImpulseNoiseBackgroundValue, double);


  void SetNoiseGeneratorSeed(int val);
  vtkGetMacro(NoiseGeneratorSeed, int);


  enum {
    COMPOSITE_INPLACE=0,
    COMPOSITE_INPLACE_DISJOINT=1,
    COMPOSITE_BALANCED=2,
    COMPOSITE_AUTO=3
  };
  void SetCompositeStrategy(int val);
  vtkGetMacro(CompositeStrategy, int);

  static bool IsSupported(vtkRenderWindow *context);

  virtual void WriteTimerLog(const char *){}

  void ShallowCopy(vtkSurfaceLICInterface *m);

  virtual void ReleaseGraphicsResources(vtkWindow * win);

  bool CanRenderSurfaceLIC(vtkActor *actor);

  void ValidateContext(vtkRenderer *renderer);

  virtual vtkPainterCommunicator *CreateCommunicator(int);

  void CreateCommunicator(vtkRenderer *, vtkActor *, vtkDataObject *data);

  vtkPainterCommunicator *GetCommunicator();

  void UpdateCommunicator(vtkRenderer *renderer,
    vtkActor *actor, vtkDataObject *data);


  void SetHasVectors(bool val);
  bool GetHasVectors();

  void InitializeResources();

  void PrepareForGeometry();
  void CompletedGeometry();
  void GatherVectors();
  void ApplyLIC();
  void CombineColorsAndLIC();
  void CopyToScreen();

  virtual void GetGlobalMinMax(vtkPainterCommunicator*, float&, float&){}


  vtkSetMacro(Enable, int);
  vtkGetMacro(Enable, int);
  vtkBooleanMacro(Enable, int);

protected:
  vtkSurfaceLICInterface();
  ~vtkSurfaceLICInterface();

  void UpdateNoiseImage(vtkRenderWindow *renWin);


  virtual bool NeedToUpdateCommunicator();
  bool NeedToRenderGeometry(vtkRenderer *renderer, vtkActor *actor);
  bool NeedToGatherVectors();
  bool NeedToComputeLIC();
  bool NeedToColorLIC();
  void SetUpdateAll();

  int Enable;

  // Unit is a pixel length.
  int     NumberOfSteps;
  double  StepSize;
  int     NormalizeVectors;

  int     EnhancedLIC;
  int     EnhanceContrast;
  double  LowLICContrastEnhancementFactor;
  double  HighLICContrastEnhancementFactor;
  double  LowColorContrastEnhancementFactor;
  double  HighColorContrastEnhancementFactor;
  int     AntiAlias;

  int     MaskOnSurface;
  double  MaskThreshold;
  double  MaskIntensity;
  double  MaskColor[3];

  int     ColorMode;
  double  LICIntensity;
  double  MapModeBias;

  int     GenerateNoiseTexture;
  int     NoiseType;
  int     NoiseTextureSize;
  int     NoiseGrainSize;
  double  MinNoiseValue;
  double  MaxNoiseValue;
  int     NumberOfNoiseLevels;
  double  ImpulseNoiseProbability;
  double  ImpulseNoiseBackgroundValue;
  int     NoiseGeneratorSeed;

  int     AlwaysUpdate;
  int     CompositeStrategy;

  vtkSurfaceLICHelper* Internals;

  // save the active fbo and its draw buffer
  int PrevDrawBuf;
  int PrevFbo;

private:
  vtkSurfaceLICInterface(const vtkSurfaceLICInterface&) VTK_DELETE_FUNCTION;
  void operator=(const vtkSurfaceLICInterface&) VTK_DELETE_FUNCTION;
};

#endif
// VTK-HeaderTest-Exclude: vtkSurfaceLICInterface.h