indie-raster 0.0.1

data/src-c/commands.c

@@ -0,0 +1,148 @@
+
+#include "commands.h"
+
+
+#define LINEMAX   1000
+
+void run_commands(Session *s, FILE *f, FILE *outfile) {
+  
+  char line[LINEMAX + 1];
+  char *tok;
+  
+  while (fgets(line, LINEMAX, f)) {
+    if ((line[0] == '#') || (line[0] == 0)) {
+      continue;
+    }
+    tok = strtok(line, " \t\n");
+    if (!(tok && tok[0])) {
+      continue;
+    }
+    
+    if (strcmp(tok, "createBlank") == 0) {
+      long destId = atol(strtok(NULL, " \t\n"));
+      long w = atol(strtok(NULL, " \t\n"));
+      long h = atol(strtok(NULL, " \t\n"));
+      createBlank(s, destId, w, h);
+    }
+    else if (strcmp(tok, "exportP4") == 0) {
+      long srcId = atol(strtok(NULL, " \t\n"));
+      exportP4(s, srcId, outfile);
+    }
+    else if (strcmp(tok, "loadImage") == 0) {
+      long destId = atol(strtok(NULL, " \t\n"));
+      long size = atol(strtok(NULL, " \t\n"));
+      loadImage(s, destId, size, f);
+    }
+    else if (strcmp(tok, "loadFont") == 0) {
+      long destId = atol(strtok(NULL, " \t\n"));
+      long size = atol(strtok(NULL, " \t\n"));
+      loadFont(s, destId, size, f);
+    }
+    else if (strcmp(tok, "drawImage") == 0) {
+      long destId = atol(strtok(NULL, " \t\n"));
+      long x = atol(strtok(NULL, " \t\n"));
+      long y = atol(strtok(NULL, " \t\n"));
+      long srcId = atol(strtok(NULL, " \t\n"));
+      drawImage(s, destId, x, y, srcId);
+    }
+    else if (strcmp(tok, "drawUPC") == 0) {
+      long destId = atol(strtok(NULL, " \t\n"));
+      long x = atol(strtok(NULL, " \t\n"));
+      long y = atol(strtok(NULL, " \t\n"));
+      char *digits = strtok(NULL, " \t\n");
+      long w = atol(strtok(NULL, " \t\n"));
+      long h = atol(strtok(NULL, " \t\n"));
+      long extraHeight = atol(strtok(NULL, " \t\n"));
+      drawUPC(s, destId, x, y, digits, w, h, extraHeight);
+    }
+    else if (strcmp(tok, "drawText") == 0) {
+      long destId = atol(strtok(NULL, " \t\n"));
+      long x0 = atol(strtok(NULL, " \t\n"));
+      long y0 = atol(strtok(NULL, " \t\n"));
+      long fontId = atol(strtok(NULL, " \t\n"));
+      long numChars = atol(strtok(NULL, " \t\n"));
+      drawText(s, destId, x0, y0, fontId, numChars, f);
+    }
+  }
+}
+
+
+void createBlank(Session *s, long destId, long w, long h) {
+  Canvas *c = Canvas_new(w, h);
+  Session_setCanvas(s, destId, c);
+}
+
+
+void exportP4(Session *s, long srcId, FILE *outfile) {
+  Canvas *c = Session_getCanvas(s, srcId);
+  Canvas_writeP4(c, outfile);
+}
+
+
+void loadImage(Session *s, long destId, long size, FILE *f) {
+  Canvas *c = Canvas_readImage(f);
+  Session_setCanvas(s, destId, c);
+}
+
+
+void loadFont(Session *s, long destId, long size, FILE *f) {
+  
+  Font *font = fonts_readFont(f);
+  Session_setItem(s, destId, (void *)font);
+}
+
+void drawText(Session *s, long destId, long x0, long y0, long fontId, long numChars, FILE *f) {
+  
+  long size = numChars * 4;
+  void *text = malloc(size);
+  fread(text, 1, size, f);
+  
+  Canvas *c = Session_getCanvas(s, destId);
+  Font *font = (Font *)Session_getItem(s, fontId);
+  
+  fonts_drawText(c, font, numChars, (uint32_t*)text, x0, y0);
+  
+  free(text);
+}
+
+
+void drawImage(Session *s, long destId, long x, long y, long srcId) {
+  Canvas *src = Session_getCanvas(s, srcId);
+  Canvas *dest = Session_getCanvas(s, destId);
+  
+  Canvas_drawOnto(src, dest, x, y);
+}
+
+
+void drawUPC(Session *s, long destId, long x0, long y0, char *digits, long w, long h, long extraHeight) {
+  
+  Canvas *dest = Session_getCanvas(s, destId);
+  long y, bar, dest_x, dest_y;
+  int barWidth = w / 95;
+  
+  char *bitstring = upc_bitstring(digits);
+  
+  // This could be optimized if needed.
+  for (y = 0; y < (h + extraHeight); y++) {
+    dest_y = y + y0;
+    if (dest_y < dest->h) {
+      for (bar = 0; bar < 95; bar++) {
+        if ((y < h) || upc_bar_is_guard_bar(bar)) {
+          for (
+                  dest_x = (x0 + (barWidth * bar));
+                  dest_x < (x0 + (barWidth * (bar + 1)));
+                  dest_x++) {
+            if (dest_x < dest->w) {
+              dest->pixels[(dest_y * dest->w) + dest_x] = ((bitstring[bar] == '1')) ? 0 : 255;
+            }
+          }
+        }
+      }
+    }
+  }
+  free(bitstring);
+}
+
+
+
+

