Tesseract

https://docs.rs/tesseract/0.15.2
Admin
The Tesseract crate provides Rust bindings for the Tesseract OCR engine, allowing Rust applications...
Tokens:9,630
Snippets:97
Trust Score:9.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Get UTF-8 Text Output

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Retrieves the recognized text from the Tesseract engine as a UTF-8 encoded string. This is the most common method for obtaining OCR results. It requires the Tesseract instance to have already recognized the image.

```rust
pub fn get_text(&mut self) -> Result<String, plumbing::TessBaseApiGetUtf8TextError> {
        Ok(self
            .0
            .get_utf8_text()?.
            as_ref()
            .to_string_lossy()
            .into_owned())
    }
```

--------------------------------

### Tesseract::mean_text_conf

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Gets the mean confidence level of the recognized text.

```APIDOC
## Tesseract::mean_text_conf

### Description
Returns the mean confidence level for the recognized text. The confidence is a value between 0 and 100, where 100 is the highest confidence.

### Method
`Tesseract::mean_text_conf`

### Returns
- `i32`: The mean confidence level of the recognized text.
```

--------------------------------

### Get TSV Text Output

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Retrieves the recognized text in TSV (Tab-Separated Values) format. This format includes bounding boxes, confidence levels, and other details for each recognized character or word, similar to HOCR but in a tabular structure.

```rust
pub fn get_tsv_text(
        &mut self,
        page: c_int,
    ) -> Result<String, plumbing::TessBaseApiGetTsvTextError> {
        Ok(self
            .0
            .get_tsv_text(page)?.
            as_ref()
            .to_string_lossy()
            .into_owned())
    }
```

--------------------------------

### Get Mean Text Confidence

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Calculates and returns the mean confidence level of the recognized text. The confidence is a value between 0 and 100, indicating the engine's certainty about the recognized characters. This is useful for evaluating OCR quality.

```rust
pub fn mean_text_conf(&mut self) -> i32 {
        self.0.mean_text_conf()
    }
```

--------------------------------

### Get HOCR Text Output

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Retrieves the recognized text encoded in the HOCR (HTML Object Character Recognition) format. HOCR includes bounding box information for each recognized word or character, making it suitable for detailed analysis or display.

```rust
pub fn get_hocr_text(
        &mut self,
        page: c_int,
    ) -> Result<String, plumbing::TessBaseApiGetHocrTextError> {
        Ok(self
            .0
            .get_hocr_text(page)?.
            as_ref()
            .to_string_lossy()
            .into_owned())
    }
```

--------------------------------

### Tesseract::new

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Initializes a new Tesseract instance with a specified data path and language. If `None` is provided for either, Tesseract's default behavior will be used.

```APIDOC
## Tesseract::new

### Description
Initializes a new Tesseract instance with a specified data path and language. If `None` is provided for either, Tesseract's default behavior will be used.

### Method
```rust
pub fn new(datapath: Option<&str>, language: Option<&str>) -> Result<Self, InitializeError>
```

### Parameters

*   **datapath** (`Option<&str>`) - Optional path to the Tesseract data directory.
*   **language** (`Option<&str>`) - Optional language code (e.g., "eng") to use for OCR.

### Returns

A `Result` containing a new `Tesseract` instance on success, or an `InitializeError` on failure.
```

--------------------------------

### Initialize Tesseract OCR Engine

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Creates a new Tesseract OCR engine instance. Specify the path to Tesseract data files and the desired language(s).

```rust
pub fn new(datapath: Option<&str>, language: Option<&str>) -> Result<Self, InitializeError> {
        let mut tess = Tesseract(plumbing::TessBaseApi::create());
        let datapath = match datapath {
            Some(i) => Some(CString::new(i)?),
            None => None,
        };
        let language = match language {
            Some(i) => Some(CString::new(i)?),
            None => None,
        };

        tess.0.init_2(datapath.as_deref(), language.as_deref())?;
        Ok(tess)
    }
```

--------------------------------

### Initialize Tesseract with None

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Tests the ability to initialize the Tesseract engine with both configuration and language set to None, expecting success.

```rust
#[test]
fn initialize_with_none() {
    assert!(Tesseract::new(None, None).is_ok());
}
```

--------------------------------

### Initialize Tesseract with Data

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Creates a new Tesseract instance initialized with raw data, an optional language, and an OCR engine mode. Use this when you have Tesseract data files available in memory.

```rust
pub fn new_with_data(
        data: &[u8],
        language: Option<&str>,
        oem: OcrEngineMode,
    ) -> Result<Self, InitializeError> {
        let mut tess = Tesseract(plumbing::TessBaseApi::create());
        let language = match language {
            Some(i) => Some(CString::new(i)?),
            None => None,
        };

        tess.0.init_1(data, language.as_deref(), oem.to_value())?;
        Ok(tess)
    }
```

--------------------------------

