// @(#)root/eve:$Id$
// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

/*************************************************************************
 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TEveRGBAPalette
#define ROOT_TEveRGBAPalette

#include "TEveUtil.h"

#include "TObject.h"
#include "TQObject.h"

#include "TMath.h"

class TEveRGBAPalette : public TObject,
                        public TQObject,
                        public TEveRefCnt
{
   friend class TEveRGBAPaletteEditor;
   friend class TEveRGBAPaletteSubEditor;

   friend class TEveRGBAPaletteOverlay;

public:
   enum ELimitAction_e { kLA_Cut, kLA_Mark, kLA_Clip, kLA_Wrap };

private:
   TEveRGBAPalette(const TEveRGBAPalette&);            // Not implemented
   TEveRGBAPalette& operator=(const TEveRGBAPalette&); // Not implemented

protected:
   Double_t  fUIf;       // UI representation calculated as: d = fUIf*i + fUIc
   Double_t  fUIc;       // UI representation calculated as: d = fUIf*i + fUIc

   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;

   Bool_t    fUIDoubleRep;    // Represent UI parts with real values.
   Bool_t    fInterpolate;    // Interpolate colors for signal values.
   Bool_t    fShowDefValue;   // Flags whether signals with default value should be shown.
   Bool_t    fFixColorRange;  // If true, map palette to low/high limit otherwise to min/max value.
   Int_t     fUnderflowAction;
   Int_t     fOverflowAction;

   Color_t   fDefaultColor;   // Color for when value is not specified
   UChar_t   fDefaultRGBA[4];
   Color_t   fUnderColor;     // Underflow color
   UChar_t   fUnderRGBA[4];
   Color_t   fOverColor;      // Overflow color
   UChar_t   fOverRGBA[4];

   mutable Int_t    fNBins;      // Number of signal-color entries.
   mutable Int_t    fCAMin;      // Minimal signal in color-array.
   mutable Int_t    fCAMax;      // Maximal signal in color-array.
   mutable UChar_t* fColorArray; //[4*fNBins]

   void SetupColor(Int_t val, UChar_t* pix) const;

   Double_t IntToDouble(Int_t i)    const { return fUIf*i + fUIc; }
   Int_t    DoubleToInt(Double_t d) const { return TMath::Nint((d - fUIc) / fUIf); }

   Double_t GetCAMinAsDouble() const { return IntToDouble(fCAMin); }
   Double_t GetCAMaxAsDouble() const { return IntToDouble(fCAMax); }

   static TEveRGBAPalette* fgDefaultPalette;

public:
   TEveRGBAPalette();
   TEveRGBAPalette(Int_t min, Int_t max, Bool_t interp=kTRUE,
                   Bool_t showdef=kTRUE, Bool_t fixcolrng=kFALSE);
   virtual ~TEveRGBAPalette();

   void SetupColorArray() const;
   void ClearColorArray();

   Bool_t   WithinVisibleRange(Int_t val) const;
   const UChar_t* ColorFromValue(Int_t val) const;
   void     ColorFromValue(Int_t val, UChar_t* pix, Bool_t alpha=kTRUE) const;
   Bool_t   ColorFromValue(Int_t val, Int_t defVal, UChar_t* pix, Bool_t alpha=kTRUE) const;

   Int_t  GetMinVal() const { return fMinVal; }
   Int_t  GetMaxVal() const { return fMaxVal; }

   void   SetLimits(Int_t low, Int_t high);
   void   SetLimitsScaleMinMax(Int_t low, Int_t high);
   void   SetMinMax(Int_t min, Int_t max);
   void   SetMin(Int_t min);
   void   SetMax(Int_t max);

   Int_t  GetLowLimit()  const { return fLowLimit;  }
   Int_t  GetHighLimit() const { return fHighLimit; }

   // ================================================================

   Bool_t GetUIDoubleRep() const { return fUIDoubleRep; }
   void   SetUIDoubleRep(Bool_t b, Double_t f=1, Double_t c=0);

   Bool_t GetInterpolate() const { return fInterpolate; }
   void   SetInterpolate(Bool_t b);

   Bool_t GetShowDefValue() const { return fShowDefValue; }
   void   SetShowDefValue(Bool_t v) { fShowDefValue = v; }

   Bool_t GetFixColorRange() const { return fFixColorRange; }
   void   SetFixColorRange(Bool_t v);

   Int_t GetUnderflowAction() const  { return fUnderflowAction; }
   Int_t GetOverflowAction()  const  { return fOverflowAction;  }
   void  SetUnderflowAction(Int_t a) { fUnderflowAction = a;    }
   void  SetOverflowAction(Int_t a)  { fOverflowAction  = a;    }

   // ================================================================

   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   SetDefaultColorPixel(Pixel_t pix);
   void   SetDefaultColorRGBA(UChar_t r, UChar_t g, UChar_t b, UChar_t a=255);

   // ----------------------------------------------------------------

   Color_t  GetUnderColor() const { return fUnderColor; }
   Color_t* PtrUnderColor() { return &fUnderColor; }
   UChar_t* GetUnderRGBA()  { return fUnderRGBA;  }
   const UChar_t* GetUnderRGBA() const { return fUnderRGBA;  }

   void   SetUnderColor(Color_t ci);
   void   SetUnderColorPixel(Pixel_t pix);
   void   SetUnderColorRGBA(UChar_t r, UChar_t g, UChar_t b, UChar_t a=255);

   // ----------------------------------------------------------------

   Color_t  GetOverColor() const { return fOverColor; }
   Color_t* PtrOverColor() { return &fOverColor; }
   UChar_t* GetOverRGBA()  { return fOverRGBA;  }
   const UChar_t* GetOverRGBA() const { return fOverRGBA;  }

   void   SetOverColor(Color_t ci);
   void   SetOverColorPixel(Pixel_t pix);
   void   SetOverColorRGBA(UChar_t r, UChar_t g, UChar_t b, UChar_t a=255);

   // ================================================================

   void MinMaxValChanged(); // *SIGNAL*

   ClassDef(TEveRGBAPalette, 1); // A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes.
};


/******************************************************************************/
// Inlines for TEveRGBAPalette
/******************************************************************************/

