tesseract_bin 1.0.0

data/vendor/tesseract-2.04/textord/pithsync.h

@@ -0,0 +1,134 @@
+/**********************************************************************
+ * File:        pithsync.h  (Formerly pitsync2.h)
+ * Description: Code to find the optimum fixed pitch segmentation of some blobs.
+ * Author:		Ray Smith
+ * Created:		Thu Nov 19 11:48:05 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.
+ *
+ **********************************************************************/
+
+#ifndef           PITHSYNC_H
+#define           PITHSYNC_H
+
+#include          "blobbox.h"
+#include          "varable.h"
+#include          "statistc.h"
+#include          "notdll.h"
+
+class FPSEGPT_LIST;
+
+class FPCUTPT
+{
+  public:
+    FPCUTPT() {  //empty
+    }
+    void setup (                 //start of cut
+      FPCUTPT cutpts[],          //predecessors
+      inT16 array_origin,        //start coord
+      STATS * projection,        //occupation
+      inT16 zero_count,          //official zero
+      inT16 pitch,               //proposed pitch
+      inT16 x,                   //position
+      inT16 offset);             //dist to gap
+
+    void assign (                //evaluate cut
+      FPCUTPT cutpts[],          //predecessors
+      inT16 array_origin,        //start coord
+      inT16 x,                   //position
+      BOOL8 faking,              //faking this one
+      BOOL8 mid_cut,             //doing free cut
+      inT16 offset,              //extra cost dist
+      STATS * projection,        //occupation
+      float projection_scale,    //scaling
+      inT16 zero_count,          //official zero
+      inT16 pitch,               //proposed pitch
+      inT16 pitch_error);        //allowed tolerance
+
+    void assign_cheap (          //evaluate cut
+      FPCUTPT cutpts[],          //predecessors
+      inT16 array_origin,        //start coord
+      inT16 x,                   //position
+      BOOL8 faking,              //faking this one
+      BOOL8 mid_cut,             //doing free cut
+      inT16 offset,              //extra cost dist
+      STATS * projection,        //occupation
+      float projection_scale,    //scaling
+      inT16 zero_count,          //official zero
+      inT16 pitch,               //proposed pitch
+      inT16 pitch_error);        //allowed tolerance
+
+    inT32 position() {  //acces func
+      return xpos;
+    }
+    double cost_function() {
+      return cost;
+    }
+    double squares() {
+      return sq_sum;
+    }
+    double sum() {
+      return mean_sum;
+    }
+    FPCUTPT *previous() {
+      return pred;
+    }
+    inT16 cheap_cuts() const {  //no of mi cuts
+      return mid_cuts;
+    }
+    inT16 index() const {
+      return region_index;
+    }
+
+    BOOL8 faked;                 //faked split point
+    BOOL8 terminal;              //successful end
+    inT16 fake_count;            //total fakes to here
+
+  private:
+    inT16 region_index;          //cut serial number
+    inT16 mid_cuts;              //no of cheap cuts
+    inT32 xpos;                  //location
+    uinT32 back_balance;         //proj backwards
+    uinT32 fwd_balance;          //proj forwards
+    FPCUTPT *pred;               //optimal previous
+    double mean_sum;             //mean so far
+    double sq_sum;               //summed distsances
+    double cost;                 //cost function
+};
+double check_pitch_sync2(                          //find segmentation
+                         BLOBNBOX_IT *blob_it,     //blobs to do
+                         inT16 blob_count,         //no of blobs
+                         inT16 pitch,              //pitch estimate
+                         inT16 pitch_error,        //tolerance
+                         STATS *projection,        //vertical
+                         inT16 projection_left,    //edges //scale factor
+                         inT16 projection_right,
+                         float projection_scale,
+                         inT16 &occupation_count,  //no of occupied cells
+                         FPSEGPT_LIST *seg_list,   //output list
+                         inT16 start,              //start of good range
+                         inT16 end                 //end of good range
+                        );
+double check_pitch_sync3(                          //find segmentation
+                         inT16 projection_left,    //edges //to be considered 0
+                         inT16 projection_right,
+                         inT16 zero_count,
+                         inT16 pitch,              //pitch estimate
+                         inT16 pitch_error,        //tolerance
+                         STATS *projection,        //vertical
+                         float projection_scale,   //scale factor
+                         inT16 &occupation_count,  //no of occupied cells
+                         FPSEGPT_LIST *seg_list,   //output list
+                         inT16 start,              //start of good range
+                         inT16 end                 //end of good range
+                        );
+#endif

