/* lgraph.cpp - line graph program

Copyright (C) 2003, Matt Mahoney.  This program is distributed
without warranty under terms of the GNU general public license.
See http://www.gnu.org/licenses/gpl.txt

To compile: g++ lgraph.cpp

Usage: lgraph files...

Input files consist of up to 4 columns of numbers separated by other
characters representing points on the Y axis.  Output is lgraph.bmp
as a line graph with each column graphed black, red, green, and blue.
If more than one file is given, then the graphs overlap.
*/

#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cassert>
#include <cmath>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

template<class T> inline int size(const T& t) {return t.size();}

// Image - can be drawn to, and saved as a .bmp file 
class Image {
public:
  Image(int w, int h): pixels(w*h*3), width(w), height(h) {}  // size w by h
  void saveBMP(const char *filename);  // Save as .bmp file

  // Add colors (-255 to 255) to pixel at x,y (origin at lower left)
  void put(int x, int y, int red, int green, int blue) {
    assert(x>=0);
    assert(x<width);
    assert(y>=0);
    assert(y<height);
    const int i=(y*width+x)*3;
    int c=pixels[i]+blue;
    pixels[i]=c>255?255:c<0?0:c;
    c=pixels[i+1]+green;
    pixels[i+1]=c>255?255:c<0?0:c;
    c=pixels[i+2]+red;
    pixels[i+2]=c>255?255:c<0?0:c;
  }
  void put(int x, int y, int color) {put(x, y, color, color, color);}
  int getwidth() const {return width;}  // in pixels
  int getheight() const {return height;}  // in pixels
private:
  vector<unsigned char> pixels;  // width * height * blue-green-red (3 bytes)
  int width, height;  // Image size in pixels
  void out2(FILE *f, int x) {fprintf(f, "%c%c", x, x>>8);}  // Write 2 bytes
  void out4(FILE *f, unsigned long x)  // Write 4 bytes, LSB first
    {fprintf(f, "%c%c%c%c", int(x), int(x>>8), int(x>>16), int(x>>24));}
};

// Save as a .bmp file
void Image::saveBMP(const char *filename) {
  FILE *f=fopen(filename, "wb");
  if (!f) {
    perror(filename);
    return;
  }
  fprintf(f,"BM");  // magic number for .bmp files
  out4(f, 54+pixels.size());  // file size
  out4(f, 0);  // reserved
  out4(f, 54);  // offset to start of image (no palette)
  out4(f, 40);  // info header size
  out4(f, width);  // image size in pixels
  out4(f, height);
  out2(f, 1);  // image planes
  out2(f, 24);  // output bits per pixel
  out4(f, 0);  // no compression
  out4(f, width*height*3);  // image size in bytes
  out4(f, 3000);  // x pixels per meter
  out4(f, 3000);  // y pixels per meter
  out4(f, 0x1000000);  // colors
  out4(f, 0x1000000);  // important colors
  for (int i=0; i<int(pixels.size()); ++i)  // write the image
    putc(pixels[i], f);
  fclose(f);
}

void graph(const char* filename, Image& g) {

  // Open file
  FILE* f=fopen(filename, "rb");
  if (!f) {
    perror(filename);
    return;
  }

  // Read columns of numbers.  A number must be in floating decimal format
  // with at least one digit, e.g. 41 or -5.27e+03
  const int N=4;        // Max number of columns to read
  vector<double> v[N];  // Data points
  int col=0;            // Column number (0 to N-1)
  string s;             // Input number so far, e.g. "-2.7"
  int c;                // Input char e.g. '5'
  bool hasdigit=false;  // There is a digit in s
  while ((c=getc(f))!=EOF) {
    if (isdigit(c) || c=='.' || c=='e' || c=='E' || c=='+' || c=='-') {
      s+=char(c);
      if (isdigit(c))
        hasdigit=true;
    }
    else if (size(s)>0) {
      if (hasdigit) {
        if (col<N)
          v[col].push_back(atof(s.c_str()));
        ++col;
      }
      s="";
      hasdigit=false;
    }
    if (c=='\n')
      col=0;
  }
  fclose(f);

  // Print file stats
  printf("%s\n", filename);
  for (int i=0; i<N; ++i) {
    if (size(v[i])>0) {
      double lo=v[i][0], hi=lo;
      for (int j=1; j<size(v[i]); ++j) {
        if (v[i][j]<lo) lo=v[i][j];
        if (v[i][j]>hi) hi=v[i][j];
      }
      printf("Column %d: %d values range %f to %f\n", i, size(v[i]), lo, hi);

      // Draw the graph
      if (hi>lo) {
        int shade=-1-20000/size(v[i]);
        if (shade<-64) shade=-64;
        for (int j=0; j<size(v[i]); ++j) {
          int x=int((j+0.5)*g.getwidth()/(size(v[i])+1.0));
          int y=int((v[i][j]-lo)*(g.getheight()-1)/(hi-lo)+0.5);
          g.put(x, y, 32*shade*(i!=1), 32*shade*(i!=2), 32*shade*(i!=3)); 
//          for (int k=0; k<y; ++k)
//            g.put(x, k, shade*(i!=1), shade*(i!=2), shade*(i!=3));
        }
      }
    }
  }
  printf("\n");
}

// argv = graph filenames...
int main(int argc, char **argv) {

  // Read file
  if (argc<=1) {
    fprintf(stderr, "To create lgraph.bmp: lgraph files...\n"
      "Files consist of a list of up to 4 numeric values\n");
    return 1;
  }

  // Create blank white image
  const int width=500, height=250;
  Image g(width, height);
  for (int i=0; i<width; ++i)
    for (int j=0; j<height; ++j)
      g.put(i, j, 255, 255, 255);

  // Graph files
  for (int i=1; i<argc; ++i)
    graph(argv[i], g);
  g.saveBMP("lgraph.bmp");
  printf("Created lgraph.bmp\n");
  return 0;
}