]>
Commit | Line | Data |
---|---|---|
d43c6cd0 | 1 | #ifndef ALICELOGO_C |
2 | #define ALICELOGO_C | |
3 | #include <TGraph.h> | |
4 | #include <TBox.h> | |
5 | #include <TEllipse.h> | |
6 | #include <TPad.h> | |
7 | #include <TCanvas.h> | |
8 | #include <TMath.h> | |
9 | #include <TString.h> | |
10 | #include <TImage.h> | |
11 | #include <TH1.h> | |
12 | #include <TLine.h> | |
13 | #include <TColor.h> | |
14 | ||
15 | /** | |
16 | * Structure to draw the ALICE logo on a pad (canvas). The logo and | |
17 | * text is drawn using ROOT primitives and the result is somewhat | |
18 | * scalable. | |
19 | * | |
20 | * Note, you can save the logo as a PNG, PDF, or SVG to include it in | |
21 | * some other document or the like. | |
22 | * | |
23 | * How to use | |
24 | * | |
25 | * @code | |
26 | * { | |
27 | * TH1* h = new TH1F("h", "h", 60, -3, 3); | |
28 | * h->SetFillColor(kRed+1); | |
29 | * h->SetFillStyle(3001); | |
30 | * h->FillRandom("gaus"); | |
31 | * h->Draw(); | |
32 | * | |
33 | * gROOT->LoadMacro("AliceLogo.C"); | |
34 | * AliceLogo* al = new AliceLogo(); | |
35 | * // al->Draw(0, .75, .4, .25, "preliminary"); | |
36 | * // al->Draw(0, .75, .4, .25, "performance"); | |
37 | * // al->Draw(0, .75, .4, .25, "","text l3 many particles"); | |
38 | * al->Draw(0, .75, .4, .25, "preliminary", "text l3 many particles"); | |
39 | * } | |
40 | * @endcode | |
41 | * | |
42 | * There are many options for colours and options for preliminary, | |
43 | * performance and just the logo. | |
44 | * | |
45 | * The logo produced does not exactly match the logos found on the | |
46 | * ALICE web-site | |
47 | * | |
48 | * https://aliceinfo.cern.ch/Figure/alice_logo | |
49 | * | |
50 | * In particular, the 'C' was hard to get right. However, the logo | |
51 | * does follow the charter as described in | |
52 | * | |
53 | * http://aliweb.cern.ch/system/files/documents/charter/charte_A5_120628.pdf | |
54 | * | |
55 | * Use the static member function(s) AliceLogo::Check to see how well | |
56 | * this code reproduces the logos. Note, you need the official logos | |
57 | * in PNG format for this. Here's a list of places to get them: | |
58 | * | |
59 | * - https://aliceinfo.cern.ch/Figure/sites/aliceinfo.cern.ch.Figure/files/Figures/General/elopez/2012-Jul-04-Preliminary_Logo.png | |
60 | * - https://aliceinfo.cern.ch/Figure/sites/aliceinfo.cern.ch.Figure/files/Figures/General/elopez/2012-Jul-04-Performance_Logo.png | |
61 | * - https://aliceinfo.cern.ch/Figure/sites/aliceinfo.cern.ch.Figure/files/Figures/General/elopez/2012-Jul-04-4_Color_Logo_CB.png | |
62 | * | |
63 | * @author Christian Holm Christensen <cholm@nbi.dk> | |
64 | */ | |
65 | struct AliceLogo | |
66 | { | |
67 | /** | |
68 | * Tags | |
69 | */ | |
70 | enum ETag { | |
71 | kNone = 0, | |
72 | kPreliminary, | |
73 | kPerformance | |
74 | }; | |
75 | /** | |
76 | * Colour options | |
77 | */ | |
78 | enum { | |
79 | kBW = 0, // Black and white only | |
80 | kText = 0x1, // Text is coloured dark-blue | |
81 | kL3 = 0x2, // Colour L3 red | |
82 | kParticles = 0x4, // Particles coloured red | |
83 | kMany = 0x8, // Many particles in many colours | |
84 | kPad = 0x10, // BAckground from pad | |
85 | kReverse = 0x20 // Text is white | |
86 | }; | |
87 | /** | |
88 | * Constructor | |
89 | */ | |
90 | AliceLogo(Bool_t debug=false) | |
91 | : fPad(0), | |
92 | fAspect(1), | |
93 | fL3Thick(.05), | |
94 | fL3Height(.63), | |
95 | fL3Width(0), | |
96 | fDebug(debug) | |
97 | { | |
98 | fRed = TColor::GetColor(226, 0, 26); | |
99 | fYellow = TColor::GetColor(238, 125, 17); | |
100 | fPink = TColor::GetColor(202, 71, 67); | |
101 | fBlue = TColor::GetColor(40, 58, 68); | |
102 | } | |
103 | /** | |
104 | * Parse a string with colour options | |
105 | * | |
106 | * @param what | |
107 | * | |
108 | * @return Colour flags | |
109 | */ | |
110 | static UInt_t ParseColors(const TString& what) | |
111 | { | |
112 | UInt_t col = AliceLogo::kBW; | |
113 | if (what.Contains("l3", TString::kIgnoreCase)) col |= kL3; | |
114 | if (what.Contains("text", TString::kIgnoreCase)) col |= kText; | |
115 | if (what.Contains("part", TString::kIgnoreCase)) col |= kParticles; | |
116 | if (what.Contains("many", TString::kIgnoreCase)) col |= kMany; | |
117 | if (what.Contains("pad", TString::kIgnoreCase)) col |= kPad; | |
118 | if (what.Contains("rever", TString::kIgnoreCase)) col |= kReverse; | |
119 | return col; | |
120 | } | |
121 | /** | |
122 | * Parse a tag string | |
123 | * | |
124 | * @param what String to parse | |
125 | * | |
126 | * @return Tag | |
127 | */ | |
128 | static UShort_t ParseTag(const TString& what) | |
129 | { | |
130 | UShort_t tag = AliceLogo::kNone; | |
131 | if (what.BeginsWith("pre", TString::kIgnoreCase)) tag = kPreliminary; | |
132 | else if (what.BeginsWith("per", TString::kIgnoreCase)) tag = kPerformance; | |
133 | return tag; | |
134 | } | |
135 | /** | |
136 | * Draw everything | |
137 | * | |
138 | * @param p Pad to draw in | |
139 | * @param x Starting X position | |
140 | * @param y Starting Y position | |
141 | * @param h Relative height | |
142 | * @param tag Tag | |
143 | * @param colors Color options | |
144 | */ | |
145 | void Draw(TVirtualPad* p, Double_t x=.77, Double_t y=.35, Double_t h=.25, | |
146 | const TString& tag="", const TString& colors="") | |
147 | { | |
148 | Draw(p, x, y, h, ParseTag(tag), ParseColors(colors)); | |
149 | } | |
150 | /** | |
151 | * Draw everything | |
152 | * | |
153 | * @param p Pad to draw in | |
154 | * @param x Starting X position | |
155 | * @param y Starting Y position | |
156 | * @param h Relative height | |
157 | * @param tag Tag | |
c8b1a7db | 158 | * @param color Color options |
d43c6cd0 | 159 | */ |
160 | void Draw(TVirtualPad* p, Double_t x, Double_t y, Double_t h, | |
161 | UShort_t tag, UInt_t color) | |
162 | { | |
163 | if (!p) p = gPad; | |
164 | if (!p) { | |
165 | Error("AliceLogo::Draw", "No pad to draw in"); | |
166 | return; | |
167 | } | |
168 | if (fDebug) | |
169 | Printf("Pad to draw logo in: %s", p->GetName()); | |
170 | // p->SetFixedAspectRatio(true); | |
171 | Int_t pH = p->YtoPixel(0); | |
172 | if (fDebug) { | |
173 | Int_t pW = p->XtoPixel(1); | |
174 | Double_t pA = Double_t(pW) / pH; | |
175 | Printf("pA=%d/%d=%lf", pW, pH, pA); | |
176 | } | |
177 | ||
178 | ||
179 | if (tag == 0) { | |
180 | fAspect = 1437. / 1933. ; | |
181 | fL3Height = .75; | |
182 | fL3Thick *= 1.1; | |
183 | } | |
184 | else { | |
185 | fAspect = 1835. / 2272. ; | |
186 | fL3Height = .63; | |
187 | } | |
188 | fL3Width = fL3Height / fAspect; | |
189 | Int_t hP = Int_t(h * pH+.5); // Height in pixels | |
190 | Int_t wP = Int_t(fAspect * hP + .5); // Width in pixels | |
191 | Int_t xP = p->XtoPixel(x); // X pos in pixels | |
192 | Int_t rP = xP + wP; // Right in pixels; | |
193 | Double_t topX = p->PixeltoX(rP); | |
194 | Double_t topY = y + h; // p->PixeltoY(tP); // y + h; | |
195 | if (fDebug){ | |
196 | Int_t yP = p->YtoPixel(y); // X pos in pixels | |
197 | Int_t tP = yP - hP; // Top in pixels | |
198 | Printf("(x,y)=(%d,%d) hP=%d wP=%d xP=%d yP=%d rP=%d tP=%d", | |
199 | xP, yP, hP, wP, xP, yP, rP, tP); | |
200 | } | |
201 | if (topX > 1 || topY > 1) { | |
202 | Warning("AliceLogo::Draw", "with (x,y)=(%f,%f) and h=%f -> top=(%f,%f)", | |
203 | x, y, h, topX, topY); | |
204 | topX = TMath::Min(topX, 1.); | |
205 | topY = TMath::Min(topY, 1.); | |
206 | } | |
207 | ||
208 | p->cd(); | |
209 | fPad = new TPad("logo", "logo", x, y, topX, topY); | |
210 | fPad->SetFixedAspectRatio(true); | |
211 | fPad->SetFillColor(fDebug ? kGreen-4 : 0); | |
212 | fPad->SetFillStyle(fDebug ? 4030 : 0); | |
213 | fPad->SetBorderSize(fDebug ? 1 : 0); | |
214 | fPad->SetBorderMode(fDebug ? 1 : 0); | |
215 | fPad->SetLineColor(fDebug ? kBlue+1 : 0); | |
216 | fPad->SetLineWidth(fDebug ? 1 : 0); | |
217 | fPad->SetTopMargin(0); | |
218 | fPad->SetBottomMargin(0); | |
219 | fPad->SetLeftMargin(0); | |
220 | fPad->SetRightMargin(0); | |
221 | fPad->Draw(); | |
c8b1a7db | 222 | if (fDebug) |
223 | Printf("(x,y)=(%f,%f) (tx,ty)=(%f,%f) (x1,y1)=(%f,%f) (x2,y2)=(%f,%f)", | |
224 | x, y, topX, topY, GetX1(), GetY1(), GetX2(), GetY2()); | |
225 | ||
d43c6cd0 | 226 | if (fDebug) { |
227 | Int_t ppH = fPad->YtoPixel(0); | |
228 | Int_t ppW = fPad->XtoPixel(1); | |
229 | Double_t ppA = Double_t(ppW) / ppH; | |
230 | Printf("ppA=%d/%d=%lf A=%lf",ppW, ppH, ppA, fAspect); | |
231 | // Printf("ppA/A=%lf/%lf=%lf", ppA, fAspect, ppA/fAspect); | |
232 | } | |
233 | ||
234 | Int_t bg = (color & kPad) ? p->GetFillColor() : Int_t(kWhite); | |
235 | ||
236 | DrawL3(color, (color & kReverse && !(color & kL3) ? bg : kWhite)); | |
237 | ||
238 | Int_t txtFg = kBlack; | |
239 | if (color & kText) | |
240 | txtFg = (color & kReverse ? kWhite : fBlue); | |
241 | DrawALICE(txtFg, bg); | |
242 | if (tag == kPreliminary) DrawLabel(txtFg, bg, true); | |
243 | else if (tag == kPerformance) DrawLabel(txtFg, bg, false); | |
244 | ||
245 | p->cd(); | |
246 | } | |
247 | /** | |
248 | * Draw the L3 outline. Note, this is put in a sub-pad of it's own. | |
249 | * | |
250 | * @param color Colour flags | |
251 | * @param bg Background color | |
252 | */ | |
253 | void DrawL3(UInt_t color, Int_t bg) | |
254 | { | |
255 | printf("Drawing L3 image "); | |
256 | fPad->cd(); | |
257 | Double_t o = TMath::Max((1-fL3Width)/2,0.); | |
258 | TVirtualPad* pad = new TPad("l3","L3",o, 1-fL3Height, | |
259 | TMath::Min(fL3Width+o,1.), 1); | |
260 | pad->SetFixedAspectRatio(true); | |
261 | pad->SetFillColor(fDebug ? kGreen-4 : 0); | |
262 | pad->SetFillStyle(fDebug ? 4030 : 0); | |
263 | pad->SetBorderSize(fDebug ? 1 : 0); | |
264 | pad->SetBorderMode(fDebug ? 1 : 0); | |
265 | pad->SetLineColor(fDebug ? kRed+1 : 0); | |
266 | pad->SetLineWidth(fDebug ? 1 : 0); | |
267 | pad->SetTopMargin(0); | |
268 | pad->SetBottomMargin(0); | |
269 | pad->SetLeftMargin(0); | |
270 | pad->SetRightMargin(0); | |
271 | pad->Draw(); | |
272 | ||
273 | Int_t lcol = (color & kL3 ? fRed : kBlack); | |
274 | if (color & kReverse && lcol == kBlack) lcol = kWhite; | |
275 | ||
276 | Double_t dA = 2 * TMath::Pi() / 8; | |
277 | Double_t ro = .5 + .5 * (1 - TMath::Cos(dA/2)); | |
278 | Double_t ri = ro - 1. / fL3Height * fL3Thick; | |
279 | Double_t x0 = .5; | |
280 | Double_t y0 = .5; | |
281 | TGraph* gi = new TGraph(9); | |
282 | TGraph* go = new TGraph(9); | |
283 | gi->SetName("L3_inner"); | |
284 | go->SetName("L3_outer"); | |
285 | SetAttr(gi, gi, bg); | |
286 | SetAttr(go, go, lcol); | |
287 | for (Int_t i = 0; i < 9; i++) { | |
288 | Double_t a = (i + .5) * dA; | |
289 | go->SetPoint(i, x0 + ro * TMath::Cos(a), y0 + ro * TMath::Sin(a)); | |
290 | gi->SetPoint(i, x0 + ri * TMath::Cos(a), y0 + ri * TMath::Sin(a)); | |
291 | } | |
292 | pad->cd(); | |
293 | printf("."); | |
294 | go->Draw("lf same"); | |
295 | printf("."); | |
296 | gi->Draw("lf same"); | |
297 | ||
298 | Double_t len = .26; | |
299 | if (color & kMany) { | |
300 | Double_t w = 0.02; | |
301 | for (Int_t i = 0; i < 36; i++) { | |
302 | Int_t col = fYellow; | |
303 | switch (i) { | |
304 | case 1: case 5: case 10: case 20: case 24: case 27: case 33: case 34: | |
305 | col = fBlue; break; | |
306 | case 3: case 4: case 8: case 16: case 19: case 23: case 29: case 30: | |
307 | case 32: | |
308 | col = fPink; break; | |
309 | case 9: case 12: case 14: case 18: case 25: case 28: case 35: | |
310 | col = fRed; break; | |
311 | default: | |
312 | break; | |
313 | } | |
314 | double l = len; | |
315 | switch (i) { | |
316 | case 1: case 9: case 8: case 10: case 19: case 21: case 33: | |
317 | l += 0.005; break; | |
318 | case 2: case 7: case 11: case 12: case 15: case 16: case 20: case 34: | |
319 | l += 0.02; break; | |
320 | case 3: case 6: case 13: case 17: case 25: case 29: | |
321 | l += 0.01; break; | |
322 | case 23: case 27: case 28: | |
323 | l -= 0.005; | |
324 | default: break; | |
325 | } | |
326 | ||
327 | printf("."); | |
328 | DrawSpoke(i * 360/36, w, l, col); | |
329 | } | |
330 | } | |
331 | else { | |
332 | Double_t w = .015; | |
333 | Int_t col = (color & kParticles ? fRed : kBlack); | |
334 | if (bg != kWhite) col = kWhite; | |
335 | for (Int_t i = 0; i < 18; i++) { | |
336 | double l = len; | |
337 | switch (i) { | |
338 | case 0: case 2: | |
339 | break; | |
340 | case 1: case 6: case 8: | |
341 | case 10: case 17: | |
342 | l += .02; break; | |
343 | case 3: case 4: case 5: case 7: case 12: | |
344 | l += .01; break; | |
345 | case 15: | |
346 | l += .005; break; | |
347 | case 16: | |
348 | l -= .005; break; | |
349 | default: | |
350 | break; | |
351 | } | |
352 | printf("."); | |
353 | DrawSpoke(i * 360/18, w, l, col); | |
354 | } | |
355 | } | |
356 | fPad->cd(); | |
357 | printf("\n"); | |
358 | } | |
359 | /** | |
360 | * Draw a spoke in the L3 outline. | |
361 | * | |
362 | * @param ang Rotation angle in degrees. | |
c8b1a7db | 363 | * @param w Width |
d43c6cd0 | 364 | * @param len Length of spoke |
365 | * @param fg Foreground colour | |
366 | */ | |
367 | void DrawSpoke(Int_t ang, Double_t w, Double_t len, Int_t fg) | |
368 | { | |
369 | Double_t r1 = .12; | |
370 | ||
371 | Double_t xx = r1; | |
372 | Double_t yy = w/2; | |
373 | Double_t xl = r1+len; | |
374 | ||
375 | Double_t rad = TMath::Pi() / 180 * ang; | |
376 | Double_t xtl = .5 + xx * TMath::Cos(rad) - yy * TMath::Sin(rad); | |
377 | Double_t ytl = .5 + xx * TMath::Sin(rad) + yy * TMath::Cos(rad); | |
378 | Double_t xbl = .5 + xx * TMath::Cos(rad) + yy * TMath::Sin(rad); | |
379 | Double_t ybl = .5 + xx * TMath::Sin(rad) - yy * TMath::Cos(rad); | |
380 | Double_t xtr = .5 + xl * TMath::Cos(rad) - yy * TMath::Sin(rad); | |
381 | Double_t ytr = .5 + xl * TMath::Sin(rad) + yy * TMath::Cos(rad); | |
382 | Double_t xbr = .5 + xl * TMath::Cos(rad) + yy * TMath::Sin(rad); | |
383 | Double_t ybr = .5 + xl * TMath::Sin(rad) - yy * TMath::Cos(rad); | |
384 | ||
385 | TGraph* tri = new TGraph(4); | |
386 | SetAttr(tri, tri, fg); | |
387 | tri->SetName(Form("spoke_tr_%03d", ang)); | |
388 | tri->SetPoint(0, 0.5,0.5); | |
389 | tri->SetPoint(3, 0.5,0.5); | |
390 | tri->SetPoint(1, xtl, ytl); | |
391 | tri->SetPoint(2, xbl, ybl); | |
392 | tri->Draw("same lf"); | |
393 | ||
394 | TGraph* lne = new TGraph(4); | |
395 | SetAttr(lne, lne, fg); | |
396 | lne->SetName(Form("spoke_ln_%03d", ang)); | |
397 | lne->SetPoint(0, xtl, ytl); | |
398 | lne->SetPoint(1, xbl, ybl); | |
399 | lne->SetPoint(2, xbr, ybr); | |
400 | lne->SetPoint(3, xtr, ytr); | |
401 | lne->SetPoint(4, xtl, ytl); | |
402 | lne->Draw("same lf"); | |
403 | ||
404 | } | |
405 | /** | |
406 | * Draw the text ALICE in a separate pad | |
407 | * | |
408 | */ | |
409 | void DrawALICE(Int_t fg, Int_t bg) | |
410 | { | |
411 | printf("Drawing ALICE title "); | |
412 | fPad->cd(); | |
413 | Double_t o = TMath::Max((1-fL3Width)/2,0.); | |
414 | Double_t r = fL3Width/2; | |
415 | Double_t t = r*TMath::Sin(TMath::Pi()/8-.05); | |
416 | Double_t t2 = r*TMath::Sin(TMath::Pi()/8+.05); | |
417 | // Middle-bottom-left point is | |
418 | Double_t mblX = o; | |
419 | Double_t mblY = (1-fL3Height/2) - t; | |
420 | // Bottom-left point is | |
421 | Double_t blY = (1-fL3Height); | |
422 | Double_t blX = .5 - t2; | |
423 | // Slope | |
424 | Double_t a = (blY - mblY) / (blX - mblX); | |
425 | // Y is then, using y = y1 + a (x - x1) | |
426 | Double_t b = mblY + a * (.5 - mblX); | |
427 | ||
428 | Double_t top = 1-fL3Height-fL3Thick; | |
429 | Double_t hh = 2 * (top - b); | |
430 | Double_t bot = TMath::Max(top - hh,0.); | |
431 | TVirtualPad* pad = new TPad("alice", "alice", o, bot+.005, | |
432 | TMath::Min(o+fL3Width,1.), top+.005); | |
433 | pad->SetFixedAspectRatio(true); | |
434 | pad->SetFillColor(fDebug ? kGreen-4 : 0); | |
435 | pad->SetFillStyle(fDebug ? 4030 : 0); | |
436 | pad->SetBorderSize(fDebug ? 1 : 0); | |
437 | pad->SetBorderMode(fDebug ? 1 : 0); | |
438 | pad->SetLineColor(fDebug ? kMagenta+1 : 0); | |
439 | pad->SetLineWidth(fDebug ? 1 : 0); | |
440 | pad->SetTopMargin(0); | |
441 | pad->SetBottomMargin(0); | |
442 | pad->SetLeftMargin(0); | |
443 | pad->SetRightMargin(0); | |
444 | pad->Draw(); | |
445 | pad->cd(); | |
446 | ||
447 | Double_t wp = pad->XtoPixel(1); | |
448 | Double_t hp = pad->YtoPixel(0); | |
449 | a = hp / wp; | |
450 | ||
451 | Double_t w = .15; | |
452 | printf("."); | |
453 | DrawA(0, 0.01, w, a, fg, bg); | |
454 | printf("."); | |
455 | DrawL(.5 - 5.8*a*w, 0.01, w, a, fg); | |
456 | printf("."); | |
457 | DrawI(.5 - 1.5*a*w, 0.01, w, a, fg); | |
458 | printf("."); | |
459 | DrawC(.5 + 2.6*a*w, 0.00, /*w,*/ a, fg, bg); | |
460 | printf("."); | |
461 | DrawE(1 - 3.5*a*w, 0.01, w, a, fg); | |
462 | fPad->cd(); | |
463 | ||
464 | printf("\n"); | |
465 | } | |
466 | /** | |
467 | * Draw the letter A | |
468 | * | |
469 | * @param x Base X coordinate | |
470 | * @param y Base Y coordinate | |
471 | * @param w Line width | |
472 | * @param a Aspect ratio of pad | |
473 | * @param fg Foreground colour | |
474 | * @param bg Background colour | |
475 | */ | |
476 | void DrawA(Double_t x, Double_t y, Double_t w, Double_t a, | |
477 | Int_t fg, Int_t bg) | |
478 | { | |
479 | Double_t u = 4.5 * w; | |
480 | Double_t r = u / 2; | |
481 | TBox* b1 = new TBox(x, y, x + a * w, y + 1 - r); | |
482 | SetAttr(b1, b1, fg); | |
483 | b1->Draw(); | |
484 | b1->DrawBox(x + (u-w) * a, y, x + u * a, y + 1 - r); | |
485 | b1->DrawBox(x, y+1-r-2*w, x + u * a, y + 1 - r -w); | |
486 | TEllipse* a1 = new TEllipse(x+u*a/2, y+1-r-.01, (r-.005)*a, r, 0, 180); | |
487 | SetAttr(a1, a1, fg); | |
488 | a1->Draw("only"); | |
489 | TEllipse* a2 = new TEllipse(x+u*a/2, y+1-r-.01, (r-w-.005)*a, r-w, 0, 180); | |
490 | SetAttr(a2, a2, bg); | |
491 | a2->Draw("only"); | |
492 | ||
493 | #if 0 | |
494 | // To draw as lines - note line width does not scale | |
495 | Int_t lw = w*gPad->YtoPixel(0); | |
496 | Double_t x1 = x+a*w/2; | |
497 | Double_t x2 = x+a*(u-w/2); | |
498 | Double_t y1 = y + 1 - r - 1.5*w; | |
499 | TLine* l1 = new TLine(x1, y, x1, y+1-r); | |
500 | l1->SetLineWidth(lw); | |
501 | l1->SetLineColor(kBlue); | |
502 | l1->Draw(); | |
503 | l1->DrawLine(x2, y,x2, y+1-r); | |
504 | l1->DrawLine(x1, y1,x2, y1); | |
505 | ||
506 | TEllipse* a3 = new TEllipse(x+u*a/2, y+1-r-.01, | |
507 | (r-w/2-.005)*a, r-w/2, 0, 180); | |
508 | a3->SetFillStyle(0); | |
509 | a3->SetFillColor(0); | |
510 | // Int_t lw = w*gPad->YtoPixel(0); | |
511 | Printf("Setting line width to %d", lw); | |
512 | a3->SetLineWidth(lw); | |
513 | a3->SetLineColor(kBlue); | |
514 | a3->Draw("only"); | |
515 | #endif | |
516 | } | |
517 | /** | |
518 | * Draw the letter L | |
519 | * | |
520 | * @param x Base X coordinate | |
521 | * @param y Base Y coordinate | |
522 | * @param w Line width | |
523 | * @param a Aspect ratio of pad | |
524 | * @param fg Foreground colour | |
d43c6cd0 | 525 | */ |
526 | void DrawL(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg) | |
527 | { | |
528 | TBox* b1 = new TBox(x, y, x+3.1 * a * w, y + w); | |
529 | SetAttr(b1, b1, fg); | |
530 | b1->Draw(); | |
531 | b1->DrawBox(x, y , x + a * w,y+.99); | |
532 | } | |
533 | /** | |
534 | * Draw the letter I | |
535 | * | |
536 | * @param x Base X coordinate | |
537 | * @param y Base Y coordinate | |
538 | * @param w Line width | |
539 | * @param a Aspect ratio of pad | |
540 | * @param fg Foreground colour | |
d43c6cd0 | 541 | */ |
542 | void DrawI(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg) | |
543 | { | |
544 | TBox* b1 = new TBox(x, y, x+3 * a * w, y + w); | |
545 | SetAttr(b1, b1, fg); | |
546 | b1->Draw(); | |
547 | b1->DrawBox(x+a*w,y,x+2*a*w,y+.99); | |
548 | b1->DrawBox(x,y+1-w,x+3*a*w,y+.99); | |
549 | } | |
550 | /** | |
551 | * Draw the letter C | |
552 | * | |
553 | * @param x Base X coordinate | |
554 | * @param y Base Y coordinate | |
d43c6cd0 | 555 | * @param a Aspect ratio of pad |
556 | * @param fg Foreground colour | |
557 | * @param bg Background colour | |
558 | */ | |
559 | void DrawC(Double_t x, Double_t y, Double_t a, Int_t fg, Int_t bg) | |
560 | { | |
561 | Int_t nO = 13; | |
562 | Double_t dx = 0; | |
563 | Double_t pO[] = { | |
564 | /* 0 */ 0.698245 +dx, 0.271355, | |
565 | /* 1 */ 0.590204 +dx, 0.0755058, | |
566 | /* 2 */ 0.424947 +dx, 0.00, | |
567 | /* 3 */ 0.220343 +dx, 0.015668+.005, | |
568 | /* 4 */ 0.0629551 +dx, 0.15668, | |
569 | /* 5 */ 0.00786939+dx, 0.329027, | |
570 | /* 6 */ -0.005, 0.564046, | |
571 | /* 7 */ 0.00786939+dx, 1-0.329027, | |
572 | /* 8 */ 0.0629551 +dx, 1-0.15668, | |
573 | /* 9 */ 0.220343 +dx, 1-0.015668-.005, | |
574 | /* 10 */ 0.424947 +dx, .99, | |
575 | /* 11 */ 0.590204 +dx, 1-0.0755058, | |
576 | /* 12 */ 0.6982450 +dx, 1-0.271355, 0 }; | |
577 | TGraph* gO = new TGraph(nO); | |
578 | gO->SetName("c_ext"); | |
579 | gO->SetLineColor(fDebug ? kGreen+1 : fg); | |
580 | gO->SetLineWidth(fDebug ? 1 : 0); | |
581 | gO->SetFillColor(fDebug ? kGreen+1 : fg); | |
582 | gO->SetFillStyle(fDebug ? 0 : 1001); | |
583 | for (Int_t i = 0; i < nO; i++) | |
584 | gO->SetPoint(i, x+pO[2*i]*a,y+pO[2*i+1]); | |
585 | gO->Draw("fc same"); | |
586 | Int_t nI = 11; | |
587 | Double_t pI[] = { | |
588 | /* 0 */ 0.551869, 1-0.713617, | |
589 | /* 1 */ 0.481045, 1-0.821127, | |
590 | /* 2 */ 0.363004, 1-0.853799, | |
591 | /* 3 */ 0.213486, 1-0.783625, | |
592 | /* 4 */ 0.158508, 1-0.635277, | |
593 | /* 4 */ 0.158, 0.5, // 1-0.635277, | |
594 | /* 5 */ 0.158508, 0.635277, | |
595 | /* 6 */ 0.213486, 0.773625, | |
596 | /* 7 */ 0.363004, 0.853799, | |
597 | /* 8 */ 0.481045, 0.821127, | |
598 | /* 9 */ 0.551869, 0.713617, 0 }; | |
599 | TGraph* gI = new TGraph(nI); | |
600 | gI->SetName("c_int"); | |
601 | gI->SetLineColor(fDebug ? kGreen+1 : bg); | |
602 | gI->SetLineWidth(fDebug ? 1 : 0); | |
603 | gI->SetFillColor(fDebug ? kGreen+1 : bg); | |
604 | gI->SetFillStyle(fDebug ? 0 : 1001); | |
605 | for (Int_t i = 0; i < nI; i++) | |
606 | gI->SetPoint(i, x+pI[2*i]*a,y+pI[2*i+1]); | |
607 | gI->Draw("fc same"); | |
608 | ||
609 | ||
610 | TGraph* gC = new TGraph(5); | |
611 | gC->SetName("c_cut"); | |
612 | SetAttr(gC, gC, bg); | |
613 | gC->SetPoint(0, gO->GetX()[0], gO->GetY()[0]); | |
614 | gC->SetPoint(1, gI->GetX()[0], gI->GetY()[0]); | |
615 | gC->SetPoint(2, gI->GetX()[nI-1], gI->GetY()[nI-1]); | |
616 | gC->SetPoint(3, gO->GetX()[nO-1], gO->GetY()[nO-1]); | |
617 | gC->SetPoint(4, gO->GetX()[0], gO->GetY()[0]); | |
618 | gC->Draw("fl same"); | |
619 | } | |
620 | /** | |
621 | * Draw the letter E | |
622 | * | |
623 | * @param x Base X coordinate | |
624 | * @param y Base Y coordinate | |
625 | * @param w Line width | |
626 | * @param a Aspect ratio of pad | |
627 | * @param fg Foreground colour | |
628 | */ | |
629 | void DrawE(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg) | |
630 | { | |
631 | Double_t u = 3.5; | |
632 | TBox* b1 = new TBox(x, y, x + a * w, y + .99); | |
633 | SetAttr(b1, b1, fg); | |
634 | b1->Draw(); | |
635 | b1->DrawBox(x, y, x + u*a*w, y+w); | |
636 | b1->DrawBox(x, y+.99-w, x + u*a*w, y+.99); | |
637 | b1->DrawBox(x, y+.5-w/2+.02, x + (u-.1)*a*w, y+.5+w/2+.02); | |
638 | } | |
639 | /** | |
640 | * Draw the letter F | |
641 | * | |
642 | * @param x Base X coordinate | |
643 | * @param y Base Y coordinate | |
644 | * @param w Line width | |
645 | * @param a Aspect ratio of pad | |
646 | * @param fg Foreground colour | |
647 | */ | |
648 | void DrawF(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg) | |
649 | { | |
650 | Double_t u = 3.5; | |
651 | TBox* b1 = new TBox(x, y, x + a * w, y + .99); | |
652 | SetAttr(b1, b1, fg); | |
653 | b1->Draw(); | |
654 | b1->DrawBox(x, y+.99-w, x + u*a*w, y+.99); | |
655 | b1->DrawBox(x, y+.5-w/2+.02, x + (u-.1)*a*w, y+.5+w/2+.02); | |
656 | } | |
657 | /** | |
658 | * Draw the label text ("Preliminary" or "Performance") in it's own pad | |
659 | * | |
660 | * @param fg Foreground colour | |
661 | * @param bg Background colour | |
c8b1a7db | 662 | * @param preliminary If true, draw preliminary, otherwise performance |
d43c6cd0 | 663 | */ |
664 | void DrawLabel(Int_t fg, Int_t bg, bool preliminary=true) | |
665 | { | |
666 | printf("Drawing stamp "); | |
667 | fPad->cd(); | |
668 | ||
669 | Double_t top = .08; | |
670 | Double_t bot = 0; | |
671 | TVirtualPad* pad = new TPad("label", "label", 0, bot, 1, top); | |
672 | pad->SetFixedAspectRatio(true); | |
673 | pad->SetFillColor(fDebug ? kGreen-4 : 0); | |
674 | pad->SetFillStyle(fDebug ? 4030 : 0); | |
675 | pad->SetBorderSize(fDebug ? 1 : 0); | |
676 | pad->SetBorderMode(fDebug ? 1 : 0); | |
677 | pad->SetLineColor(fDebug ? kCyan+2 : 0); | |
678 | pad->SetLineWidth(fDebug ? 1 : 0); | |
679 | pad->SetTopMargin(0); | |
680 | pad->SetBottomMargin(0); | |
681 | pad->SetLeftMargin(0); | |
682 | pad->SetRightMargin(0); | |
683 | pad->Draw(); | |
684 | pad->cd(); | |
685 | ||
686 | Double_t wp = pad->XtoPixel(1); | |
687 | Double_t hp = pad->YtoPixel(0); | |
688 | Double_t a = hp / wp; | |
689 | ||
690 | Double_t w = .15; | |
691 | if (preliminary) { | |
692 | printf("."); DrawP(0, 0.01, w, a, fg, bg); | |
693 | printf("."); DrawR(6.3 * w * a, 0.01, w, a, fg, bg); | |
694 | printf("."); DrawE(13 * w * a, 0.01, w, a, fg); | |
695 | printf("."); DrawL(18.7 * w * a, 0.01, w, a, fg); | |
696 | printf("."); DrawI(23.3 * w * a, 0.01, w, a, fg); | |
697 | printf("."); DrawM(29 * w * a, 0.01, w, a, fg); | |
698 | printf("."); DrawI(37.2 * w * a, 0.01, w, a, fg); | |
699 | printf("."); DrawN(42.5 * w * a, 0.01, w, a, fg); | |
700 | printf("."); DrawA(49.4 * w * a, 0.01, w, a, fg, bg); | |
701 | printf("."); DrawR(56.4 * w * a, 0.01, w, a, fg, bg); | |
702 | printf("."); DrawY(62.3 * w * a, 0.01, w, a, fg); | |
703 | } | |
704 | else { | |
705 | printf("."); DrawP(0, 0.01, w, a, fg, bg); | |
706 | printf("."); DrawE(6.3 * w * a, 0.01, w, a, fg); | |
707 | printf("."); DrawR(12 * w * a, 0.01, w, a, fg, bg); | |
708 | printf("."); DrawF(18.7 * w * a, 0.01, w, a, fg); | |
709 | printf("."); DrawO(24 * w * a, 0.01, w, a, fg, bg); | |
710 | printf("."); DrawR(30.7 * w * a, 0.01, w, a, fg, bg); | |
711 | printf("."); DrawM(37.5 * w * a, 0.01, w, a, fg); | |
712 | printf("."); DrawA(45.5 * w * a, 0.01, w, a, fg, bg); | |
713 | printf("."); DrawN(52.4 * w * a, 0.01, w, a, fg); | |
714 | printf("."); DrawC(58.7 * w * a, 0.01, /*w,*/ a, fg, bg); | |
715 | printf("."); DrawE(64.8 * w * a, 0.01, w, a, fg); | |
716 | } | |
717 | ||
718 | fPad->cd(); | |
719 | printf("\n"); | |
720 | } | |
721 | /** | |
722 | * Draw the letter O | |
723 | * | |
724 | * @param x Base X coordinate | |
725 | * @param y Base Y coordinate | |
726 | * @param w Line width | |
727 | * @param a Aspect ratio of pad | |
728 | * @param fg Foreground colour | |
729 | * @param bg Background colour | |
730 | */ | |
731 | void DrawO(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg, Int_t bg) | |
732 | { | |
733 | Double_t fw = 4.8; | |
734 | ||
735 | TEllipse* a1 = new TEllipse(x+fw/2*a*w, y + .495, a*w*fw/2, .495, 0, 360); | |
736 | SetAttr(a1, a1, fg); | |
737 | a1->Draw("only"); | |
738 | TEllipse* a2 = new TEllipse(x+fw/2*a*w, y + .495, a*w*(fw/2-1), .495-w); | |
739 | SetAttr(a2, a2, bg); | |
740 | a2->Draw("only"); | |
741 | } | |
742 | /** | |
743 | * Draw the letter P | |
744 | * | |
745 | * @param x Base X coordinate | |
746 | * @param y Base Y coordinate | |
747 | * @param w Line width | |
748 | * @param a Aspect ratio of pad | |
749 | * @param fg Foreground colour | |
750 | * @param bg Background colour | |
751 | */ | |
752 | void DrawP(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg, Int_t bg) | |
753 | { | |
754 | Double_t u = 4.3 * w; | |
755 | Double_t r = 4.3 * w / 2; | |
756 | ||
757 | TBox* b1 = new TBox(x, y, x + a * w, y + .99); | |
758 | SetAttr(b1, b1, fg); | |
759 | b1->Draw(); | |
760 | b1->DrawBox(x + a * w, y + .99 - w, x + 2.5 * a * w, y + .99); | |
761 | b1->DrawBox(x + a * w, y + .99 - u, x + 2.5 * a * w, y + .99 - u + w); | |
762 | TEllipse* a1 = new TEllipse(x+2.5*a*w, y + .99 - r, a*r, r-.01, -90, 90); | |
763 | SetAttr(a1, a1, fg); | |
764 | a1->Draw("only"); | |
765 | TEllipse* a2 = new TEllipse(x+2.5*a*w, y + .99 - r, a*(r-w), r-w-.01, | |
766 | -90, 90); | |
767 | SetAttr(a2, a2, bg); | |
768 | a2->Draw("only"); | |
769 | } | |
770 | /** | |
771 | * Draw the letter R | |
772 | * | |
773 | * @param x Base X coordinate | |
774 | * @param y Base Y coordinate | |
775 | * @param w Line width | |
776 | * @param a Aspect ratio of pad | |
777 | * @param fg Foreground colour | |
778 | * @param bg Background colour | |
779 | */ | |
780 | void DrawR(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg, Int_t bg) | |
781 | { | |
782 | DrawP(x, y, w, a, fg, bg); | |
783 | ||
784 | Double_t u = 4.3 * w; | |
785 | Double_t fw = 2.5 + 4.3 / 2; | |
786 | Double_t ang = 60 * TMath::Pi() / 180; | |
787 | Double_t o = w / TMath::Sin(ang); | |
788 | ||
789 | TGraph* g = new TGraph(5); | |
790 | SetAttr(g, g, fg); | |
791 | // Top right | |
792 | g->SetPoint(0, x+a*(2*w+o), y+1-u+.01); | |
793 | // Top left | |
794 | g->SetPoint(1, x+a*2*w, y+1-u+.01); | |
795 | // Bottom left | |
796 | g->SetPoint(2, x+a*(fw*w-o+.06), y); | |
797 | // Bottom right | |
798 | g->SetPoint(3, x+a*(fw*w+.06), y); | |
799 | g->SetPoint(4, g->GetX()[0], g->GetY()[0]); | |
800 | g->Draw("same lf"); | |
801 | } | |
802 | /** | |
803 | * Draw the letter M | |
804 | * | |
805 | * @param x Base X coordinate | |
806 | * @param y Base Y coordinate | |
807 | * @param w Line width | |
808 | * @param a Aspect ratio of pad | |
809 | * @param fg Foreground colour | |
810 | */ | |
811 | void DrawM(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg) | |
812 | { | |
813 | TBox* b1 = new TBox(x, y, x + a * w, y + 1); | |
814 | SetAttr(b1, b1, fg); | |
815 | b1->Draw(); | |
816 | b1->DrawBox(x+4.8*a*w, y, x+5.8*a*w, y+1); | |
817 | ||
818 | Double_t ang = 28 * TMath::Pi() / 180; | |
819 | Double_t o = w / TMath::Sin(ang); | |
820 | ||
821 | TGraph* gl = new TGraph(7); | |
822 | SetAttr(gl, gl, fg); | |
823 | gl->SetPoint(0, x+a*w, y+1); | |
824 | gl->SetPoint(1, x+a*w, y+1-o); | |
825 | gl->SetPoint(2, x+a*w*(1+3.8/2), y+w); | |
826 | gl->SetPoint(3, x+a*w*4.8, y+1-o); | |
827 | gl->SetPoint(4, x+a*w*4.8, y+1); | |
828 | gl->SetPoint(5, x+a*w*(1+3.8/2), y+w+o); | |
829 | gl->SetPoint(6, x+a*w, y+1); | |
830 | gl->Draw("same lf"); | |
831 | ||
832 | } | |
833 | /** | |
834 | * Draw the letter N | |
835 | * | |
836 | * @param x Base X coordinate | |
837 | * @param y Base Y coordinate | |
838 | * @param w Line width | |
839 | * @param a Aspect ratio of pad | |
840 | * @param fg Foreground colour | |
841 | */ | |
842 | void DrawN(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg) | |
843 | { | |
844 | Double_t fw = 4.6; | |
845 | TBox* b1 = new TBox(x, y, x + a * w, y + 1); | |
846 | SetAttr(b1, b1, fg); | |
847 | b1->Draw(); | |
848 | b1->DrawBox(x+a*w*(fw-1), y, x+a*w*(fw), y+1); | |
849 | ||
850 | Double_t ang = 28 * TMath::Pi() / 180; | |
851 | Double_t o = w / TMath::Sin(ang); | |
852 | ||
853 | TGraph* gl = new TGraph(5); | |
854 | gl->SetLineColor(fDebug ? kGreen+1 : fg); | |
855 | gl->SetLineWidth(fDebug ? 1 : 0); | |
856 | gl->SetFillColor(fDebug ? kGreen+1 : fg); | |
857 | gl->SetFillStyle(fDebug ? 0 : 1001); | |
858 | gl->SetPoint(0, x+a*w, y+1); | |
859 | gl->SetPoint(1, x+a*w, y+1-o); | |
860 | gl->SetPoint(2, x+a*w*(fw-1), y); | |
861 | gl->SetPoint(3, x+a*w*(fw-1), y+o); | |
862 | gl->SetPoint(4, x+a*w, y+1); | |
863 | gl->Draw("same lf"); | |
864 | } | |
865 | /** | |
866 | * Draw the letter Y | |
867 | * | |
868 | * @param x Base X coordinate | |
869 | * @param y Base Y coordinate | |
870 | * @param w Line width | |
871 | * @param a Aspect ratio of pad | |
872 | * @param fg Foreground colour | |
873 | */ | |
874 | void DrawY(Double_t x, Double_t y, Double_t w, Double_t a, Int_t fg) | |
875 | { | |
876 | Double_t u = 4 * w; | |
877 | Double_t fw = 5.5; | |
878 | ||
879 | TBox* b1 = new TBox(x+a*w*(fw/2-.5), y, x + a * w *(fw/2+.5), y + 1 - u); | |
880 | b1->SetLineColor(fDebug ? kGreen+1 : fg); | |
881 | b1->SetFillColor(fDebug ? 0 : fg); | |
882 | b1->SetFillStyle(fDebug ? 0 : 1001); | |
883 | b1->Draw(); | |
884 | ||
885 | Double_t ang = 40 * TMath::Pi() / 180; | |
886 | Double_t o = w / TMath::Sin(ang); | |
887 | Double_t o2 = w / TMath::Cos(ang); | |
888 | ||
889 | ||
890 | TGraph* g = new TGraph(8); | |
891 | SetAttr(g, g, fg); | |
892 | g->SetPoint(0, x+a*w*(fw/2-.5), y + 1-u); | |
893 | g->SetPoint(1, x, y + 1); | |
894 | g->SetPoint(2, x+a*o2, y + 1); | |
895 | g->SetPoint(3, x+a*w*fw/2, y + 1 - u + o); | |
896 | g->SetPoint(4, x+a*w*fw-a*o2, y+1); | |
897 | g->SetPoint(5, x+a*w*fw, y+1); | |
898 | g->SetPoint(6, x+a*w*(fw/2+.5), y + 1-u); | |
899 | g->SetPoint(7, x+a*w*(fw/2-.5), y + 1-u); | |
900 | ||
901 | ||
902 | g->Draw("same lf"); | |
903 | } | |
904 | /** | |
905 | * Set Line and Fill attributes | |
906 | * | |
907 | * @param lne Line attribute interface | |
908 | * @param fll Fill attribute interface | |
909 | * @param col Colour | |
910 | */ | |
911 | void SetAttr(TAttLine* lne, TAttFill* fll, Int_t col) | |
912 | { | |
913 | if (lne) { | |
914 | lne->SetLineColor(fDebug ? kGreen+1 : col); | |
915 | lne->SetLineWidth(fDebug ? 1 : 0); | |
916 | } | |
917 | if (fll) { | |
918 | fll->SetFillColor(fDebug ? kGreen+1 : col); | |
919 | fll->SetFillStyle(fDebug ? 0 : 1001); | |
920 | } | |
921 | } | |
922 | Double_t GetX1() const { return fPad ? fPad->GetXlowNDC() : -1; } | |
923 | Double_t GetX2() const { return fPad ? GetX1()+fPad->GetWNDC() : -1; } | |
924 | Double_t GetY1() const { return fPad ? fPad->GetYlowNDC() : -1; } | |
925 | Double_t GetY2() const { return fPad ? GetY1()+fPad->GetHNDC() : -1; } | |
926 | Double_t GetCX() const { return fPad ? (GetX1()+GetX2())/2 : -1; } | |
927 | Double_t GetCY() const { return fPad ? (GetY1()+GetY2())/2 : -1; } | |
928 | /** | |
929 | * run a simple test | |
930 | * | |
931 | * @param what | |
932 | */ | |
933 | static void Test(const TString& what) | |
934 | { | |
935 | Test(AliceLogo::ParseTag(what), AliceLogo::ParseColors(what), | |
936 | what.Contains("debug", TString::kIgnoreCase)); | |
937 | } | |
938 | /** | |
939 | * Run a simple test | |
940 | * | |
941 | * @param tag | |
942 | * @param col | |
943 | * @param debug | |
944 | */ | |
945 | static void Test(UShort_t tag, UInt_t col, Bool_t debug) | |
946 | { | |
947 | TCanvas* c = new TCanvas("test", "Test of AliceLogo"); | |
948 | c->SetFillColor(kYellow-10); | |
949 | TH1* h = new TH1F("h", "h", 60, -3, 3); | |
950 | h->SetFillColor(kRed+1); | |
951 | h->SetFillStyle(3001); | |
952 | h->FillRandom("gaus"); | |
953 | h->Draw(); | |
954 | ||
955 | AliceLogo* dut = new AliceLogo(debug); | |
956 | dut->Draw(c, .75, .4, .25, tag, col); | |
957 | ||
958 | c->SaveAs("test.png"); | |
959 | c->SaveAs("test.pdf"); | |
960 | c->SaveAs("test.svg"); | |
961 | } | |
962 | /** | |
963 | * Check compatiblity by overlaying this logo on 'official' images | |
964 | * | |
965 | * @param what | |
966 | */ | |
967 | static void Check(const TString& what) | |
968 | { | |
969 | Check(AliceLogo::ParseTag(what), AliceLogo::ParseColors(what), | |
970 | what.Contains("debug", TString::kIgnoreCase)); | |
971 | } | |
972 | /** | |
973 | * Check compatiblity by overlaying this logo on 'official' images | |
974 | * | |
975 | * @param tag | |
976 | * @param col | |
977 | * @param debug | |
978 | */ | |
979 | static void Check(UShort_t tag, UInt_t col, Bool_t debug=true) | |
980 | { | |
981 | ||
982 | TImage* img = TImage::Create(); | |
983 | TString imgName = "2012-Jul-04-Base_Logo.png"; | |
984 | // Int_t logoW = 0; // img->GetWidth(); | |
985 | // Int_t logoH = 0; // img->GetHeight(); | |
986 | switch (tag) { | |
987 | case AliceLogo::kPreliminary: | |
988 | // logoW = 1849; | |
989 | // logoH = 2277; | |
990 | imgName = "2012-Jul-04-Preliminary_Logo.png"; | |
991 | break; | |
992 | case AliceLogo::kPerformance: | |
993 | imgName = "2012-Jul-04-Performance_Logo.png"; | |
994 | break; | |
995 | default: | |
996 | if (col & kMany) | |
997 | imgName = "2012-Jul-04-4_Color_Logo_CB.png"; | |
998 | else | |
999 | imgName = "2012-Jul-04-Base_Logo.png"; | |
1000 | } | |
1001 | Printf("Reading %s", imgName.Data()); | |
1002 | img->ReadImage(imgName); | |
1003 | Int_t logoW = img->GetWidth(); | |
1004 | Int_t logoH = img->GetHeight(); | |
1005 | Double_t logoA = Float_t(logoH) / logoW; | |
1006 | ||
1007 | Printf("Logo dimensions (wxh): (%d x %d)", logoW, logoH); | |
1008 | Int_t myHeight = 800; | |
1009 | TCanvas* c = new TCanvas("check", "Check of AliceLogo", | |
1010 | (myHeight-22)/logoA, myHeight); | |
1011 | c->SetTopMargin(0); | |
1012 | c->SetRightMargin(0); | |
1013 | c->SetBottomMargin(0); | |
1014 | c->SetLeftMargin(0); | |
1015 | c->SetFillColor(debug ? kRed-4 : kWhite); | |
1016 | c->SetBorderSize(0); | |
1017 | c->SetBorderMode(0); | |
1018 | if (col & AliceLogo::kReverse /*&& !(col & AliceLogo::kL3)*/ && !debug) | |
1019 | c->SetFillColor(kBlack); | |
1020 | ||
1021 | if (debug) img->Draw(); | |
1022 | ||
1023 | AliceLogo* dut = new AliceLogo(debug); | |
1024 | dut->Draw(c, 0, 0, 1, tag, col); | |
1025 | ||
1026 | c->SaveAs("check.svg"); | |
1027 | } | |
1028 | ||
1029 | TVirtualPad* fPad; // Our pad | |
1030 | Double_t fAspect; // Aspect ratio of our pad | |
1031 | Double_t fL3Thick; // Fraction of canvas height | |
1032 | Double_t fL3Height; // Fraction of canvas height | |
1033 | Double_t fL3Width; // Width of L3 sub-pad | |
1034 | Bool_t fDebug; // Debug (make outline only) | |
1035 | Int_t fRed; // The red color | |
1036 | Int_t fYellow; // The yellow-ish color | |
1037 | Int_t fPink; // The dark-red pink-ish color | |
1038 | Int_t fBlue; // The blue gray-ish color | |
1039 | }; | |
1040 | ||
1041 | #endif | |
1042 | // | |
1043 | // EOF | |
1044 | // |