tesseract_bin 1.0.0

data/vendor/tesseract-2.04/ccstruct/blobs.h

@@ -0,0 +1,119 @@
+/* -*-C-*-
+ ********************************************************************************
+ *
+ * File:        blobs.h  (Formerly blobs.h)
+ * Description:  Blob definition
+ * Author:       Mark Seaman, OCR Technology
+ * Created:      Fri Oct 27 15:39:52 1989
+ * Modified:     Thu Mar 28 15:33:38 1991 (Mark Seaman) marks@hpgrlt
+ * Language:     C
+ * Package:      N/A
+ * Status:       Experimental (Do Not Distribute)
+ *
+ * (c) Copyright 1989, Hewlett-Packard Company.
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ *
+ *********************************************************************************/
+
+#ifndef BLOBS_H
+#define BLOBS_H
+
+/*----------------------------------------------------------------------
+              I n c l u d e s
+----------------------------------------------------------------------*/
+#include                   "vecfuncs.h"
+#include  "tessclas.h"
+
+/*----------------------------------------------------------------------
+              T y p e s
+----------------------------------------------------------------------*/
+typedef struct
+{                                /* Widths of pieces */
+  int num_chars;
+  int widths[1];
+} WIDTH_RECORD;
+
+/*----------------------------------------------------------------------
+              M a c r o s
+----------------------------------------------------------------------*/
+/**********************************************************************
+ * free_widths
+ *
+ * Free the memory taken up by a width array.
+ **********************************************************************/
+#define free_widths(w)  \
+if (w) memfree (w)
+
+/*----------------------------------------------------------------------
+              F u n c t i o n s
+----------------------------------------------------------------------*/
+void blob_origin(TBLOB *blob,      /*blob to compute on */
+                 TPOINT *origin);  /*return value */
+
+                                 /*blob to compute on */
+void blob_bounding_box(TBLOB *blob,
+                       register TPOINT *topleft,  /*bounding box */
+                       register TPOINT *botright);
+
+void blobs_bounding_box(TBLOB *blobs, TPOINT *topleft, TPOINT *botright); 
+
+void blobs_origin(TBLOB *blobs,     /*blob to compute on */
+                  TPOINT *origin);  /*return value */
+
+                                 /*blob to compute on */
+WIDTH_RECORD *blobs_widths(TBLOB *blobs); 
+
+int count_blobs(TBLOB *blobs); 
+
+void delete_word(TWERD *word); 
+
+void delete_edgepts(register EDGEPT *edgepts); 
+
+/*
+#if defined(__STDC__) || defined(__cplusplus)
+# define	_ARGS(s) s
+#else
+# define	_ARGS(s) ()
+#endif*/
+
+/* blobs.c
+void blob_origin
+  _ARGS((BLOB *blob,
+  TPOINT *origin));
+
+void blob_bounding_box
+  _ARGS((BLOB *blob,
+  TPOINT *topleft,
+  TPOINT *botright));
+
+void blobs_bounding_box
+  _ARGS((BLOB *blobs,
+  TPOINT *topleft,
+  TPOINT *botright));
+
+void blobs_origin
+  _ARGS((BLOB *blobs,
+  TPOINT *origin));
+
+WIDTH_RECORD *blobs_widths
+  _ARGS((BLOB *blobs));
+
+int count_blobs
+  _ARGS((BLOB *blobs));
+
+void delete_word
+  _ARGS((TWERD *word));
+
+void delete_edgepts
+  _ARGS((EDGEPT *edgepts));
+#undef _ARGS
+*/
+#endif

data/vendor/tesseract-2.04/ccstruct/blread.cpp

