---

colorlookup.h

Go to the documentation of this file.

#ifndef __COLORLOOKUP_H__
#define __COLORLOOKUP_H__

#include <cassert>
#include <algorithm>
#include <vector>

#include "pixel.h"
#include "scale.h"

#ifndef NO_VALGEN_STRINGS
/* Optional: support for constructing from a string specification */
#include <string>
using std::string;
#include "stringparser.h"
#include "msg.h"
#endif

namespace  Plot {



/******************************************************************************/
/* ColorLookup class hierarchy                                                */
/******************************************************************************/


template<class PixelType=Plot::RGBPixel<>, class Scale=Scale::Linear<double> >
class ColorLookup {
public:
  virtual ~ColorLookup() { }

  ColorLookup(const Scale& scale=default_scale) : fn(scale) { }
  
  virtual PixelType operator() (const double mag) const
    {  return lookup(fn(mag));  }

protected:
  typedef Scale ScaleType;
  static ScaleType default_scale;
  
private:
  Scale fn;

  virtual PixelType lookup(const Bounded::Magnitude mag) const=0;
};


/* Static variables */
template<class PixelType, class Scale>
typename ColorLookup<PixelType,Scale>::ScaleType ColorLookup<PixelType,Scale>::default_scale;



template<class PixelType=Plot::RGBPixel<>, class Scale=Scale::Linear<double> >
class SingleColorLookup : public ColorLookup<PixelType,Scale> {
public:
  virtual ~SingleColorLookup() { }
  SingleColorLookup(Bounded::Magnitude hue=0.0, Bounded::Magnitude sat=0.0, Bounded::Magnitude val=0.5)
    : h(hue), s(sat), v(val) {  }
    
#ifndef NO_VALGEN_STRINGS
  SingleColorLookup(StringArgs& args)
    : h(args.next(0.0)), s(args.next(0.0)), v(args.next(0.5)) {  }
#endif
  
private:
  virtual PixelType lookup(const Bounded::Magnitude) const
    {  return PixelType(HSVPixel<>(h,s,v));  }
  
  Bounded::Magnitude h,s,v;
};



template<class PixelType=Plot::RGBPixel<>, class Scale=Scale::Linear<double> >
class HueColorLookup : public ColorLookup<PixelType,Scale> {
public:
  virtual ~HueColorLookup() { }
  HueColorLookup(Bounded::Magnitude sat=1.0, Bounded::Magnitude val=1.0,
                 const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), s(sat), v(val) {  }
    
#ifndef NO_VALGEN_STRINGS
  HueColorLookup(StringArgs& args, const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), s(args.next(1.0)), v(args.next(1.0)) {  }
#endif
  
private:
  virtual PixelType lookup(const Bounded::Magnitude mag) const
    {  return PixelType(HSVPixel<>(mag,s,v));  }
  
  Bounded::Magnitude s,v;
};



template<class PixelType=Plot::RGBPixel<>, class Scale=Scale::Linear<double> >
class SaturationColorLookup : public ColorLookup<PixelType,Scale> {
public:
  virtual ~SaturationColorLookup() { }
  SaturationColorLookup(Bounded::Magnitude hue=0.0, Bounded::Magnitude val=1.0,
                        const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), h(hue), v(val) {  }
    
#ifndef NO_VALGEN_STRINGS
  SaturationColorLookup(StringArgs& args, const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), h(args.next(0.0)), v(args.next(1.0)) {  }
#endif
  
private:
  virtual PixelType lookup(const Bounded::Magnitude mag) const 
    {  return PixelType(HSVPixel<>(h,mag,v));  }

  Bounded::Magnitude h,v;
};



template<class PixelType=Plot::RGBPixel<>, class Scale=Scale::Linear<double> >
class ValueColorLookup : public ColorLookup<PixelType,Scale> {
public:
  virtual ~ValueColorLookup() { }
  ValueColorLookup(Bounded::Magnitude hue=0.0, Bounded::Magnitude sat=0.0,
                   const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), h(hue), s(sat) {  }
    
#ifndef NO_VALGEN_STRINGS
  ValueColorLookup(StringArgs& args, const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), h(args.next(0.0)), s(args.next(0.0)) {  }
#endif
  
private:
  virtual PixelType lookup(const Bounded::Magnitude mag) const
    {  return PixelType(HSVPixel<>(h,s,mag));  }

