Logo ROOT  

Reference Guide
Loading...
Searching...
No Matches
TASPaletteEditor.cxx
Go to the documentation of this file.
1// @(#)root/asimage:$Id$
2// Author: Reiner Rohlfs 24/03/2002
3
4/*************************************************************************
5 * Copyright (C) 1995-2002, Rene Brun, Fons Rademakers and Reiner Rohlfs *
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/** \class TASPaletteEditor
13\ingroup asimage
14
15This is a GUI window to edit a color palette.
16It is called by a pull down menu item of TASImage.
17*/
18
19#include "TASImage.h"
20#include "TRootEmbeddedCanvas.h"
21#include "TCanvas.h"
22#include "TH1.h"
23#include "TFile.h"
24#include "TASPaletteEditor.h"
25#include "TGXYLayout.h"
26#include "TGButton.h"
27#include "TGComboBox.h"
28#include "TGFileDialog.h"
29#include "TLine.h"
30#include "TROOT.h"
31#include "TMath.h"
32#include "RConfigure.h"
33#include "TVirtualX.h"
34#include "strlcpy.h"
35#include "snprintf.h"
36
37#ifdef R__HAS_COCOA
38# define X_DISPLAY_MISSING 1
39#endif
40
41#ifdef WIN32
42#include "Windows4root.h"
43#endif
44
45#ifndef WIN32
46# include <afterbase.h>
47#else
48# define X_DISPLAY_MISSING 1
49# include <afterbase.h>
50#endif
51# include <afterimage.h>
52extern "C" {
53# include <bmp.h>
54}
55
56
57static const char *gFileTypes[] = {
58 "ROOT palette file", "*.pal.root",
59 "ASCII palette file", "*.pal.txt",
60 nullptr, nullptr
61};
62
63static UShort_t gRedRainbow[12] = {
64 0x0000, 0x7000, 0x0000, 0x0000, 0x0000,
65 0xffff, 0xffff, 0x7000, 0x8000, 0xffff
66};
67static UShort_t gGreenRainbow[12] = {
68 0x0000, 0x0000, 0x0000, 0xffff, 0xffff,
69 0xffff, 0x0000, 0x0000, 0x8000, 0xffff
70};
71static UShort_t gBlueRainbow[12] = {
72 0x0000, 0x7000, 0xffff, 0xffff, 0x0000,
73 0x0000, 0x0000, 0x0000, 0xa000, 0xffff
74};
75
76
77
78////////////////////////////////////////////////////////////////////////////////
79/// Palette editor constructor.
80/// The palette editor allows the editing of the color palette of the image.
81
82TASPaletteEditor::TASPaletteEditor(TAttImage *attImage, UInt_t w, UInt_t h)
83 : TPaletteEditor(attImage, w, h), TGMainFrame(nullptr, w, h)
84{
85 SetLayoutManager(new TGXYLayout(this));
86 fHisto = nullptr;
87 fLimitLine[0] = nullptr;
88 fLimitLine[1] = nullptr;
89 fRampFactor = 0;
90 fImagePad = gPad;
91
92 fPaletteList = new TList;
93 fPaletteList->SetOwner();
94
95 fPalette = new TImagePalette(attImage->GetPalette());
96 fPaletteList->Add(fPalette);
97
98 // buttons
99 TGTextButton *button;
100
101 button = new TGTextButton(this, "&Apply", 1);
102 button->SetToolTipText("Apply the palette to the image");
103 AddFrame(button, new TGXYLayoutHints(70, 1, 8, 1.8));
104
105 button = new TGTextButton(this, "&Ok", 2);
106 button->SetToolTipText("Same as Apply and Cancel button");
107 AddFrame(button, new TGXYLayoutHints(70, 3, 8, 1.8));
108
109 button = new TGTextButton(this, "&Cancel", 3);
110 button->SetToolTipText("Close this window");
111 AddFrame(button, new TGXYLayoutHints(70, 5, 8, 1.8));
112
113 button = new TGTextButton(this, "&Save", 4);
114 button->SetToolTipText("Save the palette in a ROOT or an ASCII file");
115 AddFrame(button, new TGXYLayoutHints(70, 7.5, 8, 1.8));
116
117 button = new TGTextButton(this, "O&pen", 5);
118 button->SetToolTipText("Read a palette from a ROOT or an ASCII file");
119 AddFrame(button, new TGXYLayoutHints(70, 9.5, 8, 1.8));
120
121 button = new TGTextButton(this, "&New", 6);
122 button->SetToolTipText("Create a new palette (not yet implemented)");
123 button->SetState(kButtonDisabled);
124 AddFrame(button, new TGXYLayoutHints(70, 12, 8, 1.8));
125
126 button = new TGTextButton(this, "&Edit", 7);
127 button->SetToolTipText("Edit a palette (not yet implemented)");
128 button->SetState(kButtonDisabled);
129 AddFrame(button, new TGXYLayoutHints(70, 14, 8, 1.8));
130
131 fAutoUpdate = new TGCheckButton(this, "Auto Update", 13);
132 fAutoUpdate->SetToolTipText("Automatic update of the image (without Apply button)");
133 AddFrame(fAutoUpdate, new TGXYLayoutHints(50, 1, 20, 1.8));
134
135 fUnDoButton = new TGTextButton(this, "&Undo", 20);
136 fUnDoButton->SetToolTipText("Undo the last modification (repeatable)");
137 AddFrame(fUnDoButton, new TGXYLayoutHints(50, 3, 8, 1.8));
138
139 fReDoButton = new TGTextButton(this, "&Redo", 21);
140 fReDoButton->SetToolTipText("Undo the last undo operation (repeatable)");
141 AddFrame(fReDoButton, new TGXYLayoutHints(60, 3, 8, 1.8));
142
143 button = new TGTextButton(this, "&Log", 8);
144 button->SetToolTipText("Apply a log operation to the anchor points of the palette");
145 AddFrame(button, new TGXYLayoutHints(50, 15, 8, 1.8));
146
147 button = new TGTextButton(this, "E&xp", 9);
148 button->SetToolTipText("Apply a exp operation to the anchor points of the palette");
149 AddFrame(button, new TGXYLayoutHints(50, 17, 8, 1.8));
150
151 button = new TGTextButton(this, "L&in", 10);
152 button->SetToolTipText("Make the distance of all anchor points constant");
153 AddFrame(button, new TGXYLayoutHints(50, 19, 8, 1.8));
154
155 button = new TGTextButton(this, "In&vert", 11);
156 button->SetToolTipText("Invert the order of the colors");
157 AddFrame(button, new TGXYLayoutHints(60, 17, 8, 1.8));
158
159 fStepButton = new TGCheckButton(this, "Step", 12);
160 fStepButton->SetToolTipText("Apply a step function to the palette");
161 AddFrame(fStepButton, new TGXYLayoutHints(60, 19, 8, 1.8));
162
163 // ramp: 1, 2 or 4
164 TGGroupFrame *rampFrame = new TGGroupFrame(this, "Ramps");
165 rampFrame->SetLayoutManager(new TGXYLayout(rampFrame));
166 AddFrame(rampFrame, new TGXYLayoutHints(50, 8.5, 14, 6,
167 TGXYLayoutHints::kLRubberX | TGXYLayoutHints::kLRubberY |
168 TGXYLayoutHints::kLRubberH | TGXYLayoutHints::kLRubberW));
169
170 fRamps[0] = new TGRadioButton(rampFrame, "1", 1);
171 fRamps[0]->SetToolTipText("Repeat the palette once");
172 rampFrame->AddFrame(fRamps[0], new TGXYLayoutHints(2, 1.4, 5, 1.8));
173
174 fRamps[1] = new TGRadioButton(rampFrame, "2", 2);
175 fRamps[1]->SetToolTipText("Repeat the palette twice");
176 rampFrame->AddFrame(fRamps[1], new TGXYLayoutHints(2, 3.3, 5, 1.8));
177
178 fRamps[2] = new TGRadioButton(rampFrame, "4", 4);
179 fRamps[2]->SetToolTipText("Repeat the palette four times");
180 rampFrame->AddFrame(fRamps[2], new TGXYLayoutHints(8, 3.3, 5, 1.8));
181
182 fRamps[0]->Associate(this);
183 fRamps[1]->Associate(this);
184 fRamps[2]->Associate(this);
185
186 // the histogram of the data
187 fHistCanvas = new TRootEmbeddedCanvas("data hist", this, 300, 50);
188 AddFrame(fHistCanvas, new TGXYLayoutHints(1, 1, 48, 20,
189 TGXYLayoutHints::kLRubberW | TGXYLayoutHints::kLRubberH));
190
191 const ASImage *image = ((TASImage*)attImage)->GetImage();
192 if (image && image->alt.vector) {
193 Int_t pixel;
194 Double_t *data = image->alt.vector;
195 Int_t numPixel = image->width * image->height;
196 Int_t numBins = numPixel / 20;
197 numBins = (numBins < 10) ? 10 : (numBins > 200) ? 200 : numBins;
198
199 // get min and max value of image
200 fMinValue = fMaxValue = *image->alt.vector;
201 for (pixel = 1; pixel < numPixel; pixel++) {
202 if (fMinValue > *(data + pixel)) fMinValue = *(data + pixel);
203 if (fMaxValue < *(data + pixel)) fMaxValue = *(data + pixel);
204 }
205
206 fHisto = new TH1D("Statistics", "Pixel histogram of unzoomed image ",
207 numBins, fMinValue, fMaxValue);
208 for (pixel = 0; pixel < numPixel; pixel++)
209 fHisto->Fill(*(data + pixel));
210
211 fHisto->Draw("HIST");
212 fHisto->GetXaxis()->SetLabelFont(63);
213 fHisto->GetXaxis()->SetLabelSize(10);
214 fHisto->GetYaxis()->SetLabelFont(63);
215 fHisto->GetYaxis()->SetLabelSize(10);
216
217 fLimitLine[0] = new LimitLine(fMinValue + fPalette->fPoints[1] * (fMaxValue - fMinValue),
218 0, fHisto->GetMaximum(), this);
219 fLimitLine[0]->Draw();
220 fLimitLine[1] = new LimitLine(fMinValue + fPalette->fPoints[fPalette->fNumPoints - 2] *
221 (fMaxValue - fMinValue), 0, fHisto->GetMaximum(), this);
222 fLimitLine[1]->Draw();
223 }
224
225 // the combobox of different palettes
226 fComboBox = new TGComboBox(this, 100);
227 AddFrame(fComboBox, new TGXYLayoutHints(50, 6, 14, 2));
228
229 fComboBox->AddEntry("Rainbow", 0);
230 fComboBox->AddEntry("Grey", 1);
231 fComboBox->AddEntry("Hot", 2);
232 fComboBox->AddEntry("Cold", 3);
233 fComboBox->AddEntry("Bowlerhat", 4);
234 fComboBox->AddEntry("", 5);
235
236
237 // the palette
238 fPaletteCanvas = new TRootEmbeddedCanvas("palette", this, 300, 50);
239 AddFrame(fPaletteCanvas, new TGXYLayoutHints(1, 22, 78, 2.5,
240 TGXYLayoutHints::kLRubberW | TGXYLayoutHints::kLRubberY));
241
242 fPaintPalette = new PaintPalette(&fPalette, attImage);
243 fPaintPalette->Draw();
244
245 MapSubwindows();
246 Layout();
247
248 SetWindowName("Palette Editor");
249 SetIconName("Palette Editor");
250
251 MapWindow();
252
253 UpdateScreen(kFALSE);
254}
255
256////////////////////////////////////////////////////////////////////////////////
257/// Palette editor destructor. Deletes all frames and their layout hints.
258
259TASPaletteEditor::~TASPaletteEditor()
260{
261 TGFrameElement *ptr;
262
263 // delete all frames and layout hints
264 if (fList) {
265 TIter next(fList);
266 while ((ptr = (TGFrameElement *) next())) {
267 if (ptr->fLayout)
268 delete ptr->fLayout;
269 if (ptr->fFrame)
270 delete ptr->fFrame;
271 }
272 }
273
274 delete fHisto;
275 delete fPaintPalette;
276 delete fLimitLine[0];
277 delete fLimitLine[1];
278 delete fPaletteList;
279}
280
281////////////////////////////////////////////////////////////////////////////////
282/// Close editor.
283
284void TASPaletteEditor::CloseWindow()
285{
286 TPaletteEditor::CloseWindow();
287 delete this;
288}
289
290////////////////////////////////////////////////////////////////////////////////
291/// Process all editor mouse events
292
293Bool_t TASPaletteEditor::ProcessMessage(Longptr_t msg, Longptr_t param1, Longptr_t param2)
294{
295 switch (GET_MSG(msg)) {
296
297 case kC_COMMAND:
298 switch (GET_SUBMSG(msg)) {
299
300 case kCM_COMBOBOX:
301 NewPalette(param2);
302 break;
303
304 case kCM_RADIOBUTTON:
305 SetRamp(param1);
306 break;
307
308 case kCM_CHECKBUTTON:
309 if (param1 == 12)
310 SetStep();
311 break;
312
313 case kCM_BUTTON:
314 switch (param1) {
315
316 case 1 : // Apply
317 fAttImage->SetPalette(fPalette);
318 fImagePad->Modified();
319 fImagePad->Update();
320 break;
321
322 case 2 : // OK
323 fAttImage->SetPalette(fPalette);
324 fImagePad->Modified();
325 fImagePad->Update();
326 CloseWindow();
327 break;
328
329 case 3 : // Cancel
330 CloseWindow();
331 break;
332
333 case 4 : // Save
334 Save();
335 break;
336
337 case 5 : // Open
338 Open();
339 break;
340
341 case 8: // log
342 LogPalette();
343 break;
344
345 case 9: // exp
346 ExpPalette();
347 break;
348
349 case 10: // lin
350 LinPalette();
351 break;
352
353 case 11: // invert
354 InvertPalette();
355 break;
356
357
358 case 20: // undo
359 fPalette = (TImagePalette*)(fPaletteList->Before(fPalette));
360 if (fAutoUpdate->GetState() == kButtonDown) {
361 fAttImage->SetPalette(fPalette);
362 fImagePad->Modified();
363 fImagePad->Update();
364 }
365 if (fPalette) UpdateScreen(kTRUE);
366 break;
367
368 case 21: // redo
369 fPalette = (TImagePalette*)(fPaletteList->After(fPalette));
370 if (fAutoUpdate->GetState() == kButtonDown) {
371 fAttImage->SetPalette(fPalette);
372 fImagePad->Modified();
373 fImagePad->Update();
374 }
375 if (fPalette) UpdateScreen(kTRUE);
376 break;
377
378 default: ;
379 }
380 break;
381
382 default: ;
383 }
384 break;
385
386 default: ;
387 }
388
389 return kTRUE;
390}
391
392////////////////////////////////////////////////////////////////////////////////
393/// The newPalette is inserted in the list of palettes (fPaletteList) and
394/// fPalette is set to the newPalette. Protected method,
395
396void TASPaletteEditor::InsertNewPalette(TImagePalette *newPalette)
397{
398 // first remove all palettes in the list which are behind the
399 // current palette
400 while (auto obj = fPaletteList->After(fPalette))
401 delete fPaletteList->Remove(obj);
402
403 // add new palette and make it to the current palette
404 fPaletteList->Add(newPalette);
405 fPalette = newPalette;
406
407 // update the image
408 if (fAutoUpdate->GetState() == kButtonDown) {
409 fAttImage->SetPalette(fPalette);
410 fImagePad->Modified();
411 fImagePad->Update();
412 }
413}
414
415////////////////////////////////////////////////////////////////////////////////
416/// Saves the current palette either into a ROOT file or in an ASCII file.
417/// It is called by the Save - button. Protected method.
418
419void TASPaletteEditor::Save()
420{
421 TGFileInfo fi;
422 fi.fFileTypes = gFileTypes;
423 static Bool_t overwr = kFALSE;
424 fi.fOverwrite = overwr;
425
426 new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi);
427 overwr = fi.fOverwrite;
428 if (!fi.fFilename)
429 return;
430
431 TString fn = fi.fFilename;
432
433 if (fn.EndsWith(".pal.txt")) {
434 // write into an ASCII file
435 FILE *fl = fopen(fn.Data(), "w");
436 if (!fl)
437 return;
438 fprintf(fl, "%u\n", fPalette->fNumPoints);
439 for (Int_t pt = 0; pt < Int_t(fPalette->fNumPoints); pt++)
440 fprintf(fl, "%10.9f %04hx %04hx %04hx %04hx\n", fPalette->fPoints[pt], fPalette->fColorRed[pt],
441 fPalette->fColorGreen[pt], fPalette->fColorBlue[pt], fPalette->fColorAlpha[pt]);
442 fclose(fl);
443 } else {
444 // write into a ROOT file
445 if (!fn.EndsWith(".pal.root"))
446 fn.Append(".pal.root");
447
448 gROOT->SaveObjectAs(fPalette, fn.Data(), "q");
449 }
450}
451
452////////////////////////////////////////////////////////////////////////////////
453/// Opens either a ROOT file or an ASCII file and reads a palette.
454/// It is called by the Open - button. Protected method.
455
456void TASPaletteEditor::Open()
457{
458 TGFileInfo fi;
459 fi.fFileTypes = gFileTypes;
460
461 new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
462 if (!fi.fFilename)
463 return;
464
465 TString fn = fi.fFilename;
466
467 TImagePalette *newPalette = nullptr;
468
469 if (fn.EndsWith(".pal.txt")) {
470 FILE *fl = fopen(fn.Data(), "r");
471 if (!fl)
472 return;
473 UInt_t numPoints = 0;
474 if (fscanf(fl, "%u\n", &numPoints) != 1)
475 Error("Open", "Failure reading num points from %s", fn.Data());
476 newPalette = new TImagePalette(numPoints);
477 for (UInt_t pt = 0; pt < numPoints; pt++) {
478 if (fscanf(fl, "%lf %hx %hx %hx %hx\n", newPalette->fPoints + pt, newPalette->fColorRed + pt,
479 newPalette->fColorGreen + pt, newPalette->fColorBlue + pt, newPalette->fColorAlpha + pt) != 5)
480 Error("Open", "Failure reading point %u from %s", pt, fn.Data());
481 }
482 fclose(fl);
483 } else {
484 // read from a ROOT file
485 if (!fn.EndsWith(".pal.root"))
486 fn.Append(".pal.root");
487
488 TDirectory *dirsav = gDirectory;
489
490 auto fsave = TFile::Open(fn.Data(), "READ");
491 if (!fsave || !fsave->IsOpen()) {
492 delete fsave;
493 return;
494 }
495
496 newPalette = (TImagePalette *)fsave->Get("TImagePalette");
497 delete fsave;
498 if (dirsav)
499 dirsav->cd();
500 if (!newPalette)
501 return;
502 }
503
504 InsertNewPalette(newPalette);
505 UpdateScreen(kTRUE);
506
507 fComboBox->Select(5); // empty entry
508}
509
510////////////////////////////////////////////////////////////////////////////////
511/// All widgets of the screen are updated with the current palette.
512/// Protected method.
513
514void TASPaletteEditor::UpdateScreen(Bool_t histoUpdate)
515{
516 // update the color palette
517 fPaletteCanvas->GetCanvas()->Modified();
518 fPaletteCanvas->GetCanvas()->Update();
519
520 if (histoUpdate) {
521 // update the limit lines
522 Double_t xPos = fMinValue + fPalette->fPoints[1] * (fMaxValue - fMinValue);
523 fLimitLine[0]->SetX1(xPos);
524 fLimitLine[0]->SetX2(xPos);
525
526 xPos = fMinValue + fPalette->fPoints[fPalette->fNumPoints - 2] * (fMaxValue - fMinValue);
527 fLimitLine[1]->SetX1(xPos);
528 fLimitLine[1]->SetX2(xPos);
529
530 fHistCanvas->GetCanvas()->Modified();
531 fHistCanvas->GetCanvas()->Update();
532 }
533
534 // update undo / redo button
535 fUnDoButton->SetState(fPalette == fPaletteList->First() ? kButtonDisabled : kButtonUp);
536 fReDoButton->SetState(fPalette == fPaletteList->Last() ? kButtonDisabled : kButtonUp);
537
538 // test if it is a step palette
539 EButtonState step = kButtonDown;
540
541 Int_t pt;
542 for (pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt += 2)
543 if (TMath::Abs(fPalette->fPoints[pt] - fPalette->fPoints[pt + 1]) > 0.0001 ||
544 fPalette->fColorRed[pt] != fPalette->fColorRed[pt-1] ||
545 fPalette->fColorGreen[pt] != fPalette->fColorGreen[pt-1] ||
546 fPalette->fColorBlue[pt] != fPalette->fColorBlue[pt-1])
547 step = kButtonUp;
548 fStepButton->SetState(step);
549
550 // find the ramp factor
551 fRampFactor = 4;
552 Int_t off = (fPalette->fNumPoints - 2) / 4;
553 for (pt = 0; pt < Int_t(fPalette->fNumPoints - 2) / 4 * 3; pt++)
554 if (fPalette->fColorRed[pt + 1] != fPalette->fColorRed[pt + 1 + off] ||
555 fPalette->fColorGreen[pt + 1] != fPalette->fColorGreen[pt + 1 + off] ||
556 fPalette->fColorBlue[pt + 1] != fPalette->fColorBlue[pt + 1 + off] ||
557 fPalette->fColorAlpha[pt + 1] != fPalette->fColorAlpha[pt + 1 + off]) {
558 fRampFactor = 2;
559 break;
560 }
561
562 off = (fPalette->fNumPoints - 2) / 2;
563 for (pt = 0; pt < Int_t(fPalette->fNumPoints - 2) / 2; pt++)
564 if (fPalette->fColorRed[pt + 1] != fPalette->fColorRed[pt + 1 + off] ||
565 fPalette->fColorGreen[pt + 1] != fPalette->fColorGreen[pt + 1 + off] ||
566 fPalette->fColorBlue[pt + 1] != fPalette->fColorBlue[pt + 1 + off] ||
567 fPalette->fColorAlpha[pt + 1] != fPalette->fColorAlpha[pt + 1 + off]) {
568 fRampFactor = 1;
569 break;
570 }
571
572 fRamps[0]->SetState(fRampFactor == 1 ? kButtonDown : kButtonUp);
573 fRamps[1]->SetState(fRampFactor == 2 ? kButtonDown : kButtonUp);
574 fRamps[2]->SetState(fRampFactor == 4 ? kButtonDown : kButtonUp);
575}
576
577////////////////////////////////////////////////////////////////////////////////
578/// The anchor points are rescaled by a log operation.
579/// It is called by the log - button. Protected method.
580
581void TASPaletteEditor::LogPalette()
582{
583 TImagePalette *newPalette = new TImagePalette(*fPalette);
584
585 Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];
586
587 for (Int_t pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt++)
588 newPalette->fPoints[pt] = fPalette->fPoints[1] +
589 TMath::Log(fPalette->fPoints[pt] - fPalette->fPoints[1] + 1) /
590 TMath::Log(delta + 1) * delta;
591
592 InsertNewPalette(newPalette);
593 UpdateScreen(kFALSE);
594}
595
596////////////////////////////////////////////////////////////////////////////////
597/// The anchor points are rescaled by a exp operation.
598/// It is called by the exp - button. Protected method.
599
600void TASPaletteEditor::ExpPalette()
601{
602 TImagePalette *newPalette = new TImagePalette(*fPalette);
603
604 Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];
605
606 for (Int_t pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt++)
607 newPalette->fPoints[pt] = fPalette->fPoints[1] +
608 TMath::Exp((fPalette->fPoints[pt] - fPalette->fPoints[1]) *
609 TMath::Log(delta + 1) / delta) - 1;
610
611 InsertNewPalette(newPalette);
612 UpdateScreen(kFALSE);
613}
614
615////////////////////////////////////////////////////////////////////////////////
616/// The anchor points are rescaled to be linar.
617/// It is called by the lin - button. Protected method.
618
619void TASPaletteEditor::LinPalette()
620{
621 TImagePalette *newPalette = new TImagePalette(*fPalette);
622
623 Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];
624 if (fStepButton->GetState() == kButtonUp) {
625 for (Int_t pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt++)
626 newPalette->fPoints[pt] = fPalette->fPoints[1] +
627 delta * (pt - 1) / (fPalette->fNumPoints - 3);
628 } else {
629 for (Int_t pt = 0; pt < Int_t(fPalette->fNumPoints - 4); pt += 2) {
630 newPalette->fPoints[pt + 3] = fPalette->fPoints[1] + delta * (pt + 2) /
631 (fPalette->fNumPoints - 2) ;
632 newPalette->fPoints[pt + 2] = newPalette->fPoints[pt + 3];
633 }
634 }
635
636 InsertNewPalette(newPalette);
637 UpdateScreen(kFALSE);
638}
639
640////////////////////////////////////////////////////////////////////////////////
641/// The palette is inverted.
642/// It is called by the invert - button. Protected method.
643
644void TASPaletteEditor::InvertPalette()
645{
646 TImagePalette *newPalette = new TImagePalette(*fPalette);
647
648 Int_t pt;
649 for (pt = 0; pt < Int_t(fPalette->fNumPoints); pt++) {
650 newPalette->fColorRed[pt] = fPalette->fColorRed[fPalette->fNumPoints - 1 - pt];
651 newPalette->fColorGreen[pt] = fPalette->fColorGreen[fPalette->fNumPoints - 1 - pt];
652 newPalette->fColorBlue[pt] = fPalette->fColorBlue[fPalette->fNumPoints - 1 - pt];
653 newPalette->fColorAlpha[pt] = fPalette->fColorAlpha[fPalette->fNumPoints - 1 - pt];
654 }
655
656 for (pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt++)
657 newPalette->fPoints[pt] = fPalette->fPoints[1] +
658 fPalette->fPoints[fPalette->fNumPoints - 2] -
659 fPalette->fPoints[fPalette->fNumPoints - 1 - pt];
660
661 InsertNewPalette(newPalette);
662 UpdateScreen(kFALSE);
663}
664
665////////////////////////////////////////////////////////////////////////////////
666/// A new palette is created, depending on the id.
667/// It is called by the combo box. Protected method.
668
669void TASPaletteEditor::NewPalette(Long_t id)
670{
671 if (id == 5) // empty entry
672 return;
673
674 TImagePalette *newPalette;
675
676 Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];
677 UInt_t numPt;
678
679 numPt = id == 0 ? 12 : 13;
680 newPalette = new TImagePalette(numPt);
681 Int_t pt;
682 for (pt = 1; pt < Int_t(numPt - 1); pt++) {
683 newPalette->fPoints[pt] = fPalette->fPoints[1] + (pt - 1) * delta / (numPt - 3);
684 newPalette->fColorAlpha[pt] = 0xffff;
685 }
686
687 switch (id) {
688 case 0: // rainbow
689 memcpy(newPalette->fColorRed + 1, gRedRainbow, 12 * sizeof(UShort_t));
690 memcpy(newPalette->fColorGreen + 1, gGreenRainbow, 12 * sizeof(UShort_t));
691 memcpy(newPalette->fColorBlue + 1, gBlueRainbow, 12 * sizeof(UShort_t));
692 break;
693
694 case 1: // gray
695 for (pt = 1; pt < Int_t(numPt - 1); pt++) {
696 newPalette->fColorRed[pt] = 0xffff * (pt - 1) / (numPt - 3);
697 newPalette->fColorGreen[pt] = 0xffff * (pt - 1) / (numPt - 3);
698 newPalette->fColorBlue[pt] = 0xffff * (pt - 1) / (numPt - 3);
699 }
700 break;
701
702 case 2: // hot (red)
703 for (pt = 1; pt < Int_t(numPt - 1) / 2; pt++) {
704 newPalette->fColorRed[pt] = 0xffff * (pt - 1) / ((numPt - 3) / 2);
705 newPalette->fColorGreen[pt] = 0;
706 newPalette->fColorBlue[pt] = 0;
707 }
708
709 for (; pt < Int_t(numPt - 1); pt++) {
710 newPalette->fColorRed[pt] = 0xffff;
711 newPalette->fColorGreen[pt] = 0xffff * (pt - (numPt - 1) / 2) / ((numPt - 3) / 2);
712 newPalette->fColorBlue[pt] = 0xffff * (pt - (numPt - 1) / 2) / ((numPt - 3) / 2);
713 }
714 break;
715
716 case 3: // cold (blue)
717 for (pt = 1; pt < Int_t(numPt - 1) / 2; pt++) {
718 newPalette->fColorRed[pt] = 0;
719 newPalette->fColorGreen[pt] = 0;
720 newPalette->fColorBlue[pt] = 0xffff * (pt - 1) / ((numPt - 3) / 2);
721 }
722
723 for (; pt < Int_t(numPt - 1); pt++) {
724 newPalette->fColorRed[pt] = 0xffff * (pt - (numPt - 1) / 2) / ((numPt - 3) / 2);
725 newPalette->fColorGreen[pt] = 0xffff * (pt - (numPt - 1) / 2) / ((numPt - 3) / 2);
726 newPalette->fColorBlue[pt] = 0xffff;
727 }
728 break;
729
730 case 4: // bolwerhat
731 for (pt = 1; pt < Int_t(numPt + 1) / 2; pt++) {
732 newPalette->fColorRed[pt] = newPalette->fColorRed[numPt - pt - 1]
733 = 0xffff * (pt - 1) / ((numPt - 3) / 2);
734 newPalette->fColorGreen[pt] = newPalette->fColorGreen[numPt - pt - 1]
735 = 0xffff * (pt - 1) / ((numPt - 3) / 2);
736 newPalette->fColorBlue[pt] = newPalette->fColorBlue[numPt - pt - 1]
737 = 0xffff * (pt - 1) / ((numPt - 3) / 2);
738 }
739 break;
740 }
741
742 newPalette->fPoints[0] = 0;
743 newPalette->fColorRed[0] = newPalette->fColorRed[1];
744 newPalette->fColorGreen[0] = newPalette->fColorGreen[1];
745 newPalette->fColorBlue[0] = newPalette->fColorBlue[1];
746 newPalette->fColorAlpha[0] = newPalette->fColorAlpha[1];
747
748 newPalette->fPoints[newPalette->fNumPoints-1] = 1.0;
749 newPalette->fColorRed[newPalette->fNumPoints-1] = newPalette->fColorRed[newPalette->fNumPoints-2];
750 newPalette->fColorGreen[newPalette->fNumPoints-1] = newPalette->fColorGreen[newPalette->fNumPoints-2];
751 newPalette->fColorBlue[newPalette->fNumPoints-1] = newPalette->fColorBlue[newPalette->fNumPoints-2];
752 newPalette->fColorAlpha[newPalette->fNumPoints-1] = newPalette->fColorAlpha[newPalette->fNumPoints-2];
753
754 InsertNewPalette(newPalette);
755 UpdateScreen(kFALSE);
756}
757
758////////////////////////////////////////////////////////////////////////////////
759/// Create a step palette. This is called by the step - check button.
760/// Protected method.
761
762void TASPaletteEditor::SetStep()
763{
764 TImagePalette *newPalette;
765
766 if (fStepButton->GetState() == kButtonDown) {
767 // change colors in steps
768 newPalette = new TImagePalette(fPalette->fNumPoints * 2 - 2);
769 Double_t fkt = (Double_t)(fPalette->fNumPoints - 3) / (fPalette->fNumPoints - 2);
770 for (Int_t pt = 1; pt < Int_t(fPalette->fNumPoints - 1); pt++) {
771 newPalette->fPoints[pt * 2 - 1] = fPalette->fPoints[1] + (fPalette->fPoints[pt] - fPalette->fPoints[1]) * fkt;
772 newPalette->fPoints[pt * 2] = fPalette->fPoints[1] + (fPalette->fPoints[pt + 1] - fPalette->fPoints[1]) * fkt;
773 newPalette->fColorRed[pt * 2 - 1] = newPalette->fColorRed[pt * 2] = fPalette->fColorRed[pt];
774 newPalette->fColorGreen[pt * 2 - 1] = newPalette->fColorGreen[pt * 2] = fPalette->fColorGreen[pt];
775 newPalette->fColorBlue[pt * 2 - 1] = newPalette->fColorBlue[pt * 2] = fPalette->fColorBlue[pt];
776 newPalette->fColorAlpha[pt * 2 - 1] = newPalette->fColorAlpha[pt * 2] = fPalette->fColorAlpha[pt];
777 }
778 } else {
779 // continuous change of colors
780 newPalette = new TImagePalette(fPalette->fNumPoints / 2 + 1);
781 Double_t fkt = (Double_t) (fPalette->fPoints[fPalette->fNumPoints - 2] - fPalette->fPoints[1]) /
782 (fPalette->fPoints[fPalette->fNumPoints - 3] - fPalette->fPoints[1]);
783 for (Int_t pt = 1; pt < Int_t(newPalette->fNumPoints - 1); pt++) {
784 newPalette->fPoints[pt] = fPalette->fPoints[pt * 2 -1] * fkt;
785 newPalette->fColorRed[pt] = fPalette->fColorRed[pt * 2 - 1];
786 newPalette->fColorGreen[pt] = fPalette->fColorGreen[pt * 2 - 1];
787 newPalette->fColorBlue[pt] = fPalette->fColorBlue[pt * 2 - 1];
788 newPalette->fColorAlpha[pt] = fPalette->fColorAlpha[pt * 2 - 1];
789 }
790 }
791
792 newPalette->fPoints[0] = fPalette->fPoints[0];
793 newPalette->fColorRed[0] = fPalette->fColorRed[0];
794 newPalette->fColorGreen[0] = fPalette->fColorGreen[0];
795 newPalette->fColorBlue[0] = fPalette->fColorBlue[0];
796 newPalette->fColorAlpha[0] = fPalette->fColorAlpha[0];
797
798 newPalette->fPoints[newPalette->fNumPoints-2] = fPalette->fPoints[fPalette->fNumPoints-2];
799 newPalette->fPoints[newPalette->fNumPoints-1] = fPalette->fPoints[fPalette->fNumPoints-1];
800 newPalette->fColorRed[newPalette->fNumPoints-1] = fPalette->fColorRed[fPalette->fNumPoints-1];
801 newPalette->fColorGreen[newPalette->fNumPoints-1] = fPalette->fColorGreen[fPalette->fNumPoints-1];
802 newPalette->fColorBlue[newPalette->fNumPoints-1] = fPalette->fColorBlue[fPalette->fNumPoints-1];
803 newPalette->fColorAlpha[newPalette->fNumPoints-1] = fPalette->fColorAlpha[fPalette->fNumPoints-1];
804
805 InsertNewPalette(newPalette);
806 UpdateScreen(kFALSE);
807}
808
809////////////////////////////////////////////////////////////////////////////////
810/// The palette is repeated up to 4 times.
811/// This is called by one of the ramp radio buttons. Protected method.
812
813void TASPaletteEditor::SetRamp(Long_t ramp)
814{
815 if (ramp == fRampFactor)
816 return;
817
818 Int_t ptPerRamp = (fPalette->fNumPoints - 2) / fRampFactor;
819 TImagePalette *newPalette = new TImagePalette(ptPerRamp * ramp + 2);
820
821 Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];
822 for (Int_t rp = 0; rp < ramp; rp++) {
823 for (Int_t pt = 0; pt < ptPerRamp; pt++) {
824 newPalette->fPoints[1 + pt + rp * ptPerRamp] = fPalette->fPoints[1] +
825 delta / ramp * rp +
826 (fPalette->fPoints[1+pt] - fPalette->fPoints[1]) * fRampFactor / ramp;
827 newPalette->fColorRed [1 + pt + rp * ptPerRamp] = fPalette->fColorRed [1 + pt];
828 newPalette->fColorGreen[1 + pt + rp * ptPerRamp] = fPalette->fColorGreen[1 + pt];
829 newPalette->fColorBlue [1 + pt + rp * ptPerRamp] = fPalette->fColorBlue [1 + pt];
830 newPalette->fColorAlpha[1 + pt + rp * ptPerRamp] = fPalette->fColorAlpha[1 + pt];
831 }
832 }
833
834 newPalette->fPoints[0] = fPalette->fPoints[0];
835 newPalette->fColorRed[0] = fPalette->fColorRed[0];
836 newPalette->fColorGreen[0] = fPalette->fColorGreen[0];
837 newPalette->fColorBlue[0] = fPalette->fColorBlue[0];
838 newPalette->fColorAlpha[0] = fPalette->fColorAlpha[0];
839
840 newPalette->fPoints[newPalette->fNumPoints-2] = fPalette->fPoints[fPalette->fNumPoints-2];
841 newPalette->fPoints[newPalette->fNumPoints-1] = fPalette->fPoints[fPalette->fNumPoints-1];
842 newPalette->fColorRed[newPalette->fNumPoints-1] = fPalette->fColorRed[fPalette->fNumPoints-1];
843 newPalette->fColorGreen[newPalette->fNumPoints-1] = fPalette->fColorGreen[fPalette->fNumPoints-1];
844 newPalette->fColorBlue[newPalette->fNumPoints-1] = fPalette->fColorBlue[fPalette->fNumPoints-1];
845 newPalette->fColorAlpha[newPalette->fNumPoints-1] = fPalette->fColorAlpha[fPalette->fNumPoints-1];
846
847 InsertNewPalette(newPalette);
848 UpdateScreen(kFALSE);
849}
850
851////////////////////////////////////////////////////////////////////////////////
852/// Updates the range of the palette.
853/// This is called after the blue limit lines were moved to define
854/// a new range.
855
856void TASPaletteEditor::UpdateRange()
857{
858 if (fMaxValue == fMinValue)
859 return;
860
861 TImagePalette *newPalette = new TImagePalette(*fPalette);
862
863 Double_t l0 = fLimitLine[0]->GetX1();
864 Double_t l1 = fLimitLine[1]->GetX1();
865 l0 = (l0 < fMinValue) ? fMinValue : ((l0 > fMaxValue) ? fMaxValue : l0);
866 l1 = (l1 < fMinValue) ? fMinValue : ((l1 > fMaxValue) ? fMaxValue : l1);
867 if (l0 > l1) {
868 Double_t tmp = l0;
869 l0 = l1;
870 l1 = tmp;
871 }
872
873 Double_t oldDelta = fPalette->fPoints[fPalette->fNumPoints - 2] - fPalette->fPoints[1];
874 Double_t newDelta = (l1 - l0) / (fMaxValue - fMinValue);
875 Double_t newOff = (l0 - fMinValue) / (fMaxValue - fMinValue);
876
877 if (newDelta < 0.001 || oldDelta < 0.001)
878 return;
879
880 for (Int_t pt = 1; pt < Int_t(fPalette->fNumPoints - 1); pt++)
881 newPalette->fPoints[pt] = newOff +
882 (fPalette->fPoints[pt] - fPalette->fPoints[1]) * newDelta / oldDelta;
883
884 InsertNewPalette(newPalette);
885 UpdateScreen(kFALSE);
886}
887
888////////////////////////////////////////////////////////////////////////////////
889/// Actually paint the paletter.
890
891void TASPaletteEditor::PaintPalette::Paint(Option_t *)
892{
893 // get geometry of pad
894 Int_t to_w = TMath::Abs(gPad->XtoPixel(gPad->GetX2()) -
895 gPad->XtoPixel(gPad->GetX1()));
896 Int_t to_h = TMath::Abs(gPad->YtoPixel(gPad->GetY2()) -
897 gPad->YtoPixel(gPad->GetY1()));
898
899 ASGradient grad;
900
901 grad.npoints = (*fPalette)->fNumPoints - 2;
902 grad.type = GRADIENT_Left2Right;
903 grad.color = new ARGB32[grad.npoints];
904 grad.offset = new double[grad.npoints];
905 for (Int_t pt = 0; pt < grad.npoints; pt++) {
906 grad.offset[pt] = ((*fPalette)->fPoints[pt + 1] - (*fPalette)->fPoints[1]) /
907 ((*fPalette)->fPoints[(*fPalette)->fNumPoints - 2] - (*fPalette)->fPoints[1]);
908 grad.color[pt] = (((ARGB32)((*fPalette)->fColorBlue[pt + 1] & 0xff00)) >> 8) |
909 (((ARGB32)((*fPalette)->fColorGreen[pt + 1] & 0xff00)) ) |
910 (((ARGB32)((*fPalette)->fColorRed[pt + 1] & 0xff00)) << 8) |
911 (((ARGB32)((*fPalette)->fColorAlpha[pt + 1] & 0xff00)) << 16);
912 }
913
914 ASImage * grad_im = make_gradient((ASVisual*)TASImage::GetVisual(), &grad , to_w, to_h,
915 SCL_DO_COLOR, ASA_ARGB32, 0,
916 fAttImage->GetImageQuality());
917 delete [] grad.color;
918 delete [] grad.offset;
919
920 Window_t wid = (Window_t)gVirtualX->GetWindowID(gPad->GetPixmapID());
921 TASImage::Image2Drawable(grad_im, wid, 0, 0);
922 destroy_asimage(&grad_im);
923}
924
925////////////////////////////////////////////////////////////////////////////////
926/// The blue limit line in the pixel value histogram.
927
928TASPaletteEditor::LimitLine::LimitLine(Coord_t x, Coord_t y1, Coord_t y2,
929 TASPaletteEditor *gui)
930 : TLine(x, y1, x, y2)
931{
932 fGui = gui;
933 SetLineColor(4);
934 SetLineWidth(2);
935}
936
937////////////////////////////////////////////////////////////////////////////////
938/// Paint the limit lines.
939
940void TASPaletteEditor::LimitLine::Paint(Option_t *option)
941{
942 fY1 = gPad->GetUymin();
943 fY2 = gPad->GetUymax();
944
945 TLine::Paint(option);
946}
947
948////////////////////////////////////////////////////////////////////////////////
949
950void TASPaletteEditor::LimitLine::ExecuteEvent(Int_t event,
951 Int_t px, Int_t /*py*/)
952{
953 static Int_t oldX;
954
955 if (!gPad) return;
956
957 switch(event) {
958 case kMouseMotion:
959 gPad->SetCursor(kMove);
960 break;
961
962 case kButton1Down:
963 gVirtualX->SetLineColor(-1);
964 TAttLine::Modify(); //Change line attributes only if necessary
965 oldX = gPad->XtoAbsPixel(fX1);
966 break;
967
968 case kButton1Motion:
969 gVirtualX->DrawLine(oldX, gPad->YtoPixel(fY1), oldX, gPad->YtoPixel(fY2));
970 oldX = px;
971 gVirtualX->DrawLine(oldX, gPad->YtoPixel(fY1), oldX, gPad->YtoPixel(fY2));
972 gVirtualX->Update();
973 break;
974
975 case kButton1Up:
976 gVirtualX->SetLineColor(-1);
977 TAttLine::Modify(); //Change line attributes only if necessary
978 fX1 = fX2 = gPad->AbsPixeltoX(oldX);
979 fGui->UpdateRange();
980 gPad->Modified(kTRUE);
981 gPad->Update();
982 break;
983
984 default:
985 break;
986 }
987}
kMouseMotion
@ kMouseMotion
Definition Buttons.h:23
kButton1Motion
@ kButton1Motion
Definition Buttons.h:20
kButton1Up
@ kButton1Up
Definition Buttons.h:19
kButton1Down
@ kButton1Down
Definition Buttons.h:17
kMove
@ kMove
Definition GuiTypes.h:375
Window_t
Handle_t Window_t
Window handle.
Definition GuiTypes.h:29
h
#define h(i)
Definition RSha256.hxx:106
Coord_t
double Coord_t
Pad world coordinates (double).
Definition RtypesCore.h:101
UShort_t
unsigned short UShort_t
Unsigned Short integer 2 bytes (unsigned short).
Definition RtypesCore.h:54
Int_t
int Int_t
Signed integer 4 bytes (int).
Definition RtypesCore.h:59
Longptr_t
long Longptr_t
Integer large enough to hold a pointer (platform-dependent).
Definition RtypesCore.h:89
UInt_t
unsigned int UInt_t
Unsigned integer 4 bytes (unsigned int).
Definition RtypesCore.h:60
Long_t
long Long_t
Signed long integer 4 bytes (long). Size depends on architecture.
Definition RtypesCore.h:68
Bool_t
bool Bool_t
Boolean (0=false, 1=true) (bool).
Definition RtypesCore.h:77
kFALSE
constexpr Bool_t kFALSE
Definition RtypesCore.h:108
Double_t
double Double_t
Double 8 bytes.
Definition RtypesCore.h:73
kTRUE
constexpr Bool_t kTRUE
Definition RtypesCore.h:107
Option_t
const char Option_t
Option string (const char).
Definition RtypesCore.h:80
gRedRainbow
static UShort_t gRedRainbow[12]
Definition TASPaletteEditor.cxx:63
gBlueRainbow
static UShort_t gBlueRainbow[12]
Definition TASPaletteEditor.cxx:71
gGreenRainbow
static UShort_t gGreenRainbow[12]
Definition TASPaletteEditor.cxx:67
gFileTypes
static const char * gFileTypes[]
Definition TASPaletteEditor.cxx:57
Error
Error("WriteTObject","The current directory (%s) is not associated with a file. The object (%s) has not been written.", GetName(), objname)
gDirectory
#define gDirectory
Definition TDirectory.h:385
EButtonState
EButtonState
Definition TGButton.h:52
kButtonDown
@ kButtonDown
Definition TGButton.h:54
kButtonDisabled
@ kButtonDisabled
Definition TGButton.h:56
kButtonUp
@ kButtonUp
Definition TGButton.h:53
gClient
#define gClient
Definition TGClient.h:157
kFDOpen
@ kFDOpen
Definition TGFileDialog.h:21
kFDSave
@ kFDSave
Definition TGFileDialog.h:22
gROOT
#define gROOT
Definition TROOT.h:417
gPad
#define gPad
Definition TVirtualPad.h:322
gVirtualX
#define gVirtualX
Definition TVirtualX.h:375
GET_MSG
Int_t GET_MSG(Long_t val)
Definition WidgetMessageTypes.h:110
kCM_COMBOBOX
@ kCM_COMBOBOX
Definition WidgetMessageTypes.h:38
kC_COMMAND
@ kC_COMMAND
Definition WidgetMessageTypes.h:31
kCM_BUTTON
@ kCM_BUTTON
Definition WidgetMessageTypes.h:34
kCM_RADIOBUTTON
@ kCM_RADIOBUTTON
Definition WidgetMessageTypes.h:36
kCM_CHECKBUTTON
@ kCM_CHECKBUTTON
Definition WidgetMessageTypes.h:35
GET_SUBMSG
Int_t GET_SUBMSG(Long_t val)
Definition WidgetMessageTypes.h:111
TASImage
Image class.
Definition TASImage.h:31
TASImage::GetVisual
static const ASVisual * GetVisual()
Return visual.
Definition TASImage.cxx:5103
TASImage::Image2Drawable
static void Image2Drawable(ASImage *im, Drawable_t wid, Int_t x, Int_t y, Int_t xsrc=0, Int_t ysrc=0, UInt_t wsrc=0, UInt_t hsrc=0, Option_t *opt="")
Draw asimage on drawable.
Definition TASImage.cxx:1233
TASPaletteEditor::LimitLine::Paint
void Paint(Option_t *option="") override
Paint the limit lines.
Definition TASPaletteEditor.cxx:940
TASPaletteEditor::LimitLine::LimitLine
LimitLine(Coord_t x, Coord_t y1, Coord_t y2, TASPaletteEditor *gui)
The blue limit line in the pixel value histogram.
Definition TASPaletteEditor.cxx:928
TASPaletteEditor::LimitLine::ExecuteEvent
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute action corresponding to an event at (px,py).
Definition TASPaletteEditor.cxx:950
TASPaletteEditor::PaintPalette::Paint
void Paint(Option_t *option="") override
Actually paint the paletter.
Definition TASPaletteEditor.cxx:891
TASPaletteEditor::UpdateScreen
void UpdateScreen(Bool_t histoUpdate)
All widgets of the screen are updated with the current palette.
Definition TASPaletteEditor.cxx:514
TASPaletteEditor::fPaintPalette
PaintPalette * fPaintPalette
Definition TASPaletteEditor.h:71
TASPaletteEditor::UpdateRange
void UpdateRange()
Updates the range of the palette.
Definition TASPaletteEditor.cxx:856
TASPaletteEditor::fUnDoButton
TGTextButton * fUnDoButton
Definition TASPaletteEditor.h:74
TASPaletteEditor::fImagePad
TVirtualPad * fImagePad
Definition TASPaletteEditor.h:70
TASPaletteEditor::fPalette
TImagePalette * fPalette
current palette
Definition TASPaletteEditor.h:69
TASPaletteEditor::fStepButton
TGCheckButton * fStepButton
Definition TASPaletteEditor.h:78
TASPaletteEditor::fReDoButton
TGTextButton * fReDoButton
Definition TASPaletteEditor.h:75
TASPaletteEditor::fMinValue
Double_t fMinValue
min value of image
Definition TASPaletteEditor.h:62
TASPaletteEditor::Open
void Open()
Opens either a ROOT file or an ASCII file and reads a palette.
Definition TASPaletteEditor.cxx:456
TASPaletteEditor::fPaletteList
TList * fPaletteList
list of palettes for undo and redo
Definition TASPaletteEditor.h:68
TASPaletteEditor::ExpPalette
void ExpPalette()
The anchor points are rescaled by a exp operation.
Definition TASPaletteEditor.cxx:600
TASPaletteEditor::InsertNewPalette
void InsertNewPalette(TImagePalette *newPalette)
The newPalette is inserted in the list of palettes (fPaletteList) and fPalette is set to the newPalet...
Definition TASPaletteEditor.cxx:396
TASPaletteEditor::CloseWindow
void CloseWindow() override
Close editor.
Definition TASPaletteEditor.cxx:284
TASPaletteEditor::fRamps
TGRadioButton * fRamps[3]
Definition TASPaletteEditor.h:79
TASPaletteEditor::TASPaletteEditor
TASPaletteEditor(TAttImage *attImage, UInt_t w, UInt_t h)
Palette editor constructor.
Definition TASPaletteEditor.cxx:82
TASPaletteEditor::ProcessMessage
Bool_t ProcessMessage(Longptr_t msg, Longptr_t param1, Longptr_t param2) override
Process all editor mouse events.
Definition TASPaletteEditor.cxx:293
TASPaletteEditor::fHistCanvas
TRootEmbeddedCanvas * fHistCanvas
canvas to draw the histogram
Definition TASPaletteEditor.h:67
TASPaletteEditor::fComboBox
TGComboBox * fComboBox
Definition TASPaletteEditor.h:82
TASPaletteEditor::fHisto
TH1D * fHisto
histogram of image pixels
Definition TASPaletteEditor.h:65
TASPaletteEditor::~TASPaletteEditor
~TASPaletteEditor() override
Palette editor destructor. Deletes all frames and their layout hints.
Definition TASPaletteEditor.cxx:259
TASPaletteEditor::Save
void Save()
Saves the current palette either into a ROOT file or in an ASCII file.
Definition TASPaletteEditor.cxx:419
TASPaletteEditor::fAutoUpdate
TGCheckButton * fAutoUpdate
Definition TASPaletteEditor.h:77
TASPaletteEditor::NewPalette
void NewPalette(Long_t id)
A new palette is created, depending on the id.
Definition TASPaletteEditor.cxx:669
TASPaletteEditor::LinPalette
void LinPalette()
The anchor points are rescaled to be linar.
Definition TASPaletteEditor.cxx:619
TASPaletteEditor::fLimitLine
LimitLine * fLimitLine[2]
Definition TASPaletteEditor.h:72
TASPaletteEditor::SetRamp
void SetRamp(Long_t ramp)
The palette is repeated up to 4 times.
Definition TASPaletteEditor.cxx:813
TASPaletteEditor::InvertPalette
void InvertPalette()
The palette is inverted.
Definition TASPaletteEditor.cxx:644
TASPaletteEditor::SetStep
void SetStep()
Create a step palette.
Definition TASPaletteEditor.cxx:762
TASPaletteEditor::fMaxValue
Double_t fMaxValue
max value of image
Definition TASPaletteEditor.h:63
TASPaletteEditor::LogPalette
void LogPalette()
The anchor points are rescaled by a log operation.
Definition TASPaletteEditor.cxx:581
TASPaletteEditor::fPaletteCanvas
TRootEmbeddedCanvas * fPaletteCanvas
canvas to draw the current palette
Definition TASPaletteEditor.h:66
TAttImage
TImage attributes.
Definition TAttImage.h:59
TAttImage::GetPalette
virtual const TImagePalette & GetPalette() const
Definition TAttImage.h:88
TAttLine::Modify
virtual void Modify()
TAttLine::SetLineWidth
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition TAttLine.h:47
TAttLine::SetLineColor
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition TAttLine.h:44
TDirectory
Describe directory structure in memory.
Definition TDirectory.h:45
TDirectory::cd
virtual Bool_t cd()
Change current directory to "this" directory.
Definition TDirectory.cxx:544
TFile::Open
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
Definition TFile.cxx:3787
TGButton::SetToolTipText
virtual void SetToolTipText(const char *text, Long_t delayms=400)
Set tool tip text associated with this button.
Definition TGButton.cxx:439
TGButton::SetState
virtual void SetState(EButtonState state, Bool_t emit=kFALSE)
Set button state.
Definition TGButton.cxx:229
TGCheckButton
Selects different options.
Definition TGButton.h:264
TGComboBox
A combobox (also known as a drop down listbox) allows the selection of one item out of a list of item...
Definition TGComboBox.h:47
TGCompositeFrame::SetLayoutManager
virtual void SetLayoutManager(TGLayoutManager *l)
Set the layout manager for the composite frame.
Definition TGFrame.cxx:992
TGCompositeFrame::AddFrame
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=nullptr)
Add frame to the composite frame using the specified layout hints.
Definition TGFrame.cxx:1109
TGCompositeFrame::MapSubwindows
void MapSubwindows() override
Map all sub windows that are part of the composite frame.
Definition TGFrame.cxx:1156
TGCompositeFrame::Layout
void Layout() override
Layout the elements of the composite frame.
Definition TGFrame.cxx:1249
TGCompositeFrame::fList
TList * fList
container of frame elements
Definition TGFrame.h:294
TGFileDialog
This class creates a file selection dialog.
Definition TGFileDialog.h:65
TGFileInfo::fFilename
char * fFilename
selected file name
Definition TGFileDialog.h:46
TGFileInfo::fFileTypes
const char ** fFileTypes
file types used to filter selectable files
Definition TGFileDialog.h:48
TGFileInfo::fOverwrite
Bool_t fOverwrite
if true overwrite the file with existing name on save
Definition TGFileDialog.h:50
TGFrameElement::fLayout
TGLayoutHints * fLayout
Definition TGLayout.h:114
TGFrameElement::fFrame
TGFrame * fFrame
Definition TGLayout.h:112
TGFrame::MapWindow
void MapWindow() override
map window
Definition TGFrame.h:206
TGGroupFrame
A composite frame with a border and a title.
Definition TGFrame.h:532
TGMainFrame::TGMainFrame
TGMainFrame(const TGMainFrame &)=delete
TGMainFrame::SetIconName
void SetIconName(const char *name)
Set window icon name. This is typically done via the window manager.
Definition TGFrame.cxx:1793
TGMainFrame::SetWindowName
void SetWindowName(const char *name=nullptr) override
Set window name. This is typically done via the window manager.
Definition TGFrame.cxx:1780
TGRadioButton
Selects different options.
Definition TGButton.h:321
TGTextButton
Yield an action as soon as it is clicked.
Definition TGButton.h:142
TGXYLayoutHints
This layout hint must be used for the TGXYLayout manager!
Definition TGXYLayout.h:19
TGXYLayout
Is a layout manager where the position and the size of each widget in the frame are defined by X / Y ...
Definition TGXYLayout.h:58
TH1D
1-D histogram with a double per channel (see TH1 documentation)
Definition TH1.h:926
TImagePalette
A class to define a conversion from pixel values to pixel color.
Definition TAttImage.h:33
TImagePalette::fColorRed
UShort_t * fColorRed
[fNumPoints] red color at each anchor point
Definition TAttImage.h:38
TImagePalette::fPoints
Double_t * fPoints
[fNumPoints] value of each anchor point [0..1]
Definition TAttImage.h:37
TImagePalette::fColorGreen
UShort_t * fColorGreen
[fNumPoints] green color at each anchor point
Definition TAttImage.h:39
TImagePalette::fColorBlue
UShort_t * fColorBlue
[fNumPoints] blue color at each anchor point
Definition TAttImage.h:40
TImagePalette::fNumPoints
UInt_t fNumPoints
number of anchor points
Definition TAttImage.h:36
TImagePalette::fColorAlpha
UShort_t * fColorAlpha
[fNumPoints] alpha at each anchor point
Definition TAttImage.h:41
TLine::fY1
Double_t fY1
Y of 1st point.
Definition TLine.h:26
TLine::fX1
Double_t fX1
X of 1st point.
Definition TLine.h:25
TLine::TLine
TLine()
Definition TLine.h:38
TLine::fX2
Double_t fX2
X of 2nd point.
Definition TLine.h:27
TLine::Paint
void Paint(Option_t *option="") override
Paint this line with its current attributes.
Definition TLine.cxx:362
TLine::fY2
Double_t fY2
Y of 2nd point.
Definition TLine.h:28
TList
A doubly linked list.
Definition TList.h:38
TPaletteEditor::CloseWindow
virtual void CloseWindow()
Closes the window and deletes itself.
Definition TAttImage.cxx:262
TPaletteEditor::fAttImage
TAttImage * fAttImage
Definition TAttImage.h:22
TPaletteEditor::TPaletteEditor
TPaletteEditor(TAttImage *attImage, UInt_t w, UInt_t h)
Constructor.
Definition TAttImage.cxx:254
TRootEmbeddedCanvas
This class creates a TGCanvas in which a TCanvas is created.
Definition TRootEmbeddedCanvas.h:24
TString
Basic string class.
Definition TString.h:138
TString::EndsWith
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
Definition TString.cxx:2250
TString::Data
const char * Data() const
Definition TString.h:384
TString::Append
TString & Append(const char *cs)
Definition TString.h:581
pt
TPaveText * pt
Definition entrylist_figure1.C:7
x
Double_t x[n]
Definition legend1.C:17
TMath::Exp
Double_t Exp(Double_t x)
Returns the base-e exponential function of x, which is e raised to the power x.
Definition TMath.h:720
TMath::Log
Double_t Log(Double_t x)
Returns the natural logarithm of x.
Definition TMath.h:767
TMath::Abs
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:122