1911874936

Build # 1911874936

Build Type

github-actions

Committed by GitHub

Commit Message

<a href="https://github.com/dynobo/normcap/commit/<a class=hub.com/dynobo/normcap/commit/174bff48de0073ce3deee1a7d88891cb52e9adfa">174bff48d<a href="https://github.com/dynobo/normcap/commit/174bff48de0073ce3deee1a7d88891cb52e9adfa">">Merge </a><a class="double-link" href="https://github.com/dynobo/normcap/commit/<a class="double-link" href="https://github.com/dynobo/normcap/commit/b2a977056be58e4e7dc923bddb0860fd2cb57d47">b2a977056</a>">b2a977056</a><a href="https://github.com/dynobo/normcap/commit/174bff48de0073ce3deee1a7d88891cb52e9adfa"> into b972769cd">b972769cd</a>

Pull Request Pull Request #186: Dev

Run Details

1289 of 1289 new or added lines in 43 files covered. (100.0%)

1557 of 1928 relevant lines covered (80.76%)

1.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.85

/src/normcap/gui/main_window.py

"""Normcap main window."""

import io
import logging
import os
import sys
import tempfile
import time

from PIL import Image
from PySide6 import QtCore, QtGui, QtWidgets

from normcap import ocr
from normcap.gui import system_info, utils
from normcap.gui.base_window import BaseWindow
from normcap.gui.models import Capture, CaptureMode, DesktopEnvironment, Rect, Screen
from normcap.gui.notifier import Notifier
from normcap.gui.settings import init_settings
from normcap.gui.settings_menu import SettingsMenu
from normcap.gui.system_tray import SystemTray
from normcap.gui.update_check import UpdateChecker
from normcap.screengrab import grab_screens

logger = logging.getLogger(__name__)


class Communicate(QtCore.QObject):
    """Applications' communication bus."""

    on_region_selected = QtCore.Signal(Rect)
    on_image_cropped = QtCore.Signal()
    on_ocr_performed = QtCore.Signal()
    on_copied_to_clipboard = QtCore.Signal()
    on_send_notification = QtCore.Signal(Capture)
    on_window_positioned = QtCore.Signal()
    on_minimize_windows = QtCore.Signal()
    on_set_cursor_wait = QtCore.Signal()
    on_quit_or_hide = QtCore.Signal(str)
    on_update_available = QtCore.Signal(str)
    on_open_url_and_hide = QtCore.Signal(str)


