vtkGeometryRepresentation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkGeometryRepresentation_h
#define vtkGeometryRepresentation_h

#include "vtkPVDataRepresentation.h"
#include "vtkParaViewDeprecation.h" // for PV_DEPRECATED
#include "vtkProperty.h"            // needed for VTK_POINTS etc.
#include "vtkRemotingViewsModule.h" // needed for exports
#include "vtkVector.h"              // for vtkVector.

#include <set>           // needed for std::set
#include <string>        // needed for std::string
#include <unordered_map> // needed for std::unordered_map
#include <vector>        // needed for std::vector

class vtkCompositeDataDisplayAttributes;
class vtkMapper;
class vtkPiecewiseFunction;
class vtkPVGeometryFilter;
class vtkPVLODActor;
class vtkScalarsToColors;
class vtkTexture;
class vtkTransform;

namespace vtkGeometryRepresentation_detail
{
// This is defined to either vtkQuadricClustering or vtkmLevelOfDetail in the
// implementation file:
class DecimationFilterType;
}

class VTKREMOTINGVIEWS_EXPORT vtkGeometryRepresentation : public vtkPVDataRepresentation
{

public:
  static vtkGeometryRepresentation* New();
  vtkTypeMacro(vtkGeometryRepresentation, vtkPVDataRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  int ProcessViewRequest(vtkInformationRequestKey* request_type, vtkInformation* inInfo,
    vtkInformation* outInfo) override;

  void SetVisibility(bool val) override;


  void SetBlockColorsDistinctValues(int distinctValues);
  int GetBlockColorsDistinctValues();

  virtual void SetSuppressLOD(bool suppress) { this->SuppressLOD = suppress; }


  vtkBooleanMacro(DisableLighting, bool);
  vtkSetMacro(DisableLighting, bool);
  vtkGetMacro(DisableLighting, bool);

  vtkSetMacro(Ambient, double);
  vtkSetMacro(Diffuse, double);
  vtkSetMacro(Specular, double);
  vtkGetMacro(Ambient, double);
  vtkGetMacro(Diffuse, double);
  vtkGetMacro(Specular, double);

  enum RepresentationTypes
  {
    POINTS = VTK_POINTS,
    WIREFRAME = VTK_WIREFRAME,
    SURFACE = VTK_SURFACE,
    SURFACE_WITH_EDGES = 3
  };


  void SetCoordinateShiftScaleMethod(int val);
  int GetCoordinateShiftScaleMethod();


  vtkSetClampMacro(Representation, int, POINTS, SURFACE_WITH_EDGES);
  vtkGetMacro(Representation, int);

  virtual void SetRepresentation(const char*);

  vtkDataObject* GetRenderedDataObject(int port) override;


  vtkSetMacro(RequestGhostCellsIfNeeded, bool);
  vtkGetMacro(RequestGhostCellsIfNeeded, bool);
  vtkBooleanMacro(RequestGhostCellsIfNeeded, bool);

  virtual void SetNormalArray(const char* val);

  virtual void SetTCoordArray(const char* val);

  virtual void SetTangentArray(const char* val);

  //***************************************************************************
  // Forwarded to vtkPVGeometryFilter
  virtual void SetUseOutline(int);
  void SetTriangulate(int);
  void SetNonlinearSubdivisionLevel(int);
  void SetMatchBoundariesIgnoringCellOrder(int);
  virtual void SetGenerateFeatureEdges(bool);
  void SetComputePointNormals(bool);
  void SetSplitting(bool);
  void SetFeatureAngle(double);

  //***************************************************************************
  // Forwarded to vtkProperty.
  virtual void SetAmbientColor(double r, double g, double b);
  virtual void SetColor(double r, double g, double b);
  virtual void SetDiffuseColor(double r, double g, double b);
  virtual void SetLighting(bool lighting);
  virtual void SetEdgeColor(double r, double g, double b);
  virtual void SetInteractiveSelectionColor(double r, double g, double b);
  virtual void SetInterpolation(int val);
  virtual void SetLineWidth(double val);
  virtual void SetOpacity(double val);
  virtual void SetEdgeOpacity(double val);
  virtual void SetPointSize(double val);
  virtual void SetSpecularColor(double r, double g, double b);
  virtual void SetSpecularPower(double val);
  virtual void SetLuminosity(double val);
  virtual void SetRenderPointsAsSpheres(bool);
  virtual void SetRenderLinesAsTubes(bool);
  virtual void SetRoughness(double val);
  virtual void SetMetallic(double val);
  virtual void SetEdgeTint(double r, double g, double b);
  virtual void SetAnisotropy(double val);
  virtual void SetAnisotropyRotation(double val);
  virtual void SetBaseIOR(double val);
  virtual void SetCoatIOR(double val);
  virtual void SetCoatStrength(double val);
  virtual void SetCoatRoughness(double val);
  virtual void SetCoatNormalScale(double val);
  virtual void SetCoatColor(double r, double g, double b);
  virtual void SetBaseColorTexture(vtkTexture* tex);
  virtual void SetMaterialTexture(vtkTexture* tex);
  virtual void SetAnisotropyTexture(vtkTexture* tex);
  virtual void SetNormalTexture(vtkTexture* tex);
  virtual void SetCoatNormalTexture(vtkTexture* tex);
  virtual void SetEmissiveTexture(vtkTexture* tex);
  virtual void SetNormalScale(double val);
  virtual void SetOcclusionStrength(double val);
  virtual void SetEmissiveFactor(double rval, double gval, double bval);
  virtual void SetShowTexturesOnBackface(bool);

  //***************************************************************************
  // 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);
  virtual void SetTexture(vtkTexture*);
  virtual void SetUserTransform(const double[16]);
  PARAVIEW_DEPRECATED_IN_5_13_0("Use SetTextureTransform instead")
  virtual void SetFlipTextures(bool);

  //***************************************************************************
  // Forwarded to all textures
  virtual void SetTextureTransform(vtkTransform*);
  vtkGetObjectMacro(TextureTransform, vtkTransform);
  virtual void SetRepeatTextures(bool);
  vtkGetMacro(RepeatTextures, bool);
  virtual void SetInterpolateTextures(bool);
  vtkGetMacro(InterpolateTextures, bool);
  virtual void SetUseMipmapTextures(bool);
  vtkGetMacro(UseMipmapTextures, bool);

  //***************************************************************************
  // Forwarded to Mapper and LODMapper.
  virtual void SetInterpolateScalarsBeforeMapping(int val);
  virtual void SetLookupTable(vtkScalarsToColors* val);
  virtual void SetColorMissingArraysWithNanColor(bool val);
  virtual void SetSeamlessU(bool);
  virtual void SetSeamlessV(bool);

  virtual void SetMapScalars(int val);
  virtual void SetStatic(int val);

  virtual void SetSelection(vtkSelection* selection);

  vtkPVLODActor* GetActor() { return this->GetRenderedProp(); }


  vtkSetStringMacro(ActiveAssembly);
  vtkGetStringMacro(ActiveAssembly);


  void AddBlockSelector(const char* selector);
  void RemoveAllBlockSelectors();


  void SetBlockColor(const char* selector, double r, double g, double b);
  void RemoveAllBlockColors();


  void SetBlockOpacity(const char* selector, double opacity);
  void RemoveAllBlockOpacities();


  void SetBlockInterpolateScalarsBeforeMapping(const char* selector, bool interpolate);
  void RemoveAllBlockInterpolateScalarsBeforeMappings();


  void SetBlockMapScalars(const char* selector, int val);
  void RemoveAllBlockMapScalars();


  void SetBlockArrayName(const char* selector, int assoc, const char* arrayName);
  void RemoveAllBlockArrayNames();


  void SetBlockLookupTable(vtkScalarsToColors* lut);
  void RemoveAllBlockLookupTables();

  const char* GetColorArrayName();

  static bool GetBounds(
    vtkDataObject* dataObject, double bounds[6], vtkCompositeDataDisplayAttributes* cdAttributes);


  virtual void SetEnableScaling(int v);
  virtual void SetScalingArrayName(const char*);
  virtual void SetScalingFunction(vtkPiecewiseFunction* pwf);

  virtual void SetMaterial(const char*);


  vtkSetMacro(UseDataPartitions, bool);
  vtkGetMacro(UseDataPartitions, bool);


  virtual void SetUseShaderReplacements(bool);
  vtkGetMacro(UseShaderReplacements, bool);

  virtual void SetShaderReplacements(const char*);

  void SetArrayIdNames(const char* pointArray, const char* cellArray) override;


  void SetPlaceHolderDataType(int datatype);
  vtkGetMacro(PlaceHolderDataType, int);

protected:
  vtkGeometryRepresentation();
  ~vtkGeometryRepresentation() override;

  virtual void SetupDefaults();

  int FillInputPortInformation(int port, vtkInformation* info) override;

  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;

  int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  bool AddToView(vtkView* view) override;

  bool RemoveFromView(vtkView* view) override;

  virtual void UpdateColoringParameters();

  virtual vtkPVLODActor* GetRenderedProp() { return this->Actor; }

  // Progress Callback
  void HandleGeometryRepresentationProgress(vtkObject* caller, unsigned long, void*);

  void PopulateBlockAttributes(vtkCompositeDataDisplayAttributes* attrs, vtkDataObject* outputData);

  void ComputeVisibleDataBounds();

  void UpdateShaderReplacements();

  virtual bool NeedsOrderedCompositing();

  virtual void SetPointArrayToProcess(int p, const char* val);

  void UpdateGeneralTextureTransform();

  vtkAlgorithm* GeometryFilter;
  vtkAlgorithm* MultiBlockMaker;
  vtkGeometryRepresentation_detail::DecimationFilterType* Decimator;
  vtkPVGeometryFilter* LODOutlineFilter;

  vtkMapper* Mapper;
  vtkMapper* LODMapper;
  vtkPVLODActor* Actor;
  vtkProperty* Property;

  char* ActiveAssembly = nullptr;
  bool RepeatTextures;
  bool InterpolateTextures;
  bool UseMipmapTextures;
  vtkTransform* TextureTransform;
  double Ambient;
  double Specular;
  double Diffuse;
  int Representation;
  bool SuppressLOD;
  bool RequestGhostCellsIfNeeded;
  double VisibleDataBounds[6];

  vtkTimeStamp VisibleDataBoundsTime;

  vtkPiecewiseFunction* PWF;

  bool UseDataPartitions;

  bool UseShaderReplacements;
  std::string ShaderReplacementsString;

  bool BlockAttrChanged = false;
  vtkTimeStamp BlockAttributeTime;
  bool UpdateBlockAttrLOD = false;

  // This is used to be able to create the correct placeHolder in RequestData for the client
  int PlaceHolderDataType = VTK_PARTITIONED_DATA_SET_COLLECTION;

  // These block variables are similar to the ones in vtkCompositeDataDisplayAttributes
  // Some of them are exposed and some others are not because, as of now, they are not needed.


  std::vector<std::string> BlockSelectors;
  std::vector<std::pair<std::string, vtkVector3d>> BlockColors;
  std::vector<std::pair<std::string, double>> BlockOpacities;
  std::vector<std::pair<std::string, bool>> BlockInterpolateScalarsBeforeMapping;
  std::vector<std::pair<std::string, int>> BlockColorModes;
  std::vector<std::pair<std::string, std::pair<int /*assoc*/, std::string>>> BlockArrayNames;
  std::vector<vtkScalarsToColors*> BlockLookupTables;

  std::vector<std::pair<std::string, bool>> BlockScalarVisibilities;
  std::vector<std::pair<std::string, bool>> BlockUseLookupTableScalarRanges;
  std::vector<std::pair<vtkDataObject*, vtkIdType>> BlockFieldDataTupleIds;
private:
  bool DisableLighting = false;
  vtkGeometryRepresentation(const vtkGeometryRepresentation&) = delete;
  void operator=(const vtkGeometryRepresentation&) = delete;
};

#endif