chiark / gitweb /
Merge branch 'origin'
authorIan Jackson <ian@liberator.relativity.greenend.org.uk>
Sun, 19 Jul 2009 16:35:21 +0000 (17:35 +0100)
committerIan Jackson <ian@liberator.relativity.greenend.org.uk>
Sun, 19 Jul 2009 16:35:21 +0000 (17:35 +0100)
pctb/common.h
pctb/convert.c
pctb/convert.h
pctb/ocr.c
pctb/pages.c
pctb/rgbimage.c
pctb/structure.c
pctb/structure.h
pctb/x.gdb

index 1fb7e11..9d06fab 100644 (file)
@@ -53,7 +53,6 @@
 
 typedef struct {
   int w,h;
-  const struct RgbImage *rgb;
   char d[];
 } CanonImage;
 
index 4fdb063..1f13850 100644 (file)
@@ -36,28 +36,12 @@ const char *get_vardir(void) { return "."; }
 const char *get_libdir(void) { return "."; }
 
 
-enum mode {
-  mf_findwindow=      00001,
-  mf_screenshot=      00010,
-  mf_readscreenshot=  00020,
-  mf_analyse=         00100,
-  mfm_special=        07000,
-  
-  mode_findwindow=    00001,
-  mode_screenshot=    00011,
-  mode_analyse=       00120,
-  mode_showcharset=   01000,
-
-  mode_all=           00111,
-};
-
 enum outmodekind {
   omk_unset, omk_upload, omk_str, omk_raw, omk_none
 };
 static enum outmodekind o_outmode_kind;
 static const char *o_outmode_str= 0;
 
-static enum mode o_mode= mode_all;
 static char *o_screenshot_fn;
 static const char *o_serv_pctb, *o_serv_dict_fetch, *o_serv_dict_submit;
 
@@ -68,6 +52,7 @@ int o_quiet;
 
 static pid_t screenshot_compressor=-1;
 
+enum mode o_mode= mode_all;
 enum flags o_flags=
    ff_charset_allowedit |
    ff_dict_fetch|ff_dict_submit|ff_dict_pirate;
index 0dc2255..11f534b 100644 (file)
 
 #define MAXIMGIDENT 100
 
+typedef uint32_t Rgb; /* red<<0 | green<<8 | blue<<16 */
+
 typedef struct RgbImage {
   int w, h;
-  unsigned char data[];
-  /* red   = data[ y*w*3 + x*3 + 0 ] = RI_PIXEL(ri,x,y)[0]
-   * green = data[ y*w*3 + x*3 + 1 ] = RI_PIXEL(ri,x,y)[1]
-   * blue  = data[ y*w*3 + x*3 + 2 ] = RI_PIXEL(ri,x,y)[2]
-   */
+  Rgb data[]; /* data[ y*w + x ] */
 } RgbImage;
 
-typedef unsigned long Rgb;
-
 void identify_rgbimage(const RgbImage *base, Rect portion,
                       char result[MAXIMGIDENT], const char *what);
 RgbImage *alloc_rgb_image(int w, int h);
 void fwrite_ppmraw(FILE *f, const RgbImage *ri);
 
-#define RI_PIXEL(ri,x,y) ((ri)->data + ((y)*(ri)->w + (x)) * 3)
+#define RI_PIXEL32(ri,x,y) ((ri)->data + ((y)*(ri)->w + (x)))
 
 static inline Rgb ri_rgb(const RgbImage *ri, int x, int y) {
-  const unsigned char *rip= RI_PIXEL(ri,x,y);
-  return (rip[0] << 16) |
-         (rip[1] <<  8) |
-         (rip[2]      );
+  return *RI_PIXEL32(ri,x,y);
 }
 
 /*----- from structure.c -----*/
 
