|
|
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 |
