vtkMapper.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkMapper_h
#define vtkMapper_h
 
#include "vtkAbstractMapper3D.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkSmartPointer.h"        // needed for vtkSmartPointer.
#include "vtkSystemIncludes.h"      // For VTK_COLOR_MODE_DEFAULT and _MAP_SCALARS
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO
#include <vector>                   // for method args
 
#define VTK_RESOLVE_OFF 0
#define VTK_RESOLVE_POLYGON_OFFSET 1
#define VTK_RESOLVE_SHIFT_ZBUFFER 2
 
#define VTK_GET_ARRAY_BY_ID 0
#define VTK_GET_ARRAY_BY_NAME 1
 
#define VTK_MATERIALMODE_DEFAULT 0
#define VTK_MATERIALMODE_AMBIENT 1
#define VTK_MATERIALMODE_DIFFUSE 2
#define VTK_MATERIALMODE_AMBIENT_AND_DIFFUSE 3
 
VTK_ABI_NAMESPACE_BEGIN
class vtkActor;
class vtkDataSet;
class vtkDataObject;
class vtkFloatArray;
class vtkHardwareSelector;
class vtkImageData;
class vtkProp;
class vtkRenderer;
class vtkScalarsToColors;
class vtkSelection;
class vtkUnsignedCharArray;
class vtkWindow;
 
class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkMapper : public vtkAbstractMapper3D
{
public:
  vtkTypeMacro(vtkMapper, vtkAbstractMapper3D);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void ShallowCopy(vtkAbstractMapper* m) override;

  vtkMTimeType GetMTime() override;

  virtual void Render(vtkRenderer* ren, vtkActor* a) = 0;

  void ReleaseGraphicsResources(vtkWindow*) override {}


  void SetLookupTable(vtkScalarsToColors* lut);
  vtkScalarsToColors* GetLookupTable();

  virtual void CreateDefaultLookupTable();


  vtkSetMacro(ScalarVisibility, vtkTypeBool);
  vtkGetMacro(ScalarVisibility, vtkTypeBool);
  vtkBooleanMacro(ScalarVisibility, vtkTypeBool);


  vtkSetMacro(Static, vtkTypeBool);
  vtkGetMacro(Static, vtkTypeBool);
  vtkBooleanMacro(Static, vtkTypeBool);


  vtkSetMacro(ColorMode, int);
  vtkGetMacro(ColorMode, int);
  void SetColorModeToDefault() { this->SetColorMode(VTK_COLOR_MODE_DEFAULT); }
  void SetColorModeToMapScalars() { this->SetColorMode(VTK_COLOR_MODE_MAP_SCALARS); }
  void SetColorModeToDirectScalars() { this->SetColorMode(VTK_COLOR_MODE_DIRECT_SCALARS); }

  const char* GetColorModeAsString();


  vtkSetMacro(InterpolateScalarsBeforeMapping, vtkTypeBool);
  vtkGetMacro(InterpolateScalarsBeforeMapping, vtkTypeBool);
  vtkBooleanMacro(InterpolateScalarsBeforeMapping, vtkTypeBool);


  vtkSetMacro(UseLookupTableScalarRange, vtkTypeBool);
  vtkGetMacro(UseLookupTableScalarRange, vtkTypeBool);
  vtkBooleanMacro(UseLookupTableScalarRange, vtkTypeBool);