-void find_structure(CanonImage *im, int *max_relevant_y_r,
+typedef struct PageStruct PageStruct;
+
+void find_structure(const CanonImage *im,
+                   PageStruct **pagestruct_r, /* caller must free() */
+                   int *max_relevant_y_r,
                    Point *commod_focus_point_r,
                    Point *commod_page_point_r,
                    Point *commod_focuslast_point_r);
+void store_current_page(CanonImage *ci /*pointer saved*/,
+                       PageStruct *pagestruct, /*freed*/
+                       RgbImage *rgb /*freed*/);
+void adjust_colours(CanonImage *ci, const RgbImage *rgb);
+
+void select_page(int page);
+
 Rect find_sunshine_widget(void);
 
 void canon_colour_prepare(void);
@@ -122,6 +126,22 @@ enum flags {
 };
 extern enum flags o_flags;
 
+enum mode {
+  mf_findwindow=      00001,
+  mf_screenshot=      00010,
+  mf_readscreenshot=  00020,
+  mf_analyse=         00100,
+  mfm_special=        07000,
+  
+  mode_findwindow=    00001,
+  mode_screenshot=    00011,
+  mode_analyse=       00120,
+  mode_showcharset=   01000,
+
+  mode_all=           00111,
+};
+extern enum mode o_mode;
+
 extern const char *o_ocean, *o_pirate;
 extern int o_quiet;
 
@@ -134,7 +154,9 @@ void take_screenshots(void);
 void take_one_screenshot(void);
 
 #define MAX_PAGES 1000
-extern CanonImage *page_images[MAX_PAGES];
+
+extern const CanonImage *page_images[MAX_PAGES];
+extern const RgbImage *page0_rgbimage;
 extern int npages;
 
 extern const char *ocean, *pirate;
index f7cb450..92b0903 100644 (file)
@@ -397,7 +397,7 @@ static DatabaseNode *findchar_1ctx(const FindCharArgs *fca,
   int x= fca->x;
 
   for (;;) {
-    debug_flush();
+    if (DEBUGP(ocr)) debug_flush();
     debugf(" | x=%d",x);
     if (x > fca->w) break;
     Pixcol cv= fca->cols[x];
@@ -531,7 +531,7 @@ OcrResultGlyph *ocr(OcrReader *rd, OcrCellType ct, int w,
 
   x=0;
   for (;;) {
-    debug_flush();
+    if (DEBUGP(ocr)) debug_flush();
     /* skip spaces */
     if (x>=w)
       break;
index 9e7a2b2..2e3edde 100644 (file)
@@ -41,9 +41,6 @@
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
-CanonImage *page_images[MAX_PAGES];
-int npages;
-
 const char *ocean, *pirate;
 
 static XWindowAttributes attr;
@@ -267,9 +264,9 @@ static void snapshot(Snapshot **output) {
 
 #define COMPUTE_SHIFT_MASK(ix, rgb) \
   compute_shift_mask(&shiftmasks[ix], im_use->rgb##_mask)
-  COMPUTE_SHIFT_MASK(0, red);
+  COMPUTE_SHIFT_MASK(0, blue);
   COMPUTE_SHIFT_MASK(1, green);
-  COMPUTE_SHIFT_MASK(2, blue);
+  COMPUTE_SHIFT_MASK(2, red);
   
   if (!*output)
     *output= alloc_rgb_image(wwidth, wheight);
@@ -277,7 +274,7 @@ static void snapshot(Snapshot **output) {
   rtimestamp(&begin, "compute_shift_masks+alloc_rgb_image");
 
   int x,y,i;
-  unsigned char *op= (*output)->data;
+  uint32_t *op32= (*output)->data;
   for (y=0; y<wheight; y++) {
     if (im_use->xoffset == 0 &&
        im_use->format == ZPixmap &&
@@ -289,21 +286,19 @@ static void snapshot(Snapshot **output) {
        im_use->blue_mask  == 0xff0000U) {
       const char *p= im_use->data + y * im_use->bytes_per_line;
 //      debugf("optimised copy y=%d",y);
-      for (x=0; x<wwidth; x++) {
-       *op++ = *p++;
-       *op++ = *p++;
-       *op++ = *p++;
-       p++;
-      }
+      memcpy(op32, p, wwidth*sizeof(*op32));
+      op32 += wwidth;
     } else {
       for (x=0; x<wwidth; x++) {
        long xrgb= XGetPixel(im_use,x,y);
+       Rgb sample= 0;
        for (i=0; i<3; i++) {
-         unsigned long sample=
+         sample <<= 8;
+         sample |=
            ((xrgb << shiftmasks[i].lshift) >> shiftmasks[i].rshift)
            & SAMPLEMASK;
-         *op++= sample;
        }
+       *op32++= sample;
       }
     }
   }
@@ -355,7 +350,7 @@ static void wait_for_stability(Snapshot **output,
          "  last_input=%f previously=%p `%s'\n",
          last_input, previously, doing);
 
-  double min_interval= 0.025; /*us*/
+  double min_interval= 0.025;
   for (;;) {
     progress_spinner("%s",doing);
     
@@ -520,21 +515,23 @@ static void set_focus_commodity(void) {
   debugf("PAGING raise_and_set_focus done.\n");
 }
 
-static CanonImage *convert_page(const Snapshot *sn) {
+static CanonImage *convert_page(const Snapshot *sn, RgbImage **rgb_r) {
   CanonImage *im;
+  RgbImage *ri;
 
   fwrite_ppmraw(screenshot_file, sn);
 
-  const unsigned char *pixel= sn->data;
-  CANONICALISE_IMAGE(im, sn->w, sn->h, {
-    r= *pixel++;
-    g= *pixel++;
-    b= *pixel++;
+  const Rgb *pixel= sn->data;
+  CANONICALISE_IMAGE(im, sn->w, sn->h, ri, {
+    rgb= *pixel++;
   });
-    
+
   sysassert(!ferror(screenshot_file));
   sysassert(!fflush(screenshot_file));
 
+  if (rgb_r) *rgb_r= ri;
+  else free(ri);
+
   return im;
 }
 
@@ -546,8 +543,8 @@ static void prepare_ypp_client(void) {
   raise_and_get_details();
   wait_for_stability(&current,0,0, "checking current YPP client screen...");
 
-  test= convert_page(current);
-  find_structure(test, &max_relevant_y,
+  test= convert_page(current,0);
+  find_structure(test,0, &max_relevant_y,
                 &commod_focus_point,
                 &commod_page_point,
                 &commod_focuslast_point);
@@ -577,6 +574,20 @@ static void prepare_ypp_client(void) {
   free_snapshot(&status);
 }
 
+static void convert_store_page(Snapshot *current) {
+  RgbImage *rgb;
+  CanonImage *ci;
+  PageStruct *pstruct;
+  
+  progress("page %d prescanning   ...",npages);
+  ci= convert_page(current,&rgb);
+
+  progress("page %d overview      ...",npages);
+  find_structure(ci,&pstruct, 0,0,0,0);
+
+  store_current_page(ci,pstruct,rgb);
+}
+
 void take_screenshots(void) {
   Snapshot *current=0, *last=0;
 
@@ -589,19 +600,19 @@ void take_screenshots(void) {
 
   /* now to actually page down */
   for (;;) {
-    debugf("paging page %d\n",npages);
+    debugf("page %d paging\n",npages);
 
     if (!(npages < MAX_PAGES))
       fatal("Paging down seems to generate too many pages - max is %d.",
            MAX_PAGES);
-    
-    page_images[npages]= convert_page(current);
+
+    convert_store_page(current);
     free_snapshot(&last); last=current; current=0;
 
     debugf("PAGING page %d converted\n",npages);
 
     wait_for_stability(&current,last, 0,
-                      "collecting screenshot of page %d...",
+                      "page %d collecting    ...",
                       npages+1);
 
     if (npages &&  /* first pagedown doesn't do much */
@@ -629,7 +640,7 @@ void take_one_screenshot(void) {
 
   prepare_ypp_client();
   wait_for_stability(&current,0,0, "taking screenshot...");
-  page_images[0]= convert_page(current);
+  convert_store_page(current);
   npages= 1;
   progress_log("collected single screenshot.");
 }
index 81eddf9..dc9fa68 100644 (file)
@@ -85,14 +85,16 @@ static int identify1(const RgbImage *base, Rect portion,
     int x,y,i;
     for (y=0; y<h; y++) {
       for (x=0; x<w; x++) {
+       uint32_t rgb=0;
        for (i=0; i<3; i++) {
          int c;
          dbassert( dbfile_scanf("%d",&c) == 1);
          dbassert(c>=0 && c<=255);
-         int px= portion.tl.x + x, py= portion.tl.y + y;
-         diff |= px > portion.br.x || py > portion.br.y ||
-                 (c != RI_PIXEL(base,px,py)[i]);
+         rgb |= (Rgb)c << (i*8);
        }
+       int px= portion.tl.x + x, py= portion.tl.y + y;
+       diff |= px > portion.br.x || py > portion.br.y ||
+               rgb != ri_rgb(base,px,py);
       }
     }
     if (!diff) {
@@ -116,12 +118,17 @@ static int identify(const RgbImage *base, Rect portion,
 }
 
 void fwrite_ppmraw(FILE *f, const RgbImage *ri) {
+  int i;
   fprintf(f,
          "P6\n"
          "%d %d\n"
          "255\n", ri->w, ri->h);
-  int count= ri->w * ri->h * 3;
-  sysassert( fwrite(ri->data, 1, count, f) == count );
+  for (i=0; i < ri->w * ri->h; i++) {
+    Rgb rgb= ri->data[i];
+    fputc_unlocked(rgb >> 0,  f);
+    fputc_unlocked(rgb >> 8,  f);
+    fputc_unlocked(rgb >> 16, f);
+  }
   sysassert(!ferror(f));
   sysassert(!fflush(f));
 }
@@ -132,8 +139,9 @@ static void fwrite_ppm(FILE *f, const RgbImage *base, Rect portion) {
   for (y=portion.tl.y; y<=portion.br.y; y++) {
     for (x=portion.tl.x; x<=portion.br.x; x++) {
       putc(' ',f);
+      Rgb rgb= ri_rgb(base,x,y);
       for (i=0; i<3; i++)
-       fprintf(f," %3d", RI_PIXEL(base,x,y)[i]);
+       fprintf(f," %3d", (rgb>>(i*8)) & 0xff);
     }
     putc('\n',f);
   }
@@ -173,7 +181,7 @@ void identify_rgbimage(const RgbImage *base, Rect portion,
 
 RgbImage *alloc_rgb_image(int w, int h) {
   RgbImage *ri;
-  ri= mmalloc(sizeof(*ri) + w*h*3);
+  ri= mmalloc(sizeof(*ri) + w*h*sizeof(ri->data[0]));
   ri->w= w;
   ri->h= h;
   return ri;
index ad95cb5..f10addc 100644 (file)
 
 #include "structure.h"
 
-static CanonImage *cim;
-
-static inline char get(int x, int y) { return cim->d[y * cim->w + x]; }
-static inline char get_p(Point p) { return get(p.x,p.y); }
-
 DEBUG_DEFINE_DEBUGF(struct)
 
 #define START_MAIN {200,200}
@@ -40,19 +35,39 @@ DEBUG_DEFINE_DEBUGF(struct)
 #define TEXT_COLUMNS        2
 #define MAX_COLUMNS         7
 
-static Rect mainr;
-static int commbasey, comminty;
-static int colrightx[INTERESTING_COLUMNS];
+struct PageStruct {
+  Rect mr;
+  int commbasey, comminty;
+  int colrightx[INTERESTING_COLUMNS];
+};
+
+const CanonImage *page_images[MAX_PAGES];
+static PageStruct page_structs[MAX_PAGES];
+const RgbImage *page0_rgbimage;
+int npages;
+
 static int text_h=-1, columns=-1;
+
 static OcrReader *rd;
 
+static const CanonImage *cim;
+static PageStruct s;
+
 char *archipelago, *island;
 
 #define OTHERCOORD_x y
 #define OTHERCOORD_y x
 
+
+void select_page(int page) {
+  cim= page_images[page];
+  s= page_structs[page];
+  assert(cim);
+}
+
+
 typedef struct {
-  Rgb rgb; /* on screen */
+  Rgb rgbx; /* on screen, REVERSED BYTES ie r||g||b */
   char c; /* canonical */
 } CanonColourInfo;
 
@@ -99,9 +114,9 @@ CanonColourInfoReds canoncolourinfo_tree;
 void canon_colour_prepare(void) {
   const CanonColourInfo *cci;
   for (cci=canoncolourinfo_table; cci->c; cci++) {
-    unsigned char r= cci->rgb >> 16;
-    unsigned char g= cci->rgb >>  8;
-    unsigned char b= cci->rgb;
+    unsigned char r= cci->rgbx >> 16;
+    unsigned char g= cci->rgbx >>  8;
+    unsigned char b= cci->rgbx;
 
     CanonColourInfoGreens *greens= canoncolourinfo_tree.red2[r];
     if (!greens) {
@@ -119,6 +134,9 @@ void canon_colour_prepare(void) {
   }
 }
 
+static inline char get(int x, int y) { return cim->d[y * cim->w + x]; }
+static inline char get_p(Point p) { return get(p.x,p.y); }
+
 
 static void mustfail1(const char *file, int line, const char *what) {
   fprintf(stderr,
@@ -142,7 +160,7 @@ static void mustfail2(void) {
 }
 
 #define MUST(x, ifnot) do{                     \
-    if (!(x)) {                                        \
+    if (__builtin_expect(!(x), 0)) {           \
       mustfail1(__FILE__,__LINE__,#x);         \
       ifnot;                                   \
       mustfail2();                             \
@@ -152,7 +170,7 @@ static void mustfail2(void) {
 #define MP(v) fprintf(stderr," %s=%d,%d",#v,(v).x,(v).y)
 #define MI(v) fprintf(stderr," %s=%d",   #v,(v))
 #define MIL(v) fprintf(stderr," %s=%ld", #v,(v))
-#define MRGB(v) fprintf(stderr," %s=%06lx", #v,(v))
+#define MRGB(v) fprintf(stderr," %s=%06"PRIx32, #v,(v))
 #define MC(v) fprintf(stderr," %s='%c'", #v,(v))
 #define MS(v) fprintf(stderr," %s=\"%s\"", #v,(v))
 #define MF(v) fprintf(stderr," %s=%f", #v,(v))
@@ -255,12 +273,15 @@ static int commod_selector_matches(Rect search, const char *const *all,
     (search).TLBR.XY += increm;                                                      \
   }
 
-void find_structure(CanonImage *im, int *max_relevant_y_r,
+void find_structure(const CanonImage *im,
+                   PageStruct **pagestruct_r,
+                   int *max_relevant_y_r,
                    Point *commod_focus_point_r,
                    Point *commod_page_point_r,
                    Point *commod_focuslast_point_r) {
   cim= im;
-  
+
+  FILLZERO(s);
   Rect whole = { {0,0}, {cim->w-1,cim->h-1} };
 
   if (DEBUGP(rect)) {
@@ -276,44 +297,44 @@ void find_structure(CanonImage *im, int *max_relevant_y_r,
   }
 
   Point mainr_tl= START_MAIN;
-  mainr.tl= mainr_tl;
-  WALK_UNTIL_MUST(mainr.tl, y,-1, whole.tl.y, ' ');
-  mainr.br= mainr.tl;
+  s.mr.tl= mainr_tl;
+  WALK_UNTIL_MUST(s.mr.tl, y,-1, whole.tl.y, ' ');
+  s.mr.br= s.mr.tl;
 
-  WALK_UNTIL_MUST(mainr.tl, x,-1, whole.tl.x, '*');
-  WALK_UNTIL_MUST(mainr.tl, y,-1, whole.tl.y, '*');
-  WALK_UNTIL_MUST(mainr.br, x,+1, whole.br.x, '*');
-  WALK_UNTIL_MUST(mainr.br, y,+1, whole.br.y, '*');
+  WALK_UNTIL_MUST(s.mr.tl, x,-1, whole.tl.x, '*');
+  WALK_UNTIL_MUST(s.mr.tl, y,-1, whole.tl.y, '*');
+  WALK_UNTIL_MUST(s.mr.br, x,+1, whole.br.x, '*');
+  WALK_UNTIL_MUST(s.mr.br, y,+1, whole.br.y, '*');
 
-  REQUIRE_RECTANGLE(mainr.tl.x-1, mainr.tl.y, mainr.tl.x-1, mainr.br.y, "*");
-  REQUIRE_RECTANGLE(mainr.br.x+1, mainr.tl.y, mainr.br.x+1, mainr.br.y, "*");
-  REQUIRE_RECTANGLE(mainr.tl.x, mainr.tl.y-1, mainr.br.x, mainr.tl.y-1, "*");
-  REQUIRE_RECTANGLE(mainr.tl.x, mainr.br.y+1, mainr.br.x, mainr.br.y+1, "*");
+  REQUIRE_RECTANGLE(s.mr.tl.x-1, s.mr.tl.y, s.mr.tl.x-1, s.mr.br.y, "*");
+  REQUIRE_RECTANGLE(s.mr.br.x+1, s.mr.tl.y, s.mr.br.x+1, s.mr.br.y, "*");
+  REQUIRE_RECTANGLE(s.mr.tl.x, s.mr.tl.y-1, s.mr.br.x, s.mr.tl.y-1, "*");
+  REQUIRE_RECTANGLE(s.mr.tl.x, s.mr.br.y+1, s.mr.br.x, s.mr.br.y+1, "*");
 
 #define CHECK_STRIP_BORDER(tlbr,xy,increm)             \
   do {                                                 \
     Point csb_p;                                       \
     Rect csb_r;                                                \
-    csb_p= mainr.tl;                                   \
+    csb_p= s.mr.tl;                                    \
     csb_p.x++; csb_p.y++;                              \
-    csb_p.xy= mainr.tlbr.xy;                           \
+    csb_p.xy= s.mr.tlbr.xy;                            \
     if (get_p(csb_p)=='+') {                           \
-      csb_r= mainr;                                    \
+      csb_r= s.mr;                                     \
       csb_r.tl.xy= csb_p.xy;                           \
       csb_r.br.xy= csb_p.xy;                           \
       require_rectangle_r(csb_r, "+", __LINE__);       \
-      mainr.tlbr.xy += increm;                         \
+      s.mr.tlbr.xy += increm;                          \
     }                                                  \
   } while(0)
 
-  debug_rect("mainr",0, mainr);
+  debug_rect("s.mr",0, s.mr);
 
   CHECK_STRIP_BORDER(tl,x,+1);
   CHECK_STRIP_BORDER(tl,y,+1);
   CHECK_STRIP_BORDER(br,x,-1);
   CHECK_STRIP_BORDER(br,y,-1);
 
-  debug_rect("mainr",1, mainr);
+  debug_rect("s.mr",1, s.mr);
 
   Rect updown= {START_MAIN,START_MAIN};
   const int chkw= 100;
@@ -321,46 +342,47 @@ void find_structure(CanonImage *im, int *max_relevant_y_r,
   updown.br.y++;
   debug_rect("updown",__LINE__,updown);
 
-  ADJUST_BOX(updown, "+", >=,chkw, mainr.tl.y,   MUST, tl,y,-1);
+  ADJUST_BOX(updown, "+", >=,chkw, s.mr.tl.y,   MUST, tl,y,-1);
   debug_rect("updown",__LINE__,updown);
   updown.br.y= updown.tl.y;
   updown.tl.y= updown.tl.y-1;
 
-  ADJUST_BOX(updown, "+*",>=,chkw, mainr.tl.y-1, MUST, tl,y,-1);
+  ADJUST_BOX(updown, "+*",>=,chkw, s.mr.tl.y-1, MUST, tl,y,-1);
   debug_rect("updown",__LINE__,updown);
 
-  commbasey= updown.tl.y + 1;
-  comminty= updown.br.y - updown.tl.y;
+  s.commbasey= updown.tl.y + 1;
+  s.comminty= updown.br.y - updown.tl.y;
 
-  Rect across= {{ mainr.tl.x - 1, commbasey              },
-               { mainr.tl.x,     commbasey + comminty-2 }};
+  Rect across= {{ s.mr.tl.x - 1, s.commbasey                 },
+               { s.mr.tl.x,     s.commbasey + s.comminty-2 }};
   int colno=0;
   for (;;) {
 
 #define LIMIT_QUITEQ(cond,mp) { if (!(cond)) break; }
     debug_rect("across",colno*1000000+__LINE__, across);
-    ADJUST_BOX(across, "+",>=,comminty-1, mainr.br.x, LIMIT_QUITEQ, br,x,+1);
+    ADJUST_BOX(across, "+",>=,s.comminty-1,s.mr.br.x,LIMIT_QUITEQ,br,x,+1);
     debug_rect("across",colno*1000000+__LINE__, across);
 
-    MUST( colno < MAX_COLUMNS, MI(colno);MR(across);MR(mainr);MI(commbasey); );
+    MUST( colno < MAX_COLUMNS,
+         MI(colno);MR(across);MR(s.mr);MI(s.commbasey); );
     int colrx= across.br.x-1;
-    if (colrx >= mainr.br.x) colrx= mainr.br.x;
+    if (colrx >= s.mr.br.x) colrx= s.mr.br.x;
     if (colno < INTERESTING_COLUMNS)
-      colrightx[colno]= colrx;
+      s.colrightx[colno]= colrx;
       
     colno++;
     
-    if (across.br.x >= mainr.br.x)
+    if (across.br.x >= s.mr.br.x)
       break;
 
-    REQUIRE_RECTANGLE(across.br.x,mainr.tl.y, across.br.x,mainr.br.y, "+");
+    REQUIRE_RECTANGLE(across.br.x,s.mr.tl.y, across.br.x,s.mr.br.y, "+");
     across.br.x++;
   }
-  MUST( colno >= MIN_COLUMNS, MI(colno);MR(mainr);MR(across); );
+  MUST( colno >= MIN_COLUMNS, MI(colno);MR(s.mr);MR(across); );
 
   const int pagerh= 6;
-  Rect pager= {{ mainr.br.x,     mainr.br.y - (pagerh-1) },
-              { mainr.br.x + 1, mainr.br.y              }};
+  Rect pager= {{ s.mr.br.x,     s.mr.br.y - (pagerh-1) },
+              { s.mr.br.x + 1, s.mr.br.y              }};
 
   debug_rect("pager",__LINE__,pager);
   ADJUST_BOX(pager, "o",>=,pagerh-2, whole.br.x,MUST, br,x,+1);
@@ -372,29 +394,35 @@ void find_structure(CanonImage *im, int *max_relevant_y_r,
   ADJUST_BOX(pager, "o",>=,pagerh-2, whole.br.x,MUST, br,x,+1);
   debug_rect("pager",__LINE__,pager);
 
-  ADJUST_BOX(pager, "o",>=,RECT_W(pager)-2, mainr.tl.y,LIMIT_QUITEQ, tl,y,-1);
+  ADJUST_BOX(pager, "o",>=,RECT_W(pager)-2, s.mr.tl.y,LIMIT_QUITEQ, tl,y,-1);
   debug_rect("pager",__LINE__,pager);
 
 #define SET_ONCE(var,val) do{                                          \
     int v= (val);                                                      \
     if ((var)==-1) (var)= v;                                           \
-    else MUST( (var) == v, MSB(#var);MI((var));MI(v);MR(mainr); );     \
+    else MUST( (var) == v, MSB(#var);MI((var));MI(v);MR(s.mr); );      \
   }while(0)
 
   SET_ONCE(columns, colno);
-  SET_ONCE(text_h, comminty - 1);
+  SET_ONCE(text_h, s.comminty - 1);
+
+  if (pagestruct_r) {
+    *pagestruct_r= mmalloc(sizeof(s));
+    **pagestruct_r= s;
+  }
+  
   if (max_relevant_y_r)
-    SET_ONCE(*max_relevant_y_r, mainr.br.y + 10);
+    SET_ONCE(*max_relevant_y_r, s.mr.br.y + 10);
 
   if (commod_focus_point_r) {
-    *commod_focus_point_r= mainr.tl;
+    *commod_focus_point_r= s.mr.tl;
     commod_focus_point_r->x += 10;
-    commod_focus_point_r->y += comminty/3;
+    commod_focus_point_r->y += s.comminty/3;
   }
   if (commod_focuslast_point_r) {
-    *commod_focuslast_point_r= mainr.br;
+    *commod_focuslast_point_r= s.mr.br;
     commod_focuslast_point_r->x -= 10;
-    commod_focuslast_point_r->y -= comminty/3;
+    commod_focuslast_point_r->y -= s.comminty/3;
   }
   if (commod_page_point_r) {
     commod_page_point_r->x= (pager.tl.x + pager.br.x) / 2;
@@ -463,6 +491,10 @@ static void file_read_image_ppm(FILE *f) {
   struct pam inpam;
   unsigned char rgb_buf[3];
   CanonImage *im;
+  RgbImage *ri;
+  PageStruct *pstruct;
+
+  progress("page %d reading       ...",npages);
 
   pnm_readpaminit(f, &inpam, sizeof(inpam));
   if (!(inpam.maxval == 255 &&
@@ -470,14 +502,12 @@ static void file_read_image_ppm(FILE *f) {
        inpam.format == RPPM_FORMAT))
     fatal("PNM screenshot(s) file must be 8bpp 1 byte-per-sample RGB raw");
 
-  CANONICALISE_IMAGE(im, inpam.width, inpam.height, {
-    int rr= fread(&rgb_buf,1,3,f);
-    sysassert(!ferror(f));
+  CANONICALISE_IMAGE(im, inpam.width, inpam.height, ri, {
+    errno=0; int rr= fread_unlocked(&rgb_buf,1,3,f);
+    sysassert(rr==3);
     if (rr!=3) fatal("PNM screenshot(s) file ends unexpectedly");
 
-    r= rgb_buf[0];
-    g= rgb_buf[1];
-    b= rgb_buf[2];
+    rgb= rgb_buf[0] | (rgb_buf[1] << 8) | (rgb_buf[2] << 16);
   });
 
   sysassert(!ferror(screenshot_file));
@@ -485,7 +515,21 @@ static void file_read_image_ppm(FILE *f) {
   if (!(npages < MAX_PAGES))
     fatal("Too many images in screenshots file; max is %d.\n", MAX_PAGES);
 
-  page_images[npages++]= im;
+  find_structure(im,&pstruct, 0,0,0,0);
+  store_current_page(im,pstruct,ri);
+  npages++;
+}
+
+void store_current_page(CanonImage *ci, PageStruct *pstruct, RgbImage *rgb) {
+  assert(ci==cim);
+  progress("page %d unantialiasing...",npages);
+  adjust_colours(ci, rgb);
+  progress("page %d storing       ...",npages);
+  if (!npages) page0_rgbimage= rgb;
+  else free(rgb);
+  page_images[npages]= cim;
+  page_structs[npages]= *pstruct;
+  free(pstruct);
 }
 
 void read_one_screenshot(void) {
@@ -508,97 +552,183 @@ void read_screenshots(void) {
       if (c==EOF) break;
       ungetc(c, screenshot_file);
     }
-    progress("reading screenshot %d...",npages);
     file_read_image_ppm(screenshot_file);
   }
   sysassert(!ferror(screenshot_file));
   progress_log("read %d screenshots.",npages);
 }
 
-static double find_aa_density(const RgbImage *ri, Point p, long background,
-                             long foreground, int fg_extra) {
+#define FIXPT_SHIFT 15
+
+typedef long Fixpt;
+static inline Fixpt int2fixpt(int x) { return x<<FIXPT_SHIFT; }
+static inline Fixpt dbl2fixpt(double x) { return x * int2fixpt(1); }
+static inline double fixpt2dbl(Fixpt x) { return x / (1.0*int2fixpt(1)); }
+static inline Fixpt fixpt_mul(Fixpt a, Fixpt b) {
+  return (a*b + dbl2fixpt(0.5)) / int2fixpt(1);
+}
+#define MFP(v) fprintf(stderr," %s=%lx=%f", #v,(v),fixpt2dbl((v)))
+
+static Fixpt aa_bg_chan[3], aa_scale_chan[3], aa_alpha_mean_max;
+static Rgb aa_background, aa_foreground;
+
+static void find_aa_density_prep(Rgb bg, Rgb fg, int fg_extra) {
+  int i;
+  unsigned char fg_chan[3];
+
+  aa_background= bg;
+  aa_foreground= fg;
+  aa_alpha_mean_max= fg_extra ? int2fixpt(1)-1 : int2fixpt(1);
+
+  for (i=0; i<3; i++) {
+    aa_bg_chan[i]= int2fixpt( (aa_background >> (i*8)) & 0xff );
+    fg_chan[i]=                aa_foreground >> (i*8);
+
+    aa_scale_chan[i]= 1.0 / (int2fixpt(fg_chan[i]) + fg_extra - aa_bg_chan[i])
+      * dbl2fixpt(1) * dbl2fixpt(1);
+  }
+}
+
+static inline Fixpt find_aa_density(const RgbImage *ri, Point p) {
   Rgb here= ri_rgb(ri, p.x, p.y);
 
-  double alpha[3], alpha_mean=0;
+  if (here==aa_background) return 0;
+
+  Fixpt alpha[3], alpha_total=0;
   int i;
   for (i=0; i<3; i++) {
-    unsigned char here_chan= here       >> (i*8);
-    unsigned char bg_chan=   background >> (i*8);
-    unsigned char fg_chan=   foreground >> (i*8);
-    double alpha_chan=
-      ((double)here_chan    - (double)bg_chan) /
-      ((fg_chan + fg_extra) - (double)bg_chan);
+    unsigned char here_chan= here >> (i*8);
+
+    Fixpt alpha_chan= fixpt_mul(int2fixpt(here_chan) - aa_bg_chan[i],
+                               aa_scale_chan[i]);
     alpha[i]= alpha_chan;
-    alpha_mean += alpha_chan * (1/3.0);
+    alpha_total += alpha_chan;
   }
 
-  double thresh= 1.5/AAMAXVAL;
-  double alpha_min= alpha_mean - thresh;
-  double alpha_max= alpha_mean + thresh;
+  Fixpt one_third= dbl2fixpt(1/3.0);
+  Fixpt alpha_mean= fixpt_mul(alpha_total, one_third);
+  
+  Fixpt thresh= dbl2fixpt(1.5/AAMAXVAL);
+  Fixpt alpha_min= alpha_mean - thresh*2;
+  Fixpt alpha_max= alpha_mean + thresh*2;
+
   for (i=0; i<3; i++)
     MUST( alpha_min <= alpha[i] && alpha[i] <= alpha_max,
          MP(p);
-         MRGB(here);MRGB(background);MRGB(foreground);MI(fg_extra);
-         MF(alpha_min); MI(i);MF(alpha[i]);MF(alpha_max) );
-
-  if (   -1e-5 <  alpha_mean && alpha_mean <= 0.0     ) alpha_mean= 0.0;
-  if (1.0      <= alpha_mean && alpha_mean <= 1.0+1e-5) alpha_mean= 1.0;
+         MRGB(here);MRGB(aa_background);MRGB(aa_foreground);
+         MFP(aa_alpha_mean_max);MFP(thresh);MFP(alpha_mean);
+         MFP(alpha_min);MI(i);MFP(alpha[i]);MFP(alpha_max) );
 
-  MUST( 0 <= alpha_mean &&
-       (fg_extra ? (alpha_mean < 0.999) : (alpha_mean <= 1.0)),
+  MUST( -thresh <= alpha_mean && alpha_mean <= aa_alpha_mean_max + thresh,
        MP(p);
-       MRGB(here);MRGB(background);MRGB(foreground);MI(fg_extra);
-       MF(alpha_mean); MF(alpha[0]);MF(alpha[1]);MF(alpha[2]); );
+       MRGB(here);MRGB(aa_background);MRGB(aa_foreground);
+       MFP(aa_alpha_mean_max);MFP(thresh);
+       MFP(alpha_mean); MFP(alpha[0]);MFP(alpha[1]);MFP(alpha[2]); );
+
+  if (alpha_mean < 0)                 alpha_mean= 0;
+  if (alpha_mean > aa_alpha_mean_max) alpha_mean= aa_alpha_mean_max;
 
   return alpha_mean;
 }
 
 static void find_commodity(int offset, Rect *rr) {
   /* rr->tl.x==-1 if offset out of range */
-  rr->tl.y= commbasey - offset*comminty;
-  rr->br.y= rr->tl.y + comminty-2;
-  if (rr->tl.y < mainr.tl.y || rr->br.y > mainr.br.y) { rr->tl.x=-1; return; }
+  rr->tl.y= s.commbasey - offset*s.comminty;
+  rr->br.y= rr->tl.y + s.comminty-2;
+  if (rr->tl.y < s.mr.tl.y || rr->br.y > s.mr.br.y) { rr->tl.x=-1; return; }
   
-  rr->tl.x= mainr.tl.x;
-  rr->br.x= mainr.br.x;
+  rr->tl.x= s.mr.tl.x;
+  rr->br.x= s.mr.br.x;
 
-  if (rr->tl.y > mainr.tl.y)
+  if (rr->tl.y > s.mr.tl.y)
     REQUIRE_RECTANGLE(rr->tl.x,rr->tl.y-1, rr->br.x,rr->tl.y-1, "+");
-  if (rr->br.y < mainr.tl.y)
+  if (rr->br.y < s.mr.tl.y)
     REQUIRE_RECTANGLE(rr->tl.x,rr->br.y+1, rr->br.x,rr->br.y+1, "+");
 }
 
-static void find_table_entry(Rect commod, int colno, Rect *cell) {
+static void compute_table_location(Rect commod, int colno, Rect *cell) {
   cell->tl.y= commod.tl.y;
   cell->br.y= commod.br.y;
-  cell->tl.x= !colno ? commod.tl.x : colrightx[colno-1]+2;
-  cell->br.x=                        colrightx[colno];
+  cell->tl.x= !colno ? commod.tl.x : s.colrightx[colno-1]+2;
+  cell->br.x=                        s.colrightx[colno];
   debug_rect("cell", colno, *cell);
+}
 
-  const RgbImage *ri= cim->rgb;
-  
+static void ocr_rectangle(Rect r, const OcrCellType ct, FILE *tsv_output) {
+  OcrResultGlyph *results, *res;
+
+  int w= r.br.x - r.tl.x + 1;
+  Pixcol cols[w+1];
+  int x,y;
+  for (x=0; x<w; x++) {
+    FILLZERO(cols[x]);
+    for (y=0; y<text_h; y++) {
+      Point here= { x+r.tl.x, y+r.tl.y };
+      int pixel= get_p(here);
+      if (pixel==' ') pixel= '0';
+      MUST( pixel >= '0' && pixel <= '0'+AAMAXVAL,
+           MC(pixel);MP(here);MSB(ocr_celltype_name(ct));MR(r); );
+      pixcol_p_add(&cols[x], y, pixel-'0');
+    }
+  }
+  FILLZERO(cols[w]);
+
+  results= ocr(rd,ct,w,cols);
+  for (res=results; res->s; res++)
+    fputs(res->s,tsv_output);
+}
+
+#define FOR_COMMODITY_CELL(ROW_START, CELL, ROW_END) do{       \
+    Rect rowr, cell;                                           \
+    int tryrect, colno;                                                \
+                                                               \
+    for (tryrect= +cim->h; tryrect >= -cim->h; tryrect--) {    \
+      find_commodity(tryrect, &rowr);                          \
+      if (rowr.tl.x < 0)                                       \
+       continue;                                               \
+      debug_rect("commod",tryrect, rowr);                      \
+                                                               \
+      ROW_START;                                               \
+                                                               \
+      for (colno=0; colno<columns; colno++) {                  \
+       compute_table_location(rowr,colno,&cell);               \
+                                                               \
+       CELL;                                                   \
+      }                                                                \
+                                                               \
+      ROW_END;                                                 \
+    }                                                          \
+  }while(0);
+
+static void adjust_colours_cell(CanonImage *ci, const RgbImage *ri,
+                               int colno, Rect cell) {
   Rgb background;
   unsigned char chanbg[3];
   long bg_count=0, light_count=0, dark_count=0;
+  int i;
   Point p;
 
-  background= ri_rgb(ri, cell->br.x, cell->br.y);
-  memcpy(chanbg, RI_PIXEL(ri, cell->br.x, cell->br.y), 3);
-
-  FOR_P_RECT(p,*cell) {
-    const unsigned char *here_pixel= RI_PIXEL(ri, p.x, p.y);
-    int i;
-    for (i=0; i<3; i++) {
-      unsigned here= here_pixel[i];
-      if (here == chanbg[i]) bg_count++;
-      else if (here < chanbg[i]) dark_count  += (chanbg[i] - here)/4 + 1;
-      else if (here > chanbg[i]) light_count += (here - chanbg[i])/4 + 1;
+  background= ri_rgb(ri, cell.br.x, cell.br.y);
+  for (i=0; i<3; i++)
+    chanbg[i]= background >> (i*8);
+
+  FOR_P_RECT(p,cell) {
+    Rgb herergb= ri_rgb(ri, p.x, p.y);
+    if (herergb==background) {
+      bg_count+=3;
+    } else {
+      for (i=0; i<3; i++) {
+       unsigned char here= herergb >> (i*8);
+       if (here == chanbg[i]) bg_count++;
+       else if (here < chanbg[i]) dark_count  += (chanbg[i] - here)/4 + 1;
+       else if (here > chanbg[i]) light_count += (here - chanbg[i])/4 + 1;
+      }
     }
   }
-  long total_count= RECT_W(*cell) * RECT_H(*cell) * 3;
+  long total_count= RECT_W(cell) * RECT_H(cell) * 3;
 
   MUST( bg_count > total_count / 2,
-       MR(*cell);MIL(total_count);MIL(bg_count);
+       MR(cell);MIL(total_count);MIL(bg_count);
        MIL(light_count);MIL(dark_count) );
 
   if (bg_count == total_count)
@@ -615,60 +745,48 @@ static void find_table_entry(Rect commod, int colno, Rect *cell) {
     fg_extra= -1;
   } else {
     MUST( !"tell light from dark",
-         MR(*cell);MIL(total_count);MIL(bg_count);
+         MR(cell);MIL(total_count);MIL(bg_count);
          MIL(light_count);MIL(dark_count);MRGB(background); );
   }
 
   debugf("TABLEENTRY col=%d %d,%d..%d,%d bg=%ld light=%ld dark=%ld\n",
-        colno, cell->tl.x,cell->tl.y, cell->br.x,cell->br.y,
+        colno, cell.tl.x,cell.tl.y, cell.br.x,cell.br.y,
         bg_count, light_count, dark_count);
-  
+
   int monochrome= 1;
 
-  FOR_P_RECT(p,*cell) {
-    double alpha= find_aa_density(ri,p,background,foreground,fg_extra);
+  find_aa_density_prep(background, foreground, fg_extra);
 
-    int here_int= floor((AAMAXVAL+1)*alpha);
+  FOR_P_RECT(p,cell) {
+    Fixpt alpha= find_aa_density(ri,p);
+
+    int here_int= alpha >> (FIXPT_SHIFT - AADEPTH);
     assert(here_int <= AAMAXVAL);
     if (!(here_int==0 || here_int==AAMAXVAL)) monochrome=0;
-    cim->d[p.y * cim->w + p.x]= '0' + here_int;
+    ci->d[p.y * ci->w + p.x]= '0' + here_int;
   }
 
-  debug_rect("cell0M", colno, *cell);
+  debug_rect("cell0M", colno, cell);
 
-  require_rectangle_r(*cell, "0123456789", __LINE__);
+  require_rectangle_r(cell, "0123456789", __LINE__);
 }
 
-static void ocr_rectangle(Rect r, const OcrCellType ct, FILE *tsv_output) {
-  OcrResultGlyph *results, *res;
+void adjust_colours(CanonImage *ci, const RgbImage *ri) {
+  if (!(o_mode & mf_analyse))
+    return;
 
-  int w= r.br.x - r.tl.x + 1;
-  Pixcol cols[w+1];
-  int x,y;
-  for (x=0; x<w; x++) {
-    FILLZERO(cols[x]);
-    for (y=0; y<text_h; y++) {
-      Point here= { x+r.tl.x, y+r.tl.y };
-      int pixel= get_p(here);
-      if (pixel==' ') pixel= '0';
-      MUST( pixel >= '0' && pixel <= '0'+AAMAXVAL,
-           MC(pixel);MP(here);MSB(ocr_celltype_name(ct));MR(r); );
-      pixcol_p_add(&cols[x], y, pixel-'0');
-    }
-  }
-  FILLZERO(cols[w]);
+  cim= ci;
 
-  results= ocr(rd,ct,w,cols);
-  for (res=results; res->s; res++)
-    fputs(res->s,tsv_output);
+  FOR_COMMODITY_CELL({},({
+    adjust_colours_cell(ci,ri,colno,cell);
+  }),{});
 }
 
 void analyse(FILE *tsv_output) {
-  Rect thisr, entryr;
-  int page, tryrect, colno;
+  int page;
 
   for (page=0; page<npages; page++) {
-    find_structure(page_images[page], 0,0,0,0);
+    select_page(page);
 
     if (!page)
       check_correct_commodities();
@@ -676,29 +794,25 @@ void analyse(FILE *tsv_output) {
     if (!rd)
       rd= ocr_init(text_h);
 
-    progress("Scanning page %d...",page);
-
-    for (tryrect= +cim->h; tryrect >= -cim->h; tryrect--) {
-      find_commodity(tryrect, &thisr);
-      if (thisr.tl.x < 0)
-       continue;
-      debug_rect("commod",tryrect, thisr);
-
-      const char *tab= "";
-      for (colno=0; colno<columns; colno++) {
-       find_table_entry(thisr,colno,&entryr);
-       fputs(tab, tsv_output);
-       ocr_rectangle(entryr,
-                     colno<TEXT_COLUMNS
-                     ? &ocr_celltype_text
-                     : &ocr_celltype_number,
-                     tsv_output);
-       tab= "\t";
-      }
+    progress("Processing page %d...",page);
+
+    const char *tab= "";
+    
+    FOR_COMMODITY_CELL({
+      tab= "";
+    },{
+      fputs(tab, tsv_output);
+      ocr_rectangle(cell,
+                   colno<TEXT_COLUMNS
+                   ? &ocr_celltype_text
+                   : &ocr_celltype_number,
+                   tsv_output);
+      tab= "\t";
+    },{
       fputs("\n", tsv_output);
       sysassert(!ferror(tsv_output));
       sysassert(!fflush(tsv_output));
-    }
+    })
   }
   progress("Commodity table scan complete.");
 }
@@ -729,23 +843,23 @@ Rect find_sunshine_widget(void) {
 }
 
 void find_islandname(void) {
-  find_structure(page_images[0], 0,0,0,0);
+  const RgbImage *rgbsrc= page0_rgbimage;
+  select_page(0);
 
-  RgbImage *ri= alloc_rgb_image(page_images[0]->rgb->w,
-                               page_images[0]->rgb->h);
-  memcpy(ri->data, page_images[0]->rgb->data, ri->w * ri->h * 3);
+  RgbImage *ri= alloc_rgb_image(rgbsrc->w, rgbsrc->h);
+  memcpy(ri->data, rgbsrc->data, ri->w * ri->h * 3);
   
   Rect sunshiner= find_sunshine_widget();
   char sunshine[MAXIMGIDENT], archisland[MAXIMGIDENT];
 
-  const unsigned char *srcp;
-  unsigned char *destp, *endp;
-  for (srcp=page_images[0]->rgb->data, destp=ri->data,
-        endp= ri->data + 3 * ri->w * ri->h;
+  const Rgb *srcp;
+  Rgb *destp, *endp;
+  for (srcp= rgbsrc->data, destp=ri->data,
+        endp= ri->data + ri->w * ri->h;
        destp < endp;
        srcp++, destp++) {
-    unsigned char c= *srcp & 0xf0;
-    *destp= c | (c>>4);
+    Rgb new= *srcp & 0xf0f0f0;
+    *destp= new | (new>>4);
   }
 
   identify_rgbimage(ri, sunshiner, sunshine, "sunshine widget");
@@ -771,13 +885,11 @@ void find_islandname(void) {
 //    islandnamer.br.y = larger_islandnamebry;
     debug_rect("islandnamer",1, islandnamer);
 
-    int x,y,i;
+    int x,y;
     for (x=islandnamer.tl.x; x<=islandnamer.br.x; x++)
       for (y=islandnamer.tl.y; y<=islandnamer.br.y; y++) {
-       if (RI_PIXEL(ri,x,y)[0] < 0x40) {
-         for (i=0; i<3; i++) {
-           RI_PIXEL(ri,x,y)[i]= 0;
-         }
+       if ((ri_rgb(ri,x,y) & 0xff) < 0x40) {
+         *RI_PIXEL32(ri,x,y)= 0;
        }
       }
 
@@ -830,11 +942,13 @@ void find_islandname(void) {
       uint32_t pattern=0;
       int runs[32], nruns=0;
       runs[0]=0; runs[1]=0;
+
+      find_aa_density_prep(0xCCCCAA,0x002255,0);
       
       for (p.y=islandnamer.tl.y; p.y<=islandnamer.br.y; p.y++) {
        pattern <<= 1;
-       double alpha= find_aa_density(ri,p, 0xCCCCAA,0x002255,0);
-       if (alpha >= 0.49) {
+       Fixpt alpha= find_aa_density(ri,p);
+       if (alpha >= dbl2fixpt(0.49)) {
           runs[nruns]++;
           pattern |= 1u;
        } else {
index 84fdcae..263a26a 100644 (file)
@@ -50,44 +50,41 @@ static inline char canon_lookup_colour(unsigned char r,
   return blues->blue2[b];
 }
 
-#define CANONICALISE_IMAGE(im,w,h, COMPUTE_RGB) do{            \
-    /* compute_rgb should be a number of statements, or                \
-     * a block, which assigns to                               \
-     *   Rgb rgb;                                              \
-     * given the values of                                     \
-     *   int x,y;                                              \
-     * all of which are anamorphic.  Result is stored in im.   \
-     * The COMPUTE_RGB is executed exactly once for            \
-     * each pixel in reading order.                            \
-     */                                                                \
-    (im)= alloc_canon_image((w), (h));                         \
-    RgbImage *rgb_save;                                                \
-    (im)->rgb= rgb_save= alloc_rgb_image((w), (h));            \
-                                                               \
-    int x,y;                                                   \
-    for (y=0; y<(h); y++) {                                    \
-      for (x=0; x<(w); x++) {                                  \
-        unsigned char r,g,b;                                   \
-       COMPUTE_RGB;                                            \
-        CANONIMG_ALSO_STORERGB(rgb_save);                      \
-       (im)->d[y*(w) + x]= canon_lookup_colour(r,g,b);         \
-      }                                                                \
-      if (DEBUGP(rect)) {                                      \
-       fprintf(debug, "%4d ",y);                               \
-       fwrite(im->d + y*(w), 1,(w), debug);                    \
-       fputc('\n',debug);                                      \
-      }                                                                \
-    }                                                          \
-    debug_flush();                                             \
+#define CANONICALISE_IMAGE(im,w,h,rgb_save, COMPUTE_RGB) do{           \
+    /* compute_rgb should be a number of statements, or                        \
+     * a block, which assigns to                                       \
+     *   Rgb rgb;                                                      \
+     * given the values of                                             \
+     *   int x,y;                                                      \
+     * all of which are anamorphic.  Result is stored in im.           \
+     * The COMPUTE_RGB is executed exactly once for                    \
+     * each pixel in reading order.                                    \
+     */                                                                        \
+    (im)= alloc_canon_image((w), (h));                                 \
+    (rgb_save)= alloc_rgb_image((w), (h));                             \
+                                                                       \
+    int x,y;                                                           \
+    for (y=0; y<(h); y++) {                                            \
+      for (x=0; x<(w); x++) {                                          \
+        Rgb rgb;                                                       \
+       COMPUTE_RGB;                                                    \
+        CANONIMG_ALSO_STORERGB((rgb_save));                            \
+       (im)->d[y*(w) + x]= canon_lookup_colour(rgb, rgb>>8, rgb>>16);  \
+      }                                                                        \
+      if (DEBUGP(rect)) {                                              \
+       fprintf(debug, "%4d ",y);                                       \
+       fwrite(im->d + y*(w), 1,(w), debug);                            \
+       fputc('\n',debug);                                              \
+      }                                                                        \
+    }                                                                  \
+    debug_flush();                                                     \
   }while(0)
 
 
 #define CANONIMG_ALSO_STORERGB(ri)             \
   do{                                          \
-    unsigned char *rip= RI_PIXEL((ri),x,y);    \
-    rip[0]= r;                                 \
-    rip[1]= g;                                 \
-    rip[2]= b;                                 \
+    Rgb *rip= RI_PIXEL32((ri),x,y);            \
+    *rip= rgb;                                 \
   }while(0)
 
 
index 0f6bf86..1133843 100644 (file)
@@ -1,4 +1,5 @@
 file ypp-commodities
-set args -Drect 2>u --edit-charset --raw-tsv --same --screenshot-file t.ppm >raw.tsv 
+set args -Drect 2>u --edit-charset --find-island --ocean sage
+#break structure.c:596 if here!=aa_background
 break mustfail2
 run