ocr.hpp

/*M//////////////////////////////////////////////////////////////////////////////////////////




//




//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.




//




//  By downloading, copying, installing or using the software you agree to this license.




//  If you do not agree to this license, do not download, install,




//  copy or use the software.




//




//




//                          License Agreement




//                For Open Source Computer Vision Library




//




// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.




// Copyright (C) 2009, Willow Garage Inc., all rights reserved.




// Copyright (C) 2013, OpenCV Foundation, all rights reserved.




// Third party copyrights are property of their respective owners.




//




// Redistribution and use in source and binary forms, with or without modification,




// are permitted provided that the following conditions are met:




//




//   * Redistribution's of source code must retain the above copyright notice,




//     this list of conditions and the following disclaimer.




//




//   * Redistribution's in binary form must reproduce the above copyright notice,




//     this list of conditions and the following disclaimer in the documentation




//     and/or other materials provided with the distribution.




//




//   * The name of the copyright holders may not be used to endorse or promote products




//     derived from this software without specific prior written permission.




//




// This software is provided by the copyright holders and contributors "as is" and




// any express or implied warranties, including, but not limited to, the implied




// warranties of merchantability and fitness for a particular purpose are disclaimed.




// In no event shall the Intel Corporation or contributors be liable for any direct,




// indirect, incidental, special, exemplary, or consequential damages




// (including, but not limited to, procurement of substitute goods or services;




// loss of use, data, or profits; or business interruption) however caused




// and on any theory of liability, whether in contract, strict liability,




// or tort (including negligence or otherwise) arising in any way out of




// the use of this software, even if advised of the possibility of such damage.




//




//M*/








#ifndef __OPENCV_TEXT_OCR_HPP__




#define __OPENCV_TEXT_OCR_HPP__








#include <opencv2/core.hpp>








#include <vector>




#include <string>








namespace

cv