@@ -0,0 +1,537 @@
+/**********************************************************************
+ * File:        blread.cpp  (Formerly pdread.c)
+ * Description: Friend function of BLOCK to read the uscan pd file.
+ * Author:		Ray Smith
+ * Created:		Mon Mar 18 14:39:00 GMT 1991
+ *
+ * (C) Copyright 1991, Hewlett-Packard Ltd.
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ *
+ **********************************************************************/
+
+#include "mfcpch.h"
+#include          <stdlib.h>
+#ifdef __UNIX__
+#include          <assert.h>
+#endif
+#include          "scanutils.h"
+#include          "fileerr.h"
+#include          "imgtiff.h"
+#include          "pdclass.h"
+#include          "rwpoly.h"
+#include          "blread.h"
+
+#define PD_EXT        ".pd"
+#define VEC_EXT       ".vec"     //accupage file
+#define HPD_EXT       ".bl"      //hand pd file
+                                 //unlv zone file
+#define UNLV_EXT            ".uzn"
+#define BLOCK_EXPANSION   8      //boundary expansion
+#define EXTERN
+
+EXTERN BOOL_EVAR (ignore_weird_blocks, TRUE, "Don't read weird blocks");
+
+static TBOX convert_vec_block(                        //make non-rect block
+                             VEC_ENTRY *entries,     //vectors
+                             uinT16 entry_count,     //no of entries
+                             inT32 ysize,            //image size
+                             ICOORDELT_IT *left_it,  //block sides
+                             ICOORDELT_IT *right_it);
+
+/**********************************************************************
+ * BLOCK::read_pd_file
+ *
+ * Read a whole pd file to make a list of blocks, or return false.
+ **********************************************************************/
+
+BOOL8 read_pd_file(                    //print list of sides
+                   STRING name,        //basename of file
+                   inT32 xsize,        //image size
+                   inT32 ysize,        //image size
+                   BLOCK_LIST *blocks  //output list
+                  ) {
+  FILE *pdfp;                    //file pointer
+  BLOCK *block;                  //current block
+  inT32 block_count;             //no of blocks
+  inT32 junk_count;              //no of junks to read
+  inT32 junks[4];                //junk elements
+  inT32 vertex_count;            //boundary vertices
+  inT32 xcoord;                  //current coords
+  inT32 ycoord;
+  inT32 prevx;                   //previous coords
+  inT32 prevy;
+  BLOCK_IT block_it = blocks;    //block iterator
+  ICOORDELT_LIST dummy;          //for constructor
+  ICOORDELT_IT left_it = &dummy; //iterator
+  ICOORDELT_IT right_it = &dummy;//iterator
+
+  if (read_hpd_file (name, xsize, ysize, blocks))
+    return TRUE;                 //succeeded
+  if (read_vec_file (name, xsize, ysize, blocks))
+    return TRUE;                 //succeeded
+  if (read_unlv_file (name, xsize, ysize, blocks))
+    return TRUE;                 //succeeded
+  name += PD_EXT;                //add extension
+  if ((pdfp = fopen (name.string (), "r")) == NULL) {
+                                 //make rect block
+    return FALSE;                //didn't read one
+  }
+  else {
+    if (fread (&block_count, sizeof (block_count), 1, pdfp) != 1)
+      READFAILED.error ("read_pd_file", EXIT, "Block count");
+    tprintf ("%d blocks in .pd file.\n", block_count);
+    while (block_count > 0) {
+      if (fread (&junk_count, sizeof (junk_count), 1, pdfp) != 1)
+        READFAILED.error ("read_pd_file", EXIT, "Junk count");
+      if (fread (&vertex_count, sizeof (vertex_count), 1, pdfp) != 1)
+        READFAILED.error ("read_pd_file", EXIT, "Vertex count");
+      block = new BLOCK;         //make a block
+                                 //on end of list
+      block_it.add_to_end (block);
+      left_it.set_to_list (&block->leftside);
+      right_it.set_to_list (&block->rightside);
+
+                                 //read a pair
+      get_pd_vertex (pdfp, xsize, ysize, &block->box, xcoord, ycoord);
+      vertex_count -= 2;         //count read ones
+      prevx = xcoord;
+      do {
+        if (xcoord == prevx) {
+          if (!right_it.empty ()) {
+            if (right_it.data ()->x () <= xcoord + BLOCK_EXPANSION)
+              right_it.data ()->set_y (right_it.data ()->y () +
+                BLOCK_EXPANSION);
+            else
+              right_it.data ()->set_y (right_it.data ()->y () -
+                BLOCK_EXPANSION);
+          }
+          right_it.
+            add_before_then_move (new
+            ICOORDELT (xcoord + BLOCK_EXPANSION,
+            ycoord));
+        }
+        prevx = xcoord;          //remember previous
+        prevy = ycoord;
+        get_pd_vertex (pdfp, xsize, ysize, &block->box, xcoord, ycoord);
+        vertex_count -= 2;       //count read ones
+      }
+      while (ycoord <= prevy);
+      right_it.data ()->set_y (right_it.data ()->y () - BLOCK_EXPANSION);
+
+                                 //start of left
+      left_it.add_to_end (new ICOORDELT (prevx - BLOCK_EXPANSION, prevy - BLOCK_EXPANSION));
+
+      do {
+        prevx = xcoord;          //remember previous
+        get_pd_vertex (pdfp, xsize, ysize, &block->box, xcoord, ycoord);
+        vertex_count -= 2;
+        if (xcoord != prevx && vertex_count > 0) {
+          if (xcoord > prevx)
+            left_it.
+              add_to_end (new
+              ICOORDELT (xcoord - BLOCK_EXPANSION,
+              ycoord + BLOCK_EXPANSION));
+          else
+            left_it.
+              add_to_end (new
+              ICOORDELT (xcoord - BLOCK_EXPANSION,
+              ycoord - BLOCK_EXPANSION));
+        }
+        else if (vertex_count == 0)
+          left_it.add_to_end (new ICOORDELT (prevx - BLOCK_EXPANSION,
+              ycoord + BLOCK_EXPANSION));
+      }
+      while (vertex_count > 0);  //until all read
+
+      while (junk_count > 0) {
+        if (fread (junks, sizeof (inT32), 4, pdfp) != 4)
+          READFAILED.error ("read_pd_file", EXIT, "Junk coords");
+        junk_count--;
+      }
+      block_count--;             //count read blocks
+    }
+  }
+  fclose(pdfp);
+  return TRUE;                   //read one
+}
+
+
+/**********************************************************************
+ * get_pd_vertex
+ *
+ * Read a pair of coords, invert the y and clip to image limits.
+ * Also update the bounding box.
+ *
+ * Read a whole pd file to make a list of blocks, or use the whole page.
+ **********************************************************************/
+
+void get_pd_vertex(                //get new vertex
+                   FILE *pdfp,     //file to read
+                   inT32 xsize,    //image size
+                   inT32 ysize,    //image size
+                   TBOX *box,       //bounding box
+                   inT32 &xcoord,  //output coords
+                   inT32 &ycoord) {
+  TBOX new_coord;                 //expansion box
+
+                                 //get new coords
+  if (fread (&xcoord, sizeof (xcoord), 1, pdfp) != 1)
+    READFAILED.error ("read_pd_file", EXIT, "Xcoord");
+  if (fread (&ycoord, sizeof (ycoord), 1, pdfp) != 1)
+    READFAILED.error ("read_pd_file", EXIT, "Xcoord");
+  ycoord = ysize - ycoord;       //invert y
+  if (xcoord < BLOCK_EXPANSION)
+    xcoord = BLOCK_EXPANSION;    //clip to limits
+  if (xcoord > xsize - BLOCK_EXPANSION)
+    xcoord = xsize - BLOCK_EXPANSION;
+  if (ycoord < BLOCK_EXPANSION)
+    ycoord = BLOCK_EXPANSION;
+  if (ycoord > ysize - BLOCK_EXPANSION)
+    ycoord = ysize - BLOCK_EXPANSION;
+
+  new_coord =
+    TBOX (ICOORD (xcoord - BLOCK_EXPANSION, ycoord - BLOCK_EXPANSION),
+    ICOORD (xcoord + BLOCK_EXPANSION, ycoord + BLOCK_EXPANSION));
+  (*box) += new_coord;
+}
+
+
+/**********************************************************************
+ * BLOCK::read_hpd_file
+ *
+ * Read a whole hpd file to make a list of blocks.
+ * Return FALSE if the .vec fiel cannot be found
+ **********************************************************************/
+
+BOOL8 read_hpd_file(                    //print list of sides
+                    STRING name,        //basename of file
+                    inT32 xsize,        //image size
+                    inT32 ysize,        //image size
+                    BLOCK_LIST *blocks  //output list
+                   ) {
+  FILE *pdfp;                    //file pointer
+  PAGE_BLOCK_LIST *page_blocks;
+  inT32 block_no;                //no of blocks
+  BLOCK_IT block_it = blocks;    //block iterator
+
+  name += HPD_EXT;               //add extension
+  if ((pdfp = fopen (name.string (), "r")) == NULL) {
+    return FALSE;                //can't find it
+  }
+  fclose(pdfp);
+  page_blocks = read_poly_blocks (name.string ());
+  block_no = 0;
+  scan_hpd_blocks (name.string (), page_blocks, block_no, &block_it);
+  tprintf ("Text region count=%d\n", block_no);
+  return TRUE;                   //read one
+}
+
+
+/**********************************************************************
+ * BLOCK::scan_hpd_blocks
+ *
+ * Read a whole hpd file to make a list of blocks.
+ * Return FALSE if the .vec fiel cannot be found
+ **********************************************************************/
+
+void scan_hpd_blocks(                               //print list of sides
+                     const char *name,              //block label
+                     PAGE_BLOCK_LIST *page_blocks,  //head of full pag
+                     inT32 &block_no,               //no of blocks
+                     BLOCK_IT *block_it             //block iterator
+                    ) {
+  BLOCK *block;                  //current block
+                                 //page blocks
+  PAGE_BLOCK_IT pb_it = page_blocks;
+  PAGE_BLOCK *current_block;
+  TEXT_REGION_IT tr_it;
+  TEXT_BLOCK *tb;
+  TEXT_REGION *tr;
+  TBOX *block_box;                //from text region
+
+  for (pb_it.mark_cycle_pt (); !pb_it.cycled_list (); pb_it.forward ()) {
+    current_block = pb_it.data ();
+    if (current_block->type () == PB_TEXT) {
+      tb = (TEXT_BLOCK *) current_block;
+      if (!tb->regions ()->empty ()) {
+        tr_it.set_to_list (tb->regions ());
+        for (tr_it.mark_cycle_pt ();
+        !tr_it.cycled_list (); tr_it.forward ()) {
+          block_no++;
+          tr = tr_it.data ();
+          block_box = tr->bounding_box ();
+          block = new BLOCK (name, TRUE, 0, 0,
+            block_box->left (), block_box->bottom (),
+            block_box->right (), block_box->top ());
+          block->hand_block = tr;
+          block->hand_poly = tr;
+          block_it->add_after_then_move (block);
+        }
+      }
+    }
+    else if (current_block->type () == PB_WEIRD
+      && !ignore_weird_blocks
+    && ((WEIRD_BLOCK *) current_block)->id_no () > 0) {
+      block_no++;
+      block_box = current_block->bounding_box ();
+      block = new BLOCK (name, TRUE, 0, 0,
+        block_box->left (), block_box->bottom (),
+        block_box->right (), block_box->top ());
+      block->hand_block = NULL;
+      block->hand_poly = current_block;
+      block_it->add_after_then_move (block);
+    }
+    if (!current_block->child ()->empty ())
+      scan_hpd_blocks (name, current_block->child (), block_no, block_it);
+  }
+}
+
+
+
+
+
+/**********************************************************************
+ * BLOCK::read_vec_file
+ *
+ * Read a whole vec file to make a list of blocks.
+ * Return FALSE if the .vec fiel cannot be found
+ **********************************************************************/
+
+BOOL8 read_vec_file(                    //print list of sides
+                    STRING name,        //basename of file
+                    inT32 xsize,        //image size
+                    inT32 ysize,        //image size
+                    BLOCK_LIST *blocks  //output list
+                   ) {
+  FILE *pdfp;                    //file pointer
+  BLOCK *block;                  //current block
+  inT32 block_no;                //no of blocks
+  inT32 block_index;             //current blocks
+  inT32 vector_count;            //total vectors
+  VEC_HEADER header;             //file header
+  BLOCK_HEADER *vec_blocks;      //blocks from file
+  VEC_ENTRY *vec_entries;        //vectors from file
+  BLOCK_IT block_it = blocks;    //block iterator
+  ICOORDELT_IT left_it;          //iterators
+  ICOORDELT_IT right_it;
+
+  name += VEC_EXT;               //add extension
+  if ((pdfp = fopen (name.string (), "r")) == NULL) {
+    return FALSE;                //can't find it
+  }
+  if (fread (&header, sizeof (header), 1, pdfp) != 1)
+    READFAILED.error ("read_vec_file", EXIT, "Header");
+                                 //from intel
+  header.filesize = reverse32 (header.filesize);
+  header.bytesize = reverse16 (header.bytesize);
+  header.arraysize = reverse16 (header.arraysize);
+  header.width = reverse16 (header.width);
+  header.height = reverse16 (header.height);
+  header.res = reverse16 (header.res);
+  header.bpp = reverse16 (header.bpp);
+  tprintf ("%d blocks in %s file:", header.arraysize, VEC_EXT);
+  vector_count = header.filesize - header.arraysize * sizeof (BLOCK_HEADER);
+  vector_count /= sizeof (VEC_ENTRY);
+  vec_blocks =
+    (BLOCK_HEADER *) alloc_mem (header.arraysize * sizeof (BLOCK_HEADER));
+  vec_entries = (VEC_ENTRY *) alloc_mem (vector_count * sizeof (VEC_ENTRY));
+  xsize = header.width;          //real image size
+  ysize = header.height;
+  if (fread (vec_blocks, sizeof (BLOCK_HEADER), header.arraysize, pdfp)
+    != static_cast<size_t>(header.arraysize))
+    READFAILED.error ("read_vec_file", EXIT, "Blocks");
+  if (fread (vec_entries, sizeof (VEC_ENTRY), vector_count, pdfp)
+    != static_cast<size_t>(vector_count))
+    READFAILED.error ("read_vec_file", EXIT, "Vectors");
+  for (block_index = 0; block_index < header.arraysize; block_index++) {
+    vec_blocks[block_index].offset =
+      reverse16 (vec_blocks[block_index].offset);
+    vec_blocks[block_index].order =
+      reverse16 (vec_blocks[block_index].order);
+    vec_blocks[block_index].entries =
+      reverse16 (vec_blocks[block_index].entries);
+    vec_blocks[block_index].charsize =
+      reverse16 (vec_blocks[block_index].charsize);
+  }
+  for (block_index = 0; block_index < vector_count; block_index++) {
+    vec_entries[block_index].start =
+      ICOORD (reverse16 (vec_entries[block_index].start.x ()),
+      reverse16 (vec_entries[block_index].start.y ()));
+    vec_entries[block_index].end =
+      ICOORD (reverse16 (vec_entries[block_index].end.x ()),
+      reverse16 (vec_entries[block_index].end.y ()));
+  }
+  for (block_no = 1; block_no <= header.arraysize; block_no++) {
+    for (block_index = 0; block_index < header.arraysize; block_index++) {
+      if (vec_blocks[block_index].order == block_no
+      && vec_blocks[block_index].valid) {
+        block = new BLOCK;
+        left_it.set_to_list (&block->leftside);
+        right_it.set_to_list (&block->rightside);
+        block->box =
+          convert_vec_block (&vec_entries
+          [vec_blocks[block_index].offset],
+          vec_blocks[block_index].entries, ysize,
+          &left_it, &right_it);
+        block->set_xheight (vec_blocks[block_index].charsize);
+                                 //on end of list
+        block_it.add_to_end (block);
+        //                              tprintf("Block at (%d,%d)->(%d,%d) has index %d and order %d\n",
+        //                                      block->box.left(),
+        //                                      block->box.bottom(),
+        //                                      block->box.right(),
+        //                                      block->box.top(),
+        //                                      block_index,vec_blocks[block_index].order);
+      }
+    }
+  }
+  free_mem(vec_blocks);
+  free_mem(vec_entries);
+  tprintf ("%d valid\n", block_it.length ());
+  fclose(pdfp);
+  return TRUE;                   //read one
+}
+
+
+/**********************************************************************
+ * BLOCK::convert_vec_block
+ *
+ * Read a whole vec file to make a list of blocks.
+ * Return FALSE if the .vec fiel cannot be found
+ **********************************************************************/
+
+static TBOX convert_vec_block(                        //make non-rect block
+                             VEC_ENTRY *entries,     //vectors
+                             uinT16 entry_count,     //no of entries
+                             inT32 ysize,            //image size
+                             ICOORDELT_IT *left_it,  //block sides
+                             ICOORDELT_IT *right_it) {
+  TBOX block_box;                 //bounding box
+  TBOX vec_box;                   //box of vec
+  ICOORD box_point;              //expanded coord
+  ICOORD shift_vec;              //for box expansion
+  ICOORD prev_pt;                //previous coord
+  ICOORD end_pt;                 //end of vector
+  inT32 vertex_index;            //boundary vertices
+
+  for (vertex_index = 0; vertex_index < entry_count; vertex_index++) {
+    entries[vertex_index].start = ICOORD (entries[vertex_index].start.x (),
+      ysize - 1 -
+      entries[vertex_index].start.y ());
+    entries[vertex_index].end =
+      ICOORD (entries[vertex_index].end.x (),
+      ysize - 1 - entries[vertex_index].end.y ());
+    vec_box = TBOX (entries[vertex_index].start, entries[vertex_index].end);
+    block_box += vec_box;        //find total bounds
+  }
+
+  for (vertex_index = 0; vertex_index < entry_count
+    && (entries[vertex_index].start.y () != block_box.bottom ()
+    || entries[vertex_index].end.y () != block_box.bottom ());
+    vertex_index++);
+  ASSERT_HOST (vertex_index < entry_count);
+  prev_pt = entries[vertex_index].start;
+  end_pt = entries[vertex_index].end;
+  do {
+    for (vertex_index = 0; vertex_index < entry_count
+      && entries[vertex_index].start != end_pt; vertex_index++);
+                                 //found start of vertical
+    ASSERT_HOST (vertex_index < entry_count);
+    box_point = entries[vertex_index].start;
+    if (box_point.x () <= prev_pt.x ())
+      shift_vec = ICOORD (-BLOCK_EXPANSION, -BLOCK_EXPANSION);
+    else
+      shift_vec = ICOORD (-BLOCK_EXPANSION, BLOCK_EXPANSION);
+    left_it->add_to_end (new ICOORDELT (box_point + shift_vec));
+    prev_pt = box_point;
+    for (vertex_index = 0; vertex_index < entry_count
+      && entries[vertex_index].start != end_pt; vertex_index++);
+                                 //found horizontal
+    ASSERT_HOST (vertex_index < entry_count);
+    end_pt = entries[vertex_index].end;
+  }
+  while (end_pt.y () < block_box.top ());
+  shift_vec = ICOORD (-BLOCK_EXPANSION, BLOCK_EXPANSION);
+  left_it->add_to_end (new ICOORDELT (end_pt + shift_vec));
+
+  for (vertex_index = 0; vertex_index < entry_count
+    && (entries[vertex_index].start.y () != block_box.top ()
+    || entries[vertex_index].end.y () != block_box.top ());
+    vertex_index++);
+  ASSERT_HOST (vertex_index < entry_count);
+  prev_pt = entries[vertex_index].start;
+  end_pt = entries[vertex_index].end;
+  do {
+    for (vertex_index = 0; vertex_index < entry_count
+      && entries[vertex_index].start != end_pt; vertex_index++);
+                                 //found start of vertical
+    ASSERT_HOST (vertex_index < entry_count);
+    box_point = entries[vertex_index].start;
+    if (box_point.x () < prev_pt.x ())
+      shift_vec = ICOORD (BLOCK_EXPANSION, -BLOCK_EXPANSION);
+    else
+      shift_vec = ICOORD (BLOCK_EXPANSION, BLOCK_EXPANSION);
+    right_it->add_before_then_move (new ICOORDELT (box_point + shift_vec));
+    prev_pt = box_point;
+    for (vertex_index = 0; vertex_index < entry_count
+      && entries[vertex_index].start != end_pt; vertex_index++);
+                                 //found horizontal
+    ASSERT_HOST (vertex_index < entry_count);
+    end_pt = entries[vertex_index].end;
+  }
+  while (end_pt.y () > block_box.bottom ());
+  shift_vec = ICOORD (BLOCK_EXPANSION, -BLOCK_EXPANSION);
+  right_it->add_before_then_move (new ICOORDELT (end_pt + shift_vec));
+
+  shift_vec = ICOORD (BLOCK_EXPANSION, BLOCK_EXPANSION);
+  box_point = block_box.botleft () - shift_vec;
+  end_pt = block_box.topright () + shift_vec;
+  return TBOX (box_point, end_pt);
+}
+
+
+/**********************************************************************
+ * read_unlv_file
+ *
+ * Read a whole unlv zone file to make a list of blocks.
+ **********************************************************************/
+
+BOOL8 read_unlv_file(                    //print list of sides
+                     STRING name,        //basename of file
+                     inT32 xsize,        //image size
+                     inT32 ysize,        //image size
+                     BLOCK_LIST *blocks  //output list
+                    ) {
+  FILE *pdfp;                    //file pointer
+  BLOCK *block;                  //current block
+  int x;                         //current top-down coords
+  int y;
+  int width;                     //of current block
+  int height;
+  BLOCK_IT block_it = blocks;    //block iterator
+
+  name += UNLV_EXT;              //add extension
+  if ((pdfp = fopen (name.string (), "r")) == NULL) {
+    return FALSE;                //didn't read one
+  }
+  else {
+    while (fscanf (pdfp, "%d %d %d %d %*s", &x, &y, &width, &height) >= 4) {
+                                 //make rect block
+      block = new BLOCK (name.string (), TRUE, 0, 0,
+                         (inT16) x, (inT16) (ysize - y - height),
+                         (inT16) (x + width), (inT16) (ysize - y));
+                                 //on end of list
+      block_it.add_to_end (block);
+    }
+    fclose(pdfp);
+  }
+  return true;
+}