---

pixel.h

Go to the documentation of this file.

#ifndef __PIXEL_H__
#define __PIXEL_H__

#include <cmath>
#include "mathconstants.h"

// Uses roundabout path to the current directory to avoid Cray C bug
#include "../src/boundednumber.h"


namespace  Plot {


/******************************************************************************/
/* Pixel classes                                                              */
/******************************************************************************/


class Pixel {
public:
  Pixel() : transparent(true) {  }
  
  Pixel(bool visible) : transparent(!visible) {  }
  
  Pixel(const Pixel& other) : transparent(other.transparent)  {  };

  bool istransparent() {  return transparent;  }
  
  void show() {  transparent=false;  }
  
  void hide() {  transparent=true;  }

  typedef Bounded::Integer<unsigned char> IComponent;
  
  typedef Bounded::Float<  float,1,0,Bounded::Crop<Bounded::LargeFloat> > FComponent;

  typedef Bounded::Float<  float,1,0,Bounded::Wrap<Bounded::LargeFloat> > HueComponent;

private:
  bool transparent; 
};


  
/* Forward declarations to allow HSVPixel and RGBPixel to convert to
   and from one another
*/
template<class>       class RGBPixel;
template<class,class> class HSVPixel;

 
  
template<class Component=Pixel::IComponent>
class RGBPixel : public Pixel
{
  typedef RGBPixel self;
  
public:
  RGBPixel() : Pixel(), r(0), g(0), b(0) {  }
  
  RGBPixel(FComponent value) : Pixel(), r(value), g(value), b(value) {  }
  
  RGBPixel(FComponent red, FComponent green, FComponent blue, bool visible=true) : Pixel(visible),
    r(red), g(green), b(blue) {  }
  
  RGBPixel(const self& other)
    : Pixel(other), r(other.r), g(other.g), b(other.b)  {  }
  
  template<class OComponent, class OHComponent>
  RGBPixel(const HSVPixel<OComponent,OHComponent>& O);
  
  Bounded::Magnitude red()   const {  return r.mag();  } 
  Bounded::Magnitude green() const {  return g.mag();  } 
  Bounded::Magnitude blue()  const {  return b.mag();  } 
  
  self operator+= (const self &B) 
    {  r=r+B.r; g=g+B.g; b=b+B.b;  }

  self& operator*=(const Bounded::LargeFloat m)
    {  r*=m; g*=m; b*=m; return *this; }

  
  std::ostream& put(std::ostream& s) const
  {  return s << "(" << red() << "," << green() << "," << blue() << ")";  }
  
  self operator+(const self& o) {
    self tmp;
    tmp.r=r+o.r;
    tmp.g=g+o.g;
    tmp.b=b+o.b;
    return tmp;
  }

  template<class OutputType>
  void write_binary(std::ostream& s, OutputType max_val) const {
    s.put(OutputType(max_val*red()));
    s.put(OutputType(max_val*green()));
    s.put(OutputType(max_val*blue()));
  }
  
private:
  Component r,g,b;
};



template<class Component>
std::ostream& operator<<(std::ostream& s, const RGBPixel<Component>& o)
  {  return o.put(s);  }

 

template<class Component=Pixel::FComponent, class HComponent=Pixel::HueComponent>
class HSVPixel : public Pixel
{
public:
  HSVPixel() : Pixel(), h(0), s(0), v(0) {  }
  
  HSVPixel(HComponent hue, Component saturation, Component value)
    : Pixel(true), h(hue), s(saturation), v(value)  {  }
  
  HSVPixel(const HSVPixel& other)
    : Pixel(other), h(other.h), s(other.s), v(other.v)  {  }
  
  template<class OComponent>  
  HSVPixel(const RGBPixel<OComponent>& other);
  
  Bounded::Magnitude hue()        const {  return h.mag();  } 
  Bounded::Magnitude saturation() const {  return s.mag();  } 
  Bounded::Magnitude value()      const {  return v.mag();  } 
  
  std::ostream& put(std::ostream& s)
  {  return s << "(" << hue() << "," << saturation() << "," << value() << ")";  }

