ccstruct/rejctmap.h

Go to the documentation of this file.

#ifndef           REJCTMAP_H
#define           REJCTMAP_H

#ifdef __UNIX__
#include          <assert.h>
#endif
#include          "memry.h"
#include          "bits16.h"
#include                   "varable.h"
#include          "notdll.h"

extern BOOL_VAR_H (rejword_only_set_if_accepted, TRUE,
"Mimic old reject_word");
extern BOOL_VAR_H (rejmap_allow_more_good_qual, FALSE,
"Use initial good qual setting");
extern BOOL_VAR_H (rej_use_1Il_rej, TRUE, "1Il rejection enabled");
enum REJ_FLAGS
{
  /* Reject modes which are NEVER overridden */
  R_TESS_FAILURE,                
  R_SMALL_XHT,                   
  R_EDGE_CHAR,                   
  R_1IL_CONFLICT,                
  R_POSTNN_1IL,                  
  R_REJ_CBLOB,                   
  R_MM_REJECT,                   
  R_BAD_REPETITION,              

  /* Initial reject modes (pre NN_ACCEPT) */
  R_POOR_MATCH,                  
  R_NOT_TESS_ACCEPTED,           
  R_CONTAINS_BLANKS,             
  R_BAD_PERMUTER,                

  /* Reject modes generated after NN_ACCEPT but before MM_ACCEPT */
  R_HYPHEN,                      
  R_DUBIOUS,                     
  R_NO_ALPHANUMS,                
  R_MOSTLY_REJ,                  
  R_XHT_FIXUP,                   

  /* Reject modes generated after MM_ACCEPT but before QUALITY_ACCEPT */
  R_BAD_QUALITY,                 

  /* Reject modes generated after QUALITY_ACCEPT but before MINIMAL_REJ accep*/
  R_DOC_REJ,                     
  R_BLOCK_REJ,                   
  R_ROW_REJ,                     
  R_UNLV_REJ,                    

  /* Accept modes which occur inbetween the above rejection groups */
  R_NN_ACCEPT,                   
  R_HYPHEN_ACCEPT,               
  R_MM_ACCEPT,                   
  R_QUALITY_ACCEPT,              
  R_MINIMAL_REJ_ACCEPT           
};

#define           MAP_ACCEPT '1'
#define           MAP_REJECT_PERM '0'
#define           MAP_REJECT_TEMP '2'
#define           MAP_REJECT_POTENTIAL '3'

class REJ
{
  BITS16 flags1;
  BITS16 flags2;

  void set_flag(REJ_FLAGS rej_flag) { 
    if (rej_flag < 16)
      flags1.turn_on_bit (rej_flag);
    else
      flags2.turn_on_bit (rej_flag - 16);
  }

  BOOL8 rej_before_nn_accept(); 
  BOOL8 rej_between_nn_and_mm(); 
  BOOL8 rej_between_mm_and_quality_accept(); 
  BOOL8 rej_between_quality_and_minimal_rej_accept(); 
  BOOL8 rej_before_mm_accept(); 
  BOOL8 rej_before_quality_accept(); 

  public:
    REJ() {  //constructor
    }

    REJ(  //classwise copy
        const REJ &source) {
      flags1 = source.flags1;
      flags2 = source.flags2;
    }

    REJ & operator= (            //assign REJ
    const REJ & source) {        //from this
      flags1 = source.flags1;
      flags2 = source.flags2;
      return *this;
    }

    BOOL8 flag(REJ_FLAGS rej_flag) { 
      if (rej_flag < 16)
        return flags1.bit (rej_flag);
      else
        return flags2.bit (rej_flag - 16);
    }

    char display_char() { 
      if (perm_rejected ())
        return MAP_REJECT_PERM;
      else if (accept_if_good_quality ())
        return MAP_REJECT_POTENTIAL;
      else if (rejected ())
        return MAP_REJECT_TEMP;
      else
        return MAP_ACCEPT;
    }

    BOOL8 perm_rejected();  //Is char perm reject?