data/src-c/commands.h

@@ -0,0 +1,26 @@
+
+#ifndef COMMANDS_INCLUDED
+#define COMMANDS_INCLUDED
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "upc.h"
+#include "session.h"
+#include "canvas.h"
+#include "fonts.h"
+
+
+
+void run_commands(Session *s, FILE *f, FILE *outfile);
+void createBlank(Session *s, long destId, long w, long h);
+void exportP4(Session *s, long srcId, FILE *outfile);
+void loadImage(Session *s, long destId, long size, FILE *f);
+void loadFont(Session *s, long destId, long size, FILE *f);
+void drawText(Session *s, long destId, long x, long y, long fontId, long numChars, FILE *f);
+void drawImage(Session *s, long destId, long x, long y, long srcId);
+void drawUPC(Session *s, long destId, long x, long y, char *digits, long w, long h, long extraHeight);
+
+#endif

data/src-c/fonts.c

@@ -0,0 +1,66 @@
+
+#include "fonts.h"
+
+
+
+Font *fonts_readFont(FILE *f) {
+  
+  Font *font = (Font *)(malloc(sizeof(Font)));
+  
+  uint32_t u32, size, i;
+  
+  // "PRF1"
+  char magic[4];
+  fread(magic, 1, 4, f);
+  
+  // uint32      num_chars
+  fread(&u32, 1, 4, f);
+  font->numChars = u32;
+  
+  // uint32      image_width
+  fread(&u32, 1, 4, f);
+  font->w = u32;
+  
+  // uint32      image_height
+  fread(&u32, 1, 4, f);
+  font->h = u32;
+  
+  
+  // uint32+     char_codes
+  size = 4 * font->numChars;
+  font->codepoints = (uint32_t *)malloc(size);
+  fread(font->codepoints, 1, size, f);
+  
+  // uint32+     image_byte_offets
+  // (ignore them)
+  size = 4 * font->numChars;
+  void *temp = malloc(size);
+  fread(temp, 1, size, f);
+  free(temp);
+  
+  // data+       images
+  font->glyphs = (Canvas **)(malloc(sizeof(Canvas *) * font->numChars));
+  for (i = 0; i < font->numChars; i++) {
+    font->glyphs[i] = Canvas_readImage(f);
+  }
+  
+  return font;
+}
+
+
+void fonts_drawText(Canvas *c, Font *font, long numChars, uint32_t *text, long x0, long y0) {
+  
+  uint32_t i, j, codepoint;
+  long x = x0;
+  
+  for(i = 0; i < numChars; i++) {
+    codepoint = text[i];
+    for(j = 0; j < font->numChars; j++) {
+      if (font->codepoints[j] == codepoint) {
+        Canvas_drawOnto(font->glyphs[j], c, x, y0);
+        x += font->w;
+      }
+    }
+  }
+}
+

