labelimgplusplus 2.0.0__py3-none-any.whl

labelImg.py

@@ -0,0 +1,2486 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import argparse
+import codecs
+import os.path
+import platform
+import shutil
+import sys
+import webbrowser as wb
+from functools import partial
+
+try:
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+    from PyQt5.QtWidgets import *
+except ImportError:
+    # needed for py3+qt4
+    # Ref:
+    # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
+    # http://stackoverflow.com/questions/21217399/pyqt4-qtcore-qvariant-object-instead-of-a-string
+    if sys.version_info.major >= 3:
+        import sip
+        sip.setapi('QVariant', 2)
+    from PyQt4.QtGui import *
+    from PyQt4.QtCore import *
+
+from libs.combobox import ComboBox
+from libs.default_label_combobox import DefaultLabelComboBox
+from libs.resources import *
+from libs.constants import *
+from libs.utils import *
+from libs.settings import Settings
+from libs.shape import Shape, DEFAULT_LINE_COLOR, DEFAULT_FILL_COLOR
+from libs.stringBundle import StringBundle
+from libs.canvas import Canvas
+from libs.zoomWidget import ZoomWidget
+from libs.lightWidget import LightWidget
+from libs.labelDialog import LabelDialog
+from libs.colorDialog import ColorDialog
+from libs.labelFile import LabelFile, LabelFileError, LabelFileFormat
+from libs.toolBar import ToolBar, DropdownToolButton
+from libs.styles import TOOLBAR_STYLE, get_combined_style
+from libs.pascal_voc_io import PascalVocReader
+from libs.pascal_voc_io import XML_EXT
+from libs.yolo_io import YoloReader
+from libs.yolo_io import TXT_EXT
+from libs.create_ml_io import CreateMLReader
+from libs.create_ml_io import JSON_EXT
+from libs.ustr import ustr
+from libs.hashableQListWidgetItem import HashableQListWidgetItem
+from libs.galleryWidget import GalleryWidget, AnnotationStatus
+from libs.commands import UndoStack, CreateShapeCommand, DeleteShapeCommand, MoveShapeCommand, EditLabelCommand
+
+__appname__ = 'labelImg'
+
+
+class WindowMixin(object):
+
+    def menu(self, title, actions=None):
+        menu = self.menuBar().addMenu(title)
+        if actions:
+            add_actions(menu, actions)
+        return menu
+
+    def toolbar(self, title, actions=None):
+        toolbar = ToolBar(title)
+        toolbar.setObjectName(u'%sToolBar' % title)
+        # toolbar.setOrientation(Qt.Vertical)
+        toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
+        if actions:
+            add_actions(toolbar, actions)
+        self.addToolBar(Qt.LeftToolBarArea, toolbar)
+        return toolbar
+
+
+class MainWindow(QMainWindow, WindowMixin):
+    FIT_WINDOW, FIT_WIDTH, MANUAL_ZOOM = list(range(3))
+
+    def __init__(self, default_filename=None, default_prefdef_class_file=None, default_save_dir=None):
+        super(MainWindow, self).__init__()
+        self.setWindowTitle(__appname__)
+
+        # Load setting in the main thread
+        self.settings = Settings()
+        self.settings.load()
+        settings = self.settings
+
+        self.os_name = platform.system()
+
+        # Load string bundle for i18n
+        self.string_bundle = StringBundle.get_bundle()
+        get_str = lambda str_id: self.string_bundle.get_string(str_id)
+
+        # Save as Pascal voc xml
+        self.default_save_dir = default_save_dir
+        self.label_file_format = settings.get(SETTING_LABEL_FILE_FORMAT, LabelFileFormat.PASCAL_VOC)
+
+        # For loading all image under a directory
+        self.m_img_list = []
+        self._path_to_idx = {}  # O(1) lookup: path -> index
+        self._annotation_status_cache = {}  # Cache: path -> status (reduces I/O)
+
+        # Memory optimization for large images (Issue #31)
+        self._image_scale_factor = 1.0  # Display size / Original size
+        self._original_image_size = None  # QSize of original image
+
+        self.dir_name = None
+        self.label_hist = []
+        self.last_open_dir = None
+        self.cur_img_idx = 0
+        self.img_count = len(self.m_img_list)
+
+        # Whether we need to save or not.
+        self.dirty = False
+
+        # Clipboard for copy/paste annotations across images
+        self.clipboard_shapes = []
+
+        self._no_selection_slot = False
+        self._beginner = True
+        self.gallery_mode_enabled = False
+        self._normal_central_widget = None
+        self.screencast = "https://youtu.be/p0nR2YsCY_U"
+
+        # Load predefined classes to the list
+        self.load_predefined_classes(default_prefdef_class_file)
+
+        if self.label_hist:
+            self.default_label = self.label_hist[0]
+        else:
+            print("Not find:/data/predefined_classes.txt (optional)")
+
+        # Main widgets and related state.
+        self.label_dialog = LabelDialog(parent=self, list_item=self.label_hist)
+
+        self.items_to_shapes = {}
+        self.shapes_to_items = {}
+        self.prev_label_text = ''
+
+        list_layout = QVBoxLayout()
+        list_layout.setContentsMargins(0, 0, 0, 0)
+
+        # Create a widget for using default label
+        self.use_default_label_checkbox = QCheckBox(get_str('useDefaultLabel'))
+        self.use_default_label_checkbox.setChecked(False)
+        self.default_label_combo_box = DefaultLabelComboBox(self,items=self.label_hist)
+
+        use_default_label_qhbox_layout = QHBoxLayout()
+        use_default_label_qhbox_layout.addWidget(self.use_default_label_checkbox)
+        use_default_label_qhbox_layout.addWidget(self.default_label_combo_box)
+        use_default_label_container = QWidget()
+        use_default_label_container.setLayout(use_default_label_qhbox_layout)
+
+        # Create a widget for edit and diffc button
+        self.diffc_button = QCheckBox(get_str('useDifficult'))
+        self.diffc_button.setChecked(False)
+        self.diffc_button.stateChanged.connect(self.button_state)
+        self.edit_button = QToolButton()
+        self.edit_button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
+
+        # Add some of widgets to list_layout
+        list_layout.addWidget(self.edit_button)
+        list_layout.addWidget(self.diffc_button)
+        list_layout.addWidget(use_default_label_container)
+
+        # Create and add combobox for showing unique labels in group
+        self.combo_box = ComboBox(self)
+        list_layout.addWidget(self.combo_box)
+
+        # Create and add a widget for showing current label items
+        self.label_list = QListWidget()
+        label_list_container = QWidget()
+        label_list_container.setLayout(list_layout)
+        self.label_list.itemActivated.connect(self.label_selection_changed)
+        self.label_list.itemSelectionChanged.connect(self.label_selection_changed)
+        self.label_list.itemDoubleClicked.connect(self.edit_label)
+        # Connect to itemChanged to detect checkbox changes.
+        self.label_list.itemChanged.connect(self.label_item_changed)
+        list_layout.addWidget(self.label_list)
+
+
+
+        self.dock = QDockWidget(get_str('boxLabelText'), self)
+        self.dock.setObjectName(get_str('labels'))
+        self.dock.setWidget(label_list_container)
+
+        # File list widget (existing list view)
+        self.file_list_widget = QListWidget()
+        self.file_list_widget.itemDoubleClicked.connect(self.file_item_double_clicked)
+        self.file_list_widget.itemClicked.connect(self.file_item_clicked)
+
+        # Gallery widget (new thumbnail view)
+        self.gallery_widget = GalleryWidget()
+        self.gallery_widget.image_selected.connect(self.gallery_image_selected)
+        self.gallery_widget.image_activated.connect(self.gallery_image_activated)
+
+        # Tab widget to hold both views
+        self.file_view_tabs = QTabWidget()
+        self.file_view_tabs.addTab(self.file_list_widget, get_str('listView'))
+        self.file_view_tabs.addTab(self.gallery_widget, get_str('galleryView'))
+        self.file_view_tabs.currentChanged.connect(self.on_file_view_tab_changed)
+
+        file_list_layout = QVBoxLayout()
+        file_list_layout.setContentsMargins(0, 0, 0, 0)
+        file_list_layout.addWidget(self.file_view_tabs)
+        file_list_container = QWidget()
+        file_list_container.setLayout(file_list_layout)
+        self.file_dock = QDockWidget(get_str('fileList'), self)
+        self.file_dock.setObjectName(get_str('files'))
+        self.file_dock.setWidget(file_list_container)
+
+        self.zoom_widget = ZoomWidget()
+        self.light_widget = LightWidget(get_str('lightWidgetTitle'))
+        self.color_dialog = ColorDialog(parent=self)
+
+        self.canvas = Canvas(parent=self)
+        self.canvas.zoomRequest.connect(self.zoom_request)
+        self.canvas.lightRequest.connect(self.light_request)
+        self.canvas.set_drawing_shape_to_square(settings.get(SETTING_DRAW_SQUARE, False))
+
+        scroll = QScrollArea()
+        scroll.setWidget(self.canvas)
+        scroll.setWidgetResizable(True)
+        self.scroll_bars = {
+            Qt.Vertical: scroll.verticalScrollBar(),
+            Qt.Horizontal: scroll.horizontalScrollBar()
+        }
+        self.scroll_area = scroll
+        self.canvas.scrollRequest.connect(self.scroll_request)
+
+        self.canvas.newShape.connect(self.new_shape)
+        self.canvas.shapeMoved.connect(self.set_dirty)
+        self.canvas.selectionChanged.connect(self.shape_selection_changed)
+        self.canvas.drawingPolygon.connect(self.toggle_drawing_sensitive)
+
+        # Initialize undo/redo system
+        self.undo_stack = UndoStack(max_size=50)
+        self.undo_stack.add_callback(self.update_undo_redo_actions)
+
+        self.setCentralWidget(scroll)
+        self.addDockWidget(Qt.RightDockWidgetArea, self.dock)
+        self.addDockWidget(Qt.RightDockWidgetArea, self.file_dock)
+        self.file_dock.setFeatures(QDockWidget.DockWidgetFloatable)
+
+        self.dock_features = QDockWidget.DockWidgetClosable | QDockWidget.DockWidgetFloatable
+        self.dock.setFeatures(self.dock.features() ^ self.dock_features)
+
+        # Actions
+        action = partial(new_action, self)
+        quit = action(get_str('quit'), self.close,
+                      'Ctrl+Q', 'quit', get_str('quitApp'))
+
+        open = action(get_str('openFile'), self.open_file,
+                      'Ctrl+O', 'open', get_str('openFileDetail'))
+
+        open_dir = action(get_str('openDir'), self.open_dir_dialog,
+                          'Ctrl+u', 'open', get_str('openDir'))
+
+        change_save_dir = action(get_str('changeSaveDir'), self.change_save_dir_dialog,
+                                 'Ctrl+r', 'open', get_str('changeSavedAnnotationDir'))
+
+        open_annotation = action(get_str('openAnnotation'), self.open_annotation_dialog,
+                                 'Ctrl+Shift+O', 'open', get_str('openAnnotationDetail'))
+        copy_prev_bounding = action(get_str('copyPrevBounding'), self.copy_previous_bounding_boxes, 'Ctrl+Shift+V', 'copy', get_str('copyPrevBounding'))
+
+        open_next_image = action(get_str('nextImg'), self.open_next_image,
+                                 'd', 'next', get_str('nextImgDetail'))
+
+        open_prev_image = action(get_str('prevImg'), self.open_prev_image,
+                                 'a', 'prev', get_str('prevImgDetail'))
+
+        verify = action(get_str('verifyImg'), self.verify_image,
+                        'space', 'verify', get_str('verifyImgDetail'))
+
+        save = action(get_str('save'), self.save_file,
+                      'Ctrl+S', 'save', get_str('saveDetail'), enabled=False)
+
+        def get_format_meta(format):
+            """
+            returns a tuple containing (title, icon_name) of the selected format
+            """
+            if format == LabelFileFormat.PASCAL_VOC:
+                return '&PascalVOC', 'format_voc'
+            elif format == LabelFileFormat.YOLO:
+                return '&YOLO', 'format_yolo'
+            elif format == LabelFileFormat.CREATE_ML:
+                return '&CreateML', 'format_createml'
+
+        save_format = action(get_format_meta(self.label_file_format)[0],
+                             self.change_format, 'Ctrl+Y',
+                             get_format_meta(self.label_file_format)[1],
+                             get_str('changeSaveFormat'), enabled=True)
+
+        save_as = action(get_str('saveAs'), self.save_file_as,
+                         'Ctrl+Shift+S', 'save-as', get_str('saveAsDetail'), enabled=False)
+
+        close = action(get_str('closeCur'), self.close_file, 'Ctrl+W', 'close', get_str('closeCurDetail'))
+
+        delete_image = action(get_str('deleteImg'), self.delete_image, 'Ctrl+Shift+D', 'close', get_str('deleteImgDetail'))
+
+        reset_all = action(get_str('resetAll'), self.reset_all, None, 'resetall', get_str('resetAllDetail'))
+
+        color1 = action(get_str('boxLineColor'), self.choose_color1,
+                        'Ctrl+L', 'color_line', get_str('boxLineColorDetail'))
+
+        create_mode = action(get_str('crtBox'), self.set_create_mode,
+                             'w', 'new', get_str('crtBoxDetail'), enabled=False)
+        edit_mode = action(get_str('editBox'), self.set_edit_mode,
+                           'Ctrl+J', 'edit', get_str('editBoxDetail'), enabled=False)
+
+        create = action(get_str('crtBox'), self.create_shape,
+                        'w', 'new', get_str('crtBoxDetail'), enabled=False)
+        delete = action(get_str('delBox'), self.delete_selected_shape,
+                        'Delete', 'delete', get_str('delBoxDetail'), enabled=False)
+        copy = action(get_str('dupBox'), self.copy_selected_shape,
+                      'Ctrl+D', 'copy', get_str('dupBoxDetail'),
+                      enabled=False)
+
+        copy_to_clipboard = action(get_str('copyBox'), self.copy_to_clipboard,
+                                   'Ctrl+C', 'copy', get_str('copyBoxDetail'),
+                                   enabled=False)
+        paste_from_clipboard = action(get_str('pasteBox'), self.paste_from_clipboard,
+                                      'Ctrl+V', 'paste', get_str('pasteBoxDetail'),
+                                      enabled=False)
+        copy_all_to_clipboard = action(get_str('copyAllBoxes'), self.copy_all_to_clipboard,
+                                       'Ctrl+Shift+C', 'copy', get_str('copyAllBoxesDetail'),
+                                       enabled=False)
+
+        undo = action(get_str('undo'), self.undo_action,
+                      'Ctrl+Z', 'undo', get_str('undoDetail'), enabled=False)
+        redo = action(get_str('redo'), self.redo_action,
+                      'Ctrl+Shift+Z', 'redo', get_str('redoDetail'), enabled=False)
+
+        advanced_mode = action(get_str('advancedMode'), self.toggle_advanced_mode,
+                               'Ctrl+Shift+A', 'expert', get_str('advancedModeDetail'),
+                               checkable=True)
+
+        gallery_mode = action(get_str('galleryMode'), self.toggle_gallery_mode,
+                              'Ctrl+G', 'labels', get_str('galleryModeDetail'),
+                              checkable=True)
+
+        hide_all = action(get_str('hideAllBox'), partial(self.toggle_polygons, False),
+                          'Ctrl+H', 'hide', get_str('hideAllBoxDetail'),
+                          enabled=False)
+        show_all = action(get_str('showAllBox'), partial(self.toggle_polygons, True),
+                          'Ctrl+A', 'hide', get_str('showAllBoxDetail'),
+                          enabled=False)
+
+        help_default = action(get_str('tutorialDefault'), self.show_default_tutorial_dialog, None, 'help', get_str('tutorialDetail'))
+        show_info = action(get_str('info'), self.show_info_dialog, None, 'help', get_str('info'))
+        show_shortcut = action(get_str('shortcut'), self.show_shortcuts_dialog, None, 'help', get_str('shortcut'))
+
+        zoom = QWidgetAction(self)
+        zoom.setDefaultWidget(self.zoom_widget)
+        self.zoom_widget.setWhatsThis(
+            u"Zoom in or out of the image. Also accessible with"
+            " %s and %s from the canvas." % (format_shortcut("Ctrl+[-+]"),
+                                             format_shortcut("Ctrl+Wheel")))
+        self.zoom_widget.setEnabled(False)
+
+        zoom_in = action(get_str('zoomin'), partial(self.add_zoom, 10),
+                         'Ctrl++', 'zoom-in', get_str('zoominDetail'), enabled=False)
+        zoom_out = action(get_str('zoomout'), partial(self.add_zoom, -10),
+                          'Ctrl+-', 'zoom-out', get_str('zoomoutDetail'), enabled=False)
+        zoom_org = action(get_str('originalsize'), partial(self.set_zoom, 100),
+                          'Ctrl+=', 'zoom', get_str('originalsizeDetail'), enabled=False)
+        fit_window = action(get_str('fitWin'), self.set_fit_window,
+                            'Ctrl+F', 'fit-window', get_str('fitWinDetail'),
+                            checkable=True, enabled=False)
+        fit_width = action(get_str('fitWidth'), self.set_fit_width,
+                           'Ctrl+Shift+F', 'fit-width', get_str('fitWidthDetail'),
+                           checkable=True, enabled=False)
+        # Group zoom controls into a list for easier toggling.
+        zoom_actions = (self.zoom_widget, zoom_in, zoom_out,
+                        zoom_org, fit_window, fit_width)
+        self.zoom_mode = self.MANUAL_ZOOM
+        self.scalers = {
+            self.FIT_WINDOW: self.scale_fit_window,
+            self.FIT_WIDTH: self.scale_fit_width,
+            # Set to one to scale to 100% when loading files.
+            self.MANUAL_ZOOM: lambda: 1,
+        }
+
+        light = QWidgetAction(self)
+        light.setDefaultWidget(self.light_widget)
+        self.light_widget.setWhatsThis(
+            u"Brighten or darken current image. Also accessible with"
+            " %s and %s from the canvas." % (format_shortcut("Ctrl+Shift+[-+]"),
+                                             format_shortcut("Ctrl+Shift+Wheel")))
+        self.light_widget.setEnabled(False)
+
+        light_brighten = action(get_str('lightbrighten'), partial(self.add_light, 10),
+                                'Ctrl+Shift++', 'light_lighten', get_str('lightbrightenDetail'), enabled=False)
+        light_darken = action(get_str('lightdarken'), partial(self.add_light, -10),
+                              'Ctrl+Shift+-', 'light_darken', get_str('lightdarkenDetail'), enabled=False)
+        light_org = action(get_str('lightreset'), partial(self.set_light, 50),
+                           'Ctrl+Shift+=', 'light_reset', get_str('lightresetDetail'), checkable=True, enabled=False)
+        light_org.setChecked(True)
+
+        # Create brightness dropdown button for toolbar
+        brightness_dropdown = DropdownToolButton(
+            "Brightness",
+            new_icon('sun'),
+            [light_brighten, light_darken, None, light_org]
+        )
+
+        # Group light controls into a list for easier toggling.
+        light_actions = (self.light_widget, light_brighten,
+                         light_darken, light_org, brightness_dropdown)
+
+        edit = action(get_str('editLabel'), self.edit_label,
+                      'Ctrl+E', 'edit', get_str('editLabelDetail'),
+                      enabled=False)
+        self.edit_button.setDefaultAction(edit)
+
+        shape_line_color = action(get_str('shapeLineColor'), self.choose_shape_line_color,
+                                  icon='color_line', tip=get_str('shapeLineColorDetail'),
+                                  enabled=False)
+        shape_fill_color = action(get_str('shapeFillColor'), self.choose_shape_fill_color,
+                                  icon='color', tip=get_str('shapeFillColorDetail'),
+                                  enabled=False)
+
+        labels = self.dock.toggleViewAction()
+        labels.setText(get_str('showHide'))
+        labels.setShortcut('Ctrl+Shift+L')
+
+        # Label list context menu.
+        label_menu = QMenu()
+        add_actions(label_menu, (edit, delete))
+        self.label_list.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.label_list.customContextMenuRequested.connect(
+            self.pop_label_list_menu)
+
+        # Draw squares/rectangles
+        self.draw_squares_option = QAction(get_str('drawSquares'), self)
+        self.draw_squares_option.setShortcut('Ctrl+Shift+R')
+        self.draw_squares_option.setCheckable(True)
+        self.draw_squares_option.setChecked(settings.get(SETTING_DRAW_SQUARE, False))
+        self.draw_squares_option.triggered.connect(self.toggle_draw_square)
+
+        # Store actions for further handling.
+        self.actions = Struct(save=save, save_format=save_format, saveAs=save_as, open=open, close=close, resetAll=reset_all, deleteImg=delete_image,
+                              lineColor=color1, create=create, delete=delete, edit=edit, copy=copy,
+                              copyToClipboard=copy_to_clipboard, pasteFromClipboard=paste_from_clipboard,
+                              copyAllToClipboard=copy_all_to_clipboard,
+                              undo=undo, redo=redo,
+                              createMode=create_mode, editMode=edit_mode, advancedMode=advanced_mode, galleryMode=gallery_mode,
+                              shapeLineColor=shape_line_color, shapeFillColor=shape_fill_color,
+                              zoom=zoom, zoomIn=zoom_in, zoomOut=zoom_out, zoomOrg=zoom_org,
+                              fitWindow=fit_window, fitWidth=fit_width,
+                              zoomActions=zoom_actions,
+                              lightBrighten=light_brighten, lightDarken=light_darken, lightOrg=light_org,
+                              lightActions=light_actions,
+                              fileMenuActions=(
+                                  open, open_dir, save, save_as, close, reset_all, quit),
+                              beginner=(), advanced=(),
+                              editMenu=(undo, redo, None, edit, copy, copy_to_clipboard,
+                                        paste_from_clipboard, copy_all_to_clipboard, delete,
+                                        None, color1, self.draw_squares_option),
+                              beginnerContext=(create, edit, copy, copy_to_clipboard, paste_from_clipboard, delete),
+                              advancedContext=(create_mode, edit_mode, edit, copy, copy_to_clipboard,
+                                               paste_from_clipboard, delete, shape_line_color, shape_fill_color),
+                              onLoadActive=(
+                                  close, create, create_mode, edit_mode),
+                              onShapesPresent=(save_as, hide_all, show_all))
+
+        self.menus = Struct(
+            file=self.menu(get_str('menu_file')),
+            edit=self.menu(get_str('menu_edit')),
+            view=self.menu(get_str('menu_view')),
+            help=self.menu(get_str('menu_help')),
+            recentFiles=QMenu(get_str('menu_openRecent')),
+            labelList=label_menu)
+
+        # Auto saving : Enable auto saving if pressing next
+        self.auto_saving = QAction(get_str('autoSaveMode'), self)
+        self.auto_saving.setCheckable(True)
+        self.auto_saving.setChecked(settings.get(SETTING_AUTO_SAVE, False))
+        self.auto_saving.setToolTip(get_str('autoSaveModeDetail'))
+
+        # Auto-save timer (Issue #13)
+        self.auto_save_timer = QTimer(self)
+        self.auto_save_timer.timeout.connect(self._auto_save_triggered)
+
+        # Auto-save enabled toggle
+        self.auto_save_enabled = QAction(get_str('autoSaveEnabled'), self)
+        self.auto_save_enabled.setCheckable(True)
+        self.auto_save_enabled.setChecked(settings.get(SETTING_AUTO_SAVE_ENABLED, False))
+        self.auto_save_enabled.triggered.connect(self._toggle_auto_save_timer)
+        self.auto_save_enabled.setToolTip(get_str('autoSaveEnabledDetail'))
+
+        # Auto-save interval submenu
+        self.auto_save_interval_menu = QMenu(get_str('autoSaveInterval'), self)
+        self.auto_save_interval_group = QActionGroup(self)
+        self.auto_save_interval_group.setExclusive(True)
+        auto_save_intervals = [
+            (get_str('autoSave30s'), 30),
+            (get_str('autoSave1m'), 60),
+            (get_str('autoSave2m'), 120),
+            (get_str('autoSave5m'), 300),
+        ]
+        saved_interval = settings.get(SETTING_AUTO_SAVE_INTERVAL, 60)
+        for name, interval in auto_save_intervals:
+            interval_action = QAction(name, self)
+            interval_action.setCheckable(True)
+            interval_action.setData(interval)
+            interval_action.triggered.connect(self._set_auto_save_interval)
+            self.auto_save_interval_group.addAction(interval_action)
+            self.auto_save_interval_menu.addAction(interval_action)
+            if interval == saved_interval:
+                interval_action.setChecked(True)
+        # Default to 1 minute if nothing selected
+        if not any(a.isChecked() for a in self.auto_save_interval_group.actions()):
+            self.auto_save_interval_group.actions()[1].setChecked(True)  # 1 minute
+
+        # Sync single class mode from PR#106
+        self.single_class_mode = QAction(get_str('singleClsMode'), self)
+        self.single_class_mode.setShortcut("Ctrl+Shift+S")
+        self.single_class_mode.setCheckable(True)
+        self.single_class_mode.setChecked(settings.get(SETTING_SINGLE_CLASS, False))
+        self.lastLabel = None
+        # Add option to enable/disable labels being displayed at the top of bounding boxes
+        self.display_label_option = QAction(get_str('displayLabel'), self)
+        self.display_label_option.setShortcut("Ctrl+Shift+P")
+        self.display_label_option.setCheckable(True)
+        self.display_label_option.setChecked(settings.get(SETTING_PAINT_LABEL, False))
+        self.display_label_option.triggered.connect(self.toggle_paint_labels_option)
+
+        # Icon size submenu for toolbar
+        self.icon_size_menu = QMenu(get_str('iconSize'), self)
+        self.icon_size_group = QActionGroup(self)
+        self.icon_size_group.setExclusive(True)
+        icon_sizes = [
+            (get_str('iconSizeSmall'), 16),
+            (get_str('iconSizeMedium'), 22),
+            (get_str('iconSizeLarge'), 28),
+            (get_str('iconSizeXLarge'), 36),
+            (get_str('iconSizeAuto'), 0),  # 0 means auto-detect
+        ]
+        saved_icon_size = settings.get(SETTING_ICON_SIZE, 0)
+        for name, size in icon_sizes:
+            icon_action = QAction(name, self)
+            icon_action.setCheckable(True)
+            icon_action.setData(size)
+            icon_action.triggered.connect(self.change_icon_size)
+            self.icon_size_group.addAction(icon_action)
+            self.icon_size_menu.addAction(icon_action)
+            if size == saved_icon_size:
+                icon_action.setChecked(True)
+        # Default to auto if nothing selected
+        if not any(a.isChecked() for a in self.icon_size_group.actions()):
+            self.icon_size_group.actions()[-1].setChecked(True)
+
+        add_actions(self.menus.file,
+                    (open, open_dir, change_save_dir, open_annotation, copy_prev_bounding, self.menus.recentFiles, save, save_format, save_as, close, reset_all, delete_image, quit))
+        add_actions(self.menus.help, (help_default, show_info, show_shortcut))
+        add_actions(self.menus.view, (
+            self.auto_saving,
+            self.auto_save_enabled,
+            self.single_class_mode,
+            self.display_label_option,
+            labels, advanced_mode, gallery_mode, None,
+            hide_all, show_all, None,
+            zoom_in, zoom_out, zoom_org, None,
+            fit_window, fit_width, None,
+            light_brighten, light_darken, light_org, None))
+        self.menus.view.addMenu(self.auto_save_interval_menu)
+        self.menus.view.addMenu(self.icon_size_menu)
+
+        self.menus.file.aboutToShow.connect(self.update_file_menu)
+
+        # Custom context menu for the canvas widget:
+        add_actions(self.canvas.menus[0], self.actions.beginnerContext)
+        add_actions(self.canvas.menus[1], (
+            action('&Copy here', self.copy_shape),
+            action('&Move here', self.move_shape)))
+
+        self.tools = self.toolbar('Tools')
+        self.tools.setStyleSheet(TOOLBAR_STYLE)
+
+        # Apply saved icon size setting
+        saved_icon_size = settings.get(SETTING_ICON_SIZE, 0)
+        if saved_icon_size > 0:
+            self.tools.update_icon_size(saved_icon_size)
+
+        # Create dropdown for file/directory operations
+        file_dropdown = DropdownToolButton(
+            text=get_str('openFile'),
+            icon=new_icon('file'),
+            actions=[open, open_dir, change_save_dir]
+        )
+
+        self.actions.beginner = (
+            file_dropdown, gallery_mode, None, open_next_image, open_prev_image, verify, save, save_format, None, create, copy, delete, None,
+            zoom_in, zoom, zoom_out, fit_window, fit_width, None,
+            brightness_dropdown)
+
+        self.actions.advanced = (
+            file_dropdown, gallery_mode, None, open_next_image, open_prev_image, save, save_format, None,
+            create_mode, edit_mode, None,
+            hide_all, show_all)
+
+        self.statusBar().showMessage('%s started.' % __appname__)
+        self.statusBar().show()
+
+        # Application state.
+        self.image = QImage()
+        self.file_path = ustr(default_filename)
+        self.last_open_dir = None
+        self.recent_files = []
+        self.max_recent = 7
+        self.line_color = None
+        self.fill_color = None
+        self.zoom_level = 100
+        self.fit_window = False
+        # Add Chris
+        self.difficult = False
+
+        # Fix the compatible issue for qt4 and qt5. Convert the QStringList to python list
+        if settings.get(SETTING_RECENT_FILES):
+            if have_qstring():
+                recent_file_qstring_list = settings.get(SETTING_RECENT_FILES)
+                self.recent_files = [ustr(i) for i in recent_file_qstring_list]
+            else:
+                self.recent_files = recent_file_qstring_list = settings.get(SETTING_RECENT_FILES)
+
+        size = settings.get(SETTING_WIN_SIZE, QSize(600, 500))
+        position = QPoint(0, 0)
+        saved_position = settings.get(SETTING_WIN_POSE, position)
+        # Fix the multiple monitors issue
+        for i in range(QApplication.desktop().screenCount()):
+            if QApplication.desktop().availableGeometry(i).contains(saved_position):
+                position = saved_position
+                break
+        self.resize(size)
+        self.move(position)
+        save_dir = ustr(settings.get(SETTING_SAVE_DIR, None))
+        self.last_open_dir = ustr(settings.get(SETTING_LAST_OPEN_DIR, None))
+        if self.default_save_dir is None and save_dir is not None and os.path.exists(save_dir):
+            self.default_save_dir = save_dir
+            self.statusBar().showMessage('%s started. Annotation will be saved to %s' %
+                                         (__appname__, self.default_save_dir))
+            self.statusBar().show()
+
+        self.restoreState(settings.get(SETTING_WIN_STATE, QByteArray()))
+        Shape.line_color = self.line_color = QColor(settings.get(SETTING_LINE_COLOR, DEFAULT_LINE_COLOR))
+        Shape.fill_color = self.fill_color = QColor(settings.get(SETTING_FILL_COLOR, DEFAULT_FILL_COLOR))
+        self.canvas.set_drawing_color(self.line_color)
+        # Add chris
+        Shape.difficult = self.difficult
+
+        def xbool(x):
+            if isinstance(x, QVariant):
+                return x.toBool()
+            return bool(x)
+
+        if xbool(settings.get(SETTING_ADVANCE_MODE, False)):
+            self.actions.advancedMode.setChecked(True)
+            self.toggle_advanced_mode()
+
+        if xbool(settings.get(SETTING_GALLERY_MODE, False)):
+            self.actions.galleryMode.setChecked(True)
+            self.toggle_gallery_mode()
+
+        # Populate the File menu dynamically.
+        self.update_file_menu()
+
+        # Since loading the file may take some time, make sure it runs in the background.
+        if self.file_path and os.path.isdir(self.file_path):
+            self.queue_event(partial(self.import_dir_images, self.file_path or ""))
+        elif self.file_path:
+            self.queue_event(partial(self.load_file, self.file_path or ""))
+
+        # Callbacks:
+        self.zoom_widget.valueChanged.connect(self.paint_canvas)
+        self.zoom_widget.valueChanged.connect(self.update_zoom_display)
+        self.light_widget.valueChanged.connect(self.paint_canvas)
+
+        self.populate_mode_actions()
+
+        # Status bar permanent widgets (left to right)
+        # Image counter
+        self.label_image_count = QLabel('Image: 0 / 0')
+        self.label_image_count.setMinimumWidth(100)
+        self.statusBar().addPermanentWidget(self.label_image_count)
+
+        # Annotation count
+        self.label_box_count = QLabel('Boxes: 0')
+        self.label_box_count.setMinimumWidth(70)
+        self.statusBar().addPermanentWidget(self.label_box_count)
+
+        # Zoom level
+        self.label_zoom = QLabel('Zoom: 100%')
+        self.label_zoom.setMinimumWidth(80)
+        self.statusBar().addPermanentWidget(self.label_zoom)
+
+        # Save status indicator
+        self.label_save_status = QLabel('●')
+        self.label_save_status.setStyleSheet('color: green; font-size: 14px;')
+        self.label_save_status.setToolTip('Saved')
+        self.statusBar().addPermanentWidget(self.label_save_status)
+
+        # Display cursor coordinates at the right of status bar
+        self.label_coordinates = QLabel('')
+        self.statusBar().addPermanentWidget(self.label_coordinates)
+
+        # Open Dir if default file
+        if self.file_path and os.path.isdir(self.file_path):
+            self.open_dir_dialog(dir_path=self.file_path, silent=True)
+
+        # Start auto-save timer if enabled (Issue #13)
+        if self.auto_save_enabled.isChecked():
+            self._toggle_auto_save_timer()
+
+    def keyReleaseEvent(self, event):
+        if event.key() == Qt.Key_Control:
+            self.canvas.set_drawing_shape_to_square(False)
+
+    def keyPressEvent(self, event):
+        if event.key() == Qt.Key_Control:
+            # Draw rectangle if Ctrl is pressed
+            self.canvas.set_drawing_shape_to_square(True)
+
+    # Support Functions #
+    def set_format(self, save_format):
+        if save_format == FORMAT_PASCALVOC:
+            self.actions.save_format.setText(FORMAT_PASCALVOC)
+            self.actions.save_format.setIcon(new_icon("format_voc"))
+            self.label_file_format = LabelFileFormat.PASCAL_VOC
+            LabelFile.suffix = XML_EXT
+
+        elif save_format == FORMAT_YOLO:
+            self.actions.save_format.setText(FORMAT_YOLO)
+            self.actions.save_format.setIcon(new_icon("format_yolo"))
+            self.label_file_format = LabelFileFormat.YOLO
+            LabelFile.suffix = TXT_EXT
+
+        elif save_format == FORMAT_CREATEML:
+            self.actions.save_format.setText(FORMAT_CREATEML)
+            self.actions.save_format.setIcon(new_icon("format_createml"))
+            self.label_file_format = LabelFileFormat.CREATE_ML
+            LabelFile.suffix = JSON_EXT
+
+    def change_format(self):
+        # Determine the new format
+        if self.label_file_format == LabelFileFormat.PASCAL_VOC:
+            new_format = FORMAT_YOLO
+            warning = "Switching to YOLO format.\n\nNote: The 'difficult' flag will be lost."
+        elif self.label_file_format == LabelFileFormat.YOLO:
+            new_format = FORMAT_CREATEML
+            warning = "Switching to CreateML format."
+        elif self.label_file_format == LabelFileFormat.CREATE_ML:
+            new_format = FORMAT_PASCALVOC
+            warning = "Switching to PASCAL VOC format."
+        else:
+            raise ValueError('Unknown label file format.')
+
+        # Show confirmation dialog
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Warning)
+        msg.setWindowTitle("Change Annotation Format")
+        msg.setText(warning)
+        msg.setInformativeText("This will only affect new saves. Existing annotation files will not be converted.")
+        msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
+        msg.setDefaultButton(QMessageBox.Ok)
+
+        if msg.exec_() == QMessageBox.Ok:
+            self.set_format(new_format)
+            self.set_dirty()
+            self.status(f"Format changed to {new_format}")
+
+    def no_shapes(self):
+        return not self.items_to_shapes
+
+    def toggle_advanced_mode(self, value=True):
+        self._beginner = not value
+        self.canvas.set_editing(True)
+        self.populate_mode_actions()
+        self.edit_button.setVisible(not value)
+        if value:
+            self.actions.createMode.setEnabled(True)
+            self.actions.editMode.setEnabled(False)
+            self.dock.setFeatures(self.dock.features() | self.dock_features)
+        else:
+            self.dock.setFeatures(self.dock.features() ^ self.dock_features)
+
+    def toggle_gallery_mode(self, value=True):
+        """Toggle between normal view and full-screen gallery mode."""
+        # Guard against rapid toggling
+        if hasattr(self, '_toggling_gallery') and self._toggling_gallery:
+            return
+        self._toggling_gallery = True
+        try:
+            self.gallery_mode_enabled = value
+
+            if value:
+                # Cleanup any existing gallery first
+                if hasattr(self, 'full_gallery') and self.full_gallery:
+                    try:
+                        self.full_gallery.image_selected.disconnect()
+                        self.full_gallery.image_activated.disconnect()
+                    except TypeError:
+                        pass  # Already disconnected
+                    self.full_gallery = None
+                if hasattr(self, 'gallery_window') and self.gallery_window:
+                    self.gallery_window.close()
+                    self.gallery_window = None
+
+                # Create full-screen gallery as a regular window (not dialog)
+                self.gallery_window = QMainWindow(self)
+                self.gallery_window.setWindowTitle("Gallery Mode - Double-click to select, Press Escape or close to exit")
+
+                self.full_gallery = GalleryWidget(show_size_slider=True)
+                self.full_gallery.set_save_dir(self.default_save_dir)
+                self.full_gallery.set_image_list(self.m_img_list)
+                self.full_gallery.image_selected.connect(self.gallery_image_selected)
+                self.full_gallery.image_activated.connect(self._exit_gallery_and_load)
+                # Defer status refresh to allow gallery to display first
+                QTimer.singleShot(0, self._refresh_full_gallery_statuses)
+
+                # Select current image in full gallery
+                if self.file_path:
+                    self.full_gallery.select_image(self.file_path)
+
+                self.gallery_window.setCentralWidget(self.full_gallery)
+
+                # Show maximized
+                self.gallery_window.showMaximized()
+            else:
+                # Close gallery window
+                if hasattr(self, 'full_gallery') and self.full_gallery:
+                    try:
+                        self.full_gallery.image_selected.disconnect()
+                        self.full_gallery.image_activated.disconnect()
+                    except TypeError:
+                        pass
+                    self.full_gallery = None
+                if hasattr(self, 'gallery_window') and self.gallery_window:
+                    self.gallery_window.close()
+                    self.gallery_window = None
+        finally:
+            self._toggling_gallery = False
+
+    def _exit_gallery_and_load(self, image_path):
+        """Exit gallery mode and load the selected image."""
+        self.actions.galleryMode.setChecked(False)
+        self.toggle_gallery_mode(False)
+        self.gallery_image_activated(image_path)
+
+    def _refresh_full_gallery_statuses(self):
+        """Update statuses for full-screen gallery with batch processing."""
+        if not (hasattr(self, 'full_gallery') and self.full_gallery):
+            return
+
+        # Use cached statuses for instant update, collect uncached for batch processing
+        cached_statuses = {}
+        uncached = []
+        for img_path in self.m_img_list:
+            if img_path in self._annotation_status_cache:
+                cached_statuses[img_path] = self._annotation_status_cache[img_path]
+            else:
+                uncached.append(img_path)
+
+        # Apply cached statuses immediately
+        if cached_statuses:
+            self.full_gallery.update_all_statuses(cached_statuses)
+
+        # Process uncached images in batches to keep UI responsive
+        if uncached:
+            self._process_full_gallery_status_batch(uncached, 0)
+
+    def _process_full_gallery_status_batch(self, images, start_idx, batch_size=50):
+        """Process status updates in batches to avoid UI freeze."""
+        if not (hasattr(self, 'full_gallery') and self.full_gallery):
+            return  # Gallery was closed
+
+        statuses = {}
+        end_idx = min(start_idx + batch_size, len(images))
+        for img_path in images[start_idx:end_idx]:
+            statuses[img_path] = self._get_annotation_status(img_path)
+
+        self.full_gallery.update_all_statuses(statuses)
+
+        # Schedule next batch if more images remain
+        if end_idx < len(images):
+            QTimer.singleShot(0, lambda: self._process_full_gallery_status_batch(
+                images, end_idx, batch_size))
+
+    def populate_mode_actions(self):
+        if self.beginner():
+            tool, menu = self.actions.beginner, self.actions.beginnerContext
+        else:
+            tool, menu = self.actions.advanced, self.actions.advancedContext
+        self.tools.clear()
+        add_actions(self.tools, tool)
+        self.canvas.menus[0].clear()
+        add_actions(self.canvas.menus[0], menu)
+        self.menus.edit.clear()
+        actions = (self.actions.create,) if self.beginner()\
+            else (self.actions.createMode, self.actions.editMode)
+        add_actions(self.menus.edit, actions + self.actions.editMenu)
+
+    def set_beginner(self):
+        self.tools.clear()
+        add_actions(self.tools, self.actions.beginner)
+        self.tools.add_expand_button()
+        # Restore expanded state
+        if self.settings.get(SETTING_TOOLBAR_EXPANDED, False):
+            self.tools.set_expanded(True)
+
+    def set_advanced(self):
+        self.tools.clear()
+        add_actions(self.tools, self.actions.advanced)
+        self.tools.add_expand_button()
+        # Restore expanded state
+        if self.settings.get(SETTING_TOOLBAR_EXPANDED, False):
+            self.tools.set_expanded(True)
+
+    def set_dirty(self):
+        self.dirty = True
+        self.actions.save.setEnabled(True)
+        self.update_save_status(saved=False)
+        self.update_box_count()
+
+    def set_clean(self):
+        self.dirty = False
+        self.actions.save.setEnabled(False)
+        self.actions.create.setEnabled(True)
+        self.update_save_status(saved=True)
+
+    def toggle_actions(self, value=True):
+        """Enable/Disable widgets which depend on an opened image."""
+        for z in self.actions.zoomActions:
+            z.setEnabled(value)
+        for z in self.actions.lightActions:
+            z.setEnabled(value)
+        for action in self.actions.onLoadActive:
+            action.setEnabled(value)
+        # Enable paste if clipboard has shapes and image is loaded
+        if value and self.clipboard_shapes:
+            self.actions.pasteFromClipboard.setEnabled(True)
+        # Enable copy all if there are shapes
+        if value and self.canvas.shapes:
+            self.actions.copyAllToClipboard.setEnabled(True)
+
+    def queue_event(self, function):
+        QTimer.singleShot(0, function)
+
+    def status(self, message, delay=5000):
+        self.statusBar().showMessage(message, delay)
+
+    def update_status_bar(self):
+        """Update all status bar widgets."""
+        self.update_image_count()
+        self.update_box_count()
+        self.update_zoom_display()
+
+    def update_image_count(self):
+        """Update image counter in status bar."""
+        if self.m_img_list and self.file_path:
+            idx = self._path_to_idx.get(self.file_path, -1) + 1
+            self.label_image_count.setText(f'Image: {idx} / {len(self.m_img_list)}')
+        else:
+            self.label_image_count.setText('Image: 0 / 0')
+
+    def update_box_count(self):
+        """Update annotation count in status bar."""
+        count = len(self.canvas.shapes) if self.canvas else 0
+        self.label_box_count.setText(f'Boxes: {count}')
+
+    def update_zoom_display(self):
+        """Update zoom level in status bar."""
+        if self.zoom_widget:
+            self.label_zoom.setText(f'Zoom: {self.zoom_widget.value()}%')
+
+    def update_save_status(self, saved=True):
+        """Update save status indicator in status bar."""
+        if saved:
+            self.label_save_status.setStyleSheet('color: green; font-size: 14px;')
+            self.label_save_status.setToolTip('Saved')
+        else:
+            self.label_save_status.setStyleSheet('color: orange; font-size: 14px;')
+            self.label_save_status.setToolTip('Unsaved changes')
+
+    def reset_state(self):
+        self.items_to_shapes.clear()
+        self.shapes_to_items.clear()
+        self.label_list.clear()
+        self.file_path = None
+        self.image_data = None
+        self.label_file = None
+        self.canvas.reset_state()
+        self.label_coordinates.clear()
+        self.combo_box.cb.clear()
+        # Clear undo stack when loading new file
+        self.undo_stack.clear()
+        # Reset status bar widgets
+        self.label_box_count.setText('Boxes: 0')
+        self.update_save_status(saved=True)
+
+    def current_item(self):
+        items = self.label_list.selectedItems()
+        if items:
+            return items[0]
+        return None
+
+    def add_recent_file(self, file_path):
+        if file_path in self.recent_files:
+            self.recent_files.remove(file_path)
+        elif len(self.recent_files) >= self.max_recent:
+            self.recent_files.pop()
+        self.recent_files.insert(0, file_path)
+
+    def beginner(self):
+        return self._beginner
+
+    def advanced(self):
+        return not self.beginner()
+
+    def show_tutorial_dialog(self, browser='default', link=None):
+        if link is None:
+            link = self.screencast
+
+        if browser.lower() == 'default':
+            wb.open(link, new=2)
+        elif browser.lower() == 'chrome' and self.os_name == 'Windows':
+            if shutil.which(browser.lower()):  # 'chrome' not in wb._browsers in windows
+                wb.register('chrome', None, wb.BackgroundBrowser('chrome'))
+            else:
+                chrome_path="D:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+                if os.path.isfile(chrome_path):
+                    wb.register('chrome', None, wb.BackgroundBrowser(chrome_path))
+            try:
+                wb.get('chrome').open(link, new=2)
+            except (wb.Error, KeyError):
+                wb.open(link, new=2)
+        elif browser.lower() in wb._browsers:
+            wb.get(browser.lower()).open(link, new=2)
+
+    def show_default_tutorial_dialog(self):
+        self.show_tutorial_dialog(browser='default')
+
+    def show_info_dialog(self):
+        from libs.__init__ import __version__
+        msg = u'Name:{0} \nApp Version:{1} \n{2} '.format(__appname__, __version__, sys.version_info)
+        QMessageBox.information(self, u'Information', msg)
+
+    def show_shortcuts_dialog(self):
+        self.show_tutorial_dialog(browser='default', link='https://github.com/tzutalin/labelImg#Hotkeys')
+
+    def create_shape(self):
+        assert self.beginner()
+        self.canvas.set_editing(False)
+        self.actions.create.setEnabled(False)
+
+    def toggle_drawing_sensitive(self, drawing=True):
+        """In the middle of drawing, toggling between modes should be disabled."""
+        self.actions.editMode.setEnabled(not drawing)
+        if not drawing and self.beginner():
+            # Cancel creation.
+            print('Cancel creation.')
+            self.canvas.set_editing(True)
+            self.canvas.restore_cursor()
+            self.actions.create.setEnabled(True)
+
+    def toggle_draw_mode(self, edit=True):
+        self.canvas.set_editing(edit)
+        self.actions.createMode.setEnabled(edit)
+        self.actions.editMode.setEnabled(not edit)
+
+    def set_create_mode(self):
+        assert self.advanced()
+        self.toggle_draw_mode(False)
+
+    def set_edit_mode(self):
+        assert self.advanced()
+        self.toggle_draw_mode(True)
+        self.label_selection_changed()
+
+    def update_file_menu(self):
+        curr_file_path = self.file_path
+
+        def exists(filename):
+            return os.path.exists(filename)
+        menu = self.menus.recentFiles
+        menu.clear()
+        files = [f for f in self.recent_files if f !=
+                 curr_file_path and exists(f)]
+        for i, f in enumerate(files):
+            icon = new_icon('labels')
+            action = QAction(
+                icon, '&%d %s' % (i + 1, QFileInfo(f).fileName()), self)
+            action.triggered.connect(partial(self.load_recent, f))
+            menu.addAction(action)
+
+    def pop_label_list_menu(self, point):
+        self.menus.labelList.exec_(self.label_list.mapToGlobal(point))
+
+    def edit_label(self):
+        if not self.canvas.editing():
+            return
+        item = self.current_item()
+        if not item:
+            return
+        text = self.label_dialog.pop_up(item.text())
+        if text is not None:
+            item.setText(text)
+            item.setBackground(generate_color_by_text(text))
+            self.set_dirty()
+            self.update_combo_box()
+
+    # Tzutalin 20160906 : Add file list and dock to move faster
+    def file_item_double_clicked(self, item=None):
+        item_path = ustr(item.text())
+        self.cur_img_idx = self._path_to_idx.get(item_path, 0)
+        filename = self.m_img_list[self.cur_img_idx]
+        if filename:
+            self.load_file(filename)
+
+    def file_item_clicked(self, item=None):
+        """Handle single click on file list item - sync gallery selection."""
+        # Skip if we're already in a gallery selection operation
+        if hasattr(self, '_selecting_gallery') and self._selecting_gallery:
+            return
+        if item is not None:
+            item_path = ustr(item.text())
+            if item_path in self._path_to_idx:
+                self.cur_img_idx = self._path_to_idx[item_path]
+                self.gallery_widget.select_image(item_path)
+
+    def gallery_image_selected(self, image_path):
+        """Handle single click on gallery thumbnail - sync all views."""
+        # Prevent recursive calls
+        if hasattr(self, '_selecting_gallery') and self._selecting_gallery:
+            return
+        self._selecting_gallery = True
+        try:
+            if image_path in self._path_to_idx:
+                self.cur_img_idx = self._path_to_idx[image_path]
+                # Sync list selection - block signals to prevent triggering file_item_clicked
+                self.file_list_widget.blockSignals(True)
+                for i in range(self.file_list_widget.count()):
+                    item = self.file_list_widget.item(i)
+                    if ustr(item.text()) == image_path:
+                        self.file_list_widget.setCurrentItem(item)
+                        break
+                self.file_list_widget.blockSignals(False)
+                # Sync all gallery selections
+                self.gallery_widget.select_image(image_path)
+                if hasattr(self, 'full_gallery') and self.full_gallery:
+                    self.full_gallery.select_image(image_path)
+        finally:
+            self._selecting_gallery = False
+
+    def gallery_image_activated(self, image_path):
+        """Handle double-click on gallery thumbnail - load image."""
+        if image_path in self._path_to_idx:
+            self.cur_img_idx = self._path_to_idx[image_path]
+            self.load_file(image_path)
+
+    def on_file_view_tab_changed(self, index):
+        """Handle tab switch between list and gallery view."""
+        if index == 1:  # Gallery tab
+            self._refresh_gallery_statuses()
+
+    def _get_annotation_status(self, image_path, use_cache=True):
+        """Determine annotation status for an image with optional caching."""
+        # Check cache first for O(1) lookup
+        if use_cache and image_path in self._annotation_status_cache:
+            return self._annotation_status_cache[image_path]
+
+        basename = os.path.splitext(os.path.basename(image_path))[0]
+
+        # Determine annotation directory
+        if self.default_save_dir is not None:
+            ann_dir = self.default_save_dir
+        else:
+            ann_dir = os.path.dirname(image_path)
+
+        # Check for annotation files
+        xml_path = os.path.join(ann_dir, basename + XML_EXT)
+        txt_path = os.path.join(ann_dir, basename + TXT_EXT)
+        json_path = os.path.join(ann_dir, 'annotations.json')
+
+        has_labels = False
+        verified = False
+
+        # Check PASCAL VOC
+        if os.path.isfile(xml_path):
+            has_labels = True
+            try:
+                reader = PascalVocReader(xml_path)
+                verified = reader.verified
+            except Exception:
+                pass
+        # Check YOLO
+        elif os.path.isfile(txt_path):
+            has_labels = os.path.getsize(txt_path) > 0
+        # Check CreateML
+        elif os.path.isfile(json_path):
+            try:
+                import json
+                with open(json_path, 'r') as f:
+                    data = json.load(f)
+                    for item in data:
+                        if item.get('image') == os.path.basename(image_path):
+                            has_labels = len(item.get('annotations', [])) > 0
+                            verified = item.get('verified', False)
+                            break
+            except Exception:
+                pass
+
+        if verified:
+            status = AnnotationStatus.VERIFIED
+        elif has_labels:
+            status = AnnotationStatus.HAS_LABELS
+        else:
+            status = AnnotationStatus.NO_LABELS
+
+        # Cache the result
+        self._annotation_status_cache[image_path] = status
+        return status
+
+    def _invalidate_status_cache(self, image_path=None):
+        """Invalidate annotation status cache for a path or all paths."""
+        if image_path:
+            self._annotation_status_cache.pop(image_path, None)
+        else:
+            self._annotation_status_cache.clear()
+
+    def _refresh_gallery_statuses(self):
+        """Update all gallery thumbnail statuses."""
+        statuses = {}
+        for img_path in self.m_img_list:
+            statuses[img_path] = self._get_annotation_status(img_path)
+        self.gallery_widget.update_all_statuses(statuses)
+
+    def _update_current_image_gallery_status(self):
+        """Update gallery status for current image after save/verify."""
+        if self.file_path:
+            # Invalidate cache for this file to get fresh status
+            self._invalidate_status_cache(self.file_path)
+            status = self._get_annotation_status(self.file_path)
+            self.gallery_widget.update_status(self.file_path, status)
+            # Also update full-screen gallery if active
+            if hasattr(self, 'full_gallery') and self.full_gallery:
+                self.full_gallery.update_status(self.file_path, status)
+
+    # Add chris
+    def button_state(self, item=None):
+        """ Function to handle difficult examples
+        Update on each object """
+        if not self.canvas.editing():
+            return
+
+        item = self.current_item()
+        if not item:  # If not selected Item, take the first one
+            item = self.label_list.item(self.label_list.count() - 1)
+
+        difficult = self.diffc_button.isChecked()
+
+        shape = self.items_to_shapes.get(item)
+        if shape is None:
+            return
+
+        # Checked and Update
+        if difficult != shape.difficult:
+            shape.difficult = difficult
+            self.set_dirty()
+        else:  # User probably changed item visibility
+            self.canvas.set_shape_visible(shape, item.checkState() == Qt.Checked)
+
+    # React to canvas signals.
+    def shape_selection_changed(self, selected=False):
+        if self._no_selection_slot:
+            self._no_selection_slot = False
+        else:
+            shape = self.canvas.selected_shape
+            if shape:
+                self.shapes_to_items[shape].setSelected(True)
+            else:
+                self.label_list.clearSelection()
+        self.actions.delete.setEnabled(selected)
+        self.actions.copy.setEnabled(selected)
+        self.actions.copyToClipboard.setEnabled(selected)
+        self.actions.edit.setEnabled(selected)
+        self.actions.shapeLineColor.setEnabled(selected)
+        self.actions.shapeFillColor.setEnabled(selected)
+        # Enable paste if clipboard has shapes
+        self.actions.pasteFromClipboard.setEnabled(len(self.clipboard_shapes) > 0)
+        # Enable copy all if there are shapes
+        self.actions.copyAllToClipboard.setEnabled(len(self.canvas.shapes) > 0)
+
+    def add_label(self, shape):
+        shape.paint_label = self.display_label_option.isChecked()
+        item = HashableQListWidgetItem(shape.label)
+        item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+        item.setCheckState(Qt.Checked)
+        item.setBackground(generate_color_by_text(shape.label))
+        self.items_to_shapes[item] = shape
+        self.shapes_to_items[shape] = item
+        self.label_list.addItem(item)
+        for action in self.actions.onShapesPresent:
+            action.setEnabled(True)
+        self.update_combo_box()
+
+    def remove_label(self, shape):
+        if shape is None:
+            # print('rm empty label')
+            return
+        item = self.shapes_to_items[shape]
+        self.label_list.takeItem(self.label_list.row(item))
+        del self.shapes_to_items[shape]
+        del self.items_to_shapes[item]
+        self.update_combo_box()
+
+    def load_labels(self, shapes):
+        s = []
+        # Scale factor for converting original coords to display coords (Issue #31)
+        scale = self._image_scale_factor if hasattr(self, '_image_scale_factor') else 1.0
+
+        for label, points, line_color, fill_color, difficult in shapes:
+            shape = Shape(label=label)
+            for x, y in points:
+                # Scale coordinates from original to display space
+                x = x * scale
+                y = y * scale
+
+                # Ensure the labels are within the bounds of the image. If not, fix them.
+                x, y, snapped = self.canvas.snap_point_to_canvas(x, y)
+                if snapped:
+                    self.set_dirty()
+
+                shape.add_point(QPointF(x, y))
+            shape.difficult = difficult
+            shape.close()
+            s.append(shape)
+
+            if line_color:
+                shape.line_color = QColor(*line_color)
+            else:
+                shape.line_color = generate_color_by_text(label)
+
+            if fill_color:
+                shape.fill_color = QColor(*fill_color)
+            else:
+                shape.fill_color = generate_color_by_text(label)
+
+            self.add_label(shape)
+        self.update_combo_box()
+        self.canvas.load_shapes(s)
+
+    def update_combo_box(self):
+        # Get the unique labels and add them to the Combobox.
+        items_text_list = [str(self.label_list.item(i).text()) for i in range(self.label_list.count())]
+
+        unique_text_list = list(set(items_text_list))
+        # Add a null row for showing all the labels
+        unique_text_list.append("")
+        unique_text_list.sort()
+
+        self.combo_box.update_items(unique_text_list)
+
+    def save_labels(self, annotation_file_path):
+        annotation_file_path = ustr(annotation_file_path)
+        if self.label_file is None:
+            self.label_file = LabelFile()
+            self.label_file.verified = self.canvas.verified
+
+        # Scale factor for converting display coords to original coords (Issue #31)
+        inv_scale = 1.0 / self._image_scale_factor if hasattr(self, '_image_scale_factor') and self._image_scale_factor != 0 else 1.0
+
+        def format_shape(s):
+            # Scale coordinates from display space to original image space
+            scaled_points = [(p.x() * inv_scale, p.y() * inv_scale) for p in s.points]
+            return dict(label=s.label,
+                        line_color=s.line_color.getRgb(),
+                        fill_color=s.fill_color.getRgb(),
+                        points=scaled_points,
+                        difficult=s.difficult)
+
+        shapes = [format_shape(shape) for shape in self.canvas.shapes]
+        # Can add different annotation formats here
+        try:
+            if self.label_file_format == LabelFileFormat.PASCAL_VOC:
+                if annotation_file_path[-4:].lower() != ".xml":
+                    annotation_file_path += XML_EXT
+                self.label_file.save_pascal_voc_format(annotation_file_path, shapes, self.file_path, self.image_data,
+                                                       self.line_color.getRgb(), self.fill_color.getRgb())
+            elif self.label_file_format == LabelFileFormat.YOLO:
+                if annotation_file_path[-4:].lower() != ".txt":
+                    annotation_file_path += TXT_EXT
+                self.label_file.save_yolo_format(annotation_file_path, shapes, self.file_path, self.image_data, self.label_hist,
+                                                 self.line_color.getRgb(), self.fill_color.getRgb())
+            elif self.label_file_format == LabelFileFormat.CREATE_ML:
+                if annotation_file_path[-5:].lower() != ".json":
+                    annotation_file_path += JSON_EXT
+                self.label_file.save_create_ml_format(annotation_file_path, shapes, self.file_path, self.image_data,
+                                                      self.label_hist, self.line_color.getRgb(), self.fill_color.getRgb())
+            else:
+                self.label_file.save(annotation_file_path, shapes, self.file_path, self.image_data,
+                                     self.line_color.getRgb(), self.fill_color.getRgb())
+            print('Image:{0} -> Annotation:{1}'.format(self.file_path, annotation_file_path))
+            return True
+        except LabelFileError as e:
+            self.error_message(u'Error saving label data', u'<b>%s</b>' % e)
+            return False
+
+    def copy_selected_shape(self):
+        shape = self.canvas.copy_selected_shape()
+        self.add_label(shape)
+
+        # Push command for undo support (shape already created, so just push)
+        cmd = CreateShapeCommand(self, shape)
+        self.undo_stack.push(cmd)
+
+        # fix copy and delete
+        self.shape_selection_changed(True)
+
+    def copy_to_clipboard(self):
+        """Copy selected shape to clipboard for pasting across images."""
+        if self.canvas.selected_shape is None:
+            return
+        # Store a copy of the selected shape
+        self.clipboard_shapes = [self.canvas.selected_shape.copy()]
+        self.actions.pasteFromClipboard.setEnabled(True)
+        self.statusBar().showMessage(f'Copied 1 annotation to clipboard', 3000)
+
+    def copy_all_to_clipboard(self):
+        """Copy all shapes to clipboard for pasting across images."""
+        if not self.canvas.shapes:
+            return
+        # Store copies of all shapes
+        self.clipboard_shapes = [shape.copy() for shape in self.canvas.shapes]
+        self.actions.pasteFromClipboard.setEnabled(True)
+        self.statusBar().showMessage(f'Copied {len(self.clipboard_shapes)} annotations to clipboard', 3000)
+
+    def paste_from_clipboard(self):
+        """Paste shapes from clipboard to current image."""
+        if not self.clipboard_shapes:
+            return
+        if not self.canvas.pixmap or self.canvas.pixmap.isNull():
+            return
+
+        for clipboard_shape in self.clipboard_shapes:
+            # Create a new copy for each paste
+            shape = clipboard_shape.copy()
+            # Add shape to canvas
+            self.canvas.shapes.append(shape)
+            self.add_label(shape)
+            # Push command for undo support
+            cmd = CreateShapeCommand(self, shape)
+            self.undo_stack.push(cmd)
+
+        self.set_dirty()
+        self.canvas.update()
+        self.update_box_count()
+        self.statusBar().showMessage(f'Pasted {len(self.clipboard_shapes)} annotations', 3000)
+
+    def combo_selection_changed(self, index):
+        text = self.combo_box.cb.itemText(index)
+        for i in range(self.label_list.count()):
+            if text == "":
+                self.label_list.item(i).setCheckState(2)
+            elif text != self.label_list.item(i).text():
+                self.label_list.item(i).setCheckState(0)
+            else:
+                self.label_list.item(i).setCheckState(2)
+
+    def default_label_combo_selection_changed(self, index):
+        self.default_label=self.label_hist[index]
+
+    def label_selection_changed(self):
+        item = self.current_item()
+        if item and self.canvas.editing():
+            self._no_selection_slot = True
+            self.canvas.select_shape(self.items_to_shapes[item])
+            shape = self.items_to_shapes[item]
+            # Add Chris
+            self.diffc_button.setChecked(shape.difficult)
+
+    def label_item_changed(self, item):
+        shape = self.items_to_shapes[item]
+        label = item.text()
+        if label != shape.label:
+            old_label = shape.label
+            shape.label = item.text()
+            shape.line_color = generate_color_by_text(shape.label)
+
+            # Push command for undo support (change already made, so just push)
+            cmd = EditLabelCommand(self, shape, old_label, label)
+            self.undo_stack.push(cmd)
+
+            self.set_dirty()
+        else:  # User probably changed item visibility
+            self.canvas.set_shape_visible(shape, item.checkState() == Qt.Checked)
+
+    # Callback functions:
+    def new_shape(self):
+        """Pop-up and give focus to the label editor.
+
+        position MUST be in global coordinates.
+        """
+        if not self.use_default_label_checkbox.isChecked():
+            if len(self.label_hist) > 0:
+                self.label_dialog = LabelDialog(
+                    parent=self, list_item=self.label_hist)
+
+            # Sync single class mode from PR#106
+            if self.single_class_mode.isChecked() and self.lastLabel:
+                text = self.lastLabel
+            else:
+                text = self.label_dialog.pop_up(text=self.prev_label_text)
+                self.lastLabel = text
+        else:
+            text = self.default_label
+
+        # Add Chris
+        self.diffc_button.setChecked(False)
+        if text is not None:
+            self.prev_label_text = text
+            generate_color = generate_color_by_text(text)
+            shape = self.canvas.set_last_label(text, generate_color, generate_color)
+            self.add_label(shape)
+
+            # Push command for undo support (shape already created, so just push)
+            cmd = CreateShapeCommand(self, shape)
+            self.undo_stack.push(cmd)
+
+            if self.beginner():  # Switch to edit mode.
+                self.canvas.set_editing(True)
+                self.actions.create.setEnabled(True)
+            else:
+                self.actions.editMode.setEnabled(True)
+            self.set_dirty()
+
+            if text not in self.label_hist:
+                self.label_hist.append(text)
+        else:
+            # self.canvas.undoLastLine()
+            self.canvas.reset_all_lines()
+
+    def scroll_request(self, delta, orientation):
+        units = - delta / (8 * 15)
+        bar = self.scroll_bars[orientation]
+        bar.setValue(int(bar.value() + bar.singleStep() * units))
+
+    def set_zoom(self, value):
+        self.actions.fitWidth.setChecked(False)
+        self.actions.fitWindow.setChecked(False)
+        self.zoom_mode = self.MANUAL_ZOOM
+        # Arithmetic on scaling factor often results in float
+        # Convert to int to avoid type errors
+        self.zoom_widget.setValue(int(value))
+
+    def add_zoom(self, increment=10):
+        self.set_zoom(self.zoom_widget.value() + increment)
+
+    def zoom_request(self, delta):
+        # get the current scrollbar positions
+        # calculate the percentages ~ coordinates
+        h_bar = self.scroll_bars[Qt.Horizontal]
+        v_bar = self.scroll_bars[Qt.Vertical]
+
+        # get the current maximum, to know the difference after zooming
+        h_bar_max = h_bar.maximum()
+        v_bar_max = v_bar.maximum()
+
+        # get the cursor position and canvas size
+        # calculate the desired movement from 0 to 1
+        # where 0 = move left
+        #       1 = move right
+        # up and down analogous
+        cursor = QCursor()
+        pos = cursor.pos()
+        relative_pos = QWidget.mapFromGlobal(self, pos)
+
+        cursor_x = relative_pos.x()
+        cursor_y = relative_pos.y()
+
+        w = self.scroll_area.width()
+        h = self.scroll_area.height()
+
+        # the scaling from 0 to 1 has some padding
+        # you don't have to hit the very leftmost pixel for a maximum-left movement
+        margin = 0.1
+        move_x = (cursor_x - margin * w) / (w - 2 * margin * w)
+        move_y = (cursor_y - margin * h) / (h - 2 * margin * h)
+
+        # clamp the values from 0 to 1
+        move_x = min(max(move_x, 0), 1)
+        move_y = min(max(move_y, 0), 1)
+
+        # zoom in
+        units = delta // (8 * 15)
+        scale = 10
+        self.add_zoom(scale * units)
+
+        # get the difference in scrollbar values
+        # this is how far we can move
+        d_h_bar_max = h_bar.maximum() - h_bar_max
+        d_v_bar_max = v_bar.maximum() - v_bar_max
+
+        # get the new scrollbar values
+        new_h_bar_value = int(h_bar.value() + move_x * d_h_bar_max)
+        new_v_bar_value = int(v_bar.value() + move_y * d_v_bar_max)
+
+        h_bar.setValue(new_h_bar_value)
+        v_bar.setValue(new_v_bar_value)
+
+    def light_request(self, delta):
+        self.add_light(5*delta // (8 * 15))
+
+    def set_fit_window(self, value=True):
+        if value:
+            self.actions.fitWidth.setChecked(False)
+        self.zoom_mode = self.FIT_WINDOW if value else self.MANUAL_ZOOM
+        self.adjust_scale()
+
+    def set_fit_width(self, value=True):
+        if value:
+            self.actions.fitWindow.setChecked(False)
+        self.zoom_mode = self.FIT_WIDTH if value else self.MANUAL_ZOOM
+        self.adjust_scale()
+
+    def set_light(self, value):
+        self.actions.lightOrg.setChecked(int(value) == 50)
+        # Arithmetic on scaling factor often results in float
+        # Convert to int to avoid type errors
+        self.light_widget.setValue(int(value))
+
+    def add_light(self, increment=10):
+        self.set_light(self.light_widget.value() + increment)
+
+    def toggle_polygons(self, value):
+        for item, shape in self.items_to_shapes.items():
+            item.setCheckState(Qt.Checked if value else Qt.Unchecked)
+
+    def load_file(self, file_path=None):
+        """Load the specified file, or the last opened file if None."""
+        self.reset_state()
+        self.canvas.setEnabled(False)
+        if file_path is None:
+            file_path = self.settings.get(SETTING_FILENAME)
+        # Make sure that filePath is a regular python string, rather than QString
+        file_path = ustr(file_path)
+
+        # Fix bug: An  index error after select a directory when open a new file.
+        unicode_file_path = ustr(file_path)
+        unicode_file_path = os.path.abspath(unicode_file_path)
+        # Tzutalin 20160906 : Add file list and dock to move faster
+        # Highlight the file item
+        if unicode_file_path and self.file_list_widget.count() > 0:
+            if unicode_file_path in self._path_to_idx:
+                index = self._path_to_idx[unicode_file_path]
+                file_widget_item = self.file_list_widget.item(index)
+                file_widget_item.setSelected(True)
+                # Sync gallery selection
+                self.gallery_widget.select_image(unicode_file_path)
+            else:
+                self.file_list_widget.clear()
+                self.m_img_list.clear()
+
+        if unicode_file_path and os.path.exists(unicode_file_path):
+            if LabelFile.is_label_file(unicode_file_path):
+                try:
+                    self.label_file = LabelFile(unicode_file_path)
+                except LabelFileError as e:
+                    self.error_message(u'Error opening file',
+                                       (u"<p><b>%s</b></p>"
+                                        u"<p>Make sure <i>%s</i> is a valid label file.")
+                                       % (e, unicode_file_path))
+                    self.status("Error reading %s" % unicode_file_path)
+                    
+                    return False
+                self.image_data = self.label_file.image_data
+                self.line_color = QColor(*self.label_file.lineColor)
+                self.fill_color = QColor(*self.label_file.fillColor)
+                self.canvas.verified = self.label_file.verified
+            else:
+                # Load image with memory-efficient downsampling for large images
+                self.label_file = None
+                self.canvas.verified = False
+
+                # Use QImageReader for memory-efficient loading
+                reader = QImageReader(unicode_file_path)
+                reader.setAutoTransform(True)
+                original_size = reader.size()
+
+                if not original_size.isValid():
+                    self.error_message(u'Error opening file',
+                                       u"<p>Make sure <i>%s</i> is a valid image file." % unicode_file_path)
+                    self.status("Error reading %s" % unicode_file_path)
+                    return False
+
+                # Downsample if larger than 2048px on either dimension (Issue #31)
+                MAX_DISPLAY_DIM = 2048
+                if original_size.width() > MAX_DISPLAY_DIM or original_size.height() > MAX_DISPLAY_DIM:
+                    scaled_size = original_size.scaled(MAX_DISPLAY_DIM, MAX_DISPLAY_DIM, Qt.KeepAspectRatio)
+                    reader.setScaledSize(scaled_size)
+                    self._image_scale_factor = scaled_size.width() / original_size.width()
+                else:
+                    self._image_scale_factor = 1.0
+
+                self._original_image_size = original_size
+                image = reader.read()
+
+                if image.isNull():
+                    self.error_message(u'Error opening file',
+                                       u"<p>Make sure <i>%s</i> is a valid image file." % unicode_file_path)
+                    self.status("Error reading %s" % unicode_file_path)
+                    return False
+
+                # Don't store full image data - saves memory
+                self.image_data = None
+
+            self.status("Loaded %s" % os.path.basename(unicode_file_path))
+            self.image = image
+            self.file_path = unicode_file_path
+            self.canvas.load_pixmap(QPixmap.fromImage(image))
+            if self.label_file:
+                self.load_labels(self.label_file.shapes)
+            self.set_clean()
+            self.canvas.setEnabled(True)
+            self.adjust_scale(initial=True)
+            self.paint_canvas()
+            self.add_recent_file(self.file_path)
+            self.toggle_actions(True)
+            self.show_bounding_box_from_annotation_file(self.file_path)
+
+            counter = self.counter_str()
+            self.setWindowTitle(__appname__ + ' ' + file_path + ' ' + counter)
+
+            # Update status bar widgets
+            self.update_status_bar()
+            self.update_save_status(saved=True)
+
+            # Default : select last item if there is at least one item
+            if self.label_list.count():
+                self.label_list.setCurrentItem(self.label_list.item(self.label_list.count() - 1))
+                self.label_list.item(self.label_list.count() - 1).setSelected(True)
+
+            self.canvas.setFocus(True)
+            return True
+        return False
+
+    def counter_str(self):
+        """
+        Converts image counter to string representation.
+        """
+        return '[{} / {}]'.format(self.cur_img_idx + 1, self.img_count)
+
+    def show_bounding_box_from_annotation_file(self, file_path):
+        if self.default_save_dir is not None:
+            basename = os.path.basename(os.path.splitext(file_path)[0])
+            xml_path = os.path.join(self.default_save_dir, basename + XML_EXT)
+            txt_path = os.path.join(self.default_save_dir, basename + TXT_EXT)
+            json_path = os.path.join(self.default_save_dir, basename + JSON_EXT)
+
+            """Annotation file priority:
+            PascalXML > YOLO
+            """
+            if os.path.isfile(xml_path):
+                self.load_pascal_xml_by_filename(xml_path)
+            elif os.path.isfile(txt_path):
+                self.load_yolo_txt_by_filename(txt_path)
+            elif os.path.isfile(json_path):
+                self.load_create_ml_json_by_filename(json_path, file_path)
+
+        else:
+            xml_path = os.path.splitext(file_path)[0] + XML_EXT
+            txt_path = os.path.splitext(file_path)[0] + TXT_EXT
+            json_path = os.path.splitext(file_path)[0] + JSON_EXT
+
+            if os.path.isfile(xml_path):
+                self.load_pascal_xml_by_filename(xml_path)
+            elif os.path.isfile(txt_path):
+                self.load_yolo_txt_by_filename(txt_path)
+            elif os.path.isfile(json_path):
+                self.load_create_ml_json_by_filename(json_path, file_path)
+            
+
+    def resizeEvent(self, event):
+        if self.canvas and not self.image.isNull()\
+           and self.zoom_mode != self.MANUAL_ZOOM:
+            self.adjust_scale()
+        super(MainWindow, self).resizeEvent(event)
+
+    def paint_canvas(self):
+        assert not self.image.isNull(), "cannot paint null image"
+        self.canvas.scale = 0.01 * self.zoom_widget.value()
+        self.canvas.overlay_color = self.light_widget.color()
+        self.canvas.label_font_size = int(0.02 * max(self.image.width(), self.image.height()))
+        self.canvas.adjustSize()
+        self.canvas.update()
+
+    def adjust_scale(self, initial=False):
+        value = self.scalers[self.FIT_WINDOW if initial else self.zoom_mode]()
+        self.zoom_widget.setValue(int(100 * value))
+
+    def scale_fit_window(self):
+        """Figure out the size of the pixmap in order to fit the main widget."""
+        e = 2.0  # So that no scrollbars are generated.
+        w1 = self.centralWidget().width() - e
+        h1 = self.centralWidget().height() - e
+        a1 = w1 / h1
+        # Calculate a new scale value based on the pixmap's aspect ratio.
+        w2 = self.canvas.pixmap.width() - 0.0
+        h2 = self.canvas.pixmap.height() - 0.0
+        a2 = w2 / h2
+        return w1 / w2 if a2 >= a1 else h1 / h2
+
+    def scale_fit_width(self):
+        # The epsilon does not seem to work too well here.
+        w = self.centralWidget().width() - 2.0
+        return w / self.canvas.pixmap.width()
+
+    def closeEvent(self, event):
+        if not self.may_continue():
+            event.ignore()
+        settings = self.settings
+        # If it loads images from dir, don't load it at the beginning
+        if self.dir_name is None:
+            settings[SETTING_FILENAME] = self.file_path if self.file_path else ''
+        else:
+            settings[SETTING_FILENAME] = ''
+
+        settings[SETTING_WIN_SIZE] = self.size()
+        settings[SETTING_WIN_POSE] = self.pos()
+        settings[SETTING_WIN_STATE] = self.saveState()
+        settings[SETTING_LINE_COLOR] = self.line_color
+        settings[SETTING_FILL_COLOR] = self.fill_color
+        settings[SETTING_RECENT_FILES] = self.recent_files
+        settings[SETTING_ADVANCE_MODE] = not self._beginner
+        settings[SETTING_GALLERY_MODE] = self.gallery_mode_enabled
+        if self.default_save_dir and os.path.exists(self.default_save_dir):
+            settings[SETTING_SAVE_DIR] = ustr(self.default_save_dir)
+        else:
+            settings[SETTING_SAVE_DIR] = ''
+
+        if self.last_open_dir and os.path.exists(self.last_open_dir):
+            settings[SETTING_LAST_OPEN_DIR] = self.last_open_dir
+        else:
+            settings[SETTING_LAST_OPEN_DIR] = ''
+
+        settings[SETTING_AUTO_SAVE] = self.auto_saving.isChecked()
+        settings[SETTING_AUTO_SAVE_ENABLED] = self.auto_save_enabled.isChecked()
+        settings[SETTING_AUTO_SAVE_INTERVAL] = self._get_current_auto_save_interval()
+        settings[SETTING_SINGLE_CLASS] = self.single_class_mode.isChecked()
+        settings[SETTING_PAINT_LABEL] = self.display_label_option.isChecked()
+        settings[SETTING_DRAW_SQUARE] = self.draw_squares_option.isChecked()
+        settings[SETTING_LABEL_FILE_FORMAT] = self.label_file_format
+        settings[SETTING_TOOLBAR_EXPANDED] = self.tools.is_expanded()
+        settings.save()
+
+    def load_recent(self, filename):
+        if self.may_continue():
+            self.load_file(filename)
+
+    def scan_all_images(self, folder_path):
+        extensions = ['.%s' % fmt.data().decode("ascii").lower() for fmt in QImageReader.supportedImageFormats()]
+        images = []
+
+        for root, dirs, files in os.walk(folder_path):
+            for file in files:
+                if file.lower().endswith(tuple(extensions)):
+                    relative_path = os.path.join(root, file)
+                    path = ustr(os.path.abspath(relative_path))
+                    images.append(path)
+        natural_sort(images, key=lambda x: x.lower())
+        return images
+
+    def change_save_dir_dialog(self, _value=False):
+        if self.default_save_dir is not None:
+            path = ustr(self.default_save_dir)
+        else:
+            path = '.'
+
+        dir_path = ustr(QFileDialog.getExistingDirectory(self,
+                                                         '%s - Save annotations to the directory' % __appname__, path,  QFileDialog.ShowDirsOnly
+                                                         | QFileDialog.DontResolveSymlinks))
+
+        if dir_path is not None and len(dir_path) > 1:
+            self.default_save_dir = dir_path
+            # Clear status cache since annotation directory changed
+            self._invalidate_status_cache()
+            # Update gallery to reload thumbnails with annotations from new dir
+            self.gallery_widget.set_save_dir(self.default_save_dir)
+
+        self.show_bounding_box_from_annotation_file(self.file_path)
+
+        self.statusBar().showMessage('%s . Annotation will be saved to %s' %
+                                     ('Change saved folder', self.default_save_dir))
+        self.statusBar().show()
+
+
+    def open_annotation_dialog(self, _value=False):
+        if self.file_path is None:
+            self.statusBar().showMessage('Please select image first')
+            self.statusBar().show()
+            return
+
+        path = os.path.dirname(ustr(self.file_path))\
+            if self.file_path else '.'
+        if self.label_file_format == LabelFileFormat.PASCAL_VOC:
+            filters = "Open Annotation XML file (%s)" % ' '.join(['*.xml'])
+            filename = ustr(QFileDialog.getOpenFileName(self, '%s - Choose a xml file' % __appname__, path, filters))
+            if filename:
+                if isinstance(filename, (tuple, list)):
+                    filename = filename[0]
+            self.load_pascal_xml_by_filename(filename)
+
+        elif self.label_file_format == LabelFileFormat.CREATE_ML:
+            
+            filters = "Open Annotation JSON file (%s)" % ' '.join(['*.json'])
+            filename = ustr(QFileDialog.getOpenFileName(self, '%s - Choose a json file' % __appname__, path, filters))
+            if filename:
+                if isinstance(filename, (tuple, list)):
+                    filename = filename[0]
+
+            self.load_create_ml_json_by_filename(filename, self.file_path)         
+        
+
+    def open_dir_dialog(self, _value=False, dir_path=None, silent=False):
+        if not self.may_continue():
+            return
+
+        default_open_dir_path = dir_path if dir_path else '.'
+        if self.last_open_dir and os.path.exists(self.last_open_dir):
+            default_open_dir_path = self.last_open_dir
+        else:
+            default_open_dir_path = os.path.dirname(self.file_path) if self.file_path else '.'
+        if silent != True:
+            target_dir_path = ustr(QFileDialog.getExistingDirectory(self,
+                                                                    '%s - Open Directory' % __appname__, default_open_dir_path,
+                                                                    QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks))
+        else:
+            target_dir_path = ustr(default_open_dir_path)
+        self.last_open_dir = target_dir_path
+        self.import_dir_images(target_dir_path)
+        # Only set default_save_dir if not already set (e.g., from command line)
+        if self.default_save_dir is None:
+            self.default_save_dir = target_dir_path
+        if self.file_path:
+            self.show_bounding_box_from_annotation_file(file_path=self.file_path)
+
+    def import_dir_images(self, dir_path):
+        if not self.may_continue() or not dir_path:
+            return
+
+        self.last_open_dir = dir_path
+        self.dir_name = dir_path
+        self.file_path = None
+        self.file_list_widget.clear()
+
+        # Show progress dialog for scanning
+        progress = QProgressDialog("Scanning directory...", "Cancel", 0, 0, self)
+        progress.setWindowTitle("Loading Images")
+        progress.setWindowModality(Qt.WindowModal)
+        progress.setMinimumDuration(500)  # Only show if operation takes > 500ms
+        progress.setValue(0)
+        QApplication.processEvents()
+
+        self.m_img_list = self.scan_all_images(dir_path)
+        self._path_to_idx = {path: idx for idx, path in enumerate(self.m_img_list)}
+        self._annotation_status_cache.clear()  # Clear cache for new directory
+        self.img_count = len(self.m_img_list)
+
+        if progress.wasCanceled():
+            progress.close()
+            return
+
+        # Update progress for file list population
+        if self.img_count > 100:
+            progress.setLabelText(f"Loading {self.img_count} images...")
+            progress.setMaximum(self.img_count)
+
+        # Populate file list widget
+        for i, imgPath in enumerate(self.m_img_list):
+            item = QListWidgetItem(imgPath)
+            self.file_list_widget.addItem(item)
+            if self.img_count > 100 and i % 50 == 0:
+                progress.setValue(i)
+                QApplication.processEvents()
+                if progress.wasCanceled():
+                    progress.close()
+                    return
+
+        progress.setValue(self.img_count)
+
+        # Populate gallery widget with annotation directory
+        self.gallery_widget.set_save_dir(self.default_save_dir)
+        self.gallery_widget.set_image_list(self.m_img_list)
+        self._refresh_gallery_statuses()
+
+        # Update full-screen gallery if active
+        if hasattr(self, 'full_gallery') and self.full_gallery:
+            self.full_gallery.set_save_dir(self.default_save_dir)
+            self.full_gallery.set_image_list(self.m_img_list)
+            self._refresh_full_gallery_statuses()
+
+        progress.close()
+
+        # Update image count in status bar
+        self.update_image_count()
+        self.open_next_image()
+
+    def verify_image(self, _value=False):
+        # Proceeding next image without dialog if having any label
+        if self.file_path is not None:
+            try:
+                self.label_file.toggle_verify()
+            except AttributeError:
+                # If the labelling file does not exist yet, create if and
+                # re-save it with the verified attribute.
+                self.save_file()
+                if self.label_file is not None:
+                    self.label_file.toggle_verify()
+                else:
+                    return
+
+            self.canvas.verified = self.label_file.verified
+            self.paint_canvas()
+            self.save_file()
+            # Update gallery status after verify
+            self._update_current_image_gallery_status()
+
+    def open_prev_image(self, _value=False):
+        # Proceeding prev image without dialog if having any label
+        if self.auto_saving.isChecked():
+            if self.default_save_dir is not None:
+                if self.dirty is True:
+                    self.save_file()
+            else:
+                self.change_save_dir_dialog()
+                return
+
+        if not self.may_continue():
+            return
+
+        if self.img_count <= 0:
+            return
+
+        if self.file_path is None:
+            return
+
+        if self.cur_img_idx - 1 >= 0:
+            self.cur_img_idx -= 1
+            filename = self.m_img_list[self.cur_img_idx]
+            if filename:
+                self.load_file(filename)
+
+    def open_next_image(self, _value=False):
+        # Proceeding next image without dialog if having any label
+        if self.auto_saving.isChecked():
+            if self.default_save_dir is not None:
+                if self.dirty is True:
+                    self.save_file()
+            else:
+                self.change_save_dir_dialog()
+                return
+
+        if not self.may_continue():
+            return
+
+        if self.img_count <= 0:
+            return
+        
+        if not self.m_img_list:
+            return
+
+        filename = None
+        if self.file_path is None:
+            filename = self.m_img_list[0]
+            self.cur_img_idx = 0
+        else:
+            if self.cur_img_idx + 1 < self.img_count:
+                self.cur_img_idx += 1
+                filename = self.m_img_list[self.cur_img_idx]
+
+        if filename:
+            self.load_file(filename)
+
+    def open_file(self, _value=False):
+        if not self.may_continue():
+            return
+        path = os.path.dirname(ustr(self.file_path)) if self.file_path else '.'
+        formats = ['*.%s' % fmt.data().decode("ascii").lower() for fmt in QImageReader.supportedImageFormats()]
+        filters = "Image & Label files (%s)" % ' '.join(formats + ['*%s' % LabelFile.suffix])
+        filename,_ = QFileDialog.getOpenFileName(self, '%s - Choose Image or Label file' % __appname__, path, filters)
+        if filename:
+            if isinstance(filename, (tuple, list)):
+                filename = filename[0]
+            self.cur_img_idx = 0
+            self.img_count = 1
+            self.load_file(filename)
+
+    def save_file(self, _value=False):
+        if self.default_save_dir is not None and len(ustr(self.default_save_dir)):
+            if self.file_path:
+                image_file_name = os.path.basename(self.file_path)
+                saved_file_name = os.path.splitext(image_file_name)[0]
+                saved_path = os.path.join(ustr(self.default_save_dir), saved_file_name)
+                self._save_file(saved_path)
+        else:
+            image_file_dir = os.path.dirname(self.file_path)
+            image_file_name = os.path.basename(self.file_path)
+            saved_file_name = os.path.splitext(image_file_name)[0]
+            saved_path = os.path.join(image_file_dir, saved_file_name)
+            self._save_file(saved_path if self.label_file
+                            else self.save_file_dialog(remove_ext=False))
+
+    def save_file_as(self, _value=False):
+        assert not self.image.isNull(), "cannot save empty image"
+        self._save_file(self.save_file_dialog())
+
+    def save_file_dialog(self, remove_ext=True):
+        caption = '%s - Choose File' % __appname__
+        filters = 'File (*%s)' % LabelFile.suffix
+        open_dialog_path = self.current_path()
+        dlg = QFileDialog(self, caption, open_dialog_path, filters)
+        dlg.setDefaultSuffix(LabelFile.suffix[1:])
+        dlg.setAcceptMode(QFileDialog.AcceptSave)
+        filename_without_extension = os.path.splitext(self.file_path)[0]
+        dlg.selectFile(filename_without_extension)
+        dlg.setOption(QFileDialog.DontUseNativeDialog, False)
+        if dlg.exec_():
+            full_file_path = ustr(dlg.selectedFiles()[0])
+            if remove_ext:
+                return os.path.splitext(full_file_path)[0]  # Return file path without the extension.
+            else:
+                return full_file_path
+        return ''
+
+    def _save_file(self, annotation_file_path):
+        if annotation_file_path and self.save_labels(annotation_file_path):
+            self.set_clean()
+            self.statusBar().showMessage('Saved to  %s' % annotation_file_path)
+            self.statusBar().show()
+            # Update gallery status after save
+            self._update_current_image_gallery_status()
+
+    def close_file(self, _value=False):
+        if not self.may_continue():
+            return
+        self.reset_state()
+        self.set_clean()
+        self.toggle_actions(False)
+        self.canvas.setEnabled(False)
+        self.actions.saveAs.setEnabled(False)
+
+    def delete_image(self):
+        delete_path = self.file_path
+        if delete_path is not None:
+            idx = self.cur_img_idx
+            if os.path.exists(delete_path):
+                os.remove(delete_path)
+            self.import_dir_images(self.last_open_dir)
+            if self.img_count > 0:
+                self.cur_img_idx = min(idx, self.img_count - 1)
+                filename = self.m_img_list[self.cur_img_idx]
+                self.load_file(filename)
+            else:
+                self.close_file()
+
+    def reset_all(self):
+        self.settings.reset()
+        self.close()
+        process = QProcess()
+        process.startDetached(os.path.abspath(__file__))
+
+    def may_continue(self):
+        if not self.dirty:
+            return True
+        else:
+            discard_changes = self.discard_changes_dialog()
+            if discard_changes == QMessageBox.No:
+                return True
+            elif discard_changes == QMessageBox.Yes:
+                self.save_file()
+                return True
+            else:
+                return False
+
+    def discard_changes_dialog(self):
+        yes, no, cancel = QMessageBox.Yes, QMessageBox.No, QMessageBox.Cancel
+        msg = u'You have unsaved changes, would you like to save them and proceed?\nClick "No" to undo all changes.'
+        return QMessageBox.warning(self, u'Attention', msg, yes | no | cancel)
+
+    def error_message(self, title, message):
+        return QMessageBox.critical(self, title,
+                                    '<p><b>%s</b></p>%s' % (title, message))
+
+    def current_path(self):
+        return os.path.dirname(self.file_path) if self.file_path else '.'
+
+    def choose_color1(self):
+        color = self.color_dialog.getColor(self.line_color, u'Choose line color',
+                                           default=DEFAULT_LINE_COLOR)
+        if color:
+            self.line_color = color
+            Shape.line_color = color
+            self.canvas.set_drawing_color(color)
+            self.canvas.update()
+            self.set_dirty()
+
+    def delete_selected_shape(self):
+        """Delete the currently selected shape with undo support."""
+        if self.canvas.selected_shape is None:
+            return
+        shape = self.canvas.selected_shape
+        index = self.canvas.shapes.index(shape) if shape in self.canvas.shapes else None
+
+        # Create and push command (command handles the actual deletion)
+        cmd = DeleteShapeCommand(self, shape, index)
+        cmd.execute()
+        self.undo_stack.push(cmd)
+        self.set_dirty()
+
+        if self.no_shapes():
+            for action in self.actions.onShapesPresent:
+                action.setEnabled(False)
+
+    def undo_action(self):
+        """Undo the last action."""
+        if self.undo_stack.can_undo():
+            self.undo_stack.undo()
+            self.set_dirty()
+            self.canvas.update()
+
+    def redo_action(self):
+        """Redo the last undone action."""
+        if self.undo_stack.can_redo():
+            self.undo_stack.redo()
+            self.set_dirty()
+            self.canvas.update()
+
+    def update_undo_redo_actions(self):
+        """Update the enabled state of undo/redo actions."""
+        self.actions.undo.setEnabled(self.undo_stack.can_undo())
+        self.actions.redo.setEnabled(self.undo_stack.can_redo())
+
+        # Update tooltips with descriptions
+        if self.undo_stack.can_undo():
+            desc = self.undo_stack.get_undo_description()
+            self.actions.undo.setToolTip(f"Undo: {desc}")
+        else:
+            self.actions.undo.setToolTip("Undo")
+
+        if self.undo_stack.can_redo():
+            desc = self.undo_stack.get_redo_description()
+            self.actions.redo.setToolTip(f"Redo: {desc}")
+        else:
+            self.actions.redo.setToolTip("Redo")
+
+    def choose_shape_line_color(self):
+        color = self.color_dialog.getColor(self.line_color, u'Choose Line Color',
+                                           default=DEFAULT_LINE_COLOR)
+        if color:
+            self.canvas.selected_shape.line_color = color
+            self.canvas.update()
+            self.set_dirty()
+
+    def choose_shape_fill_color(self):
+        color = self.color_dialog.getColor(self.fill_color, u'Choose Fill Color',
+                                           default=DEFAULT_FILL_COLOR)
+        if color:
+            self.canvas.selected_shape.fill_color = color
+            self.canvas.update()
+            self.set_dirty()
+
+    def copy_shape(self):
+        if self.canvas.selected_shape is None:
+            # True if one accidentally touches the left mouse button before releasing
+            return
+        self.canvas.end_move(copy=True)
+        self.add_label(self.canvas.selected_shape)
+        self.set_dirty()
+
+    def move_shape(self):
+        self.canvas.end_move(copy=False)
+        self.set_dirty()
+
+    def load_predefined_classes(self, predef_classes_file):
+        if os.path.exists(predef_classes_file) is True:
+            with codecs.open(predef_classes_file, 'r', 'utf8') as f:
+                for line in f:
+                    line = line.strip()
+                    if self.label_hist is None:
+                        self.label_hist = [line]
+                    else:
+                        self.label_hist.append(line)
+
+    def load_pascal_xml_by_filename(self, xml_path):
+        if self.file_path is None:
+            return
+        if os.path.isfile(xml_path) is False:
+            return
+
+        self.set_format(FORMAT_PASCALVOC)
+
+        t_voc_parse_reader = PascalVocReader(xml_path)
+        shapes = t_voc_parse_reader.get_shapes()
+        self.load_labels(shapes)
+        self.canvas.verified = t_voc_parse_reader.verified
+
+    def load_yolo_txt_by_filename(self, txt_path):
+        if self.file_path is None:
+            return
+        if os.path.isfile(txt_path) is False:
+            return
+
+        self.set_format(FORMAT_YOLO)
+        # Use original image size for YOLO coordinate conversion (Issue #31)
+        # YOLO stores normalized coords, so we need original dimensions
+        if hasattr(self, '_original_image_size') and self._original_image_size is not None:
+            # Create a mock image object with original dimensions
+            class MockImage:
+                def __init__(self, size, grayscale=False):
+                    self._size = size
+                    self._grayscale = grayscale
+                def width(self):
+                    return self._size.width()
+                def height(self):
+                    return self._size.height()
+                def isGrayscale(self):
+                    return self._grayscale
+            mock_img = MockImage(self._original_image_size, self.image.isGrayscale())
+            t_yolo_parse_reader = YoloReader(txt_path, mock_img)
+        else:
+            t_yolo_parse_reader = YoloReader(txt_path, self.image)
+        shapes = t_yolo_parse_reader.get_shapes()
+        self.load_labels(shapes)
+        self.canvas.verified = t_yolo_parse_reader.verified
+
+    def load_create_ml_json_by_filename(self, json_path, file_path):
+        if self.file_path is None:
+            return
+        if os.path.isfile(json_path) is False:
+            return
+
+        self.set_format(FORMAT_CREATEML)
+
+        create_ml_parse_reader = CreateMLReader(json_path, file_path)
+        shapes = create_ml_parse_reader.get_shapes()
+        self.load_labels(shapes)
+        self.canvas.verified = create_ml_parse_reader.verified
+
+    def copy_previous_bounding_boxes(self):
+        current_index = self._path_to_idx.get(self.file_path, 0)
+        if current_index - 1 >= 0:
+            prev_file_path = self.m_img_list[current_index - 1]
+            self.show_bounding_box_from_annotation_file(prev_file_path)
+            self.save_file()
+
+    def toggle_paint_labels_option(self):
+        for shape in self.canvas.shapes:
+            shape.paint_label = self.display_label_option.isChecked()
+
+    def toggle_draw_square(self):
+        self.canvas.set_drawing_shape_to_square(self.draw_squares_option.isChecked())
+
+    def change_icon_size(self):
+        """Change toolbar icon size based on user selection."""
+        action = self.sender()
+        if action:
+            size = action.data()
+            self.settings[SETTING_ICON_SIZE] = size
+
+            if size == 0:
+                # Auto mode - recalculate from DPI
+                from libs.toolBar import calculate_icon_size
+                size = calculate_icon_size()
+
+            # Update toolbar icon size
+            if hasattr(self, 'tools') and self.tools:
+                self.tools.update_icon_size(size)
+
+    # Auto-save timer methods (Issue #13)
+    def _toggle_auto_save_timer(self):
+        """Toggle timer-based auto-save."""
+        if self.auto_save_enabled.isChecked():
+            interval = self._get_current_auto_save_interval()
+            self.auto_save_timer.start(interval * 1000)  # Convert to ms
+        else:
+            self.auto_save_timer.stop()
+
+    def _set_auto_save_interval(self):
+        """Set auto-save interval from menu selection."""
+        action = self.sender()
+        if action:
+            interval = action.data()
+            if self.auto_save_enabled.isChecked():
+                self.auto_save_timer.start(interval * 1000)
+
+    def _get_current_auto_save_interval(self):
+        """Get currently selected auto-save interval in seconds."""
+        for action in self.auto_save_interval_group.actions():
+            if action.isChecked():
+                return action.data()
+        return 60  # Default 1 minute
+
+    def _auto_save_triggered(self):
+        """Called by timer to perform auto-save."""
+        if not self.dirty:
+            return  # Nothing to save
+
+        if not self.file_path:
+            return  # No file loaded
+
+        # Determine save path
+        if self.default_save_dir:
+            save_path = self._generate_save_path()
+        else:
+            save_path = self.file_path
+
+        if save_path:
+            self.status("Auto-saving...")
+            if self._save_file(save_path):
+                self.status("Auto-saved to %s" % os.path.basename(save_path))
+
+
+def inverted(color):
+    return QColor(*[255 - v for v in color.getRgb()])
+
+
+def read(filename, default=None):
+    try:
+        reader = QImageReader(filename)
+        reader.setAutoTransform(True)
+        image = reader.read()
+        if image.isNull():
+            return default
+        return image
+    except (IOError, OSError):
+        return default
+
+
+def get_main_app(argv=None):
+    """
+    Standard boilerplate Qt application code.
+    Do everything but app.exec_() -- so that we can test the application in one thread
+    """
+    if not argv:
+        argv = []
+
+    # Enable high-DPI scaling for better icon rendering on HiDPI displays
+    try:
+        QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
+        QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
+    except AttributeError:
+        pass  # Qt4 doesn't have these attributes
+
+    app = QApplication(argv)
+    app.setStyle('Fusion')  # Use Fusion style for consistent cross-platform styling
+    app.setStyleSheet(get_combined_style())  # Apply global stylesheet
+    app.setApplicationName(__appname__)
+    app.setWindowIcon(new_icon("app"))
+    # Tzutalin 201705+: Accept extra agruments to change predefined class file
+    argparser = argparse.ArgumentParser()
+    argparser.add_argument("image_dir", nargs="?")
+    argparser.add_argument("class_file",
+                           default=os.path.join(os.path.dirname(__file__), "data", "predefined_classes.txt"),
+                           nargs="?")
+    argparser.add_argument("save_dir", nargs="?")
+    args = argparser.parse_args(argv[1:])
+
+    args.image_dir = args.image_dir and os.path.normpath(args.image_dir)
+    args.class_file = args.class_file and os.path.normpath(args.class_file)
+    args.save_dir = args.save_dir and os.path.normpath(args.save_dir)
+
+    # Usage : labelImg.py image classFile saveDir
+    win = MainWindow(args.image_dir,
+                     args.class_file,
+                     args.save_dir)
+    win.show()
+    return app, win
+
+
+def main():
+    """construct main app and run it"""
+    app, _win = get_main_app(sys.argv)
+    return app.exec_()
+
+if __name__ == '__main__':
+    sys.exit(main())