vtkGeometryRepresentation.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
2 // SPDX-License-Identifier: BSD-3-Clause
16 #ifndef vtkGeometryRepresentation_h
17 #define vtkGeometryRepresentation_h
18 
20 #include "vtkParaViewDeprecation.h" // for PV_DEPRECATED
21 #include "vtkProperty.h" // needed for VTK_POINTS etc.
22 #include "vtkRemotingViewsModule.h" // needed for exports
23 #include "vtkVector.h" // for vtkVector.
24 
25 #include <set> // needed for std::set
26 #include <string> // needed for std::string
27 #include <unordered_map> // needed for std::unordered_map
28 #include <vector> // needed for std::vector
29 
31 class vtkMapper;
34 class vtkPVLODActor;
35 class vtkScalarsToColors;
36 class vtkTexture;
37 class vtkTransform;
38 
40 {
41 // This is defined to either vtkQuadricClustering or vtkmLevelOfDetail in the
42 // implementation file:
44 }
45 
47 {
48 
49 public:
50  static vtkGeometryRepresentation* New();
52  void PrintSelf(ostream& os, vtkIndent indent) override;
53 
60  int ProcessViewRequest(vtkInformationRequestKey* request_type, vtkInformation* inInfo,
61  vtkInformation* outInfo) override;
62 
67  void SetVisibility(bool val) override;
68 
70 
74  void SetBlockColorsDistinctValues(int distinctValues);
75  int GetBlockColorsDistinctValues();
77 
81  virtual void SetSuppressLOD(bool suppress) { this->SuppressLOD = suppress; }
82 
84 
89  vtkBooleanMacro(DisableLighting, bool);
90  vtkSetMacro(DisableLighting, bool);
91  vtkGetMacro(DisableLighting, bool);
94 
101  vtkSetMacro(Ambient, double);
102  vtkSetMacro(Diffuse, double);
103  vtkSetMacro(Specular, double);
104  vtkGetMacro(Ambient, double);
105  vtkGetMacro(Diffuse, double);
106  vtkGetMacro(Specular, double);
108 
110  {
111  POINTS = VTK_POINTS,
112  WIREFRAME = VTK_WIREFRAME,
113  SURFACE = VTK_SURFACE,
114  SURFACE_WITH_EDGES = 3
115  };
116 
118 
122  void SetCoordinateShiftScaleMethod(int val);
123  int GetCoordinateShiftScaleMethod();
125 
127 
131  vtkSetClampMacro(Representation, int, POINTS, SURFACE_WITH_EDGES);
132  vtkGetMacro(Representation, int);
134 
139  virtual void SetRepresentation(const char*);
140 
144  vtkDataObject* GetRenderedDataObject(int port) override;
145 
147 
152  vtkSetMacro(RequestGhostCellsIfNeeded, bool);
153  vtkGetMacro(RequestGhostCellsIfNeeded, bool);
154  vtkBooleanMacro(RequestGhostCellsIfNeeded, bool);
156 
161  virtual void SetNormalArray(const char* val);
162 
167  virtual void SetTCoordArray(const char* val);
168 
173  virtual void SetTangentArray(const char* val);
174 
175  //***************************************************************************
176  // Forwarded to vtkPVGeometryFilter
177  virtual void SetUseOutline(int);
178  void SetTriangulate(int);
179  void SetNonlinearSubdivisionLevel(int);
180  void SetMatchBoundariesIgnoringCellOrder(int);
181  virtual void SetGenerateFeatureEdges(bool);
182  void SetComputePointNormals(bool);
183  void SetSplitting(bool);
184  void SetFeatureAngle(double);
185 
186  //***************************************************************************
187  // Forwarded to vtkProperty.
188  virtual void SetAmbientColor(double r, double g, double b);
189  virtual void SetColor(double r, double g, double b);
190  virtual void SetDiffuseColor(double r, double g, double b);
191  virtual void SetLighting(bool lighting);
192  virtual void SetEdgeColor(double r, double g, double b);
193  virtual void SetInteractiveSelectionColor(double r, double g, double b);
194  virtual void SetInterpolation(int val);
195  virtual void SetLineWidth(double val);
196  virtual void SetOpacity(double val);
197  virtual void SetEdgeOpacity(double val);
198  virtual void SetPointSize(double val);
199  virtual void SetSpecularColor(double r, double g, double b);
200  virtual void SetSpecularPower(double val);
201  virtual void SetLuminosity(double val);
202  virtual void SetRenderPointsAsSpheres(bool);
203  virtual void SetRenderLinesAsTubes(bool);
204  virtual void SetRoughness(double val);
205  virtual void SetMetallic(double val);
206  virtual void SetEdgeTint(double r, double g, double b);
207  virtual void SetAnisotropy(double val);
208  virtual void SetAnisotropyRotation(double val);
209  virtual void SetBaseIOR(double val);
210  virtual void SetCoatIOR(double val);
211  virtual void SetCoatStrength(double val);
212  virtual void SetCoatRoughness(double val);
213  virtual void SetCoatNormalScale(double val);
214  virtual void SetCoatColor(double r, double g, double b);
215  virtual void SetBaseColorTexture(vtkTexture* tex);
216  virtual void SetMaterialTexture(vtkTexture* tex);
217  virtual void SetAnisotropyTexture(vtkTexture* tex);
218  virtual void SetNormalTexture(vtkTexture* tex);
219  virtual void SetCoatNormalTexture(vtkTexture* tex);
220  virtual void SetEmissiveTexture(vtkTexture* tex);
221  virtual void SetNormalScale(double val);
222  virtual void SetOcclusionStrength(double val);
223  virtual void SetEmissiveFactor(double rval, double gval, double bval);
224  virtual void SetShowTexturesOnBackface(bool);
225 
226  //***************************************************************************
227  // Forwarded to Actor.
228  virtual void SetOrientation(double, double, double);
229  virtual void SetOrigin(double, double, double);
230  virtual void SetPickable(int val);
231  virtual void SetPosition(double, double, double);
232  virtual void SetScale(double, double, double);
233  virtual void SetTexture(vtkTexture*);
234  virtual void SetUserTransform(const double[16]);
235  PARAVIEW_DEPRECATED_IN_5_13_0("Use SetTextureTransform instead")
236  virtual void SetFlipTextures(bool);
237 
238  //***************************************************************************
239  // Forwarded to all textures
240  virtual void SetTextureTransform(vtkTransform*);
241  vtkGetObjectMacro(TextureTransform, vtkTransform);
242  virtual void SetRepeatTextures(bool);
243  vtkGetMacro(RepeatTextures, bool);
244  virtual void SetInterpolateTextures(bool);
245  vtkGetMacro(InterpolateTextures, bool);
246  virtual void SetUseMipmapTextures(bool);
247  vtkGetMacro(UseMipmapTextures, bool);
248 
249  //***************************************************************************
250  // Forwarded to Mapper and LODMapper.
251  virtual void SetInterpolateScalarsBeforeMapping(int val);
252  virtual void SetLookupTable(vtkScalarsToColors* val);
253  virtual void SetColorMissingArraysWithNanColor(bool val);
254  virtual void SetSeamlessU(bool);
255  virtual void SetSeamlessV(bool);
257 
264  virtual void SetMapScalars(int val);
265  virtual void SetStatic(int val);
267 
271  virtual void SetSelection(vtkSelection* selection);
272 
276  vtkPVLODActor* GetActor() { return this->GetRenderedProp(); }
277 
279 
285  vtkSetStringMacro(ActiveAssembly);
286  vtkGetStringMacro(ActiveAssembly);
288 
290 
293  void AddBlockSelector(const char* selector);
294  void RemoveAllBlockSelectors();
296 
298 
301  void SetBlockColor(const char* selector, double r, double g, double b);
302  void RemoveAllBlockColors();
304 
306 
309  void SetBlockOpacity(const char* selector, double opacity);
310  void RemoveAllBlockOpacities();
312 
314 
317  void SetBlockInterpolateScalarsBeforeMapping(const char* selector, bool interpolate);
318  void RemoveAllBlockInterpolateScalarsBeforeMappings();
320 
322 
327  void SetBlockMapScalars(const char* selector, int val);
328  void RemoveAllBlockMapScalars();
330 
332 
335  void SetBlockArrayName(const char* selector, int assoc, const char* arrayName);
336  void RemoveAllBlockArrayNames();
338 
340 
346  void SetBlockLookupTableSelector(const char* selector);
347  void RemoveAllBlockLookupTableSelectors();
348  void SetBlockLookupTable(vtkScalarsToColors* lut);
349  void RemoveAllBlockLookupTables();
351 
355  const char* GetColorArrayName();
356 
364  static bool GetBounds(
365  vtkDataObject* dataObject, double bounds[6], vtkCompositeDataDisplayAttributes* cdAttributes);
366 
368 
372  virtual void SetEnableScaling(int v);
373  virtual void SetScalingArrayName(const char*);
374  virtual void SetScalingFunction(vtkPiecewiseFunction* pwf);
376 
380  virtual void SetMaterial(const char*);
381 
383 
389  vtkSetMacro(UseDataPartitions, bool);
390  vtkGetMacro(UseDataPartitions, bool);
392 
394 
397  virtual void SetUseShaderReplacements(bool);
398  vtkGetMacro(UseShaderReplacements, bool);
400 
406  virtual void SetShaderReplacements(const char*);
407 
412  void SetArrayIdNames(const char* pointArray, const char* cellArray) override;
413 
415 
427  vtkSetMacro(PlaceHolderDataType, int);
428  vtkGetMacro(PlaceHolderDataType, int);
430 
431 protected:
433  ~vtkGeometryRepresentation() override;
434 
441  virtual void SetupDefaults();
442 
446  int FillInputPortInformation(int port, vtkInformation* info) override;
447 
458  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
459 
463  int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
464  vtkInformationVector* outputVector) override;
465 
471  bool AddToView(vtkView* view) override;
472 
478  bool RemoveFromView(vtkView* view) override;
479 
483  virtual void UpdateColoringParameters();
484 
488  virtual vtkPVLODActor* GetRenderedProp() { return this->Actor; }
489 
490  // Progress Callback
491  void HandleGeometryRepresentationProgress(vtkObject* caller, unsigned long, void*);
492 
500  void PopulateBlockAttributes(vtkCompositeDataDisplayAttributes* attrs, vtkDataObject* outputData);
501 
506  void ComputeVisibleDataBounds();
507 
511  void UpdateShaderReplacements();
512 
519  virtual bool NeedsOrderedCompositing();
520 
524  virtual void SetPointArrayToProcess(int p, const char* val);
525 
529  void UpdateGeneralTextureTransform();
530 
535 
540 
541  char* ActiveAssembly = nullptr;
546  double Ambient;
547  double Specular;
548  double Diffuse;
552  double VisibleDataBounds[6];
553 
555 
557 
559 
562 
563  bool BlockAttrChanged = false;
565  bool UpdateBlockAttrLOD = false;
566 
567  // This is used to be able to create the correct placeHolder in RequestData for the client
568  int PlaceHolderDataType = VTK_PARTITIONED_DATA_SET_COLLECTION;
569 
570  // These block variables are similar to the ones in vtkCompositeDataDisplayAttributes
571  // Some of them are exposed and some others are not because, as of now, they are not needed.
572 
574 
577  std::set<std::string> BlockSelectors;
578  std::unordered_map<std::string, vtkVector3d> BlockColors;
579  std::unordered_map<std::string, double> BlockOpacities;
580  std::unordered_map<std::string, bool> BlockInterpolateScalarsBeforeMapping;
581  std::unordered_map<std::string, int> BlockColorModes;
582  std::unordered_map<std::string, std::pair<int /*assoc*/, std::string>> BlockArrayNames;
583  std::vector<std::string> BlockLookupTableSelectors;
584  std::vector<vtkScalarsToColors*> BlockLookupTables;
587 
590  std::unordered_map<std::string, bool> BlockScalarVisibilities;
591  std::unordered_map<std::string, bool> BlockUseLookupTableScalarRanges;
592  std::unordered_map<vtkDataObject*, vtkIdType> BlockFieldDataTupleIds;
594 private:
595  bool DisableLighting = false;
597  void operator=(const vtkGeometryRepresentation&) = delete;
598 };
599 
600 #endif
vtkGeometryRepresentation_detail::DecimationFilterType * Decimator
std::unordered_map< std::string, vtkVector3d > BlockColors
Configurable through vtkGeometryRepresentation API.
virtual vtkPVLODActor * GetRenderedProp()
Used in ConvertSelection to locate the prop used for actual rendering.
#define VTKREMOTINGVIEWS_EXPORT
std::unordered_map< std::string, bool > BlockUseLookupTableScalarRanges
Configured internally in vtkGeometryRepresentation.
vtkPVDataRepresentation adds some ParaView specific API to data representations.
#define VTK_SURFACE
std::unordered_map< std::string, double > BlockOpacities
Configurable through vtkGeometryRepresentation API.
std::unordered_map< std::string, bool > BlockScalarVisibilities
Configured internally in vtkGeometryRepresentation.
std::unordered_map< std::string, int > BlockColorModes
Configurable through vtkGeometryRepresentation API.
info
Geometry filter that does outlines for volumes.
std::unordered_map< std::string, bool > BlockInterpolateScalarsBeforeMapping
Configurable through vtkGeometryRepresentation API.
representation for showing any datasets as external shell of polygons.
#define PARAVIEW_DEPRECATED_IN_5_13_0(reason)
std::vector< std::string > BlockLookupTableSelectors
Configurable through vtkGeometryRepresentation API.
vtkPVGeometryFilter * LODOutlineFilter
std::set< std::string > BlockSelectors
Configurable through vtkGeometryRepresentation API.
#define VTK_POINTS
std::vector< vtkScalarsToColors * > BlockLookupTables
Configurable through vtkGeometryRepresentation API.
an actor that supports multiple levels of detail
Definition: vtkPVLODActor.h:25
std::unordered_map< vtkDataObject *, vtkIdType > BlockFieldDataTupleIds
Configured internally in vtkGeometryRepresentation.
port
std::unordered_map< std::string, std::pair< int, std::string > > BlockArrayNames
Configurable through vtkGeometryRepresentation API.
#define VTK_WIREFRAME
virtual void SetSuppressLOD(bool suppress)
Enable/Disable LOD;.