data/src-c/fonts.h

@@ -0,0 +1,26 @@
+
+#ifndef FONTS_INCLUDED
+#define FONTS_INCLUDED
+
+#include <stdint.h>
+#include <stdlib.h>
+#include "canvas.h"
+
+
+typedef struct {
+  
+  uint32_t numChars;
+  uint32_t w;
+  uint32_t h;
+  
+  uint32_t *codepoints;
+  Canvas **glyphs;
+  
+} Font;
+
+
+Font *fonts_readFont(FILE *f);
+void fonts_drawText(Canvas *c, Font *font, long numChars, uint32_t *text, long x0, long y0);
+
+
+#endif

data/src-c/main.c

@@ -0,0 +1,16 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "commands.h"
+#include "session.h"
+
+
+int main(int argc, char *argv[]) {
+  
+  Session *s = Session_new();
+  run_commands(s, stdin, stdout);
+  
+  return 0;
+}
+

data/src-c/make.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+gcc \
+  -o ../build-c/indie-raster \
+  canvas.c commands.c fonts.c main.c session.c upc.c pnm.c
+
+#  -O2 \
+
+
+
+# bash make.sh && cat ../example/commands2 | ../build-c/indie-raster > temp.pbm && convert temp.pbm temp.png && open temp.png

data/src-c/pnm.c

@@ -0,0 +1,109 @@
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "pnm.h"
+
+#define UTIL_PNM_LINE_MAX   100
+
+
+void util_read_pnm_header(FILE *f, int *p, long *w, long *h, int *maxValue) {
+  // Note: standard whitespace assumed
+  
+  char line[UTIL_PNM_LINE_MAX + 1];
+  char *tok;
+  
+  // "P4\n"
+  fgets(line, UTIL_PNM_LINE_MAX, f);
+  *p = line[1] - 0x30;
+  
+  // "300 200\n"
+  fgets(line, UTIL_PNM_LINE_MAX, f);
+  tok = strtok(line, " \n");
+  *w = atol(tok);
+  tok = strtok(NULL, " \n");
+  *h = atol(tok);
+  
+  if ((*p == 4) || (*p == 1)) {
+    *maxValue = 1;
+  }
+  else {
+    fgets(line, UTIL_PNM_LINE_MAX, f);
+    *maxValue = atoi(line);
+  }
+}
+
+
+//### P6
+
+void util_write_p6(FILE *f, long w, long h, unsigned char *pixels) {
+  fprintf(f, "P6\n%ld %ld\n255\n", w, h);
+  //fwrite(TODO);
+}
+
+//### P5
+
+void util_write_p5(FILE *f, long w, long h, unsigned char *pixels) {
+  fprintf(f, "P5\n%ld %ld\n255\n", w, h);
+  //fwrite(TODO);
+}
+
+//### P4
+
+void util_write_p4(FILE *f, long w, long h, unsigned char *pixels) {
+  fprintf(f, "P4\n%ld %ld\n", w, h);
+  util_write_p4_body(f, w, h, pixels);
+}
+
+
+void util_write_p4_body(FILE *f, long w, long h, unsigned char *pixels) {
+  util_write_p4_body_from_subrect(f, 0, 0, w, h, w, pixels);
+}
+
+void util_write_p4_body_from_subrect(FILE *f, long x0, long y0, long w, long h, long pixels_w, unsigned char *pixels) {
+  long pos, x, y;
+  int c, i, value;
+  c = 0;
+  for (y = y0; y < (h + y0); y++) {
+    i = 0;
+    for (x = x0; x < (w + x0); x++) {
+      pos = (y * (pixels_w)) + x;
+      value = ((pixels[pos] > 127) ? 0 : 1); // 1 is black
+      c |= (value << (7 - i));
+      
+      // Write byte?
+      if ((i == 7) || (x == ((w + x0) - 1))) {
+        fputc(c, f);
+        c = 0;
+      }
+      
+      i = (i + 1) % 8;
+    }
+  }
+}
+
+
+void util_read_p4_body(FILE *f, long w, long h, unsigned char **pixels_) {
+  
+  int i, c;
+  long x, y, pos;
+  unsigned char *pixels;
+  
+  pixels = (unsigned char *)malloc(w * h);
+  
+  pos = 0;
+  for (y = 0; y < h; y++) {
+    for (x = 0; x < w; x++) {
+      i = x % 8;
+      if (i == 0) {
+        c = fgetc(f);
+        //ASSERT c > 0
+      }
+      pixels[pos] = ((c >> (7 - i)) & 1) ? 0 : 255;
+      pos++;
+    }
+  }
+  
+  *pixels_ = pixels;
+}
+

