/* boxgraph.cpp - line graph program

Copyright (C) 2004, 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++ boxgraph.cpp

Usage: boxgraph [n=0 [size=400]] < file 

Input consists of x, rx, y, ry coordinates in 2 columns or
x, rx, y, ry, z, rz coordinates in 3 columns, where x,y,z reprsent centers
of boxes and rx, ry, rz reprsent radii (1/2 width).  Output is a 2-D
or 3-D graph, boxgraph.bmp, with successive boxes going from red to blue.
The first n boxes are black.  The size defaults to 400 by 400 pixels.
*/

#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:

  // Construct with size w by h pixels with initial color 0=black, 255=white
  Image(int w, int h, int color=255): pixels(w*h*3), width(w), height(h) {
    fill(pixels.begin(), pixels.end(), color);
  }
  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) {
    if (x<0 || x>=width || y<0 || y>=width)
      return;
    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);
}

// Is c a floating point digit?
inline bool isnum(int c) {
  return isdigit(c) || c=='+' || c=='-' || c=='.';
}

// Read 6 floating point numbers from f into x1..x6, return not EOF?
bool read6num(FILE* f, double& x1, double& x2, double& x3,
                       double& x4, double& x5, double& x6) {
  static const int N=1000;
  static char buf[N];
  x1=x2=x3=x4=x5=x6=0;
  char *p=buf;  // write pointer
  int state=0;  // state 2n-1 means reading xn
  while (true) {
    int c=getc(f);
    if ((state&1)==0) {  // between numbers
      if (isnum(c)) {
        ++state;
        p=buf;
        *p++ = c;
      }
    }
    else {  // reading a number
      if (!isnum(c) && tolower(c)!='e') {
        ++state;
        *p=0;
        switch (state) {
          case  2: x1=atof(buf); break;
          case  4: x2=atof(buf); break;
          case  6: x3=atof(buf); break;
          case  8: x4=atof(buf); break;
          case 10: x5=atof(buf); break;
          case 12: x6=atof(buf); break;
        }
      }
      else if (p<buf+N-1)
        *p++ = c;
    }
    if (c=='\n')
      return true;
    else if (c==EOF)
      return false;
  }
}

// Draw a point in coordinate range 0,0 to 1,1
void drawpoint(Image& g, double x, double y, int red, int green, int blue) {
  const int w=g.getwidth()-1;
  const int h=g.getheight()-1;
  const double px=x*w;
  const double py=y*h;
  const int ix=int(px);
  const int iy=int(py);
  const double upper=px-ix;
  const double right=py-iy;
  const double ur=upper*right;
  const double ul=upper*(1-right);
  const double lr=(1-upper)*right;
  const double ll=(1-upper)*(1-right);
  g.put(ix,   iy,   int(ll*red), int(ll*green), int(ll*blue));
  g.put(ix+1, iy,   int(lr*red), int(lr*green), int(lr*blue));
  g.put(ix,   iy+1, int(ul*red), int(ul*green), int(ul*blue));
  g.put(ix+1, iy+1, int(ur*red), int(ur*green), int(ur*blue));
}

// Draw line from x1,y1 to x2,y2 in g with range 0,0 to 1,1.
void drawline(Image& g, double x1, double y1, double x2, double y2,
    int red, int green, int blue) {
  const double len=sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
  if (len>0) {
    const double step=1/(len*(1+g.getwidth()+g.getheight()));
    for (double t=0; t<=1; t+=step)
      drawpoint(g, t*x1+(1-t)*x2, t*y1+(1-t)*y2, red, green, blue);
  }
}

// Draw in 3-D perspective from (x1,y1,z1) to (x2,y2,z2)
void draw3d(Image& g, double x1, double y1, double z1, double x2, double y2,
    double z2, int red, int green, int blue) {
  const double ZX=0.3, ZY=0.2;  // perspective angle
  const double len=0.25*sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)+(z2-z1)*(z2-z1));
  drawline(g, x1*(1-ZX)+(z1)*ZX, y1*(1-ZY)+(z1)*ZY,
              x2*(1-ZX)+(z2)*ZX, y2*(1-ZY)+(z2)*ZY,
              red, green, blue);  // line
  drawline(g, x1*(1-ZX)+(z1)*ZX, (z1)*ZY,
              x2*(1-ZX)+(z2)*ZX, (z2)*ZY,
              red/8, green/8, blue/8);  // shadow
  drawline(g, x1*(1-ZX)+(z1)*ZX, y1*(1-ZY)+(z1)*ZY,
              x1*(1-ZX)+(z1)*ZX, (z1)*ZY,
              int(red*len), int(green*len), int(blue*len));
              // projection to shadow
}

void drawbox(Image& g, double x, double y, double rx, double ry,
             int red, int green, int blue) {
  drawline(g, x-rx, y-ry, x+rx, y-ry, red, green, blue);
  drawline(g, x-rx, y-ry, x-rx, y+ry, red, green, blue);
  drawline(g, x+rx, y+ry, x+rx, y-ry, red, green, blue);
  drawline(g, x+rx, y+ry, x-rx, y+ry, red, green, blue);
}

