vtkSurfaceLICPainter.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkSurfaceLICPainter.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 vtkSurfaceLICPainter_h
#define vtkSurfaceLICPainter_h
 
#include "vtkRenderingLICModule.h" // For export macro
#include "vtkPainter.h"
 
class vtkRenderWindow;
class vtkRenderer;
class vtkActor;
class vtkImageData;
class vtkDataObject;
class vtkDataArray;
class vtkPainterCommunicator;
 
class VTKRENDERINGLIC_EXPORT vtkSurfaceLICPainter : public vtkPainter
{
public:
  static vtkSurfaceLICPainter* New();
  vtkTypeMacro(vtkSurfaceLICPainter, vtkPainter);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  virtual void ReleaseGraphicsResources(vtkWindow * win);
 
  virtual vtkDataObject* GetOutput();
 
 
  void SetEnable(int val);
  vtkGetMacro(Enable, int);
  void SetEnableOn(){ this->SetEnable(1); }
  void SetEnableOff(){ this->SetEnable(0); }
 
 
  void SetInputArrayToProcess(int fieldAssociation, const char *name);
  void SetInputArrayToProcess(int fieldAssociation, int fieldAttributeType);
 
 
  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 *){}
 
protected:
  vtkSurfaceLICPainter();
  ~vtkSurfaceLICPainter();
 
  virtual void ProcessInformation(vtkInformation* info);
 
  virtual void GetGlobalMinMax(vtkPainterCommunicator*, float&, float&){}
 
 
  virtual void StartTimerEvent(const char *){}
  virtual void EndTimerEvent(const char *){}
 
  virtual vtkPainterCommunicator *CreateCommunicator(int);
 
  void CreateCommunicator();
 
  void GetBounds(vtkDataObject* data, double bounds[6]);
 
  virtual void ReportReferences(vtkGarbageCollector *collector);
 
  void UpdateNoiseImage(vtkRenderWindow *renWin);
 
 
  virtual void RenderInternal(
        vtkRenderer* renderer,
        vtkActor* actor,
        unsigned long typeflags,
        bool forceCompileOnly);
 
 
  void ValidateContext(vtkRenderer *renderer);
 
 
  bool NeedToUpdateOutputData();
  virtual bool NeedToUpdateCommunicator();
  bool NeedToRenderGeometry(vtkRenderer *renderer, vtkActor *actor);
  bool NeedToGatherVectors();
  bool NeedToComputeLIC();
  bool NeedToColorLIC();
  void SetUpdateAll();
 
 
  bool PrepareOutput();
  void InitializeResources();
 
 
  bool VectorsToTCoords(vtkDataObject *dataObj);
  bool VectorsToTCoords(vtkDataSet *dataObj);
  void ClearTCoords(vtkDataSet *data);
 
  bool CanRenderSurfaceLIC(vtkActor *actor, int typeflags);
 
protected:
  // 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     Enable;
  int     CompositeStrategy;
 
  vtkDataObject* Output;
  class vtkInternals;
  vtkInternals* Internals;
 
private:
  vtkSurfaceLICPainter(const vtkSurfaceLICPainter&); // Not implemented.
  void operator=(const vtkSurfaceLICPainter&); // Not implemented.
};
 
#endif