---

image.h

Go to the documentation of this file.

#ifndef __IMAGE_H__
#define __IMAGE_H__

#include <algorithm>
#include <cmath>
#include <fstream>
#include <string>
using std::string;

#include "matrix.h"
#include "pixel.h"
#include "mathconstants.h"

namespace  Plot {


template<class PixelType=RGBPixel<>, class PixelMatrix=typename MatrixType<PixelType>::rectangular >
class AARImage {
public:
  typedef typename PixelMatrix::size_type PixelSubscript;
  typedef PixelSubscript size_type;
  typedef PixelType value_type;

private:
  void BresenhamAlongC(PixelSubscript rA, PixelSubscript cA, PixelSubscript rB, PixelSubscript cB, int direction, PixelType p, int thickness);
  void BresenhamAlongR(PixelSubscript rA, PixelSubscript cA, PixelSubscript rB, PixelSubscript cB, int direction, PixelType p, int thickness);
  
  PixelMatrix pixels;

public:
  typedef double CartesianCoordinate;

  AARImage(PixelSubscript height=0, PixelSubscript width=0, PixelType bg=default_bg )
    : pixels (height,width)  {  mat::set(pixels,bg); }

  inline void draw_pixel(const PixelSubscript r, const PixelSubscript c, PixelType p) {
    if (inbounds(r,c))
      pixels[r][c] = p;
  }

  inline const PixelType& get_pixel(const PixelSubscript r, const PixelSubscript c) const
    {  return(pixels[r][c]);  }

  inline PixelSubscript nrows() const {  return pixels.nrows();  }

  inline PixelSubscript ncols() const {  return pixels.ncols();  }

  
  void draw_rectangle(PixelSubscript r1, PixelSubscript c1, PixelSubscript r2, PixelSubscript c2, PixelType p);
  void draw_line(PixelSubscript r1, PixelSubscript c1, PixelSubscript r2, PixelSubscript c2, PixelType p, int thickness=1);
  void draw_bar(CartesianCoordinate cx, CartesianCoordinate cy,
                double angle, double length, double width=1, PixelType p=default_fg, bool always_draw=true);

  void draw_border(size_type borderwidth=1, PixelType p=default_border) {
    const PixelSubscript b=borderwidth;
    const PixelSubscript r=nrows();
    const PixelSubscript c=ncols();
    
    draw_rectangle(0,   0,   r, b,   p);
    draw_rectangle(0,   b,   b, c-b, p);
    draw_rectangle(0,   c-b, r, c,   p);
    draw_rectangle(r-b, b,   r, c-b, p);
  }

  template<class OutputType>
  std::ostream& ppm_write( std::ostream& os, const string& comments="", OutputType max_val=(unsigned char)(255) ) const;

  template<class PType, class PMatrix>
  friend std::ostream& operator<<(std::ostream& s, const AARImage<PType,PMatrix>& o);

protected:
  inline PixelSubscript col_from_x(const CartesianCoordinate x) const {  return PixelSubscript(x);  }

  inline PixelSubscript row_from_y(const CartesianCoordinate y) const {  return PixelSubscript(pixels.nrows()-1-y);  }
   
