fwPaletteExtra.cc

Go to the documentation of this file.

#include "Fireworks/Core/src/fwPaletteExtra.h"

#include "TROOT.h"
#include "TColor.h"
#include "TMath.h"

namespace fireworks {

  //static unsigned int rSize = 17;

  struct PaletteExtraTopBottomIndices {
    float (*colVals)[3];
    bool whiteBg;
    FWColorManager::EPalette id;
    PaletteExtraTopBottomIndices(float (*iColors)[3], bool iIsWhiteBg, FWColorManager::EPalette iId)
        : colVals(iColors), whiteBg(iIsWhiteBg), id(iId){};

    void set(int i, Color_t cidx) {
      if (whiteBg) {
        //if (id == FWColorManager::kFall || id == FWColorManager::kArctic)
        const TColor* c = gROOT->GetColor(cidx);
        colVals[i][0] = c->GetRed();
        colVals[i][1] = c->GetGreen();
        colVals[i][2] = c->GetBlue();
        if (id != FWColorManager::kPurple)
          TColor::HLStoRGB(
              c->GetHue(), 1.2 * c->GetLight(), c->GetSaturation(), colVals[i][0], colVals[i][1], colVals[i][2]);

        /*

         cidx = TColor::GetColorBright(cidx);
        TColor* cb = gROOT->GetColor(cidx);
         colVals[i+rSize][0] = cb->GetRed();
         colVals[i+rSize][1] = cb->GetGreen();
         colVals[i+rSize][2] = cb->GetBlue();
         */

      } else {
        const TColor* c = gROOT->GetColor(cidx);
        colVals[i][0] = c->GetRed();
        colVals[i][1] = c->GetGreen();
        colVals[i][2] = c->GetBlue();
        /*
         cidx = TColor::GetColorDark(cidx);
 const TColor * cd = gROOT->GetColor(cidx);
         colVals[i+rSize][0] = cd->GetRed();
         colVals[i+rSize][1] = cd->GetGreen();
         colVals[i+rSize][2] = cd->GetBlue();
         */
      }
    }

    //______________________________________________________________________________

    void InitArctic() {
      // set muon geometry gray
      set(0, kYellow + 2);
      set(1, kMagenta - 3);
      set(2, kCyan + 3);
      set(3, kAzure + 7);
      set(4, kAzure + 8);

      set(5, kAzure + 3);  // jets, met
      set(6, kAzure - 3);
      set(7, kOrange + 7);
      set(8, kAzure);  // jets, met
      set(9, kBlue - 1);
      set(10, kBlue - 7);
      set(11, kTeal - 1);
      set(12, kTeal - 7);
      set(13, kCyan - 7);
      set(14, kAzure + 10);
      // set(16, kOrange);
    }

    //______________________________________________________________________________

    void InitFall() {
      set(0, kYellow - 4);  //vertices, jets
      set(1, kRed + 1);
      set(2, kMagenta + 3);
      set(3, kGreen + 2);
      set(4, kBlue + 2);
      set(5, kOrange - 5);  //hcal
      set(6, kOrange - 8);
      set(7, kMagenta - 1);
      set(8, kRed - 2);   // muon, ecal, met
      set(9, kCyan + 2);  // tracks

      int j = 2;
      for (int i = 10; i < 15; ++i) {
        set(i, kRed - j);
        j++;
      }
    }

    void InitSpring() {
      set(0, kRed);  // jet
      set(1, kOrange - 2);
      set(2, kRed - 7);
      set(3, kPink + 2);
      set(4, kOrange - 7);
      set(5, kSpring + 5);  //hcal

      set(6, kSpring);
      set(7, kMagenta);     // electrons
      set(8, kSpring + 4);  //ecal, muons
      set(9, kGreen + 2);
      set(10, kSpring + 3);
      set(11, kGreen - 5);
      set(12, kGreen - 6);
      set(13, kGreen - 7);
      set(14, kTeal - 5);
    }

    void InitPurple() {
      set(0, kGreen - 7);
      set(1, kRed + 1);
      set(2, kMagenta + 3);
      set(3, kCyan + 2);
      set(4, kBlue + 2);
      set(5, kViolet - 5);
      set(6, kViolet - 6);
      set(7, kViolet - 7);
      set(8, kGray + 1);  //ecal, muo
      set(9, kPink - 8);  //tracks
      set(10, kBlue - 8);
      set(11, kBlue - 4);
      set(12, kBlue - 2);
      set(13, kViolet + 8);
      set(14, kViolet + 10);
    }
  };

  void GetColorValuesForPaletteExtra(float (*iColors)[3],
                                     unsigned int iSize,
                                     FWColorManager::EPalette id,
                                     bool isWhiteBg) {
    PaletteExtraTopBottomIndices p(iColors, isWhiteBg, id);
    switch (id) {
      case FWColorManager::kArctic:
        p.InitArctic();
        break;
      case FWColorManager::kFall:
        p.InitFall();
        break;
      case FWColorManager::kSpring:
        p.InitSpring();
        break;

      case FWColorManager::kPurple:
        p.InitPurple();
        break;
      default:
        break;
    }

    iSize = iSize / 2;
    unsigned int lastIdx = iSize - 2;
    if (isWhiteBg) {
      for (unsigned int i = 0; i < lastIdx; ++i) {
        float s = 1.2;
        float r = TMath::Min(1.f, s * iColors[i][0]);
        float g = TMath::Min(1.f, s * iColors[i][1]);
        float b = TMath::Min(1.f, s * iColors[i][2]);

        iColors[i][0] = r;
        iColors[i][1] = g;
        iColors[i][2] = b;

        float value = 1.7;
        r = TMath::Power(r, (2.5 - value) / 2.5);
        g = TMath::Power(g, (2.5 - value) / 2.5);
        b = TMath::Power(b, (2.5 - value) / 2.5);
        /*
         s = 1.2;
         r = TMath::Min(1.f,s* iColors[i][0]);
         g = TMath::Min(1.f,s *iColors[i][1]);
         b = TMath::Min(1.f,s *iColors[i][2]);
         */

        r = TMath::Min(1.f, r);
        g = TMath::Min(1.f, g);
        b = TMath::Min(1.f, b);

        iColors[i + iSize][0] = r;
        iColors[i + iSize][1] = g;
        iColors[i + iSize][2] = b;
      }
    } else {
      for (unsigned int i = 0; i < lastIdx; ++i) {
        //   TColor* c = gROOT->GetColor(i);
        float s = 0.4;
        float r = s * iColors[i][0];
        float g = s * iColors[i][1];
        float b = s * iColors[i][2];

        // printf("[%d] (%.1f, %.1f, %.1f) => ", i,  r, g, b);
        float value = -0.5;
        r = TMath::Power(r, (2.5 - value) / 2.5);
        g = TMath::Power(g, (2.5 - value) / 2.5);
        b = TMath::Power(b, (2.5 - value) / 2.5);

        // printf(" (%.1f, %.1f, %.1f) \n", r, g, b);
        //TColor::HLStoRGB(c->GetHue(), c->GetSaturation(), c->GetLight()*0.8, r, g, b);
        iColors[i + iSize][0] = r;
        iColors[i + iSize][1] = g;
        iColors[i + iSize][2] = b;
      }
    }
  }

}  // namespace fireworks