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