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);
  }


  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, int>* output)
  {
    assert( x2-x1 >= 1 && x2-x1 >= y2-y1 && y2-y1 >= 0);

    for(int x = x1; x != x2; ++x)
    {
      double t = ( double(x-x1) ) / (x2 - x1);
      int y = round( interpolate(t, double(y1), double(y2)) );

      int X = x, Y = y;

      if(swap_xy)
      {
        swap(X,Y);
      }
      if(flip_y) Y = -Y-1;   // minus 1 is necessary because the pixel is specified by its lower left corner (x, y) pair.
      
      if(output) 
        output->insert(make_pair(Y, X));
      else
        (*this)[Y + vReso/2][X + hReso/2] = interpolate(t, col1, col2);
    }
  }
  

  void Canvas :: ScanLineSegment(int x1, int y1, RGB const& col1, int x2, int y2, RGB const& col2, multimap<int,int>* output)
  {
    if(x1==x2 && y1==y2) return;
    
    if(x1 > x2)                                       // always scan convert from left to right.
    {
      swap(x1, x2), swap(y1, y2); 
      swap( ((RGB&)col1),  ((RGB&)col2) );
    }
    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, col1, x2, y2, col2, output);
  }


  void Canvas :: SolidTriangle(int x1, int y1, RGB const& col1, int x2, int y2, RGB const& col2, int x3, int y3, RGB const& col3)
  {
    multimap<int, int> scanned_pnts;     // the key is y value of the scanned point.

    ScanLineSegment(x1,y1,White, x2,y2,White, &scanned_pnts);
    ScanLineSegment(x1,y1,White, x3,y3,White, &scanned_pnts);
    ScanLineSegment(x3,y3,White, x2,y2,White, &scanned_pnts);

    int cur_yval = vReso / 2;           // initialize to an invalid value.
    vector<int> xvals;                  // put x_vals of all points with the same y value here.
    
    for (multimap<int, int>::iterator it = scanned_pnts.begin(); it != scanned_pnts.end(); ++it)
    {
      int y = it->first;
      if(y != cur_yval) 
      {
        if(xvals.size())
        {
          int xleft = *( min_element( xvals.begin(), xvals.end() ) );
          int xright = *( max_element( xvals.begin(), xvals.end() ) );
          ScanLineSegment(xleft, cur_yval, White, xright, cur_yval, White);
          xvals.clear();
        }
        cur_yval = y;
      }
      xvals.push_back(it->second);
    }
  }
  
}

---