dox/Common/DataModel/vtkColor.h

Go to the documentation of this file.

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

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

#include "vtkTuple.h"
#include "vtkObject.h" // for legacy macros

// .NAME vtkColor3 - templated base type for storage of 3 component colors.
//
template<typename T>
class vtkColor3 : public vtkTuple<T, 3>
{
public:
  vtkColor3()
  {
  }

  explicit vtkColor3(const T& scalar) : vtkTuple<T, 3>(scalar)
  {
  }

  explicit vtkColor3(const T* init) : vtkTuple<T, 3>(init)
  {
  }

  vtkColor3(const T& red, const T& green, const T& blue)
  {
    this->Data[0] = red;
    this->Data[1] = green;
    this->Data[2] = blue;
  }


  void Set(const T& red, const T& green, const T& blue)
  {
    this->Data[0] = red;
    this->Data[1] = green;
    this->Data[2] = blue;
  }

  void SetRed(const T& red) { this->Data[0] = red; }

  const T& GetRed() const { return this->Data[0]; }

  void SetGreen(const T& green) { this->Data[1] = green; }

  const T& GetGreen() const { return this->Data[1]; }

  void SetBlue(const T& blue) { this->Data[2] = blue; }

  const T& GetBlue() const { return this->Data[2]; }

  VTK_LEGACY(const T& Red() const);

  VTK_LEGACY(const T& Green() const);


  VTK_LEGACY(const T& Blue() const);
};

// .NAME vtkColor4 - templated base type for storage of 4 component colors.
//
template<typename T>
class vtkColor4 : public vtkTuple<T, 4>
{
public:
  vtkColor4()
  {
  }

  explicit vtkColor4(const T& scalar) : vtkTuple<T, 4>(scalar)
  {
  }

  explicit vtkColor4(const T* init) : vtkTuple<T, 4>(init)
  {
  }

  vtkColor4(const T& red, const T& green, const T& blue, const T& alpha)
  {
    this->Data[0] = red;
    this->Data[1] = green;
    this->Data[2] = blue;
    this->Data[3] = alpha;
  }


  void Set(const T& red, const T& green, const T& blue)
  {
    this->Data[0] = red;
    this->Data[1] = green;
    this->Data[2] = blue;
  }


  void Set(const T& red, const T& green, const T& blue, const T& alpha)
  {
    this->Data[0] = red;
    this->Data[1] = green;
    this->Data[2] = blue;
    this->Data[3] = alpha;
  }

  void SetRed(const T& red) { this->Data[0] = red; }

  const T& GetRed() const { return this->Data[0]; }

  void SetGreen(const T& green) { this->Data[1] = green; }

  const T& GetGreen() const { return this->Data[1]; }

  void SetBlue(const T& blue) { this->Data[2] = blue; }

  const T& GetBlue() const { return this->Data[2]; }

  void SetAlpha(const T& alpha) { this->Data[3] = alpha; }

  const T& GetAlpha() const { return this->Data[3]; }

  VTK_LEGACY(const T& Red() const);

  VTK_LEGACY(const T& Green() const);

  VTK_LEGACY(const T& Blue() const);


  VTK_LEGACY(const T& Alpha() const);
};


class vtkColor3ub : public vtkColor3<unsigned char>
{
public:
  vtkColor3ub() {}
  explicit vtkColor3ub(unsigned char scalar)
    : vtkColor3<unsigned char>(scalar) {}
  explicit vtkColor3ub(const unsigned char* init)
    : vtkColor3<unsigned char>(init) {}


  explicit vtkColor3ub(int hexSigned)
  {
    unsigned int hex = static_cast<unsigned int>(hexSigned);
    this->Data[2] = hex & 0xff;
    hex >>= 8;
    this->Data[1] = hex & 0xff;
    hex >>= 8;
    this->Data[0] = hex & 0xff;
  }

  vtkColor3ub(unsigned char r, unsigned char g, unsigned char b)
    : vtkColor3<unsigned char>(r, g, b) {}
};

class vtkColor3f : public vtkColor3<float>
{
public:
  vtkColor3f() {}
  explicit vtkColor3f(float scalar) : vtkColor3<float>(scalar) {}
  explicit vtkColor3f(const float* init) : vtkColor3<float>(init) {}
  vtkColor3f(float r, float g, float b) : vtkColor3<float>(r, g, b) {}
};