  Bounded::Magnitude h,s;
};



template<class PixelType=Plot::RGBPixel<>, class Scale=Scale::Linear<double> >
class SpecifiedHueLookup : public ColorLookup<PixelType,Scale> {
public:
  virtual ~SpecifiedHueLookup() { }
  SpecifiedHueLookup(Bounded::Magnitude hue=0.0,
                     Bounded::Magnitude confidence=1.0,
                     bool paper_based_colors=false,
                     const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), h(hue), c(confidence) {  }
  
#ifndef NO_VALGEN_STRINGS
  SpecifiedHueLookup(StringArgs& args, 
                     bool paper_based_colors=false,
                     Bounded::Magnitude default_hue=0.0,
                     const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), h(args.next(default_hue)), c(args.next(1.0)),
    paper_based(paper_based_colors) {  }
#endif
  
private:
  virtual PixelType lookup(const Bounded::Magnitude mag) const {
    return (paper_based?
            PixelType(HSVPixel<>(h,mag,std::max(1.0-mag,c))) : 
            PixelType(HSVPixel<>(h,c,mag)));
  }

  Bounded::Magnitude h,c;
  const bool paper_based;
};



template<class PixelType=Plot::RGBPixel<>, class Scale=Scale::Linear<double> >
class ColorLookupTable : public ColorLookup<PixelType,Scale> {
protected:
  typedef std::vector<PixelType> Table;

public:
  ColorLookupTable(size_t numcolors,const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), colors(numcolors), valid(true) { }

#ifndef NO_VALGEN_STRINGS

  ColorLookupTable(const string& spec_="", size_t numcolors=0, const Scale& scale=default_scale)
    : ColorLookup<PixelType,Scale>(scale), colors(numcolors>0?numcolors:252), valid(true) {

    /* If empty, uses a default specification */
    const string spec      = (spec_.empty()? string("KRYW") : spec_);
    const size_t steps     = spec.length();
    const size_t stepsize  = size_t(colors.size()/(steps>1 ? (steps-1) : 1));
    size_t start,i;
    for (i=0,start=0; i<steps-1; i++,start+=stepsize)
      interpolate(start, start+stepsize,color(spec[i]), color(spec[i+1]));
    interpolate(start, colors.size(),color(spec[i]), color(spec[steps-1]));
  }
#endif

  virtual ~ColorLookupTable() { }

  bool is_valid() {  return valid;  }
  
private:  
  virtual PixelType lookup(const Bounded::Magnitude mag) const
    {  return colors[Generic::crop(0,int(colors.size()-1),int(mag*(colors.size()-1)))];  }

protected:
  Table colors;
  bool  valid;

  void interpolate(const size_t start, const size_t finish,
                   const PixelType& startcolor, const PixelType& finishcolor) {
    assert (start<=finish);
    
    const size_t num_vals = size_t(finish-start);
    const double division = (num_vals!=0 ? 1.0/num_vals : 0);
    
    const double rs       = startcolor.red();
    const double gs       = startcolor.green();
    const double bs       = startcolor.blue();
    
    const double rinc     = division*(finishcolor.red()   - startcolor.red());
    const double ginc     = division*(finishcolor.green() - startcolor.green());
    const double binc     = division*(finishcolor.blue()  - startcolor.blue());
    
    for(size_t i=0; i<num_vals; i++)
      colors[start+i]=PixelType(rs+rinc*i,gs+ginc*i,bs+binc*i);
  }

  
  PixelType color(const char c) {
    PixelType p;
    const double h=0.5;
    switch (c) {
    case 'R': p=PixelType(1,0,0); break;   case 'r': p=PixelType(h,0,0); break;  /* Red     */
    case 'Y': p=PixelType(1,1,0); break;   case 'y': p=PixelType(h,h,0); break;  /* Yellow  */
    case 'G': p=PixelType(0,1,0); break;   case 'g': p=PixelType(0,h,0); break;  /* Green   */
    case 'C': p=PixelType(0,1,1); break;   case 'c': p=PixelType(0,h,h); break;  /* Cyan    */
    case 'B': p=PixelType(0,0,1); break;   case 'b': p=PixelType(0,0,h); break;  /* Blue    */
    case 'M': p=PixelType(1,0,1); break;   case 'm': p=PixelType(h,0,h); break;  /* Magenta */
    case 'W': p=PixelType(1,1,1); break;   case 'w': p=PixelType(h,h,h); break;  /* White   */
    case 'K': p=PixelType(0,0,0); break;   case 'k': p=PixelType(0,0,0); break;  /* Black   */
    default: valid=false; /* Set error flag if no match */
    }
    return p;
  }
};

 
 
template<class PixelType=Plot::RGBPixel<>, class Scale=Scale::Linear<double> >
class KRYWColorLookup : public ColorLookupTable<PixelType,Scale> {
public:
  virtual ~KRYWColorLookup() { }
  KRYWColorLookup(size_t numcolors=0, const Scale& scale=default_scale)
    : ColorLookupTable<PixelType,Scale>((numcolors>0?numcolors:252),scale) {
    const size_t step   = size_t(colors.size()/3);
    interpolate(0,      step,          PixelType(0,0,0), PixelType(1,0,0));
    interpolate(step,   2*step,        PixelType(1,0,0), PixelType(1,1,0));
    interpolate(2*step, colors.size(), PixelType(1,1,0), PixelType(1,1,1));
  }
};
 


/******************************************************************************/
/* ColorLookupFactory                                                         */
/******************************************************************************/

#ifndef NO_VALGEN_STRINGS
template<class PixelType=Plot::RGBPixel<>, class Scale=Scale::Linear<double> >
class ColorLookupFactory {
  bool paper_based;
  Bounded::Magnitude default_hue;
  
public:
  typedef ColorLookup<PixelType> result_type;
  virtual ~ColorLookupFactory() {  }

