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