| /********************************************************************** |
| * File: charcut.cpp (Formerly charclip.c) |
| * Description: Code for character clipping |
| * Author: Phil Cheatle |
| * Created: Wed Nov 11 08:35:15 GMT 1992 |
| * |
| * (C) Copyright 1992, 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 "charcut.h" |
| #include "imgs.h" |
| #include "svshowim.h" |
| //#include "evnts.h" |
| #include "notdll.h" |
| #include "scrollview.h" |
| |
| #define LARGEST(a,b) ( (a) > (b) ? (a) : (b) ) |
| #define SMALLEST(a,b) ( (a) > (b) ? (b) : (a) ) |
| #define BUG_OFFSET 1 |
| #define EXTERN |
| |
| EXTERN INT_VAR (pix_word_margin, 3, "How far outside word BB to grow"); |
| |
| extern IMAGE page_image; |
| |
| ELISTIZE (PIXROW) |
| /************************************************************************* |
| * PIXROW::PIXROW() |
| * |
| * Constructor for a specified size PIXROW from a blob |
| *************************************************************************/ |
| PIXROW::PIXROW(inT16 pos, inT16 count, PBLOB *blob) { |
| OUTLINE_LIST *outline_list; |
| OUTLINE_IT outline_it; |
| POLYPT_LIST *pts_list; |
| POLYPT_IT pts_it; |
| inT16 i; |
| FCOORD pt; |
| FCOORD vec; |
| float y_coord; |
| inT16 x_coord; |
| |
| row_offset = pos; |
| row_count = count; |
| min = (inT16 *) alloc_mem (count * sizeof (inT16)); |
| max = (inT16 *) alloc_mem (count * sizeof (inT16)); |
| outline_list = blob->out_list (); |
| outline_it.set_to_list (outline_list); |
| |
| for (i = 0; i < count; i++) { |
| min[i] = MAX_INT16 - 1; |
| max[i] = -MAX_INT16 + 1; |
| y_coord = row_offset + i + 0.5; |
| for (outline_it.mark_cycle_pt (); |
| !outline_it.cycled_list (); outline_it.forward ()) { |
| pts_list = outline_it.data ()->polypts (); |
| pts_it.set_to_list (pts_list); |
| for (pts_it.mark_cycle_pt (); |
| !pts_it.cycled_list (); pts_it.forward ()) { |
| pt = pts_it.data ()->pos; |
| vec = pts_it.data ()->vec; |
| if ((vec.y () != 0) && |
| (((pt.y () <= y_coord) && (pt.y () + vec.y () >= y_coord)) |
| || ((pt.y () >= y_coord) |
| && (pt.y () + vec.y () <= y_coord)))) { |
| /* The segment crosses y_coord so find x-point and check for min/max. */ |
| x_coord = (inT16) floor ((y_coord - |
| pt.y ()) * vec.x () / vec.y () + |
| pt.x () + 0.5); |
| if (x_coord < min[i]) |
| min[i] = x_coord; |
| x_coord--; //to get pix to left of line |
| if (x_coord > max[i]) |
| max[i] = x_coord; |
| } |
| } |
| } |
| } |
| } |
| |
| |
| /************************************************************************* |
| * PIXROW::plot() |
| * |
| * Draw the PIXROW |
| *************************************************************************/ |
| |
| #ifndef GRAPHICS_DISABLED |
| void PIXROW::plot(ScrollView* fd //where to paint |
| ) const { |
| inT16 i; |
| inT16 y_coord; |
| |
| for (i = 0; i < row_count; i++) { |
| y_coord = row_offset + i; |
| if (min[i] <= max[i]) { |
| fd->Rectangle(min[i], y_coord, max[i] + 1, y_coord + 1); |
| } |
| } |
| } |
| #endif |
| |
| /************************************************************************* |
| * PIXROW::bounding_box() |
| * |
| * Generate bounding box for blob image |
| *************************************************************************/ |
| |
| bool PIXROW::bad_box( //return true if box exceeds image |
| int xsize, |
| int ysize) const { |
| TBOX bbox = bounding_box (); |
| if (bbox.left () < 0 || bbox.right () > xsize |
| || bbox.top () > ysize || bbox.bottom () < 0) { |
| tprintf("Box (%d,%d)->(%d,%d) bad compared to %d,%d\n", |
| bbox.left(),bbox.bottom(), bbox.right(), bbox.top(), |
| xsize, ysize); |
| return true; |
| } |
| return false; |
| } |
| |
| |
| /************************************************************************* |
| * PIXROW::bounding_box() |
| * |
| * Generate bounding box for blob image |
| *************************************************************************/ |
| |
| TBOX PIXROW::bounding_box() const { |
| inT16 i; |
| inT16 y_coord; |
| inT16 min_x = MAX_INT16 - 1; |
| inT16 min_y = MAX_INT16 - 1; |
| inT16 max_x = -MAX_INT16 + 1; |
| inT16 max_y = -MAX_INT16 + 1; |
| |
| for (i = 0; i < row_count; i++) { |
| y_coord = row_offset + i; |
| if (min[i] <= max[i]) { |
| if (y_coord < min_y) |
| min_y = y_coord; |
| if (y_coord + 1 > max_y) |
| max_y = y_coord + 1; |
| if (min[i] < min_x) |
| min_x = min[i]; |
| if (max[i] + 1 > max_x) |
| max_x = max[i] + 1; |
| } |
| } |
| if (min_x > max_x || min_y > max_y) |
| return TBOX (); |
| else |
| return TBOX (ICOORD (min_x, min_y), ICOORD (max_x, max_y)); |
| } |
| |
| |
| /************************************************************************* |
| * PIXROW::contract() |
| * |
| * Reduce the mins and maxs so that they end on black pixels |
| *************************************************************************/ |
| |
| void PIXROW::contract( //image array |
| IMAGELINE *imlines, |
| inT16 x_offset, //of pixels[0] |
| inT16 foreground_colour //0 or 1 |
| ) { |
| inT16 i; |
| uinT8 *line_pixels; |
| |
| for (i = 0; i < row_count; i++) { |
| if (min[i] > max[i]) |
| continue; |
| |
| line_pixels = imlines[i].pixels; |
| while (line_pixels[min[i] - x_offset] != foreground_colour) { |
| if (min[i] == max[i]) { |
| min[i] = MAX_INT16 - 1; |
| max[i] = -MAX_INT16 + 1; |
| goto nextline; |
| } |
| else |
| min[i]++; |
| } |
| while (line_pixels[max[i] - x_offset] != foreground_colour) { |
| if (min[i] == max[i]) { |
| min[i] = MAX_INT16 - 1; |
| max[i] = -MAX_INT16 + 1; |
| goto nextline; |
| } |
| else |
| max[i]--; |
| } |
| nextline:; |
| //goto label! |
| } |
| } |
| |
| |
| /************************************************************************* |
| * PIXROW::extend() |
| * |
| * 1 pixel extension in each direction to cover extra black area |
| *************************************************************************/ |
| |
| BOOL8 PIXROW::extend( //image array |
| IMAGELINE *imlines, |
| TBOX &imbox, |
| PIXROW *prev, //for prev blob |
| PIXROW *next, //for next blob |
| inT16 foreground_colour) { |
| inT16 i; |
| inT16 x_offset = imbox.left (); |
| inT16 limit; |
| inT16 left_limit; |
| inT16 right_limit; |
| uinT8 *pixels = NULL; |
| uinT8 *pixels_below = NULL; //row below current |
| uinT8 *pixels_above = NULL; //row above current |
| BOOL8 changed = FALSE; |
| |
| pixels_above = imlines[0].pixels; |
| for (i = 0; i < row_count; i++) { |
| pixels_below = pixels; |
| pixels = pixels_above; |
| if (i < (row_count - 1)) |
| pixels_above = imlines[i + 1].pixels; |
| else |
| pixels_above = NULL; |
| |
| /* Extend Left by one pixel*/ |
| if (prev == NULL || prev->max[i] < prev->min[i]) |
| limit = imbox.left (); |
| else |
| limit = prev->max[i] + 1; |
| if ((min[i] <= max[i]) && |
| (min[i] > limit) && |
| (pixels[min[i] - 1 - x_offset] == foreground_colour)) { |
| min[i]--; |
| changed = TRUE; |
| } |
| |
| /* Extend Right by one pixel*/ |
| if (next == NULL || next->min[i] > next->max[i]) |
| limit = imbox.right () - 1;//-1 to index inside pix |
| else |
| limit = next->min[i] - 1; |
| if ((min[i] <= max[i]) && |
| (max[i] < limit) && |
| (pixels[max[i] + 1 - x_offset] == foreground_colour)) { |
| max[i]++; |
| changed = TRUE; |
| } |
| |
| /* Extend down by one row */ |
| if (pixels_below != NULL) { |
| if (min[i] < min[i - 1]) { //row goes left of row below |
| if (prev == NULL || prev->max[i - 1] < prev->min[i - 1]) |
| left_limit = min[i]; |
| else |
| left_limit = LARGEST (min[i], prev->max[i - 1] + 1); |
| } |
| else |
| left_limit = min[i - 1]; |
| |
| if (max[i] > max[i - 1]) { //row goes right of row below |
| if (next == NULL || next->min[i - 1] > next->max[i - 1]) |
| right_limit = max[i]; |
| else |
| right_limit = SMALLEST (max[i], next->min[i - 1] - 1); |
| } |
| else |
| right_limit = max[i - 1]; |
| |
| while ((left_limit <= right_limit) && |
| (pixels_below[left_limit - x_offset] != foreground_colour)) |
| left_limit++; //find black extremity |
| |
| if ((left_limit <= right_limit) && (left_limit < min[i - 1])) { |
| min[i - 1] = left_limit; //widen left if poss |
| changed = TRUE; |
| } |
| |
| while ((left_limit <= right_limit) && |
| (pixels_below[right_limit - x_offset] != foreground_colour)) |
| right_limit--; //find black extremity |
| |
| if ((left_limit <= right_limit) && (right_limit > max[i - 1])) { |
| max[i - 1] = right_limit;//widen right if poss |
| changed = TRUE; |
| } |
| } |
| |
| /* Extend up by one row */ |
| if (pixels_above != NULL) { |
| if (min[i] < min[i + 1]) { //row goes left of row above |
| if (prev == NULL || prev->min[i + 1] > prev->max[i + 1]) |
| left_limit = min[i]; |
| else |
| left_limit = LARGEST (min[i], prev->max[i + 1] + 1); |
| } |
| else |
| left_limit = min[i + 1]; |
| |
| if (max[i] > max[i + 1]) { //row goes right of row above |
| if (next == NULL || next->min[i + 1] > next->max[i + 1]) |
| right_limit = max[i]; |
| else |
| right_limit = SMALLEST (max[i], next->min[i + 1] - 1); |
| } |
| else |
| right_limit = max[i + 1]; |
| |
| while ((left_limit <= right_limit) && |
| (pixels_above[left_limit - x_offset] != foreground_colour)) |
| left_limit++; //find black extremity |
| |
| if ((left_limit <= right_limit) && (left_limit < min[i + 1])) { |
| min[i + 1] = left_limit; //widen left if poss |
| changed = TRUE; |
| } |
| |
| while ((left_limit <= right_limit) && |
| (pixels_above[right_limit - x_offset] != foreground_colour)) |
| right_limit--; //find black extremity |
| |
| if ((left_limit <= right_limit) && (right_limit > max[i + 1])) { |
| max[i + 1] = right_limit;//widen right if poss |
| changed = TRUE; |
| } |
| } |
| } |
| return changed; |
| } |
| |
| |
| /************************************************************************* |
| * PIXROW::char_clip_image() |
| * Cut out a sub image for a character |
| *************************************************************************/ |
| |
| void PIXROW::char_clip_image( //box of imlines extnt |
| IMAGELINE *imlines, |
| TBOX &im_box, |
| ROW *row, //row containing word |
| IMAGE &clip_image, //unscaled sq subimage |
| float &baseline_pos //baseline ht in image |
| ) { |
| inT16 clip_image_xsize; //sub image x size |
| inT16 clip_image_ysize; //sub image y size |
| inT16 x_shift; //from pixrow to subim |
| inT16 y_shift; //from pixrow to subim |
| TBOX char_pix_box; //bbox of char pixels |
| inT16 y_dest; |
| inT16 x_min; |
| inT16 x_max; |
| inT16 x_min_dest; |
| inT16 x_max_dest; |
| inT16 x_width; |
| inT16 y; |
| |
| clip_image_xsize = clip_image.get_xsize (); |
| clip_image_ysize = clip_image.get_ysize (); |
| |
| char_pix_box = bounding_box (); |
| /* |
| The y shift is calculated by first finding the coord of the bottom of the |
| image relative to the image lines. Then reducing this so by the amount |
| relative to the clip image size, necessary to vertically position the |
| character. |
| */ |
| y_shift = char_pix_box.bottom () - row_offset - |
| (inT16) floor ((clip_image_ysize - char_pix_box.height () + 0.5) / 2); |
| |
| /* |
| The x_shift is the shift to be applied to the page coord in the pixrow to |
| generate a centred char in the clip image. Thus the left hand edge of the |
| char is shifted to the margin width of the centred character. |
| */ |
| x_shift = char_pix_box.left () - |
| (inT16) floor ((clip_image_xsize - char_pix_box.width () + 0.5) / 2); |
| |
| for (y = 0; y < row_count; y++) { |
| /* |
| Check that there is something in this row of the source that will fit in the |
| sub image. If there is, reduce x range if necessary, then copy it |
| */ |
| y_dest = y - y_shift; |
| if ((min[y] <= max[y]) && (y_dest >= 0) && (y_dest < clip_image_ysize)) { |
| x_min = min[y]; |
| x_min_dest = x_min - x_shift; |
| if (x_min_dest < 0) { |
| x_min = x_min - x_min_dest; |
| x_min_dest = 0; |
| } |
| x_max = max[y]; |
| x_max_dest = x_max - x_shift; |
| if (x_max_dest > clip_image_xsize - 1) { |
| x_max = x_max - (x_max_dest - (clip_image_xsize - 1)); |
| x_max_dest = clip_image_xsize - 1; |
| } |
| x_width = x_max - x_min + 1; |
| if (x_width > 0) { |
| x_min -= im_box.left (); |
| //offset pixel ptr |
| imlines[y].pixels += x_min; |
| clip_image.put_line (x_min_dest, y_dest, x_width, imlines + y, |
| 0); |
| imlines[y].init (); //reset pixel ptr |
| } |
| } |
| } |
| /* |
| Baseline position relative to clip image: First find the baseline relative |
| to the page origin at the x coord of the centre of the character. Then |
| make this relative to the character bottom. Finally shift by the margin |
| between the bottom of the character and the bottom of the clip image. |
| */ |
| if (row == NULL) |
| baseline_pos = 0; //Not needed |
| else |
| baseline_pos = row->base_line ((char_pix_box.left () + |
| char_pix_box.right ()) / 2.0) |
| - char_pix_box.bottom () |
| + ((clip_image_ysize - char_pix_box.height ()) / 2); |
| } |
| |
| |
| /************************************************************************* |
| * char_clip_word() |
| * |
| * Generate a PIXROW_LIST with one element for each blob in the word, together |
| * with the image lines for the whole word. |
| *************************************************************************/ |
| |
| void char_clip_word( // |
| WERD *word, //word to be processed |
| IMAGE &bin_image, //whole image |
| PIXROW_LIST *&pixrow_list, //pixrows built |
| IMAGELINE *&imlines, //lines cut from image |
| TBOX &pix_box //box defining imlines |
| ) { |
| TBOX word_box = word->bounding_box (); |
| PBLOB_LIST *blob_list; |
| PBLOB_IT blob_it; |
| PIXROW_IT pixrow_it; |
| inT16 pix_offset; //Y pos of pixrow[0] |
| inT16 row_height; //No of pix rows |
| inT16 imlines_x_offset; |
| PIXROW *prev; |
| PIXROW *next; |
| PIXROW *current; |
| BOOL8 changed; //still improving |
| BOOL8 just_changed; //still improving |
| inT16 iteration_count = 0; |
| inT16 foreground_colour; |
| |
| if (word->flag (W_INVERSE)) |
| foreground_colour = 1; |
| else |
| foreground_colour = 0; |
| |
| /* Define region for max pixrow expansion */ |
| pix_box = word_box; |
| pix_box.move_bottom_edge (-pix_word_margin); |
| pix_box.move_top_edge (pix_word_margin); |
| pix_box.move_left_edge (-pix_word_margin); |
| pix_box.move_right_edge (pix_word_margin); |
| pix_box -= TBOX (ICOORD (0, 0 + BUG_OFFSET), |
| ICOORD (bin_image.get_xsize (), |
| bin_image.get_ysize () - BUG_OFFSET)); |
| |
| /* Generate pixrows list */ |
| |
| pix_offset = pix_box.bottom (); |
| row_height = pix_box.height (); |
| blob_list = word->blob_list (); |
| blob_it.set_to_list (blob_list); |
| |
| pixrow_list = new PIXROW_LIST; |
| pixrow_it.set_to_list (pixrow_list); |
| |
| for (blob_it.mark_cycle_pt (); !blob_it.cycled_list (); blob_it.forward ()) { |
| PIXROW *row = new PIXROW (pix_offset, row_height, blob_it.data ()); |
| ASSERT_HOST (!row-> |
| bad_box (bin_image.get_xsize (), bin_image.get_ysize ())); |
| pixrow_it.add_after_then_move (row); |
| } |
| |
| imlines = generate_imlines (bin_image, pix_box); |
| |
| /* Contract pixrows - shrink min and max back to black pixels */ |
| |
| imlines_x_offset = pix_box.left (); |
| |
| pixrow_it.move_to_first (); |
| for (pixrow_it.mark_cycle_pt (); |
| !pixrow_it.cycled_list (); pixrow_it.forward ()) { |
| ASSERT_HOST (!pixrow_it.data ()-> |
| bad_box (bin_image.get_xsize (), bin_image.get_ysize ())); |
| pixrow_it.data ()->contract (imlines, imlines_x_offset, |
| foreground_colour); |
| ASSERT_HOST (!pixrow_it.data ()-> |
| bad_box (bin_image.get_xsize (), bin_image.get_ysize ())); |
| } |
| |
| /* Expand pixrows iteratively 1 pixel at a time */ |
| do { |
| changed = FALSE; |
| pixrow_it.move_to_first (); |
| prev = NULL; |
| current = NULL; |
| next = pixrow_it.data (); |
| for (pixrow_it.mark_cycle_pt (); |
| !pixrow_it.cycled_list (); pixrow_it.forward ()) { |
| prev = current; |
| current = next; |
| if (pixrow_it.at_last ()) |
| next = NULL; |
| else |
| next = pixrow_it.data_relative (1); |
| just_changed = current->extend (imlines, pix_box, prev, next, |
| foreground_colour); |
| ASSERT_HOST (!current-> |
| bad_box (bin_image.get_xsize (), |
| bin_image.get_ysize ())); |
| changed = changed || just_changed; |
| } |
| iteration_count++; |
| } |
| while (changed); |
| } |
| |
| |
| /************************************************************************* |
| * generate_imlines() |
| * Get an array of IMAGELINES holding a portion of an image |
| *************************************************************************/ |
| |
| IMAGELINE *generate_imlines( //get some imagelines |
| IMAGE &bin_image, //from here |
| TBOX &pix_box) { |
| IMAGELINE *imlines; //array of lines |
| int i; |
| |
| imlines = new IMAGELINE[pix_box.height ()]; |
| for (i = 0; i < pix_box.height (); i++) { |
| imlines[i].init (pix_box.width ()); |
| //coord to start at |
| bin_image.fast_get_line (pix_box.left (), |
| pix_box.bottom () + i + BUG_OFFSET, |
| //line to get |
| pix_box.width (), //width to get |
| imlines + i); //dest imline |
| } |
| return imlines; |
| } |
| |
| |
| /************************************************************************* |
| * display_clip_image() |
| * All the boring user interface bits to let you see what's going on |
| *************************************************************************/ |
| |
| #ifndef GRAPHICS_DISABLED |
| ScrollView* display_clip_image(WERD *word, //word to be processed |
| IMAGE &bin_image, //whole image |
| PIXROW_LIST *pixrow_list, //pixrows built |
| TBOX &pix_box //box of subimage |
| ) { |
| ScrollView* clip_window; //window for debug |
| TBOX word_box = word->bounding_box (); |
| int border = word_box.height () / 2; |
| TBOX display_box = word_box; |
| |
| display_box.move_bottom_edge (-border); |
| display_box.move_top_edge (border); |
| display_box.move_left_edge (-border); |
| display_box.move_right_edge (border); |
| display_box -= TBOX (ICOORD (0, 0 - BUG_OFFSET), |
| ICOORD (bin_image.get_xsize (), |
| bin_image.get_ysize () - BUG_OFFSET)); |
| |
| pgeditor_msg ("Creating Clip window..."); |
| clip_window = new ScrollView("Clipped Blobs", |
| editor_word_xpos, editor_word_ypos, |
| 3 * (word_box.width () + 2 * border), |
| 3 * (word_box.height () + 2 * border), |
| display_box.left () + display_box.right (), |
| display_box.bottom () - BUG_OFFSET + |
| display_box.top () - BUG_OFFSET, |
| true); |
| // ymin, ymax |
| pgeditor_msg ("Creating Clip window...Done"); |
| |
| clip_window->Clear(); |
| sv_show_sub_image (&bin_image, |
| display_box.left (), |
| display_box.bottom (), |
| display_box.width (), |
| display_box.height (), |
| clip_window, |
| display_box.left (), display_box.bottom () - BUG_OFFSET); |
| |
| word->plot (clip_window, ScrollView::RED); |
| word_box.plot (clip_window, ScrollView::BLUE, ScrollView::BLUE); |
| pix_box.plot (clip_window, ScrollView::BLUE, ScrollView::BLUE); |
| plot_pixrows(pixrow_list, clip_window); |
| return clip_window; |
| } |
| |
| |
| /************************************************************************* |
| * display_images() |
| * Show a pair of clip and scaled character images and wait for key before |
| * continuing. |
| *************************************************************************/ |
| |
| void display_images(IMAGE &clip_image, IMAGE &scaled_image) { |
| ScrollView* clip_im_window; //window for debug |
| ScrollView* scale_im_window; //window for debug |
| inT16 i; |
| |
| // xmin xmax ymin ymax |
| clip_im_window = new ScrollView ("Clipped Blob", editor_word_xpos - 20, |
| editor_word_ypos - 100, 5 * clip_image.get_xsize (), |
| 5 * clip_image.get_ysize (), clip_image.get_xsize (), |
| clip_image.get_ysize (), true); |
| |
| sv_show_sub_image (&clip_image, |
| 0, 0, |
| clip_image.get_xsize (), clip_image.get_ysize (), |
| clip_im_window, 0, 0); |
| |
| clip_im_window->Pen(255,0,0); |
| for (i = 1; i < clip_image.get_xsize (); i++) { |
| clip_im_window->SetCursor(i,0); |
| clip_im_window->DrawTo(i, clip_image.get_xsize ()); |
| } |
| for (i = 1; i < clip_image.get_ysize (); i++) { |
| clip_im_window->SetCursor(0,i); |
| clip_im_window->DrawTo(clip_image.get_xsize (),i); |
| |
| } |
| |
| // xmin xmax ymin ymax |
| scale_im_window = new ScrollView ("Scaled Blob", editor_word_xpos + 300, |
| editor_word_ypos - 100, 5 * scaled_image.get_xsize (), |
| 5 * scaled_image.get_ysize (), scaled_image.get_xsize (), |
| scaled_image.get_ysize (), true); |
| |
| sv_show_sub_image (&scaled_image, |
| 0, 0, |
| scaled_image.get_xsize (), scaled_image.get_ysize (), |
| scale_im_window, 0, 0); |
| |
| scale_im_window->Pen(255,0,0); |
| for (i = 1; i < scaled_image.get_xsize (); i++) { |
| scale_im_window->SetCursor(i,0); |
| scale_im_window->DrawTo(i, scaled_image.get_xsize ()); |
| } |
| for (i = 1; i < scaled_image.get_ysize (); i++) { |
| scale_im_window->SetCursor(0,i); |
| scale_im_window->DrawTo(scaled_image.get_xsize (),i); |
| } |
| |
| ScrollView::Update(); |
| } |
| |
| |
| /************************************************************************* |
| * plot_pixrows() |
| * Display a list of pixrows |
| *************************************************************************/ |
| |
| void plot_pixrows( //plot for all blobs |
| PIXROW_LIST *pixrow_list, |
| ScrollView* win) { |
| PIXROW_IT pixrow_it(pixrow_list); |
| inT16 colour = ScrollView::RED; |
| |
| for (pixrow_it.mark_cycle_pt (); |
| !pixrow_it.cycled_list (); pixrow_it.forward ()) { |
| if (colour > ScrollView::RED + 7) |
| colour = ScrollView::RED; |
| |
| win->Pen((ScrollView::Color) colour); |
| pixrow_it.data ()->plot (win); |
| colour++; |
| } |
| } |
| #endif |
