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 "vtkOpenGLPolyDataMapper.h"
#include "vtkRenderingLICOpenGL2Module.h" // For export macro
 
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) override;
 
 
  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() override;
 
  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;
 
private:
  vtkSurfaceLICInterface(const vtkSurfaceLICInterface&) = delete;
  void operator=(const vtkSurfaceLICInterface&) = delete;
};
 
#endif
// VTK-HeaderTest-Exclude: vtkSurfaceLICInterface.h