class MainWindow(BaseWindow):
    """Main (parent) window."""

    tray: SystemTray
    settings_menu: SettingsMenu
    update_checker: UpdateChecker
    com = Communicate()
    capture = Capture()

    def __init__(self, args):
        """Initialize main application window."""
        self.settings = init_settings(
            "normcap",
            "settings",
            initial=args,
            reset=args.get("reset", False),
        )
        self.capture.mode = (
            CaptureMode.PARSE
            if self.settings.value("mode") == "parse"
            else CaptureMode.RAW
        )
        self.screens: dict[int, Screen] = system_info.screens()
        try:
            self._update_screenshots()
        except AssertionError:
            logger.warning("Screenshots not available. Exiting NormCap.")
            sys.exit(1)

        super().__init__(
            screen_idx=0,
            parent=None,
            color=str(self.settings.value("color")),
        )

        self.clipboard = QtWidgets.QApplication.clipboard()

        self._set_signals()
        self._add_tray()
        self._add_settings_menu()
        self._add_update_checker()
        self._add_notifier()

        self.all_windows: dict[int, BaseWindow] = {0: self}
        if len(self.screens) > 1:
            self._init_child_windows()

    def _update_screenshots(self):
        for idx, screenshot in enumerate(grab_screens()):
            utils.save_image_in_tempfolder(screenshot, postfix=f"_raw_screen{idx}")
            self.screens[idx].screenshot = screenshot

    def _add_settings_menu(self):
        self.settings_menu = SettingsMenu(self)
        self.settings_menu.com.on_setting_changed.connect(self._update_setting)
        self.settings_menu.com.on_open_url.connect(self.com.on_open_url_and_hide)
        self.settings_menu.com.on_quit_or_hide.connect(
            lambda: self.com.on_quit_or_hide.emit("clicked close in menu")
        )
        self.settings_menu.move(self.width() - self.settings_menu.width() - 26, 26)
        self.settings_menu.show()

    def _add_tray(self):
        self.tray = SystemTray(self)
        self.tray.com.on_capture.connect(self._show_windows)
        self.tray.com.on_quit.connect(
            lambda: self._quit_application("clicked exit in tray")
        )
        if self.settings.value("tray", type=bool):
            self.tray.show()

    def _add_update_checker(self):
        if self.settings.value("update", type=bool):
            checker = UpdateChecker(self, packaged=system_info.is_briefcase_package())
            checker.com.on_version_retrieved.connect(checker.show_update_message)
            checker.com.on_click_get_new_version.connect(self.com.on_open_url_and_hide)
            QtCore.QTimer.singleShot(500, checker.check)

    def _add_notifier(self):
        self.notifier = Notifier(self)
        self.com.on_send_notification.connect(self.notifier.send_notification)
        self.notifier.com.on_notification_sent.connect(
            lambda: self.com.on_quit_or_hide.emit("notification sent")
        )

    def _set_signals(self):
        """Set up signals to trigger program logic."""
        self.com.on_region_selected.connect(self._crop_image)
        self.com.on_image_cropped.connect(self._capture_to_ocr)
        self.com.on_ocr_performed.connect(self._copy_to_clipboard)
        self.com.on_copied_to_clipboard.connect(self._notify_or_close)

        self.com.on_minimize_windows.connect(self._hide_windows)
        self.com.on_set_cursor_wait.connect(
            lambda: utils.set_cursor(QtCore.Qt.WaitCursor)
        )
        self.com.on_quit_or_hide.connect(self._quit_or_hide)
        self.com.on_open_url_and_hide.connect(self._open_url_and_hide)

    ###################
    # UI Manipulation #
    ###################

    def _init_child_windows(self):
        """Initialize child windows with method depending on system."""
        if not system_info.display_manager_is_wayland():
            self._create_all_child_windows()
        elif system_info.desktop_environment() in [
            DesktopEnvironment.GNOME,
            DesktopEnvironment.KDE,
        ]:
            self.com.on_window_positioned.connect(self._create_next_child_window)

    def _create_next_child_window(self):
        """Open child window only for next display."""
        if len(system_info.screens()) > len(self.all_windows):
            index = max(self.all_windows.keys()) + 1
            self._create_child_window(index)

    def _create_all_child_windows(self):
        """Open all child windows at once."""
        for index in system_info.screens():
            if index == self.screen_idx:
                continue
            self._create_child_window(index)

    def _create_child_window(self, index: int):
        """Open a child window for the specified screen."""
        self.all_windows[index] = BaseWindow(
            screen_idx=index,
            parent=self,
            color=str(self.settings.value("color")),
        )
        # self.all_windows[index].show()

    def _hide_windows(self):
        """Hide all windows of normcap."""
        logger.debug("Hide %s window(s)", len(self.all_windows))
        utils.set_cursor(None)
        for window in self.all_windows.values():
            window.hide()

    def _show_windows(self):
        """Make hidden windows visible again."""
        try:
            # Give the menu some time to close before taking screenshot
            time.sleep(0.05)
            self._update_screenshots()
        except AssertionError:
            logger.debug("Abort showing windows.")
            return

        for window in self.all_windows.values():
            window.showFullScreen()

    def _quit_or_hide(self, reason: str):
        if self.settings.value("tray", type=bool):
            self._hide_windows()
        else:
            self._quit_application(reason)

    def _quit_application(self, reason: str):
        self.main_window.tray.hide()
        QtWidgets.QApplication.processEvents()
        time.sleep(0.05)
        logger.debug("Path to debug images: %s%snormcap", tempfile.gettempdir(), os.sep)
        logger.info("Exit normcap (reason: %s)", reason)
        QtWidgets.QApplication.quit()

    def _show_or_hide_tray_icon(self):
        if self.settings.value("tray", type=bool):
            logger.debug("Show tray icon")
            self.main_window.tray.show()
        else:
            logger.debug("Hide tray icon")
            self.main_window.tray.hide()

    def _notify_or_close(self):
        if self.settings.value("notification", type=bool):
            self.com.on_send_notification.emit(self.capture)
        else:
            self.com.on_quit_or_hide.emit("detection completed")

    def resizeEvent(self, event: QtGui.QResizeEvent) -> None:
        """Reposition settings menu on resize."""
        if hasattr(self, "settings_menu"):
            self.settings_menu.move(self.width() - self.settings_menu.width() - 26, 26)
        return super().resizeEvent(event)

    #########################
    # Helper                #
    #########################

    def _open_url_and_hide(self, url):
        """Open url in default browser, then hide to tray or exit."""
        logger.debug("Open %s", url)
        QtGui.QDesktopServices.openUrl(url)
        self.com.on_quit_or_hide.emit("opened web browser")

    def _copy_to_clipboard(self):
        """Copy results to clipboard."""
        # Signal is only temporarily connected to avoid being triggered
        # on arbitrary clipboard changes
        self.clipboard.dataChanged.connect(self.com.on_copied_to_clipboard.emit)
        self.clipboard.dataChanged.connect(self.clipboard.dataChanged.disconnect)

        copy = utils.copy_to_clipboard()
        copy(self.capture.ocr_text)
        QtWidgets.QApplication.processEvents()

    #########################
    # Settings              #
    #########################

    def _update_setting(self, data):
        name, value = data
        self.settings.setValue(name, value)

        if name == "tray":
            self._show_or_hide_tray_icon()
        elif name == "mode":
            self.capture.mode = (
                CaptureMode.PARSE if value == "parse" else CaptureMode.RAW
            )

        logger.debug(
            "Settings:\n%s",
            [(k, self.settings.value(k)) for k in self.settings.allKeys()],
        )

    #####################
    # OCR Functionality #
    #####################

    def _crop_image(self, grab_info: tuple[Rect, int]):
        """Crop image to selected region."""
        logger.info("Crop image to selected region %s", grab_info[0].points)
        rect, screen_idx = grab_info

        screenshot = self.screens[screen_idx].screenshot
        if not screenshot:
            raise TypeError("Screenshot is None!")

        self.capture.rect = rect
        self.capture.screen = self.screens[screen_idx]
        self.capture.image = screenshot.copy(QtCore.QRect(*rect.geometry))

        utils.save_image_in_tempfolder(self.capture.image, postfix="_cropped")

        self.com.on_image_cropped.emit()

    @staticmethod
    def _qimage_to_pil_image(image: QtGui.QImage):
        """Cast QImage to pillow Image type."""
        ba = QtCore.QByteArray()
        buffer = QtCore.QBuffer(ba)
        buffer.open(QtCore.QIODevice.ReadWrite)
        image.save(buffer, "PNG")  # type:ignore
        return Image.open(io.BytesIO(buffer.data()))

    def _capture_to_ocr(self):
        """Perform content recognition on grabed image."""
        if self.capture.image_area < 25:
            logger.warning("Area of %s too small. Skip OCR", self.capture.image_area)
            self.com.on_quit_or_hide.emit("selection too small")
            return

        logger.debug("Start OCR")
        ocr_result = ocr.recognize(
            languages=self.settings.value("language"),
            image=self._qimage_to_pil_image(self.capture.image),
            tessdata_path=system_info.get_tessdata_path(),
            parse=self.capture.mode is CaptureMode.PARSE,
            resize_factor=3.2,
            padding_size=80,
        )
        utils.save_image_in_tempfolder(ocr_result.image, postfix="_enhanced")

        self.capture.ocr_text = ocr_result.text
        self.capture.ocr_applied_magic = ocr_result.best_scored_magic

        logger.info("Text from OCR:\n%s", self.capture.ocr_text)
        self.com.on_ocr_performed.emit()

1	"""Normcap main window."""
2
3	import io	2✔
4	import logging	2✔
5	import os	2✔
6	import sys	2✔
7	import tempfile	2✔
8	import time	2✔
9
10	from PIL import Image	2✔
11	from PySide6 import QtCore, QtGui, QtWidgets	2✔
12
13	from normcap import ocr	2✔
14	from normcap.gui import system_info, utils	2✔
15	from normcap.gui.base_window import BaseWindow	2✔
16	from normcap.gui.models import Capture, CaptureMode, DesktopEnvironment, Rect, Screen	2✔
17	from normcap.gui.notifier import Notifier	2✔
18	from normcap.gui.settings import init_settings	2✔
19	from normcap.gui.settings_menu import SettingsMenu	2✔
20	from normcap.gui.system_tray import SystemTray	2✔
21	from normcap.gui.update_check import UpdateChecker	2✔
22	from normcap.screengrab import grab_screens	2✔
23
24	logger = logging.getLogger(__name__)	2✔
25
26
27	class Communicate(QtCore.QObject):	2✔
28	"""Applications' communication bus."""
29
30	on_region_selected = QtCore.Signal(Rect)	2✔
31	on_image_cropped = QtCore.Signal()	2✔
32	on_ocr_performed = QtCore.Signal()	2✔
33	on_copied_to_clipboard = QtCore.Signal()	2✔
34	on_send_notification = QtCore.Signal(Capture)	2✔
35	on_window_positioned = QtCore.Signal()	2✔
36	on_minimize_windows = QtCore.Signal()	2✔
37	on_set_cursor_wait = QtCore.Signal()	2✔
38	on_quit_or_hide = QtCore.Signal(str)	2✔
39	on_update_available = QtCore.Signal(str)	2✔
40	on_open_url_and_hide = QtCore.Signal(str)	2✔
41
42
43	class MainWindow(BaseWindow):	2✔
44	"""Main (parent) window."""
45
46	tray: SystemTray	2✔
47	settings_menu: SettingsMenu	2✔
48	update_checker: UpdateChecker	2✔
49	com = Communicate()	2✔
50	capture = Capture()	2✔
51
52	def __init__(self, args):	2✔
53	"""Initialize main application window."""
54	self.settings = init_settings(	2✔
55	"normcap",
56	"settings",
57	initial=args,
58	reset=args.get("reset", False),
59	)
60	self.capture.mode = (	2✔
61	CaptureMode.PARSE
62	if self.settings.value("mode") == "parse"
63	else CaptureMode.RAW
64	)
65	self.screens: dict[int, Screen] = system_info.screens()	2✔
66	try:	2✔
67	self._update_screenshots()	2✔
68	except AssertionError:	×
69	logger.warning("Screenshots not available. Exiting NormCap.")	×
70	sys.exit(1)	×
71
72	super().__init__(	2✔
73	screen_idx=0,
74	parent=None,
75	color=str(self.settings.value("color")),
76	)
77
78	self.clipboard = QtWidgets.QApplication.clipboard()	2✔
79
80	self._set_signals()	2✔
81	self._add_tray()	2✔
82	self._add_settings_menu()	2✔
83	self._add_update_checker()	2✔
84	self._add_notifier()	2✔
85
86	self.all_windows: dict[int, BaseWindow] = {0: self}	2✔
87	if len(self.screens) > 1:	2✔
88	self._init_child_windows()	×
89
90	def _update_screenshots(self):	2✔
91	for idx, screenshot in enumerate(grab_screens()):	2✔
92	utils.save_image_in_tempfolder(screenshot, postfix=f"_raw_screen{idx}")	2✔
93	self.screens[idx].screenshot = screenshot	2✔
94
95	def _add_settings_menu(self):	2✔
96	self.settings_menu = SettingsMenu(self)	2✔
97	self.settings_menu.com.on_setting_changed.connect(self._update_setting)	2✔
98	self.settings_menu.com.on_open_url.connect(self.com.on_open_url_and_hide)	2✔
99	self.settings_menu.com.on_quit_or_hide.connect(	2✔
100	lambda: self.com.on_quit_or_hide.emit("clicked close in menu")
101	)
102	self.settings_menu.move(self.width() - self.settings_menu.width() - 26, 26)	2✔
103	self.settings_menu.show()	2✔
104
105	def _add_tray(self):	2✔
106	self.tray = SystemTray(self)	2✔
107	self.tray.com.on_capture.connect(self._show_windows)	2✔
108	self.tray.com.on_quit.connect(	2✔
109	lambda: self._quit_application("clicked exit in tray")
110	)
111	if self.settings.value("tray", type=bool):	2✔
112	self.tray.show()	×
113
114	def _add_update_checker(self):	2✔
115	if self.settings.value("update", type=bool):	2✔
116	checker = UpdateChecker(self, packaged=system_info.is_briefcase_package())	×
117	checker.com.on_version_retrieved.connect(checker.show_update_message)	×
118	checker.com.on_click_get_new_version.connect(self.com.on_open_url_and_hide)	×
119	QtCore.QTimer.singleShot(500, checker.check)	×
120
121	def _add_notifier(self):	2✔
122	self.notifier = Notifier(self)	2✔
123	self.com.on_send_notification.connect(self.notifier.send_notification)	2✔
124	self.notifier.com.on_notification_sent.connect(	2✔
125	lambda: self.com.on_quit_or_hide.emit("notification sent")
126	)
127
128	def _set_signals(self):	2✔
129	"""Set up signals to trigger program logic."""
130	self.com.on_region_selected.connect(self._crop_image)	2✔
131	self.com.on_image_cropped.connect(self._capture_to_ocr)	2✔
132	self.com.on_ocr_performed.connect(self._copy_to_clipboard)	2✔
133	self.com.on_copied_to_clipboard.connect(self._notify_or_close)	2✔
134
135	self.com.on_minimize_windows.connect(self._hide_windows)	2✔
136	self.com.on_set_cursor_wait.connect(	2✔
137	lambda: utils.set_cursor(QtCore.Qt.WaitCursor)
138	)
139	self.com.on_quit_or_hide.connect(self._quit_or_hide)	2✔
140	self.com.on_open_url_and_hide.connect(self._open_url_and_hide)	2✔
141
142	###################
143	# UI Manipulation #
144	###################
145
146	def _init_child_windows(self):	2✔
147	"""Initialize child windows with method depending on system."""
148	if not system_info.display_manager_is_wayland():	×
149	self._create_all_child_windows()	×
150	elif system_info.desktop_environment() in [	×
151	DesktopEnvironment.GNOME,
152	DesktopEnvironment.KDE,
153	]:
154	self.com.on_window_positioned.connect(self._create_next_child_window)	×
155
156	def _create_next_child_window(self):	2✔
157	"""Open child window only for next display."""
158	if len(system_info.screens()) > len(self.all_windows):	×
159	index = max(self.all_windows.keys()) + 1	×
160	self._create_child_window(index)	×
161
162	def _create_all_child_windows(self):	2✔
163	"""Open all child windows at once."""
164	for index in system_info.screens():	×
165	if index == self.screen_idx:	×
166	continue	×
167	self._create_child_window(index)	×
168
169	def _create_child_window(self, index: int):	2✔
170	"""Open a child window for the specified screen."""
171	self.all_windows[index] = BaseWindow(	×
172	screen_idx=index,
173	parent=self,
174	color=str(self.settings.value("color")),
175	)
176	# self.all_windows[index].show()
177
178	def _hide_windows(self):	2✔
179	"""Hide all windows of normcap."""
180	logger.debug("Hide %s window(s)", len(self.all_windows))	2✔
181	utils.set_cursor(None)	2✔
182	for window in self.all_windows.values():	2✔
183	window.hide()	2✔
184
185	def _show_windows(self):	2✔
186	"""Make hidden windows visible again."""
187	try:	×
188	# Give the menu some time to close before taking screenshot
189	time.sleep(0.05)	×
190	self._update_screenshots()	×
191	except AssertionError:	×
192	logger.debug("Abort showing windows.")	×
193	return	×
194
195	for window in self.all_windows.values():	×
196	window.showFullScreen()	×
197
198	def _quit_or_hide(self, reason: str):	2✔
199	if self.settings.value("tray", type=bool):	2✔
200	self._hide_windows()	×
201	else:
202	self._quit_application(reason)	2✔
203
204	def _quit_application(self, reason: str):	2✔
205	self.main_window.tray.hide()	2✔
206	QtWidgets.QApplication.processEvents()	2✔
207	time.sleep(0.05)	2✔
208	logger.debug("Path to debug images: %s%snormcap", tempfile.gettempdir(), os.sep)	2✔
209	logger.info("Exit normcap (reason: %s)", reason)	2✔
210	QtWidgets.QApplication.quit()	2✔
211
212	def _show_or_hide_tray_icon(self):	2✔
213	if self.settings.value("tray", type=bool):	×
214	logger.debug("Show tray icon")	×
215	self.main_window.tray.show()	×
216	else:
217	logger.debug("Hide tray icon")	×
218	self.main_window.tray.hide()	×
219
220	def _notify_or_close(self):	2✔
221	if self.settings.value("notification", type=bool):	2✔
222	self.com.on_send_notification.emit(self.capture)	2✔
223	else:
224	self.com.on_quit_or_hide.emit("detection completed")	×
225
226	def resizeEvent(self, event: QtGui.QResizeEvent) -> None:	2✔
227	"""Reposition settings menu on resize."""
228	if hasattr(self, "settings_menu"):	2✔
229	self.settings_menu.move(self.width() - self.settings_menu.width() - 26, 26)	×
230	return super().resizeEvent(event)	2✔
231
232	#########################
233	# Helper #
234	#########################
235
236	def _open_url_and_hide(self, url):	2✔
237	"""Open url in default browser, then hide to tray or exit."""
238	logger.debug("Open %s", url)	×
239	QtGui.QDesktopServices.openUrl(url)	×
240	self.com.on_quit_or_hide.emit("opened web browser")	×
241
242	def _copy_to_clipboard(self):	2✔
243	"""Copy results to clipboard."""
244	# Signal is only temporarily connected to avoid being triggered
245	# on arbitrary clipboard changes
246	self.clipboard.dataChanged.connect(self.com.on_copied_to_clipboard.emit)	2✔
247	self.clipboard.dataChanged.connect(self.clipboard.dataChanged.disconnect)	2✔
248
249	copy = utils.copy_to_clipboard()	2✔
250	copy(self.capture.ocr_text)	2✔
251	QtWidgets.QApplication.processEvents()	2✔
252
253	#########################
254	# Settings #
255	#########################
256
257	def _update_setting(self, data):	2✔
258	name, value = data	×
259	self.settings.setValue(name, value)	×
260
261	if name == "tray":	×
262	self._show_or_hide_tray_icon()	×
263	elif name == "mode":	×
264	self.capture.mode = (	×
265	CaptureMode.PARSE if value == "parse" else CaptureMode.RAW
266	)
267
268	logger.debug(	×
269	"Settings:\n%s",
270	[(k, self.settings.value(k)) for k in self.settings.allKeys()],
271	)
272
273	#####################
274	# OCR Functionality #
275	#####################
276
277	def _crop_image(self, grab_info: tuple[Rect, int]):	2✔
278	"""Crop image to selected region."""
279	logger.info("Crop image to selected region %s", grab_info[0].points)	2✔
280	rect, screen_idx = grab_info	2✔
281
282	screenshot = self.screens[screen_idx].screenshot	2✔
283	if not screenshot:	2✔
284	raise TypeError("Screenshot is None!")	×
285
286	self.capture.rect = rect	2✔
287	self.capture.screen = self.screens[screen_idx]	2✔
288	self.capture.image = screenshot.copy(QtCore.QRect(*rect.geometry))	2✔
289
290	utils.save_image_in_tempfolder(self.capture.image, postfix="_cropped")	2✔
291
292	self.com.on_image_cropped.emit()	2✔
293
294	@staticmethod	2✔
295	def _qimage_to_pil_image(image: QtGui.QImage):	2✔
296	"""Cast QImage to pillow Image type."""
297	ba = QtCore.QByteArray()	2✔
298	buffer = QtCore.QBuffer(ba)	2✔
299	buffer.open(QtCore.QIODevice.ReadWrite)	2✔
300	image.save(buffer, "PNG") # type:ignore	2✔
301	return Image.open(io.BytesIO(buffer.data()))	2✔
302
303	def _capture_to_ocr(self):	2✔
304	"""Perform content recognition on grabed image."""
305	if self.capture.image_area < 25:	2✔
306	logger.warning("Area of %s too small. Skip OCR", self.capture.image_area)	×
307	self.com.on_quit_or_hide.emit("selection too small")	×
308	return	×
309
310	logger.debug("Start OCR")	2✔
311	ocr_result = ocr.recognize(	2✔
312	languages=self.settings.value("language"),
313	image=self._qimage_to_pil_image(self.capture.image),
314	tessdata_path=system_info.get_tessdata_path(),
315	parse=self.capture.mode is CaptureMode.PARSE,
316	resize_factor=3.2,
317	padding_size=80,
318	)
319	utils.save_image_in_tempfolder(ocr_result.image, postfix="_enhanced")	2✔
320
321	self.capture.ocr_text = ocr_result.text	2✔
322	self.capture.ocr_applied_magic = ocr_result.best_scored_magic	2✔
323
324	logger.info("Text from OCR:\n%s", self.capture.ocr_text)	2✔
325	self.com.on_ocr_performed.emit()	2✔

dynobo / normcap / 1911874936

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous