/* Textorizer2.c: writes a picture with text
 * see: http://www.w3.org/People/maxf/textorizer/ 
 * Copyright Max Froumentin 2006
 * This software is distributed under the 
 * W3C® SOFTWARE NOTICE AND LICENSE:
 * http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
 */

#include <stdlib.h>
#include <png.h>
#include <assert.h>
#include <math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

char *InFileName="in.png",*OutFileName="out.svg",*TextFileName="text.txt";

#define MAX_TEXT_LENGTH 1000000

char Text[MAX_TEXT_LENGTH];

struct pixel
{
  unsigned char r,g,b,a;
};

long Width, Height;
long svgWidth, svgHeight;
struct pixel *Pixels;
double FontSize=10;
double saturationAdjust=0.2;

/* we need a table of character widths. Ugly, but it does'nt seen we can
 * do better than that in SVG for this purpose. TODO use the sera SVG font
 * <http://www.w3.org/2003/08/sera/sera.svg> and parse the file to retrieve
 * each character's widths
 */
double CharWidths[256];

void setCharWidths(void) 
{
  CharWidths[' ']=651/2048.0;
  CharWidths['!']=821/2048.0;
  CharWidths['"']=942/2048.0;
  CharWidths['#']=1716/2048.0;
  CharWidths['$']=1303/2048.0;
  CharWidths['%']=1946/2048.0;
  CharWidths['&']=1597/2048.0;
  CharWidths[44]=563/2048.0; /* ' */
  CharWidths['(']=799/2048.0;
  CharWidths[')']=799/2048.0;
  CharWidths['*']=1024/2048.0;
  CharWidths['+']=1716/2048.0;
  CharWidths[',']=651/2048.0;
  CharWidths['-']=739/2048.0;
  CharWidths['.']=651/2048.0;
  CharWidths['/']=690/2048.0;
  CharWidths['0']=1303/2048.0;
  CharWidths['1']=1303/2048.0;
  CharWidths['2']=1303/2048.0;
  CharWidths['3']=1303/2048.0;
  CharWidths['4']=1303/2048.0;
  CharWidths['5']=1303/2048.0;
  CharWidths['6']=1303/2048.0;
  CharWidths['7']=1303/2048.0;
  CharWidths['8']=1303/2048.0;
  CharWidths['9']=1303/2048.0;
  CharWidths[':']=690/2048.0;
  CharWidths[';']=690/2048.0;
  CharWidths['<']=1716/2048.0;
  CharWidths['=']=1716/2048.0;
  CharWidths['>']=1716/2048.0;
  CharWidths['?']=1087/2048.0;
  CharWidths['@']=2048/2048.0;
  CharWidths['A']=1401/2048.0;
  CharWidths['B']=1405/2048.0;
  CharWidths['C']=1430/2048.0;
  CharWidths['D']=1577/2048.0;
  CharWidths['E']=1294/2048.0;
  CharWidths['F']=1178/2048.0;
  CharWidths['G']=1587/2048.0;
  CharWidths['H']=1540/2048.0;
  CharWidths['I']=604/2048.0;
  CharWidths['J']=604/2048.0;
  CharWidths['K']=1343/2048.0;
  CharWidths['L']=1141/2048.0;
  CharWidths['M']=1767/2048.0;
  CharWidths['N']=1532/2048.0;
  CharWidths['O']=1612/2048.0;
  CharWidths['P']=1235/2048.0;
  CharWidths['Q']=1612/2048.0;
  CharWidths['R']=1423/2048.0;
  CharWidths['S']=1300/2048.0;
  CharWidths['T']=1251/2048.0;
  CharWidths['U']=1499/2048.0;
  CharWidths['V']=1401/2048.0;
  CharWidths['W']=2025/2048.0;
  CharWidths['X']=1403/2048.0;
  CharWidths['Y']=1251/2048.0;
  CharWidths['Z']=1403/2048.0;
  CharWidths['[']=799/2048.0;
  CharWidths[92]=690/2048.0; /* '\' */
  CharWidths[']']=799/2048.0;
  CharWidths['^']=1716/2048.0;
  CharWidths['_']=1024/2048.0;
  CharWidths['`']=1024/2048.0;
  CharWidths['a']=1255/2048.0;
  CharWidths['b']=1300/2048.0;
  CharWidths['c']=1126/2048.0;
  CharWidths['d']=1300/2048.0;
  CharWidths['e']=1260/2048.0;
  CharWidths['f']=721/2048.0;
  CharWidths['g']=1300/2048.0;
  CharWidths['h']=1298/2048.0;
  CharWidths['i']=569/2048.0;
  CharWidths['j']=569/2048.0;
  CharWidths['k']=1186/2048.0;
  CharWidths['l']=569/2048.0;
  CharWidths['m']=1995/2048.0;
  CharWidths['n']=1298/2048.0;
  CharWidths['o']=1253/2048.0;
  CharWidths['p']=1300/2048.0;
  CharWidths['q']=1300/2048.0;
  CharWidths['r']=842/2048.0;
  CharWidths['s']=1067/2048.0;
  CharWidths['t']=803/2048.0;
  CharWidths['u']=1298/2048.0;
  CharWidths['v']=1212/2048.0;
  CharWidths['w']=1675/2048.0;
  CharWidths['x']=1212/2048.0;
  CharWidths['y']=1212/2048.0;
  CharWidths['z']=1075/2048.0;
  CharWidths['{']=1303/2048.0;
  CharWidths['|']=690/2048.0;
  CharWidths['}']=1303/2048.0;
  CharWidths['~']=1716/2048.0;
}
 





