New files: a generic color palette with value to color mapping; to be used by most...
authormtadel <mtadel@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 14 Nov 2006 16:27:45 +0000 (16:27 +0000)
committermtadel <mtadel@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 14 Nov 2006 16:27:45 +0000 (16:27 +0000)
EVE/Reve/RGBAPalette.cxx [new file with mode: 0644]
EVE/Reve/RGBAPalette.h [new file with mode: 0644]
EVE/Reve/RGBAPaletteEditor.cxx [new file with mode: 0644]
EVE/Reve/RGBAPaletteEditor.h [new file with mode: 0644]

diff --git a/EVE/Reve/RGBAPalette.cxx b/EVE/Reve/RGBAPalette.cxx
new file mode 100644 (file)
index 0000000..72d2720
--- /dev/null
@@ -0,0 +1,169 @@
+// $Header$
+
+#include "RGBAPalette.h"
+
+#include <TColor.h>
+#include <TStyle.h>
+
+using namespace Reve;
+
+//______________________________________________________________________
+// RGBAPalette
+//
+
+ClassImp(RGBAPalette)
+
+RGBAPalette::RGBAPalette() :
+  TObject(),
+  Reve::ReferenceCount(),
+  fCutLow      (kTRUE),
+  fCutHigh     (kFALSE),
+  fInterpolate (kFALSE),
+  fWrap        (kFALSE),
+  fColorArray  (0)
+{
+  SetLimits(0, 1000);
+  SetMinMax(0, 100);
+}
+
+RGBAPalette::RGBAPalette(Int_t min, Int_t max) :
+  TObject(),
+  Reve::ReferenceCount(),
+  fCutLow      (kTRUE),
+  fCutHigh     (kFALSE),
+  fInterpolate (kFALSE),
+  fWrap        (kFALSE),
+  fColorArray  (0)
+{
+  SetLimits(0, 1000);
+  SetMinMax(min, max);
+}
+
+RGBAPalette::RGBAPalette(Int_t min, Int_t max, Bool_t interp, Bool_t wrap) :
+  TObject(),
+  Reve::ReferenceCount(),
+  fInterpolate (interp),
+  fWrap        (wrap),
+  fColorArray  (0)
+{
+  SetLimits(0, 1023);
+  SetMinMax(min, max);
+}
+
+RGBAPalette::~RGBAPalette()
+{
+  delete [] fColorArray;
+}
+
+/**************************************************************************/
+
+void RGBAPalette::SetupColor(Int_t val, UChar_t* pixel) const
+{
+  using namespace TMath;
+  Float_t div  = Max(1, fMaxVal - fMinVal);
+  Int_t   nCol = gStyle->GetNumberOfColors();
+
+  Float_t f;
+  if      (val >= fMaxVal) f = nCol - 1;
+  else if (val <= fMinVal) f = 0;
+  else                     f = (val - fMinVal)/div*(nCol - 1);
+
+  if (fInterpolate) {
+    Int_t  bin = (Int_t) f;
+    Float_t f1 = f - bin, f2 = 1.0f - f1;
+    ColorFromIdx(f1, gStyle->GetColorPalette(bin),
+                f2, gStyle->GetColorPalette(Min(bin + 1, nCol - 1)),
+                pixel);
+  } else {
+    ColorFromIdx(gStyle->GetColorPalette((Int_t) Nint(f)), pixel);    
+  }
+}
+
+void RGBAPalette::SetupColorArray() const
+{
+  if(fColorArray) // !!!! should reinit anyway, maybe palette in gstyle changed
+    return;
+
+  // !!!! probably should store original palette for editing ...
+
+  fColorArray = new UChar_t [4 * fNBins];
+  UChar_t* p = fColorArray;
+  for(Int_t v=fMinVal; v<=fMaxVal; ++v, p+=4)
+    SetupColor(v, p);
+}
+
+void RGBAPalette::ClearColorArray()
+{
+  if(fColorArray) {
+    delete [] fColorArray;
+    fColorArray = 0;
+  }
+}
+
+/**************************************************************************/
+
+void RGBAPalette::SetLimits(Int_t low, Int_t high)
+{
+  fLowLimit  = low;
+  fHighLimit = high;
+  if (fMaxVal < fLowLimit)  SetMax(fLowLimit);
+  if (fMinVal < fLowLimit)  SetMin(fLowLimit);
+  if (fMinVal > fHighLimit) SetMin(fHighLimit);
+  if (fMaxVal > fHighLimit) SetMax(fHighLimit);
+    
+}
+
+void RGBAPalette::SetMin(Int_t min)
+{
+  fMinVal = TMath::Min(min, fMaxVal);
+  fNBins  = fMaxVal - fMinVal + 1;
+  ClearColorArray();
+}
+
+void RGBAPalette::SetMax(Int_t max)
+{
+  fMaxVal = TMath::Max(max, fMinVal);
+  fNBins  = fMaxVal - fMinVal + 1;
+  ClearColorArray();
+}
+
+void RGBAPalette::SetMinMax(Int_t min, Int_t max)
+{
+  fMinVal = min;
+  fMaxVal = max;
+  fNBins  = fMaxVal - fMinVal + 1;
+  ClearColorArray();
+}
+
+void RGBAPalette::SetInterpolate(Bool_t b)
+{
+  fInterpolate = b;
+  ClearColorArray();
+}
+
+void RGBAPalette::SetWrap(Bool_t b)
+{
+  fWrap = b;
+}
+
+/**************************************************************************/
+
+void RGBAPalette::SetDefaultColor(Color_t ci)
+{
+  fDefaultColor = ci;
+  ColorFromIdx(ci, fDefaultRGBA, kTRUE);
+}
+
+void RGBAPalette::SetDefaultColor(Pixel_t pix)
+{
+  SetDefaultColor(Color_t(TColor::GetColor(pix)));
+}
+
+void RGBAPalette::SetDefaultColor(UChar_t r, UChar_t g, UChar_t b, UChar_t a)
+{
+  fDefaultColor = Color_t(TColor::GetColor(r, g, b));
+  fDefaultRGBA[0] = r;
+  fDefaultRGBA[1] = g;
+  fDefaultRGBA[2] = b;
+  fDefaultRGBA[3] = a;
+}
diff --git a/EVE/Reve/RGBAPalette.h b/EVE/Reve/RGBAPalette.h
new file mode 100644 (file)
index 0000000..2cbc49f
--- /dev/null
@@ -0,0 +1,107 @@
+// $Header$
+
+#ifndef REVE_RGBAPalette_H
+#define REVE_RGBAPalette_H
+
+#include <Reve/Reve.h>
+
+#include <TObject.h>
+
+namespace Reve {
+
+class RGBAPalette : public TObject, public ReferenceCount
+{
+  friend class RGBAPaletteEditor;
+  friend class RGBAPaletteSubEditor;
+
+private:
+  RGBAPalette(const RGBAPalette&);            // Not implemented
+  RGBAPalette& operator=(const RGBAPalette&); // Not implemented
+
+protected:
+  Int_t     fLowLimit;  // Low  limit for Min/Max values (used by editor)
+  Int_t     fHighLimit; // High limit for Min/Max values (used by editor)
+  Int_t     fMinVal;
+  Int_t     fMaxVal;
+  Int_t     fNBins;
+  Bool_t    fCutLow;    // Instruct renderer not to display quoads below fMinVal
+  Bool_t    fCutHigh;   // Instruct renderer not to display quoads above fMaxVal
+  Bool_t    fInterpolate;
+  Bool_t    fWrap;
+  Color_t   fDefaultColor;
+  UChar_t   fDefaultRGBA[4];
+
+  mutable UChar_t* fColorArray; //[4*fNBins]
+
+  void SetupColor(Int_t val, UChar_t* pix) const;
+
+  static RGBAPalette* fgDefaultPalette;
+
+public:
+  RGBAPalette();
+  RGBAPalette(Int_t min, Int_t max);
+  RGBAPalette(Int_t min, Int_t max, Bool_t interp, Bool_t wrap);
+  virtual ~RGBAPalette();
+
+  void SetupColorArray() const;
+  void ClearColorArray();
+
+  UChar_t* ColorFromArray(Int_t val) const;
+  void     ColorFromArray(Int_t val, UChar_t* pix, Bool_t alpha=kTRUE) const;
+
+  Bool_t   WithinVisibleRange(Int_t val) const;
+
+  Int_t  GetMinVal() const      { return fMinVal; }
+  Int_t  GetMaxVal() const      { return fMaxVal; }
+  Bool_t GetInterpolate() const { return fInterpolate; }
+  Bool_t GetWrap() const        { return fWrap; }
+
+  void   SetLimits(Int_t low, Int_t high);
+  void   SetMinMax(Int_t min, Int_t max);
+  void   SetMin(Int_t min);
+  void   SetMax(Int_t max);
+  void   SetInterpolate(Bool_t b);
+  void   SetWrap(Bool_t b);
+
+  Color_t  GetDefaultColor() const { return fDefaultColor; }
+  Color_t* PtrDefaultColor() { return &fDefaultColor; }
+  UChar_t* GetDefaultRGBA()  { return fDefaultRGBA;  }
+  const UChar_t* GetDefaultRGBA() const { return fDefaultRGBA;  }
+
+  void   SetDefaultColor(Color_t ci);
+  void   SetDefaultColor(Pixel_t pix);
+  void   SetDefaultColor(UChar_t r, UChar_t g, UChar_t b, UChar_t a=255);
+
+  // ?? Should we emit some *SIGNALS* ??
+  // ?? Should we have a RendererTimeStamp ??
+
+  ClassDef(RGBAPalette, 1);
+}; // endclass RGBAPalette
+
+
+inline UChar_t* RGBAPalette::ColorFromArray(Int_t val) const
+{
+  if(!fColorArray)  SetupColorArray();
+  if(val < fMinVal) val = fWrap ? ((val+1-fMinVal)%fNBins + fMaxVal) : fMinVal;
+  if(val > fMaxVal) val = fWrap ? ((val-1-fMaxVal)%fNBins + fMinVal) : fMaxVal;
+  return fColorArray + 4 * (val - fMinVal);
+}
+
+inline void RGBAPalette::ColorFromArray(Int_t val, UChar_t* pix, Bool_t alpha) const
+{
+  UChar_t* c = ColorFromArray(val);
+  pix[0] = c[0]; pix[1] = c[1]; pix[2] = c[2];
+  if (alpha) pix[3] = c[3];
+}
+
+inline Bool_t RGBAPalette::WithinVisibleRange(Int_t val) const
+{
+  if ((val < fMinVal && fCutLow) || (val > fMaxVal && fCutHigh))
+    return kFALSE;
+  else
+    return kTRUE;
+}
+
+}
+
+#endif
diff --git a/EVE/Reve/RGBAPaletteEditor.cxx b/EVE/Reve/RGBAPaletteEditor.cxx
new file mode 100644 (file)
index 0000000..9379441
--- /dev/null
@@ -0,0 +1,157 @@
+// $Header$
+
+#include "RGBAPaletteEditor.h"
+#include <Reve/RGBAPalette.h>
+#include <Reve/RGValuators.h>
+
+#include <TVirtualPad.h>
+#include <TColor.h>
+
+#include <TGLabel.h>
+#include <TGButton.h>
+#include <TGNumberEntry.h>
+#include <TGColorSelect.h>
+#include <TGSlider.h>
+#include <TGDoubleSlider.h>
+
+using namespace Reve;
+
+
+RGBAPaletteSubEditor::RGBAPaletteSubEditor(const TGWindow* p) :
+  TGVerticalFrame(p)
+{
+  // Create weeds.
+
+  Int_t labelW = 42;
+
+  {
+    TGHorizontalFrame* f = new TGHorizontalFrame(this);
+
+    fDefaultColor = new TGColorSelect(f, 0, -1);
+    f->AddFrame(fDefaultColor, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
+    fDefaultColor->Connect("ColorSelected(Pixel_t)",
+                          "Reve::RGBAPaletteSubEditor", this, "DoDefaultColor(Pixel_t)");
+
+    fInterpolate = new TGCheckButton(f, "Interpolate");
+    f->AddFrame(fInterpolate, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
+    fInterpolate->Connect("Toggled(Bool_t)",
+                         "Reve::RGBAPaletteSubEditor", this, "DoInterpolate()");
+
+    fWrap = new TGCheckButton(f, "Wrap");
+    f->AddFrame(fWrap, new TGLayoutHints(kLHintsTop, 3, 1, 1, 0));
+    fWrap->Connect("Toggled(Bool_t)",
+                  "Reve::RGBAPaletteSubEditor", this, "DoWrap()");
+  }
+
+  fMinVal = new RGValuator(this, "MinVal", 200, 0);
+  fMinVal->SetNELength(4);
+  fMinVal->SetLabelWidth(labelW);
+  fMinVal->Build();
+  fMinVal->GetSlider()->SetWidth(120);
+  fMinVal->Connect("ValueSet(Double_t)",
+                  "Reve::RGBAPaletteSubEditor", this, "DoMinVal()");
+  AddFrame(fMinVal, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
+
+  fMaxVal = new RGValuator(this,"MaxVal", 200, 0);
+  fMaxVal->SetNELength(4);
+  fMaxVal->SetLabelWidth(labelW);
+  fMaxVal->Build();
+  fMaxVal->GetSlider()->SetWidth(120);
+  fMaxVal->SetLimits(0, 500);
+  fMaxVal->Connect("ValueSet(Double_t)",
+                  "Reve::RGBAPaletteSubEditor", this, "DoMaxVal()");
+  AddFrame(fMaxVal, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
+
+}
+
+/**************************************************************************/
+
+void RGBAPaletteSubEditor::SetModel(RGBAPalette* p)
+{
+  fM = p;
+
+  fMinVal->SetValue(fM->fMinVal);
+  fMaxVal->SetValue(fM->fMaxVal);
+  fMaxVal->SetLimits(fM->fLowLimit, fM->fHighLimit);
+  fMinVal->SetLimits(fM->fLowLimit, fM->fHighLimit);
+  fInterpolate->SetState(fM->fInterpolate ? kButtonDown : kButtonUp);
+  fWrap->SetState(fM->fWrap ? kButtonDown : kButtonUp);
+  fDefaultColor->SetColor(TColor::Number2Pixel(fM->GetDefaultColor()), kFALSE);
+}
+
+/**************************************************************************/
+
+void RGBAPaletteSubEditor::Changed()
+{
+  Emit("Changed()");
+}
+
+/**************************************************************************/
+
+void RGBAPaletteSubEditor::DoMinVal()
+{
+  fM->SetMin((Int_t) fMinVal->GetValue());
+  fMinVal->SetValue(fM->fMinVal);
+  Changed();
+}
+
+void RGBAPaletteSubEditor::DoMaxVal()
+{
+  fM->SetMax((Int_t) fMaxVal->GetValue());
+  fMaxVal->SetValue(fM->fMaxVal);
+  Changed();
+}
+
+
+void RGBAPaletteSubEditor::DoInterpolate()
+{
+  fM->SetInterpolate(fInterpolate->IsOn());
+  Changed();
+}
+
+void RGBAPaletteSubEditor::DoWrap()
+{
+  fM->SetWrap(fWrap->IsOn());
+  Changed();
+}
+
+void RGBAPaletteSubEditor::DoDefaultColor(Pixel_t color)
+{
+  fM->SetDefaultColor(color);
+  Changed();
+}
+
+/**************************************************************************/
+/**************************************************************************/
+/**************************************************************************/
+/**************************************************************************/
+
+//______________________________________________________________________
+// RGBAPaletteEditor
+//
+
+ClassImp(RGBAPaletteEditor)
+
+RGBAPaletteEditor::RGBAPaletteEditor(const TGWindow *p, Int_t width, Int_t height,
+            UInt_t options, Pixel_t back) :
+  TGedFrame(p, width, height, options | kVerticalFrame, back),
+  fM (0),
+  fSE(0)
+{
+  MakeTitle("RGBAPalette");
+
+  fSE = new RGBAPaletteSubEditor(this);
+  AddFrame(fSE, new TGLayoutHints(kLHintsTop, 2, 0, 2, 2));
+  fSE->Connect("Changed()", "Reve::RGBAPaletteEditor", this, "Update()");
+}
+
+RGBAPaletteEditor::~RGBAPaletteEditor()
+{}
+
+/**************************************************************************/
+
+void RGBAPaletteEditor::SetModel(TObject* obj)
+{
+  fM = dynamic_cast<RGBAPalette*>(obj);
+  fSE->SetModel(fM);
+}
diff --git a/EVE/Reve/RGBAPaletteEditor.h b/EVE/Reve/RGBAPaletteEditor.h
new file mode 100644 (file)
index 0000000..e5ce223
--- /dev/null
@@ -0,0 +1,75 @@
+// $Header$
+
+#ifndef REVE_RGBAPaletteEditor_H
+#define REVE_RGBAPaletteEditor_H
+
+#include <TGedFrame.h>
+
+class TGCheckButton;
+class TGColorSelect;
+
+namespace Reve {
+
+class RGBAPalette;
+class RGValuator;
+
+class RGBAPaletteSubEditor : public TGVerticalFrame
+{
+private:
+  RGBAPaletteSubEditor(const RGBAPaletteSubEditor&);            // Not implemented
+  RGBAPaletteSubEditor& operator=(const RGBAPaletteSubEditor&); // Not implemented
+
+protected:
+  RGBAPalette*      fM;
+
+  Reve::RGValuator* fMinVal;
+  Reve::RGValuator* fMaxVal;
+
+  TGCheckButton*    fInterpolate;
+  TGCheckButton*    fWrap;
+
+  TGColorSelect*    fDefaultColor;
+
+public:
+  RGBAPaletteSubEditor(const TGWindow* p);
+  virtual ~RGBAPaletteSubEditor() {}
+
+  void SetModel(RGBAPalette* p);
+
+  void Changed(); //*SIGNAL*
+
+  void DoMinVal();
+  void DoMaxVal();
+  void DoInterpolate();
+  void DoWrap();
+  void DoDefaultColor(Pixel_t);
+
+  ClassDef(RGBAPaletteSubEditor, 1); // SubEditor for RGBAPalette
+}; // endclass RGBAPaletteSubEditor
+
+
+/**************************************************************************/
+/**************************************************************************/
+
+class RGBAPaletteEditor : public TGedFrame
+{
+private:
+  RGBAPaletteEditor(const RGBAPaletteEditor&);            // Not implemented
+  RGBAPaletteEditor& operator=(const RGBAPaletteEditor&); // Not implemented
+
+protected:
+  RGBAPalette*          fM;
+  RGBAPaletteSubEditor* fSE;
+
+public:
+  RGBAPaletteEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30, UInt_t options = kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+  virtual ~RGBAPaletteEditor();
+
+  virtual void SetModel(TObject* obj);
+
+  ClassDef(RGBAPaletteEditor, 1); // Editor for RGBAPalette
+}; // endclass RGBAPaletteEditor
+
+}
+
+#endif