Canvas.cpp

#include "Canvas.h"
#include "color.h"
#include "xmath.h"
#include <iostream>
#include <fstream>
#include <vector>


using namespace std;

namespace columbia
{

  void Canvas :: init() 
  { 
    int N = hReso*vReso;
    
    delete [] data; 
    data = new RGB [N]; 
    memset(data, 0, sizeof(RGB) * N);

    eye_at = hReso / 2;     // default horizontal field of view = 90.
  }

  void Canvas :: Clear(RGB const& color)
  {
    for (int row = 0; row < vReso; row++) 
      for (int col = 0; col < hReso; col++) 
      {
        (*this)[row][col] = color;
      }
  }
  

  void Canvas :: WritePPM(const char *_filename) const
  {
    Canvas* This =  (Canvas*)this;
    
    if(!_filename) 
      _filename = filename.c_str();

    ofstream file;
    file.open (_filename, ios::out | ios::binary);
    
    if(file) 
    {
      file << "P6\n";   // color rawbits format
      file << hReso << " " << vReso << endl << 100 << endl;
  
      unsigned char r, g, b;
      for (int row = 0; row < vReso; row++) 
        for (int col = 0; col < hReso; col++) 
        {
          r = (unsigned char) (100.0*(*This)[vReso-row-1][col][0]);  
          g = (unsigned char) (100.0*(*This)[vReso-row-1][col][1]);  
          b = (unsigned char) (100.0*(*This)[vReso-row-1][col][2]);  

          if(r>100.0 || g>100.0 || b>100.0)  throw "RGB color overflow\n"; 

          file << r << g << b;
        }

      file << endl;
      file.close();
    }
    else 
      cerr << "Can't open output file " << _filename << endl;
  }



  void Canvas :: scanLineSegment(int x1, int y1, RGB const& col1, int x2, int y2, RGB const& col2, multimap<int, pair<int, RGB> >* output)
  {
    assert( x2-x1 >= 1 && x2-x1 >= y2-y1 && y2-y1 >= 0);

    if(y1 == y2)                                     // this is horizontal line, or vertical line if swap_xy set.
    {
      for(int x = x1; x < x2; ++x)                   
      {
        writePixel(x, y1, interpolate(( double(x-x1) ) / (x2 - x1), col1, col2), output);
      }
    }
    else if(y2-y1 == x2-x1)                         // diagonal lines.
    {
      int y = y1;
      for(int x = x1; x < x2; ++x, ++y)
      {
        writePixel(x, y, interpolate(( double(x-x1) ) / (x2 - x1), col1, col2), output);
      }
    }
    else     
    {
      for(int x = x1; x < x2; ++x)
      {
        double t = ( double(x-x1) ) / (x2 - x1);
        writePixel(x, round( interpolate(t, double(y1), double(y2)) ), interpolate(t, col1, col2), output);
      }
    }
  }
  

  void Canvas :: ScanLineSegment(int x1, int y1, RGB const& col1, int x2, int y2, RGB const& col2, multimap<int, pair<int, RGB> >* output)
  {
    if(x1==x2 && y1==y2) return;

    RGB c1(col1), c2(col2);
    
    if(x1 > x2)                                       // always scan convert from left to right.
    {
      swap(x1, x2), swap(y1, y2); 
      swap(c1,  c2);
    }
    if( (flip_y = y1 > y2) )                          // always scan convert from down to up.
    {
      y1 = -y1, y2 = -y2;
    }
    if( (swap_xy = y2-y1 > x2-x1) )                   // and always scan convert a line with <= 45 deg to x-axis.
    {
      swap(x1, y1), swap(x2, y2);
    }
    scanLineSegment(x1, y1, c1, x2, y2, c2, output);
  }


  void Canvas :: WireCircle(int center_x, int center_y, int radius, int slices, RGB const& col)
  {
    double angle_step = 2 * pi / slices;

    double angle = 0;
    int x1 = center_x + radius, y1 = center_y;
    int x2, y2;
    
    for(int i=0; i<slices; i++)
    {
      angle += angle_step;
      x2 = round(center_x + radius * cos(angle));
      y2 = round(center_y + radius * sin(angle));
      (*this)[y2 + vReso/2][x2 + hReso/2] = col;   // make sure consecutive segment is connected.  
      ScanLineSegment(x1, y1, col, x2, y2, col);
      x1 = x2;
      y1 = y2;
    }
  }


  void Canvas :: SolidCircle(int center_x, int center_y, int radius, RGB const& col)
  {
    for(int y = 0; y <= radius; y++)
    {
      int x = round( sqrt(double(radius * radius - y * y)) );
      if(x == 0) 
        x = round( sqrt(2. * radius - 1) / 2 );     // half value of the previous x. this way the circle looks better.
      
      ScanLineSegment(-x + center_x,  y + center_y, col,   x + center_x,  y + center_y, col);
      if(y != 0)
        ScanLineSegment(-x + center_x,  -y + center_y, col,   x + center_x,  -y + center_y, col);
    }
  }

  
  void Canvas :: SolidRectangle(int minx, int miny, int maxx, int maxy, RGB const& col)
  {
    for(int y = miny; y < maxy; y++)
      ScanLineSegment(minx,  y, col,   maxx, y, col);
  }
  

  void Canvas :: WireTriangle(Point const& P1, RGB const& col1, Point const& P2, RGB const& col2, Point const& P3, RGB const& col3)
  {
    Point p1 = perspectiveProjection(P1);
    Point p2 = perspectiveProjection(P2);
    Point p3 = perspectiveProjection(P3);
    ScanLineSegment(round(p1.x), round(p1.y), col1, round(p2.x), round(p2.y), col2);
    ScanLineSegment(round(p1.x), round(p1.y), col1, round(p3.x), round(p3.y), col3);
    ScanLineSegment(round(p3.x), round(p3.y), col3, round(p2.x), round(p2.y), col2);
  }
  
  void Canvas :: SolidTriangle(Point const& P1, RGB const& col1, Point const& P2, RGB const& col2, Point const& P3, RGB const& col3)
  {
    Point p1 = perspectiveProjection(P1);
    Point p2 = perspectiveProjection(P2);
    Point p3 = perspectiveProjection(P3);

    multimap<int, pair<int, RGB> > scanned_pnts;     // ele is <y, <x, col> >, sorted by y val.

    ScanLineSegment(round(p1.x), round(p1.y), col1, round(p2.x), round(p2.y), col2, &scanned_pnts);
    ScanLineSegment(round(p1.x), round(p1.y), col1, round(p3.x), round(p3.y), col3, &scanned_pnts);
    ScanLineSegment(round(p3.x), round(p3.y), col3, round(p2.x), round(p2.y), col2, &scanned_pnts);
    
    int cur_yval = vReso / 2 + 1;                    // initialize to an invalid value.
    map<int, RGB> x_rgb;                             // put x_vals and related cols of all points with the same y value here.
    
    for (multimap<int, pair<int, RGB> >::iterator it = scanned_pnts.begin(); it != scanned_pnts.end(); ++it)
    {
      int y = it->first;
      if(y != cur_yval) 
      {
        if(x_rgb.size())
        {
          ScanLineSegment(x_rgb.begin()->first, cur_yval, x_rgb.begin()->second, 
                   (--x_rgb.end())->first+1, cur_yval, (--x_rgb.end())->second);
          x_rgb.clear();
        }
        cur_yval = y;
      }
      x_rgb.insert(it->second);
    }
  }
}

---