### Initialize Tesseract with OCR Engine Mode

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Initializes the Tesseract OCR engine with a specific OCR Engine Mode (OEM). This allows control over which Tesseract recognition engine is used.

```rust
pub fn new_with_oem(
        datapath: Option<&str>,
        language: Option<&str>,
        oem: OcrEngineMode,
    ) -> Result<Self, InitializeError> {
        let mut tess = Tesseract(plumbing::TessBaseApi::create());
        let datapath = match datapath {
            Some(i) => Some(CString::new(i)?),
            None => None,
        };
        let language = match language {
            Some(i) => Some(CString::new(i)?),
            None => None,
        };

        tess.0
            .init_4(datapath.as_deref(), language.as_deref(), oem.to_value())?;
        Ok(tess)
    }
```

--------------------------------

### Tesseract::new_with_oem

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Initializes a new Tesseract instance with a specified data path, language, and OCR engine mode (OEM). This allows for more control over the recognition process.

```APIDOC
## Tesseract::new_with_oem

### Description
Initializes a new Tesseract instance with a specified data path, language, and OCR engine mode (OEM). This allows for more control over the recognition process.

### Method
```rust
pub fn new_with_oem(datapath: Option<&str>, language: Option<&str>, oem: OcrEngineMode) -> Result<Self, InitializeError>
```

### Parameters

*   **datapath** (`Option<&str>`) - Optional path to the Tesseract data directory.
*   **language** (`Option<&str>`) - Optional language code (e.g., "eng") to use for OCR.
*   **oem** (`OcrEngineMode`) - The OCR engine mode to use (e.g., `Default`, `LstmOnly`).

### Returns

A `Result` containing a new `Tesseract` instance on success, or an `InitializeError` on failure.
```

--------------------------------

### Implement From<TessBaseApiInitError> for InitializeError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Allows converting a TessBaseApiInitError into an InitializeError.

```rust
fn from(source: TessBaseApiInitError) -> Self
```

--------------------------------

### Implement Display for InitializeError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides a Display implementation for the InitializeError enum, allowing it to be formatted for user-facing messages.

```rust
fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result
```

--------------------------------

### Tesseract::new_with_data

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Creates a new Tesseract instance with provided image data and optional language and OCR engine mode.

```APIDOC
## Tesseract::new_with_data

### Description
Initializes Tesseract with raw image data. This method allows for specifying the language model and the OCR engine mode to use.

### Method
`Tesseract::new_with_data`

### Parameters
- `data` (&[u8]): A slice of bytes representing the image data.
- `language` (Option<&str>): An optional string slice specifying the language for OCR.
- `oem` (OcrEngineMode): The OCR Engine Mode to use.

### Returns
- `Result<Self, InitializeError>`: A `Result` containing a new `Tesseract` instance on success, or an `InitializeError` on failure.
```

--------------------------------

### OCR Test with Image File

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

A unit test that performs OCR on a sample image file ('img.png') using English language and asserts that the output matches the content of 'img.txt'. This verifies the basic OCR functionality for file inputs.

```rust
#[test]
fn ocr_test() -> Result<(), TesseractError> {
    assert_eq!(
        ocr("img.png", "eng")?,
        include_str!("../img.txt").to_string()
    );
    Ok(())
}
```

--------------------------------

### Set Image from Filename

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the input image for OCR from a file path. The function returns the modified Tesseract instance. Ensure the file exists and is a supported image format.

```rust
pub fn set_image(mut self, filename: &str) -> Result<Self, SetImageError> {
        let pix = plumbing::leptonica_plumbing::Pix::read(&CString::new(filename)?)?;
        self.0.set_image_2(&pix);
        Ok(self)
    }
```

--------------------------------

### OCR Engine Mode Comparison Test

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Compares the text recognition results between Tesseract's legacy engine (OEM::TesseractOnly) and its LSTM engine (OEM::LstmOnly).

```rust
#[test]
#[ignore] // Many systems do not have legacy Tesseract data available
fn oem_test() -> Result<(), TesseractError> {
    let only_tesseract_str = 
        Tesseract::new_with_oem(None, Some("eng"), OcrEngineMode::TesseractOnly)?
            .set_image("img.png")?
            .recognize()? 
            .get_text()?;

    let only_lstm_str = Tesseract::new_with_oem(None, Some("eng"), OcrEngineMode::LstmOnly)?
        .set_image("img.png")?
        .recognize()? 
        .get_text()?;

    assert_ne!(only_tesseract_str, only_lstm_str);
    Ok(())
}
```

--------------------------------

### Basic Image Recognition Test

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Tests basic image recognition functionality by setting an image and asserting the recognized text against a known file.

```rust
#[test]
fn expanded_test() -> Result<(), TesseractError> {
    let mut cube = Tesseract::new(None, Some("eng"))?
        .set_image("img.png")?
        .set_variable("tessedit_char_blacklist", "z")?
        .recognize()?;
    assert_eq!(&cube.get_text()?, include_str!("../img.txt"));
    Ok(())
}
```

