---

histogramimage.h

Go to the documentation of this file.

#ifndef __HISTOGRAM_IMAGE_H__
#define __HISTOGRAM_IMAGE_H__

// Uses roundabout paths to the current directory to avoid Cray C bug
#include "../src/image.h"
#include "../src/pixel.h"
#include "../src/colorlookup.h"
#include "../src/histogram.h"

namespace  Plot {


template<class PixelType=RGBPixel<>, class PixelMatrix= typename MatrixType<PixelType>::rectangular >
class OneDHistogramImage : public AARImage<PixelType,PixelMatrix> {
private:

  typedef typename AARImage<PixelType,PixelMatrix>::PixelSubscript PixelSubscript;

  typedef int Subscript;
  
  PixelSubscript border;
  
  double num_bins;
  
  double size_scale;
  
  bool vertical;
  
  Bounded::Magnitude bin_fullness_range;
  
  PixelSubscript min_pixelnum;
  
  PixelSubscript zero_pixelnum;
  
  PixelSubscript max_pixelnum;

  PixelType bg;

  PixelType fg;

  bool markzero;
  
  inline PixelSubscript bin_number_pixelnum(const Subscript b) const
    {  return PixelSubscript(b*size_scale+border);  }
  
  /* Will need to be modified for a symmetric plot */
  inline PixelSubscript bin_fullness_pixelnum(const Bounded::Magnitude bin_fullness) const {
    return Generic::crop(min_pixelnum,max_pixelnum,
                         min_pixelnum+Subscript((1+max_pixelnum-min_pixelnum)*
                                                (bin_fullness/bin_fullness_range)));
  }
  
  void draw_element(const Subscript bin_number, const Bounded::Magnitude bin_fullness, PixelType p=default_fg);
  void draw_element_vertical(const Subscript bin_number, const Bounded::Magnitude bin_fullness, PixelType p=default_fg);

  
public:
  
  OneDHistogramImage()
    : border(0), num_bins(0), size_scale(1.0), vertical(false),
      bin_fullness_range(0), min_pixelnum(0), zero_pixelnum(0), 
      max_pixelnum(0), markzero(false) { }
  
  template <class Histogram>
  OneDHistogramImage(const Histogram &h, bool vertical=false,
                     double size_scale_i=1.0, double aspect_ratio_i=1.0, 
                     Bounded::Magnitude bin_fullness_range_i=1.0, int borderwidth=0,
                     const ColorLookup<PixelType>& L=HueColorLookup<PixelType>(),
                     const PixelType& bordercolor=default_border, 
                     const PixelType& bg_=default_bg,
                     const PixelType& fg_=default_fg);
  
};



template<class PixelType, class PixelMatrix>
template <class Histogram>
OneDHistogramImage<PixelType,PixelMatrix>::OneDHistogramImage
  (const Histogram &h, bool vertical_i, double size_scale_i, double aspect_ratio_i, 
   Bounded::Magnitude bin_fullness_range_i, int borderwidth, const ColorLookup<PixelType>& L,
   const PixelType& bordercolor, const PixelType& bg_, const PixelType& fg_)
  : AARImage<PixelType>(2*borderwidth+Subscript(h.num_bins()*size_scale_i*(vertical_i?1.0:aspect_ratio_i)),
                        2*borderwidth+Subscript(h.num_bins()*size_scale_i*(vertical_i?aspect_ratio_i:1.0))),
  border(borderwidth), num_bins(h.num_bins()), size_scale(size_scale_i), vertical(vertical_i),
  bin_fullness_range(bin_fullness_range_i), min_pixelnum(borderwidth), zero_pixelnum(borderwidth), 
  max_pixelnum(borderwidth+PixelSubscript(h.num_bins()*size_scale_i*aspect_ratio_i)),
  bg(bg_), fg(fg_), markzero(false) {

  draw_border(borderwidth,bordercolor);
  typedef typename Histogram::size_type Subscript;

  if (vertical)
    for (Subscript b=0; b<h.num_bins(); b++)
      draw_element_vertical(b,h.value_mag(b),L((b*1.0)/h.num_bins()));
  else
    for (Subscript b=0; b<h.num_bins(); b++)
      draw_element(b,h.value_mag(b),L((b*1.0)/h.num_bins()));
}



template<class PixelType, class PixelMatrix>
void OneDHistogramImage<PixelType,PixelMatrix>::draw_element_vertical
  (const Subscript bin_number, const Bounded::Magnitude bin_fullness, PixelType p)
{
  const PixelSubscript pivot = bin_fullness_pixelnum(bin_fullness);
  const PixelSubscript binpl = bin_number_pixelnum(bin_number);
  const PixelSubscript binph = bin_number_pixelnum(bin_number+1);
    
  /* Representation consists of three boxes: bar, background, and (optional) origin */
  draw_rectangle(  binpl,   zero_pixelnum, binph, pivot,           p );
  draw_rectangle(  binpl,   pivot,         binph, max_pixelnum,    bg);
  if (markzero)
    draw_rectangle(binpl,   zero_pixelnum, binph, zero_pixelnum+1, fg);
}


 
template<class PixelType, class PixelMatrix>
void OneDHistogramImage<PixelType,PixelMatrix>::draw_element
  (const Subscript bin_number, const Bounded::Magnitude bin_fullness, PixelType p)
{
  const PixelSubscript pivot = bin_fullness_pixelnum(bin_fullness);
  const PixelSubscript binpl = bin_number_pixelnum(bin_number);
  const PixelSubscript binph = bin_number_pixelnum(bin_number+1);
    
  /* Representation consists of three boxes: bar, background, and (optional) origin */
  draw_rectangle(  nrows()-zero_pixelnum, binpl,   nrows()-pivot,           binph, p );
  draw_rectangle(  nrows()-pivot,         binpl,   nrows()-max_pixelnum,    binph, bg);
  if (markzero)                                                    
    draw_rectangle(nrows()-zero_pixelnum, binpl,   nrows()-zero_pixelnum+1, binph, fg);
}


} /* namespace Plot */
#endif /* __HISTOGRAM_IMAGE_H__ */

---