Logo ROOT  
Reference Guide
TColor.cxx
Go to the documentation of this file.
1// @(#)root/base:$Id$
2// Author: Rene Brun 12/12/94
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include "Riostream.h"
13#include "TROOT.h"
14#include "TColor.h"
15#include "TObjArray.h"
16#include "TArrayI.h"
17#include "TArrayD.h"
18#include "TVirtualPad.h"
19#include "TVirtualX.h"
20#include "TError.h"
21#include "TMathBase.h"
22#include "TApplication.h"
23#include <algorithm>
24#include <cmath>
25
27
28namespace {
29 static Bool_t& TColor__GrayScaleMode() {
30 static Bool_t grayScaleMode;
31 return grayScaleMode;
32 }
33 static TArrayI& TColor__Palette() {
34 static TArrayI globalPalette(0);
35 return globalPalette;
36 }
37 static TArrayD& TColor__PalettesList() {
38 static TArrayD globalPalettesList(0);
39 return globalPalettesList;
40 }
41}
42
43static Int_t gHighestColorIndex = 0; ///< Highest color index defined
44static Float_t gColorThreshold = -1.; ///< Color threshold used by GetColor
45static Int_t gDefinedColors = 0; ///< Number of defined colors.
46static Int_t gLastDefinedColors = 649; ///< Previous number of defined colors
47
48#define fgGrayscaleMode TColor__GrayScaleMode()
49#define fgPalette TColor__Palette()
50#define fgPalettesList TColor__PalettesList()
51
52using std::floor;
53
54/** \class TColor
55\ingroup Base
56\ingroup GraphicsAtt
57
58The color creation and management class.
59
60 - [Introduction](#C00)
61 - [Basic colors](#C01)
62 - [The color wheel](#C02)
63 - [Bright and dark colors](#C03)
64 - [Gray scale view of of canvas with colors](#C04)
65 - [Color palettes](#C05)
66 - [High quality predefined palettes](#C06)
67 - [Palette inversion](#C061)
68 - [Color transparency](#C07)
69
70## <a name="C00"></a> Introduction
71
72Colors are defined by their red, green and blue components, simply called the
73RGB components. The colors are also known by the hue, light and saturation
74components also known as the HLS components. When a new color is created the
75components of both color systems are computed.
76
77At initialization time, a table of colors is generated. An existing color can
78be retrieved by its index:
79
80~~~ {.cpp}
81 TColor *color = gROOT->GetColor(10);
82~~~
83
84Then it can be manipulated. For example its RGB components can be modified:
85
86~~~ {.cpp}
87 color->SetRGB(0.1, 0.2, 0.3);
88~~~
89
90A new color can be created the following way:
91
92~~~ {.cpp}
93 Int_t ci = 1756; // color index
94 TColor *color = new TColor(ci, 0.1, 0.2, 0.3);
95~~~
96
97\since **6.07/07:**
98TColor::GetFreeColorIndex() allows to make sure the new color is created with an
99unused color index:
100
101~~~ {.cpp}
102 Int_t ci = TColor::GetFreeColorIndex();
103 TColor *color = new TColor(ci, 0.1, 0.2, 0.3);
104~~~
105
106Two sets of colors are initialized;
107
108 - The basic colors: colors with index from 0 to 50.
109 - The color wheel: colors with indices from 300 to 1000.
110
111## <a name="C01"></a> Basic colors
112The following image displays the 50 basic colors.
113
114Begin_Macro(source)
115{
116 TCanvas *c = new TCanvas("c","Fill Area colors",0,0,500,200);
117 c->DrawColorTable();
118 return c;
119}
120End_Macro
121
122## <a name="C02"></a> The color wheel
123The wheel contains the recommended 216 colors to be used in web applications.
124
125The colors in the color wheel are created by `TColor::CreateColorWheel`.
126
127Using this color set for your text, background or graphics will give your
128application a consistent appearance across different platforms and browsers.
129
130Colors are grouped by hue, the aspect most important in human perception.
131Touching color chips have the same hue, but with different brightness and
132vividness.
133
134Colors of slightly different hues clash. If you intend to display
135colors of the same hue together, you should pick them from the same group.
136
137Each color chip is identified by a mnemonic (e.g. kYellow) and a number.
138The keywords, kRed, kBlue, kYellow, kPink, etc are defined in the header file
139Rtypes.h that is included in all ROOT other header files. It is better
140to use these keywords in user code instead of hardcoded color numbers, e.g.:
141
142~~~ {.cpp}
143 myObject.SetFillColor(kRed);
144 myObject.SetFillColor(kYellow-10);
145 myLine.SetLineColor(kMagenta+2);
146~~~
147
148Begin_Macro(source)
149{
150 TColorWheel *w = new TColorWheel();
151 cw = new TCanvas("cw","cw",0,0,400,400);
152 w->SetCanvas(cw);
153 w->Draw();
154}
155End_Macro
156
157The complete list of predefined color names is the following:
158
159~~~ {.cpp}
160kWhite = 0, kBlack = 1, kGray = 920, kRed = 632, kGreen = 416,
161kBlue = 600, kYellow = 400, kMagenta = 616, kCyan = 432, kOrange = 800,
162kSpring = 820, kTeal = 840, kAzure = 860, kViolet = 880, kPink = 900
163~~~
164
165Note the special role of color `kWhite` (color number 0). It is the default
166background color also. For instance in a PDF or PS files (as paper is usually white)
167it is simply not painted. To have a white color behaving like the other color the
168simplest is to define an other white color not attached to the color index 0:
169
170~~~ {.cpp}
171 Int_t ci = TColor::GetFreeColorIndex();
172 TColor *color = new TColor(ci, 1., 1., 1.);
173~~~
174
175## <a name="C03"></a> Bright and dark colors
176The dark and bright color are used to give 3-D effects when drawing various
177boxes (see TWbox, TPave, TPaveText, TPaveLabel, etc).
178
179 - The dark colors have an index = color_index+100
180 - The bright colors have an index = color_index+150
181 - Two static functions return the bright and dark color number
182 corresponding to a color index. If the bright or dark color does not
183 exist, they are created:
184 ~~~ {.cpp}
185 Int_t dark = TColor::GetColorDark(color_index);
186 Int_t bright = TColor::GetColorBright(color_index);
187 ~~~
188
189## <a name="C04"></a> Grayscale view of of canvas with colors
190One can toggle between a grayscale preview and the regular colored mode using
191`TCanvas::SetGrayscale()`. Note that in grayscale mode, access via RGB
192will return grayscale values according to ITU standards (and close to b&w
193printer gray-scales), while access via HLS returns de-saturated gray-scales. The
194image below shows the ROOT color wheel in grayscale mode.
195
196Begin_Macro(source)
197{
198 TColorWheel *w = new TColorWheel();
199 cw = new TCanvas("cw","cw",0,0,400,400);
200 cw->GetCanvas()->SetGrayscale();
201 w->SetCanvas(cw);
202 w->Draw();
203}
204End_Macro
205
206## <a name="C05"></a> Color palettes
207It is often very useful to represent a variable with a color map. The concept
208of "color palette" allows to do that. One color palette is active at any time.
209This "current palette" is set using:
210
211~~~ {.cpp}
212gStyle->SetPalette(...);
213~~~
214
215This function has two parameters: the number of colors in the palette and an
216array of containing the indices of colors in the palette. The following small
217example demonstrates how to define and use the color palette:
218
219Begin_Macro(source)
220{
221 TCanvas *c1 = new TCanvas("c1","c1",0,0,600,400);
222 TF2 *f1 = new TF2("f1","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",1,3,1,3);
223 Int_t palette[5];
224 palette[0] = 15;
225 palette[1] = 20;
226 palette[2] = 23;
227 palette[3] = 30;
228 palette[4] = 32;
229 gStyle->SetPalette(5,palette);
230 f1->Draw("colz");
231 return c1;
232}
233End_Macro
234
235 To define more a complex palette with a continuous gradient of color, one
236should use the static function `TColor::CreateGradientColorTable()`.
237The following example demonstrates how to proceed:
238
239Begin_Macro(source)
240{
241 TCanvas *c2 = new TCanvas("c2","c2",0,0,600,400);
242 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",1,3,1,3);
243 const Int_t Number = 3;
244 Double_t Red[Number] = { 1.00, 0.00, 0.00};
245 Double_t Green[Number] = { 0.00, 1.00, 0.00};
246 Double_t Blue[Number] = { 1.00, 0.00, 1.00};
247 Double_t Length[Number] = { 0.00, 0.50, 1.00 };
248 Int_t nb=50;
249 TColor::CreateGradientColorTable(Number,Length,Red,Green,Blue,nb);
250 f2->SetContour(nb);
251 f2->SetLineWidth(1);
252 f2->SetLineColor(kBlack);
253 f2->Draw("surf1z");
254 return c2;
255}
256End_Macro
257
258The function `TColor::CreateGradientColorTable()` automatically
259calls `gStyle->SetPalette()`, so there is not need to add one.
260
261After a call to `TColor::CreateGradientColorTable()` it is sometimes
262useful to store the newly create palette for further use. In particular, it is
263recommended to do if one wants to switch between several user define palettes.
264To store a palette in an array it is enough to do:
265
266~~~ {.cpp}
267 Int_t MyPalette[100];
268 Double_t Red[] = {0., 0.0, 1.0, 1.0, 1.0};
269 Double_t Green[] = {0., 0.0, 0.0, 1.0, 1.0};
270 Double_t Blue[] = {0., 1.0, 0.0, 0.0, 1.0};
271 Double_t Length[] = {0., .25, .50, .75, 1.0};
272 Int_t FI = TColor::CreateGradientColorTable(5, Length, Red, Green, Blue, 100);
273 for (int i=0;i<100;i++) MyPalette[i] = FI+i;
274~~~
275
276Later on to reuse the palette `MyPalette` it will be enough to do
277
278~~~ {.cpp}
279 gStyle->SetPalette(100, MyPalette);
280~~~
281
282As only one palette is active, one need to use `TExec` to be able to
283display plots using different palettes on the same pad.
284The tutorial multipalette.C illustrates this feature.
285
286Begin_Macro(source)
287../../../tutorials/graphs/multipalette.C
288End_Macro
289
290## <a name="C06"></a> High quality predefined palettes
291\since **6.04:**
29262 high quality palettes are predefined with 255 colors each.
293Despite the [disadvantages of the Rainbow color map](https://root.cern.ch/rainbow-color-map),
294it was kept in the list of predefined color maps.
295These palettes can be accessed "by name" with `gStyle->SetPalette(num)`.
296`num` can be taken within the following enum:
297
298~~~ {.cpp}
299kDeepSea=51, kGreyScale=52, kDarkBodyRadiator=53,
300kBlueYellow= 54, kRainBow=55, kInvertedDarkBodyRadiator=56,
301kBird=57, kCubehelix=58, kGreenRedViolet=59,
302kBlueRedYellow=60, kOcean=61, kColorPrintableOnGrey=62,
303kAlpine=63, kAquamarine=64, kArmy=65,
304kAtlantic=66, kAurora=67, kAvocado=68,
305kBeach=69, kBlackBody=70, kBlueGreenYellow=71,
306kBrownCyan=72, kCMYK=73, kCandy=74,
307kCherry=75, kCoffee=76, kDarkRainBow=77,
308kDarkTerrain=78, kFall=79, kFruitPunch=80,
309kFuchsia=81, kGreyYellow=82, kGreenBrownTerrain=83,
310kGreenPink=84, kIsland=85, kLake=86,
311kLightTemperature=87, kLightTerrain=88, kMint=89,
312kNeon=90, kPastel=91, kPearl=92,
313kPigeon=93, kPlum=94, kRedBlue=95,
314kRose=96, kRust=97, kSandyTerrain=98,
315kSienna=99, kSolar=100, kSouthWest=101,
316kStarryNight=102, kSunset=103, kTemperatureMap=104,
317kThermometer=105, kValentine=106, kVisibleSpectrum=107,
318kWaterMelon=108, kCool=109, kCopper=110,
319kGistEarth=111, kViridis=112, kCividis=113
320~~~
321
322<table border=0>
323<tr><td>
324Begin_Macro
325{
326 c = new TCanvas("c","c",0,0,300,300);
327 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
328 f2->SetContour(99); gStyle->SetPalette(kDeepSea);
329 f2->Draw("surf2Z"); f2->SetTitle("kDeepSea");
330}
331End_Macro
332</td><td>
333Begin_Macro
334{
335 c = new TCanvas("c","c",0,0,300,300);
336 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
337 f2->SetContour(99); gStyle->SetPalette(kGreyScale);
338 f2->Draw("surf2Z"); f2->SetTitle("kGreyScale");
339}
340End_Macro
341</td><td>
342Begin_Macro
343{
344 c = new TCanvas("c","c",0,0,300,300);
345 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
346 f2->SetContour(99); gStyle->SetPalette(kDarkBodyRadiator);
347 f2->Draw("surf2Z"); f2->SetTitle("kDarkBodyRadiator");
348}
349End_Macro
350</td></tr>
351<tr><td>
352Begin_Macro
353{
354 c = new TCanvas("c","c",0,0,300,300);
355 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
356 f2->SetContour(99); gStyle->SetPalette(kBlueYellow);
357 f2->Draw("surf2Z"); f2->SetTitle("kBlueYellow");
358}
359End_Macro
360</td><td>
361Begin_Macro
362{
363 c = new TCanvas("c","c",0,0,300,300);
364 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
365 f2->SetContour(99); gStyle->SetPalette(kRainBow);
366 f2->Draw("surf2Z"); f2->SetTitle("kRainBow");
367}
368End_Macro
369</td><td>
370Begin_Macro
371{
372 c = new TCanvas("c","c",0,0,300,300);
373 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
374 f2->SetContour(99); gStyle->SetPalette(kInvertedDarkBodyRadiator);
375 f2->Draw("surf2Z"); f2->SetTitle("kInvertedDarkBodyRadiator");
376}
377End_Macro
378</td></tr>
379<tr><td>
380Begin_Macro
381{
382 c = new TCanvas("c","c",0,0,300,300);
383 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
384 f2->SetContour(99); gStyle->SetPalette(kBird);
385 f2->Draw("surf2Z"); f2->SetTitle("kBird (default)");
386}
387End_Macro
388</td><td>
389Begin_Macro
390{
391 c = new TCanvas("c","c",0,0,300,300);
392 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
393 f2->SetContour(99); gStyle->SetPalette(kCubehelix);
394 f2->Draw("surf2Z"); f2->SetTitle("kCubehelix");
395}
396End_Macro
397</td><td>
398Begin_Macro
399{
400 c = new TCanvas("c","c",0,0,300,300);
401 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
402 f2->SetContour(99); gStyle->SetPalette(kGreenRedViolet);
403 f2->Draw("surf2Z"); f2->SetTitle("kGreenRedViolet");
404}
405End_Macro
406</td></tr>
407<tr><td>
408Begin_Macro
409{
410 c = new TCanvas("c","c",0,0,300,300);
411 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
412 f2->SetContour(99); gStyle->SetPalette(kBlueRedYellow);
413 f2->Draw("surf2Z"); f2->SetTitle("kBlueRedYellow");
414}
415End_Macro
416</td><td>
417Begin_Macro
418{
419 c = new TCanvas("c","c",0,0,300,300);
420 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
421 f2->SetContour(99); gStyle->SetPalette(kOcean);
422 f2->Draw("surf2Z"); f2->SetTitle("kOcean");
423}
424End_Macro
425</td><td>
426Begin_Macro
427{
428 c = new TCanvas("c","c",0,0,300,300);
429 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
430 f2->SetContour(99); gStyle->SetPalette(kColorPrintableOnGrey);
431 f2->Draw("surf2Z"); f2->SetTitle("kColorPrintableOnGrey");
432}
433End_Macro
434</td></tr>
435<tr><td>
436Begin_Macro
437{
438 c = new TCanvas("c","c",0,0,300,300);
439 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
440 f2->SetContour(99); gStyle->SetPalette(kAlpine);
441 f2->Draw("surf2Z"); f2->SetTitle("kAlpine");
442}
443End_Macro
444</td><td>
445Begin_Macro
446{
447 c = new TCanvas("c","c",0,0,300,300);
448 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
449 f2->SetContour(99); gStyle->SetPalette(kAquamarine);
450 f2->Draw("surf2Z"); f2->SetTitle("kAquamarine");
451}
452End_Macro
453</td><td>
454Begin_Macro
455{
456 c = new TCanvas("c","c",0,0,300,300);
457 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
458 f2->SetContour(99); gStyle->SetPalette(kArmy);
459 f2->Draw("surf2Z"); f2->SetTitle("kArmy");
460}
461End_Macro
462</td></tr>
463<tr><td>
464Begin_Macro
465{
466 c = new TCanvas("c","c",0,0,300,300);
467 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
468 f2->SetContour(99); gStyle->SetPalette(kAtlantic);
469 f2->Draw("surf2Z"); f2->SetTitle("kAtlantic");
470}
471End_Macro
472</td><td>
473Begin_Macro
474{
475 c = new TCanvas("c","c",0,0,300,300);
476 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
477 f2->SetContour(99); gStyle->SetPalette(kAurora);
478 f2->Draw("surf2Z"); f2->SetTitle("kAurora");
479}
480End_Macro
481</td><td>
482Begin_Macro
483{
484 c = new TCanvas("c","c",0,0,300,300);
485 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
486 f2->SetContour(99); gStyle->SetPalette(kAvocado);
487 f2->Draw("surf2Z"); f2->SetTitle("kAvocado");
488}
489End_Macro
490</td></tr>
491<tr><td>
492Begin_Macro
493{
494 c = new TCanvas("c","c",0,0,300,300);
495 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
496 f2->SetContour(99); gStyle->SetPalette(kBeach);
497 f2->Draw("surf2Z"); f2->SetTitle("kBeach");
498}
499End_Macro
500</td><td>
501Begin_Macro
502{
503 c = new TCanvas("c","c",0,0,300,300);
504 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
505 f2->SetContour(99); gStyle->SetPalette(kBlackBody);
506 f2->Draw("surf2Z"); f2->SetTitle("kBlackBody");
507}
508End_Macro
509</td><td>
510Begin_Macro
511{
512 c = new TCanvas("c","c",0,0,300,300);
513 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
514 f2->SetContour(99); gStyle->SetPalette(kBlueGreenYellow);
515 f2->Draw("surf2Z"); f2->SetTitle("kBlueGreenYellow");
516}
517End_Macro
518</td></tr>
519<tr><td>
520Begin_Macro
521{
522 c = new TCanvas("c","c",0,0,300,300);
523 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
524 f2->SetContour(99); gStyle->SetPalette(kBrownCyan);
525 f2->Draw("surf2Z"); f2->SetTitle("kBrownCyan");
526}
527End_Macro
528</td><td>
529Begin_Macro
530{
531 c = new TCanvas("c","c",0,0,300,300);
532 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
533 f2->SetContour(99); gStyle->SetPalette(kCMYK);
534 f2->Draw("surf2Z"); f2->SetTitle("kCMYK");
535}
536End_Macro
537</td><td>
538Begin_Macro
539{
540 c = new TCanvas("c","c",0,0,300,300);
541 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
542 f2->SetContour(99); gStyle->SetPalette(kCandy);
543 f2->Draw("surf2Z"); f2->SetTitle("kCandy");
544}
545End_Macro
546</td></tr>
547<tr><td>
548Begin_Macro
549{
550 c = new TCanvas("c","c",0,0,300,300);
551 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
552 f2->SetContour(99); gStyle->SetPalette(kCherry);
553 f2->Draw("surf2Z"); f2->SetTitle("kCherry");
554}
555End_Macro
556</td><td>
557Begin_Macro
558{
559 c = new TCanvas("c","c",0,0,300,300);
560 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
561 f2->SetContour(99); gStyle->SetPalette(kCoffee);
562 f2->Draw("surf2Z"); f2->SetTitle("kCoffee");
563}
564End_Macro
565</td><td>
566Begin_Macro
567{
568 c = new TCanvas("c","c",0,0,300,300);
569 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
570 f2->SetContour(99); gStyle->SetPalette(kDarkRainBow);
571 f2->Draw("surf2Z"); f2->SetTitle("kDarkRainBow");
572}
573End_Macro
574</td></tr>
575<tr><td>
576Begin_Macro
577{
578 c = new TCanvas("c","c",0,0,300,300);
579 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
580 f2->SetContour(99); gStyle->SetPalette(kDarkTerrain);
581 f2->Draw("surf2Z"); f2->SetTitle("kDarkTerrain");
582}
583End_Macro
584</td><td>
585Begin_Macro
586{
587 c = new TCanvas("c","c",0,0,300,300);
588 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
589 f2->SetContour(99); gStyle->SetPalette(kFall);
590 f2->Draw("surf2Z"); f2->SetTitle("kFall");
591}
592End_Macro
593</td><td>
594Begin_Macro
595{
596 c = new TCanvas("c","c",0,0,300,300);
597 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
598 f2->SetContour(99); gStyle->SetPalette(kFruitPunch);
599 f2->Draw("surf2Z"); f2->SetTitle("kFruitPunch");
600}
601End_Macro
602</td></tr>
603<tr><td>
604Begin_Macro
605{
606 c = new TCanvas("c","c",0,0,300,300);
607 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
608 f2->SetContour(99); gStyle->SetPalette(kFuchsia);
609 f2->Draw("surf2Z"); f2->SetTitle("kFuchsia");
610}
611End_Macro
612</td><td>
613Begin_Macro
614{
615 c = new TCanvas("c","c",0,0,300,300);
616 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
617 f2->SetContour(99); gStyle->SetPalette(kGreyYellow);
618 f2->Draw("surf2Z"); f2->SetTitle("kGreyYellow");
619}
620End_Macro
621</td><td>
622Begin_Macro
623{
624 c = new TCanvas("c","c",0,0,300,300);
625 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
626 f2->SetContour(99); gStyle->SetPalette(kGreenBrownTerrain);
627 f2->Draw("surf2Z"); f2->SetTitle("kGreenBrownTerrain");
628}
629End_Macro
630</td></tr>
631<tr><td>
632Begin_Macro
633{
634 c = new TCanvas("c","c",0,0,300,300);
635 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
636 f2->SetContour(99); gStyle->SetPalette(kGreenPink);
637 f2->Draw("surf2Z"); f2->SetTitle("kGreenPink");
638}
639End_Macro
640</td><td>
641Begin_Macro
642{
643 c = new TCanvas("c","c",0,0,300,300);
644 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
645 f2->SetContour(99); gStyle->SetPalette(kIsland);
646 f2->Draw("surf2Z"); f2->SetTitle("kIsland");
647}
648End_Macro
649</td><td>
650Begin_Macro
651{
652 c = new TCanvas("c","c",0,0,300,300);
653 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
654 f2->SetContour(99); gStyle->SetPalette(kLake);
655 f2->Draw("surf2Z"); f2->SetTitle("kLake");
656}
657End_Macro
658</td></tr>
659<tr><td>
660Begin_Macro
661{
662 c = new TCanvas("c","c",0,0,300,300);
663 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
664 f2->SetContour(99); gStyle->SetPalette(kLightTemperature);
665 f2->Draw("surf2Z"); f2->SetTitle("kLightTemperature");
666}
667End_Macro
668</td><td>
669Begin_Macro
670{
671 c = new TCanvas("c","c",0,0,300,300);
672 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
673 f2->SetContour(99); gStyle->SetPalette(kLightTerrain);
674 f2->Draw("surf2Z"); f2->SetTitle("kLightTerrain");
675}
676End_Macro
677</td><td>
678Begin_Macro
679{
680 c = new TCanvas("c","c",0,0,300,300);
681 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
682 f2->SetContour(99); gStyle->SetPalette(kMint);
683 f2->Draw("surf2Z"); f2->SetTitle("kMint");
684}
685End_Macro
686</td></tr>
687<tr><td>
688Begin_Macro
689{
690 c = new TCanvas("c","c",0,0,300,300);
691 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
692 f2->SetContour(99); gStyle->SetPalette(kNeon);
693 f2->Draw("surf2Z"); f2->SetTitle("kNeon");
694}
695End_Macro
696</td><td>
697Begin_Macro
698{
699 c = new TCanvas("c","c",0,0,300,300);
700 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
701 f2->SetContour(99); gStyle->SetPalette(kPastel);
702 f2->Draw("surf2Z"); f2->SetTitle("kPastel");
703}
704End_Macro
705</td><td>
706Begin_Macro
707{
708 c = new TCanvas("c","c",0,0,300,300);
709 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
710 f2->SetContour(99); gStyle->SetPalette(kPearl);
711 f2->Draw("surf2Z"); f2->SetTitle("kPearl");
712}
713End_Macro
714</td></tr>
715<tr><td>
716Begin_Macro
717{
718 c = new TCanvas("c","c",0,0,300,300);
719 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
720 f2->SetContour(99); gStyle->SetPalette(kPigeon);
721 f2->Draw("surf2Z"); f2->SetTitle("kPigeon");
722}
723End_Macro
724</td><td>
725Begin_Macro
726{
727 c = new TCanvas("c","c",0,0,300,300);
728 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
729 f2->SetContour(99); gStyle->SetPalette(kPlum);
730 f2->Draw("surf2Z"); f2->SetTitle("kPlum");
731}
732End_Macro
733</td><td>
734Begin_Macro
735{
736 c = new TCanvas("c","c",0,0,300,300);
737 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
738 f2->SetContour(99); gStyle->SetPalette(kRedBlue);
739 f2->Draw("surf2Z"); f2->SetTitle("kRedBlue");
740}
741End_Macro
742</td></tr>
743<tr><td>
744Begin_Macro
745{
746 c = new TCanvas("c","c",0,0,300,300);
747 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
748 f2->SetContour(99); gStyle->SetPalette(kRose);
749 f2->Draw("surf2Z"); f2->SetTitle("kRose");
750}
751End_Macro
752</td><td>
753Begin_Macro
754{
755 c = new TCanvas("c","c",0,0,300,300);
756 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
757 f2->SetContour(99); gStyle->SetPalette(kRust);
758 f2->Draw("surf2Z"); f2->SetTitle("kRust");
759}
760End_Macro
761</td><td>
762Begin_Macro
763{
764 c = new TCanvas("c","c",0,0,300,300);
765 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
766 f2->SetContour(99); gStyle->SetPalette(kSandyTerrain);
767 f2->Draw("surf2Z"); f2->SetTitle("kSandyTerrain");
768}
769End_Macro
770</td></tr>
771<tr><td>
772Begin_Macro
773{
774 c = new TCanvas("c","c",0,0,300,300);
775 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
776 f2->SetContour(99); gStyle->SetPalette(kSienna);
777 f2->Draw("surf2Z"); f2->SetTitle("kSienna");
778}
779End_Macro
780</td><td>
781Begin_Macro
782{
783 c = new TCanvas("c","c",0,0,300,300);
784 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
785 f2->SetContour(99); gStyle->SetPalette(kSolar);
786 f2->Draw("surf2Z"); f2->SetTitle("kSolar");
787}
788End_Macro
789</td><td>
790Begin_Macro
791{
792 c = new TCanvas("c","c",0,0,300,300);
793 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
794 f2->SetContour(99); gStyle->SetPalette(kSouthWest);
795 f2->Draw("surf2Z"); f2->SetTitle("kSouthWest");
796}
797End_Macro
798</td></tr>
799<tr><td>
800Begin_Macro
801{
802 c = new TCanvas("c","c",0,0,300,300);
803 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
804 f2->SetContour(99); gStyle->SetPalette(kStarryNight);
805 f2->Draw("surf2Z"); f2->SetTitle("kStarryNight");
806}
807End_Macro
808</td><td>
809Begin_Macro
810{
811 c = new TCanvas("c","c",0,0,300,300);
812 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
813 f2->SetContour(99); gStyle->SetPalette(kSunset);
814 f2->Draw("surf2Z"); f2->SetTitle("kSunset");
815}
816End_Macro
817</td><td>
818Begin_Macro
819{
820 c = new TCanvas("c","c",0,0,300,300);
821 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
822 f2->SetContour(99); gStyle->SetPalette(kTemperatureMap);
823 f2->Draw("surf2Z"); f2->SetTitle("kTemperatureMap");
824}
825End_Macro
826</td></tr>
827<tr><td>
828Begin_Macro
829{
830 c = new TCanvas("c","c",0,0,300,300);
831 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
832 f2->SetContour(99); gStyle->SetPalette(kThermometer);
833 f2->Draw("surf2Z"); f2->SetTitle("kThermometer");
834}
835End_Macro
836</td><td>
837Begin_Macro
838{
839 c = new TCanvas("c","c",0,0,300,300);
840 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
841 f2->SetContour(99); gStyle->SetPalette(kValentine);
842 f2->Draw("surf2Z"); f2->SetTitle("kValentine");
843}
844End_Macro
845</td><td>
846Begin_Macro
847{
848 c = new TCanvas("c","c",0,0,300,300);
849 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
850 f2->SetContour(99); gStyle->SetPalette(kVisibleSpectrum);
851 f2->Draw("surf2Z"); f2->SetTitle("kVisibleSpectrum");
852}
853End_Macro
854</td></tr>
855<tr><td>
856Begin_Macro
857{
858 c = new TCanvas("c","c",0,0,300,300);
859 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
860 f2->SetContour(99); gStyle->SetPalette(kWaterMelon);
861 f2->Draw("surf2Z"); f2->SetTitle("kWaterMelon");
862}
863End_Macro
864</td><td>
865Begin_Macro
866{
867 c = new TCanvas("c","c",0,0,300,300);
868 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
869 f2->SetContour(99); gStyle->SetPalette(kCool);
870 f2->Draw("surf2Z"); f2->SetTitle("kCool");
871}
872End_Macro
873</td><td>
874Begin_Macro
875{
876 c = new TCanvas("c","c",0,0,300,300);
877 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
878 f2->SetContour(99); gStyle->SetPalette(kCopper);
879 f2->Draw("surf2Z"); f2->SetTitle("kCopper");
880}
881End_Macro
882</td></tr>
883<tr><td>
884Begin_Macro
885{
886 c = new TCanvas("c","c",0,0,300,300);
887 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
888 f2->SetContour(99); gStyle->SetPalette(kGistEarth);
889 f2->Draw("surf2Z"); f2->SetTitle("kGistEarth");
890}
891End_Macro
892</td><td>
893Begin_Macro
894{
895 c = new TCanvas("c","c",0,0,300,300);
896 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
897 f2->SetContour(99); gStyle->SetPalette(kViridis);
898 f2->Draw("surf2Z"); f2->SetTitle("kViridis");
899}
900End_Macro
901</td><td>
902Begin_Macro
903{
904 c = new TCanvas("c","c",0,0,300,300);
905 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
906 f2->SetContour(99); gStyle->SetPalette(kCividis);
907 f2->Draw("surf2Z"); f2->SetTitle("kCividis");
908}
909End_Macro
910</td></tr>
911</table>
912
913## <a name="C061"></a> Palette inversion
914Once a palette is defined, it is possible to invert the color order thanks to the
915method TColor::InvertPalette. The top of the palette becomes the bottom and vice versa.
916
917Begin_Macro(source)
918{
919 auto c = new TCanvas("c","c",0,0,600,400);
920 TF2 *f2 = new TF2("f2","0.1+(1-(x-2)*(x-2))*(1-(y-2)*(y-2))",0.999,3.002,0.999,3.002);
921 f2->SetContour(99); gStyle->SetPalette(kCherry);
922 TColor::InvertPalette();
923 f2->Draw("surf2Z"); f2->SetTitle("kCherry inverted");
924}
925End_Macro
926
927## <a name="C07"></a> Color transparency
928To make a graphics object transparent it is enough to set its color to a
929transparent one. The color transparency is defined via its alpha component. The
930alpha value varies from `0.` (fully transparent) to `1.` (fully
931opaque). To set the alpha value of an existing color it is enough to do:
932
933~~~ {.cpp}
934 TColor *col26 = gROOT->GetColor(26);
935 col26->SetAlpha(0.01);
936~~~
937
938A new color can be created transparent the following way:
939
940~~~ {.cpp}
941 Int_t ci = 1756;
942 TColor *color = new TColor(ci, 0.1, 0.2, 0.3, "", 0.5); // alpha = 0.5
943~~~
944
945An example of transparency usage with parallel coordinates can be found
946in parallelcoordtrans.C.
947
948To ease the creation of a transparent color the static method
949`GetColorTransparent(Int_t color, Float_t a)` is provided.
950In the following example the `trans_red` color index point to
951a red color 30% transparent. The alpha value of the color index
952`kRed` is not modified.
953
954~~~ {.cpp}
955 Int_t trans_red = GetColorTransparent(kRed, 0.3);
956~~~
957
958This function is also used in the methods
959`SetFillColorAlpha()`, `SetLineColorAlpha()`,
960`SetMarkerColorAlpha()` and `SetTextColorAlpha()`.
961In the following example the fill color of the histogram `histo`
962is set to blue with a transparency of 35%. The color `kBlue`
963itself remains fully opaque.
964
965~~~ {.cpp}
966 histo->SetFillColorAlpha(kBlue, 0.35);
967~~~
968
969The transparency is available on all platforms when the flag `OpenGL.CanvasPreferGL` is set to `1`
970in `$ROOTSYS/etc/system.rootrc`, or on Mac with the Cocoa backend. On the file output
971it is visible with PDF, PNG, Gif, JPEG, SVG, TeX ... but not PostScript.
972The following macro gives an example of transparency usage:
973
974Begin_Macro(source)
975../../../tutorials/graphics/transparency.C
976End_Macro
977
978*/
979
980////////////////////////////////////////////////////////////////////////////////
981/// Default constructor.
982
984{
985 fNumber = -1;
986 fRed = fGreen = fBlue = fHue = fLight = fSaturation = -1;
987 fAlpha = 1;
988}
989
990////////////////////////////////////////////////////////////////////////////////
991/// Normal color constructor. Initialize a color structure.
992/// Compute the RGB and HLS color components.
993
995 Float_t a)
996 : TNamed(name,"")
997{
999 // do not enter if color number already exist
1000 TColor *col = gROOT->GetColor(color);
1001 if (col) {
1002 Warning("TColor", "color %d already defined", color);
1003 fNumber = col->GetNumber();
1004 fRed = col->GetRed();
1005 fGreen = col->GetGreen();
1006 fBlue = col->GetBlue();
1007 fHue = col->GetHue();
1008 fLight = col->GetLight();
1009 fAlpha = col->GetAlpha();
1010 fSaturation = col->GetSaturation();
1011 return;
1012 }
1013
1014 fNumber = color;
1015
1017
1018 char aname[32];
1019 if (!name || !*name) {
1020 snprintf(aname,32, "Color%d", color);
1021 SetName(aname);
1022 }
1023
1024 // enter in the list of colors
1025 TObjArray *lcolors = (TObjArray*)gROOT->GetListOfColors();
1026 lcolors->AddAtAndExpand(this, color);
1027
1028 // fill color structure
1029 SetRGB(r, g, b);
1030 fAlpha = a;
1032}
1033
1034////////////////////////////////////////////////////////////////////////////////
1035/// Fast TColor constructor. It creates a color with an index just above the
1036/// current highest one. It does not name the color.
1037/// This is useful to create palettes.
1038
1040{
1043 fRed = r;
1044 fGreen = g;
1045 fBlue = b;
1046 fAlpha = a;
1048
1049 // enter in the list of colors
1050 TObjArray *lcolors = (TObjArray*)gROOT->GetListOfColors();
1051 lcolors->AddAtAndExpand(this, fNumber);
1053}
1054
1055////////////////////////////////////////////////////////////////////////////////
1056/// Color destructor.
1057
1059{
1060 gROOT->GetListOfColors()->Remove(this);
1061 if (gROOT->GetListOfColors()->IsEmpty()) {
1062 fgPalette.Set(0);
1063 fgPalette=0;
1064 }
1065}
1066
1067////////////////////////////////////////////////////////////////////////////////
1068/// Color copy constructor.
1069
1070TColor::TColor(const TColor &color) : TNamed(color)
1071{
1072 ((TColor&)color).Copy(*this);
1073}
1074
1076{
1077 ((TColor &)color).Copy(*this);
1078 return *this;
1079}
1080
1081////////////////////////////////////////////////////////////////////////////////
1082/// Initialize colors used by the TCanvas based graphics (via TColor objects).
1083/// This method should be called before the ApplicationImp is created (which
1084/// initializes the GUI colors).
1085
1087{
1088 static Bool_t initDone = kFALSE;
1089
1090 if (initDone) return;
1091 initDone = kTRUE;
1092
1093 if (gROOT->GetListOfColors()->First() == 0) {
1094
1095 new TColor(kWhite,1,1,1,"background");
1096 new TColor(kBlack,0,0,0,"black");
1097 new TColor(2,1,0,0,"red");
1098 new TColor(3,0,1,0,"green");
1099 new TColor(4,0,0,1,"blue");
1100 new TColor(5,1,1,0,"yellow");
1101 new TColor(6,1,0,1,"magenta");
1102 new TColor(7,0,1,1,"cyan");
1103 new TColor(10,0.999,0.999,0.999,"white");
1104 new TColor(11,0.754,0.715,0.676,"editcol");
1105
1106 // The color white above is defined as being nearly white.
1107 // Sets the associated dark color also to white.
1109 TColor *c110 = gROOT->GetColor(110);
1110 if (c110) c110->SetRGB(0.999,0.999,.999);
1111
1112 // Initialize Custom colors
1113 new TColor(20,0.8,0.78,0.67);
1114 new TColor(31,0.54,0.66,0.63);
1115 new TColor(41,0.83,0.81,0.53);
1116 new TColor(30,0.52,0.76,0.64);
1117 new TColor(32,0.51,0.62,0.55);
1118 new TColor(24,0.70,0.65,0.59);
1119 new TColor(21,0.8,0.78,0.67);
1120 new TColor(47,0.67,0.56,0.58);
1121 new TColor(35,0.46,0.54,0.57);
1122 new TColor(33,0.68,0.74,0.78);
1123 new TColor(39,0.5,0.5,0.61);
1124 new TColor(37,0.43,0.48,0.52);
1125 new TColor(38,0.49,0.6,0.82);
1126 new TColor(36,0.41,0.51,0.59);
1127 new TColor(49,0.58,0.41,0.44);
1128 new TColor(43,0.74,0.62,0.51);
1129 new TColor(22,0.76,0.75,0.66);
1130 new TColor(45,0.75,0.51,0.47);
1131 new TColor(44,0.78,0.6,0.49);
1132 new TColor(26,0.68,0.6,0.55);
1133 new TColor(28,0.53,0.4,0.34);
1134 new TColor(25,0.72,0.64,0.61);
1135 new TColor(27,0.61,0.56,0.51);
1136 new TColor(23,0.73,0.71,0.64);
1137 new TColor(42,0.87,0.73,0.53);
1138 new TColor(46,0.81,0.37,0.38);
1139 new TColor(48,0.65,0.47,0.48);
1140 new TColor(34,0.48,0.56,0.6);
1141 new TColor(40,0.67,0.65,0.75);
1142 new TColor(29,0.69,0.81,0.78);
1143
1144 // Initialize some additional greyish non saturated colors
1145 new TColor(8, 0.35,0.83,0.33);
1146 new TColor(9, 0.35,0.33,0.85);
1147 new TColor(12,.3,.3,.3,"grey12");
1148 new TColor(13,.4,.4,.4,"grey13");
1149 new TColor(14,.5,.5,.5,"grey14");
1150 new TColor(15,.6,.6,.6,"grey15");
1151 new TColor(16,.7,.7,.7,"grey16");
1152 new TColor(17,.8,.8,.8,"grey17");
1153 new TColor(18,.9,.9,.9,"grey18");
1154 new TColor(19,.95,.95,.95,"grey19");
1155 new TColor(50, 0.83,0.35,0.33);
1156
1157 // Initialize the Pretty Palette Spectrum Violet->Red
1158 // The color model used here is based on the HLS model which
1159 // is much more suitable for creating palettes than RGB.
1160 // Fixing the saturation and lightness we can scan through the
1161 // spectrum of visible light by using "hue" alone.
1162 // In Root hue takes values from 0 to 360.
1163 Int_t i;
1164 Float_t saturation = 1;
1165 Float_t lightness = 0.5;
1166 Float_t maxHue = 280;
1167 Float_t minHue = 0;
1168 Int_t maxPretty = 50;
1169 Float_t hue;
1170 Float_t r=0., g=0., b=0., h, l, s;
1171
1172 for (i=0 ; i<maxPretty-1 ; i++) {
1173 hue = maxHue-(i+1)*((maxHue-minHue)/maxPretty);
1174 TColor::HLStoRGB(hue, lightness, saturation, r, g, b);
1175 new TColor(i+51, r, g, b);
1176 }
1177
1178 // Initialize special colors for x3d
1179 TColor *s0;
1180 for (i = 1; i < 8; i++) {
1181 s0 = gROOT->GetColor(i);
1182 if (s0) s0->GetRGB(r,g,b);
1183 if (i == 1) { r = 0.6; g = 0.6; b = 0.6; }
1184 if (r == 1) r = 0.9; else if (r == 0) r = 0.1;
1185 if (g == 1) g = 0.9; else if (g == 0) g = 0.1;
1186 if (b == 1) b = 0.9; else if (b == 0) b = 0.1;
1188 TColor::HLStoRGB(h,0.6*l,s,r,g,b);
1189 new TColor(200+4*i-3,r,g,b);
1190 TColor::HLStoRGB(h,0.8*l,s,r,g,b);
1191 new TColor(200+4*i-2,r,g,b);
1192 TColor::HLStoRGB(h,1.2*l,s,r,g,b);
1193 new TColor(200+4*i-1,r,g,b);
1194 TColor::HLStoRGB(h,1.4*l,s,r,g,b);
1195 new TColor(200+4*i ,r,g,b);
1196 }
1197
1198 // Create the ROOT Color Wheel
1200 }
1201 // If fgPalette.fN !=0 SetPalette has been called already
1202 // (from rootlogon.C for instance)
1203
1204 if (!fgPalette.fN) SetPalette(1,0);
1205}
1206
1207////////////////////////////////////////////////////////////////////////////////
1208/// Return color as hexadecimal string. This string can be directly passed
1209/// to, for example, TGClient::GetColorByName(). String will be reused so
1210/// copy immediately if needed.
1211
1212const char *TColor::AsHexString() const
1213{
1214 static TString tempbuf;
1215
1216 Int_t r, g, b, a;
1217 r = Int_t(GetRed() * 255);
1218 g = Int_t(GetGreen() * 255);
1219 b = Int_t(GetBlue() * 255);
1220 a = Int_t(fAlpha * 255);
1221
1222 if (a != 255) {
1223 tempbuf.Form("#%02x%02x%02x%02x", a, r, g, b);
1224 } else {
1225 tempbuf.Form("#%02x%02x%02x", r, g, b);
1226 }
1227 return tempbuf;
1228}
1229
1230////////////////////////////////////////////////////////////////////////////////
1231/// Copy this color to obj.
1232
1233void TColor::Copy(TObject &obj) const
1234{
1235 TNamed::Copy((TNamed&)obj);
1236 ((TColor&)obj).fRed = fRed;
1237 ((TColor&)obj).fGreen = fGreen;
1238 ((TColor&)obj).fBlue = fBlue;
1239 ((TColor&)obj).fHue = fHue;
1240 ((TColor&)obj).fLight = fLight;
1241 ((TColor&)obj).fAlpha = fAlpha;
1242 ((TColor&)obj).fSaturation = fSaturation;
1243 ((TColor&)obj).fNumber = fNumber;
1244}
1245
1246////////////////////////////////////////////////////////////////////////////////
1247/// Create the Gray scale colors in the Color Wheel
1248
1250{
1251 if (gROOT->GetColor(kGray)) return;
1252 TColor *gray = new TColor(kGray,204./255.,204./255.,204./255.);
1253 TColor *gray1 = new TColor(kGray+1,153./255.,153./255.,153./255.);
1254 TColor *gray2 = new TColor(kGray+2,102./255.,102./255.,102./255.);
1255 TColor *gray3 = new TColor(kGray+3, 51./255., 51./255., 51./255.);
1256 gray ->SetName("kGray");
1257 gray1->SetName("kGray+1");
1258 gray2->SetName("kGray+2");
1259 gray3->SetName("kGray+3");
1260}
1261
1262////////////////////////////////////////////////////////////////////////////////
1263/// Create the "circle" colors in the color wheel.
1264
1265void TColor::CreateColorsCircle(Int_t offset, const char *name, UChar_t *rgb)
1266{
1267 TString colorname;
1268 for (Int_t n=0;n<15;n++) {
1269 Int_t colorn = offset+n-10;
1270 TColor *color = gROOT->GetColor(colorn);
1271 if (!color) {
1272 color = new TColor(colorn,rgb[3*n]/255.,rgb[3*n+1]/255.,rgb[3*n+2]/255.);
1273 color->SetTitle(color->AsHexString());
1274 if (n>10) colorname.Form("%s+%d",name,n-10);
1275 else if (n<10) colorname.Form("%s-%d",name,10-n);
1276 else colorname.Form("%s",name);
1277 color->SetName(colorname);
1278 }
1279 }
1280}
1281
1282////////////////////////////////////////////////////////////////////////////////
1283/// Create the "rectangular" colors in the color wheel.
1284
1285void TColor::CreateColorsRectangle(Int_t offset, const char *name, UChar_t *rgb)
1286{
1287 TString colorname;
1288 for (Int_t n=0;n<20;n++) {
1289 Int_t colorn = offset+n-9;
1290 TColor *color = gROOT->GetColor(colorn);
1291 if (!color) {
1292 color = new TColor(colorn,rgb[3*n]/255.,rgb[3*n+1]/255.,rgb[3*n+2]/255.);
1293 color->SetTitle(color->AsHexString());
1294 if (n>9) colorname.Form("%s+%d",name,n-9);
1295 else if (n<9) colorname.Form("%s-%d",name,9-n);
1296 else colorname.Form("%s",name);
1297 color->SetName(colorname);
1298 }
1299 }
1300}
1301
1302////////////////////////////////////////////////////////////////////////////////
1303/// Static function steering the creation of all colors in the color wheel.
1304
1306{
1307 UChar_t magenta[46]= {255,204,255
1308 ,255,153,255, 204,153,204
1309 ,255,102,255, 204,102,204, 153,102,153
1310 ,255, 51,255, 204, 51,204, 153, 51,153, 102, 51,102
1311 ,255, 0,255, 204, 0,204, 153, 0,153, 102, 0,102, 51, 0, 51};
1312
1313 UChar_t red[46] = {255,204,204
1314 ,255,153,153, 204,153,153
1315 ,255,102,102, 204,102,102, 153,102,102
1316 ,255, 51, 51, 204, 51, 51, 153, 51, 51, 102, 51, 51
1317 ,255, 0, 0, 204, 0, 0, 153, 0, 0, 102, 0, 0, 51, 0, 0};
1318
1319 UChar_t yellow[46] = {255,255,204
1320 ,255,255,153, 204,204,153
1321 ,255,255,102, 204,204,102, 153,153,102
1322 ,255,255, 51, 204,204, 51, 153,153, 51, 102,102, 51
1323 ,255,255, 0, 204,204, 0, 153,153, 0, 102,102, 0, 51, 51, 0};
1324
1325 UChar_t green[46] = {204,255,204
1326 ,153,255,153, 153,204,153
1327 ,102,255,102, 102,204,102, 102,153,102
1328 , 51,255, 51, 51,204, 51, 51,153, 51, 51,102, 51
1329 , 0,255, 0, 0,204, 0, 0,153, 0, 0,102, 0, 0, 51, 0};
1330
1331 UChar_t cyan[46] = {204,255,255
1332 ,153,255,255, 153,204,204
1333 ,102,255,255, 102,204,204, 102,153,153
1334 , 51,255,255, 51,204,204, 51,153,153, 51,102,102
1335 , 0,255,255, 0,204,204, 0,153,153, 0,102,102, 0, 51, 51};
1336
1337 UChar_t blue[46] = {204,204,255
1338 ,153,153,255, 153,153,204
1339 ,102,102,255, 102,102,204, 102,102,153
1340 , 51, 51,255, 51, 51,204, 51, 51,153, 51, 51,102
1341 , 0, 0,255, 0, 0,204, 0, 0,153, 0, 0,102, 0, 0, 51};
1342
1343 UChar_t pink[60] = {255, 51,153, 204, 0,102, 102, 0, 51, 153, 0, 51, 204, 51,102
1344 ,255,102,153, 255, 0,102, 255, 51,102, 204, 0, 51, 255, 0, 51
1345 ,255,153,204, 204,102,153, 153, 51,102, 153, 0,102, 204, 51,153
1346 ,255,102,204, 255, 0,153, 204, 0,153, 255, 51,204, 255, 0,153};
1347
1348 UChar_t orange[60]={255,204,153, 204,153,102, 153,102, 51, 153,102, 0, 204,153, 51
1349 ,255,204,102, 255,153, 0, 255,204, 51, 204,153, 0, 255,204, 0
1350 ,255,153, 51, 204,102, 0, 102, 51, 0, 153, 51, 0, 204,102, 51
1351 ,255,153,102, 255,102, 0, 255,102, 51, 204, 51, 0, 255, 51, 0};
1352
1353 UChar_t spring[60]={153,255, 51, 102,204, 0, 51,102, 0, 51,153, 0, 102,204, 51
1354 ,153,255,102, 102,255, 0, 102,255, 51, 51,204, 0, 51,255, 0
1355 ,204,255,153, 153,204,102, 102,153, 51, 102,153, 0, 153,204, 51
1356 ,204,255,102, 153,255, 0, 204,255, 51, 153,204, 0, 204,255, 0};
1357
1358 UChar_t teal[60] = {153,255,204, 102,204,153, 51,153,102, 0,153,102, 51,204,153
1359 ,102,255,204, 0,255,102, 51,255,204, 0,204,153, 0,255,204
1360 , 51,255,153, 0,204,102, 0,102, 51, 0,153, 51, 51,204,102
1361 ,102,255,153, 0,255,153, 51,255,102, 0,204, 51, 0,255, 51};
1362
1363 UChar_t azure[60] ={153,204,255, 102,153,204, 51,102,153, 0, 51,153, 51,102,204
1364 ,102,153,255, 0,102,255, 51,102,255, 0, 51,204, 0, 51,255
1365 , 51,153,255, 0,102,204, 0, 51,102, 0,102,153, 51,153,204
1366 ,102,204,255, 0,153,255, 51,204,255, 0,153,204, 0,204,255};
1367
1368 UChar_t violet[60]={204,153,255, 153,102,204, 102, 51,153, 102, 0,153, 153, 51,204
1369 ,204,102,255, 153, 0,255, 204, 51,255, 153, 0,204, 204, 0,255
1370 ,153, 51,255, 102, 0,204, 51, 0,102, 51, 0,153, 102, 51,204
1371 ,153,102,255, 102, 0,255, 102, 51,255, 51, 0,204, 51, 0,255};
1372
1373 TColor::CreateColorsCircle(kMagenta,"kMagenta",magenta);
1374 TColor::CreateColorsCircle(kRed, "kRed", red);
1375 TColor::CreateColorsCircle(kYellow, "kYellow", yellow);
1376 TColor::CreateColorsCircle(kGreen, "kGreen", green);
1377 TColor::CreateColorsCircle(kCyan, "kCyan", cyan);
1378 TColor::CreateColorsCircle(kBlue, "kBlue", blue);
1379
1380 TColor::CreateColorsRectangle(kPink, "kPink", pink);
1381 TColor::CreateColorsRectangle(kOrange,"kOrange",orange);
1382 TColor::CreateColorsRectangle(kSpring,"kSpring",spring);
1383 TColor::CreateColorsRectangle(kTeal, "kTeal", teal);
1384 TColor::CreateColorsRectangle(kAzure, "kAzure", azure);
1385 TColor::CreateColorsRectangle(kViolet,"kViolet",violet);
1386
1388}
1389
1390////////////////////////////////////////////////////////////////////////////////
1391/// Static function returning the color number i in current palette.
1392
1394{
1395 Int_t ncolors = fgPalette.fN;
1396 if (ncolors == 0) return 0;
1397 Int_t icol = i%ncolors;
1398 if (icol < 0) icol = 0;
1399 return fgPalette.fArray[icol];
1400}
1401
1402////////////////////////////////////////////////////////////////////////////////
1403/// Static function returning the current active palette.
1404
1406{
1407 return fgPalette;
1408}
1409
1410////////////////////////////////////////////////////////////////////////////////
1411/// Static function returning number of colors in the color palette.
1412
1414{
1415 return fgPalette.fN;
1416}
1417
1418////////////////////////////////////////////////////////////////////////////////
1419/// Static function returning kTRUE if some new colors have been defined after
1420/// initialisation or since the last call to this method. This allows to avoid
1421/// the colors and palette streaming in TCanvas::Streamer if not needed.
1422
1424{
1425 // After initialization gDefinedColors == 649. If it is bigger it means some new
1426 // colors have been defined
1427 Bool_t hasChanged = (gDefinedColors - gLastDefinedColors) > 50;
1429 return hasChanged;
1430}
1431
1432////////////////////////////////////////////////////////////////////////////////
1433/// Return pixel value corresponding to this color. This pixel value can
1434/// be used in the GUI classes. This call does not work in batch mode since
1435/// it needs to communicate with the graphics system.
1436
1438{
1439 if (gVirtualX && !gROOT->IsBatch()) {
1440 if (gApplication) {
1443 }
1444 return gVirtualX->GetPixel(fNumber);
1445 }
1446
1447 return 0;
1448}
1449
1450////////////////////////////////////////////////////////////////////////////////
1451/// Static method to compute RGB from HLS. The l and s are between [0,1]
1452/// and h is between [0,360]. The returned r,g,b triplet is between [0,1].
1453
1455 Float_t &r, Float_t &g, Float_t &b)
1456{
1457
1458 Float_t rh, rl, rs, rm1, rm2;
1459 rh = rl = rs = 0;
1460 if (hue > 0) { rh = hue; if (rh > 360) rh = 360; }
1461 if (light > 0) { rl = light; if (rl > 1) rl = 1; }
1462 if (satur > 0) { rs = satur; if (rs > 1) rs = 1; }
1463
1464 if (rl <= 0.5)
1465 rm2 = rl*(1.0 + rs);
1466 else
1467 rm2 = rl + rs - rl*rs;
1468 rm1 = 2.0*rl - rm2;
1469
1470 if (!rs) { r = rl; g = rl; b = rl; return; }
1471 r = HLStoRGB1(rm1, rm2, rh+120);
1472 g = HLStoRGB1(rm1, rm2, rh);
1473 b = HLStoRGB1(rm1, rm2, rh-120);
1474}
1475
1476////////////////////////////////////////////////////////////////////////////////
1477/// Static method. Auxiliary to HLS2RGB().
1478
1480{
1481 Float_t hue = huei;
1482 if (hue > 360) hue = hue - 360;
1483 if (hue < 0) hue = hue + 360;
1484 if (hue < 60 ) return rn1 + (rn2-rn1)*hue/60;
1485 if (hue < 180) return rn2;
1486 if (hue < 240) return rn1 + (rn2-rn1)*(240-hue)/60;
1487 return rn1;
1488}
1489
1490////////////////////////////////////////////////////////////////////////////////
1491/// Static method to compute RGB from HLS. The h,l,s are between [0,255].
1492/// The returned r,g,b triplet is between [0,255].
1493
1495{
1496 Float_t hh, ll, ss, rr, gg, bb;
1497
1498 hh = Float_t(h) * 360 / 255;
1499 ll = Float_t(l) / 255;
1500 ss = Float_t(s) / 255;
1501
1502 TColor::HLStoRGB(hh, ll, ss, rr, gg, bb);
1503
1504 r = (Int_t) (rr * 255);
1505 g = (Int_t) (gg * 255);
1506 b = (Int_t) (bb * 255);
1507}
1508
1509////////////////////////////////////////////////////////////////////////////////
1510/// Static method to compute RGB from HSV:
1511///
1512/// - The hue value runs from 0 to 360.
1513/// - The saturation is the degree of strength or purity and is from 0 to 1.
1514/// Purity is how much white is added to the color, so S=1 makes the purest
1515/// color (no white).
1516/// - Brightness value also ranges from 0 to 1, where 0 is the black.
1517///
1518/// The returned r,g,b triplet is between [0,1].
1519
1521 Float_t &r, Float_t &g, Float_t &b)
1522{
1523 Int_t i;
1524 Float_t f, p, q, t;
1525
1526 if (satur==0) {
1527 // Achromatic (grey)
1528 r = g = b = value;
1529 return;
1530 }
1531
1532 hue /= 60; // sector 0 to 5
1533 i = (Int_t)floor(hue);
1534 f = hue-i; // factorial part of hue
1535 p = value*(1-satur);
1536 q = value*(1-satur*f );
1537 t = value*(1-satur*(1-f));
1538
1539 switch (i) {
1540 case 0:
1541 r = value;
1542 g = t;
1543 b = p;
1544 break;
1545 case 1:
1546 r = q;
1547 g = value;
1548 b = p;
1549 break;
1550 case 2:
1551 r = p;
1552 g = value;
1553 b = t;
1554 break;
1555 case 3:
1556 r = p;
1557 g = q;
1558 b = value;
1559 break;
1560 case 4:
1561 r = t;
1562 g = p;
1563 b = value;
1564 break;
1565 default:
1566 r = value;
1567 g = p;
1568 b = q;
1569 break;
1570 }
1571}
1572
1573////////////////////////////////////////////////////////////////////////////////
1574/// List this color with its attributes.
1575
1577{
1578 printf("Color:%d Red=%f Green=%f Blue=%f Alpha=%f Name=%s\n",
1580}
1581
1582////////////////////////////////////////////////////////////////////////////////
1583/// Dump this color with its attributes.
1584
1586{
1587 ls();
1588}
1589
1590////////////////////////////////////////////////////////////////////////////////
1591/// Static method to compute HLS from RGB. The r,g,b triplet is between
1592/// [0,1], hue is between [0,360], light and satur are [0,1].
1593
1595 Float_t &hue, Float_t &light, Float_t &satur)
1596{
1597 Float_t rnorm, gnorm, bnorm, minval, maxval, msum, mdiff, r, g, b;
1598 minval = maxval =0 ;
1599 r = g = b = 0;
1600 if (rr > 0) { r = rr; if (r > 1) r = 1; }
1601 if (gg > 0) { g = gg; if (g > 1) g = 1; }
1602 if (bb > 0) { b = bb; if (b > 1) b = 1; }
1603
1604 minval = r;
1605 if (g < minval) minval = g;
1606 if (b < minval) minval = b;
1607 maxval = r;
1608 if (g > maxval) maxval = g;
1609 if (b > maxval) maxval = b;
1610
1611 rnorm = gnorm = bnorm = 0;
1612 mdiff = maxval - minval;
1613 msum = maxval + minval;
1614 light = 0.5 * msum;
1615 if (maxval != minval) {
1616 rnorm = (maxval - r)/mdiff;
1617 gnorm = (maxval - g)/mdiff;
1618 bnorm = (maxval - b)/mdiff;
1619 } else {
1620 satur = hue = 0;
1621 return;
1622 }
1623
1624 if (light < 0.5)
1625 satur = mdiff/msum;
1626 else
1627 satur = mdiff/(2.0 - msum);
1628
1629 if (r == maxval)
1630 hue = 60.0 * (6.0 + bnorm - gnorm);
1631 else if (g == maxval)
1632 hue = 60.0 * (2.0 + rnorm - bnorm);
1633 else
1634 hue = 60.0 * (4.0 + gnorm - rnorm);
1635
1636 if (hue > 360)
1637 hue = hue - 360;
1638}
1639
1640////////////////////////////////////////////////////////////////////////////////
1641/// Static method to compute HSV from RGB.
1642///
1643/// - The input values:
1644/// - r,g,b triplet is between [0,1].
1645/// - The returned values:
1646/// - The hue value runs from 0 to 360.
1647/// - The saturation is the degree of strength or purity and is from 0 to 1.
1648/// Purity is how much white is added to the color, so S=1 makes the purest
1649/// color (no white).
1650/// - Brightness value also ranges from 0 to 1, where 0 is the black.
1651
1653 Float_t &hue, Float_t &satur, Float_t &value)
1654{
1655 Float_t min, max, delta;
1656
1657 min = TMath::Min(TMath::Min(r, g), b);
1658 max = TMath::Max(TMath::Max(r, g), b);
1659 value = max;
1660
1661 delta = max - min;
1662
1663 if (max != 0) {
1664 satur = delta/max;
1665 } else {
1666 satur = 0;
1667 hue = -1;
1668 return;
1669 }
1670
1671 if (r == max) {
1672 hue = (g-b)/delta;
1673 } else if (g == max) {
1674 hue = 2+(b-r)/delta;
1675 } else {
1676 hue = 4+(r-g)/delta;
1677 }
1678
1679 hue *= 60;
1680 if (hue < 0) hue += 360;
1681}
1682
1683////////////////////////////////////////////////////////////////////////////////
1684/// Static method to compute HLS from RGB. The r,g,b triplet is between
1685/// [0,255], hue, light and satur are between [0,255].
1686
1688{
1689 Float_t rr, gg, bb, hue, light, satur;
1690
1691 rr = Float_t(r) / 255;
1692 gg = Float_t(g) / 255;
1693 bb = Float_t(b) / 255;
1694
1695 TColor::RGBtoHLS(rr, gg, bb, hue, light, satur);
1696
1697 h = (Int_t) (hue/360 * 255);
1698 l = (Int_t) (light * 255);
1699 s = (Int_t) (satur * 255);
1700}
1701
1702////////////////////////////////////////////////////////////////////////////////
1703/// Initialize this color and its associated colors.
1704
1706{
1708 fRed = r;
1709 fGreen = g;
1710 fBlue = b;
1711
1712 if (fRed < 0) return;
1713
1715
1716 Int_t nplanes = 16;
1717 if (gVirtualX) gVirtualX->GetPlanes(nplanes);
1718 if (nplanes == 0) nplanes = 16;
1719
1720 // allocate color now (can be delayed when we have a large colormap)
1721#ifndef R__WIN32
1722 if (nplanes < 15)
1723#endif
1724 Allocate();
1725
1726 if (fNumber > 50) return;
1727
1728 // now define associated colors for WBOX shading
1729 Float_t dr, dg, db, lr, lg, lb;
1730
1731 // set dark color
1732 HLStoRGB(fHue, 0.7*fLight, fSaturation, dr, dg, db);
1733 TColor *dark = gROOT->GetColor(100+fNumber);
1734 if (dark) {
1735 if (nplanes > 8) dark->SetRGB(dr, dg, db);
1736 else dark->SetRGB(0.3,0.3,0.3);
1737 }
1738
1739 // set light color
1740 HLStoRGB(fHue, 1.2*fLight, fSaturation, lr, lg, lb);
1741 TColor *light = gROOT->GetColor(150+fNumber);
1742 if (light) {
1743 if (nplanes > 8) light->SetRGB(lr, lg, lb);
1744 else light->SetRGB(0.8,0.8,0.8);
1745 }
1747}
1748
1749////////////////////////////////////////////////////////////////////////////////
1750/// Make this color known to the graphics system.
1751
1753{
1754 if (gVirtualX && !gROOT->IsBatch())
1755
1756 gVirtualX->SetRGB(fNumber, GetRed(), GetGreen(), GetBlue());
1757}
1758
1759////////////////////////////////////////////////////////////////////////////////
1760/// Static method returning color number for color specified by
1761/// hex color string of form: "#rrggbb", where rr, gg and bb are in
1762/// hex between [0,FF], e.g. "#c0c0c0".
1763///
1764/// The color retrieval is done using a threshold defined by SetColorThreshold.
1765///
1766/// If specified color does not exist it will be created with as
1767/// name "#rrggbb" with rr, gg and bb in hex between [0,FF].
1768
1769Int_t TColor::GetColor(const char *hexcolor)
1770{
1771 if (hexcolor && *hexcolor == '#') {
1772 Int_t r, g, b;
1773 if (sscanf(hexcolor+1, "%02x%02x%02x", &r, &g, &b) == 3)
1774 return GetColor(r, g, b);
1775 }
1776 ::Error("TColor::GetColor(const char*)", "incorrect color string");
1777 return 0;
1778}
1779
1780////////////////////////////////////////////////////////////////////////////////
1781/// Static method returning color number for color specified by
1782/// r, g and b. The r,g,b should be in the range [0,1].
1783///
1784/// The color retrieval is done using a threshold defined by SetColorThreshold.
1785///
1786/// If specified color does not exist it will be created
1787/// with as name "#rrggbb" with rr, gg and bb in hex between
1788/// [0,FF].
1789
1791{
1792 Int_t rr, gg, bb;
1793 rr = Int_t(r * 255);
1794 gg = Int_t(g * 255);
1795 bb = Int_t(b * 255);
1796
1797 return GetColor(rr, gg, bb);
1798}
1799
1800////////////////////////////////////////////////////////////////////////////////
1801/// Static method returning color number for color specified by
1802/// system dependent pixel value. Pixel values can be obtained, e.g.,
1803/// from the GUI color picker.
1804///
1805/// The color retrieval is done using a threshold defined by SetColorThreshold.
1806
1807
1809{
1810 Int_t r, g, b;
1811
1812 Pixel2RGB(pixel, r, g, b);
1813
1814 return GetColor(r, g, b);
1815}
1816
1817////////////////////////////////////////////////////////////////////////////////
1818/// This method specifies the color threshold used by GetColor to retrieve a color.
1819///
1820/// \param[in] t Color threshold. By default is equal to 1./31. or 1./255.
1821/// depending on the number of available color planes.
1822///
1823/// When GetColor is called, it scans the defined colors and compare them to the
1824/// requested color.
1825/// If the Red Green and Blue values passed to GetColor are Rr Gr Br
1826/// and Rd Gd Bd the values of a defined color. These two colors are considered equal
1827/// if (abs(Rr-Rd) < t & abs(Br-Bd) < t & abs(Br-Bd) < t). If this test passes,
1828/// the color defined by Rd Gd Bd is returned by GetColor.
1829///
1830/// To make sure GetColor will return a color having exactly the requested
1831/// R G B values it is enough to specify a nul :
1832/// ~~~ {.cpp}
1833/// TColor::SetColorThreshold(0.);
1834/// ~~~
1835///
1836/// To reset the color threshold to its default value it is enough to do:
1837/// ~~~ {.cpp}
1838/// TColor::SetColorThreshold(-1.);
1839/// ~~~
1840
1842{
1843 gColorThreshold = t;
1844}
1845
1846////////////////////////////////////////////////////////////////////////////////
1847/// Static method returning color number for color specified by
1848/// r, g and b. The r,g,b should be in the range [0,255].
1849/// If the specified color does not exist it will be created
1850/// with as name "#rrggbb" with rr, gg and bb in hex between
1851/// [0,FF].
1852///
1853/// The color retrieval is done using a threshold defined by SetColorThreshold.
1854
1855
1857{
1859 if (r < 0) r = 0;
1860 if (g < 0) g = 0;
1861 if (b < 0) b = 0;
1862 if (r > 255) r = 255;
1863 if (g > 255) g = 255;
1864 if (b > 255) b = 255;
1865
1866 // Get list of all defined colors
1867 TObjArray *colors = (TObjArray*) gROOT->GetListOfColors();
1868
1869 TColor *color = 0;
1870
1871 // Look for color by name
1872 if ((color = (TColor*) colors->FindObject(Form("#%02x%02x%02x", r, g, b))))
1873 // We found the color by name, so we use that right away
1874 return color->GetNumber();
1875
1876 Float_t rr, gg, bb;
1877 rr = Float_t(r)/255.;
1878 gg = Float_t(g)/255.;
1879 bb = Float_t(b)/255.;
1880
1881 TIter next(colors);
1882
1883 Float_t thres;
1884 if (gColorThreshold >= 0) {
1885 thres = gColorThreshold;
1886 } else {
1887 Int_t nplanes = 16;
1888 thres = 1.0/31.0; // 5 bits per color : 0 - 0x1F !
1889 if (gVirtualX) gVirtualX->GetPlanes(nplanes);
1890 if (nplanes >= 24) thres = 1.0/255.0; // 8 bits per color : 0 - 0xFF !
1891 }
1892
1893 // Loop over all defined colors
1894 while ((color = (TColor*)next())) {
1895 if (TMath::Abs(color->GetRed() - rr) > thres) continue;
1896 if (TMath::Abs(color->GetGreen() - gg) > thres) continue;
1897 if (TMath::Abs(color->GetBlue() - bb) > thres) continue;
1898 // We found a matching color in the color table
1899 return color->GetNumber();
1900 }
1901
1902 // We didn't find a matching color in the color table, so we
1903 // add it. Note name is of the form "#rrggbb" where rr, etc. are
1904 // hexadecimal numbers.
1905 color = new TColor(colors->GetLast()+1, rr, gg, bb,
1906 Form("#%02x%02x%02x", r, g, b));
1907
1908 return color->GetNumber();
1909}
1910
1911////////////////////////////////////////////////////////////////////////////////
1912/// Static function: Returns the bright color number corresponding to n
1913/// If the TColor object does not exist, it is created.
1914/// The convention is that the bright color nb = n+150
1915
1917{
1918 if (n < 0) return -1;
1919
1920 // Get list of all defined colors
1921 TObjArray *colors = (TObjArray*) gROOT->GetListOfColors();
1922 Int_t ncolors = colors->GetSize();
1923 // Get existing color at index n
1924 TColor *color = 0;
1925 if (n < ncolors) color = (TColor*)colors->At(n);
1926 if (!color) return -1;
1927
1928 //Get the rgb of the the new bright color corresponding to color n
1929 Float_t r,g,b;
1930 HLStoRGB(color->GetHue(), 1.2*color->GetLight(), color->GetSaturation(), r, g, b);
1931
1932 //Build the bright color (unless the slot nb is already used)
1933 Int_t nb = n+150;
1934 TColor *colorb = 0;
1935 if (nb < ncolors) colorb = (TColor*)colors->At(nb);
1936 if (colorb) return nb;
1937 colorb = new TColor(nb,r,g,b);
1938 colorb->SetName(Form("%s_bright",color->GetName()));
1939 colors->AddAtAndExpand(colorb,nb);
1940 return nb;
1941}
1942
1943////////////////////////////////////////////////////////////////////////////////
1944/// Static function: Returns the dark color number corresponding to n
1945/// If the TColor object does not exist, it is created.
1946/// The convention is that the dark color nd = n+100
1947
1949{
1950 if (n < 0) return -1;
1951
1952 // Get list of all defined colors
1953 TObjArray *colors = (TObjArray*) gROOT->GetListOfColors();
1954 Int_t ncolors = colors->GetSize();
1955 // Get existing color at index n
1956 TColor *color = 0;
1957 if (n < ncolors) color = (TColor*)colors->At(n);
1958 if (!color) return -1;
1959
1960 //Get the rgb of the the new dark color corresponding to color n
1961 Float_t r,g,b;
1962 HLStoRGB(color->GetHue(), 0.7*color->GetLight(), color->GetSaturation(), r, g, b);
1963
1964 //Build the dark color (unless the slot nd is already used)
1965 Int_t nd = n+100;
1966 TColor *colord = 0;
1967 if (nd < ncolors) colord = (TColor*)colors->At(nd);
1968 if (colord) return nd;
1969 colord = new TColor(nd,r,g,b);
1970 colord->SetName(Form("%s_dark",color->GetName()));
1971 colors->AddAtAndExpand(colord,nd);
1972 return nd;
1973}
1974
1975////////////////////////////////////////////////////////////////////////////////
1976/// Static function: Returns the transparent color number corresponding to n.
1977/// The transparency level is given by the alpha value a.
1978
1980{
1981 if (n < 0) return -1;
1982
1983 TColor *color = gROOT->GetColor(n);
1984 if (color) {
1985 TColor *colort = new TColor(gROOT->GetListOfColors()->GetLast()+1,
1986 color->GetRed(), color->GetGreen(), color->GetBlue());
1987 colort->SetAlpha(a);
1988 colort->SetName(Form("%s_transparent",color->GetName()));
1989 return colort->GetNumber();
1990 } else {
1991 ::Error("TColor::GetColorTransparent", "color with index %d not defined", n);
1992 return -1;
1993 }
1994}
1995
1996////////////////////////////////////////////////////////////////////////////////
1997/// Static function: Returns a free color index which can be used to define
1998/// a user custom color.
1999///
2000/// ~~~ {.cpp}
2001/// Int_t ci = TColor::GetFreeColorIndex();
2002/// TColor *color = new TColor(ci, 0.1, 0.2, 0.3);
2003/// ~~~
2004
2006{
2007 return gHighestColorIndex+1;
2008}
2009
2010////////////////////////////////////////////////////////////////////////////////
2011/// Static method that given a color index number, returns the corresponding
2012/// pixel value. This pixel value can be used in the GUI classes. This call
2013/// does not work in batch mode since it needs to communicate with the
2014/// graphics system.
2015
2017{
2019 TColor *color = gROOT->GetColor(ci);
2020 if (color)
2021 return color->GetPixel();
2022 else
2023 ::Warning("TColor::Number2Pixel", "color with index %d not defined", ci);
2024
2025 return 0;
2026}
2027
2028////////////////////////////////////////////////////////////////////////////////
2029/// Convert r,g,b to graphics system dependent pixel value.
2030/// The r,g,b triplet must be [0,1].
2031
2033{
2034 if (r < 0) r = 0;
2035 if (g < 0) g = 0;
2036 if (b < 0) b = 0;
2037 if (r > 1) r = 1;
2038 if (g > 1) g = 1;
2039 if (b > 1) b = 1;
2040
2041 ColorStruct_t color;
2042 color.fRed = UShort_t(r * 65535);
2043 color.fGreen = UShort_t(g * 65535);
2044 color.fBlue = UShort_t(b * 65535);
2045 color.fMask = kDoRed | kDoGreen | kDoBlue;
2046 gVirtualX->AllocColor(gVirtualX->GetColormap(), color);
2047 return color.fPixel;
2048}
2049
2050////////////////////////////////////////////////////////////////////////////////
2051/// Convert r,g,b to graphics system dependent pixel value.
2052/// The r,g,b triplet must be [0,255].
2053
2055{
2056 if (r < 0) r = 0;
2057 if (g < 0) g = 0;
2058 if (b < 0) b = 0;
2059 if (r > 255) r = 255;
2060 if (g > 255) g = 255;
2061 if (b > 255) b = 255;
2062
2063 ColorStruct_t color;
2064 color.fRed = UShort_t(r * 257); // 65535/255
2065 color.fGreen = UShort_t(g * 257);
2066 color.fBlue = UShort_t(b * 257);
2067 color.fMask = kDoRed | kDoGreen | kDoBlue;
2068 gVirtualX->AllocColor(gVirtualX->GetColormap(), color);
2069 return color.fPixel;
2070}
2071
2072////////////////////////////////////////////////////////////////////////////////
2073/// Convert machine dependent pixel value (obtained via RGB2Pixel or
2074/// via Number2Pixel() or via TColor::GetPixel()) to r,g,b triplet.
2075/// The r,g,b triplet will be [0,1].
2076
2078{
2079 ColorStruct_t color;
2080 color.fPixel = pixel;
2081 gVirtualX->QueryColor(gVirtualX->GetColormap(), color);
2082 r = (Float_t)color.fRed / 65535;
2083 g = (Float_t)color.fGreen / 65535;
2084 b = (Float_t)color.fBlue / 65535;
2085}
2086
2087////////////////////////////////////////////////////////////////////////////////
2088/// Convert machine dependent pixel value (obtained via RGB2Pixel or
2089/// via Number2Pixel() or via TColor::GetPixel()) to r,g,b triplet.
2090/// The r,g,b triplet will be [0,255].
2091
2093{
2094 ColorStruct_t color;
2095 color.fPixel = pixel;
2096 gVirtualX->QueryColor(gVirtualX->GetColormap(), color);
2097 r = color.fRed / 257;
2098 g = color.fGreen / 257;
2099 b = color.fBlue / 257;
2100}
2101
2102////////////////////////////////////////////////////////////////////////////////
2103/// Convert machine dependent pixel value (obtained via RGB2Pixel or
2104/// via Number2Pixel() or via TColor::GetPixel()) to a hexadecimal string.
2105/// This string can be directly passed to, for example,
2106/// TGClient::GetColorByName(). String will be reused so copy immediately
2107/// if needed.
2108
2110{
2111 static TString tempbuf;
2112 Int_t r, g, b;
2113 Pixel2RGB(pixel, r, g, b);
2114 tempbuf.Form("#%02x%02x%02x", r, g, b);
2115 return tempbuf;
2116}
2117
2118////////////////////////////////////////////////////////////////////////////////
2119/// Save a color with index > 228 as a C++ statement(s) on output stream out.
2120
2121void TColor::SaveColor(std::ostream &out, Int_t ci)
2122{
2123 char quote = '"';
2124 Float_t r,g,b,a;
2125 Int_t ri, gi, bi;
2126 TString cname;
2127
2128 TColor *c = gROOT->GetColor(ci);
2129 if (c) {
2130 c->GetRGB(r, g, b);
2131 a = c->GetAlpha();
2132 } else {
2133 return;
2134 }
2135
2136 if (gROOT->ClassSaved(TColor::Class())) {
2137 out << std::endl;
2138 } else {
2139 out << std::endl;
2140 out << " Int_t ci; // for color index setting" << std::endl;
2141 out << " TColor *color; // for color definition with alpha" << std::endl;
2142 }
2143
2144 if (a<1) {
2145 out<<" ci = "<<ci<<";"<<std::endl;
2146 out<<" color = new TColor(ci, "<<r<<", "<<g<<", "<<b<<", "
2147 <<"\" \", "<<a<<");"<<std::endl;
2148 } else {
2149 ri = (Int_t)(255*r);
2150 gi = (Int_t)(255*g);
2151 bi = (Int_t)(255*b);
2152 cname.Form("#%02x%02x%02x", ri, gi, bi);
2153 out<<" ci = TColor::GetColor("<<quote<<cname.Data()<<quote<<");"<<std::endl;
2154 }
2155}
2156
2157////////////////////////////////////////////////////////////////////////////////
2158/// Return whether all colors return grayscale values.
2160{
2161 return fgGrayscaleMode;
2162}
2163
2164////////////////////////////////////////////////////////////////////////////////
2165/// Set whether all colors should return grayscale values.
2166
2167void TColor::SetGrayscale(Bool_t set /*= kTRUE*/)
2168{
2169 if (fgGrayscaleMode == set) return;
2170
2171 fgGrayscaleMode = set;
2172
2173 if (!gVirtualX || gROOT->IsBatch()) return;
2174
2176 TIter iColor(gROOT->GetListOfColors());
2177 TColor* color = 0;
2178 while ((color = (TColor*) iColor()))
2179 color->Allocate();
2180}
2181
2182////////////////////////////////////////////////////////////////////////////////
2183/// Static function creating a color table with several connected linear gradients.
2184///
2185/// - Number: The number of end point colors that will form the gradients.
2186/// Must be at least 2.
2187/// - Stops: Where in the whole table the end point colors should lie.
2188/// Each entry must be on [0, 1], each entry must be greater than
2189/// the previous entry.
2190/// - Red, Green, Blue: The end point color values.
2191/// Each entry must be on [0, 1]
2192/// - NColors: Total number of colors in the table. Must be at least 1.
2193///
2194/// Returns a positive value on success and -1 on error.
2195///
2196/// The table is constructed by tracing lines between the given points in
2197/// RGB space. Each color value may have a value between 0 and 1. The
2198/// difference between consecutive "Stops" values gives the fraction of
2199/// space in the whole table that should be used for the interval between
2200/// the corresponding color values.
2201///
2202/// Normally the first element of Stops should be 0 and the last should be 1.
2203/// If this is not true, fewer than NColors will be used in proportion with
2204/// the total interval between the first and last elements of Stops.
2205///
2206/// This definition is similar to the povray-definition of gradient
2207/// color tables.
2208///
2209/// For instance:
2210/// ~~~ {.cpp}
2211/// UInt_t Number = 3;
2212/// Double_t Red[3] = { 0.0, 1.0, 1.0 };
2213/// Double_t Green[3] = { 0.0, 0.0, 1.0 };
2214/// Double_t Blue[3] = { 1.0, 0.0, 1.0 };
2215/// Double_t Stops[3] = { 0.0, 0.4, 1.0 };
2216/// ~~~
2217/// This defines a table in which there are three color end points:
2218/// RGB = {0, 0, 1}, {1, 0, 0}, and {1, 1, 1} = blue, red, white
2219/// The first 40% of the table is used to go linearly from blue to red.
2220/// The remaining 60% of the table is used to go linearly from red to white.
2221///
2222/// If you define a very short interval such that less than one color fits
2223/// in it, no colors at all will be allocated. If this occurs for all
2224/// intervals, ROOT will revert to the default palette.
2225///
2226/// Original code by Andreas Zoglauer (zog@mpe.mpg.de)
2227
2229 Double_t* Red, Double_t* Green,
2230 Double_t* Blue, UInt_t NColors, Float_t alpha)
2231{
2233
2234 UInt_t g, c;
2235 UInt_t nPalette = 0;
2236 Int_t *palette = new Int_t[NColors+1];
2237 UInt_t nColorsGradient;
2238
2239 if(Number < 2 || NColors < 1){
2240 delete [] palette;
2241 return -1;
2242 }
2243
2244 // Check if all RGB values are between 0.0 and 1.0 and
2245 // Stops goes from 0.0 to 1.0 in increasing order.
2246 for (c = 0; c < Number; c++) {
2247 if (Red[c] < 0 || Red[c] > 1.0 ||
2248 Green[c] < 0 || Green[c] > 1.0 ||
2249 Blue[c] < 0 || Blue[c] > 1.0 ||
2250 Stops[c] < 0 || Stops[c] > 1.0) {
2251 delete [] palette;
2252 return -1;
2253 }
2254 if (c >= 1) {
2255 if (Stops[c-1] > Stops[c]) {
2256 delete [] palette;
2257 return -1;
2258 }
2259 }
2260 }
2261
2262 // Now create the colors and add them to the default palette:
2263
2264 // For each defined gradient...
2265 for (g = 1; g < Number; g++) {
2266 // create the colors...
2267 nColorsGradient = (Int_t) (floor(NColors*Stops[g]) - floor(NColors*Stops[g-1]));
2268 for (c = 0; c < nColorsGradient; c++) {
2269 new TColor( Float_t(Red[g-1] + c * (Red[g] - Red[g-1]) / nColorsGradient),
2270 Float_t(Green[g-1] + c * (Green[g] - Green[g-1])/ nColorsGradient),
2271 Float_t(Blue[g-1] + c * (Blue[g] - Blue[g-1]) / nColorsGradient),
2272 alpha);
2273 palette[nPalette] = gHighestColorIndex;
2274 nPalette++;
2275 }
2276 }
2277
2278 TColor::SetPalette(nPalette, palette);
2279 delete [] palette;
2280 return gHighestColorIndex + 1 - NColors;
2281}
2282
2283
2284////////////////////////////////////////////////////////////////////////////////
2285/// Static function.
2286/// The color palette is used by the histogram classes
2287/// (see TH1::Draw options).
2288/// For example TH1::Draw("col") draws a 2-D histogram with cells
2289/// represented by a box filled with a color CI function of the cell content.
2290/// if the cell content is N, the color CI used will be the color number
2291/// in colors[N],etc. If the maximum cell content is > ncolors, all
2292/// cell contents are scaled to ncolors.
2293///
2294/// `if ncolors <= 0` a default palette (see below) of 50 colors is
2295/// defined. The colors defined in this palette are OK for coloring pads, labels.
2296///
2297/// ~~~ {.cpp}
2298/// index 0->9 : grey colors from light to dark grey
2299/// index 10->19 : "brown" colors
2300/// index 20->29 : "blueish" colors
2301/// index 30->39 : "redish" colors
2302/// index 40->49 : basic colors
2303/// ~~~
2304///
2305/// `if ncolors == 1 && colors == 0`, a Rainbow Color map is created
2306/// with 50 colors. It is kept for backward compatibility. Better palettes like
2307/// kBird are recommended.
2308///
2309/// High quality predefined palettes with 255 colors are available when `colors == 0`.
2310/// The following value of `ncolors` give access to:
2311///
2312/// ~~~ {.cpp}
2313/// if ncolors = 51 and colors=0, a Deep Sea palette is used.
2314/// if ncolors = 52 and colors=0, a Grey Scale palette is used.
2315/// if ncolors = 53 and colors=0, a Dark Body Radiator palette is used.
2316/// if ncolors = 54 and colors=0, a Two-Color Hue palette is used.(dark blue through neutral gray to bright yellow)
2317/// if ncolors = 55 and colors=0, a Rain Bow palette is used.
2318/// if ncolors = 56 and colors=0, an Inverted Dark Body Radiator palette is used.
2319/// if ncolors = 57 and colors=0, a monotonically increasing L value palette is used.
2320/// if ncolors = 58 and colors=0, a Cubehelix palette is used
2321/// (Cf. Dave Green's "cubehelix" colour scheme at http://www.mrao.cam.ac.uk/~dag/CUBEHELIX/)
2322/// if ncolors = 59 and colors=0, a Green Red Violet palette is used.
2323/// if ncolors = 60 and colors=0, a Blue Red Yellow palette is used.
2324/// if ncolors = 61 and colors=0, an Ocean palette is used.
2325/// if ncolors = 62 and colors=0, a Color Printable On Grey palette is used.
2326/// if ncolors = 63 and colors=0, an Alpine palette is used.
2327/// if ncolors = 64 and colors=0, an Aquamarine palette is used.
2328/// if ncolors = 65 and colors=0, an Army palette is used.
2329/// if ncolors = 66 and colors=0, an Atlantic palette is used.
2330/// if ncolors = 67 and colors=0, an Aurora palette is used.
2331/// if ncolors = 68 and colors=0, an Avocado palette is used.
2332/// if ncolors = 69 and colors=0, a Beach palette is used.
2333/// if ncolors = 70 and colors=0, a Black Body palette is used.
2334/// if ncolors = 71 and colors=0, a Blue Green Yellow palette is used.
2335/// if ncolors = 72 and colors=0, a Brown Cyan palette is used.
2336/// if ncolors = 73 and colors=0, a CMYK palette is used.
2337/// if ncolors = 74 and colors=0, a Candy palette is used.
2338/// if ncolors = 75 and colors=0, a Cherry palette is used.
2339/// if ncolors = 76 and colors=0, a Coffee palette is used.
2340/// if ncolors = 77 and colors=0, a Dark Rain Bow palette is used.
2341/// if ncolors = 78 and colors=0, a Dark Terrain palette is used.
2342/// if ncolors = 79 and colors=0, a Fall palette is used.
2343/// if ncolors = 80 and colors=0, a Fruit Punch palette is used.
2344/// if ncolors = 81 and colors=0, a Fuchsia palette is used.
2345/// if ncolors = 82 and colors=0, a Grey Yellow palette is used.
2346/// if ncolors = 83 and colors=0, a Green Brown Terrain palette is used.
2347/// if ncolors = 84 and colors=0, a Green Pink palette is used.
2348/// if ncolors = 85 and colors=0, an Island palette is used.
2349/// if ncolors = 86 and colors=0, a Lake palette is used.
2350/// if ncolors = 87 and colors=0, a Light Temperature palette is used.
2351/// if ncolors = 88 and colors=0, a Light Terrain palette is used.
2352/// if ncolors = 89 and colors=0, a Mint palette is used.
2353/// if ncolors = 90 and colors=0, a Neon palette is used.
2354/// if ncolors = 91 and colors=0, a Pastel palette is used.
2355/// if ncolors = 92 and colors=0, a Pearl palette is used.
2356/// if ncolors = 93 and colors=0, a Pigeon palette is used.
2357/// if ncolors = 94 and colors=0, a Plum palette is used.
2358/// if ncolors = 95 and colors=0, a Red Blue palette is used.
2359/// if ncolors = 96 and colors=0, a Rose palette is used.
2360/// if ncolors = 97 and colors=0, a Rust palette is used.
2361/// if ncolors = 98 and colors=0, a Sandy Terrain palette is used.
2362/// if ncolors = 99 and colors=0, a Sienna palette is used.
2363/// if ncolors = 100 and colors=0, a Solar palette is used.
2364/// if ncolors = 101 and colors=0, a South West palette is used.
2365/// if ncolors = 102 and colors=0, a Starry Night palette is used.
2366/// if ncolors = 103 and colors=0, a Sunset palette is used.
2367/// if ncolors = 104 and colors=0, a Temperature Map palette is used.
2368/// if ncolors = 105 and colors=0, a Thermometer palette is used.
2369/// if ncolors = 106 and colors=0, a Valentine palette is used.
2370/// if ncolors = 107 and colors=0, a Visible Spectrum palette is used.
2371/// if ncolors = 108 and colors=0, a Water Melon palette is used.
2372/// if ncolors = 109 and colors=0, a Cool palette is used.
2373/// if ncolors = 110 and colors=0, a Copper palette is used.
2374/// if ncolors = 111 and colors=0, a Gist Earth palette is used.
2375/// if ncolors = 112 and colors=0, a Viridis palette is used.
2376/// if ncolors = 113 and colors=0, a Cividis palette is used.
2377/// ~~~
2378/// These palettes can also be accessed by names:
2379/// ~~~ {.cpp}
2380/// kDeepSea=51, kGreyScale=52, kDarkBodyRadiator=53,
2381/// kBlueYellow= 54, kRainBow=55, kInvertedDarkBodyRadiator=56,
2382/// kBird=57, kCubehelix=58, kGreenRedViolet=59,
2383/// kBlueRedYellow=60, kOcean=61, kColorPrintableOnGrey=62,
2384/// kAlpine=63, kAquamarine=64, kArmy=65,
2385/// kAtlantic=66, kAurora=67, kAvocado=68,
2386/// kBeach=69, kBlackBody=70, kBlueGreenYellow=71,
2387/// kBrownCyan=72, kCMYK=73, kCandy=74,
2388/// kCherry=75, kCoffee=76, kDarkRainBow=77,
2389/// kDarkTerrain=78, kFall=79, kFruitPunch=80,
2390/// kFuchsia=81, kGreyYellow=82, kGreenBrownTerrain=83,
2391/// kGreenPink=84, kIsland=85, kLake=86,
2392/// kLightTemperature=87, kLightTerrain=88, kMint=89,
2393/// kNeon=90, kPastel=91, kPearl=92,
2394/// kPigeon=93, kPlum=94, kRedBlue=95,
2395/// kRose=96, kRust=97, kSandyTerrain=98,
2396/// kSienna=99, kSolar=100, kSouthWest=101,
2397/// kStarryNight=102, kSunset=103, kTemperatureMap=104,
2398/// kThermometer=105, kValentine=106, kVisibleSpectrum=107,
2399/// kWaterMelon=108, kCool=109, kCopper=110,
2400/// kGistEarth=111 kViridis=112, kCividis=113
2401/// ~~~
2402/// For example:
2403/// ~~~ {.cpp}
2404/// gStyle->SetPalette(kBird);
2405/// ~~~
2406/// Set the current palette as "Bird" (number 57).
2407///
2408/// The color numbers specified in the palette can be viewed by selecting
2409/// the item "colors" in the "VIEW" menu of the canvas toolbar.
2410/// The color parameters can be changed via TColor::SetRGB.
2411///
2412/// Note that when drawing a 2D histogram `h2` with the option "COL" or
2413/// "COLZ" or with any "CONT" options using the color map, the number of colors
2414/// used is defined by the number of contours `n` specified with:
2415/// `h2->SetContour(n)`
2416
2418{
2419 Int_t i;
2420
2421 static Int_t paletteType = 0;
2422
2423 Int_t palette[50] = {19,18,17,16,15,14,13,12,11,20,
2424 21,22,23,24,25,26,27,28,29,30, 8,
2425 31,32,33,34,35,36,37,38,39,40, 9,
2426 41,42,43,44,45,47,48,49,46,50, 2,
2427 7, 6, 5, 4, 3, 2,1};
2428
2429 // set default palette (pad type)
2430 if (ncolors <= 0) {
2431 ncolors = 50;
2432 fgPalette.Set(ncolors);
2433 for (i=0;i<ncolors;i++) fgPalette.fArray[i] = palette[i];
2434 paletteType = 1;
2435 return;
2436 }
2437
2438 // set Rainbow Color map. Kept for backward compatibility.
2439 if (ncolors == 1 && colors == 0) {
2440 ncolors = 50;
2441 fgPalette.Set(ncolors);
2442 for (i=0;i<ncolors-1;i++) fgPalette.fArray[i] = 51+i;
2443 fgPalette.fArray[ncolors-1] = kRed; // the last color of this palette is red
2444 paletteType = 2;
2445 return;
2446 }
2447
2448 // High quality palettes (255 levels)
2449 if (colors == 0 && ncolors>50) {
2450
2451 if (!fgPalettesList.fN) fgPalettesList.Set(63); // Right now 63 high quality palettes
2452 Int_t Idx = (Int_t)fgPalettesList.fArray[ncolors-51]; // High quality palettes indices start at 51
2453
2454 // This high quality palette has already been created. Reuse it.
2455 if (Idx > 0) {
2456 Double_t alphas = 10*(fgPalettesList.fArray[ncolors-51]-Idx);
2457 Bool_t same_alpha = TMath::Abs(alpha-alphas) < 0.0001;
2458 if (paletteType == ncolors && same_alpha) return; // The current palette is already this one.
2459 fgPalette.Set(255); // High quality palettes have 255 entries
2460 for (i=0;i<255;i++) fgPalette.fArray[i] = Idx+i;
2461 paletteType = ncolors;
2462
2463 // restore the palette transparency if needed
2464 if (alphas>0 && !same_alpha) {
2465 TColor *ca;
2466 for (i=0;i<255;i++) {
2467 ca = gROOT->GetColor(Idx+i);
2468 ca->SetAlpha(alpha);
2469 }
2470 fgPalettesList.fArray[paletteType-51] = (Double_t)Idx+alpha/10.;
2471 }
2472 return;
2473 }
2474
2476 Double_t stops[9] = { 0.0000, 0.1250, 0.2500, 0.3750, 0.5000, 0.6250, 0.7500, 0.8750, 1.0000};
2477
2478 switch (ncolors) {
2479 // Deep Sea
2480 case 51:
2481 {
2482 Double_t red[9] = { 0./255., 9./255., 13./255., 17./255., 24./255., 32./255., 27./255., 25./255., 29./255.};
2483 Double_t green[9] = { 0./255., 0./255., 0./255., 2./255., 37./255., 74./255., 113./255., 160./255., 221./255.};
2484 Double_t blue[9] = { 28./255., 42./255., 59./255., 78./255., 98./255., 129./255., 154./255., 184./255., 221./255.};
2485 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2486 }
2487 break;
2488
2489 // Grey Scale
2490 case 52:
2491 {
2492 Double_t red[9] = { 0./255., 32./255., 64./255., 96./255., 128./255., 160./255., 192./255., 224./255., 255./255.};
2493 Double_t green[9] = { 0./255., 32./255., 64./255., 96./255., 128./255., 160./255., 192./255., 224./255., 255./255.};
2494 Double_t blue[9] = { 0./255., 32./255., 64./255., 96./255., 128./255., 160./255., 192./255., 224./255., 255./255.};
2495 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2496 }
2497 break;
2498
2499 // Dark Body Radiator
2500 case 53:
2501 {
2502 Double_t red[9] = { 0./255., 45./255., 99./255., 156./255., 212./255., 230./255., 237./255., 234./255., 242./255.};
2503 Double_t green[9] = { 0./255., 0./255., 0./255., 45./255., 101./255., 168./255., 238./255., 238./255., 243./255.};
2504 Double_t blue[9] = { 0./255., 1./255., 1./255., 3./255., 9./255., 8./255., 11./255., 95./255., 230./255.};
2505 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2506 }
2507 break;
2508
2509 // Two-color hue (dark blue through neutral gray to bright yellow)
2510 case 54:
2511 {
2512 Double_t red[9] = { 0./255., 22./255., 44./255., 68./255., 93./255., 124./255., 160./255., 192./255., 237./255.};
2513 Double_t green[9] = { 0./255., 16./255., 41./255., 67./255., 93./255., 125./255., 162./255., 194./255., 241./255.};
2514 Double_t blue[9] = { 97./255., 100./255., 99./255., 99./255., 93./255., 68./255., 44./255., 26./255., 74./255.};
2515 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2516 }
2517 break;
2518
2519 // Rain Bow
2520 case 55:
2521 {
2522 Double_t red[9] = { 0./255., 5./255., 15./255., 35./255., 102./255., 196./255., 208./255., 199./255., 110./255.};
2523 Double_t green[9] = { 0./255., 48./255., 124./255., 192./255., 206./255., 226./255., 97./255., 16./255., 0./255.};
2524 Double_t blue[9] = { 99./255., 142./255., 198./255., 201./255., 90./255., 22./255., 13./255., 8./255., 2./255.};
2525 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2526 }
2527 break;
2528
2529 // Inverted Dark Body Radiator
2530 case 56:
2531 {
2532 Double_t red[9] = { 242./255., 234./255., 237./255., 230./255., 212./255., 156./255., 99./255., 45./255., 0./255.};
2533 Double_t green[9] = { 243./255., 238./255., 238./255., 168./255., 101./255., 45./255., 0./255., 0./255., 0./255.};
2534 Double_t blue[9] = { 230./255., 95./255., 11./255., 8./255., 9./255., 3./255., 1./255., 1./255., 0./255.};
2535 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2536 }
2537 break;
2538
2539 // Bird
2540 case 57:
2541 {
2542 Double_t red[9] = { 0.2082, 0.0592, 0.0780, 0.0232, 0.1802, 0.5301, 0.8186, 0.9956, 0.9764};
2543 Double_t green[9] = { 0.1664, 0.3599, 0.5041, 0.6419, 0.7178, 0.7492, 0.7328, 0.7862, 0.9832};
2544 Double_t blue[9] = { 0.5293, 0.8684, 0.8385, 0.7914, 0.6425, 0.4662, 0.3499, 0.1968, 0.0539};
2545 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2546 }
2547 break;
2548
2549 // Cubehelix
2550 case 58:
2551 {
2552 Double_t red[9] = { 0.0000, 0.0956, 0.0098, 0.2124, 0.6905, 0.9242, 0.7914, 0.7596, 1.0000};
2553 Double_t green[9] = { 0.0000, 0.1147, 0.3616, 0.5041, 0.4577, 0.4691, 0.6905, 0.9237, 1.0000};
2554 Double_t blue[9] = { 0.0000, 0.2669, 0.3121, 0.1318, 0.2236, 0.6741, 0.9882, 0.9593, 1.0000};
2555 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2556 }
2557 break;
2558
2559 // Green Red Violet
2560 case 59:
2561 {
2562 Double_t red[9] = {13./255., 23./255., 25./255., 63./255., 76./255., 104./255., 137./255., 161./255., 206./255.};
2563 Double_t green[9] = {95./255., 67./255., 37./255., 21./255., 0./255., 12./255., 35./255., 52./255., 79./255.};
2564 Double_t blue[9] = { 4./255., 3./255., 2./255., 6./255., 11./255., 22./255., 49./255., 98./255., 208./255.};
2565 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2566 }
2567 break;
2568
2569 // Blue Red Yellow
2570 case 60:
2571 {
2572 Double_t red[9] = {0./255., 61./255., 89./255., 122./255., 143./255., 160./255., 185./255., 204./255., 231./255.};
2573 Double_t green[9] = {0./255., 0./255., 0./255., 0./255., 14./255., 37./255., 72./255., 132./255., 235./255.};
2574 Double_t blue[9] = {0./255., 140./255., 224./255., 144./255., 4./255., 5./255., 6./255., 9./255., 13./255.};
2575 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2576 }
2577 break;
2578
2579 // Ocean
2580 case 61:
2581 {
2582 Double_t red[9] = { 14./255., 7./255., 2./255., 0./255., 5./255., 11./255., 55./255., 131./255., 229./255.};
2583 Double_t green[9] = {105./255., 56./255., 26./255., 1./255., 42./255., 74./255., 131./255., 171./255., 229./255.};
2584 Double_t blue[9] = { 2./255., 21./255., 35./255., 60./255., 92./255., 113./255., 160./255., 185./255., 229./255.};
2585 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2586 }
2587 break;
2588
2589 // Color Printable On Grey
2590 case 62:
2591 {
2592 Double_t red[9] = { 0./255., 0./255., 0./255., 70./255., 148./255., 231./255., 235./255., 237./255., 244./255.};
2593 Double_t green[9] = { 0./255., 0./255., 0./255., 0./255., 0./255., 69./255., 67./255., 216./255., 244./255.};
2594 Double_t blue[9] = { 0./255., 102./255., 228./255., 231./255., 177./255., 124./255., 137./255., 20./255., 244./255.};
2595 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2596 }
2597 break;
2598
2599 // Alpine
2600 case 63:
2601 {
2602 Double_t red[9] = { 50./255., 56./255., 63./255., 68./255., 93./255., 121./255., 165./255., 192./255., 241./255.};
2603 Double_t green[9] = { 66./255., 81./255., 91./255., 96./255., 111./255., 128./255., 155./255., 189./255., 241./255.};
2604 Double_t blue[9] = { 97./255., 91./255., 75./255., 65./255., 77./255., 103./255., 143./255., 167./255., 217./255.};
2605 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2606 }
2607 break;
2608
2609 // Aquamarine
2610 case 64:
2611 {
2612 Double_t red[9] = { 145./255., 166./255., 167./255., 156./255., 131./255., 114./255., 101./255., 112./255., 132./255.};
2613 Double_t green[9] = { 158./255., 178./255., 179./255., 181./255., 163./255., 154./255., 144./255., 152./255., 159./255.};
2614 Double_t blue[9] = { 190./255., 199./255., 201./255., 192./255., 176./255., 169./255., 160./255., 166./255., 190./255.};
2615 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2616 }
2617 break;
2618
2619 // Army
2620 case 65:
2621 {
2622 Double_t red[9] = { 93./255., 91./255., 99./255., 108./255., 130./255., 125./255., 132./255., 155./255., 174./255.};
2623 Double_t green[9] = { 126./255., 124./255., 128./255., 129./255., 131./255., 121./255., 119./255., 153./255., 173./255.};
2624 Double_t blue[9] = { 103./255., 94./255., 87./255., 85./255., 80./255., 85./255., 107./255., 120./255., 146./255.};
2625 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2626 }
2627 break;
2628
2629 // Atlantic
2630 case 66:
2631 {
2632 Double_t red[9] = { 24./255., 40./255., 69./255., 90./255., 104./255., 114./255., 120./255., 132./255., 103./255.};
2633 Double_t green[9] = { 29./255., 52./255., 94./255., 127./255., 150./255., 162./255., 159./255., 151./255., 101./255.};
2634 Double_t blue[9] = { 29./255., 52./255., 96./255., 132./255., 162./255., 181./255., 184./255., 186./255., 131./255.};
2635 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2636 }
2637 break;
2638
2639 // Aurora
2640 case 67:
2641 {
2642 Double_t red[9] = { 46./255., 38./255., 61./255., 92./255., 113./255., 121./255., 132./255., 150./255., 191./255.};
2643 Double_t green[9] = { 46./255., 36./255., 40./255., 69./255., 110./255., 135./255., 131./255., 92./255., 34./255.};
2644 Double_t blue[9] = { 46./255., 80./255., 74./255., 70./255., 81./255., 105./255., 165./255., 211./255., 225./255.};
2645 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2646 }
2647 break;
2648
2649 // Avocado
2650 case 68:
2651 {
2652 Double_t red[9] = { 0./255., 4./255., 12./255., 30./255., 52./255., 101./255., 142./255., 190./255., 237./255.};
2653 Double_t green[9] = { 0./255., 40./255., 86./255., 121./255., 140./255., 172./255., 187./255., 213./255., 240./255.};
2654 Double_t blue[9] = { 0./255., 9./255., 14./255., 18./255., 21./255., 23./255., 27./255., 35./255., 101./255.};
2655 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2656 }
2657 break;
2658
2659 // Beach
2660 case 69:
2661 {
2662 Double_t red[9] = { 198./255., 206./255., 206./255., 211./255., 198./255., 181./255., 161./255., 171./255., 244./255.};
2663 Double_t green[9] = { 103./255., 133./255., 150./255., 172./255., 178./255., 174./255., 163./255., 175./255., 244./255.};
2664 Double_t blue[9] = { 49./255., 54./255., 55./255., 66./255., 91./255., 130./255., 184./255., 224./255., 244./255.};
2665 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2666 }
2667 break;
2668
2669 // Black Body
2670 case 70:
2671 {
2672 Double_t red[9] = { 243./255., 243./255., 240./255., 240./255., 241./255., 239./255., 186./255., 151./255., 129./255.};
2673 Double_t green[9] = { 0./255., 46./255., 99./255., 149./255., 194./255., 220./255., 183./255., 166./255., 147./255.};
2674 Double_t blue[9] = { 6./255., 8./255., 36./255., 91./255., 169./255., 235./255., 246./255., 240./255., 233./255.};
2675 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2676 }
2677 break;
2678
2679 // Blue Green Yellow
2680 case 71:
2681 {
2682 Double_t red[9] = { 22./255., 19./255., 19./255., 25./255., 35./255., 53./255., 88./255., 139./255., 210./255.};
2683 Double_t green[9] = { 0./255., 32./255., 69./255., 108./255., 135./255., 159./255., 183./255., 198./255., 215./255.};
2684 Double_t blue[9] = { 77./255., 96./255., 110./255., 116./255., 110./255., 100./255., 90./255., 78./255., 70./255.};
2685 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2686 }
2687 break;
2688
2689 // Brown Cyan
2690 case 72:
2691 {
2692 Double_t red[9] = { 68./255., 116./255., 165./255., 182./255., 189./255., 180./255., 145./255., 111./255., 71./255.};
2693 Double_t green[9] = { 37./255., 82./255., 135./255., 178./255., 204./255., 225./255., 221./255., 202./255., 147./255.};
2694 Double_t blue[9] = { 16./255., 55./255., 105./255., 147./255., 196./255., 226./255., 232./255., 224./255., 178./255.};
2695 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2696 }
2697 break;
2698
2699 // CMYK
2700 case 73:
2701 {
2702 Double_t red[9] = { 61./255., 99./255., 136./255., 181./255., 213./255., 225./255., 198./255., 136./255., 24./255.};
2703 Double_t green[9] = { 149./255., 140./255., 96./255., 83./255., 132./255., 178./255., 190./255., 135./255., 22./255.};
2704 Double_t blue[9] = { 214./255., 203./255., 168./255., 135./255., 110./255., 100./255., 111./255., 113./255., 22./255.};
2705 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2706 }
2707 break;
2708
2709 // Candy
2710 case 74:
2711 {
2712 Double_t red[9] = { 76./255., 120./255., 156./255., 183./255., 197./255., 180./255., 162./255., 154./255., 140./255.};
2713 Double_t green[9] = { 34./255., 35./255., 42./255., 69./255., 102./255., 137./255., 164./255., 188./255., 197./255.};
2714 Double_t blue[9] = { 64./255., 69./255., 78./255., 105./255., 142./255., 177./255., 205./255., 217./255., 198./255.};
2715 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2716 }
2717 break;
2718
2719 // Cherry
2720 case 75:
2721 {
2722 Double_t red[9] = { 37./255., 102./255., 157./255., 188./255., 196./255., 214./255., 223./255., 235./255., 251./255.};
2723 Double_t green[9] = { 37./255., 29./255., 25./255., 37./255., 67./255., 91./255., 132./255., 185./255., 251./255.};
2724 Double_t blue[9] = { 37./255., 32./255., 33./255., 45./255., 66./255., 98./255., 137./255., 187./255., 251./255.};
2725 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2726 }
2727 break;
2728
2729 // Coffee
2730 case 76:
2731 {
2732 Double_t red[9] = { 79./255., 100./255., 119./255., 137./255., 153./255., 172./255., 192./255., 205./255., 250./255.};
2733 Double_t green[9] = { 63./255., 79./255., 93./255., 103./255., 115./255., 135./255., 167./255., 196./255., 250./255.};
2734 Double_t blue[9] = { 51./255., 59./255., 66./255., 61./255., 62./255., 70./255., 110./255., 160./255., 250./255.};
2735 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2736 }
2737 break;
2738
2739 // Dark Rain Bow
2740 case 77:
2741 {
2742 Double_t red[9] = { 43./255., 44./255., 50./255., 66./255., 125./255., 172./255., 178./255., 155./255., 157./255.};
2743 Double_t green[9] = { 63./255., 63./255., 85./255., 101./255., 138./255., 163./255., 122./255., 51./255., 39./255.};
2744 Double_t blue[9] = { 121./255., 101./255., 58./255., 44./255., 47./255., 55./255., 57./255., 44./255., 43./255.};
2745 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2746 }
2747 break;
2748
2749 // Dark Terrain
2750 case 78:
2751 {
2752 Double_t red[9] = { 0./255., 41./255., 62./255., 79./255., 90./255., 87./255., 99./255., 140./255., 228./255.};
2753 Double_t green[9] = { 0./255., 57./255., 81./255., 93./255., 85./255., 70./255., 71./255., 125./255., 228./255.};
2754 Double_t blue[9] = { 95./255., 91./255., 91./255., 82./255., 60./255., 43./255., 44./255., 112./255., 228./255.};
2755 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2756 }
2757 break;
2758
2759 // Fall
2760 case 79:
2761 {
2762 Double_t red[9] = { 49./255., 59./255., 72./255., 88./255., 114./255., 141./255., 176./255., 205./255., 222./255.};
2763 Double_t green[9] = { 78./255., 72./255., 66./255., 57./255., 59./255., 75./255., 106./255., 142./255., 173./255.};
2764 Double_t blue[9] = { 78./255., 55./255., 46./255., 40./255., 39./255., 39./255., 40./255., 41./255., 47./255.};
2765 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2766 }
2767 break;
2768
2769 // Fruit Punch
2770 case 80:
2771 {
2772 Double_t red[9] = { 243./255., 222./255., 201./255., 185./255., 165./255., 158./255., 166./255., 187./255., 219./255.};
2773 Double_t green[9] = { 94./255., 108./255., 132./255., 135./255., 125./255., 96./255., 68./255., 51./255., 61./255.};
2774 Double_t blue[9] = { 7./255., 9./255., 12./255., 19./255., 45./255., 89./255., 118./255., 146./255., 118./255.};
2775 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2776 }
2777 break;
2778
2779 // Fuchsia
2780 case 81:
2781 {
2782 Double_t red[9] = { 19./255., 44./255., 74./255., 105./255., 137./255., 166./255., 194./255., 206./255., 220./255.};
2783 Double_t green[9] = { 19./255., 28./255., 40./255., 55./255., 82./255., 110./255., 159./255., 181./255., 220./255.};
2784 Double_t blue[9] = { 19./255., 42./255., 68./255., 96./255., 129./255., 157./255., 188./255., 203./255., 220./255.};
2785 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2786 }
2787 break;
2788
2789 // Grey Yellow
2790 case 82:
2791 {
2792 Double_t red[9] = { 33./255., 44./255., 70./255., 99./255., 140./255., 165./255., 199./255., 211./255., 216./255.};
2793 Double_t green[9] = { 38./255., 50./255., 76./255., 105./255., 140./255., 165./255., 191./255., 189./255., 167./255.};
2794 Double_t blue[9] = { 55./255., 67./255., 97./255., 124./255., 140./255., 166./255., 163./255., 129./255., 52./255.};
2795 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2796 }
2797 break;
2798
2799 // Green Brown Terrain
2800 case 83:
2801 {
2802 Double_t red[9] = { 0./255., 33./255., 73./255., 124./255., 136./255., 152./255., 159./255., 171./255., 223./255.};
2803 Double_t green[9] = { 0./255., 43./255., 92./255., 124./255., 134./255., 126./255., 121./255., 144./255., 223./255.};
2804 Double_t blue[9] = { 0./255., 43./255., 68./255., 76./255., 73./255., 64./255., 72./255., 114./255., 223./255.};
2805 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2806 }
2807 break;
2808
2809 // Green Pink
2810 case 84:
2811 {
2812 Double_t red[9] = { 5./255., 18./255., 45./255., 124./255., 193./255., 223./255., 205./255., 128./255., 49./255.};
2813 Double_t green[9] = { 48./255., 134./255., 207./255., 230./255., 193./255., 113./255., 28./255., 0./255., 7./255.};
2814 Double_t blue[9] = { 6./255., 15./255., 41./255., 121./255., 193./255., 226./255., 208./255., 130./255., 49./255.};
2815 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2816 }
2817 break;
2818
2819 // Island
2820 case 85:
2821 {
2822 Double_t red[9] = { 180./255., 106./255., 104./255., 135./255., 164./255., 188./255., 189./255., 165./255., 144./255.};
2823 Double_t green[9] = { 72./255., 126./255., 154./255., 184./255., 198./255., 207./255., 205./255., 190./255., 179./255.};
2824 Double_t blue[9] = { 41./255., 120./255., 158./255., 188./255., 194./255., 181./255., 145./255., 100./255., 62./255.};
2825 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2826 }
2827 break;
2828
2829 // Lake
2830 case 86:
2831 {
2832 Double_t red[9] = { 57./255., 72./255., 94./255., 117./255., 136./255., 154./255., 174./255., 192./255., 215./255.};
2833 Double_t green[9] = { 0./255., 33./255., 68./255., 109./255., 140./255., 171./255., 192./255., 196./255., 209./255.};
2834 Double_t blue[9] = { 116./255., 137./255., 173./255., 201./255., 200./255., 201./255., 203./255., 190./255., 187./255.};
2835 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2836 }
2837 break;
2838
2839 // Light Temperature
2840 case 87:
2841 {
2842 Double_t red[9] = { 31./255., 71./255., 123./255., 160./255., 210./255., 222./255., 214./255., 199./255., 183./255.};
2843 Double_t green[9] = { 40./255., 117./255., 171./255., 211./255., 231./255., 220./255., 190./255., 132./255., 65./255.};
2844 Double_t blue[9] = { 234./255., 214./255., 228./255., 222./255., 210./255., 160./255., 105./255., 60./255., 34./255.};
2845 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2846 }
2847 break;
2848
2849 // Light Terrain
2850 case 88:
2851 {
2852 Double_t red[9] = { 123./255., 108./255., 109./255., 126./255., 154./255., 172./255., 188./255., 196./255., 218./255.};
2853 Double_t green[9] = { 184./255., 138./255., 130./255., 133./255., 154./255., 175./255., 188./255., 196./255., 218./255.};
2854 Double_t blue[9] = { 208./255., 130./255., 109./255., 99./255., 110./255., 122./255., 150./255., 171./255., 218./255.};
2855 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2856 }
2857 break;
2858
2859 // Mint
2860 case 89:
2861 {
2862 Double_t red[9] = { 105./255., 106./255., 122./255., 143./255., 159./255., 172./255., 176./255., 181./255., 207./255.};
2863 Double_t green[9] = { 252./255., 197./255., 194./255., 187./255., 174./255., 162./255., 153./255., 136./255., 125./255.};
2864 Double_t blue[9] = { 146./255., 133./255., 144./255., 155./255., 163./255., 167./255., 166./255., 162./255., 174./255.};
2865 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2866 }
2867 break;
2868
2869 // Neon
2870 case 90:
2871 {
2872 Double_t red[9] = { 171./255., 141./255., 145./255., 152./255., 154./255., 159./255., 163./255., 158./255., 177./255.};
2873 Double_t green[9] = { 236./255., 143./255., 100./255., 63./255., 53./255., 55./255., 44./255., 31./255., 6./255.};
2874 Double_t blue[9] = { 59./255., 48./255., 46./255., 44./255., 42./255., 54./255., 82./255., 112./255., 179./255.};
2875 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2876 }
2877 break;
2878
2879 // Pastel
2880 case 91:
2881 {
2882 Double_t red[9] = { 180./255., 190./255., 209./255., 223./255., 204./255., 228./255., 205./255., 152./255., 91./255.};
2883 Double_t green[9] = { 93./255., 125./255., 147./255., 172./255., 181./255., 224./255., 233./255., 198./255., 158./255.};
2884 Double_t blue[9] = { 236./255., 218./255., 160./255., 133./255., 114./255., 132./255., 162./255., 220./255., 218./255.};
2885 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2886 }
2887 break;
2888
2889 // Pearl
2890 case 92:
2891 {
2892 Double_t red[9] = { 225./255., 183./255., 162./255., 135./255., 115./255., 111./255., 119./255., 145./255., 211./255.};
2893 Double_t green[9] = { 205./255., 177./255., 166./255., 135./255., 124./255., 117./255., 117./255., 132./255., 172./255.};
2894 Double_t blue[9] = { 186./255., 165./255., 155./255., 135./255., 126./255., 130./255., 150./255., 178./255., 226./255.};
2895 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2896 }
2897 break;
2898
2899 // Pigeon
2900 case 93:
2901 {
2902 Double_t red[9] = { 39./255., 43./255., 59./255., 63./255., 80./255., 116./255., 153./255., 177./255., 223./255.};
2903 Double_t green[9] = { 39./255., 43./255., 59./255., 74./255., 91./255., 114./255., 139./255., 165./255., 223./255.};
2904 Double_t blue[9] = { 39./255., 50./255., 59./255., 70./255., 85./255., 115./255., 151./255., 176./255., 223./255.};
2905 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2906 }
2907 break;
2908
2909 // Plum
2910 case 94:
2911 {
2912 Double_t red[9] = { 0./255., 38./255., 60./255., 76./255., 84./255., 89./255., 101./255., 128./255., 204./255.};
2913 Double_t green[9] = { 0./255., 10./255., 15./255., 23./255., 35./255., 57./255., 83./255., 123./255., 199./255.};
2914 Double_t blue[9] = { 0./255., 11./255., 22./255., 40./255., 63./255., 86./255., 97./255., 94./255., 85./255.};
2915 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2916 }
2917 break;
2918
2919 // Red Blue
2920 case 95:
2921 {
2922 Double_t red[9] = { 94./255., 112./255., 141./255., 165./255., 167./255., 140./255., 91./255., 49./255., 27./255.};
2923 Double_t green[9] = { 27./255., 46./255., 88./255., 135./255., 166./255., 161./255., 135./255., 97./255., 58./255.};
2924 Double_t blue[9] = { 42./255., 52./255., 81./255., 106./255., 139./255., 158./255., 155./255., 137./255., 116./255.};
2925 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2926 }
2927 break;
2928
2929 // Rose
2930 case 96:
2931 {
2932 Double_t red[9] = { 30./255., 49./255., 79./255., 117./255., 135./255., 151./255., 146./255., 138./255., 147./255.};
2933 Double_t green[9] = { 63./255., 60./255., 72./255., 90./255., 94./255., 94./255., 68./255., 46./255., 16./255.};
2934 Double_t blue[9] = { 18./255., 28./255., 41./255., 56./255., 62./255., 63./255., 50./255., 36./255., 21./255.};
2935 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2936 }
2937 break;
2938
2939 // Rust
2940 case 97:
2941 {
2942 Double_t red[9] = { 0./255., 30./255., 63./255., 101./255., 143./255., 152./255., 169./255., 187./255., 230./255.};
2943 Double_t green[9] = { 0./255., 14./255., 28./255., 42./255., 58./255., 61./255., 67./255., 74./255., 91./255.};
2944 Double_t blue[9] = { 39./255., 26./255., 21./255., 18./255., 15./255., 14./255., 14./255., 13./255., 13./255.};
2945 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2946 }
2947 break;
2948
2949 // Sandy Terrain
2950 case 98:
2951 {
2952 Double_t red[9] = { 149./255., 140./255., 164./255., 179./255., 182./255., 181./255., 131./255., 87./255., 61./255.};
2953 Double_t green[9] = { 62./255., 70./255., 107./255., 136./255., 144./255., 138./255., 117./255., 87./255., 74./255.};
2954 Double_t blue[9] = { 40./255., 38./255., 45./255., 49./255., 49./255., 49./255., 38./255., 32./255., 34./255.};
2955 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2956 }
2957 break;
2958
2959 // Sienna
2960 case 99:
2961 {
2962 Double_t red[9] = { 99./255., 112./255., 148./255., 165./255., 179./255., 182./255., 183./255., 183./255., 208./255.};
2963 Double_t green[9] = { 39./255., 40./255., 57./255., 79./255., 104./255., 127./255., 148./255., 161./255., 198./255.};
2964 Double_t blue[9] = { 15./255., 16./255., 18./255., 33./255., 51./255., 79./255., 103./255., 129./255., 177./255.};
2965 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2966 }
2967 break;
2968
2969 // Solar
2970 case 100:
2971 {
2972 Double_t red[9] = { 99./255., 116./255., 154./255., 174./255., 200./255., 196./255., 201./255., 201./255., 230./255.};
2973 Double_t green[9] = { 0./255., 0./255., 8./255., 32./255., 58./255., 83./255., 119./255., 136./255., 173./255.};
2974 Double_t blue[9] = { 5./255., 6./255., 7./255., 9./255., 9./255., 14./255., 17./255., 19./255., 24./255.};
2975 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2976 }
2977 break;
2978
2979 // South West
2980 case 101:
2981 {
2982 Double_t red[9] = { 82./255., 106./255., 126./255., 141./255., 155./255., 163./255., 142./255., 107./255., 66./255.};
2983 Double_t green[9] = { 62./255., 44./255., 69./255., 107./255., 135./255., 152./255., 149./255., 132./255., 119./255.};
2984 Double_t blue[9] = { 39./255., 25./255., 31./255., 60./255., 73./255., 68./255., 49./255., 72./255., 188./255.};
2985 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2986 }
2987 break;
2988
2989 // Starry Night
2990 case 102:
2991 {
2992 Double_t red[9] = { 18./255., 29./255., 44./255., 72./255., 116./255., 158./255., 184./255., 208./255., 221./255.};
2993 Double_t green[9] = { 27./255., 46./255., 71./255., 105./255., 146./255., 177./255., 189./255., 190./255., 183./255.};
2994 Double_t blue[9] = { 39./255., 55./255., 80./255., 108./255., 130./255., 133./255., 124./255., 100./255., 76./255.};
2995 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
2996 }
2997 break;
2998
2999 // Sunset
3000 case 103:
3001 {
3002 Double_t red[9] = { 0./255., 48./255., 119./255., 173./255., 212./255., 224./255., 228./255., 228./255., 245./255.};
3003 Double_t green[9] = { 0./255., 13./255., 30./255., 47./255., 79./255., 127./255., 167./255., 205./255., 245./255.};
3004 Double_t blue[9] = { 0./255., 68./255., 75./255., 43./255., 16./255., 22./255., 55./255., 128./255., 245./255.};
3005 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3006 }
3007 break;
3008
3009 // Temperature Map
3010 case 104:
3011 {
3012 Double_t red[9] = { 34./255., 70./255., 129./255., 187./255., 225./255., 226./255., 216./255., 193./255., 179./255.};
3013 Double_t green[9] = { 48./255., 91./255., 147./255., 194./255., 226./255., 229./255., 196./255., 110./255., 12./255.};
3014 Double_t blue[9] = { 234./255., 212./255., 216./255., 224./255., 206./255., 110./255., 53./255., 40./255., 29./255.};
3015 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3016 }
3017 break;
3018
3019 // Thermometer
3020 case 105:
3021 {
3022 Double_t red[9] = { 30./255., 55./255., 103./255., 147./255., 174./255., 203./255., 188./255., 151./255., 105./255.};
3023 Double_t green[9] = { 0./255., 65./255., 138./255., 182./255., 187./255., 175./255., 121./255., 53./255., 9./255.};
3024 Double_t blue[9] = { 191./255., 202./255., 212./255., 208./255., 171./255., 140./255., 97./255., 57./255., 30./255.};
3025 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3026 }
3027 break;
3028
3029 // Valentine
3030 case 106:
3031 {
3032 Double_t red[9] = { 112./255., 97./255., 113./255., 125./255., 138./255., 159./255., 178./255., 188./255., 225./255.};
3033 Double_t green[9] = { 16./255., 17./255., 24./255., 37./255., 56./255., 81./255., 110./255., 136./255., 189./255.};
3034 Double_t blue[9] = { 38./255., 35./255., 46./255., 59./255., 78./255., 103./255., 130./255., 152./255., 201./255.};
3035 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3036 }
3037 break;
3038
3039 // Visible Spectrum
3040 case 107:
3041 {
3042 Double_t red[9] = { 18./255., 72./255., 5./255., 23./255., 29./255., 201./255., 200./255., 98./255., 29./255.};
3043 Double_t green[9] = { 0./255., 0./255., 43./255., 167./255., 211./255., 117./255., 0./255., 0./255., 0./255.};
3044 Double_t blue[9] = { 51./255., 203./255., 177./255., 26./255., 10./255., 9./255., 8./255., 3./255., 0./255.};
3045 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3046 }
3047 break;
3048
3049 // Water Melon
3050 case 108:
3051 {
3052 Double_t red[9] = { 19./255., 42./255., 64./255., 88./255., 118./255., 147./255., 175./255., 187./255., 205./255.};
3053 Double_t green[9] = { 19./255., 55./255., 89./255., 125./255., 154./255., 169./255., 161./255., 129./255., 70./255.};
3054 Double_t blue[9] = { 19./255., 32./255., 47./255., 70./255., 100./255., 128./255., 145./255., 130./255., 75./255.};
3055 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3056 }
3057 break;
3058
3059 // Cool
3060 case 109:
3061 {
3062 Double_t red[9] = { 33./255., 31./255., 42./255., 68./255., 86./255., 111./255., 141./255., 172./255., 227./255.};
3063 Double_t green[9] = { 255./255., 175./255., 145./255., 106./255., 88./255., 55./255., 15./255., 0./255., 0./255.};
3064 Double_t blue[9] = { 255./255., 205./255., 202./255., 203./255., 208./255., 205./255., 203./255., 206./255., 231./255.};
3065 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3066 }
3067 break;
3068
3069 // Copper
3070 case 110:
3071 {
3072 Double_t red[9] = { 0./255., 25./255., 50./255., 79./255., 110./255., 145./255., 181./255., 201./255., 254./255.};
3073 Double_t green[9] = { 0./255., 16./255., 30./255., 46./255., 63./255., 82./255., 101./255., 124./255., 179./255.};
3074 Double_t blue[9] = { 0./255., 12./255., 21./255., 29./255., 39./255., 49./255., 61./255., 74./255., 103./255.};
3075 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3076 }
3077 break;
3078
3079 // Gist Earth
3080 case 111:
3081 {
3082 Double_t red[9] = { 0./255., 13./255., 30./255., 44./255., 72./255., 120./255., 156./255., 200./255., 247./255.};
3083 Double_t green[9] = { 0./255., 36./255., 84./255., 117./255., 141./255., 153./255., 151./255., 158./255., 247./255.};
3084 Double_t blue[9] = { 0./255., 94./255., 100./255., 82./255., 56./255., 66./255., 76./255., 131./255., 247./255.};
3085 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3086 }
3087 break;
3088
3089 // Viridis
3090 case 112:
3091 {
3092 Double_t red[9] = { 26./255., 51./255., 43./255., 33./255., 28./255., 35./255., 74./255., 144./255., 246./255.};
3093 Double_t green[9] = { 9./255., 24./255., 55./255., 87./255., 118./255., 150./255., 180./255., 200./255., 222./255.};
3094 Double_t blue[9] = { 30./255., 96./255., 112./255., 114./255., 112./255., 101./255., 72./255., 35./255., 0./255.};
3095 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3096 }
3097 break;
3098
3099 // Cividis
3100 case 113:
3101 {
3102 Double_t red[9] = { 0./255., 5./255., 65./255., 97./255., 124./255., 156./255., 189./255., 224./255., 255./255.};
3103 Double_t green[9] = { 32./255., 54./255., 77./255., 100./255., 123./255., 148./255., 175./255., 203./255., 234./255.};
3104 Double_t blue[9] = { 77./255., 110./255., 107./255., 111./255., 120./255., 119./255., 111./255., 94./255., 70./255.};
3105 Idx = TColor::CreateGradientColorTable(9, stops, red, green, blue, 255, alpha);
3106 }
3107 break;
3108
3109 default:
3110 ::Error("SetPalette", "Unknown palette number %d", ncolors);
3111 return;
3112 }
3113 paletteType = ncolors;
3114 if (Idx>0) fgPalettesList.fArray[paletteType-51] = (Double_t)Idx;
3115 else fgPalettesList.fArray[paletteType-51] = 0.;
3116 if (alpha > 0.) fgPalettesList.fArray[paletteType-51] += alpha/10.;
3117 return;
3118 }
3119
3120 // set user defined palette
3121 if (colors) {
3122 fgPalette.Set(ncolors);
3123 for (i=0;i<ncolors;i++) fgPalette.fArray[i] = colors[i];
3124 } else {
3125 fgPalette.Set(TMath::Min(50,ncolors));
3126 for (i=0;i<TMath::Min(50,ncolors);i++) fgPalette.fArray[i] = palette[i];
3127 }
3128 paletteType = 3;
3129}
3130
3131
3132////////////////////////////////////////////////////////////////////////////////
3133/// Invert the current color palette.
3134/// The top of the palette becomes the bottom and vice versa.
3135
3137{
3138 std::reverse(fgPalette.fArray, fgPalette.fArray + fgPalette.GetSize());
3139}
int Int_t
Definition: CPyCppyy.h:43
unsigned int UInt_t
Definition: CPyCppyy.h:44
unsigned long ULong_t
Definition: CPyCppyy.h:51
void Class()
Definition: Class.C:29
const Mask_t kDoRed
Definition: GuiTypes.h:318
const Mask_t kDoGreen
Definition: GuiTypes.h:319
const Mask_t kDoBlue
Definition: GuiTypes.h:320
ROOT::R::TRInterface & r
Definition: Object.C:4
#define b(i)
Definition: RSha256.hxx:100
#define f(i)
Definition: RSha256.hxx:104
#define c(i)
Definition: RSha256.hxx:101
#define g(i)
Definition: RSha256.hxx:105
#define s0(x)
Definition: RSha256.hxx:90
#define h(i)
Definition: RSha256.hxx:106
unsigned short UShort_t
Definition: RtypesCore.h:38
unsigned char UChar_t
Definition: RtypesCore.h:36
const Bool_t kFALSE
Definition: RtypesCore.h:90
bool Bool_t
Definition: RtypesCore.h:61
double Double_t
Definition: RtypesCore.h:57
float Float_t
Definition: RtypesCore.h:55
const Bool_t kTRUE
Definition: RtypesCore.h:89
const char Option_t
Definition: RtypesCore.h:64
#define ClassImp(name)
Definition: Rtypes.h:361
@ kTeal
Definition: Rtypes.h:65
@ kGray
Definition: Rtypes.h:63
@ kPink
Definition: Rtypes.h:65
@ kRed
Definition: Rtypes.h:64
@ kOrange
Definition: Rtypes.h:65
@ kBlack
Definition: Rtypes.h:63
@ kGreen
Definition: Rtypes.h:64
@ kMagenta
Definition: Rtypes.h:64
@ kWhite
Definition: Rtypes.h:63
@ kCyan
Definition: Rtypes.h:64
@ kBlue
Definition: Rtypes.h:64
@ kAzure
Definition: Rtypes.h:65
@ kYellow
Definition: Rtypes.h:64
@ kViolet
Definition: Rtypes.h:65
@ kSpring
Definition: Rtypes.h:65
R__EXTERN TApplication * gApplication
Definition: TApplication.h:166
static Int_t gDefinedColors
Number of defined colors.
Definition: TColor.cxx:45
#define fgGrayscaleMode
Definition: TColor.cxx:48
static Float_t gColorThreshold
Color threshold used by GetColor.
Definition: TColor.cxx:44
static Int_t gLastDefinedColors
Previous number of defined colors.
Definition: TColor.cxx:46
#define fgPalette
Definition: TColor.cxx:49
#define fgPalettesList
Definition: TColor.cxx:50
static Int_t gHighestColorIndex
Highest color index defined.
Definition: TColor.cxx:43
void Warning(const char *location, const char *msgfmt,...)
char name[80]
Definition: TGX11.cxx:109
float * q
Definition: THbookFile.cxx:87
double floor(double)
#define gROOT
Definition: TROOT.h:406
char * Form(const char *fmt,...)
#define gVirtualX
Definition: TVirtualX.h:338
Color * colors
Definition: X3DBuffer.c:21
#define snprintf
Definition: civetweb.c:1540
void InitializeGraphics()
Initialize the graphics environment.
static void NeedGraphicsLibs()
Static method.
Array of doubles (64 bits per element).
Definition: TArrayD.h:27
Array of integers (32 bits per element).
Definition: TArrayI.h:27
The color creation and management class.
Definition: TColor.h:19
Float_t fSaturation
Saturation.
Definition: TColor.h:28
static void SetPalette(Int_t ncolors, Int_t *colors, Float_t alpha=1.)
Static function.
Definition: TColor.cxx:2417
static void HLS2RGB(Float_t h, Float_t l, Float_t s, Float_t &r, Float_t &g, Float_t &b)
Static method to compute RGB from HLS.
Definition: TColor.cxx:1454
virtual void SetRGB(Float_t r, Float_t g, Float_t b)
Initialize this color and its associated colors.
Definition: TColor.cxx:1705
static void RGBtoHLS(Float_t r, Float_t g, Float_t b, Float_t &h, Float_t &l, Float_t &s)
Definition: TColor.h:78
static Float_t HLStoRGB1(Float_t rn1, Float_t rn2, Float_t huei)
Static method. Auxiliary to HLS2RGB().
Definition: TColor.cxx:1479
static Int_t GetColorPalette(Int_t i)
Static function returning the color number i in current palette.
Definition: TColor.cxx:1393
static const TArrayI & GetPalette()
Static function returning the current active palette.
Definition: TColor.cxx:1405
Float_t GetRed() const
Definition: TColor.h:57
Float_t fLight
Light.
Definition: TColor.h:27
static ULong_t RGB2Pixel(Int_t r, Int_t g, Int_t b)
Convert r,g,b to graphics system dependent pixel value.
Definition: TColor.cxx:2054
static ULong_t Number2Pixel(Int_t ci)
Static method that given a color index number, returns the corresponding pixel value.
Definition: TColor.cxx:2016
static void RGB2HSV(Float_t r, Float_t g, Float_t b, Float_t &h, Float_t &s, Float_t &v)
Static method to compute HSV from RGB.
Definition: TColor.cxx:1652
static Int_t GetColor(const char *hexcolor)
Static method returning color number for color specified by hex color string of form: "#rrggbb",...
Definition: TColor.cxx:1769
static void InitializeColors()
Initialize colors used by the TCanvas based graphics (via TColor objects).
Definition: TColor.cxx:1086
static void HSV2RGB(Float_t h, Float_t s, Float_t v, Float_t &r, Float_t &g, Float_t &b)
Static method to compute RGB from HSV:
Definition: TColor.cxx:1520
Float_t fAlpha
Alpha (transparency)
Definition: TColor.h:29
static void InvertPalette()
Invert the current color palette.
Definition: TColor.cxx:3136
Float_t fHue
Hue.
Definition: TColor.h:26
static void CreateColorWheel()
Static function steering the creation of all colors in the color wheel.
Definition: TColor.cxx:1305
virtual void ls(Option_t *option="") const
List this color with its attributes.
Definition: TColor.cxx:1576
static void SaveColor(std::ostream &out, Int_t ci)
Save a color with index > 228 as a C++ statement(s) on output stream out.
Definition: TColor.cxx:2121
static Int_t GetColorBright(Int_t color)
Static function: Returns the bright color number corresponding to n If the TColor object does not exi...
Definition: TColor.cxx:1916
static Bool_t IsGrayscale()
Return whether all colors return grayscale values.
Definition: TColor.cxx:2159
static void Pixel2RGB(ULong_t pixel, Int_t &r, Int_t &g, Int_t &b)
Convert machine dependent pixel value (obtained via RGB2Pixel or via Number2Pixel() or via TColor::Ge...
Definition: TColor.cxx:2092
const char * AsHexString() const
Return color as hexadecimal string.
Definition: TColor.cxx:1212
static Int_t GetColorDark(Int_t color)
Static function: Returns the dark color number corresponding to n If the TColor object does not exist...
Definition: TColor.cxx:1948
Float_t GetAlpha() const
Definition: TColor.h:63
static const char * PixelAsHexString(ULong_t pixel)
Convert machine dependent pixel value (obtained via RGB2Pixel or via Number2Pixel() or via TColor::Ge...
Definition: TColor.cxx:2109
void Allocate()
Make this color known to the graphics system.
Definition: TColor.cxx:1752
void Copy(TObject &color) const
Copy this color to obj.
Definition: TColor.cxx:1233
ULong_t GetPixel() const
Return pixel value corresponding to this color.
Definition: TColor.cxx:1437
static void SetColorThreshold(Float_t t)
This method specifies the color threshold used by GetColor to retrieve a color.
Definition: TColor.cxx:1841
Float_t GetLight() const
Definition: TColor.h:61
Float_t GetHue() const
Definition: TColor.h:60
Float_t fGreen
Fraction of Green.
Definition: TColor.h:24
static void CreateColorsCircle(Int_t offset, const char *name, UChar_t *rgb)
Create the "circle" colors in the color wheel.
Definition: TColor.cxx:1265
Int_t GetNumber() const
Definition: TColor.h:55
Float_t GetBlue() const
Definition: TColor.h:59
TColor & operator=(const TColor &color)
Definition: TColor.cxx:1075
Float_t GetGreen() const
Definition: TColor.h:58
static Int_t GetNumberOfColors()
Static function returning number of colors in the color palette.
Definition: TColor.cxx:1413
static Int_t GetFreeColorIndex()
Static function: Returns a free color index which can be used to define a user custom color.
Definition: TColor.cxx:2005
Float_t GetSaturation() const
Definition: TColor.h:62
static void HLStoRGB(Float_t h, Float_t l, Float_t s, Float_t &r, Float_t &g, Float_t &b)
Definition: TColor.h:73
TColor()
Default constructor.
Definition: TColor.cxx:983
Int_t fNumber
Color number identifier.
Definition: TColor.h:21
static void CreateColorsRectangle(Int_t offset, const char *name, UChar_t *rgb)
Create the "rectangular" colors in the color wheel.
Definition: TColor.cxx:1285
Float_t fBlue
Fraction of Blue.
Definition: TColor.h:25
static void CreateColorsGray()
Create the Gray scale colors in the Color Wheel.
Definition: TColor.cxx:1249
virtual void SetAlpha(Float_t a)
Definition: TColor.h:67
virtual ~TColor()
Color destructor.
Definition: TColor.cxx:1058
virtual void Print(Option_t *option="") const
Dump this color with its attributes.
Definition: TColor.cxx:1585
Float_t fRed
Fraction of Red.
Definition: TColor.h:23
static void RGB2HLS(Float_t r, Float_t g, Float_t b, Float_t &h, Float_t &l, Float_t &s)
Static method to compute HLS from RGB.
Definition: TColor.cxx:1594
static Int_t GetColorTransparent(Int_t color, Float_t a)
Static function: Returns the transparent color number corresponding to n.
Definition: TColor.cxx:1979
static Int_t CreateGradientColorTable(UInt_t Number, Double_t *Stops, Double_t *Red, Double_t *Green, Double_t *Blue, UInt_t NColors, Float_t alpha=1.)
Static function creating a color table with several connected linear gradients.
Definition: TColor.cxx:2228
static Bool_t DefinedColors()
Static function returning kTRUE if some new colors have been defined after initialisation or since th...
Definition: TColor.cxx:1423
static void SetGrayscale(Bool_t set=kTRUE)
Set whether all colors should return grayscale values.
Definition: TColor.cxx:2167
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
virtual void Copy(TObject &named) const
Copy this to obj.
Definition: TNamed.cxx:94
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:140
An array of TObjects.
Definition: TObjArray.h:37
virtual void AddAtAndExpand(TObject *obj, Int_t idx)
Add object at position idx.
Definition: TObjArray.cxx:235
Mother of all ROOT objects.
Definition: TObject.h:37
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:877
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:891
Basic string class.
Definition: TString.h:131
const char * Data() const
Definition: TString.h:364
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2289
const Int_t n
Definition: legend1.C:16
static constexpr double s
static constexpr double gray
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
ULong_t fPixel
Definition: GuiTypes.h:310
UShort_t fRed
Definition: GuiTypes.h:311
UShort_t fGreen
Definition: GuiTypes.h:312
UShort_t fBlue
Definition: GuiTypes.h:313
UShort_t fMask
Definition: GuiTypes.h:314
auto * l
Definition: textangle.C:4
auto * a
Definition: textangle.C:12