--------------------------------

### TryInto for TesseractError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.TesseractError.html

Provides the `try_into` method for types that implement `TryFrom<TesseractError>`, allowing conversion into another type with error handling.

```APIDOC
## impl<T, U> TryInto<U> for T
where U: TryFrom<T>

### Description
This implementation block provides the `try_into` method for types `T` that can be converted into type `U` using `TryFrom<T>`. It allows for fallible conversions, returning a `Result`.

### Methods
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion. Returns `Ok(U)` on success or `Err(Error)` if the conversion fails.

### Type Alias
#### type Error = <U as TryFrom<T>>::Error
The associated type `Error` represents the specific error type returned when the `try_into` conversion fails. This is determined by the `TryFrom` implementation for `U`.
```

--------------------------------

### Implement From<InitializeError> for TesseractError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Allows converting an InitializeError into a TesseractError.

```rust
fn from(source: InitializeError) -> Self
```

--------------------------------

### TryFrom for TesseractError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.TesseractError.html

Provides the `try_from` method for types that implement `TryFrom<U>`, allowing conversion from another type with error handling.

```APIDOC
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion. Returns `Ok(T)` on success or `Err(Error)` if the conversion fails.
```

--------------------------------

### Implement From<NulError> for InitializeError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Allows converting a NulError into an InitializeError.

```rust
fn from(source: NulError) -> Self
```

--------------------------------

### Implement Debug for InitializeError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides a Debug implementation for the InitializeError enum, allowing it to be formatted for debugging purposes.

```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

--------------------------------

### Recognize Image Content

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Performs the OCR recognition process on the currently set image. This function should be called after setting the image and any desired configurations. It returns the Tesseract instance for further chaining.

```rust
pub fn recognize(mut self) -> Result<Self, plumbing::TessBaseApiRecogniseError> {
        self.0.recognize()?;
        Ok(self)
    }
```

--------------------------------

### Implement TryFrom<U> for T

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides the TryFrom trait implementation for generic types, attempting to convert U into T.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Implement TryInto<U> for T

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides the TryInto trait implementation for generic types, attempting to convert T into U.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Tesseract::recognize

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Performs OCR recognition on the current image.

```APIDOC
## Tesseract::recognize

### Description
Initiates the OCR process on the image that has been previously set. This method performs the actual text recognition.

### Method
`Tesseract::recognize`

### Returns
- `Result<Self, plumbing::TessBaseApiRecogniseError>`: A `Result` containing the `Tesseract` instance after recognition, or an error if recognition fails.
```

--------------------------------

### OCR Test with Memory Image and Resolution

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

A unit test that performs OCR on image data from a TIFF file in memory, setting a specific source resolution (PPI). It then retrieves the text and asserts it against 'img.txt'. This tests the combination of memory input and resolution setting.

```rust
#[test]
fn ocr_from_mem_with_ppi() -> Result<(), TesseractError> {
    let mut cube = Tesseract::new(None, Some("eng"))?.
        set_image_from_mem(include_bytes!("../img.tiff"))?.
        set_source_resolution(70);
    assert_eq!(&cube.get_text()?, include_str!("../img.txt"));
}
```

--------------------------------

### Implement From<T> for T

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides the From trait implementation for generic types, returning the argument unchanged.

```rust
fn from(t: T) -> T
```

--------------------------------

### Set Image from Frame Data

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the input image for OCR from raw frame data in memory. This method requires specifying image dimensions and pixel format details. Use this for images loaded directly into memory.

```rust
pub fn set_frame(
        mut self,
        frame_data: &[u8],
        width: i32,
        height: i32,
        bytes_per_pixel: i32,
        bytes_per_line: i32,
    ) -> Result<Self, plumbing::TessBaseApiSetImageSafetyError> {
        self.0
            .set_image(frame_data, width, height, bytes_per_pixel, bytes_per_line)?;
        Ok(self)
    }
```

--------------------------------

### Tesseract::get_text

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Retrieves the recognized text from the image.

```APIDOC
## Tesseract::get_text

### Description
Retrieves the recognized text as a UTF-8 encoded string after the `recognize` method has been called.

### Method
`Tesseract::get_text`

### Returns
- `Result<String, plumbing::TessBaseApiGetUtf8TextError>`: A `Result` containing the recognized text as a `String` on success, or an error if retrieving the text fails.
```

--------------------------------

### Set Tesseract Variable

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets a Tesseract configuration variable. This allows fine-tuning OCR behavior by modifying internal parameters. Both the variable name and its value must be provided as strings.

```rust
pub fn set_variable(mut self, name: &str, value: &str) -> Result<Self, SetVariableError> {
        self.0
            .set_variable(&CString::new(name)?,
 &CString::new(value)?)?;
        Ok(self)
    }
