#include "config_auto.h"

#include "config_auto.h"

#endif

#endif

#include "allheaders.h"

#include "allheaders.h"

#include "svshowim.h"

#include "svshowim.h"

  window->Image(pix, xpos, window->TranslateYCoordinate(yext) + ypos);

  window->Image(pix, xpos, window->TranslateYCoordinate(yext) + ypos);

  pixDestroy(&pix);

  pixDestroy(&pix);

}

}

 * Blank display of word then redisplay word according to current display mode

 * Blank display of word then redisplay word according to current display mode

 * settings

 * settings

 */

 */

namespace tesseract {

namespace tesseract {

BOOL8 Tesseract:: word_blank_and_set_display(BLOCK* block, ROW* row,

BOOL8 Tesseract:: word_blank_and_set_display(BLOCK* block, ROW* row,

                                             WERD_RES* word_res) {

                                             WERD_RES* word_res) {

  word_res->word->bounding_box().plot(image_win, ScrollView::BLACK,

  word_res->word->bounding_box().plot(image_win, ScrollView::BLACK,

      editor_image_word_bb_color));

      editor_image_word_bb_color));

  return TRUE;

  return TRUE;

}

}

/**

/**

 * word_dumper()

 * word_dumper()

  return TRUE;

  return TRUE;

}

}

/**

/**

 * word_set_display()  Word processor

 * word_set_display()  Word processor

 *

 *

  word->set_display_flag(DF_BLAMER, word_display_mode.bit(DF_BLAMER));

  word->set_display_flag(DF_BLAMER, word_display_mode.bit(DF_BLAMER));

  return word_display(block, row, word_res);

  return word_display(block, row, word_res);

}

}

}  // namespace tesseract

}  // namespace tesseract

#include "textord.h"

#include "textord.h"

#include "wordrec.h"

#include "wordrec.h"

class PAGE_RES;

class PAGE_RES;

class PAGE_RES_IT;

class PAGE_RES_IT;

class BLOCK_LIST;

class BLOCK_LIST;

  //// pgedit.h //////////////////////////////////////////////////////////

  //// pgedit.h //////////////////////////////////////////////////////////

  SVMenuNode *build_menu_new();

  SVMenuNode *build_menu_new();

  void pgeditor_main(int width, int height, PAGE_RES* page_res);

  void pgeditor_main(int width, int height, PAGE_RES* page_res);

  void process_image_event( // action in image win

  void process_image_event( // action in image win

                           const SVEvent &event);

                           const SVEvent &event);

  BOOL8 process_cmd_win_event(                 // UI command semantics

  BOOL8 process_cmd_win_event(                 // UI command semantics

  BOOL8 word_bln_display(BLOCK* block, ROW* row, WERD_RES* word_res);

  BOOL8 word_bln_display(BLOCK* block, ROW* row, WERD_RES* word_res);

  BOOL8 word_blank_and_set_display(BLOCK* block, ROW* row, WERD_RES* word_res);

  BOOL8 word_blank_and_set_display(BLOCK* block, ROW* row, WERD_RES* word_res);

  BOOL8 word_set_display(BLOCK* block, ROW* row, WERD_RES* word_res);

  BOOL8 word_set_display(BLOCK* block, ROW* row, WERD_RES* word_res);

  BOOL8 word_dumper(BLOCK* block, ROW* row, WERD_RES* word_res);

  BOOL8 word_dumper(BLOCK* block, ROW* row, WERD_RES* word_res);

  //// reject.h //////////////////////////////////////////////////////////

  //// reject.h //////////////////////////////////////////////////////////

  void make_reject_map(            //make rej map for wd //detailed results

  void make_reject_map(            //make rej map for wd //detailed results

                       WERD_RES *word,

                       WERD_RES *word,

void TESSLINE::plot(ScrollView* window, ScrollView::Color color,

void TESSLINE::plot(ScrollView* window, ScrollView::Color color,

                    ScrollView::Color child_color) {

                    ScrollView::Color child_color) {

  if (is_hole)

  if (is_hole)

    window->Pen(child_color);

    window->Pen(child_color);

  else

  else

    else

    else

      window->DrawTo(pt->pos.x, pt->pos.y);

      window->DrawTo(pt->pos.x, pt->pos.y);

  } while (pt != loop);

  } while (pt != loop);

}

}

// Iterate the given list of outlines, converting to TESSLINE by polygonal

// Iterate the given list of outlines, converting to TESSLINE by polygonal

#include          "blckerr.h"

#include          "blckerr.h"

#include          "stepblob.h"

#include          "stepblob.h"

enum WERD_FLAGS

enum WERD_FLAGS

{

{

  W_SEGMENTED,                   //< correctly segmented

  W_SEGMENTED,                   //< correctly segmented

    // tprintf word metadata (but not blob innards)

    // tprintf word metadata (but not blob innards)

    void print();

    void print();

    // plot word on window in a uniform colour

    // plot word on window in a uniform colour

    void plot(ScrollView *window, ScrollView::Color colour);

    void plot(ScrollView *window, ScrollView::Color colour);

    // Get the next color in the (looping) rainbow.

    // Get the next color in the (looping) rainbow.

    static ScrollView::Color NextColor(ScrollView::Color colour);

    static ScrollView::Color NextColor(ScrollView::Color colour);

    // plot word on window in a rainbow of colours

    // plot word on window in a rainbow of colours

    void plot(ScrollView *window);

    void plot(ScrollView *window);

    // plot rejected blobs in a rainbow of colours

    // plot rejected blobs in a rainbow of colours

    void plot_rej_blobs(ScrollView *window);

    void plot_rej_blobs(ScrollView *window);

 private:

 private:

    uinT8 blanks;                // no of blanks

    uinT8 blanks;                // no of blanks

#include "linlsq.h"

#include "linlsq.h"

#include "werd.h"

#include "werd.h"

#define FIRST_COLOUR    ScrollView::RED         //< first rainbow colour

#define FIRST_COLOUR    ScrollView::RED         //< first rainbow colour

#define LAST_COLOUR     ScrollView::AQUAMARINE  //< last rainbow colour

#define LAST_COLOUR     ScrollView::AQUAMARINE  //< last rainbow colour

#define CHILD_COLOUR    ScrollView::BROWN       //< colour of children

#define CHILD_COLOUR    ScrollView::BROWN       //< colour of children

  }

  }

  plot_rej_blobs(window);

  plot_rej_blobs(window);

}

}

// Get the next color in the (looping) rainbow.

// Get the next color in the (looping) rainbow.

ScrollView::Color WERD::NextColor(ScrollView::Color colour) {

ScrollView::Color WERD::NextColor(ScrollView::Color colour) {

  ScrollView::Color next = static_cast<ScrollView::Color>(colour + 1);

  ScrollView::Color next = static_cast<ScrollView::Color>(colour + 1);

  return next;

  return next;

}

}

/**

/**

 * WERD::plot

 * WERD::plot

 *

 *

  }

  }

  plot_rej_blobs(window);

  plot_rej_blobs(window);

}

}

/**

/**

 * Draw the WERD rejected blobs in window - ALWAYS GREY

 * Draw the WERD rejected blobs in window - ALWAYS GREY

 */

 */

