sudacode/owocr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

More fixes

Browse Source
This commit is contained in:
AuroraWright
2025-10-13 15:27:02 +02:00
parent d5b12a08f2
commit 3bf2e04b7d
1 changed files with 61 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
owocr/run.py
View File

@@ -10,7 +10,6 @@ import logging
import inspect import inspect
import os import os
import json import json
import copy
from dataclasses import asdict from dataclasses import asdict
import numpy as np import numpy as np
@@ -296,15 +295,15 @@ class TextFiltering:
self.frame_stabilization = 0 if config.get_general('screen_capture_delay_secs') == -1 else config.get_general('screen_capture_frame_stabilization') self.frame_stabilization = 0 if config.get_general('screen_capture_delay_secs') == -1 else config.get_general('screen_capture_frame_stabilization')
self.line_recovery = config.get_general('screen_capture_line_recovery') self.line_recovery = config.get_general('screen_capture_line_recovery')
self.furigana_filter = config.get_general('screen_capture_furigana_filter') self.furigana_filter = config.get_general('screen_capture_furigana_filter')
self.last_frame_data = [None, None] self.last_frame_data = (None, None)
self.last_last_frame_data = [None, None] self.last_last_frame_data = (None, None)
self.stable_frame_data = None self.stable_frame_data = None
self.last_frame_text = [] self.last_frame_text = ([], None)
self.last_last_frame_text = [] self.last_last_frame_text = ([], None)
self.stable_frame_text = [] self.stable_frame_text = []
self.processed_stable_frame = False self.processed_stable_frame = False
self.frame_stabilization_timestamp = 0 self.frame_stabilization_timestamp = 0
self.cj_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]') self.cj_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E01-\u9FFF]')
self.kanji_regex = re.compile(r'[\u4E00-\u9FFF]') self.kanji_regex = re.compile(r'[\u4E00-\u9FFF]')
self.regex = self.get_regex() self.regex = self.get_regex()
self.kana_variants = { self.kana_variants = {
@@ -382,7 +381,7 @@ class TextFiltering:
if changed_lines == None: if changed_lines == None:
return 0, 0, None return 0, 0, None
changed_lines_count = len(changed_lines) changed_lines_count = len(changed_lines)
self.last_frame_data = (pil_image, copy.deepcopy(current_result)) self.last_frame_data = (pil_image, current_result)
if changed_lines_count and config.get_general('output_format') != 'json': if changed_lines_count and config.get_general('output_format') != 'json':
changed_regions_image = self._create_changed_regions_image(pil_image, changed_lines, None, None) changed_regions_image = self._create_changed_regions_image(pil_image, changed_lines, None, None)
if not changed_regions_image: if not changed_regions_image:
@@ -414,7 +413,7 @@ class TextFiltering:
recovered_lines_count = 0 recovered_lines_count = 0
recovered_lines = [] recovered_lines = []
self.processed_stable_frame = True self.processed_stable_frame = True
self.stable_frame_data = copy.deepcopy(current_result) self.stable_frame_data = current_result
changed_lines_count = len(changed_lines) changed_lines_count = len(changed_lines)
if (changed_lines_count or recovered_lines_count) and config.get_general('output_format') != 'json': if (changed_lines_count or recovered_lines_count) and config.get_general('output_format') != 'json':
if recovered_lines: if recovered_lines:
@@ -430,7 +429,7 @@ class TextFiltering:
return changed_lines_count, recovered_lines_count, None return changed_lines_count, recovered_lines_count, None
else: else:
self.last_last_frame_data = self.last_frame_data self.last_last_frame_data = self.last_frame_data
self.last_frame_data = (pil_image, copy.deepcopy(current_result)) self.last_frame_data = (pil_image, current_result)
self.processed_stable_frame = False self.processed_stable_frame = False
self.frame_stabilization_timestamp = time.time() self.frame_stabilization_timestamp = time.time()
return 0, 0, None return 0, 0, None
@@ -442,62 +441,66 @@ class TextFiltering:
changed_lines = [] changed_lines = []
current_lines = [] current_lines = []
previous_lines = [] previous_lines = []
current_text = []
previous_text = []
for p in current_result.paragraphs: for p in current_result.paragraphs:
current_lines.extend(p.lines) current_lines.extend(p.lines)
if len(current_lines) == 0: if len(current_lines) == 0:
return None return None
all_previous_text_spliced = [] for current_line in current_lines:
current_text_line = self._get_line_text(current_line)
current_text_line = self._normalize_line_for_comparison(current_text_line)
current_text.append(current_text_line)
if all(not current_text_line for current_text_line in current_lines):
return None
if previous_result: if previous_result:
for p in previous_result.paragraphs: for p in previous_result.paragraphs:
previous_lines.extend(p.lines) previous_lines.extend(p.lines)
if next_result != None: if next_result:
for p in next_result.paragraphs: for p in next_result.paragraphs:
previous_lines.extend(p.lines) previous_lines.extend(p.lines)
for prev_line in previous_lines: for previous_line in previous_lines:
prev_text = self._get_line_text(prev_line) previous_text_line = self._get_line_text(previous_line)
prev_text = self._normalize_line_for_comparison(prev_text) previous_text_line = self._normalize_line_for_comparison(previous_text_line)
all_previous_text_spliced.append(prev_text) previous_text.append(previous_text_line)
all_previous_text = ''.join(all_previous_text_spliced) all_previous_text = ''.join(previous_text)
logger.debug(f"Previous text: '{all_previous_text_spliced}'") logger.debug(f"Previous text: '{previous_text}'")
processed_valid_line = False for i, current_text_line in enumerate(current_text):
for current_line in current_lines: if not current_text_line:
current_text = self._get_line_text(current_line)
current_text = self._normalize_line_for_comparison(current_text)
if not current_text:
continue continue
processed_valid_line = True if not next_result and len(current_text_line) < 3:
text_similar = current_text_line in previous_text
if next_result == None and len(current_text) < 3:
text_similar = current_text in all_previous_text_spliced
else: else:
text_similar = current_text in all_previous_text text_similar = current_text_line in all_previous_text
logger.debug(f"Current line: '{current_text}' Similar: '{text_similar}'") logger.debug(f"Current line: '{current_text_line}' Similar: '{text_similar}'")
if not text_similar: if not text_similar:
if next_result != None: if next_result:
logger.opt(colors=True).debug(f"<red>Recovered line: '{current_text}'</red>") logger.opt(colors=True).debug(f"<red>Recovered line: '{current_text_line}'</red>")
changed_lines.append(current_line) changed_lines.append(current_lines[i])
return changed_lines if processed_valid_line else None return changed_lines
def _find_changed_lines_text(self, current_result, current_result_ocr, two_pass_processing_active, recovered_lines_count): def _find_changed_lines_text(self, current_result, current_result_ocr, two_pass_processing_active, recovered_lines_count):
frame_stabilization_active = self.frame_stabilization != 0 frame_stabilization_active = self.frame_stabilization != 0
if (not frame_stabilization_active) or two_pass_processing_active: if (not frame_stabilization_active) or two_pass_processing_active:
changed_lines = self._find_changed_lines_text_impl(current_result, current_result_ocr, None, self.last_frame_text, None, True, recovered_lines_count) changed_lines = self._find_changed_lines_text_impl(current_result, current_result_ocr, None, self.last_frame_text[0], None, True, recovered_lines_count)
self.last_frame_text = current_result if changed_lines == None:
return []
self.last_frame_text = (current_result, current_result_ocr)
return changed_lines return changed_lines
changed_lines_stabilization = self._find_changed_lines_text_impl(current_result, current_result_ocr, None, self.last_frame_text, None, False, False) changed_lines_stabilization = self._find_changed_lines_text_impl(current_result, current_result_ocr, None, self.last_frame_text[0], None, False, 0)
if changed_lines_stabilization == None: if changed_lines_stabilization == None:
return [] return []
@@ -510,9 +513,9 @@ class TextFiltering:
return [] return []
if time.time() - self.frame_stabilization_timestamp < self.frame_stabilization: if time.time() - self.frame_stabilization_timestamp < self.frame_stabilization:
return [] return []
if self.line_recovery and self.last_last_frame_text: if self.line_recovery and self.last_last_frame_text[0]:
logger.debug(f'Checking for missed lines') logger.debug(f'Checking for missed lines')
recovered_lines = self._find_changed_lines_text_impl(self.last_last_frame_text, None, None, self.stable_frame_text, current_result, True, False) recovered_lines = self._find_changed_lines_text_impl(self.last_last_frame_text[0], self.last_last_frame_text[1], None, self.stable_frame_text, current_result, False, 0)
recovered_lines_count = len(recovered_lines) if recovered_lines else 0 recovered_lines_count = len(recovered_lines) if recovered_lines else 0
else: else:
recovered_lines_count = 0 recovered_lines_count = 0
@@ -523,7 +526,7 @@ class TextFiltering:
return changed_lines return changed_lines
else: else:
self.last_last_frame_text = self.last_frame_text self.last_last_frame_text = self.last_frame_text
self.last_frame_text = current_result self.last_frame_text = (current_result, current_result_ocr)
self.processed_stable_frame = False self.processed_stable_frame = False
self.frame_stabilization_timestamp = time.time() self.frame_stabilization_timestamp = time.time()
return [] return []
@@ -533,43 +536,41 @@ class TextFiltering:
current_result = recovered_lines + current_result current_result = recovered_lines + current_result
if len(current_result) == 0: if len(current_result) == 0:
return [] return None
changed_lines = [] changed_lines = []
current_lines = [] current_lines = []
current_lines_ocr = [] current_lines_ocr = []
all_previous_text_spliced = [] previous_text = []
for current_line in current_result:
current_text_line = self._normalize_line_for_comparison(current_line)
current_lines.append(current_text_line)
if all(not current_text_line for current_text_line in current_lines):
return None
if self.furigana_filter and self.language == 'ja' and isinstance(current_result_ocr, OcrResult): if self.furigana_filter and self.language == 'ja' and isinstance(current_result_ocr, OcrResult):
for p in current_result_ocr.paragraphs: for p in current_result_ocr.paragraphs:
current_lines_ocr.extend(p.lines) current_lines_ocr.extend(p.lines)
for current_line in current_result:
current_text = self._normalize_line_for_comparison(current_line)
current_lines.append(current_text)
for prev_line in previous_result: for prev_line in previous_result:
prev_text = self._normalize_line_for_comparison(prev_line) prev_text = self._normalize_line_for_comparison(prev_line)
all_previous_text_spliced.append(prev_text) previous_text.append(prev_text)
if next_result != None: if next_result != None:
for next_text in next_result: for next_text in next_result:
all_previous_text_spliced.extend(next_text) previous_text.extend(next_text)
all_previous_text = ''.join(all_previous_text_spliced) all_previous_text = ''.join(previous_text)
logger.opt(colors=True).debug(f"<magenta>Previous text: '{all_previous_text_spliced}'</magenta>") logger.opt(colors=True).debug(f"<magenta>Previous text: '{previous_text}'</magenta>")
first = True first = True
processed_valid_line = False
for i, current_text in enumerate(current_lines): for i, current_text in enumerate(current_lines):
if not current_text: if not current_text:
continue continue
processed_valid_line = True if next_result != None and len(current_text) < 3:
is_furigana = False text_similar = current_text in previous_text
if len(current_text) < 3:
text_similar = current_text in all_previous_text_spliced
else: else:
text_similar = current_text in all_previous_text text_similar = current_text in all_previous_text
@@ -579,7 +580,7 @@ class TextFiltering:
continue continue
if recovered_lines_count > 0: if recovered_lines_count > 0:
if any(line.startswith(current_text) for line in current_lines): if any(line.startswith(current_text) for j, line in enumerate(current_lines) if i != j):
logger.opt(colors=True).debug(f"<magenta>Skipping recovered line: '{current_text}'</magenta>") logger.opt(colors=True).debug(f"<magenta>Skipping recovered line: '{current_text}'</magenta>")
recovered_lines_count -= 1 recovered_lines_count -= 1
continue continue
@@ -598,6 +599,8 @@ class TextFiltering:
has_kanji = self.kanji_regex.search(current_text) has_kanji = self.kanji_regex.search(current_text)
if not has_kanji: if not has_kanji:
is_furigana = False
for j in range(len(current_lines_ocr)): for j in range(len(current_lines_ocr)):
if i2 == j: if i2 == j:
continue continue
@@ -647,7 +650,7 @@ class TextFiltering:
logger.opt(colors=True).debug(f"<magenta>After cutting: '{changed_line}'</magenta>") logger.opt(colors=True).debug(f"<magenta>After cutting: '{changed_line}'</magenta>")
changed_lines.append(changed_line) changed_lines.append(changed_line)
return changed_lines if processed_valid_line else [] return changed_lines
def _find_overlap(self, previous_text, current_text): def _find_overlap(self, previous_text, current_text):
min_overlap_length = 3 min_overlap_length = 3
@@ -1188,7 +1191,7 @@ class SecondPassThread:
def _process_ocr(self): def _process_ocr(self):
while self.running and not terminated: while self.running and not terminated:
try: try:
img, engine_instance, recovered_lines_count = self.input_queue.get(timeout=30) img, engine_instance, recovered_lines_count = self.input_queue.get(timeout=0.1)
start_time = time.time() start_time = time.time()
res, result_data = engine_instance(img) res, result_data = engine_instance(img)