data/src-c/pnm.h

@@ -0,0 +1,20 @@
+
+#ifndef UTIL_PNM_INCLUDED
+#define UTIL_PNM_INCLUDED
+
+#include <stdio.h>
+
+
+void util_read_pnm_header(FILE *f, int *p, long *w, long *h, int *maxValue);
+
+void util_write_p6(FILE *f, long w, long h, unsigned char *pixels);
+
+void util_write_p5(FILE *f, long w, long h, unsigned char *pixels);
+
+void util_write_p4(FILE *f, long w, long h, unsigned char *pixels);
+void util_write_p4_body(FILE *f, long w, long h, unsigned char *pixels);
+void util_write_p4_body_from_subrect(FILE *f, long x0, long y0, long w, long h, long pixels_w, unsigned char *pixels);
+void util_read_p4_body(FILE *f, long w, long h, unsigned char **pixels_);
+
+
+#endif

data/src-c/session.c

@@ -0,0 +1,36 @@
+
+#include <stdlib.h>
+#include "session.h"
+
+
+Session* Session_new() {
+  Session *s = (Session*)calloc(1, sizeof(Session));
+  return s;
+}
+
+
+void Session_free(Session **s) {
+  free(*s);
+  *s = NULL;
+}
+
+
+void Session_setCanvas(Session *s, long id, Canvas *canvas) {
+  Session_setItem(s, id, (void*)canvas);
+}
+
+
+Canvas * Session_getCanvas(Session *s, long id) {
+  return (Canvas *)Session_getItem(s, id);
+}
+
+
+void Session_setItem(Session *s, long id, void *data) {
+  s->items[id] = data;
+}
+
+
+void * Session_getItem(Session *s, long id) {
+  return s->items[id];
+}
+

data/src-c/session.h

@@ -0,0 +1,24 @@
+
+#ifndef SESSION_INCLUDED
+#define SESSION_INCLUDED
+
+#include "canvas.h"
+
+
+typedef struct {
+  
+  long numBins;
+  
+  void *items[1000];
+  
+} Session;
+
+Session* Session_new();
+void Session_free(Session **s);
+void Session_setCanvas(Session *s, long id, Canvas *canvas);
+Canvas * Session_getCanvas(Session *s, long id);
+void Session_setItem(Session *s, long id, void *data);
+void * Session_getItem(Session *s, long id);
+
+#endif
+

data/src-c/upc.c

@@ -0,0 +1,83 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "upc.h"
+
+/*
+Note: 1 is black
+
+101           0 1 2 
+0101111       3 4 5  6 7 8  9
+0101111       10
+0101111       17
+0101111       24
+0101111       31
+0101111       38 ... 44
+01010         45 ... 49
+1100110       50 ...
+1100110       57
+1100110       64
+1100110       71
+1100110       78
+1100110       85 ... 91
+101           92 93 94
+*/
+
+char *LEFT_DIGITS[] = {
+  (char*)"0001101",
+  (char*)"0011001",
+  (char*)"0010011",
+  (char*)"0111101",
+  (char*)"0100011",
+  (char*)"0110001",
+  (char*)"0101111",
+  (char*)"0111011",
+  (char*)"0110111",
+  (char*)"0001011"
+};
+
+char *RIGHT_DIGITS[] = {
+  (char*)"1110010",
+  (char*)"1100110",
+  (char*)"1101100",
+  (char*)"1000010",
+  (char*)"1011100",
+  (char*)"1001110",
+  (char*)"1010000",
+  (char*)"1000100",
+  (char*)"1001000",
+  (char*)"1110100"
+};
+
+
+int upc_bar_is_guard_bar(int bar) {
+  return (bar < (0 + 3)) || (bar > (94 - 3)) || ((bar >= 45) && (bar < (45 + 5)));
+}
+
+
+char* upc_bitstring(char *digits) {
+  
+  int i;
+  
+  // Blank string
+  char *bs = (char*)malloc(95 + 1);
+  bs[95] = 0;
+  
+  // Guard bars
+  strncpy(&(bs[0]),  "101", 3);
+  strncpy(&(bs[45]), "01010", 5);
+  strncpy(&(bs[92]), "101", 3);
+  
+  // Digits
+  for (i = 0; i < 6; i++) {
+    strncpy(&(bs[3 + 7 * i]), LEFT_DIGITS[digits[i] - 0x30], 7);
+  }
+  for (i = 0; i < 6; i++) {
+    strncpy(&(bs[50 + 7 * i]), RIGHT_DIGITS[digits[i + 6] - 0x30], 7);
+  }
+  
+  return bs;
+}
+