#ifndef png_jmpbuf
#  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
#endif

#define PNG_BYTES_TO_CHECK 8
int check_if_png(char *file_name, FILE **fp)
{
   unsigned char buf[PNG_BYTES_TO_CHECK];

   /* Open the prospective PNG file. */
   if ((*fp = fopen(file_name, "rb")) == NULL)
      return 0;

   /* Read in some of the signature bytes */
   if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK)
      return 0;

   /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.
      Return nonzero (true) if they match */
   
   /* extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); */
   
   return(!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK));
}

int loadpng(FILE *fp)
{
  unsigned long i,j,k;
  png_structp png_ptr;
  png_infop info_ptr;
  png_uint_32 width, height;
  png_bytep *row_pointers;
  int bit_depth, color_type;
  int interlace_type, compression_type, filter_type;


  /* create the png data structures */
  png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
  if (!png_ptr) return 0;

  info_ptr = png_create_info_struct(png_ptr);
  if (!info_ptr) {
    png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
    return 0;
  }

  if (setjmp(png_jmpbuf(png_ptr))) {
    png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
    return 0;
  }
  
  png_init_io(png_ptr, fp);

  /* read file information */

   /* If we have already read some of the signature */
   png_set_sig_bytes(png_ptr, 8);

  png_read_info(png_ptr, info_ptr);
  png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, 
               &interlace_type, &compression_type, &filter_type);

  printf("* reading PNG image (");
  printf("%ldx%ld, %d bit, ",width,height,bit_depth);
  switch (color_type) {
  case PNG_COLOR_TYPE_GRAY: printf("grey levels, "); break;
  case PNG_COLOR_TYPE_PALETTE: printf("palette, "); break;
  case PNG_COLOR_TYPE_RGB: printf("RGB, "); break;
  case PNG_COLOR_TYPE_RGB_ALPHA: printf("RGBA, "); break;
  case PNG_COLOR_TYPE_GRAY_ALPHA: printf("grey levels + alpha, "); break;
  }
  switch (interlace_type) {
  case PNG_INTERLACE_NONE: printf("not interlaced, "); break;
  case PNG_INTERLACE_ADAM7: printf("ADAM7-interlaced, "); break;
  }
  switch (compression_type) {
  case PNG_COMPRESSION_TYPE_BASE: printf(" compressed, "); break;
  }
  switch (filter_type) {
  case PNG_FILTER_TYPE_BASE: printf(" filtered, ");
  }
  printf(")\n");


  /* tell libpng to strip 16 bit/color files down to 8 bits/color */
  png_set_strip_16(png_ptr);

  /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
   * byte into separate bytes (useful for paletted and grayscale images).
   */
  png_set_packing(png_ptr);
  
  /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
  if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
    png_set_expand(png_ptr);
  
  /* Expand paletted colors into true RGB triplets */
  if (color_type == PNG_COLOR_TYPE_PALETTE)
    png_set_expand(png_ptr);
  
  /* Expand paletted or RGB images with transparency to full alpha channels
   * so the data will be available as RGBA quartets.
   */
  if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
    png_set_expand(png_ptr);
  
  /* Add filler (or alpha) byte (before/after each RGB triplet) */