```

--------------------------------

### Perform OCR on Image File

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

A convenience function to perform OCR on an image file. It initializes Tesseract, sets the image, recognizes the text, and returns the result. This is a common workflow for processing single image files.

```rust
pub fn ocr(filename: &str, language: &str) -> Result<String, TesseractError> {
    Ok(Tesseract::new(None, Some(language))?.
        set_image(filename)?.
        recognize()?.
        get_text()?)
}
```

--------------------------------

### Set Source Resolution

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the source resolution (PPI - Pixels Per Inch) of the input image. This can improve OCR accuracy, especially for images with varying resolutions. It's recommended to set this before processing the image.

```rust
pub fn set_source_resolution(mut self, ppi: i32) -> Self {
        self.0.set_source_resolution(ppi);
        self
    }
```

--------------------------------

### Set Image from Memory Buffer

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the input image for OCR from a byte slice representing image data in memory. This is useful for images loaded from various sources like network streams or embedded resources.

```rust
pub fn set_image_from_mem(
        mut self,
        img: &[u8],
    ) -> Result<Self, plumbing::leptonica_plumbing::PixReadMemError> {
        let pix = plumbing::leptonica_plumbing::Pix::read_mem(img)?;
        self.0.set_image_2(&pix);
        Ok(self)
    }