  vtkSetVector2Macro(ScalarRange, double);
  vtkGetVectorMacro(ScalarRange, double, 2);

 
  // When ScalarMode is set to use Field Data (ScalarModeToFieldData),
  // you must call SelectColorArray to choose the field data array to
  // be used to color cells. In this mode, the default behavior is to
  // treat the field data tuples as being associated with cells. If
  // the poly data contains triangle strips, the array is expected to
  // contain the cell data for each mini-cell formed by any triangle
  // strips in the poly data as opposed to treating them as a single
  // tuple that applies to the entire strip.  This mode can also be
  // used to color the entire poly data by a single color obtained by
  // mapping the tuple at a given index in the field data array
  // through the color map. Use SetFieldDataTupleId() to specify
  // the tuple index.
  vtkSetMacro(ScalarMode, int);
  vtkGetMacro(ScalarMode, int);
  void SetScalarModeToDefault() { this->SetScalarMode(VTK_SCALAR_MODE_DEFAULT); }
  void SetScalarModeToUsePointData() { this->SetScalarMode(VTK_SCALAR_MODE_USE_POINT_DATA); }
  void SetScalarModeToUseCellData() { this->SetScalarMode(VTK_SCALAR_MODE_USE_CELL_DATA); }
  void SetScalarModeToUsePointFieldData()
  {
    this->SetScalarMode(VTK_SCALAR_MODE_USE_POINT_FIELD_DATA);
  }
  void SetScalarModeToUseCellFieldData()
  {
    this->SetScalarMode(VTK_SCALAR_MODE_USE_CELL_FIELD_DATA);
  }
  void SetScalarModeToUseFieldData() { this->SetScalarMode(VTK_SCALAR_MODE_USE_FIELD_DATA); }


  void SelectColorArray(int arrayNum);
  void SelectColorArray(const char* arrayName);
 
  // When ScalarMode is set to UseFieldData, set the index of the
  // tuple by which to color the entire data set. By default, the
  // index is -1, which means to treat the field data array selected
  // with SelectColorArray as having a scalar value for each cell.
  // Indices of 0 or higher mean to use the tuple at the given index
  // for coloring the entire data set.
  vtkSetMacro(FieldDataTupleId, vtkIdType);
  vtkGetMacro(FieldDataTupleId, vtkIdType);


  void ColorByArrayComponent(int arrayNum, int component);
  void ColorByArrayComponent(const char* arrayName, int component);

  vtkGetStringMacro(ArrayName);
  vtkSetStringMacro(ArrayName);
  vtkGetMacro(ArrayId, int);
  vtkSetMacro(ArrayId, int);
  vtkGetMacro(ArrayAccessMode, int);
  vtkSetMacro(ArrayAccessMode, int);
  vtkGetMacro(ArrayComponent, int);
  vtkSetMacro(ArrayComponent, int);

  const char* GetScalarModeAsString();


  static void SetResolveCoincidentTopology(int val);
  static int GetResolveCoincidentTopology();
  static void SetResolveCoincidentTopologyToDefault();
  static void SetResolveCoincidentTopologyToOff() { SetResolveCoincidentTopology(VTK_RESOLVE_OFF); }
  static void SetResolveCoincidentTopologyToPolygonOffset()
  {
    SetResolveCoincidentTopology(VTK_RESOLVE_POLYGON_OFFSET);
  }
  static void SetResolveCoincidentTopologyToShiftZBuffer()
  {
    SetResolveCoincidentTopology(VTK_RESOLVE_SHIFT_ZBUFFER);
  }



  static void SetResolveCoincidentTopologyPolygonOffsetParameters(double factor, double units);
  static void GetResolveCoincidentTopologyPolygonOffsetParameters(double& factor, double& units);


  void SetRelativeCoincidentTopologyPolygonOffsetParameters(double factor, double units);
  void GetRelativeCoincidentTopologyPolygonOffsetParameters(double& factor, double& units);


  static void SetResolveCoincidentTopologyLineOffsetParameters(double factor, double units);
  static void GetResolveCoincidentTopologyLineOffsetParameters(double& factor, double& units);


  void SetRelativeCoincidentTopologyLineOffsetParameters(double factor, double units);
  void GetRelativeCoincidentTopologyLineOffsetParameters(double& factor, double& units);


  static void SetResolveCoincidentTopologyPointOffsetParameter(double units);
  static void GetResolveCoincidentTopologyPointOffsetParameter(double& units);