  inline bool inbounds(const PixelSubscript r, const PixelSubscript c) const {
    return (int(r)>=0 && r<pixels.nrows() &&
            int(c)>=0 && c<pixels.ncols());
  }

public:  
  static PixelType default_fg;
  static PixelType default_bg;
  static PixelType default_border;
};



/* Static defaults */ 
template<class PixelType, class PixelMatrix> PixelType AARImage<PixelType,PixelMatrix>::default_fg(1,1,1,false);
template<class PixelType, class PixelMatrix> PixelType AARImage<PixelType,PixelMatrix>::default_bg(0,0,0);
template<class PixelType, class PixelMatrix> PixelType AARImage<PixelType,PixelMatrix>::default_border(1,1,1);

 
  
template<class PixelType, class PixelMatrix>
template<class OutputType>
std::ostream& AARImage<PixelType,PixelMatrix>::ppm_write( std::ostream& os, const string& comments, OutputType max_val) const
{
  os << "P6\n"; /* file type: P6=binary, P3=ASCII */
  os << "#" << comments.c_str() << "\n";
  os << pixels.ncols()  << " " << pixels.nrows() << "\n";  
  os << int(max_val)    << "\n"; /* maximum R, G, or B value */

  for   (PixelSubscript r=0; r<pixels.nrows(); r++)
    for (PixelSubscript c=0; c<pixels.ncols(); c++)
      (pixels[r][c].write_binary(os, max_val));

  return os;
}


 
template<class PixelType, class PixelMatrix>  
std::ostream& operator<<(std::ostream& s, const AARImage<PixelType,PixelMatrix>& o)
  {  return s << o.pixels;  }

 

template<class PixelType, class PixelMatrix>  
void AARImage<PixelType,PixelMatrix>::draw_rectangle(PixelSubscript r1, PixelSubscript c1, PixelSubscript r2, PixelSubscript c2, PixelType p)
{
  for (PixelSubscript r=std::min(r1,r2); r<std::max(r1,r2); r++)
    for (PixelSubscript c=std::min(c1,c2); c<std::max(c1,c2); c++)
      draw_pixel(r,c,p);
}



template<class PixelType, class PixelMatrix>  
void AARImage<PixelType,PixelMatrix>::draw_line(PixelSubscript r1, PixelSubscript c1, PixelSubscript r2, PixelSubscript c2, PixelType p, int thickness)
{
  int rA,rB,cA,cB;  /* canonical form of coordinates   */
  int r, direction;
  
  /* Swap endpoints if line wasn't specifed from left to right */
  const int dc = c2-c1;
  if (dc >= 0)  { rA = r1; cA = c1;   r = r2; cB = c2; }
  else          { rA = r2; cA = c2;   r = r1; cB = c1; }
  
  
  /* Flip right endpoint across horizontal axis if it is above it 
     (leaves lower right quadrant only) */
  const int dr = rA-r;
  if (dr < 0)   { direction =  1;  rB =         r; }
  else          { direction = -1;  rB = (rA<<1)-r; }

  //cout << "(" << rA << "," << cA << ") -> (" << rB << "," << cB << ") " << direction << " " << p << endl;
  //cout << "dr: " << dr << " dc: " << dc << endl;

  /* Iterate along the axis which changes the most */
  if (std::abs(dc) > std::abs(dr))  BresenhamAlongC(rA, cA, rB, cB,  direction, p, thickness);
  else                              BresenhamAlongR(rA, cA, rB, cB,  direction, p, thickness);
}



template<class PixelType, class PixelMatrix>  
void AARImage<PixelType,PixelMatrix>::BresenhamAlongC(PixelSubscript rA, PixelSubscript cA, PixelSubscript rB, PixelSubscript cB, int direction, PixelType p, int thickness)
{
  const int dr    = rB-rA;
  const int dc    = cB-cA;
  const int incE  = 2*dr;
  const int incSE = 2*(dr-dc);

  //cout << "AlongC" << endl;
  
  int d = 2*dr-dc;
  int r = rA;
  int i;
  
  for (i=-thickness/2; i<=thickness/2; i++)
    draw_pixel(rA+i,cA,p);  /* set starting point */

  for (int c=int(cA+1); c<=int(cB); c++) {
    if (d <= 0 ) /* choose E */
      d += incE;
    else {       /* choose SE */
      d += incSE;
      r += direction;
    }
    for (i=-thickness/2; i<=thickness/2; i++)
      draw_pixel(r+i,c,p);
  }
}



template<class PixelType, class PixelMatrix>
void AARImage<PixelType,PixelMatrix>::BresenhamAlongR(PixelSubscript rA, PixelSubscript cA, PixelSubscript rB, PixelSubscript cB, int direction, PixelType p, int thickness)
{
  const int dc    = cB-cA;
  const int dr    = rB-rA;
  const int incE  = 2*dc;
  const int incSE = 2*(dc-dr);

  //cout << "AlongR" << endl;
  
  int d  = 2*dc-dr;
  int c  = cA;
  int rp = rA; /* r corrected for direction */

  int i;
  
  for (i=-thickness/2; i<=thickness/2; i++)
    draw_pixel(rA,cA+i,p);  /* set starting point */

  for (int r=int(rA); r<int(rB); r++) {
    rp += direction;
    if (d <= 0 ) /* choose E */
      d += incE;
    else {       /* choose SE */
      d += incSE;
      c += 1;
    }
    for (i=-thickness/2; i<=thickness/2; i++)
      draw_pixel(rp,c+i,p);
  }
}



template<class PixelType, class PixelMatrix>
void AARImage<PixelType,PixelMatrix>::draw_bar(CartesianCoordinate cx, CartesianCoordinate cy,
                                               double angle, double length, double width, 
                                               PixelType p, bool always_draw)
{
  /* Lines shorter than one pixel can be skipped if requested */
  /* The "-1" corrects for the width of the halves of each endpoint that are counted implicitly */
  if (always_draw || length >= 1.0) {
    const double              xoffset = (double)(((length)/2)*cos(angle));
    const double              yoffset = (double)(((length)/2)*sin(angle));
    const CartesianCoordinate y1      = cy-yoffset;
    const CartesianCoordinate y2      = cy+yoffset;
    const CartesianCoordinate x1      = cx-xoffset;
    const CartesianCoordinate x2      = cx+xoffset;
    const PixelSubscript      r1      = row_from_y(y1);
    const PixelSubscript      r2      = row_from_y(y2);
    const PixelSubscript      c1      = col_from_x(x1);
    const PixelSubscript      c2      = col_from_x(x2);
    
    if (p.istransparent()) {
      PixelAverage<> pa;
      pa+=get_pixel(r1,c1);
      pa+=get_pixel(r2,c2);
      p=contrasting_color(pa());
    }

    /* Draw at least one full line */ 
    if (width<=1)
      draw_line(r1,c1,r2,c2,p,1);
    else {
      /* This is a hack to get a filled rectangle without having to handle polygons */
      double delt;
      for (delt=0; delt<width/2; delt+=0.5) {
        const double deltax=(double)(delt*cos((Math::pi)/2-angle));
        const double deltay=(double)(delt*sin((Math::pi)/2-angle));
        draw_line( row_from_y(y1+deltay), col_from_x(x1-deltax),
                   row_from_y(y2+deltay), col_from_x(x2-deltax), p, std::min(2,int(width)));
        draw_line( row_from_y(y1-deltay), col_from_x(x1+deltax),
                   row_from_y(y2-deltay), col_from_x(x2+deltax), p, std::min(2,int(width)));
      }
    }
  }
}



} /* namespace Plot */
#endif /* __IMAGE_H__ */

---