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