void WERD::plot_rej_blobs(ScrollView *window) {

void WERD::plot_rej_blobs(ScrollView *window) {

  C_BLOB_IT it = &rej_cblobs;

  C_BLOB_IT it = &rej_cblobs;

  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {

  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {

    it.data()->plot(window, ScrollView::GREY, ScrollView::GREY);

    it.data()->plot(window, ScrollView::GREY, ScrollView::GREY);

  }

  }

}

}

/**

/**

  // Prints summary stats only of the histogram.

  // Prints summary stats only of the histogram.

  void print_summary() const;

  void print_summary() const;

  // Draws the histogram as a series of rectangles.

  // Draws the histogram as a series of rectangles.

  void plot(ScrollView* window,   // window to draw in

  void plot(ScrollView* window,   // window to draw in

            float xorigin,   // origin of histo

            float xorigin,   // origin of histo

                float xscale,    // size of one unit

                float xscale,    // size of one unit

                float yscale,    // size of one uint

                float yscale,    // size of one uint

                ScrollView::Color colour) const;  // colour to draw in

                ScrollView::Color colour) const;  // colour to draw in

 private:

 private:

  inT32 rangemin_;                // min of range

  inT32 rangemin_;                // min of range

  // rangemax_ is not well named as it is really one past the max.

  // rangemax_ is not well named as it is really one past the max.

#include <stdio.h>

#include <stdio.h>

class ScrollView;

class ScrollView;

class SVNetwork;

class SVNetwork;

class SVMutex;

class SVMutex;

// - A LMB click either draws point-to-point, point or text.

// - A LMB click either draws point-to-point, point or text.

// - A LMB dragging either draws a line, a rectangle or ellipse.

// - A LMB dragging either draws a line, a rectangle or ellipse.

#include "scrollview.h"

#include "scrollview.h"

#include "svmnode.h"

#include "svmnode.h"

#include <stdlib.h>

#include <stdlib.h>

#include <iostream>

#include <iostream>

// The current color values we use, initially white (== ScrollView::WHITE).

// The current color values we use, initially white (== ScrollView::WHITE).

int rgb[3] = { 255, 255, 255 };

int rgb[3] = { 255, 255, 255 };

	if (argc > 1) { server_name = argv[1]; } else { server_name = "localhost"; }

	if (argc > 1) { server_name = argv[1]; } else { server_name = "localhost"; }

	SVPaint svp(server_name);

	SVPaint svp(server_name);

}

}

AC_MSG_CHECKING(--enable-graphics argument)

AC_MSG_CHECKING(--enable-graphics argument)

AC_ARG_ENABLE([graphics],

AC_ARG_ENABLE([graphics],

    [enable_graphics=$enableval],

    [enable_graphics=$enableval],

    [enable_graphics="yes"])

    [enable_graphics="yes"])

AC_MSG_RESULT($enable_graphics)

AC_MSG_RESULT($enable_graphics)

if test "$enable_graphics" = "no"; then

if test "$enable_graphics" = "no"; then

fi

fi

# check whether to build embedded version

# check whether to build embedded version

  AC_SUBST([AM_CPPFLAGS], [-DEMBEDDED])

  AC_SUBST([AM_CPPFLAGS], [-DEMBEDDED])

fi

fi

# check whether to build multiple libraries

# check whether to build multiple libraries

AC_MSG_CHECKING(--enable-multiple-libraries argument)

AC_MSG_CHECKING(--enable-multiple-libraries argument)

AC_ARG_ENABLE([multiple-libraries],

AC_ARG_ENABLE([multiple-libraries],

    [enable_mlibs=$enableval],

    [enable_mlibs=$enableval],

    [enable_mlibs="no"])

    [enable_mlibs="no"])

AC_MSG_RESULT($enable_mlibs)

AC_MSG_RESULT($enable_mlibs)

// See the License for the specific language governing permissions and

// See the License for the specific language governing permissions and

// limitations under the License.

// limitations under the License.

#include <ctype.h>

#include <ctype.h>

#include <stdarg.h>

#include <stdarg.h>

#include <stddef.h>

#include <stddef.h>

  TO_BLOCK_IT block_it = blocks;          // destination iterator

  TO_BLOCK_IT block_it = blocks;          // destination iterator

  TO_BLOCK *block;                        // created block

  TO_BLOCK *block;                        // created block

  if (to_win != NULL)

  if (to_win != NULL)

    to_win->Clear();

    to_win->Clear();

  for (block_it.mark_cycle_pt(); !block_it.cycled_list();

  for (block_it.mark_cycle_pt(); !block_it.cycled_list();

       block_it.forward()) {

       block_it.forward()) {

    block = block_it.data();

    block = block_it.data();

         tesseract::CCStruct::kXHeightFraction;

         tesseract::CCStruct::kXHeightFraction;

    block->line_size *= textord_min_linesize;

    block->line_size *= textord_min_linesize;

    block->max_blob_size = block->line_size * textord_excess_blobsize;

    block->max_blob_size = block->line_size * textord_excess_blobsize;

    if (textord_show_blobs && testing_on) {

    if (textord_show_blobs && testing_on) {

      if (to_win == NULL)

      if (to_win == NULL)

        create_to_win(page_tr);

        create_to_win(page_tr);

      plot_box_list(to_win, &block->large_blobs, ScrollView::WHITE);

      plot_box_list(to_win, &block->large_blobs, ScrollView::WHITE);

      plot_box_list(to_win, &block->blobs, ScrollView::WHITE);

      plot_box_list(to_win, &block->blobs, ScrollView::WHITE);

    }

    }

  }

  }

}

}

// Display the edges of the columns at the given y coords.

// Display the edges of the columns at the given y coords.

void ColPartitionSet::DisplayColumnEdges(int y_bottom, int y_top,

void ColPartitionSet::DisplayColumnEdges(int y_bottom, int y_top,

                                         ScrollView* win) {

                                         ScrollView* win) {

  ColPartition_IT it(&parts_);

  ColPartition_IT it(&parts_);

  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {

  for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {

    ColPartition* part = it.data();

    ColPartition* part = it.data();

    win->Line(part->LeftAtY(y_top), y_top, part->LeftAtY(y_bottom), y_bottom);

    win->Line(part->LeftAtY(y_top), y_top, part->LeftAtY(y_bottom), y_bottom);

    win->Line(part->RightAtY(y_top), y_top, part->RightAtY(y_bottom), y_bottom);

    win->Line(part->RightAtY(y_top), y_top, part->RightAtY(y_bottom), y_bottom);

  }

  }

}

}

// Return the ColumnSpanningType that best explains the columns overlapped

// Return the ColumnSpanningType that best explains the columns overlapped

                             BLOBNBOX_LIST* image_blobs, TO_BLOCK* block,

                             BLOBNBOX_LIST* image_blobs, TO_BLOCK* block,

                             int min_gutter_width,

                             int min_gutter_width,

                             FCOORD* deskew, FCOORD* reskew) {

                             FCOORD* deskew, FCOORD* reskew) {

  ScrollView* tab_win = FindInitialTabVectors(image_blobs, min_gutter_width,

  ScrollView* tab_win = FindInitialTabVectors(image_blobs, min_gutter_width,

                                                  block);

                                                  block);

  TabVector::MergeSimilarTabVectors(vertical_skew_, &vectors_, this);

  TabVector::MergeSimilarTabVectors(vertical_skew_, &vectors_, this);

  SortVectors();

  SortVectors();

  CleanupTabs();

  CleanupTabs();

    return false;  // Skew angle is too large.

    return false;  // Skew angle is too large.

  part_grid->Deskew(*deskew);

  part_grid->Deskew(*deskew);

  ApplyTabConstraints();

  ApplyTabConstraints();

  if (textord_tabfind_show_finaltabs) {

  if (textord_tabfind_show_finaltabs) {

    tab_win = MakeWindow(640, 50, "FinalTabs");

    tab_win = MakeWindow(640, 50, "FinalTabs");

    if (textord_debug_images) {

    if (textord_debug_images) {

    }

    }

    tab_win = DisplayTabVectors(tab_win);

    tab_win = DisplayTabVectors(tab_win);

  }

  }

  return true;

  return true;

}

}

  left_tab_boxes_.sort(SortByBoxLeft<BLOBNBOX>);

  left_tab_boxes_.sort(SortByBoxLeft<BLOBNBOX>);

  right_tab_boxes_.sort(SortRightToLeft<BLOBNBOX>);

  right_tab_boxes_.sort(SortRightToLeft<BLOBNBOX>);

  ScrollView* tab_win = NULL;

  ScrollView* tab_win = NULL;

  if (textord_tabfind_show_initialtabs) {

  if (textord_tabfind_show_initialtabs) {

    tab_win = MakeWindow(0, 100, "InitialTabs");

    tab_win = MakeWindow(0, 100, "InitialTabs");

    tab_win->Pen(ScrollView::BLUE);

    tab_win->Pen(ScrollView::BLUE);

    DisplayBoxVector(right_tab_boxes_, tab_win);

    DisplayBoxVector(right_tab_boxes_, tab_win);

    tab_win = DisplayTabs("Tabs", tab_win);

    tab_win = DisplayTabs("Tabs", tab_win);

  }

  }

  return tab_win;

  return tab_win;

}

}

  // Set the aligned_text_ member of each blob, so text lines traces

  // Set the aligned_text_ member of each blob, so text lines traces

  // get terminated where there is a change from text to image.

  // get terminated where there is a change from text to image.

  ComputeBlobGoodness();

  ComputeBlobGoodness();

  if (tab_win != NULL)

  if (tab_win != NULL)

    tab_win->Pen(ScrollView::WHITE);

    tab_win->Pen(ScrollView::WHITE);

  // Accumulate column sections into a STATS

  // Accumulate column sections into a STATS

  if (tab_win != NULL) {

  if (tab_win != NULL) {

    tab_win->Update();

    tab_win->Update();

  }

  }

  // Now make a list of column widths.

  // Now make a list of column widths.

  ICOORDELT_IT w_it(&column_widths_);

  ICOORDELT_IT w_it(&column_widths_);

  int total_col_count = col_widths.get_total();

  int total_col_count = col_widths.get_total();

  // Recompute margins based on a local neighbourhood search.

  // Recompute margins based on a local neighbourhood search.

  part_grid_.GridFindMargins(best_columns_);

  part_grid_.GridFindMargins(best_columns_);

  SetPartitionTypes();

  SetPartitionTypes();

  if (textord_tabfind_show_initial_partitions) {

  if (textord_tabfind_show_initial_partitions) {

    ScrollView* part_win = MakeWindow(100, 300, "InitialPartitions");

    ScrollView* part_win = MakeWindow(100, 300, "InitialPartitions");

    part_grid_.DisplayBoxes(part_win);

    part_grid_.DisplayBoxes(part_win);

    DisplayTabVectors(part_win);

    DisplayTabVectors(part_win);

  }

  }

  if (textord_tabfind_find_tables) {

  if (textord_tabfind_find_tables) {

    TableFinder table_finder;

    TableFinder table_finder;

  part_grid_.FindFigureCaptions();

  part_grid_.FindFigureCaptions();

  part_grid_.RefinePartitionPartners(true);

  part_grid_.RefinePartitionPartners(true);

  SmoothPartnerRuns();

  SmoothPartnerRuns();

  if (textord_tabfind_show_partitions) {

  if (textord_tabfind_show_partitions) {

    ScrollView* window = MakeWindow(400, 300, "Partitions");

    ScrollView* window = MakeWindow(400, 300, "Partitions");

    if (textord_debug_images)

    if (textord_debug_images)

      delete window->AwaitEvent(SVET_DESTROY);

      delete window->AwaitEvent(SVET_DESTROY);

    }

    }

  }

  }

  part_grid_.AssertNoDuplicates();

  part_grid_.AssertNoDuplicates();

  // Ownership of the ColPartitions moves from part_sets_ to part_grid_ here,

  // Ownership of the ColPartitions moves from part_sets_ to part_grid_ here,

  // and ownership of the BLOBNBOXes moves to the ColPartitions.

  // and ownership of the BLOBNBOXes moves to the ColPartitions.

  DisplayBlocks(blocks);

  DisplayBlocks(blocks);

  RotateAndReskewBlocks(input_is_rtl, to_blocks);

  RotateAndReskewBlocks(input_is_rtl, to_blocks);

  int result = 0;

  int result = 0;

  if (blocks_win_ != NULL) {

  if (blocks_win_ != NULL) {

    bool waiting = false;

    bool waiting = false;

    do {

    do {

      delete event;

      delete event;

    } while (waiting);

    } while (waiting);

  }

  }

  return result;

  return result;

}

}

  set_global_median_xheight(static_cast<int>(xheight_stats.median() + 0.5));

  set_global_median_xheight(static_cast<int>(xheight_stats.median() + 0.5));

  set_global_median_blob_width(static_cast<int>(width_stats.median() + 0.5));

  set_global_median_blob_width(static_cast<int>(width_stats.median() + 0.5));

  set_global_median_ledding(static_cast<int>(ledding_stats.median() + 0.5));

  set_global_median_ledding(static_cast<int>(ledding_stats.median() + 0.5));

  if (textord_tablefind_show_stats) {

  if (textord_tablefind_show_stats) {

    const char* kWindowName = "X-height (R), X-width (G), and ledding (B)";

    const char* kWindowName = "X-height (R), X-width (G), and ledding (B)";

    ScrollView* stats_win = MakeWindow(500, 10, kWindowName);

    ScrollView* stats_win = MakeWindow(500, 10, kWindowName);

    width_stats.plot(stats_win, 10, 200, 2, 15, ScrollView::GREEN);

    width_stats.plot(stats_win, 10, 200, 2, 15, ScrollView::GREEN);

    ledding_stats.plot(stats_win, 10, 200, 2, 15, ScrollView::BLUE);

    ledding_stats.plot(stats_win, 10, 200, 2, 15, ScrollView::BLUE);

  }

  }

}

}

void TableFinder::set_global_median_xheight(int xheight) {

void TableFinder::set_global_median_xheight(int xheight) {

StrokeWidth::~StrokeWidth() {

StrokeWidth::~StrokeWidth() {

  if (widths_win_ != NULL) {

  if (widths_win_ != NULL) {

    delete widths_win_->AwaitEvent(SVET_DESTROY);

    delete widths_win_->AwaitEvent(SVET_DESTROY);

    if (textord_tabfind_only_strokewidths)

    if (textord_tabfind_only_strokewidths)

      exit(0);

      exit(0);

    delete widths_win_;

    delete widths_win_;

      best_blob->set_leader_on_right(true);

      best_blob->set_leader_on_right(true);

    else

    else

      best_blob->set_leader_on_left(true);

      best_blob->set_leader_on_left(true);

    if (leaders_win_ != NULL) {

    if (leaders_win_ != NULL) {

      leaders_win_->Pen(left_of_part ? ScrollView::RED : ScrollView::GREEN);

      leaders_win_->Pen(left_of_part ? ScrollView::RED : ScrollView::GREEN);

      const TBOX& blob_box = best_blob->bounding_box();

      const TBOX& blob_box = best_blob->bounding_box();

      leaders_win_->Rectangle(blob_box.left(), blob_box.bottom(),

      leaders_win_->Rectangle(blob_box.left(), blob_box.bottom(),

                              blob_box.right(), blob_box.top());

                              blob_box.right(), blob_box.top());

    }

    }

  }

  }

}

}

  return copy;

  return copy;

}

}

// Provides a color for BBGrid to draw the rectangle.

// Provides a color for BBGrid to draw the rectangle.

// Must be kept in sync with PolyBlockType.

// Must be kept in sync with PolyBlockType.

ScrollView::Color  ColPartition::BoxColor() const {

ScrollView::Color  ColPartition::BoxColor() const {

    return BLOBNBOX::TextlineColor(blob_type_, flow_);

    return BLOBNBOX::TextlineColor(blob_type_, flow_);

  return POLY_BLOCK::ColorForPolyBlockType(type_);

  return POLY_BLOCK::ColorForPolyBlockType(type_);

}

}

// Keep in sync with BlobRegionType.

// Keep in sync with BlobRegionType.

static char kBlobTypes[BRT_COUNT + 1] = "NHSRIUVT";

static char kBlobTypes[BRT_COUNT + 1] = "NHSRIUVT";

  if (truth_cb_ != NULL) truth_cb_->Run(image_height_, page_res_);

  if (truth_cb_ != NULL) truth_cb_->Run(image_height_, page_res_);

  if (tesseract_->interactive_mode) {

  if (tesseract_->interactive_mode) {

    tesseract_->pgeditor_main(rect_width_, rect_height_, page_res_);

    tesseract_->pgeditor_main(rect_width_, rect_height_, page_res_);

    // The page_res is invalid after an interactive session, so cleanup

    // The page_res is invalid after an interactive session, so cleanup

    // in a way that lets us continue to the next page without crashing.

    // in a way that lets us continue to the next page without crashing.

    delete page_res_;

    delete page_res_;

/*----------------------------------------------------------------------------

/*----------------------------------------------------------------------------

            Public Code

            Public Code

-----------------------------------------------------------------------------*/

