class TColor: public TNamed

The color creation and management class

• Introduction
• Basic colors
• The color wheel
• Bright and dark colors
• Gray scale view of of canvas with colors
• Color palettes

Introduction

Colors are defined by their Red, Green and blue components, simply called the RGB components. The colors are also known by the Hue, Light and saturation components also known as the HLS components. When a new color is created the components of both color systems are computed.

At initialization time, a table of colors is generated. An existing color can be retrieve thanks to its index:

   TColor *color = gROOT->GetColor(10);

Then it can be manipulated. For example its RGB components can be modified:

   color->SetRGB(0.1, 0.2, 0.3);

A new color can be created the following way:

   Int_t ci = 1756; // color index
   TColor *color = new TColor(ci, 0.1, 0.2, 0.3);

Two sets of colors are initialized;

• The basic colors: colors with index from 0 to 50.
• The color wheel: colors with indices from 300 to 1000.

Basic colors

The following image displays the 50 basic colors.

The color wheel

The wheel contains the recommended 216 colors to be used in web applications. C The colors in the color wheel are created by TColor::CreateColorWheel.

Using this color set for your text, background or graphics will give your application a consistent appearance across different platforms and browsers.

Colors are grouped by hue, the aspect most important in human perception. Touching color chips have the same hue, but with different brightness and vividness.

Colors of slightly different hues clash. If you intend to display colors of the same hue together, you should pick them from the same group.

Each color chip is identified by a mnemonic (e.g. kYellow) and a number. The keywords, kRed, kBlue, kYellow, kPink, etc are defined in the header file Rtypes.h that is included in all ROOT other header files. It is better to use these keywords in user code instead of hardcoded color numbers, e.g.:

   myObject.SetFillColor(kRed);
   myObject.SetFillColor(kYellow-10);
   myLine.SetLineColor(kMagenta+2);

Bright and dark colors

The dark and bright color are used to give 3-D effects when drawing various boxes (see TWbox, TPave, TPaveText, TPaveLabel, etc).

• The Dark colors have an index = color_index+100
• The Bright colors have an index = color_index+150
• Pointers to the dark and bright colors can be retrieved via the TColor static functions:

        TColor *dark   = TColor::GetColorDark(color_index);
        TColor *bright = TColor::GetColorBright(color_index);
     

Gray scale view of of canvas with colors

One can toggle between a grayscale preview and the regular colored mode using TCanvas::SetGrayscale(). Note that in grayscale mode, access via RGB will return grayscale values according to ITU standards (and close to b&w printer grayscales), while access via HLS returns de-saturated grayscales. The image below shows the ROOT color wheel in grayscale mode.

Color palettes

It is often very useful to represent a variable with a color map. The concept of "color palette" allows to do that. One color palette is active at any time. This "current palette" is set using:

gStyle->SetPalette(...);

This function has two parameters: the number of colors in the palette and an array of containing the indices of colors in the pallette. The following small example demonstrates how to define and use the color palette:

To define more a complexe palette with a continous gradient of color, one should use the static function TColor::CreateGradientColorTable(). The following example demostrates how to proceed:

The function TColor::CreateGradientColorTable() performs automatically a call to gStyle->SetPalette(). So there is not need to add one.

After a call to TColor::CreateGradientColorTable() it is sometimes useful to store the newly create palette for further use. In particular, it is recomended to do if one wants to switch between several user define palettes. To store a palette in an array it is enough to do:

   Int_t MyPalette[100];
   Double_t r[]    = {0., 0.0, 1.0, 1.0, 1.0};
   Double_t g[]    = {0., 0.0, 0.0, 1.0, 1.0};
   Double_t b[]    = {0., 1.0, 0.0, 0.0, 1.0};
   Double_t stop[] = {0., .25, .50, .75, 1.0};
   Int_t FI = TColor::CreateGradientColorTable(5, stop, r, g, b, 100);
   for (int i=0;i<100;i++) MyPalette[i] = FI+i;

Later on to reuse the palette MyPalette it will be enough to do

   gStyle->SetPalette(100, MyPalette);

As only one palette is active, one need to use TExec to be able to display plots using differents palettes on the same pad. The following macro illustrate this feature.