Canvas.h

Go to the documentation of this file.

/**
 *\file         Canvas.h
 *
 *\brief        The Canvas class is a discrete simulation of the real life canvas. 
 *
 *              The canvas is cutted into grid structure, with <b><var>vReso</var></b> grids along
 *              vertical (<b><var>Row</var></b>) direction and <b><var>hReso</var></b> horizontal grids along 
 *              horizontal(<b><var>Col</var></b>) direction. Each rectangular grid is called a pixel, or picture
 *              element, and is specified by its lower-left <b><var>(row, col)</var></b> position. 
 *              The coordinate system has the lower-left corner of the canvas as its origin, 
 *              with <b><var>Row</var></b> going up and <b><var>Col</var></b> going right. The lower-left corner 
 *              pixel has a coordinate of <b><var>(0,0)</var></b>, and the upper-right one of <b><var>
 *              (hReso - 1, vReso - 1)</var></b>. 
 *
 *              A <b><var>(x, y)</var></b> pair means <b><var>col = x+hReso/2, and row = y+vReso/2</var></b>.
 *
 *              To each piexel <b><var>(row, col)</var></b> on the Canvas, a RGB color value is associated,
 *              which can be accessed via index operator [<b><var>row</var></b>][<b><var>col</var></b>].
 *
 *              WritePPM() writes the Canvas to an image file of PPM format.
 *
 *\author       Xianming Chen
 *
 */


#ifndef _CANVAS_H_
#define _CANVAS_H_

#include "RGB.h"

#include <string>
#include <cassert>
#include <map>

using namespace std;

namespace columbia
{
  class Canvas
  { 
  public:
      explicit Canvas(int resoH = 512, int resoV = 512) : hReso(resoH), vReso(resoV), filename("tmp.ppm"), data(0)  { init(); }
      ~Canvas()                                  { delete [] data; }
      void Clear(RGB const&);
      

      RGB* operator[] (int r)                    { assert(r>=0 && r<vReso); return data + r*hReso; }
      RGB& Pixel(int row, int col);              //! Use this instead of the [] operator if both row and col number checking is needed.
      
      /**
       * Scan-convert a line segment given two end points. The scan conversion stop right before the second end point.
       * If output = 0, Draw a line segment between two end points, (x1,y1) and (x2,y2).  Each pixel color is interpolated from two end colors.
       * Else only return scanned result to output.
       */
      void ScanLineSegment(int x1, int y1, RGB const& color1, int x2, int y2, RGB const& color2, multimap<int, int>* output=0);  

      void WireCircle(int center_x, int center_y, int radius, int reso, RGB const& col);

      /**
       * These implement simple filling algorithms for circles, axis alligned rectangles, and general triangles.
       */
      void SolidCircle(int center_x, int center_y, int radius, RGB const& col);
      void SolidRectangle(int minx, int miny, int maxx, int maxy, RGB const& col);

      void SolidTriangle(int x1, int y1, RGB const& col1, int x2, int y2, RGB const& col2, int x3, int y3, RGB const& col3);

      void WritePPM(const char* = 0) const;

      int hReso, vReso;                          //! Resolutions (pixel #)at horizontal and vertical directions.
      std::string filename;                      //! write as PPM image file name.
  private:
      RGB* data;
      bool swap_xy, flip_y;                      // if line has abs(slope) > 1.0, flip it around y=x for scan conversion, and then flip back to fill pixel.

      void init();

      /* Only for lines of |slope| <= 1.0 && x1!=x2.  */
      void scanLineSegment(int x1, int y1, RGB const& col1, int x2, int y2, RGB const& col2, multimap<int, int>* output);
  };
  

  inline RGB& Canvas :: Pixel(int row, int col)
  {
    if(row >= vReso)
    {
      cout << "row = " << row << endl;
      throw "row number overflow\n";
    }
    if(row < 0)
    {
      cout << "row = " << row << endl;
      throw "row number underflow\n";
    }
    if(col >= hReso)
    {
      cout << "col = " << col << endl;
      throw "col number overrflow\n";
    }
    if(col < 0)
    {
      cout << "col = " << col << endl;
      throw "col number underflow\n";
    }
    return *(data + row * hReso + col);
  }
  

}

#endif

---