REveUtil.hxx

Go to the documentation of this file.

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

/*************************************************************************
 * Copyright (C) 1995-2019, 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 ROOT7_REveUtil
#define ROOT7_REveUtil

#include "REveTypes.hxx"

#include "TError.h"

#include <list>
#include <map>
#include <set>
#include <exception>

class TGeoManager;

namespace ROOT {
namespace Experimental {

class REveElement;

////////////////////////////////////////////////////////////////////////////////
/// REveUtil
/// Standard utility functions for Reve.
////////////////////////////////////////////////////////////////////////////////

class REveUtil
{
private:
   static TObjArray *fgDefaultColors;

public:
   virtual ~REveUtil() {}

   // Macro functions

   static Bool_t CheckMacro(const char *mac);
   static void AssertMacro(const char *mac);
   static void Macro(const char *mac);
   static void LoadMacro(const char *mac);

   // Color management

   static void ColorFromIdx(Color_t ci, UChar_t col[4], Bool_t alpha = kTRUE);
   static void ColorFromIdx(Color_t ci, UChar_t col[4], Char_t transparency);
   static void ColorFromIdx(Float_t f1, Color_t c1, Float_t f2, Color_t c2, UChar_t col[4], Bool_t alpha = kTRUE);
   static Color_t *FindColorVar(TObject *obj, const char *varname);

   static void SetColorBrightness(Float_t value, Bool_t full_redraw = kFALSE);

   // Math utilities

   static Bool_t IsU1IntervalContainedByMinMax(Float_t minM, Float_t maxM, Float_t minQ, Float_t maxQ);
   static Bool_t IsU1IntervalOverlappingByMinMax(Float_t minM, Float_t maxM, Float_t minQ, Float_t maxQ);

   static Bool_t IsU1IntervalContainedByMeanDelta(Float_t meanM, Float_t deltaM, Float_t meanQ, Float_t deltaQ);
   static Bool_t IsU1IntervalOverlappingByMeanDelta(Float_t meanM, Float_t deltaM, Float_t meanQ, Float_t deltaQ);

   static Float_t GetFraction(Float_t minM, Float_t maxM, Float_t minQ, Float_t maxQ);
};

inline Bool_t REveUtil::IsU1IntervalContainedByMeanDelta(Float_t meanM, Float_t deltaM, Float_t meanQ, Float_t deltaQ)
{
   return IsU1IntervalContainedByMinMax(meanM - deltaM, meanM + deltaM, meanQ - deltaQ, meanQ + deltaQ);
}

inline Bool_t REveUtil::IsU1IntervalOverlappingByMeanDelta(Float_t meanM, Float_t deltaM, Float_t meanQ, Float_t deltaQ)
{
   return IsU1IntervalContainedByMinMax(meanM - deltaM, meanM + deltaM, meanQ - deltaQ, meanQ + deltaQ);
}


////////////////////////////////////////////////////////////////////////////////
/// REveGeoManagerHolder
/// Exception-safe global variable holders
////////////////////////////////////////////////////////////////////////////////

class REveGeoManagerHolder
{
private:
   TGeoManager *fManager{nullptr};  ///<!  hold manager
   Int_t fNSegments{0};             ///<!  previous settings for num segments

public:
   REveGeoManagerHolder(TGeoManager *new_gmgr = nullptr, Int_t n_seg = 0);
   ~REveGeoManagerHolder();
};

////////////////////////////////////////////////////////////////////////////////
/// REveRefCnt
/// REveRefCnt base-class (interface)
////////////////////////////////////////////////////////////////////////////////

class REveRefCnt
{
protected:
   Int_t fRefCount{0};

public:
   REveRefCnt() = default;
   virtual ~REveRefCnt() {}

   REveRefCnt(const REveRefCnt &) : fRefCount(0) {}
   REveRefCnt &operator=(const REveRefCnt &) { return *this; }

   void IncRefCount() { ++fRefCount; }
   void DecRefCount()
   {
      if (--fRefCount <= 0)
         OnZeroRefCount();
   }

   virtual void OnZeroRefCount() { delete this; }
};

////////////////////////////////////////////////////////////////////////////////
/// REveRefBackPtr
/// reference-count with back pointers
////////////////////////////////////////////////////////////////////////////////

class REveRefBackPtr : public REveRefCnt
{
protected:
   typedef std::map<REveElement *, Int_t> RefMap_t;

   RefMap_t fBackRefs;

public:
   REveRefBackPtr();
   virtual ~REveRefBackPtr();

   REveRefBackPtr(const REveRefBackPtr &);
   REveRefBackPtr &operator=(const REveRefBackPtr &);

   using REveRefCnt::DecRefCount;
   using REveRefCnt::IncRefCount;
   virtual void IncRefCount(REveElement *re);
   virtual void DecRefCount(REveElement *re);

   virtual void StampBackPtrElements(UChar_t stamps);
};

} // namespace Experimental
} // namespace ROOT

#endif