/*=========================================================================
Program: Visualization Toolkit
Module: $RCSfile: vtkMapper.h,v $
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.
=========================================================================*/
// .NAME vtkMapper - abstract class specifies interface to map data to graphics primitives
// .SECTION Description
// vtkMapper is an abstract class to specify interface between data and
// graphics primitives. Subclasses of vtkMapper map data through a
// lookuptable and control the creation of rendering primitives that
// interface to the graphics library. The mapping can be controlled by
// supplying a lookup table and specifying a scalar range to map data
// through.
//vtkMapper是一个抽象类,指定了几何数据和图元的接口,子类化vtkMapper,利用艳色查找表把数据映射成图元;
封装了opengl的核心函数glBegin(GL_Vertex)glEnd()等生成图元的函数
// There are several important control mechanisms affecting the behavior of
// this object. The ScalarVisibility flag controls whether scalar data (if
// any) controls the color of the associated actor(s) that refer to the
// mapper.
有几个重要的机制影响Actror的行为,ScalarVisibility控制标量数据如点属性,单元属性是否应用.
The ScalarMode ivar is used to determine whether scalar point data
// or cell data is used to color the object. By default, point data scalars
// are used unless there are none, in which cell scalars are used. Or you can
// explicitly control whether to use point or cell scalar data. Finally, the
// mapping of scalars through the lookup table varies depending on the
// setting of the ColorMode flag. See the documentation for the appropriate
// methods for an explanation.
//默认使用标量数据,除非没有入输入标量
//
// Another important feature of this class is whether to use immediate mode
// rendering (ImmediateModeRenderingOn) or display list rendering
// (ImmediateModeRenderingOff). If display lists are used, a data structure
// is constructed (generally in the rendering library) which can then be
// rapidly traversed and rendered by the rendering library. The disadvantage
// of display lists is that they require additionally memory which may affect
// the performance of the system.
//两种渲染模式,立即模式和显示列表模式,显示列表渲染的好处是增加速度
// Another important feature of the mapper is the ability to shift the
// z-buffer to resolve coincident topology. For example, if you'd like to
// draw a mesh with some edges a different color, and the edges lie on the
// mesh, this feature can be useful to get nice looking lines. (See the
// ResolveCoincidentTopology-related methods.)
//另一个特性是利用z-buffer去解决深度容差,比如,如果你想画一个网格,这个网格带有边界,并且边界线的
艳色和网格的艳色不一样,这个时候打开深度偏移就可以得到很好的效果
// .SECTION See Also
// vtkDataSetMapper vtkPolyDataMapper
#ifndef __vtkMapper_h
#define __vtkMapper_h
#include "vtkAbstractMapper3D.h"
#include "vtkScalarsToColors.h" // For VTK_COLOR_MODE_DEFAULT and _MAP_SCALARS
#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 vtkFloatArray;
class vtkImageData;
class VTK_RENDERING_EXPORT vtkMapper : public vtkAbstractMapper3D
{
public:
vtkTypeRevisionMacro(vtkMapper,vtkAbstractMapper3D);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
// Make a shallow copy of this mapper.
void ShallowCopy(vtkAbstractMapper *m);
// Description:
// Overload standard modified time function. If lookup table is modified,
// then this object is modified as well.
unsigned long GetMTime();
// Description:
// Method initiates the mapping process. Generally sent by the actor
// as each frame is rendered.
virtual void Render(vtkRenderer *ren, vtkActor *a) = 0;//执行渲染的代码,由子类实现
// Description:
// Release any graphics resources that are being consumed by this mapper.
// The parameter window could be used to determine which graphic
// resources to release.
virtual void ReleaseGraphicsResources(vtkWindow *) {};
// Description:
// Specify a lookup table for the mapper to use.
void SetLookupTable(vtkScalarsToColors *lut);设置艳色查找表,给actor着色
vtkScalarsToColors *GetLookupTable();
// Description:
// Create default lookup table. Generally used to create one when none
// is available with the scalar data.
virtual void CreateDefaultLookupTable();
// Description:
// Turn on/off flag to control whether scalar data is used to color objects.
vtkSetMacro(ScalarVisibility,int);
vtkGetMacro(ScalarVisibility,int);
vtkBooleanMacro(ScalarVisibility,int);
// Description:
// Turn on/off flag to control whether the mapper's data is static. Static data
// means that the mapper does not propagate updates down the pipeline, greatly
// decreasing the time it takes to update many mappers. This should only be
// used if the data never changes.
//如果mapper里面的数据集不发生变化的时候,可以极大的增加速度
vtkSetMacro(Static,int);
vtkGetMacro(Static,int);
vtkBooleanMacro(Static,int);
// Description:
// Control how the scalar data is mapped to colors. By default
// (ColorModeToDefault), unsigned char scalars are treated as colors, and
// NOT mapped through the lookup table, while everything else is. Setting
// ColorModeToMapScalars means that all scalar data will be mapped through
// the lookup table. (Note that for multi-component scalars, the
// particular component to use for mapping can be specified using the
// SelectColorArray() method.)
//所有的艳色模式都要通过艳色查找表实现
vtkSetMacro(ColorMode,int);
vtkGetMacro(ColorMode,int);
void SetColorModeToDefault()
{this->SetColorMode(VTK_COLOR_MODE_DEFAULT);};
void SetColorModeToMapScalars()
{this->SetColorMode(VTK_COLOR_MODE_MAP_SCALARS);};
// Description:
// Return the method of coloring scalar data.
const char *GetColorModeAsString();
// Description:
// By default, vertex color is used to map colors to a surface.
// Colors are interpolated after being mapped.
// This option avoids color interpolation by using a one dimensional
// texture map for the colors.
//映射艳色后插值
vtkSetMacro(InterpolateScalarsBeforeMapping,int);
vtkGetMacro(InterpolateScalarsBeforeMapping,int);
vtkBooleanMacro(InterpolateScalarsBeforeMapping,int);
// Description:
// Control whether the mapper sets the lookuptable range based on its
// own ScalarRange, or whether it will use the LookupTable ScalarRange
// regardless of it's own setting. By default the Mapper is allowed to set
// the LookupTable range, but users who are sharing LookupTables between
// mappers/actors will probably wish to force the mapper to use the
// LookupTable unchanged.
vtkSetMacro(UseLookupTableScalarRange,int);
vtkGetMacro(UseLookupTableScalarRange,int);
vtkBooleanMacro(UseLookupTableScalarRange,int);
// Description:
// Specify range in terms of scalar minimum and maximum (smin,smax). These
// values are used to map scalars into lookup table. Has no effect when
// UseLookupTableScalarRange is true.
vtkSetVector2Macro(ScalarRange,double);
vtkGetVectorMacro(ScalarRange,double,2);
// Description:
// Turn on/off flag to control whether data is rendered using
// immediate mode or note. Immediate mode rendering
// tends to be slower but it can handle larger datasets.
// The default value is immediate mode off. If you are
// having problems rendering a large dataset you might
// want to consider using immediate more rendering.
//控制是否渲染大的数据集
vtkSetMacro(ImmediateModeRendering,int);
vtkGetMacro(ImmediateModeRendering,int);
vtkBooleanMacro(ImmediateModeRendering,int);
// Description:
// Turn on/off flag to control whether data is rendered using
// immediate mode or note. Immediate mode rendering
// tends to be slower but it can handle larger datasets.
// The default value is immediate mode off. If you are
// having problems rendering a large dataset you might
// want to consider using immediate more rendering.
static void SetGlobalImmediateModeRendering(int val);
static void GlobalImmediateModeRenderingOn()
{vtkMapper::SetGlobalImmediateModeRendering(1);};
static void GlobalImmediateModeRenderingOff()
{vtkMapper::SetGlobalImmediateModeRendering(0);};
static int GetGlobalImmediateModeRendering();
// Description:
// Control how the filter works with scalar point data and cell attribute
// data. By default (ScalarModeToDefault), the filter will use point data,
// and if no point data is available, then cell data is used. Alternatively
// you can explicitly set the filter to use point data
// (ScalarModeToUsePointData) or cell data (ScalarModeToUseCellData).
// You can also choose to get the scalars from an array in point field
// data (ScalarModeToUsePointFieldData) or cell field data
// (ScalarModeToUseCellFieldData). If scalars are coming from a field
// data array, you must call SelectColorArray before you call
// GetColors.
// 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, if the poly data has triangle strips,
// the field data is treated as the celldata for each mini-cell formed by
// a triangle in the strip rather than the entire strip.
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); }
// Description:
// When ScalarMode is set to UsePointFieldData or UseCellFieldData,
// you can specify which array to use for coloring using these methods.
// The lookup table will decide how to convert vectors to colors.
//用点哉属性或者单元哉属性
void SelectColorArray(int arrayNum);
void SelectColorArray(const char* arrayName);
// Description:
// Legacy:
// These methods used to be used to specify the array component.
// It is better to do this in the lookup table.
void ColorByArrayComponent(int arrayNum, int component);
void ColorByArrayComponent(const char* arrayName, int component);
// Description:
// Get the array name or number and component to color by.
char* GetArrayName() { return this->ArrayName; }
int GetArrayId() { return this->ArrayId; }
int GetArrayAccessMode() { return this->ArrayAccessMode; }
int GetArrayComponent() { return this->ArrayComponent; }
// Description:
// Return the method for obtaining scalar data.
const char *GetScalarModeAsString();
// Description:
// Set/Get a global flag that controls whether coincident topology (e.g., a
// line on top of a polygon) is shifted to avoid z-buffer resolution (and
// hence rendering problems). If not off, there are two methods to choose
// from. PolygonOffset uses graphics systems calls to shift polygons, but
// does not distinguish vertices and lines from one another. ShiftZBuffer
// remaps the z-buffer to distinguish vertices, lines, and polygons, but
// does not always produce acceptable results. If you use the ShiftZBuffer
// approach, you may also want to set the ResolveCoincidentTopologyZShift
// value. (Note: not all mappers/graphics systems implement this
// functionality.)
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);}
// Description:
// Used to set the polygon offset scale factor and units.
// Used when ResolveCoincidentTopology is set to PolygonOffset.
// These are global variables.
static void SetResolveCoincidentTopologyPolygonOffsetParameters(
double factor, double units);
static void GetResolveCoincidentTopologyPolygonOffsetParameters(
double& factor, double& units);
// Description:
// Used when ResolveCoincidentTopology is set to PolygonOffset. The polygon
// offset can be applied either to the solid polygonal faces or the
// lines/vertices. When set (default), the offset is applied to the faces
// otherwise it is applied to lines and vertices.
// This is a global variable.
static void SetResolveCoincidentTopologyPolygonOffsetFaces(int faces);
static int GetResolveCoincidentTopologyPolygonOffsetFaces();
// Description:
// Used to set the z-shift if ResolveCoincidentTopology is set to
// ShiftZBuffer. This is a global variable.
static void SetResolveCoincidentTopologyZShift(double val);
static double GetResolveCoincidentTopologyZShift();
// Description:
// Return bounding box (array of six doubles) of data expressed as
// (xmin,xmax, ymin,ymax, zmin,zmax).
virtual double *GetBounds();
virtual void GetBounds(double bounds[6])
{this->vtkAbstractMapper3D::GetBounds(bounds);};
// Description:
// This instance variable is used by vtkLODActor to determine which
// mapper to use. It is an estimate of the time necessary to render.
// Setting the render time does not modify the mapper.
//vtkLoadActor在不同的时刻需要不同的vtkMapper
void SetRenderTime(double time) {this->RenderTime = time;}
vtkGetMacro(RenderTime, double);
//BTX
// Description:
// Get the input as a vtkDataSet. This method is overridden in
// the specialized mapper classes to return more specific data types.
vtkDataSet *GetInput();
//ETX
// Description:
// Get the input to this mapper as a vtkDataSet, instead of as a
// more specialized data type that the subclass may return from
// GetInput(). This method is provided for use in the wrapper languages,
// C++ programmers should use GetInput() instead.
vtkDataSet *GetInputAsDataSet()
{return this->GetInput();}
// Description:
// Map the scalars (if there are any scalars and ScalarVisibility is on)
// through the lookup table, returning an unsigned char RGBA array. This is
// typically done as part of the rendering process. The alpha parameter
// allows the blending of the scalars with an additional alpha (typically
// which comes from a vtkActor, etc.)
vtkUnsignedCharArray *MapScalars(double alpha);
// Description:
// Set/Get the light-model color mode.
vtkSetMacro(ScalarMaterialMode,int);
vtkGetMacro(ScalarMaterialMode,int);
void SetScalarMaterialModeToDefault()
{this->SetScalarMaterialMode(VTK_MATERIALMODE_DEFAULT);};
void SetScalarMaterialModeToAmbient()
{this->SetScalarMaterialMode(VTK_MATERIALMODE_AMBIENT);};
void SetScalarMaterialModeToDiffuse()
{this->SetScalarMaterialMode(VTK_MATERIALMODE_DIFFUSE);};
void SetScalarMaterialModeToAmbientAndDiffuse()
{this->SetScalarMaterialMode(VTK_MATERIALMODE_AMBIENT_AND_DIFFUSE);};
// Description:
// Return the light-model color mode.
const char *GetScalarMaterialModeAsString();
protected:
vtkMapper();
~vtkMapper();
vtkUnsignedCharArray *Colors;
// Use texture coordinates for coloring.
int InterpolateScalarsBeforeMapping;
// Coordinate for each point.
vtkFloatArray *ColorCoordinates;
// 1D ColorMap used for the texture image.
vtkImageData* ColorTextureMap;
void MapScalarsToTexture(vtkDataArray* scalars, double alpha);
vtkScalarsToColors *LookupTable;
int ScalarVisibility;
vtkTimeStamp BuildTime;
double ScalarRange[2];
int UseLookupTableScalarRange;
int ImmediateModeRendering;
int ColorMode;
int ScalarMode;
int ScalarMaterialMode;
double RenderTime;
// for coloring by a component of a field data array
int ArrayId;
char ArrayName[256];
int ArrayComponent;
int ArrayAccessMode;
int Static;
private:
vtkMapper(const vtkMapper&); // Not implemented.
void operator=(const vtkMapper&); // Not implemented.
};
#endif
//提供了艳色查找表,深度偏移等
#include "vtkMapper.h"
#include "vtkDataSet.h"
#include "vtkExecutive.h"
#include "vtkLookupTable.h"
#include "vtkFloatArray.h"
#include "vtkImageData.h"
#include "vtkPointData.h"
#include "vtkMath.h"
vtkCxxRevisionMacro(vtkMapper, "$Revision: 1.122 $");
// Initialize static member that controls global immediate mode rendering
static int vtkMapperGlobalImmediateModeRendering = 0;
// Initialize static member that controls global coincidence resolution
static int vtkMapperGlobalResolveCoincidentTopology = VTK_RESOLVE_OFF;
static double vtkMapperGlobalResolveCoincidentTopologyZShift = 0.01;
static double vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetFactor = 1.0;
static double vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetUnits = 1.0;
static int vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetFaces = 1;
//偏移相关的参数
// Construct with initial range (0,1).
vtkMapper::vtkMapper()
{
this->Colors = 0;
this->Static = 0;
this->LookupTable = 0;
this->ScalarVisibility = 1;
this->ScalarRange[0] = 0.0; this->ScalarRange[1] = 1.0;
this->UseLookupTableScalarRange = 0;
this->ImmediateModeRendering = 0;
this->ColorMode = VTK_COLOR_MODE_DEFAULT;
this->ScalarMode = VTK_SCALAR_MODE_DEFAULT;
this->ScalarMaterialMode = VTK_MATERIALMODE_DEFAULT;
vtkMath::UninitializeBounds(this->Bounds);
this->Center[0] = this->Center[1] = this->Center[2] = 0.0;
this->RenderTime = 0.0;
strcpy(this->ArrayName, "");
this->ArrayId = -1;
this->ArrayComponent = 0;
this->ArrayAccessMode = VTK_GET_ARRAY_BY_ID;
this->InterpolateScalarsBeforeMapping = 0;
this->ColorCoordinates = 0;
this->ColorTextureMap = 0;
}
vtkMapper::~vtkMapper()
{
if (this->LookupTable)
{
this->LookupTable->UnRegister(this);
}
if ( this->Colors != 0 )
{
this->Colors->UnRegister(this);
}
if ( this->ColorCoordinates != 0 )
{
this->ColorCoordinates->UnRegister(this);
}
if ( this->ColorTextureMap != 0 )
{
this->ColorTextureMap->UnRegister(this);
}
}
// Get the bounds for the input of this mapper as
// (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).
double *vtkMapper::GetBounds()
{
static double bounds[] = {-1.0,1.0, -1.0,1.0, -1.0,1.0};
vtkDataSet *input = this->GetInput();
if ( ! input )
{
return bounds;
}
else
{
if (!this->Static)
{
this->Update();
}
input->GetBounds(this->Bounds);
return this->Bounds;
}
}
vtkDataSet *vtkMapper::GetInput()
{
if (this->GetNumberOfInputConnections(0) < 1)
{
return 0;
}
return vtkDataSet::SafeDownCast(
this->GetExecutive()->GetInputData(0, 0));
}
void vtkMapper::SetGlobalImmediateModeRendering(int val)
{
if (val == vtkMapperGlobalImmediateModeRendering)
{
return;
}
vtkMapperGlobalImmediateModeRendering = val;
}
int vtkMapper::GetGlobalImmediateModeRendering()
{
return vtkMapperGlobalImmediateModeRendering;
}
void vtkMapper::SetResolveCoincidentTopology(int val)
{
if (val == vtkMapperGlobalResolveCoincidentTopology)
{
return;
}
vtkMapperGlobalResolveCoincidentTopology = val;
}
int vtkMapper::GetResolveCoincidentTopology()
{
return vtkMapperGlobalResolveCoincidentTopology;
}
void vtkMapper::SetResolveCoincidentTopologyToDefault()
{
vtkMapperGlobalResolveCoincidentTopology = VTK_RESOLVE_OFF;
}
void vtkMapper::SetResolveCoincidentTopologyZShift(double val)
{
if (val == vtkMapperGlobalResolveCoincidentTopologyZShift)
{
return;
}
vtkMapperGlobalResolveCoincidentTopologyZShift = val;
}
double vtkMapper::GetResolveCoincidentTopologyZShift()
{
return vtkMapperGlobalResolveCoincidentTopologyZShift;
}
void vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(
double factor, double units)
{
if (factor == vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetFactor &&
units == vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetUnits )
{
return;
}
vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetFactor = factor;
vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetUnits = units;
}
void vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(
double& factor, double& units)
{
factor = vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetFactor;
units = vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetUnits;
}
void vtkMapper::SetResolveCoincidentTopologyPolygonOffsetFaces(int faces)
{
vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetFaces = faces;
}
int vtkMapper::GetResolveCoincidentTopologyPolygonOffsetFaces()
{
return vtkMapperGlobalResolveCoincidentTopologyPolygonOffsetFaces;
}
// Overload standard modified time function. If lookup table is modified,
// then this object is modified as well.
unsigned long vtkMapper::GetMTime()
{
//unsigned long mTime=this->MTime.GetMTime();
unsigned long mTime=vtkAbstractMapper::GetMTime();
unsigned long lutMTime;
if ( this->LookupTable != NULL )
{
lutMTime = this->LookupTable->GetMTime();
mTime = ( lutMTime > mTime ? lutMTime : mTime );
}
return mTime;
}
void vtkMapper::ShallowCopy(vtkAbstractMapper *mapper)
{
vtkMapper *m = vtkMapper::SafeDownCast(mapper);
if ( m != NULL )
{
this->SetLookupTable(m->GetLookupTable());
this->SetScalarVisibility(m->GetScalarVisibility());
this->SetScalarRange(m->GetScalarRange());
this->SetColorMode(m->GetColorMode());
this->SetScalarMode(m->GetScalarMode());
this->SetScalarMaterialMode(m->GetScalarMaterialMode());
this->SetImmediateModeRendering(m->GetImmediateModeRendering());
this->SetUseLookupTableScalarRange(m->GetUseLookupTableScalarRange());
if ( m->GetArrayAccessMode() == VTK_GET_ARRAY_BY_ID )
{
this->ColorByArrayComponent(m->GetArrayId(),m->GetArrayComponent());
}
else
{
this->ColorByArrayComponent(m->GetArrayName(),m->GetArrayComponent());
}
}
// Now do superclass
this->vtkAbstractMapper3D::ShallowCopy(mapper);
}
// a side effect of this is that this->Colors is also set
// to the return value
vtkUnsignedCharArray *vtkMapper::MapScalars(double alpha)
{
int cellFlag = 0;
vtkDataArray *scalars = vtkAbstractMapper::
GetScalars(this->GetInput(), this->ScalarMode, this->ArrayAccessMode,
this->ArrayId, this->ArrayName, cellFlag);
// This is for a legacy feature: selection of the array component to color by
// from the mapper. It is now in the lookuptable. When this feature
// is removed, we can remove this condition.
if (scalars == 0 || scalars->GetNumberOfComponents() <= this->ArrayComponent)
{
this->ArrayComponent = 0;
}
if ( !this->ScalarVisibility || scalars==0 || this->GetInput()==0)
{ // No scalar colors.
if ( this->ColorCoordinates )
{
this->ColorCoordinates->UnRegister(this);
this->ColorCoordinates = 0;
}
if ( this->ColorTextureMap )
{
this->ColorTextureMap->UnRegister(this);
this->ColorTextureMap = 0;
}
if ( this->Colors )
{
this->Colors->UnRegister(this);
this->Colors = 0;
}
return 0;
}
// Get the lookup table.
if ( scalars->GetLookupTable() )
{
this->SetLookupTable(scalars->GetLookupTable());
}
else
{
// make sure we have a lookup table//make sure we have a lookup table
if ( this->LookupTable == 0 )
{
this->CreateDefaultLookupTable();
}
this->LookupTable->Build();
}
if ( !this->UseLookupTableScalarRange )
{
this->LookupTable->SetRange(this->ScalarRange);
}
// Decide betweeen texture color or vertex color.
// Cell data always uses vertext color.
// Only point data can use both texture and vertext coloring.
if (this->InterpolateScalarsBeforeMapping && ! cellFlag)
{
// Only use texture color if we are mapping scalars.
// Directly coloring with RGB unsigned chars should not use texture.
if ( this->ColorMode != VTK_COLOR_MODE_DEFAULT ||
(vtkUnsignedCharArray::SafeDownCast(scalars)) == 0 )
{ // Texture color option.
this->MapScalarsToTexture(scalars, alpha);
return 0;
}
}
// Vertex colors are being used.
// Get rid of texure Color arrays. Only texture or vertex coloring
// can be active at one time. The existence of the array is the
// signal to use that technique.
if ( this->ColorCoordinates )
{
this->ColorCoordinates->UnRegister(this);
this->ColorCoordinates = 0;
}
if ( this->ColorTextureMap )
{
this->ColorTextureMap->UnRegister(this);
this->ColorTextureMap = 0;
}
// Lets try to resuse the old colors.//Lets try to resuse the old colors;
if (this->Colors)
{
if (this->LookupTable && this->LookupTable->GetAlpha() == alpha)
{
if (this->GetMTime() < this->Colors->GetMTime() &&
this->GetInput()->GetMTime() < this->Colors->GetMTime() &&
this->LookupTable->GetMTime() < this->Colors->GetMTime())
{
return this->Colors;
}
}
}
// Get rid of old colors
if ( this->Colors )
{
this->Colors->UnRegister(this);
this->Colors = 0;
}
// map scalars
this->LookupTable->SetAlpha(alpha);
this->Colors = this->LookupTable->
MapScalars(scalars, this->ColorMode, this->ArrayComponent);
// Consistent register and unregisters
this->Colors->Register(this);
this->Colors->Delete();
return this->Colors;
}
void vtkMapper::SelectColorArray(int arrayNum)//SelectColorArray(int arrayNum)
{
this->ColorByArrayComponent(arrayNum, -1);
}
void vtkMapper::SelectColorArray(const char* arrayName)
{
this->ColorByArrayComponent(arrayName, -1);
}
void vtkMapper::ColorByArrayComponent(int arrayNum, int component)
{
if (this->ArrayId == arrayNum && component == this->ArrayComponent &&
this->ArrayAccessMode == VTK_GET_ARRAY_BY_ID)
{
return;
}
this->Modified();
this->ArrayId = arrayNum;
this->ArrayComponent = component;
this->ArrayAccessMode = VTK_GET_ARRAY_BY_ID;
}
void vtkMapper::ColorByArrayComponent(const char* arrayName, int component)
{
if (!arrayName ||
( strcmp(this->ArrayName, arrayName) == 0 &&
component == this->ArrayComponent &&
this->ArrayAccessMode == VTK_GET_ARRAY_BY_NAME ))
{
return;
}
this->Modified();
strcpy(this->ArrayName, arrayName);
this->ArrayComponent = component;
this->ArrayAccessMode = VTK_GET_ARRAY_BY_NAME;
}
// Specify a lookup table for the mapper to use.
void vtkMapper::SetLookupTable(vtkScalarsToColors *lut)
{
if ( this->LookupTable != lut )
{
if ( this->LookupTable)
{
this->LookupTable->UnRegister(this);
}
this->LookupTable = lut;
if (lut)
{
lut->Register(this);
}
this->Modified();
}
}
vtkScalarsToColors *vtkMapper::GetLookupTable()
{
if ( this->LookupTable == 0 )
{
this->CreateDefaultLookupTable();
}
return this->LookupTable;
}
void vtkMapper::CreateDefaultLookupTable()
{
if ( this->LookupTable)
{
this->LookupTable->UnRegister(this);
}
this->LookupTable = vtkLookupTable::New();
// Consistent Register/UnRegisters.
this->LookupTable->Register(this);
this->LookupTable->Delete();
}
// Return the method of coloring scalar data.
const char *vtkMapper::GetColorModeAsString(void)
{
if ( this->ColorMode == VTK_COLOR_MODE_MAP_SCALARS )
{
return "MapScalars";
}
else
{
return "Default";
}
}
// Return the method for obtaining scalar data.
const char *vtkMapper::GetScalarModeAsString(void)
{
if ( this->ScalarMode == VTK_SCALAR_MODE_USE_CELL_DATA )
{
return "UseCellData";
}
else if ( this->ScalarMode == VTK_SCALAR_MODE_USE_POINT_DATA )
{
return "UsePointData";
}
else if ( this->ScalarMode == VTK_SCALAR_MODE_USE_POINT_FIELD_DATA )
{
return "UsePointFieldData";
}
else if ( this->ScalarMode == VTK_SCALAR_MODE_USE_CELL_FIELD_DATA )
{
return "UseCellFieldData";
}
else
{
return "Default";
}
}
const char *vtkMapper::GetScalarMaterialModeAsString(void)
{
if ( this->ScalarMaterialMode == VTK_MATERIALMODE_AMBIENT )
{
return "Ambient";
}
else if ( this->ScalarMaterialMode == VTK_MATERIALMODE_DIFFUSE )
{
return "Diffuse";
}
else if ( this->ScalarMaterialMode == VTK_MATERIALMODE_AMBIENT_AND_DIFFUSE )
{
return "Ambient and Diffuse";
}
else
{
return "Default";
}
}
template<class T>
void vtkMapperCreateColorTextureCoordinates(T* input, float* output,
vtkIdType num, int numComps,
int component, double* range)
{
double tmp, sum;
double k = 1.0 / (range[1]-range[0]);
vtkIdType i;
int j;
if (component < 0 || component >= numComps)
{
for (i = 0; i < num; ++i)
{
sum = 0;
for (j = 0; j < numComps; ++j)
{
tmp = static_cast<double>(*input);
sum += (tmp * tmp);
++input;
}
output[i] = k * (sqrt(sum) - range[0]);
if (output[i] > 1.0)
{
output[i] = 1.0;
}
if (output[i] < 0.0)
{
output[i] = 0.0;
}
}
}
else
{
input += component;
for (i = 0; i < num; ++i)
{
output[i] = k * (static_cast<double>(*input) - range[0]);
if (output[i] > 1.0)
{
output[i] = 1.0;
}
if (output[i] < 0.0)
{
output[i] = 0.0;
}
input = input + numComps;
}
}
}
#define ColorTextureMapSize 256
// a side effect of this is that this->ColorCoordinates and
// this->ColorTexture are set.
void vtkMapper::MapScalarsToTexture(vtkDataArray* scalars, double alpha)
{
double* range = this->LookupTable->GetRange();
// Get rid of vertex color array. Only texture or vertex coloring
// can be active at one time. The existence of the array is the
// signal to use that technique.
if ( this->Colors )
{
this->Colors->UnRegister(this);
this->Colors = 0;
}
// If the lookup table has changed, the recreate the color texture map.
// Set a new lookup table changes this->MTime.
if (this->ColorTextureMap == 0 ||
this->GetMTime() > this->ColorTextureMap->GetMTime() ||
this->LookupTable->GetMTime() > this->ColorTextureMap->GetMTime() ||
this->LookupTable->GetAlpha() != alpha)
{
this->LookupTable->SetAlpha(alpha);
if ( this->ColorTextureMap )
{
this->ColorTextureMap->UnRegister(this);
this->ColorTextureMap = 0;
}
// Get the texture map from the lookup table.
// Create a dummy ramp of scalars.
// In the future, we could extend vtkScalarsToColors.
double k = (range[1]-range[0]) / (ColorTextureMapSize-1);
vtkFloatArray* tmp = vtkFloatArray::New();
tmp->SetNumberOfTuples(ColorTextureMapSize);
float* ptr = tmp->GetPointer(0);
for (int i = 0; i < ColorTextureMapSize; ++i)
{
*ptr = range[0] + i * k;
++ptr;
}
this->ColorTextureMap = vtkImageData::New();
this->ColorTextureMap->SetExtent(0,ColorTextureMapSize-1,
0,0, 0,0);
this->ColorTextureMap->SetNumberOfScalarComponents(4);
this->ColorTextureMap->SetScalarTypeToUnsignedChar();
this->ColorTextureMap->GetPointData()->SetScalars(
this->LookupTable->MapScalars(tmp, this->ColorMode, 0));
// Do we need to delete the scalars?
this->ColorTextureMap->GetPointData()->GetScalars()->Delete();
// Consistent register and unregisters
this->ColorTextureMap->Register(this);
this->ColorTextureMap->Delete();
tmp->Delete();
}
// Create new coordinates if necessary.
// Need to compare lookup table incase the range has changed.
if (this->ColorCoordinates == 0 ||
this->GetMTime() > this->ColorCoordinates->GetMTime() ||
this->GetInput()->GetMTime() > this->ColorCoordinates->GetMTime() ||
this->LookupTable->GetMTime() > this->ColorCoordinates->GetMTime())
{
// Get rid of old colors
if ( this->ColorCoordinates )
{
this->ColorCoordinates->UnRegister(this);
this->ColorCoordinates = 0;
}
// Now create the color texture coordinates.
int numComps = scalars->GetNumberOfComponents();
void* input = scalars->GetVoidPointer(0);
vtkIdType num = scalars->GetNumberOfTuples();
this->ColorCoordinates = vtkFloatArray::New();
this->ColorCoordinates->SetNumberOfTuples(num);
float* output = this->ColorCoordinates->GetPointer(0);
int scalarComponent;
// Although I like the feature of applying magnitude to single component
// scalars, it is not how the old MapScalars for vertex coloring works.
if (this->LookupTable->GetVectorMode() == vtkScalarsToColors::MAGNITUDE &&
scalars->GetNumberOfComponents() > 1)
{
scalarComponent = -1;
}
else
{
scalarComponent = this->LookupTable->GetVectorComponent();
}
switch (scalars->GetDataType())
{
vtkTemplateMacro(
vtkMapperCreateColorTextureCoordinates(static_cast<VTK_TT*>(input),
output, num, numComps,
scalarComponent, range)
);
case VTK_BIT:
vtkErrorMacro("Cannot color by bit array.");
break;
default:
vtkErrorMacro(<< "Unknown input ScalarType");
return;
}
}
}
void vtkMapper::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os,indent);
if ( this->LookupTable )
{
os << indent << "Lookup Table:\n";
this->LookupTable->PrintSelf(os,indent.GetNextIndent());
}
else
{
os << indent << "Lookup Table: (none)\n";
}
os << indent << "Immediate Mode Rendering: "
<< (this->ImmediateModeRendering ? "On\n" : "Off\n");
os << indent << "Global Immediate Mode Rendering: " <<
(vtkMapperGlobalImmediateModeRendering ? "On\n" : "Off\n");
os << indent << "Scalar Visibility: "
<< (this->ScalarVisibility ? "On\n" : "Off\n");
os << indent << "Static: "
<< (this->Static ? "On\n" : "Off\n");
double *range = this->GetScalarRange();
os << indent << "Scalar Range: (" << range[0] << ", " << range[1] << ")\n";
os << indent << "UseLookupTableScalarRange: "
<< this->UseLookupTableScalarRange << "\n";
os << indent << "Color Mode: " << this->GetColorModeAsString() << endl;
os << indent << "InterpolateScalarsBeforeMapping: "
<< (this->InterpolateScalarsBeforeMapping ? "On\n" : "Off\n");
os << indent << "Scalar Mode: " << this->GetScalarModeAsString() << endl;
os << indent << "LM Color Mode: "
<< this->GetScalarMaterialModeAsString() << endl;
os << indent << "RenderTime: " << this->RenderTime << endl;
os << indent << "Resolve Coincident Topology: ";
if ( vtkMapperGlobalResolveCoincidentTopology == VTK_RESOLVE_OFF )
{
os << "Off" << endl;
}
else if ( vtkMapperGlobalResolveCoincidentTopology == VTK_RESOLVE_POLYGON_OFFSET )
{
os << "Polygon Offset" << endl;
}
else
{
os << "Shift Z-Buffer" << endl;
}
}