//______________________________________________________________________________
inline Bool_t TEveRGBAPalette::WithinVisibleRange(Int_t val) const
{
   if ((val < fMinVal && fUnderflowAction == kLA_Cut) ||
       (val > fMaxVal && fOverflowAction  == kLA_Cut))
      return kFALSE;
   else
      return kTRUE;
}

//______________________________________________________________________________
inline const UChar_t* TEveRGBAPalette::ColorFromValue(Int_t val) const
{
   // Here we expect that kLA_Cut has been checked; we further check
   // for kLA_Wrap and kLA_Clip otherwise we proceed as for kLA_Mark.

   if (!fColorArray)  SetupColorArray();

   if (val < fMinVal)
   {
      if (fUnderflowAction == kLA_Wrap)
         val = (val+1-fCAMin)%fNBins + fCAMax;
      else if (fUnderflowAction == kLA_Clip)
         val = fMinVal;
      else
         return fUnderRGBA;
   }
   else if(val > fMaxVal)
   {
      if (fOverflowAction == kLA_Wrap)
         val = (val-1-fCAMax)%fNBins + fCAMin;
      else if (fOverflowAction == kLA_Clip)
         val = fMaxVal;
      else
         return fOverRGBA;
   }

   return fColorArray + 4 * (val - fCAMin);
}

//______________________________________________________________________________
inline void TEveRGBAPalette::ColorFromValue(Int_t val, UChar_t* pix, Bool_t alpha) const
{
   const UChar_t* c = ColorFromValue(val);
   pix[0] = c[0]; pix[1] = c[1]; pix[2] = c[2];
   if (alpha) pix[3] = c[3];
}

//______________________________________________________________________________
inline Bool_t TEveRGBAPalette::ColorFromValue(Int_t val, Int_t defVal, UChar_t* pix, Bool_t alpha) const
{
   if (val == defVal) {
      if (fShowDefValue) {
         pix[0] = fDefaultRGBA[0];
         pix[1] = fDefaultRGBA[1];
         pix[2] = fDefaultRGBA[2];
         if (alpha) pix[3] = fDefaultRGBA[3];
         return kTRUE;
      } else {
         return kFALSE;
      }
   }

   if (WithinVisibleRange(val)) {
      ColorFromValue(val, pix, alpha);
      return kTRUE;
   } else {
      return kFALSE;
   }
}

#endif