void draw3dbox(Image& g, double x, double y, double z, double rx,
               double ry, double rz, int red, int green, int blue) {
  draw3d(g, x-rx, y-ry, z-rz, x+rx, y-ry, z-rz, red, green, blue);
  draw3d(g, x-rx, y-ry, z-rz, x-rx, y+ry, z-rz, red, green, blue);
  draw3d(g, x-rx, y-ry, z-rz, x-rx, y-ry, z+rz, red, green, blue);
  draw3d(g, x+rx, y-ry, z-rz, x+rx, y+ry, z-rz, red, green, blue);
  draw3d(g, x+rx, y-ry, z-rz, x+rx, y-ry, z+rz, red, green, blue);
  draw3d(g, x-rx, y+ry, z-rz, x+rx, y+ry, z-rz, red, green, blue);
  draw3d(g, x-rx, y+ry, z-rz, x-rx, y+ry, z+rz, red, green, blue);
  draw3d(g, x-rx, y-ry, z+rz, x+rx, y-ry, z+rz, red, green, blue);
  draw3d(g, x-rx, y-ry, z+rz, x-rx, y+ry, z+rz, red, green, blue);
  draw3d(g, x+rx, y+ry, z-rz, x+rx, y+ry, z+rz, red, green, blue);
  draw3d(g, x-rx, y+ry, z+rz, x+rx, y+ry, z+rz, red, green, blue);
  draw3d(g, x+rx, y-ry, z+rz, x+rx, y+ry, z+rz, red, green, blue);
}

int main(int argc, char** argv) {

  const int n=argc>1?atoi(argv[1]):0;  // number of black lines
  const int image_size=argc>2?atoi(argv[2]):400;  // image size
  bool three_d=false;  // 3D?

  // Read data into v[n][6]
  vector<double> x(6);
  vector<vector<double> > v;
  while (read6num(stdin, x[0], x[1], x[2], x[3], x[4], x[5]))
    v.push_back(x);
  if (size(v)<1) {
    printf("No input data\n");
    return 1;
  }

  // Scale to range 0-1
  for (int i=0; i<6; i+=2) {
    double xmin=v[0][i]-v[0][i+1], xmax=v[0][i]+v[0][i+1];
    for (int j=1; j<size(v); ++j) {
      xmin=min(v[j][i]-v[j][i+1], xmin);
      xmax=max(v[j][i]+v[j][i+1], xmax);
    }
    double scale=0;
    if (xmax>xmin) {
      scale=1/(xmax-xmin);
      if (i==4)
        three_d=true;
    }
    printf("scale=%f xmin=%f xmax=%f\n", scale, xmin, xmax);
    for (int j=0; j<size(v); ++j) {
      v[j][i]-=xmin;
      v[j][i]*=scale;
      v[j][i+1]*=scale;
    }
  }

  // Draw a 3D cube
  Image g(image_size, image_size, 255);
  if (three_d) {
    const int gray=-16;
    draw3d(g, 0, 0, 0, 1, 0, 0, gray, gray, gray);
    draw3d(g, 1, 0, 0, 1, 1, 0, gray, gray, gray);
    draw3d(g, 0, 1, 0, 0, 0, 0, gray, gray, gray);
    draw3d(g, 0, 0, 1, 1, 0, 1, gray, gray, gray);
    draw3d(g, 1, 0, 1, 1, 1, 1, gray, gray, gray);
    draw3d(g, 0, 1, 1, 0, 0, 1, gray, gray, gray);
    draw3d(g, 0, 0, 0, 0, 0, 1, gray, gray, gray);
    draw3d(g, 1, 0, 0, 1, 0, 1, gray, gray, gray);
    draw3d(g, 0, 1, 0, 0, 1, 1, gray, gray, gray);
    draw3d(g, 0, 1, 1, 1, 1, 1, gray, gray, gray);
    draw3d(g, 1, 1, 1, 1, 1, 0, gray, gray, gray);
    draw3d(g, 1, 1, 0, 0, 1, 0, gray, gray, gray);
  }

  // Draw the graph
  const int s=max(size(v)-n, 1);
  for (int i=0; i<size(v); ++i) {
    const int in   = i-n;
    const int black= -128;
    const int red  = i<n?black:-300*in/s*in/s;
    const int green= i<n?black:-900*(s/2-in)/s*(s/2-in)/s;
    const int blue = i<n?black:-300*(s-in)/s*(s-in)/s;
    if (three_d) {
      if (i>0)
        draw3d(g, v[i-1][0], v[i-1][2], v[i-1][4],
                  v[i][0], v[i][2], v[i][4], red, green, blue);
        draw3dbox(g, v[i][0], v[i][2], v[i][4], v[i][1], v[i][3], v[i][5],
                  red, green, blue);
    }
    else {
      if (i>0)
        drawline(g, v[i-1][0], v[i-1][2], v[i][0], v[i][2], red, green, blue);
      drawbox(g, v[i][0], v[i][2], v[i][1], v[i][3], red, green, blue);
    }
  }
  g.saveBMP("boxgraph.bmp");
  fprintf(stderr, "Created boxgraph.bmp\n");
    
  return 0;
}