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