{



namespace
text


{











enum



{



OCR_LEVEL_WORD,



OCR_LEVEL_TEXTLINE


};







enum
page_seg_mode



{



PSM_OSD_ONLY,



PSM_AUTO_OSD,



PSM_AUTO_ONLY,



PSM_AUTO,



PSM_SINGLE_COLUMN,



PSM_SINGLE_BLOCK_VERT_TEXT,



PSM_SINGLE_BLOCK,



PSM_SINGLE_LINE,



PSM_SINGLE_WORD,



PSM_CIRCLE_WORD,



PSM_SINGLE_CHAR


};







enum
ocr_engine_mode



{



OEM_TESSERACT_ONLY,



OEM_CUBE_ONLY,



OEM_TESSERACT_CUBE_COMBINED,



OEM_DEFAULT


};







//base class BaseOCR declares a common API that would be used in a typical text recognition scenario




class
CV_EXPORTS_W
BaseOCR



{



public:



virtual
~BaseOCR() {};



virtual
void
run(Mat& image, std::string& output_text, std::vector<Rect>* component_rects=NULL,



std::vector<std::string>* component_texts=NULL, std::vector<float>* component_confidences=NULL,



int
component_level=0) = 0;



virtual
void
run(Mat& image,
Mat& mask, std::string& output_text, std::vector<Rect>* component_rects=NULL,



std::vector<std::string>* component_texts=NULL, std::vector<float>* component_confidences=NULL,



int
component_level=0) = 0;


};







class
CV_EXPORTS_W
OCRTesseract
:
public
BaseOCR



{



public:



virtual
void
run(Mat& image, std::string& output_text, std::vector<Rect>* component_rects=NULL,



std::vector<std::string>* component_texts=NULL, std::vector<float>* component_confidences=NULL,



int
component_level=0) CV_OVERRIDE;







virtual
void
run(Mat& image,
Mat& mask, std::string& output_text, std::vector<Rect>* component_rects=NULL,



std::vector<std::string>* component_texts=NULL, std::vector<float>* component_confidences=NULL,



int
component_level=0) CV_OVERRIDE;







// aliases for scripting




CV_WRAP String run(InputArray image,
int
min_confidence,
int
component_level=0);







CV_WRAP String run(InputArray image, InputArray mask,
int
min_confidence,
int
component_level=0);







CV_WRAP virtual
void
setWhiteList(const String& char_whitelist) = 0;











CV_WRAP static
Ptr<OCRTesseract> create(const
char* datapath=NULL, const
char* language=NULL,



const
char* char_whitelist=NULL,
int
oem=OEM_DEFAULT,
int
psmode=PSM_AUTO);


};











/* OCR HMM Decoder */







enum decoder_mode


{



OCR_DECODER_VITERBI = 0
// Other algorithms may be added



};







/* OCR classifier type*/




enum classifier_type


{



OCR_KNN_CLASSIFIER = 0,



OCR_CNN_CLASSIFIER = 1


};







class
CV_EXPORTS_W
OCRHMMDecoder
:
public
BaseOCR



{



public:







class
CV_EXPORTS_W
ClassifierCallback




{



public:



virtual
~ClassifierCallback() { }



virtual
void
eval( InputArray image, std::vector<int>& out_class, std::vector<double>& out_confidence);



};







public:



virtual
void
run(Mat& image, std::string& output_text, std::vector<Rect>* component_rects=NULL,



std::vector<std::string>* component_texts=NULL, std::vector<float>* component_confidences=NULL,



int
component_level=0) CV_OVERRIDE;







virtual
void
run(Mat& image,
Mat& mask, std::string& output_text, std::vector<Rect>* component_rects=NULL,



std::vector<std::string>* component_texts=NULL, std::vector<float>* component_confidences=NULL,



int
component_level=0) CV_OVERRIDE;







// aliases for scripting




CV_WRAP String run(InputArray image,
int
min_confidence,
int
component_level=0);







CV_WRAP String run(InputArray image, InputArray mask,
int
min_confidence,
int
component_level=0);







CV_WRAP static
Ptr<OCRHMMDecoder> create(const
Ptr<OCRHMMDecoder::ClassifierCallback> classifier,// The character classifier with built in feature extractor




const String& vocabulary,
// The language vocabulary (chars when ASCII English text)




//     size() must be equal to the number of classes




InputArray transition_probabilities_table,
// Table with transition probabilities between character pairs




//     cols == rows == vocabulary.size()




InputArray emission_probabilities_table,
// Table with observation emission probabilities




//     cols == rows == vocabulary.size()




int
mode = OCR_DECODER_VITERBI);
// HMM Decoding algorithm (only Viterbi for the moment)








CV_WRAP static
Ptr<OCRHMMDecoder> create(const String& filename,







const String& vocabulary,
// The language vocabulary (chars when ASCII English text)




//     size() must be equal to the number of classes




InputArray transition_probabilities_table,
// Table with transition probabilities between character pairs




//     cols == rows == vocabulary.size()




InputArray emission_probabilities_table,
// Table with observation emission probabilities




//     cols == rows == vocabulary.size()




int
mode = OCR_DECODER_VITERBI,
// HMM Decoding algorithm (only Viterbi for the moment)








int
classifier = OCR_KNN_CLASSIFIER);
// The character classifier type



protected:







Ptr<OCRHMMDecoder::ClassifierCallback> classifier;



std::string
vocabulary;



Mat
transition_p;



Mat
emission_p;



decoder_mode mode;


};






CV_EXPORTS_W
Ptr<OCRHMMDecoder::ClassifierCallback>
loadOCRHMMClassifierNM(const String& filename);






CV_EXPORTS_W
Ptr<OCRHMMDecoder::ClassifierCallback>
loadOCRHMMClassifierCNN(const String& filename);






CV_EXPORTS_W
Ptr<OCRHMMDecoder::ClassifierCallback>
loadOCRHMMClassifier(const String& filename,
int
classifier);






CV_EXPORTS
void
createOCRHMMTransitionsTable(std::string& vocabulary, std::vector<std::string>& lexicon,
OutputArray
transition_probabilities_table);






CV_EXPORTS_W
Mat
createOCRHMMTransitionsTable(const String& vocabulary, std::vector<cv::String>& lexicon);











/* OCR BeamSearch Decoder */







class CV_EXPORTS_W
OCRBeamSearchDecoder
: public
BaseOCR



{



public:







class
CV_EXPORTS_W
ClassifierCallback




{



public:



virtual
~ClassifierCallback() { }



virtual
void
eval( InputArray image, std::vector< std::vector<double> >& recognition_probabilities, std::vector<int>& oversegmentation );







int
getWindowSize() {return
0;}



int
getStepSize() {return
0;}



};







public:



virtual
void
run(Mat& image, std::string& output_text, std::vector<Rect>* component_rects=NULL,



std::vector<std::string>* component_texts=NULL, std::vector<float>* component_confidences=NULL,



int
component_level=0) CV_OVERRIDE;







virtual
void
run(Mat& image,
Mat& mask, std::string& output_text, std::vector<Rect>* component_rects=NULL,



std::vector<std::string>* component_texts=NULL, std::vector<float>* component_confidences=NULL,



int
component_level=0) CV_OVERRIDE;







// aliases for scripting




CV_WRAP String run(InputArray image,
int
min_confidence,
int
component_level=0);







CV_WRAP String run(InputArray image, InputArray mask,
int
min_confidence,
int
component_level=0);







static CV_WRAP



Ptr<OCRBeamSearchDecoder> create(const
Ptr<OCRBeamSearchDecoder::ClassifierCallback> classifier,// The character classifier with built in feature extractor




const std::string& vocabulary,
// The language vocabulary (chars when ASCII English text)




//     size() must be equal to the number of classes




InputArray transition_probabilities_table,
// Table with transition probabilities between character pairs




//     cols == rows == vocabulary.size()




InputArray emission_probabilities_table,
// Table with observation emission probabilities




//     cols == rows == vocabulary.size()




text::decoder_mode mode = OCR_DECODER_VITERBI,
// HMM Decoding algorithm (only Viterbi for the moment)




int
beam_size = 500
// Size of the beam in Beam Search algorithm




);







static
//CV_WRAP FIXIT bug in handling of Java overloads




Ptr<OCRBeamSearchDecoder> create(const String& filename,
// The character classifier file




const String& vocabulary,
// The language vocabulary (chars when ASCII English text)




//     size() must be equal to the number of classes




InputArray transition_probabilities_table,
// Table with transition probabilities between character pairs




//     cols == rows == vocabulary.size()




InputArray emission_probabilities_table,
// Table with observation emission probabilities




//     cols == rows == vocabulary.size()




text::decoder_mode mode = OCR_DECODER_VITERBI,
// HMM Decoding algorithm (only Viterbi for the moment)




int
beam_size = 500
// Size of the beam in Beam Search algorithm




);


protected:







Ptr<OCRBeamSearchDecoder::ClassifierCallback> classifier;



std::string
vocabulary;



Mat
transition_p;



Mat
emission_p;



decoder_mode mode;



int
beam_size;


};






CV_EXPORTS_W
Ptr<OCRBeamSearchDecoder::ClassifierCallback> loadOCRBeamSearchClassifierCNN(const String& filename);










class CV_EXPORTS
OCRHolisticWordRecognizer
: public
BaseOCR



{



public:



virtual
void
run(Mat& image,



std::string& output_text,



std::vector<Rect>* component_rects = NULL,



std::vector<std::string>* component_texts = NULL,



std::vector<float>* component_confidences = NULL,



int
component_level = OCR_LEVEL_WORD) CV_OVERRIDE = 0;







virtual
void
run(Mat& image,



Mat& mask,



std::string& output_text,



std::vector<Rect>* component_rects = NULL,



std::vector<std::string>* component_texts = NULL,



std::vector<float>* component_confidences = NULL,



int
component_level = OCR_LEVEL_WORD) CV_OVERRIDE = 0;







static
Ptr<OCRHolisticWordRecognizer>
create(const
std::string &archFilename,



const
std::string &weightsFilename,



const
std::string &wordsFilename);


};










}}
// cv::text::












#endif

// _OPENCV_TEXT_OCR_HPP_