-----------------------------------------------------------------------------*/

void DisplayProtoList(const char* ch, LIST protolist) {

void DisplayProtoList(const char* ch, LIST protolist) {

  void* window = c_create_window("Char samples", 50, 200,

  void* window = c_create_window("Char samples", 50, 200,

                                 520, 520, -130.0, 130.0, -130.0, 130.0);

                                 520, 520, -130.0, 130.0, -130.0, 130.0);

  }

  }

  c_make_current(window);

  c_make_current(window);

}

}

// Helper to run clustering on a single config.

// Helper to run clustering on a single config.

// Mostly copied from the old mftraining, but with renamed variables.

// Mostly copied from the old mftraining, but with renamed variables.

      // Merge.

      // Merge.

      MergeInsignificantProtos(ProtoList, CharSample->Label,

      MergeInsignificantProtos(ProtoList, CharSample->Label,

                               Clusterer, &Config);

                               Clusterer, &Config);

      if (strcmp(test_ch, CharSample->Label) == 0)

      if (strcmp(test_ch, CharSample->Label) == 0)

        DisplayProtoList(test_ch, ProtoList);

        DisplayProtoList(test_ch, ProtoList);

      ProtoList = RemoveInsignificantProtos(ProtoList, true,

      ProtoList = RemoveInsignificantProtos(ProtoList, true,

                                            false,

                                            false,

                                            Clusterer->SampleSize);

                                            Clusterer->SampleSize);