    BOOL8 rejected();  //Is char rejected?

    BOOL8 accepted() {  //Is char accepted?
      return !rejected ();
    }

                                 //potential rej?
    BOOL8 accept_if_good_quality(); 

    BOOL8 recoverable() { 
      return (rejected () && !perm_rejected ());
    }

    void setrej_tess_failure();  //Tess generated blank
    void setrej_small_xht();  //Small xht char/wd
    void setrej_edge_char();  //Close to image edge
    void setrej_1Il_conflict();  //Initial reject map
    void setrej_postNN_1Il();  //1Il after NN
    void setrej_rej_cblob();  //Insert duff blob
    void setrej_mm_reject();  //Matrix matcher
                                 //Odd repeated char
    void setrej_bad_repetition(); 
    void setrej_poor_match();  //Failed Rays heuristic
                                 //TEMP reject_word
    void setrej_not_tess_accepted(); 
                                 //TEMP reject_word
    void setrej_contains_blanks(); 
    void setrej_bad_permuter();  //POTENTIAL reject_word
    void setrej_hyphen();  //PostNN dubious hyph or .
    void setrej_dubious();  //PostNN dubious limit
    void setrej_no_alphanums();  //TEMP reject_word
    void setrej_mostly_rej();  //TEMP reject_word
    void setrej_xht_fixup();  //xht fixup
    void setrej_bad_quality();  //TEMP reject_word
    void setrej_doc_rej();  //TEMP reject_word
    void setrej_block_rej();  //TEMP reject_word
    void setrej_row_rej();  //TEMP reject_word
    void setrej_unlv_rej();  //TEMP reject_word
    void setrej_nn_accept();  //NN Flipped a char
    void setrej_hyphen_accept();  //Good aspect ratio
    void setrej_mm_accept();  //Matrix matcher
                                 //Quality flip a char
    void setrej_quality_accept(); 
                                 //Accept all except blank
    void setrej_minimal_rej_accept(); 

    void full_print(FILE *fp); 
};

class REJMAP
{
  REJ *ptr;                      //ptr to the chars
  INT16 len;                     //Number of chars

  public:
    REJMAP() {  //constructor
      ptr = NULL;
      len = 0;
    }

    REJMAP(  //classwise copy
           const REJMAP &rejmap);

    REJMAP & operator= (         //assign REJMAP
      const REJMAP & source);    //from this

    ~REJMAP () {                 //destructor
      if (ptr != NULL)
        free_struct (ptr, len * sizeof (REJ), "REJ");
    }

    void initialise(  //Redefine map
                    INT16 length);

    REJ & operator[](            //access function
      INT16 index) const         //map index
    {
      ASSERT_HOST (index < len);
      return ptr[index];         //no bounds checks
    }

    INT32 length() const {  //map length
      return len;
    }

    INT16 accept_count();  //How many accepted?

    INT16 reject_count() {  //How many rejects?
      return len - accept_count ();
    }

    void remove_pos(             //Cut out an element
                    INT16 pos);  //element to remove

    void print(FILE *fp); 

    void full_print(FILE *fp); 

    BOOL8 recoverable_rejects();  //Any non perm rejs?

    BOOL8 quality_recoverable_rejects(); 
    //Any potential rejs?

    void rej_word_small_xht();  //Reject whole word
                                 //Reject whole word
    void rej_word_tess_failure(); 
    void rej_word_not_tess_accepted(); 
    //Reject whole word
                                 //Reject whole word
    void rej_word_contains_blanks(); 
                                 //Reject whole word
    void rej_word_bad_permuter(); 
    void rej_word_xht_fixup();  //Reject whole word
                                 //Reject whole word
    void rej_word_no_alphanums(); 
    void rej_word_mostly_rej();  //Reject whole word
    void rej_word_bad_quality();  //Reject whole word
    void rej_word_doc_rej();  //Reject whole word
    void rej_word_block_rej();  //Reject whole word
    void rej_word_row_rej();  //Reject whole word
};
#endif

---