VTK
vtkScalarsToColors.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkScalarsToColors.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
52 #ifndef vtkScalarsToColors_h
53 #define vtkScalarsToColors_h
54 
55 #include "vtkCommonCoreModule.h" // For export macro
56 #include "vtkVariant.h" // Set/get annotation methods require variants.
57 #include "vtkObject.h"
58 
59 class vtkAbstractArray;
60 class vtkDataArray;
62 class vtkAbstractArray;
63 class vtkStringArray;
64 
65 
66 class VTKCOMMONCORE_EXPORT vtkScalarsToColors : public vtkObject
67 {
68 public:
70  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
71  static vtkScalarsToColors *New();
72 
77  virtual int IsOpaque();
78 
83  virtual void Build() {}
84 
86 
89  virtual double *GetRange();
90  virtual void SetRange(double min, double max);
91  void SetRange(double rng[2])
92  {this->SetRange(rng[0],rng[1]);}
94 
99  virtual unsigned char *MapValue(double v);
100 
105  virtual void GetColor(double v, double rgb[3]);
106 
111  double *GetColor(double v)
112  {this->GetColor(v,this->RGB); return this->RGB;}
113 
119  virtual double GetOpacity(double v);
120 
126  double GetLuminance(double x)
127  {double rgb[3]; this->GetColor(x,rgb);
128  return static_cast<double>(rgb[0]*0.30 + rgb[1]*0.59 + rgb[2]*0.11);}
129 
131 
137  virtual void SetAlpha(double alpha);
138  vtkGetMacro(Alpha,double);
140 
142 
159  virtual vtkUnsignedCharArray *MapScalars(vtkDataArray *scalars, int colorMode,
160  int component);
161  virtual vtkUnsignedCharArray *MapScalars(vtkAbstractArray *scalars, int colorMode,
162  int component);
164 
166 
171  vtkSetMacro(VectorMode, int);
172  vtkGetMacro(VectorMode, int);
173  void SetVectorModeToMagnitude();
174  void SetVectorModeToComponent();
175  void SetVectorModeToRGBColors();
177 
178  enum VectorModes {
179  MAGNITUDE=0,
180  COMPONENT=1,
181  RGBCOLORS=2
182  };
183 
185 
189  vtkSetMacro(VectorComponent, int);
190  vtkGetMacro(VectorComponent, int);
192 
194 
201  vtkSetMacro(VectorSize, int);
202  vtkGetMacro(VectorSize, int);
204 
212  void MapVectorsThroughTable(void *input, unsigned char *output,
213  int inputDataType, int numberOfValues,
214  int inputIncrement, int outputFormat,
215  int vectorComponent, int vectorSize);
216  void MapVectorsThroughTable(void *input, unsigned char *output,
217  int inputDataType, int numberOfValues,
218  int inputIncrement, int outputFormat)
219  { this->MapVectorsThroughTable(input, output, inputDataType, numberOfValues,
220  inputIncrement, outputFormat, -1, -1); }
221 
230  void MapScalarsThroughTable(vtkDataArray *scalars,
231  unsigned char *output,
232  int outputFormat);
234  unsigned char *output)
235  {this->MapScalarsThroughTable(scalars,output,VTK_RGBA);}
236  void MapScalarsThroughTable(void *input, unsigned char *output,
237  int inputDataType, int numberOfValues,
238  int inputIncrement,
239  int outputFormat)
240  {this->MapScalarsThroughTable2(input, output, inputDataType,
241  numberOfValues, inputIncrement, outputFormat);}
242 
248  virtual void MapScalarsThroughTable2(void *input, unsigned char *output,
249  int inputDataType, int numberOfValues,
250  int inputIncrement,
251  int outputFormat);
252 
256  virtual void DeepCopy(vtkScalarsToColors *o);
257 
262  virtual int UsingLogScale()
263  { return 0; }
264 
268  virtual vtkIdType GetNumberOfAvailableColors();
269 
271 
284  virtual void SetAnnotations( vtkAbstractArray* values, vtkStringArray* annotations );
285  vtkGetObjectMacro(AnnotatedValues,vtkAbstractArray);
286  vtkGetObjectMacro(Annotations,vtkStringArray);
288 
293  virtual vtkIdType SetAnnotation(vtkVariant value, vtkStdString annotation);
294 
299  virtual vtkIdType SetAnnotation(vtkStdString value, vtkStdString annotation);
300 
304  vtkIdType GetNumberOfAnnotatedValues();
305 
309  vtkVariant GetAnnotatedValue(vtkIdType idx);
310 
314  vtkStdString GetAnnotation(vtkIdType idx);
315 
319  virtual void GetAnnotationColor(const vtkVariant& val, double rgba[4]);
320 
324  vtkIdType GetAnnotatedValueIndex( vtkVariant val );
325 
331  vtkIdType GetAnnotatedValueIndexInternal(vtkVariant& val);
332 
345  virtual void GetIndexedColor(vtkIdType i, double rgba[4]);
346 
353  virtual bool RemoveAnnotation(vtkVariant value);
354 
358  virtual void ResetAnnotations();
359 
361 
369  vtkSetMacro(IndexedLookup,int);
370  vtkGetMacro(IndexedLookup,int);
371  vtkBooleanMacro(IndexedLookup,int);
373 
374 
376 
381  template<typename T> static
382  unsigned char ColorToUChar(T t)
383  {
384  return t;
385  }
386  template<typename T> static
387  void ColorToUChar(T t, unsigned char* dest)
388  {
389  *dest = ColorToUChar(t);
390  }
392 
393 
394 
395 protected:
397  ~vtkScalarsToColors() VTK_OVERRIDE;
398 
410  void MapColorsToColors(void *input, unsigned char *output,
411  int inputDataType, int numberOfValues,
412  int numberOfComponents, int vectorSize,
413  int outputFormat);
414 
420  vtkUnsignedCharArray *ConvertToRGBA(
421  vtkDataArray *colors, int numComp, int numTuples);
422 
423 
428  void MapVectorsToMagnitude(void *input, double *output,
429  int inputDataType, int numberOfValues,
430  int numberOfComponents, int vectorSize);
431 
436  virtual vtkIdType CheckForAnnotatedValue( vtkVariant value );
437 
442  virtual void UpdateAnnotatedValueMap();
443 
444  // Annotations of specific values.
445  vtkAbstractArray* AnnotatedValues;
446  vtkStringArray* Annotations;
447 
448  class vtkInternalAnnotatedValueMap;
449  vtkInternalAnnotatedValueMap* AnnotatedValueMap;
450 
451  int IndexedLookup;
452 
453  double Alpha;
454 
455  // How to map arrays with multiple components.
456  int VectorMode;
457  int VectorComponent;
458  int VectorSize;
459 
460  // Obsolete, kept so subclasses will still compile
461  int UseMagnitude;
462 
463  unsigned char RGBABytes[4];
464 
465 private:
466  double RGB[3];
467  double InputRange[2];
468 
469  vtkScalarsToColors(const vtkScalarsToColors&) VTK_DELETE_FUNCTION;
470  void operator=(const vtkScalarsToColors&) VTK_DELETE_FUNCTION;
471 };
472 
474 
479 template<> inline
480 unsigned char vtkScalarsToColors::ColorToUChar(double t)
481 {
482  return static_cast<unsigned char>(t*255 + 0.5);
483 }
484 template<> inline
485 unsigned char vtkScalarsToColors::ColorToUChar(float t)
486 {
487  return static_cast<unsigned char>(t*255 + 0.5);
488 }
490 
491 
492 #endif
void MapScalarsThroughTable(vtkDataArray *scalars, unsigned char *output)
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:47
static void ColorToUChar(T t, unsigned char *dest)
Converts a color from numeric type T to uchar.
abstract base class for most VTK objects
Definition: vtkObject.h:59
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
Abstract superclass for all arrays.
void SetRange(double rng[2])
Sets/Gets the range of scalars that will be mapped.
void DeepCopy(vtkPistonReference *self, vtkPistonReference *other)
a vtkAbstractArray subclass for strings
int vtkIdType
Definition: vtkType.h:287
A atomic type representing the union of many types.
Definition: vtkVariant.h:75
Superclass for mapping scalar values to colors.
a simple class to control print indentation
Definition: vtkIndent.h:39
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:54
static unsigned char ColorToUChar(T t)
Converts a color from numeric type T to uchar.
void MapScalarsThroughTable(void *input, unsigned char *output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat)
vtkSetMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
dynamic, self-adjusting array of unsigned char
#define VTK_RGBA
double * GetColor(double v)
Map one value through the lookup table and return the color as an RGB array of doubles between 0 and ...
void MapVectorsThroughTable(void *input, unsigned char *output, int inputDataType, int numberOfValues, int inputIncrement, int outputFormat)
virtual void Build()
Perform any processing required (if any) before processing scalars.
vtkBooleanMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on...
#define max(a, b)
double GetLuminance(double x)
Map one value through the lookup table and return the luminance 0.3*red + 0.59*green + 0...
virtual int UsingLogScale()
This should return 1 is the subclass is using log scale for mapping scalars to colors.