```

--------------------------------

### Implement Any for T

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides the Any trait implementation for generic types.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Implement Into<U> for T

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides the Into trait implementation for generic types, converting T into U if U implements From<T>.

```rust
fn into(self) -> U
```

--------------------------------

### Implement Error trait for InitializeError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Implements the standard Error trait for InitializeError, providing methods to access the error source and description.

```rust
fn source(&self) -> Option<&(dyn Error + 'static)>
```

```rust
fn description(&self) -> &str
```

```rust
fn cause(&self) -> Option<&dyn Error>
```

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

--------------------------------

### ocr

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Performs OCR on an image file and returns the recognized text.

```APIDOC
## ocr

### Description
A convenience function to perform OCR on an image file. It initializes Tesseract, sets the image, performs recognition, and returns the extracted text.

### Method
`ocr`

### Parameters
- `filename` (&str): The path to the image file to process.
- `language` (&str): The language code for the OCR engine (e.g., "eng").

### Returns
- `Result<String, TesseractError>`: A `Result` containing the recognized text as a `String` on success, or a `TesseractError` if any step in the process fails.
```

--------------------------------

### Tesseract::set_image_from_mem

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the image to be processed by Tesseract from in-memory image data.

```APIDOC
## Tesseract::set_image_from_mem

### Description
Sets the image for Tesseract processing using image data directly from memory.

### Method
`Tesseract::set_image_from_mem`

### Parameters
- `img` (&[u8]): A slice of bytes representing the image data in memory.

### Returns
- `Result<Self, plumbing::leptonica_plumbing::PixReadMemError>`: A `Result` containing the modified `Tesseract` instance on success, or an error if reading the image from memory fails.
```

--------------------------------

### ocr_from_frame

Source: https://docs.rs/tesseract/0.15.2/tesseract/index.html

Performs OCR on a frame.

```APIDOC
## ocr_from_frame

### Description
Performs Optical Character Recognition (OCR) on a frame.

### Parameters

(No specific parameters are detailed in the source for this function.)

### Response

(No specific response details are detailed in the source for this function.)

### Request Example

(No request example is available in the source.)

### Response Example

(No response example is available in the source.)
```

--------------------------------

### Tesseract::set_image

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the image to be processed by Tesseract from a file path.

```APIDOC
## Tesseract::set_image

### Description
Loads an image from a specified file path and sets it as the current image for Tesseract processing.

### Method
`Tesseract::set_image`

### Parameters
- `filename` (&str): The path to the image file.

### Returns
- `Result<Self, SetImageError>`: A `Result` containing the modified `Tesseract` instance on success, or a `SetImageError` on failure.
```

--------------------------------

### ocr_from_frame Function Signature

Source: https://docs.rs/tesseract/0.15.2/tesseract/fn.ocr_from_frame.html

The signature for the `ocr_from_frame` function, outlining the required parameters for image data, dimensions, and language, and its return type.

```rust
pub fn ocr_from_frame(
    frame_data: &[u8],
    width: i32,
    height: i32,
    bytes_per_pixel: i32,
    bytes_per_line: i32,
    language: &str,
) -> Result<String, TesseractError>
```

--------------------------------

### Implement ToString for T

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides the ToString trait implementation for types that implement Display.

```rust
fn to_string(&self) -> String
```

--------------------------------

### Tesseract::set_page_seg_mode

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the page segmentation mode for Tesseract.

```APIDOC
## Tesseract::set_page_seg_mode

### Description
Sets the page segmentation mode (PSM) for Tesseract. The PSM controls how Tesseract analyzes the page layout and segments the text.

### Method
`Tesseract::set_page_seg_mode`

### Parameters
- `mode` (PageSegMode): The page segmentation mode to set.

### Returns
- `()`: This method does not return a value.
```

--------------------------------

### Tesseract::set_source_resolution

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the source resolution (PPI) of the image.

```APIDOC
## Tesseract::set_source_resolution

### Description
Sets the source resolution of the image in Pixels Per Inch (PPI). This can help Tesseract to better interpret the image scale and improve OCR accuracy.

### Method
`Tesseract::set_source_resolution`

### Parameters
- `ppi` (i32): The source resolution in PPI.

### Returns
- `Self`: The modified `Tesseract` instance.
```

--------------------------------

### From<NulError> for SetImageError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.SetImageError.html

Converts a NulError into a SetImageError. This is useful for handling errors during CString creation.

```rust
impl From<NulError> for SetImageError {
    fn from(source: NulError) -> Self {
        SetImageError::CStringError(source)
    }
}
```

--------------------------------

### Perform OCR on Image Frame Data

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

A convenience function to perform OCR on image data provided as a byte slice (frame). It initializes Tesseract, sets the frame data, recognizes, and returns the text. Useful for real-time image processing or images in memory.

```rust
pub fn ocr_from_frame(
    frame_data: &[u8],
    width: i32,
    height: i32,
    bytes_per_pixel: i32,
    bytes_per_line: i32,
    language: &str,
) -> Result<String, TesseractError> {
    Ok(Tesseract::new(None, Some(language))?.
        set_frame(frame_data, width, height, bytes_per_pixel, bytes_per_line)?.
        recognize()?.
        get_text()?)
}
```

--------------------------------

### Tesseract::set_variable

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets a Tesseract configuration variable.

```APIDOC
## Tesseract::set_variable

### Description
Sets a Tesseract configuration variable to a specific value. This allows fine-tuning of Tesseract's behavior and recognition process.

### Method
`Tesseract::set_variable`

### Parameters
- `name` (&str): The name of the variable to set.
- `value` (&str): The value to set for the variable.

### Returns
- `Result<Self, SetVariableError>`: A `Result` containing the modified `Tesseract` instance on success, or a `SetVariableError` if the variable could not be set.
```

--------------------------------

### From<SetImageError> for TesseractError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.SetImageError.html

Converts a SetImageError into a TesseractError. This allows integrating SetImageError into a broader Tesseract error handling strategy.

```rust
impl From<SetImageError> for TesseractError {
    fn from(source: SetImageError) -> Self {
        TesseractError::SetImageError(source)
    }
}
```

--------------------------------

### HOCR Text Generation Test

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Tests the generation of HOCR (HTML Output Recognition) text from an image and checks for a specific HTML structure.

```rust
#[test]
fn hocr_test() -> Result<(), TesseractError> {
    let mut cube = Tesseract::new(None, Some("eng"))?.set_image("img.png")?;
    assert!(&cube.get_hocr_text(0)?.contains("<div class='ocr_page'"));
    Ok(())
}
```

--------------------------------

### Tesseract::get_hocr_text

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Retrieves the recognized text encoded as HTML with bounding box tags.

```APIDOC
## Tesseract::get_hocr_text

### Description
Retrieves the recognized text in HOCR (HTML Object Character Recognition) format. This format includes bounding box information for each recognized word or character, encoded within HTML tags.

### Method
`Tesseract::get_hocr_text`

### Parameters
- `page` (c_int): The page number to retrieve HOCR text for.

### Returns
- `Result<String, plumbing::TessBaseApiGetHocrTextError>`: A `Result` containing the HOCR encoded text as a `String` on success, or an error if retrieval fails.
```

--------------------------------

### ocr_from_frame

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Performs OCR on raw image frame data and returns the recognized text.

```APIDOC
## ocr_from_frame

### Description
A convenience function to perform OCR on raw image data from a frame buffer. It initializes Tesseract, sets the frame data, performs recognition, and returns the extracted text.

### Method
`ocr_from_frame`

### Parameters
- `frame_data` (&[u8]): Slice of bytes containing the image pixel data.
- `width` (i32): The width of the image in pixels.
- `height` (i32): The height of the image in pixels.
- `bytes_per_pixel` (i32): The number of bytes per pixel.
- `bytes_per_line` (i32): The number of bytes per line (stride).
- `language` (&str): The language code for the OCR engine (e.g., "eng").

### Returns
- `Result<String, TesseractError>`: A `Result` containing the recognized text as a `String` on success, or a `TesseractError` if any step in the process fails.
```

--------------------------------

### as_tess_page_seg_mode

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.PageSegMode.html

Converts the current PageSegMode variant into the underlying Tesseract-compatible value.

```APIDOC
## pub fn as_tess_page_seg_mode(&self) -> TessPageSegMode

### Description
Retrieves the raw page segmentation mode value used by the underlying Tesseract engine.

### Returns
- **TessPageSegMode**: The corresponding value expected by the Tesseract C++ API.
```

--------------------------------

### OCR Test with Image Frame Data

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

A unit test that performs OCR on image data loaded from a TIFF file ('img.tiff') as a byte array. It specifies image dimensions and asserts the recognized text against 'img.txt'. This tests OCR processing from memory buffers.

```rust
#[test]
fn ocr_from_frame_test() -> Result<(), TesseractError> {
    assert_eq!(
        ocr_from_frame(include_bytes!("../img.tiff"), 2256, 324, 3, 2256 * 3, "eng")?,
        include_str!("../img.txt").to_string()
    );
    Ok(())
}
```

--------------------------------

### Implement Borrow for T

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides the Borrow trait implementation for generic types.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### Set Page Segmentation Mode

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the page segmentation mode for Tesseract. This mode determines how Tesseract analyzes the page layout to identify text blocks, lines, and words. Choose a mode that best suits your document's structure.

```rust
pub fn set_page_seg_mode(&mut self, mode: PageSegMode) {
        self.0.set_page_seg_mode(mode.as_tess_page_seg_mode());
    }
```

--------------------------------

### InitializeError Enum Definition

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

This snippet shows the definition of the InitializeError enum, detailing its variants.

```APIDOC
## Enum InitializeError

### Summary
```rust
pub enum InitializeError {
    CStringError(NulError),
    TessBaseAPIInitError(TessBaseApiInitError),
}
```

### Variants
*   **CStringError(NulError)**: Represents an error during CString conversion, wrapping a `NulError`.
*   **TessBaseAPIInitError(TessBaseApiInitError)**: Represents an error during the initialization of the Tesseract Base API, wrapping a `TessBaseApiInitError`.
```

--------------------------------

### Tesseract OCR Function Signature

Source: https://docs.rs/tesseract/0.15.2/tesseract/fn.ocr.html

This is the function signature for performing OCR. It takes a filename and language code as input and returns the recognized text or an error.

```rust
pub fn ocr(filename: &str, language: &str) -> Result<String, TesseractError>
```

--------------------------------

### PageSegMode Variants

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.PageSegMode.html

The available variants for configuring the page segmentation mode in Tesseract.

```APIDOC
## PageSegMode Variants

- **PsmOsdOnly**: Orientation and script detection only.
- **PsmAutoOsd**: Automatic page segmentation with orientation and script detection (OSD).
- **PsmAutoOnly**: Automatic page segmentation, but no OSD, or OCR.
- **PsmAuto**: Fully automatic page segmentation, but no OSD.
- **PsmSingleColumn**: Assume a single column of text of variable sizes.
- **PsmSingleBlockVertText**: Assume a single uniform block of vertically aligned text.
- **PsmSingleBlock**: Assume a single uniform block of text (Default).
- **PsmSingleLine**: Treat the image as a single text line.
- **PsmSingleWord**: Treat the image as a single word.
- **PsmCircleWord**: Treat the image as a single word in a circle.
- **PsmSingleChar**: Treat the image as a single character.
- **PsmSparseText**: Find as much text as possible in no particular order.
- **PsmSparseTextOsd**: Sparse text with orientation and script detection.
- **PsmRawLine**: Treat the image as a single text line, bypassing Tesseract-specific hacks.
```

--------------------------------

### Tesseract::get_tsv_text

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Retrieves the recognized text encoded as TSV with bounding boxes and confidence.

```APIDOC
## Tesseract::get_tsv_text

### Description
Retrieves the recognized text in TSV (Tab-Separated Values) format. This format includes bounding box coordinates, confidence levels, and the recognized text for each word or line.

### Method
`Tesseract::get_tsv_text`

### Parameters
- `page` (c_int): The page number to retrieve TSV text for.

### Returns
- `Result<String, plumbing::TessBaseApiGetTsvTextError>`: A `Result` containing the TSV encoded text as a `String` on success, or an error if retrieval fails.
```

--------------------------------

### ocr

Source: https://docs.rs/tesseract/0.15.2/tesseract/index.html

Performs OCR on an image.

```APIDOC
## ocr

### Description
Performs Optical Character Recognition (OCR) on an image.

### Parameters

(No specific parameters are detailed in the source for this function.)

### Response

(No specific response details are detailed in the source for this function.)

### Request Example

(No request example is available in the source.)

### Response Example

(No response example is available in the source.)
```

--------------------------------

### From<PixReadError> for SetImageError

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.SetImageError.html

Converts a PixReadError into a SetImageError. This is useful for handling errors when reading Pix images.

```rust
impl From<PixReadError> for SetImageError {
    fn from(source: PixReadError) -> Self {
        SetImageError::PixReadError(source)
    }
}
```

--------------------------------

### InitializeError Enum Definition

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Defines the InitializeError enum with its possible variants.

```rust
pub enum InitializeError {
    CStringError(NulError),
    TessBaseAPIInitError(TessBaseApiInitError),
}
```

--------------------------------

### OcrEngineMode Enum Definition

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.OcrEngineMode.html

Defines the different operating modes for the Tesseract OCR engine. Use these to control whether to use Tesseract only, LSTM only, or a combination.

```rust
pub enum OcrEngineMode {
    Default,
    LstmOnly,
    TesseractLstmCombined,
    TesseractOnly,
}
```

--------------------------------

### Implement BorrowMut for T

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.InitializeError.html

Provides the BorrowMut trait implementation for generic types.

```rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### Tesseract::set_frame

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets the image to be processed by Tesseract from raw frame data.

```APIDOC
## Tesseract::set_frame

### Description
Sets the image for Tesseract processing using raw pixel data from a frame buffer. This is useful for processing images directly from memory or camera feeds.

### Method
`Tesseract::set_frame`

### Parameters
- `frame_data` (&[u8]): Slice of bytes containing the image pixel data.
- `width` (i32): The width of the image in pixels.
- `height` (i32): The height of the image in pixels.
- `bytes_per_pixel` (i32): The number of bytes per pixel.
- `bytes_per_line` (i32): The number of bytes per line (stride).

### Returns
- `Result<Self, plumbing::TessBaseApiSetImageSafetyError>`: A `Result` containing the modified `Tesseract` instance on success, or an error if setting the image fails.
```

--------------------------------

### LSTM Only OCR Test

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Tests the LSTM-only OCR engine mode, asserting that the recognized text matches a known file.

```rust
#[test]
fn oem_ltsm_only_test() -> Result<(), TesseractError> {
    let only_lstm_str = Tesseract::new_with_oem(None, Some("eng"), OcrEngineMode::LstmOnly)?
        .set_image("img.png")?
        .recognize()? 
        .get_text()?;

    assert_eq!(only_lstm_str, include_str!("../img.txt"));
    Ok(())
}
```

--------------------------------

### ocr_from_frame

Source: https://docs.rs/tesseract/0.15.2/tesseract/fn.ocr_from_frame.html

Performs OCR on raw image frame data. This function takes detailed information about the image buffer, including dimensions, pixel format, and language, to extract text.

```APIDOC
## Function ocr_from_frame

### Description
Performs Optical Character Recognition (OCR) on raw image frame data. This function requires detailed specifications of the image buffer, such as dimensions, pixel format, and the language for recognition, to accurately extract text.

### Signature
```rust
pub fn ocr_from_frame(
    frame_data: &[u8],
    width: i32,
    height: i32,
    bytes_per_pixel: i32,
    bytes_per_line: i32,
    language: &str,
) -> Result<String, TesseractError>
```

### Parameters
* **frame_data** (`&[u8]`) - A slice containing the raw pixel data of the image frame.
* **width** (`i32`) - The width of the image frame in pixels.
* **height** (`i32`) - The height of the image frame in pixels.
* **bytes_per_pixel** (`i32`) - The number of bytes used to represent each pixel.
* **bytes_per_line** (`i32`) - The number of bytes from one image line to the next.
* **language** (`&str`) - The language model to use for OCR (e.g., "eng" for English).

### Returns
* `Result<String, TesseractError>` - On success, returns a `String` containing the extracted text. On failure, returns a `TesseractError`.
```

--------------------------------

### SetImageError Enum Definition

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.SetImageError.html

Defines the SetImageError enum with its possible error variants.

```rust
pub enum SetImageError {
    CStringError(NulError),
    PixReadError(PixReadError),
}
```

--------------------------------

### PageSegMode Enum Definition

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/page_seg_mode.rs.html

Defines the PageSegMode enum with variants representing different page segmentation strategies for Tesseract. Each variant includes a brief description of its purpose.

```rust
1// ⚠️ This file is generated
2// ⚠️ Regenerate with `make src/page_seg_mode.rs`
3
4use tesseract_sys::TessPageSegMode;
5
6/// Enum representing different PageSegMode options accepted by Tesseract
7#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8pub enum PageSegMode {
9    /// Orientation and script detection only.
10    PsmOsdOnly,
11    /// Automatic page segmentation with orientation and script detection. (OSD)
12    PsmAutoOsd,
13    /// Automatic page segmentation, but no OSD, or OCR.
14    PsmAutoOnly,
15    /// Fully automatic page segmentation, but no OSD.
16    PsmAuto,
17    /// Assume a single column of text of variable sizes.
18    PsmSingleColumn,
19    /// Assume a single uniform block of vertically aligned text.
20    PsmSingleBlockVertText,
21    /// Assume a single uniform block of text. (Default.)
22    PsmSingleBlock,
23    /// Treat the image as a single text line.
24    PsmSingleLine,
25    /// Treat the image as a single word.
26    PsmSingleWord,
27    /// Treat the image as a single word in a circle.
28    PsmCircleWord,
29    /// Treat the image as a single character.
30    PsmSingleChar,
31    /// Find as much text as possible in no particular order.
32    PsmSparseText,
33    /// Sparse text with orientation and script det.
34    PsmSparseTextOsd,
35    /// Treat the image as a single text line, bypassing hacks that are Tesseract-specific.
36    PsmRawLine,
37}
38
39impl PageSegMode {
40    /// Get the page-seg-mode's value as used by Tesseract
41    pub fn as_tess_page_seg_mode(&self) -> TessPageSegMode {
42        match self {
43            PageSegMode::PsmOsdOnly => tesseract_sys::TessPageSegMode_PSM_OSD_ONLY,
44            PageSegMode::PsmAutoOsd => tesseract_sys::TessPageSegMode_PSM_AUTO_OSD,
45            PageSegMode::PsmAutoOnly => tesseract_sys::TessPageSegMode_PSM_AUTO_ONLY,
46            PageSegMode::PsmAuto => tesseract_sys::TessPageSegMode_PSM_AUTO,
47            PageSegMode::PsmSingleColumn => tesseract_sys::TessPageSegMode_PSM_SINGLE_COLUMN,
48            PageSegMode::PsmSingleBlockVertText => {
49                tesseract_sys::TessPageSegMode_PSM_SINGLE_BLOCK_VERT_TEXT
50            }
51            PageSegMode::PsmSingleBlock => tesseract_sys::TessPageSegMode_PSM_SINGLE_BLOCK,
52            PageSegMode::PsmSingleLine => tesseract_sys::TessPageSegMode_PSM_SINGLE_LINE,
53            PageSegMode::PsmSingleWord => tesseract_sys::TessPageSegMode_PSM_SINGLE_WORD,
54            PageSegMode::PsmCircleWord => tesseract_sys::TessPageSegMode_PSM_CIRCLE_WORD,
55            PageSegMode::PsmSingleChar => tesseract_sys::TessPageSegMode_PSM_SINGLE_CHAR,
56            PageSegMode::PsmSparseText => tesseract_sys::TessPageSegMode_PSM_SPARSE_TEXT,
57            PageSegMode::PsmSparseTextOsd => tesseract_sys::TessPageSegMode_PSM_SPARSE_TEXT_OSD,
58            PageSegMode::PsmRawLine => tesseract_sys::TessPageSegMode_PSM_RAW_LINE,
59        }
60    }
61}

```

--------------------------------

### Tesseract::set_rectangle

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Sets a rectangular region of interest on the image.

```APIDOC
## Tesseract::set_rectangle

### Description
Defines a rectangular region within the current image to focus OCR processing on. This can be used to process only a specific part of an image.

### Method
`Tesseract::set_rectangle`

### Parameters
- `left` (i32): The x-coordinate of the top-left corner of the rectangle.
- `top` (i32): The y-coordinate of the top-left corner of the rectangle.
- `width` (i32): The width of the rectangle.
- `height` (i32): The height of the rectangle.

### Returns
- `Self`: The modified `Tesseract` instance.
```

--------------------------------

### Set Recognition Rectangle

Source: https://docs.rs/tesseract/0.15.2/src/tesseract/lib.rs.html

Defines a specific rectangular region within the image for OCR processing. This allows focusing recognition on a particular area of interest. The coordinates are relative to the image's top-left corner.

```rust
pub fn set_rectangle(mut self, left: i32, top: i32, width: i32, height: i32) -> Self {
        self.0.set_rectangle(left, top, width, height);
        self
    }
```

--------------------------------

### SetImageError Enum

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.SetImageError.html

The SetImageError enum is used to indicate errors during image setting operations. It includes variants for CString conversion failures and errors encountered while reading Pix images.

```APIDOC
## Enum SetImageError

### Summary
```
pub enum SetImageError {
    CStringError(NulError),
    PixReadError(PixReadError),
}
```

### Variants

*   **CStringError(NulError)**: Represents an error that occurred during CString conversion, wrapping a `NulError`.
*   **PixReadError(PixReadError)**: Represents an error that occurred while reading a Pix image, wrapping a `PixReadError`.
```

--------------------------------

### TesseractError Enum Definition

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.TesseractError.html

Defines the TesseractError enum, which enumerates different types of errors that can be returned by the Tesseract OCR library. Each variant wraps a specific underlying error type.

```rust
pub enum TesseractError {
    InitializeError(InitializeError),
    SetImageError(SetImageError),
    RecognizeError(TessBaseApiRecogniseError),
    GetTextError(TessBaseApiGetUtf8TextError),
    GetHOCRTextError(TessBaseApiGetHocrTextError),
    GetTsvTextError(TessBaseApiGetTsvTextError),
    SetFrameError(TessBaseApiSetImageSafetyError),
    SetImgFromMemError(PixReadMemError),
    SetVariableError(SetVariableError),
}
```

--------------------------------

### SetVariableError Enum Definition

Source: https://docs.rs/tesseract/0.15.2/tesseract/enum.SetVariableError.html

Defines the SetVariableError enum with its possible variants: CStringError and TessBaseAPISetVariableError.

```rust
pub enum SetVariableError {
    CStringError(NulError),
    TessBaseAPISetVariableError(TessBaseApiSetVariableError),
}
```
Tokens:
Raw