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 :: 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, 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; 
      
      if(output) 
        output->insert(make_pair(Y, X));
      else
        Pixel(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 :: 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 :: 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);
    }
  }
  
}

---