/*    if (bit_depth == 8 &&  */
/*        (color_type == PNG_COLOR_TYPE_RGB||color_type == PNG_COLOR_TYPE_GRAY)) */
  png_set_filler(png_ptr, 0x000000ff, PNG_FILLER_AFTER);  
  
  /* update info_ptr from the transforms. used to get a correct value for
   * png_get_rowbytes */
  png_read_update_info(png_ptr, info_ptr);

  /* allocate the memory to hold a row of the image */
  row_pointers = (png_bytep *)malloc(height*sizeof(png_bytep));
  for (i = 0; i < height; i++)
    row_pointers[i] = malloc(png_get_rowbytes(png_ptr, info_ptr));

  png_read_image(png_ptr, row_pointers);

  /* malloc pixmap data */
  Width = width;
  Height = height;
  assert(Pixels = (struct pixel *)malloc((size_t)Width*
                                         (size_t)Height*
                                         sizeof(struct pixel)));
  k=0;
  for (i=0;i<Height;i++)
    for (j=0;j<Width;j++) {
      Pixels[k].r = row_pointers[i][4*j];
      Pixels[k].g = row_pointers[i][4*j+1];
      Pixels[k++].b = row_pointers[i][4*j+2];
    }
  /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
  png_read_end(png_ptr, info_ptr);
  
  /* clean up after the read, and free any memory allocated - REQUIRED */
  png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);

  for (i = 0; i < height; i++)
    free(row_pointers[i]);
  free(row_pointers);
  return 1;
}       

void readText(void)
{
  FILE *f;
  if ((f = fopen(TextFileName, "r"))==NULL) {
    fprintf(stderr,"couldn't open file '%s'. Aborting.\n",TextFileName);
    exit(-1);
  }
  fgets(Text, MAX_TEXT_LENGTH, f);
  fclose(f);
}



/* return average of r,g,b at pixel x,y */
int pixelAt(int x, int y)
{
  if (x<0) x=0;
  if (x>=Width) x=Width-1;
  if (y<0) y=0;
  if (y>=Height) y=Height-1;
    
    
  return (int)rint((Pixels[y*Width+x].r+Pixels[y*Width+x].g+Pixels[y*Width+x].b)/3);
}

int rAt(int x, int y) { return Pixels[y*Width+x].r; }
int gAt(int x, int y) { return Pixels[y*Width+x].g; }
int bAt(int x, int y) { return Pixels[y*Width+x].b; }

/* @@TODO average 9 neighbouring pixels 
int rAtD(int x, int y) { return MAX(Pixels[y*Width+x].r-30,0); }
int gAtD(int x, int y) { return MAX(Pixels[y*Width+x].g-30,0); }
int bAtD(int x, int y) { return MAX(Pixels[y*Width+x].b-30,0); }
*/

/* convert RGB to HSV */
#define MAX(x,y,z) (x>y&&x>z)?x:((y>z)?y:z)
#define MIN(x,y,z) (x<y&&x<z)?x:((y<z)?y:z)

void rgb2hsv( int r, int g, int b, double *h, double *s, double *v ) {
  double R=r/255.0, G=g/255.0, B=b/255.0;
  double max=MAX(R,G,B), min=MIN(R,G,B);
  if (max==R && G>=B) *h=60.0*(G-B)/(max-min);
  else if (max==R && G<B) *h=60.0*(G-B)/(max-min)+360.0;
  else if (max==G) *h=60.0*(B-R)/(max-min)+120.0;
  else if (max==B) *h=60.0*(R-G)/(max-min)+240.0;
  *s=(max-min)/max;
  *v=max;
}

void hsv2rgb( int *r, int *g, int *b, double H, double S, double V ) {
  int Hi=(int)floor(H/60.0)%6;
  double f=H/60-Hi;
  double p=V*(1-S);
  double q=V*(1-f*S);
  double t=V*(1-(1-f)*S);
  double R,G,B;
  switch (Hi) {
  case 0: R=V;G=t;B=p;break;
  case 1: R=q;G=V;B=p;break;
  case 2: R=p;G=V;B=t;break;
  case 3: R=p;G=q;B=V;break;
  case 4: R=t;G=p;B=V;break;
  case 5: R=V;G=p;B=q;break;
  }
  *r=R*255;    *g=G*255;    *b=B*255;
} 