  ColorLookupFactory(bool paper_based_colors=false,
                     Bounded::Magnitude default_single_hue=0)
    : paper_based(paper_based_colors), default_hue(default_single_hue) {  }
  
  virtual result_type* operator() (string specification) const {
    /* Construct argument list */
    StringParser sp;
    StringArgs arglist(sp, specification);
    const string name=arglist.next(string(""));
    bool warned=false; /* Prevents multiple warnings */
    
    /* Scale to flip the value for some ColorLookup types */
    const Scale  scale=Scale((paper_based? -1.0 : 1.0),
                             (paper_based?  1.0 : 0.0));
    result_type* clu=0;

    if      (name=="Hue")            clu = new HueColorLookup<PixelType>(arglist);
    else if (name=="Saturation")     clu = new SaturationColorLookup<PixelType>(arglist);
    else if (name=="Value")          clu = new ValueColorLookup<PixelType>(arglist);
    else if (name=="Grayscale")      clu = new ValueColorLookup<PixelType>(arglist,scale);
    else if (name=="SpecifiedColor") clu = new SingleColorLookup<PixelType>(arglist);
    else if (name=="SpecifiedHue")   clu = new SpecifiedHueLookup<PixelType>(arglist,paper_based,default_hue);
    
    else if (name=="Cold")           clu = new ColorLookupTable<PixelType>(paper_based? "WBC"      : "KBCW");
    else if (name=="Cool")           clu = new ColorLookupTable<PixelType>(paper_based? "WbBC"     : "KBC");
    else if (name=="Warm")           clu = new ColorLookupTable<PixelType>(paper_based? "WrRY"     : "KRY");
    else if (name=="Hot")            clu = new ColorLookupTable<PixelType>(paper_based? "WRY"      : "KRYW");
    else if (name=="CoolWarm")       clu = new ColorLookupTable<PixelType>(paper_based? "CBbWrRY"  : "CBKRY");
    else if (name=="ColdHot")        clu = new ColorLookupTable<PixelType>(paper_based? "CBWRY"    : "WCBKRYW");
    else if (name=="BlueRed")        clu = new ColorLookupTable<PixelType>(paper_based? "BWR"      : "BKR");

    /* The name RYW is a misnomer, and is only for backwards compatibility */
    else if (name=="RYW")            clu = new ColorLookupTable<PixelType>(paper_based? "WRY"      : "KRYW");

    else { /* Assume it's a specification for an interpolated ColorLookupTable */
      ColorLookupTable<PixelType>*   c   = new ColorLookupTable<PixelType>(name);
      if (c->is_valid())             clu = c;
      else {
        error("ColorLookup: Unknown or invalid type `" + name + "'");
        warned=true;
      }
    }
    
    if (!warned && !arglist.empty())
      error("ColorLookup: Unused arguments: `" + arglist.stringrep() + "'");
    
    /* Use default value if none yet defined */
    if (!clu) clu = new KRYWColorLookup<PixelType>(0,scale);
    return clu;
  }
  
  virtual void error(const string& s) const {
    Msg::LevelHandler<>* mh = Msg::LevelHandler<>::default_instance();
    if (mh) (*mh)(Msg::Error,s);
  }
};
#endif /* NO_VALGEN_STRINGS */



#define RYWColorLookup KRYWColorLookup



} /* namespace Plot */
#endif /* __COLORLOOKUP_H__ */

---