vtkMapper.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkMapper.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 vtkMapper_h
#define vtkMapper_h

#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkAbstractMapper3D.h"
#include "vtkSystemIncludes.h" // For VTK_COLOR_MODE_DEFAULT and _MAP_SCALARS
#include "vtkSmartPointer.h" // needed for vtkSmartPointer.

#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

class vtkWindow;
class vtkRenderer;
class vtkActor;
class vtkDataSet;
class vtkDataObject;
class vtkFloatArray;
class vtkImageData;
class vtkScalarsToColors;
class vtkUnsignedCharArray;

class VTKRENDERINGCORE_EXPORT vtkMapper : public vtkAbstractMapper3D
{
public:
  vtkTypeMacro(vtkMapper, vtkAbstractMapper3D);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void ShallowCopy(vtkAbstractMapper *m);

  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 *GetInputAsDataSet()
    { 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 GetIsOpaque();

  virtual bool GetSupportsSelection()
    { return false; }

  virtual int CanUseTextureMapForColoring(vtkDataObject* input);

  void ClearColorArrays();

  vtkUnsignedCharArray *GetColorMapColors();

  vtkFloatArray *GetColorCoordinates();

  vtkImageData* GetColorTextureMap();

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;

private:
  vtkMapper(const vtkMapper&) = delete;
  void operator=(const vtkMapper&) = delete;
};

#endif