data/src-c/upc.h

@@ -0,0 +1,9 @@
+
+#ifndef UPC_INCLUDED
+#define UPC_INCLUDED
+
+int upc_bar_is_guard_bar(int bar);
+char* upc_bitstring(char *digits);
+
+
+#endif

data/src-ruby/indie-raster.rb

@@ -0,0 +1,95 @@
+
+require 'Open3'
+
+
+def ascii_to_utf32(str)
+  arr = []
+  str.split('').each do |c|
+    arr.push c, "\000\000\000"
+  end
+  return arr.join('')
+end
+
+def ith_byte(i, str)
+  x = str[i]
+  x = x.ord if x.class == String # Ruby 1.9+
+  return x
+end
+
+def dataFromOpt(opt)
+  if opt[:data]
+    return opt[:data]
+  elsif opt[:path]
+    File.open(opt[:path], "r") do |f|
+      return f.read
+    end
+  end
+end
+
+
+class IndieRasterSession
+
+  def initialize
+    @c = []
+    @fonts = {}
+  end
+
+  def createBlank(opt)
+    @c.push "createBlank #{opt[:id] or 1} #{opt[:w]} #{opt[:h]}\n"
+  end
+
+  def loadImage(opt)
+    data = dataFromOpt opt
+    @c.push "loadImage #{opt[:id]} #{data.length}\n"
+    @c.push data
+  end
+
+  def loadFont(opt)
+    data = dataFromOpt opt
+    @fonts[opt[:id]] = data
+    @c.push "loadFont #{opt[:id]} #{data.length}\n"
+    @c.push data
+  end
+
+  def drawImage(opt)
+    @c.push "drawImage #{opt[:on] or 1} #{opt[:x]} #{opt[:y]} #{opt[:id]}\n"
+  end
+
+  def widthOfText(opt)
+    glyphWidth = ith_byte 8, @fonts[opt[:font]] #ASSUMPTION: glyph width < 256px
+    return glyphWidth * opt[:text].length
+  end
+
+  def drawText(opt)
+    data = ascii_to_utf32 opt[:text]
+    if opt[:toLeftOf]
+      opt[:x] = opt[:toLeftOf] - self.widthOfText(opt)
+    end
+    @c.push "drawText #{opt[:on] or 1} #{opt[:x]} #{opt[:y]} #{opt[:font]} #{data.length / 4}\n"
+    @c.push data
+  end
+
+  def drawUPC(opt)
+    @c.push "drawUPC #{opt[:on] or 1} #{opt[:x]} #{opt[:y]} #{opt[:digits]} #{opt[:w]} #{opt[:h]} #{opt[:guard_bar_extra_h] or 0} #{opt[:middle_font] or 0} #{opt[:side_font] or 0}\n"
+  end
+
+  def exportP4(opt = {})
+
+    @c.push "exportP4 #{opt[:id] or 1}\n"
+
+    cmd = File.expand_path(File.dirname(__FILE__) + "/../build-c/indie-raster")
+    input = @c.join ''
+
+    stdin, stdout, stderr = Open3.popen3 cmd
+    stdin.puts input
+    stdin.close
+    code = $?.to_i
+    out = stdout.read
+    err = stderr.read
+    #TODO handle error
+
+    return out
+  end
+
+end
+