  static int reversed_color_order;
  
private:
  HComponent h;
  Component  s,v;
};


/* Static variables */
template<class Component, class HComponent>
int HSVPixel<Component,HComponent>::reversed_color_order=false;


template<class Component>
std::ostream& operator<<(std::ostream& s, const HSVPixel<Component>& o)
{  return o.put(s);  }


template<class Component>
template<class OComponent, class OHComponent>
RGBPixel<Component>::RGBPixel(const HSVPixel<OComponent,OHComponent>& other) : Pixel(other)
{
  int    j;
  double rd, gd, bd;
  double f, p, q, T;
  double hue;
  
  const double h=(HSVPixel<OComponent,OHComponent>::reversed_color_order?
                  1-other.hue() : other.hue());
  const double s=other.saturation();
  const double v=other.value();
  
  /* convert HSV back to RGB */
  if (s==0.0) { rd = v;  gd = v;  bd = v; }
  else {
    /* hue ranges [0,6) */
    hue = h * 6.0;
    
    j = (int) floor(hue);
    if (j<0) j=0;          /* either h or floor seem to go neg on some sys */
    f = hue - j;
    p = v * (1-s);
    q = v * (1 - (s*f));
    T = v * (1 - (s*(1 - f)));
    
    switch (j) {
    case 0:  rd = v;  gd = T;  bd = p;  break;
    case 1:  rd = q;  gd = v;  bd = p;  break;
    case 2:  rd = p;  gd = v;  bd = T;  break;
    case 3:  rd = p;  gd = q;  bd = v;  break;
    case 4:  rd = T;  gd = p;  bd = v;  break;
    case 5:  rd = v;  gd = p;  bd = q;  break;
    default: rd = v;  gd = T;  bd = p;  break;  /* never happen */
    }
  }
  
  r = Component(Bounded::LargeInt(floor( rd*r.Max + 0.5 )));
  g = Component(Bounded::LargeInt(floor( gd*g.Max + 0.5 )));
  b = Component(Bounded::LargeInt(floor( bd*b.Max + 0.5 )));
}



template<class Component, class HComponent>
template<class OComponent>
HSVPixel<Component,HComponent>::HSVPixel(const RGBPixel<OComponent>& other) : Pixel(other)
{
  double r = other.red();
  double g = other.green();
  double b = other.blue();

  double hh=0;
  
  double maxval = std::max(std::max(r,g),b);
  double minval = std::min(std::min(r,g),b);

  /* Value */
  v = maxval;

  /* Saturation */
  s = (maxval == 0.0) ? 0.0 : ((maxval-minval)/maxval);
  
  /* Hue */
  if (s.mag() == 0.0)
    hh = 0;
  else {
    double delt = maxval - minval;
    
    if (r == maxval)
      hh =       (g - b)/delt; /* Between yellow and magenta */
    
    else if (g == maxval)
      hh = 2.0 + (b - r)/delt; /* Between cyan and yellow    */
    
    else if (b  == maxval)
      hh = 4.0 + (r - g)/delt; /* Between magenta and cyan   */
    
    /* Convert to degrees (disabled) */
    /* *h *= 60; if (*h < 0.0) *h += 360; */
    
    /* Scale to Max */
    hh *= (60.0/360.0); if (hh < 0.0) hh = hh+h.Max;
  }
  h = (reversed_color_order? 1.0-hh : hh);
}



template<class HSVPixelType=HSVPixel<> >
class PixelAverage {
private:
  double valtot, colorx, colory, count;

public:
  PixelAverage() : valtot(0), colorx(0), colory(0), count(0)  { }

  void operator+=(HSVPixelType p) {
    const double angle = 2*(Math::pi)*p.hue();
    const double mag   = p.saturation();
    colorx += mag * cos(angle);
    colory += mag * sin(angle);
    valtot += p.value();
    count++;
  }
  
  HSVPixelType operator() () const {
    const Bounded::Magnitude hue = (colorx? atan2(colory,colorx)/2/(Math::pi) : 0.0);
    const Bounded::Magnitude sat = (count? sqrt(colorx*colorx+colory*colory)/count : 0.0);
    const Bounded::Magnitude val = (count? valtot/count : 0.0);
    return HSVPixel<>(hue,sat,val);
  }
};

    

template<class HSVPixelType>  
RGBPixel<>  contrasting_color( HSVPixelType prevailing_color) {
  const Bounded::Magnitude  val = prevailing_color.value();
  if      (val >= 0.75) return RGBPixel<>(0,0,0); /* bright background */
  else if (val <  0.25) return RGBPixel<>(1,1,1); /* dark background   */
  else                  return RGBPixel<>(0,0,1); /* medium background */
}

  
} /* namespace Plot */
#endif /* __PIXEL_H__ */

---