// Clears the window and draws baselines.

// Clears the window and draws baselines.

void Classify::RefreshDebugWindow(ScrollView **win, const char *msg,

void Classify::RefreshDebugWindow(ScrollView **win, const char *msg,

                                  int y_offset, const TBOX &wbox) {

                                  int y_offset, const TBOX &wbox) {

  const int kSampleSpaceWidth = 500;

  const int kSampleSpaceWidth = 500;

  if (*win == NULL) {

  if (*win == NULL) {

    *win = new ScrollView(msg, 100, y_offset, kSampleSpaceWidth * 2, 200,

    *win = new ScrollView(msg, 100, y_offset, kSampleSpaceWidth * 2, 200,

               kSampleSpaceWidth, kBlnXHeight + kBlnBaselineOffset);

               kSampleSpaceWidth, kBlnXHeight + kBlnBaselineOffset);

  (*win)->ZoomToRectangle(wbox.left(), wbox.top(),

  (*win)->ZoomToRectangle(wbox.left(), wbox.top(),

                          wbox.right(), wbox.bottom());

                          wbox.right(), wbox.bottom());

}

}

// Learns the given word using its chopped_word, seam_array, denorm,

// Learns the given word using its chopped_word, seam_array, denorm,

  int start_blob = 0;

  int start_blob = 0;

  char prev_map_char = '0';

  char prev_map_char = '0';

  if (classify_debug_character_fragments) {

  if (classify_debug_character_fragments) {

    if (learn_fragmented_word_debug_win_ != NULL) {

    if (learn_fragmented_word_debug_win_ != NULL) {

      window_wait(learn_fragmented_word_debug_win_);

      window_wait(learn_fragmented_word_debug_win_);

    word->chopped_word->plot(learn_fragmented_word_debug_win_);

    word->chopped_word->plot(learn_fragmented_word_debug_win_);

    ScrollView::Update();

    ScrollView::Update();

  }

  }

  for (int ch = 0; ch < word_len; ++ch) {

  for (int ch = 0; ch < word_len; ++ch) {

    if (classify_debug_character_fragments) {

    if (classify_debug_character_fragments) {

  if (rotated_blob == NULL)

  if (rotated_blob == NULL)

    rotated_blob = blob;

    rotated_blob = blob;

  // Draw debug windows showing the blob that is being learned if needed.

  // Draw debug windows showing the blob that is being learned if needed.

  if (strcmp(classify_learn_debug_str.string(), correct_text) == 0) {

  if (strcmp(classify_learn_debug_str.string(), correct_text) == 0) {

    RefreshDebugWindow(&learn_debug_win_, "LearnPieces", 600,

    RefreshDebugWindow(&learn_debug_win_, "LearnPieces", 600,

               ScrollView::BLUE, ScrollView::BROWN);

               ScrollView::BLUE, ScrollView::BROWN);

    learn_fragments_debug_win_->Update();

    learn_fragments_debug_win_->Update();

  }

  }

  if (filename != NULL) {

  if (filename != NULL) {

    classify_norm_method.set_value(character);  // force char norm spc 30/11/93

    classify_norm_method.set_value(character);  // force char norm spc 30/11/93

                    INT_CLASS Class,

                    INT_CLASS Class,

                    PROTO_ID ProtoId,

                    PROTO_ID ProtoId,

                    ScrollView::Color color);

                    ScrollView::Color color);

int TruncateParam(FLOAT32 Param, int Min, int Max, char *Id);

int TruncateParam(FLOAT32 Param, int Min, int Max, char *Id);

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/**

/**

 * Initializes the int matcher window if it is not already

 * Initializes the int matcher window if it is not already

 * initialized.

 * initialized.

ScrollView* CreateFeatureSpaceWindow(const char* name, int xpos, int ypos) {

ScrollView* CreateFeatureSpaceWindow(const char* name, int xpos, int ypos) {

  return new ScrollView(name, xpos, ypos, 520, 520, 260, 260, true);

  return new ScrollView(name, xpos, ypos, 520, 520, 260, 260, true);

}

}

}  // namespace tesseract.

}  // namespace tesseract.

/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/

void RenderIntFeature(ScrollView *window, const INT_FEATURE_STRUCT* Feature,

void RenderIntFeature(ScrollView *window, const INT_FEATURE_STRUCT* Feature,

                      ScrollView::Color color);

                      ScrollView::Color color);

// Creates a window of the appropriate size for displaying elements

// Creates a window of the appropriate size for displaying elements

// in feature space.

// in feature space.

ScrollView* CreateFeatureSpaceWindow(const char* name, int xpos, int ypos);

ScrollView* CreateFeatureSpaceWindow(const char* name, int xpos, int ypos);

#endif

#endif