class vtkColor3d : public vtkColor3<double>
{
public:
  vtkColor3d() {}
  explicit vtkColor3d(double scalar) : vtkColor3<double>(scalar) {}
  explicit vtkColor3d(const double* init) : vtkColor3<double>(init) {}
  vtkColor3d(double r, double g, double b) : vtkColor3<double>(r, g, b) {}
};

class vtkColor4ub : public vtkColor4<unsigned char>
{
public:
  vtkColor4ub() {}
  explicit vtkColor4ub(unsigned char scalar)
    : vtkColor4<unsigned char>(scalar) {}
  explicit vtkColor4ub(const unsigned char* init)
    : vtkColor4<unsigned char>(init) {}


  explicit vtkColor4ub(int hexSigned)
  {
    unsigned int hex = static_cast<unsigned int>(hexSigned);
    this->Data[3] = hex & 0xff;
    hex >>= 8;
    this->Data[2] = hex & 0xff;
    hex >>= 8;
    this->Data[1] = hex & 0xff;
    hex >>= 8;
    this->Data[0] = hex & 0xff;
  }

  vtkColor4ub(unsigned char r, unsigned char g,
              unsigned char b, unsigned char a = 255)
                : vtkColor4<unsigned char>(r, g, b, a) {}
  vtkColor4ub(const vtkColor3ub &c) :
    vtkColor4<unsigned char>(c[0], c[1], c[2], 255) {}
};

class vtkColor4f : public vtkColor4<float>
{
public:
  vtkColor4f() {}
  explicit vtkColor4f(float scalar) : vtkColor4<float>(scalar) {}
  explicit vtkColor4f(const float* init) : vtkColor4<float>(init) {}
  vtkColor4f(float r, float g, float b, float a = 1.0)
    : vtkColor4<float>(r, g, b, a) {}
};

class vtkColor4d : public vtkColor4<double>
{
public:
  vtkColor4d() {}
  explicit vtkColor4d(double scalar) : vtkColor4<double>(scalar) {}
  explicit vtkColor4d(const double* init) : vtkColor4<double>(init) {}
  vtkColor4d(double r, double g, double b, double a = 1.0)
    : vtkColor4<double>(r, g, b, a) {}
};

#ifndef VTK_LEGACY_REMOVE
template<typename T>
const T& vtkColor3<T>::Red() const
{
  VTK_LEGACY_REPLACED_BODY(vtkColor3::Red, "VTK 6.0", vtkColor3::GetRed);
  return this->GetRed();
}

template<typename T>
const T& vtkColor3<T>::Green() const
{
  VTK_LEGACY_REPLACED_BODY(vtkColor3::Green, "VTK 6.0", vtkColor3::GetGreen);
  return this->GetGreen();
}

template<typename T>
const T& vtkColor3<T>::Blue() const
{
  VTK_LEGACY_REPLACED_BODY(vtkColor3::Blue, "VTK 6.0", vtkColor3::GetBlue);
  return this->GetBlue();
}

template<typename T>
const T& vtkColor4<T>::Red() const
{
  VTK_LEGACY_REPLACED_BODY(vtkColor4::Red, "VTK 6.0", vtkColor4::GetRed);
  return this->GetRed();
}

template<typename T>
const T& vtkColor4<T>::Green() const
{
  VTK_LEGACY_REPLACED_BODY(vtkColor4::Green, "VTK 6.0", vtkColor4::GetGreen);
  return this->GetGreen();
}

template<typename T>
const T& vtkColor4<T>::Blue() const
{
  VTK_LEGACY_REPLACED_BODY(vtkColor4::Blue, "VTK 6.0", vtkColor4::GetBlue);
  return this->GetBlue();
}

template<typename T>
const T& vtkColor4<T>::Alpha() const
{
  VTK_LEGACY_REPLACED_BODY(vtkColor4::Alpha, "VTK 6.0", vtkColor4::GetAlpha);
  return this->GetAlpha();
}
#endif // VTK_LEGACY_REMOVE

#endif // __vtkColor_h
// VTK-HeaderTest-Exclude: vtkColor.h