data/vendor/tesseract-2.04/textord/pitsync1.cpp

@@ -0,0 +1,425 @@
+/**********************************************************************
+ * File:        pitsync1.cpp  (Formerly pitsync.c)
+ * Description: Code to find the optimum fixed pitch segmentation of some blobs.
+ * Author:		Ray Smith
+ * Created:		Thu Nov 19 11:48:05 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"
+#ifdef __UNIX__
+#include          <assert.h>
+#endif
+#include          <math.h>
+#include          "memry.h"
+#include          "pitsync1.h"
+
+#include          "notdll.h"
+
+ELISTIZE (FPSEGPT) CLISTIZE (FPSEGPT_LIST)
+#define EXTERN
+EXTERN
+INT_VAR (pitsync_linear_version, 6, "Use new fast algorithm");
+EXTERN
+double_VAR (pitsync_joined_edge, 0.75,
+"Dist inside big blob for chopping");
+EXTERN
+double_VAR (pitsync_offset_freecut_fraction, 0.25,
+"Fraction of cut for free cuts");
+EXTERN
+INT_VAR (pitsync_fake_depth, 1, "Max advance fake generation");
+
+/**********************************************************************
+ * FPSEGPT::FPSEGPT
+ *
+ * Constructor to make a new FPSEGPT.
+ * The existing FPCUTPT is duplicated.
+ **********************************************************************/
+
+FPSEGPT::FPSEGPT(                //constructor
+                 FPCUTPT *cutpt  //create from new form
+                ) {
+  pred = NULL;
+  mean_sum = cutpt->sum ();
+  sq_sum = cutpt->squares ();
+  cost = cutpt->cost_function ();
+  faked = cutpt->faked;
+  terminal = cutpt->terminal;
+  fake_count = cutpt->fake_count;
+  xpos = cutpt->position ();
+  mid_cuts = cutpt->cheap_cuts ();
+}
+
+
+/**********************************************************************
+ * FPSEGPT::FPSEGPT
+ *
+ * Constructor to make a new FPSEGPT.
+ **********************************************************************/
+
+FPSEGPT::FPSEGPT (               //constructor
+inT16 x                          //position
+):xpos (x) {
+  pred = NULL;
+  mean_sum = 0;
+  sq_sum = 0;
+  cost = 0;
+  faked = FALSE;
+  terminal = FALSE;
+  fake_count = 0;
+  mid_cuts = 0;
+}
+
+
+/**********************************************************************
+ * FPSEGPT::FPSEGPT
+ *
+ * Constructor to make a new FPSEGPT.
+ **********************************************************************/
+
+FPSEGPT::FPSEGPT (               //constructor
+inT16 x,                         //position
+BOOL8 faking,                    //faking this one
+inT16 offset,                    //dist to gap
+inT16 region_index,              //segment number
+inT16 pitch,                     //proposed pitch
+inT16 pitch_error,               //allowed tolerance
+FPSEGPT_LIST * prev_list         //previous segment
+):xpos (x) {
+  inT16 best_fake;               //on previous
+  FPSEGPT *segpt;                //segment point
+  inT32 dist;                    //from prev segment
+  double sq_dist;                //squared distance
+  double mean;                   //mean pitch
+  double total;                  //total dists
+  double factor;                 //cost function
+  FPSEGPT_IT pred_it = prev_list;//for previuos segment
+
+  cost = MAX_FLOAT32;
+  pred = NULL;
+  faked = faking;
+  terminal = FALSE;
+  best_fake = MAX_INT16;
+  mid_cuts = 0;
+  for (pred_it.mark_cycle_pt (); !pred_it.cycled_list (); pred_it.forward ()) {
+    segpt = pred_it.data ();
+    if (segpt->fake_count < best_fake)
+      best_fake = segpt->fake_count;
+    dist = x - segpt->xpos;
+    if (dist >= pitch - pitch_error && dist <= pitch + pitch_error
+    && !segpt->terminal) {
+      total = segpt->mean_sum + dist;
+      sq_dist = dist * dist + segpt->sq_sum + offset * offset;
+      //sum of squarees
+      mean = total / region_index;
+      factor = mean - pitch;
+      factor *= factor;
+      factor += sq_dist / (region_index) - mean * mean;
+      if (factor < cost) {
+        cost = factor;           //find least cost
+        pred = segpt;            //save path
+        mean_sum = total;
+        sq_sum = sq_dist;
+        fake_count = segpt->fake_count + faked;
+      }
+    }
+  }
+  if (fake_count > best_fake + 1)
+    pred = NULL;                 //fail it
+}
+
+
+/**********************************************************************
+ * check_pitch_sync
+ *
+ * Construct the lattice of possible segmentation points and choose the
+ * optimal path. Return the optimal path only.
+ * The return value is a measure of goodness of the sync.
+ **********************************************************************/
+
+double check_pitch_sync(                        //find segmentation
+                        BLOBNBOX_IT *blob_it,   //blobs to do
+                        inT16 blob_count,       //no of blobs
+                        inT16 pitch,            //pitch estimate
+                        inT16 pitch_error,      //tolerance
+                        STATS *projection,      //vertical
+                        FPSEGPT_LIST *seg_list  //output list
+                       ) {
+  inT16 x;                       //current coord
+  inT16 min_index;               //blob number
+  inT16 max_index;               //blob number
+  inT16 left_edge;               //of word
+  inT16 right_edge;              //of word
+  inT16 right_max;               //max allowed x
+  inT16 min_x;                   //in this region
+  inT16 max_x;
+  inT16 region_index;
+  inT16 best_region_index = 0;   //for best result
+  inT16 offset;                  //dist to legal area
+  inT16 left_best_x;             //edge of good region
+  inT16 right_best_x;            //right edge
+  TBOX min_box;                   //bounding box
+  TBOX max_box;                   //bounding box
+  TBOX next_box;                  //box of next blob
+  FPSEGPT *segpt;                //segment point
+  FPSEGPT_LIST *segpts;          //points in a segment
+  double best_cost;              //best path
+  double mean_sum;               //computes result
+  FPSEGPT *best_end;             //end of best path
+  BLOBNBOX_IT min_it;            //copy iterator
+  BLOBNBOX_IT max_it;            //copy iterator
+  FPSEGPT_IT segpt_it;           //iterator
+                                 //output segments
+  FPSEGPT_IT outseg_it = seg_list;
+  FPSEGPT_LIST_CLIST lattice;    //list of lists
+                                 //region iterator
+  FPSEGPT_LIST_C_IT lattice_it = &lattice;
+
+  //      tprintf("Computing sync on word of %d blobs with pitch %d\n",
+  //              blob_count, pitch);
+  //      if (blob_count==8 && pitch==27)
+  //              projection->print(stdout,TRUE);
+  if (pitch < 3)
+    pitch = 3;                   //nothing ludicrous
+  if ((pitch - 3) / 2 < pitch_error)
+    pitch_error = (pitch - 3) / 2;
+  min_it = *blob_it;
+  min_box = box_next (&min_it);  //get box
+  //      if (blob_count==8 && pitch==27)
+  //              tprintf("1st box at (%d,%d)->(%d,%d)\n",
+  //                      min_box.left(),min_box.bottom(),
+  //                      min_box.right(),min_box.top());
+                                 //left of word
+  left_edge = min_box.left () + pitch_error;
+  for (min_index = 1; min_index < blob_count; min_index++) {
+    min_box = box_next (&min_it);
+    //              if (blob_count==8 && pitch==27)
+    //                      tprintf("Box at (%d,%d)->(%d,%d)\n",
+    //                              min_box.left(),min_box.bottom(),
+    //                              min_box.right(),min_box.top());
+  }
+  right_edge = min_box.right (); //end of word
+  max_x = left_edge;
+                                 //min permissible
+  min_x = max_x - pitch + pitch_error * 2 + 1;
+  right_max = right_edge + pitch - pitch_error - 1;
+  segpts = new FPSEGPT_LIST;     //list of points
+  segpt_it.set_to_list (segpts);
+  for (x = min_x; x <= max_x; x++) {
+    segpt = new FPSEGPT (x);     //make a new one
+                                 //put in list
+    segpt_it.add_after_then_move (segpt);
+  }
+                                 //first segment
+  lattice_it.add_before_then_move (segpts);
+  min_index = 0;
+  region_index = 1;
+  best_cost = MAX_FLOAT32;
+  best_end = NULL;
+  min_it = *blob_it;
+  min_box = box_next (&min_it);  //first box
+  do {
+    left_best_x = -1;
+    right_best_x = -1;
+    segpts = new FPSEGPT_LIST;   //list of points
+    segpt_it.set_to_list (segpts);
+    min_x += pitch - pitch_error;//next limits
+    max_x += pitch + pitch_error;
+    while (min_box.right () < min_x && min_index < blob_count) {
+      min_index++;
+      min_box = box_next (&min_it);
+    }
+    max_it = min_it;
+    max_index = min_index;
+    max_box = min_box;
+    next_box = box_next (&max_it);
+    for (x = min_x; x <= max_x && x <= right_max; x++) {
+      while (x < right_edge && max_index < blob_count
+      && x > max_box.right ()) {
+        max_index++;
+        max_box = next_box;
+        next_box = box_next (&max_it);
+      }
+      if (x <= max_box.left () + pitch_error
+        || x >= max_box.right () - pitch_error || x >= right_edge
+        || (max_index < blob_count - 1 && x >= next_box.left ())
+        || (x - max_box.left () > pitch * pitsync_joined_edge
+      && max_box.right () - x > pitch * pitsync_joined_edge)) {
+      //                      || projection->local_min(x))
+        if (x - max_box.left () > 0
+          && x - max_box.left () <= pitch_error)
+                                 //dist to real break
+          offset = x - max_box.left ();
+        else if (max_box.right () - x > 0
+          && max_box.right () - x <= pitch_error
+          && (max_index >= blob_count - 1
+          || x < next_box.left ()))
+          offset = max_box.right () - x;
+        else
+          offset = 0;
+        //                              offset=pitsync_offset_freecut_fraction*projection->pile_count(x);
+        segpt = new FPSEGPT (x, FALSE, offset, region_index,
+          pitch, pitch_error, lattice_it.data ());
+      }
+      else {
+        offset = projection->pile_count (x);
+        segpt = new FPSEGPT (x, TRUE, offset, region_index,
+          pitch, pitch_error, lattice_it.data ());
+      }
+      if (segpt->previous () != NULL) {
+        segpt_it.add_after_then_move (segpt);
+        if (x >= right_edge - pitch_error) {
+          segpt->terminal = TRUE;//no more wanted
+          if (segpt->cost_function () < best_cost) {
+            best_cost = segpt->cost_function ();
+            //find least
+            best_end = segpt;
+            best_region_index = region_index;
+            left_best_x = x;
+            right_best_x = x;
+          }
+          else if (segpt->cost_function () == best_cost
+            && right_best_x == x - 1)
+            right_best_x = x;
+        }
+      }
+      else {
+        delete segpt;            //no good
+      }
+    }
+    if (segpts->empty ()) {
+      if (best_end != NULL)
+        break;                   //already found one
+      make_illegal_segment (lattice_it.data (), min_box, min_it,
+        region_index, pitch, pitch_error, segpts);
+    }
+    else {
+      if (right_best_x > left_best_x + 1) {
+        left_best_x = (left_best_x + right_best_x + 1) / 2;
+        for (segpt_it.mark_cycle_pt (); !segpt_it.cycled_list ()
+          && segpt_it.data ()->position () != left_best_x;
+          segpt_it.forward ());
+        if (segpt_it.data ()->position () == left_best_x)
+                                 //middle of region
+          best_end = segpt_it.data ();
+      }
+    }
+                                 //new segment
+    lattice_it.add_before_then_move (segpts);
+    region_index++;
+  }
+  while (min_x < right_edge);
+  ASSERT_HOST (best_end != NULL);//must always find some
+
+  for (lattice_it.mark_cycle_pt (); !lattice_it.cycled_list ();
+  lattice_it.forward ()) {
+    segpts = lattice_it.data ();
+    segpt_it.set_to_list (segpts);
+    //              if (blob_count==8 && pitch==27)
+    //              {
+    //                      for (segpt_it.mark_cycle_pt();!segpt_it.cycled_list();segpt_it.forward())
+    //                      {
+    //                              segpt=segpt_it.data();
+    //                              tprintf("At %d, (%x) cost=%g, m=%g, sq=%g, pred=%x\n",
+    //                                      segpt->position(),segpt,segpt->cost_function(),
+    //                                      segpt->sum(),segpt->squares(),segpt->previous());
+    //                      }
+    //                      tprintf("\n");
+    //              }
+    for (segpt_it.mark_cycle_pt (); !segpt_it.cycled_list ()
+      && segpt_it.data () != best_end; segpt_it.forward ());
+    if (segpt_it.data () == best_end) {
+                                 //save good one
+      segpt = segpt_it.extract ();
+      outseg_it.add_before_then_move (segpt);
+      best_end = segpt->previous ();
+    }
+  }
+  ASSERT_HOST (best_end == NULL);
+  ASSERT_HOST (!outseg_it.empty ());
+  outseg_it.move_to_last ();
+  mean_sum = outseg_it.data ()->sum ();
+  mean_sum = mean_sum * mean_sum / best_region_index;
+  if (outseg_it.data ()->squares () - mean_sum < 0)
+    tprintf ("Impossible sqsum=%g, mean=%g, total=%d\n",
+      outseg_it.data ()->squares (), outseg_it.data ()->sum (),
+      best_region_index);
+  lattice.deep_clear ();         //shift the lot
+  return outseg_it.data ()->squares () - mean_sum;
+}
+
+
+/**********************************************************************
+ * make_illegal_segment
+ *
+ * Make a fake set of chop points due to having no legal places.
+ **********************************************************************/
+
+void make_illegal_segment(                          //find segmentation
+                          FPSEGPT_LIST *prev_list,  //previous segments
+                          TBOX blob_box,             //bounding box
+                          BLOBNBOX_IT blob_it,      //iterator
+                          inT16 region_index,       //number of segment
+                          inT16 pitch,              //pitch estimate
+                          inT16 pitch_error,        //tolerance
+                          FPSEGPT_LIST *seg_list    //output list
+                         ) {
+  inT16 x;                       //current coord
+  inT16 min_x = 0;               //in this region
+  inT16 max_x = 0;
+  inT16 offset;                  //dist to edge
+  FPSEGPT *segpt;                //segment point
+  FPSEGPT *prevpt;               //previous point
+  float best_cost;               //best path
+  FPSEGPT_IT segpt_it = seg_list;//iterator
+                                 //previous points
+  FPSEGPT_IT prevpt_it = prev_list;
+
+  best_cost = MAX_FLOAT32;
+  for (prevpt_it.mark_cycle_pt (); !prevpt_it.cycled_list ();
+  prevpt_it.forward ()) {
+    prevpt = prevpt_it.data ();
+    if (prevpt->cost_function () < best_cost) {
+                                 //find least
+      best_cost = prevpt->cost_function ();
+      min_x = prevpt->position ();
+      max_x = min_x;             //limits on coords
+    }
+    else if (prevpt->cost_function () == best_cost) {
+      max_x = prevpt->position ();
+    }
+  }
+  min_x += pitch - pitch_error;
+  max_x += pitch + pitch_error;
+  for (x = min_x; x <= max_x; x++) {
+    while (x > blob_box.right ()) {
+      blob_box = box_next (&blob_it);
+    }
+    offset = x - blob_box.left ();
+    if (blob_box.right () - x < offset)
+      offset = blob_box.right () - x;
+    segpt = new FPSEGPT (x, FALSE, offset,
+      region_index, pitch, pitch_error, prev_list);
+    if (segpt->previous () != NULL) {
+      ASSERT_HOST (offset >= 0);
+      fprintf (stderr, "made fake at %d\n", x);
+                                 //make one up
+      segpt_it.add_after_then_move (segpt);
+      segpt->faked = TRUE;
+      segpt->fake_count++;
+    }
+    else
+      delete segpt;
+  }
+}

data/vendor/tesseract-2.04/textord/pitsync1.h

@@ -0,0 +1,135 @@
+/**********************************************************************
+ * File:        pitsync1.h  (Formerly pitsync.h)
+ * Description: Code to find the optimum fixed pitch segmentation of some blobs.
+ * Author:		Ray Smith
+ * Created:		Thu Nov 19 11:48:05 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.
+ *
+ **********************************************************************/
+
+#ifndef           PITSYNC1_H
+#define           PITSYNC1_H
+
+#include          "elst.h"
+#include          "clst.h"
+#include          "blobbox.h"
+#include          "varable.h"
+#include          "statistc.h"
+#include          "pithsync.h"
+#include          "notdll.h"
+#include          "notdll.h"
+
+class FPSEGPT_LIST;
+
+class FPSEGPT:public ELIST_LINK
+{
+  public:
+    FPSEGPT() {  //empty
+    }
+    FPSEGPT(           //constructor
+            inT16 x);  //position
+    FPSEGPT(                           //constructor
+            inT16 x,                   //position
+            BOOL8 faking,              //faking this one
+            inT16 offset,              //extra cost dist
+            inT16 region_index,        //segment number
+            inT16 pitch,               //proposed pitch
+            inT16 pitch_error,         //allowed tolerance
+            FPSEGPT_LIST *prev_list);  //previous segment
+    FPSEGPT(FPCUTPT *cutpt);  //build from new type
+
+    inT32 position() {  //acces func
+      return xpos;
+    }
+    double cost_function() {
+      return cost;
+    }
+    double squares() {
+      return sq_sum;
+    }
+    double sum() {
+      return mean_sum;
+    }
+    FPSEGPT *previous() {
+      return pred;
+    }
+    inT16 cheap_cuts() const {  //no of cheap cuts
+      return mid_cuts;
+    }
+
+                                 //faked split point
+    NEWDELETE2 (FPSEGPT) BOOL8 faked;
+    BOOL8 terminal;              //successful end
+    inT16 fake_count;            //total fakes to here
+
+  private:
+    inT16 mid_cuts;              //no of cheap cuts
+    inT32 xpos;                  //location
+    FPSEGPT *pred;               //optimal previous
+    double mean_sum;             //mean so far
+    double sq_sum;               //summed distsances
+    double cost;                 //cost function
+};
+
+ELISTIZEH (FPSEGPT) CLISTIZEH (FPSEGPT_LIST)
+extern
+BOOL_VAR_H (pitsync_projection_fix, FALSE,
+"Fix bug in projection profile");
+extern
+INT_VAR_H (pitsync_linear_version, 0, "Use new fast algorithm");
+extern
+double_VAR_H (pitsync_joined_edge, 0.75,
+"Dist inside big blob for chopping");
+extern
+double_VAR_H (pitsync_offset_freecut_fraction, 0.25,
+"Fraction of cut for free cuts");
+extern
+INT_VAR_H (pitsync_fake_depth, 1, "Max advance fake generation");
+double check_pitch_sync(                        //find segmentation
+                        BLOBNBOX_IT *blob_it,   //blobs to do
+                        inT16 blob_count,       //no of blobs
+                        inT16 pitch,            //pitch estimate
+                        inT16 pitch_error,      //tolerance
+                        STATS *projection,      //vertical
+                        FPSEGPT_LIST *seg_list  //output list
+                       );
+void make_illegal_segment(                          //find segmentation
+                          FPSEGPT_LIST *prev_list,  //previous segments
+                          TBOX blob_box,             //bounding box
+                          BLOBNBOX_IT blob_it,      //iterator
+                          inT16 region_index,       //number of segment
+                          inT16 pitch,              //pitch estimate
+                          inT16 pitch_error,        //tolerance
+                          FPSEGPT_LIST *seg_list    //output list
+                         );
+inT16 vertical_torow_projection(                   //project whole row
+                                TO_ROW *row,       //row to do
+                                STATS *projection  //output
+                               );
+void vertical_blob_projection(              //project outlines
+                              PBLOB *blob,  //blob to project
+                              STATS *stats  //output
+                             );
+void vertical_outline_projection(                   //project outlines
+                                 OUTLINE *outline,  //outline to project
+                                 STATS *stats       //output
+                                );
+void vertical_cblob_projection(               //project outlines
+                               C_BLOB *blob,  //blob to project
+                               STATS *stats   //output
+                              );
+void vertical_coutline_projection(                     //project outlines
+                                  C_OUTLINE *outline,  //outline to project
+                                  STATS *stats         //output
+                                 );
+#endif