vtkPointGaussianRepresentation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkPointGaussianRepresentation_h
#define vtkPointGaussianRepresentation_h
 
#include "vtkPVDataRepresentation.h"
#include "vtkRemotingViewsModule.h" // needed for exports
#include "vtkSmartPointer.h"        // needed for smart pointer
#include <string>                   // for std::string
#include <vector>                   // for std::vector
 
class vtkActor;
class vtkDataObject;
class vtkPiecewiseFunction;
class vtkPointGaussianMapper;
class vtkScalarsToColors;
 
class VTKREMOTINGVIEWS_EXPORT vtkPointGaussianRepresentation : public vtkPVDataRepresentation
{
public:
  vtkTypeMacro(vtkPointGaussianRepresentation, vtkPVDataRepresentation);
  static vtkPointGaussianRepresentation* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  int ProcessViewRequest(vtkInformationRequestKey* request_type, vtkInformation* inInfo,
    vtkInformation* outInfo) override;
 
  void SetLookupTable(vtkScalarsToColors* lut);
 
  void SetVisibility(bool val) override;
 
  virtual void SetEmissive(bool val);
 
  virtual void SetMapScalars(int val);
 
  //***************************************************************************
  // Forwarded to Actor.
  virtual void SetOrientation(double, double, double);
  virtual void SetOrigin(double, double, double);
  virtual void SetPickable(int val);
  virtual void SetPosition(double, double, double);
  virtual void SetScale(double, double, double);
 
  //***************************************************************************
  // Forwarded to Actor->GetProperty()
  virtual void SetAmbientColor(double r, double g, double b);
  virtual void SetDiffuseColor(double r, double g, double b);
  virtual void SetEdgeColor(double r, double g, double b);
  virtual void SetInterpolation(int val);
  virtual void SetLineWidth(double val);
  virtual void SetOpacity(double val);
  virtual void SetPointSize(double val);
  virtual void SetSpecularColor(double r, double g, double b);
  virtual void SetSpecularPower(double val);
 
  virtual void SetSplatSize(double radius);
 
  enum ShaderPresets
  {
    GAUSSIAN_BLUR, // This is the default
    SPHERE,        // Points shaded to look (something) like a sphere lit from the view direction
    BLACK_EDGED_CIRCLE, // Camera facing, flat circle, rimmed in black
    PLAIN_CIRCLE,       // Same as above, but without the black edge
    TRIANGLE,           // Camera facing, flat triangle
    SQUARE_OUTLINE,     // Camera facing, flat square, with empty center
    CUSTOM,             // Custom shader
    NUMBER_OF_PRESETS   // !!! THIS MUST ALWAYS BE THE LAST PRESET ENUM !!!
  };
 
  void SelectShaderPreset(int preset);
 
  void SetCustomShader(const char* shaderString);
 
  void SetCustomTriangleScale(double scale);
 
  void SelectScaleArray(int, int, int, int, const char* name);
 
  void SelectScaleArrayComponent(int component);
 
  void SetUseScaleFunction(bool enable);
 
  void SetScaleTransferFunction(vtkPiecewiseFunction* pwf);
 
  void SetOpacityTransferFunction(vtkPiecewiseFunction* pwf);
 
  void SelectOpacityArray(int, int, int, int, const char* name);
 
  void SelectOpacityArrayComponent(int component);
 
 
  void SetOpacityByArray(bool newVal);
  vtkGetMacro(OpacityByArray, bool);
  vtkBooleanMacro(OpacityByArray, bool);
 
 
  void SetScaleByArray(bool newVal);
  vtkGetMacro(ScaleByArray, bool);
  vtkBooleanMacro(ScaleByArray, bool);
 
protected:
  vtkPointGaussianRepresentation();
  ~vtkPointGaussianRepresentation() override;
 
  bool AddToView(vtkView* view) override;
  bool RemoveFromView(vtkView* view) override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  void UpdateColoringParameters();
  vtkSetStringMacro(LastScaleArray);
  vtkSetStringMacro(LastOpacityArray);
  void InitializeShaderPresets();
  void UpdateMapperScaleFunction();
 
  vtkSmartPointer<vtkActor> Actor;
  vtkSmartPointer<vtkPointGaussianMapper> Mapper;
  vtkSmartPointer<vtkDataObject> ProcessedData;
  vtkSmartPointer<vtkPiecewiseFunction> ScaleFunction;
 
  int SelectedPreset;
 
  bool ScaleByArray;
  char* LastScaleArray;
  int LastScaleArrayComponent;
 
  bool OpacityByArray;
  char* LastOpacityArray;
  int LastOpacityArrayComponent;
 
  bool UseScaleFunction;
 
  std::vector<std::string> PresetShaderStrings;
  std::vector<float> PresetShaderScales;
 
private:
  vtkPointGaussianRepresentation(const vtkPointGaussianRepresentation&) = delete;
  void operator=(const vtkPointGaussianRepresentation&) = delete;
};
 
#endif // vtkPointGaussianRepresentation_h