void make_svg(char* svgfn) 
{
  int x,y,ti=0;
  double rx;

  long w=(svgWidth!=0)?svgWidth:Width;
  long h=(svgHeight!=0)?svgHeight:Height;

  FILE *svgf=fopen(svgfn,"w");

  fprintf(svgf,"<?xml version='1.0'?>\n");

  fprintf(svgf,"<!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 20010904//EN' \n");
  fprintf(svgf,"  'http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd'>\n");


  fprintf(svgf,"<svg width='%ldpx' height='%ldpx' viewBox='0 0 %ld %ld'\n",w,h,Width,Height);
  fprintf(svgf,"     xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'>\n");
  fprintf(svgf,"  <desc>Bitmap to Letters demo</desc>\n");
  fprintf(svgf,"\n");
  fprintf(svgf,"<g font-family='Vera Sans' font-weight='bold' font-size='%g' fill='black'>\n",FontSize); 

  int stepy=FontSize*1.2;
  int nbletters=strlen(Text);
  /* and now for the meaty stuff */

  for (y=0;y<Height;y+=stepy) { 
    rx=1;
    while (rx<Width) {
      x=(int)floor(rx)-1;

      double scale=2-((rAt(x,y)+gAt(x,y)+bAt(x,y))/(3*256.0));
      char c=Text[ti%nbletters];
      
      int r=rAt(x,y),g=gAt(x,y),b=bAt(x,y);

      if (r+g+b<3*255) { /* eliminate white */
        /* increase the colour's saturation to compensate for mixing with white */
        double h,s,v;
        rgb2hsv(r,g,b,&h,&s,&v);
        if (s!=0) {
          s=(s+saturationAdjust)>1.0?1.0:(s+saturationAdjust);
          hsv2rgb(&r,&g,&b,h,s,v);
        }
        fprintf(svgf,"<text x='%g' y='%d' font-size='%g' fill='#%02x%02x%02x'>%c</text>\n",rx,y,FontSize*scale,r,g,b,c);
        rx+=scale*CharWidths[(int)c]*FontSize;
        ti++; /* next letter */
      } 
      else /* advance one em */
        rx+=scale*CharWidths['m']*FontSize;
    }
  }
  fprintf(svgf,"  </g>\n");
  fprintf(svgf,"</svg>\n");
  fclose(svgf);
}

int main(int argc, char **argv)
{
  FILE *f;
  int i;
  
  if (argc==1 || !strcmp(argv[1],"-h")) {
    fprintf(stderr, "textorizer2 version $Id: textorizer2.c,v 1.4 2006/04/27 10:29:01 mf Exp $\n<http://www.w3.org/People/maxf/textorizer>\n");
    fprintf(stderr,"usage: %s [options]\n",argv[0]);
    fprintf(stderr,"  -o <string> : SVG output file name (default: out.svg)\n");
    fprintf(stderr,"  -i <string> : PNG input file name (default: in.png)\n");
    fprintf(stderr,"  -f <number> : font size (default: 10)\n");
    fprintf(stderr,"  -t <string> : text file name (default: text.txt)\n");
    fprintf(stderr,"  -s <number> : colour adjustment (default: 0.2)\n");
    fprintf(stderr,"  -w <integer> : width of SVG image in pixels (default: input width)\n");
    fprintf(stderr,"  -h <integer> : height of SVG image in pixels (default: input height)\n");
    return 0;
  }

  for (i=1;i<argc;i++) {
    if (!strcmp(argv[i],"-f")) { FontSize=atof(argv[++i]); continue; }
    if (!strcmp(argv[i],"-i")) { InFileName=argv[++i]; continue; }
    if (!strcmp(argv[i],"-o")) { OutFileName=argv[++i]; continue; }
    if (!strcmp(argv[i],"-t")) { TextFileName=argv[++i]; continue; }
    if (!strcmp(argv[i],"-s")) { saturationAdjust=atof(argv[++i]); continue; }
    if (!strcmp(argv[i],"-w")) { svgWidth=atoi(argv[++i]); continue; }
    if (!strcmp(argv[i],"-h")) { svgHeight=atoi(argv[++i]); continue; }
  }

  check_if_png(InFileName, &f);
  assert(loadpng(f));
  fclose(f);

  readText();
  setCharWidths();

  make_svg(OutFileName);
  return 0;
}