| import re |
| import time |
| import base64 |
| import json |
| import cv2 |
| import numpy as np |
| from typing import List |
| import httpx |
|
|
| from .base import register_OCR, OCRBase, TextBlock |
|
|
| import logging |
| httpx_logger = logging.getLogger("httpx") |
| httpx_logger.setLevel(logging.WARNING) |
|
|
|
|
| @register_OCR('google_vision') |
| class OCRGoogleVisionAPI(OCRBase): |
| params = { |
| 'api_key': '', |
| 'language_hints': { |
| 'value': '', |
| 'description': 'Language codes separated by commas (BCP-47)' |
| }, |
| 'proxy': { |
| 'value': '', |
| 'description': 'Proxy address (e.g., http(s)://user:password@host:port or socks4/5://user:password@host:port)' |
| }, |
| 'delay': 0.0, |
| 'newline_handling': { |
| 'type': 'selector', |
| 'options': [ |
| 'preserve', |
| 'remove' |
| ], |
| 'value': 'preserve', |
| 'description': 'Choose how to handle newline characters in OCR results' |
| }, |
| 'no_uppercase': { |
| 'type': 'checkbox', |
| 'value': False, |
| 'description': 'Convert text to lowercase except the first letter of each sentence' |
| }, |
| 'description': 'OCR using Google Vision API' |
| } |
|
|
| @property |
| def request_delay(self): |
| try: |
| return float(self.get_param_value('delay')) |
| except (ValueError, TypeError): |
| return 1.0 |
|
|
| @property |
| def language_hints(self): |
| hints = self.get_param_value('language_hints') |
| return [hint.strip() for hint in hints.split(",")] if hints else None |
|
|
| @property |
| def api_key(self): |
| return self.get_param_value('api_key') |
|
|
| @property |
| def proxy(self): |
| return self.get_param_value('proxy') |
|
|
| @property |
| def newline_handling(self): |
| return self.get_param_value('newline_handling') |
|
|
| @property |
| def no_uppercase(self): |
| return self.get_param_value('no_uppercase') |
|
|
| def __init__(self, **params) -> None: |
| if 'delay' in params: |
| try: |
| params['delay'] = float(params['delay']) |
| except (ValueError, TypeError): |
| params['delay'] = 1.0 |
| super().__init__(**params) |
| self.proxy_url = self.proxy |
| self.last_request_time = 0 |
|
|
| def send_to_google_vision(self, image_buffer: bytes): |
| VISION_API_URL = f"https://vision.googleapis.com/v1/images:annotate?key={self.api_key}" |
|
|
| image_content = base64.b64encode(image_buffer).decode("utf-8") |
|
|
| request_body = { |
| "requests": [ |
| { |
| "image": { |
| "content": image_content |
| }, |
| "features": [ |
| { |
| "type": "TEXT_DETECTION" |
| } |
| ] |
| } |
| ] |
| } |
|
|
| if self.language_hints: |
| request_body["requests"][0]["imageContext"] = { |
| "languageHints": self.language_hints |
| } |
|
|
| headers = { |
| "Content-Type": "application/json" |
| } |
|
|
| client_kwargs = {'headers': headers} |
| if self.proxy_url: |
| mounts = {} |
| if self.proxy_url.startswith(('http://', 'https://', 'socks4://', 'socks5://')): |
| mounts["all://"] = httpx.HTTPTransport(proxy=self.proxy_url) |
| else: |
| self.logger.warning("The proxy URL does not contain a schema (http://, https://, socks4://, socks5://). The proxy may not work.") |
| mounts["all://"] = httpx.HTTPTransport(proxy=self.proxy_url) |
| client_kwargs['mounts'] = mounts |
|
|
| with httpx.Client(**client_kwargs) as client: |
| try: |
| if self.debug_mode: |
| proxy_info = self.proxy_url if self.proxy_url else "No proxy" |
| self.logger.debug(f"Sending request to Google Vision API with proxy: {proxy_info}") |
|
|
| response = client.post(VISION_API_URL, headers=headers, json=request_body) |
| response.raise_for_status() |
|
|
| return response.json() |
| except httpx.HTTPError as e: |
| raise Exception(f"Error during request to Google Vision API: {e}") |
|
|
| def extract_text_and_coordinates(self, annotations): |
| text_with_coords = [] |
| for annotation in annotations: |
| if 'description' in annotation: |
| words = annotation.get('description', '').split() |
| vertices = annotation.get('boundingPoly', {}).get('vertices', []) |
| text_with_coords.append({ |
| "text": annotation['description'], |
| "coordinates": [(v.get("x", 0), v.get("y", 0)) for v in vertices] |
| }) |
| return text_with_coords |
|
|
| def extract_full_text(self, response_json): |
| try: |
| return response_json['responses'][0]['fullTextAnnotation']['text'] |
| except (IndexError, KeyError, TypeError): |
| return "Full text not found or not recognized" |
|
|
| def process_image(self, image_buffer: bytes): |
| response = self.send_to_google_vision(image_buffer) |
| full_text = self.extract_full_text(response) |
|
|
| return { |
| 'full_text': full_text, |
| 'language': response['responses'][0].get('language', 'und'), |
| 'text_with_coordinates': self.extract_text_and_coordinates(response.get("responses", [{}])[0].get("textAnnotations", [])) |
| } |
|
|
| def format_ocr_result(self, result): |
| formatted_result = { |
| "language": result.get("language", ""), |
| "full_text": result.get("full_text", ""), |
| "text_with_coordinates": [ |
| f"{item['text']}: {item['coordinates']}" |
| for item in result.get("text_with_coordinates", []) |
| ] |
| } |
| return json.dumps(formatted_result, indent=4, ensure_ascii=False) |
|
|
| def _ocr_blk_list(self, img: np.ndarray, blk_list: List[TextBlock], *args, **kwargs): |
| im_h, im_w = img.shape[:2] |
| if self.debug_mode: |
| self.logger.debug(f'Image dimensions: {im_h}x{im_w}') |
| for blk in blk_list: |
| x1, y1, x2, y2 = blk.xyxy |
| if self.debug_mode: |
| self.logger.debug(f'Processing block: ({x1}, {y1}, {x2}, {y2})') |
| if y2 < im_h and x2 < im_w and x1 >= 0 and y1 >= 0 and x1 < x2 and y1 < y2: |
| cropped_img = img[y1:y2, x1:x2] |
| if self.debug_mode: |
| self.logger.debug(f'Cropped image dimensions: {cropped_img.shape}') |
| blk.text = self.ocr(cropped_img) |
| else: |
| if self.debug_mode: |
| self.logger.warning('Invalid text block coordinates') |
| blk.text = '' |
|
|
| def ocr_img(self, img: np.ndarray) -> str: |
| return self.ocr(img) |
|
|
| def ocr(self, img: np.ndarray) -> str: |
| if self.debug_mode: |
| self.logger.debug(f'Starting OCR on image of shape: {img.shape}') |
| self._respect_delay() |
| try: |
| if img.size > 0: |
| if self.debug_mode: |
| self.logger.debug(f'Input image size: {img.shape}') |
| _, buffer = cv2.imencode('.jpg', img) |
| result = self.process_image(buffer.tobytes()) |
| if self.debug_mode: |
| formatted_result = self.format_ocr_result(result) |
| self.logger.debug(f'OCR result: {formatted_result}') |
|
|
| ignore_texts = [ |
| 'Full text not found or not recognized' |
| ] |
| if result['full_text'] in ignore_texts: |
| return '' |
| full_text = result['full_text'] |
| if self.newline_handling == 'remove': |
| full_text = full_text.replace('\n', ' ') |
|
|
| full_text = self._apply_punctuation_and_spacing(full_text) |
|
|
| if self.no_uppercase: |
| full_text = self._apply_no_uppercase(full_text) |
|
|
| return full_text |
| else: |
| if self.debug_mode: |
| self.logger.warning('Empty image for OCR') |
| return '' |
| except Exception as e: |
| if self.debug_mode: |
| self.logger.error(f"OCR error: {str(e)}") |
| return '' |
|
|
| def _apply_no_uppercase(self, text: str) -> str: |
| def process_sentence(sentence): |
| words = sentence.split() |
| if not words: |
| return '' |
| processed = [words[0].capitalize()] + [word.lower() for word in words[1:]] |
| return ' '.join(processed) |
|
|
| sentences = re.split(r'(?<=[.!?…])\s+', text) |
| processed_sentences = [process_sentence(sentence) for sentence in sentences] |
|
|
| return ' '.join(processed_sentences) |
|
|
| def _apply_punctuation_and_spacing(self, text: str) -> str: |
| text = re.sub(r'\s+([,.!?…])', r'\1', text) |
| text = re.sub(r'([,.!?…])(?!\s)(?![,.!?…])', r'\1 ', text) |
| text = re.sub(r'([,.!?…])\s+([,.!?…])', r'\1\2', text) |
| return text.strip() |
|
|
| def _respect_delay(self): |
| current_time = time.time() |
| time_since_last_request = current_time - self.last_request_time |
| if self.debug_mode: |
| self.logger.info(f'Time since last request: {time_since_last_request} seconds') |
|
|
| if time_since_last_request < self.request_delay: |
| sleep_time = self.request_delay - time_since_last_request |
| if self.debug_mode: |
| self.logger.info(f'Waiting {sleep_time} seconds before next request') |
| time.sleep(sleep_time) |
| self.last_request_time = time.time() |
|
|
| def updateParam(self, param_key: str, param_content): |
| if param_key == 'delay': |
| try: |
| param_content = float(param_content) |
| except (ValueError, TypeError): |
| param_content = 1.0 |
| super().updateParam(param_key, param_content) |
| if param_key == 'proxy': |
| self.proxy_url = param_content |