  void SetRelativeCoincidentTopologyPointOffsetParameter(double units);
  void GetRelativeCoincidentTopologyPointOffsetParameter(double& units);


  void GetCoincidentTopologyPolygonOffsetParameters(double& factor, double& units);
  void GetCoincidentTopologyLineOffsetParameters(double& factor, double& units);
  void GetCoincidentTopologyPointOffsetParameter(double& units);


  static void SetResolveCoincidentTopologyPolygonOffsetFaces(int faces);
  static int GetResolveCoincidentTopologyPolygonOffsetFaces();


  static void SetResolveCoincidentTopologyZShift(double val);
  static double GetResolveCoincidentTopologyZShift();

  double* GetBounds() VTK_SIZEHINT(6) override;
  void GetBounds(double bounds[6]) override { this->vtkAbstractMapper3D::GetBounds(bounds); }

  void SetRenderTime(double time) { this->RenderTime = time; }
  vtkGetMacro(RenderTime, double);

  vtkDataSet* GetInput();


  vtkDataSet* GetDataSetInput() { return this->GetInput(); }


  virtual vtkUnsignedCharArray* MapScalars(double alpha);
  virtual vtkUnsignedCharArray* MapScalars(double alpha, int& cellFlag);
  virtual vtkUnsignedCharArray* MapScalars(vtkDataSet* input, double alpha);
  virtual vtkUnsignedCharArray* MapScalars(vtkDataSet* input, double alpha, int& cellFlag);


  virtual bool HasOpaqueGeometry();
  virtual bool HasTranslucentPolygonalGeometry();

  virtual bool GetSupportsSelection() { return false; }

  virtual void ProcessSelectorPixelBuffers(vtkHardwareSelector* /* sel */,
    std::vector<unsigned int>& /* pixeloffsets */, vtkProp* /* prop */)
  {
  }

  virtual int CanUseTextureMapForColoring(vtkDataObject* input);

  void ClearColorArrays();

  vtkUnsignedCharArray* GetColorMapColors();

  vtkFloatArray* GetColorCoordinates();

  vtkImageData* GetColorTextureMap();


  vtkGetObjectMacro(Selection, vtkSelection);
  virtual void SetSelection(vtkSelection*);

  static vtkSmartPointer<vtkImageData> BuildColorTextureImage(
    vtkScalarsToColors* lkup, int colorMode);
 
protected:
  vtkMapper();
  ~vtkMapper() override;
 
  // color mapped colors
  vtkUnsignedCharArray* Colors;
 
  // Use texture coordinates for coloring.
  vtkTypeBool InterpolateScalarsBeforeMapping;
  // Coordinate for each point.
  vtkFloatArray* ColorCoordinates;
  // 1D ColorMap used for the texture image.
  vtkImageData* ColorTextureMap;
  void MapScalarsToTexture(vtkAbstractArray* scalars, double alpha);
 
  vtkScalarsToColors* LookupTable;
  vtkTypeBool ScalarVisibility;
  vtkTimeStamp BuildTime;
  double ScalarRange[2];
  vtkTypeBool UseLookupTableScalarRange;
 
  int ColorMode;
  int ScalarMode;
 
  double RenderTime;
 
  // for coloring by a component of a field data array
  int ArrayId;
  char* ArrayName;
  int ArrayComponent;
  int ArrayAccessMode;
 
  // If coloring by field data, which tuple to use to color the entire
  // data set. If -1, treat array values as cell data.
  vtkIdType FieldDataTupleId;
 
  vtkTypeBool Static;
 
  double CoincidentPolygonFactor;
  double CoincidentPolygonOffset;
  double CoincidentLineFactor;
  double CoincidentLineOffset;
  double CoincidentPointOffset;
 
  vtkSelection* Selection = nullptr;
 
private:
  vtkMapper(const vtkMapper&) = delete;
  void operator=(const vtkMapper&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif