/**********************************************************************

 * File:        pithsync.h  (Formerly pitsync2.h)

 * Description: Code to find the optimum fixed pitch segmentation of some blobs.

 * Author:    Ray Smith

 *

 * (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 "params.h"

#include "statistc.h"

namespace tesseract {

class FPSEGPT_LIST;

class FPCUTPT {

public:

  FPCUTPT() = default;

  void setup(               // start of cut

      FPCUTPT cutpts[],     // predecessors

      int16_t array_origin, // start coord

      STATS *projection,    // occupation

      int16_t zero_count,   // official zero

      int16_t pitch,        // proposed pitch

      int16_t x,            // position

      int16_t offset);      // dist to gap

  void assign(                // evaluate cut

      FPCUTPT cutpts[],       // predecessors

      int16_t array_origin,   // start coord

      int16_t x,              // position

      bool faking,            // faking this one

      bool mid_cut,           // doing free cut

      int16_t offset,         // extra cost dist

      STATS *projection,      // occupation

      float projection_scale, // scaling

      int16_t zero_count,     // official zero

      int16_t pitch,          // proposed pitch

      int16_t pitch_error);   // allowed tolerance

  void assign_cheap(          // evaluate cut

      FPCUTPT cutpts[],       // predecessors

      int16_t array_origin,   // start coord

      int16_t x,              // position

      bool faking,            // faking this one

      bool mid_cut,           // doing free cut

      int16_t offset,         // extra cost dist

      STATS *projection,      // occupation

      float projection_scale, // scaling

      int16_t zero_count,     // official zero

      int16_t pitch,          // proposed pitch

      int16_t pitch_error);   // allowed tolerance

  int32_t position() { // access func

    return xpos;

  }

  double cost_function() {

    return cost;

  }

  double squares() {

    return sq_sum;

  }

  double sum() {

    return mean_sum;

  }

  FPCUTPT *previous() {

    return pred;

  }

  int16_t cheap_cuts() const { // no of mi cuts

    return mid_cuts;

  }

  int16_t index() const {

    return region_index;

  }

  bool faked;         // faked split point

  bool terminal;      // successful end

  int16_t fake_count; // total fakes to here

private:

  int16_t region_index;  // cut serial number

  int16_t mid_cuts;      // no of cheap cuts

  int32_t xpos;          // location

  uint32_t back_balance; // proj backwards

  uint32_t 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_t blob_count,      // no of blobs

    int16_t pitch,           // pitch estimate

    int16_t pitch_error,     // tolerance

    STATS *projection,       // vertical

    int16_t projection_left, // edges //scale factor

    int16_t projection_right, float projection_scale,

    int16_t &occupation_count, // no of occupied cells

    FPSEGPT_LIST *seg_list,    // output list

    int16_t start,             // start of good range

    int16_t end                // end of good range

);

double check_pitch_sync3(    // find segmentation

    int16_t projection_left, // edges //to be considered 0

    int16_t projection_right, int16_t zero_count,

    int16_t pitch,             // pitch estimate

    int16_t pitch_error,       // tolerance

    STATS *projection,         // vertical

    float projection_scale,    // scale factor

    int16_t &occupation_count, // no of occupied cells

    FPSEGPT_LIST *seg_list,    // output list

    int16_t start,             // start of good range

    int16_t end                // end of good range

);

} // namespace tesseract

#endif