ok-script 0.0.86__tar.gz → 0.0.96__tar.gz

{ok-script-0.0.86 → ok-script-0.0.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.86
+Version: 0.0.96
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking

{ok-script-0.0.86 → ok-script-0.0.96}/ok/OK.py

@@ -37,6 +37,9 @@ class OK:
         config['debug'] = config.get("debug", False)
         self.debug = config['debug']
         try:
+            if self.debug:
+                import win32api
+                win32api.SetConsoleCtrlHandler(self.console_handler, True)
             self.config = config
             self.init_device_manager()
             from ok.gui.debug.Screenshot import Screenshot
@@ -59,6 +62,7 @@ class OK:
             if self.config.get("use_gui"):
                 if not self.init_error:
                     self.app.show_main_window()
+                logger.debug('start app.exec()')
                 self.app.exec()
             else:
                 self.task_executor.start()
@@ -97,7 +101,7 @@ class OK:
         if template_matching is not None:
             coco_feature_json = self.config.get('template_matching').get('coco_feature_json')
             from ok.feature.FeatureSet import FeatureSet
-            self.feature_set = FeatureSet(coco_feature_json,
+            self.feature_set = FeatureSet(self.debug, coco_feature_json,
                                           default_horizontal_variance=template_matching.get(
                                               'default_horizontal_variance', 0),
                                           default_vertical_variance=template_matching.get('default_vertical_variance',
@@ -110,7 +114,7 @@ class OK:
                                           trigger_tasks=self.config.get('trigger_tasks', []),
                                           scenes=self.config['scenes'],
                                           feature_set=self.feature_set,
-                                          config_folder=self.config.get("config_folder"))
+                                          config_folder=self.config.get("config_folder"), debug=self.debug)
 
         ok.gui.executor = self.task_executor
 
@@ -135,6 +139,26 @@ class OK:
         while not self.exit_event.is_set():
             time.sleep(1)
 
+    def console_handler(self, event):
+        import win32con
+        if event == win32con.CTRL_C_EVENT:
+            logger.info("CTRL+C event dump threads")
+            from ok.capture.windows.dump import dump_threads
+            dump_threads()
+            self.quit()
+        elif event == win32con.CTRL_CLOSE_EVENT:
+            logger.info("Close event quit")
+            self.quit()
+        elif event == win32con.CTRL_LOGOFF_EVENT:
+            logger.info("Logoff event quit")
+            self.quit()
+        elif event == win32con.CTRL_SHUTDOWN_EVENT:
+            logger.info("Shutdown event quit")
+            self.quit()
+        else:  # Perform clean-up tasks here
+            print("Performing clean-up...")
+        return True
+
     def quit(self):
         logger.debug('quit app')
         self.exit_event.set()

{ok-script-0.0.86 → ok-script-0.0.96}/ok/capture/BaseCaptureMethod.py

@@ -24,20 +24,10 @@ class BaseCaptureMethod:
 
     @property
     def width(self):
-        if self._size[0] == 0:
-            try:
-                self.get_frame()
-            except Exception as e:
-                logger.error('width get frame error', e)
         return self._size[0]
 
     @property
     def height(self):
-        if self._size[1] == 0:
-            try:
-                self.get_frame()
-            except Exception as e:
-                logger.error('height get frame error', e)
         return self._size[1]
 
     def get_frame(self) -> np.ndarray | None:

{ok-script-0.0.86 → ok-script-0.0.96}/ok/capture/HwndWindow.py

@@ -29,7 +29,6 @@ class HwndWindow:
     left_cut = 0
     ext_left_bounds = 0  # for BitBlt
     ext_top_bounds = 0  # for BitBlt
-    window_change_listeners = []
     frame_aspect_ratio = 0
     hwnd = None
     frame_width = 0
@@ -178,10 +177,9 @@ def find_hwnd(title, exe_name, frame_width, frame_height, player_id=-1):
 
     win32gui.EnumWindows(callback, None)
     if len(results) > 0:
-        biggest = results[0]
+        biggest = None
         for result in results:
-            from ok.capture.windows.BitBltCaptureMethod import bit_blt_test_hwnd
-            if (biggest is None or (result[2] * result[3]) > biggest[2] * biggest[3]) and bit_blt_test_hwnd(result[0]):
+            if biggest is None or (result[2] * result[3]) > biggest[2] * biggest[3]:
                 biggest = result
         x_offset = 0
         y_offset = 0

{ok-script-0.0.86 → ok-script-0.0.96}/ok/capture/adb/DeviceManager.py

@@ -67,7 +67,7 @@ class DeviceManager:
                         logger.debug(f'adb_connect already connected {addr}')
                         return device
             if try_connect:
-                self.adb.connect(addr, timeout=5)
+                self.adb.connect(addr, timeout=3)
                 logger.debug(f'adb_connect {addr}')
                 return self.adb_connect(addr, try_connect=False)
         except AdbTimeout as e:
@@ -116,8 +116,8 @@ class DeviceManager:
             if imei is not None:
                 preferred = self.get_preferred_device()
                 if current and preferred is not None and preferred['imei'] != imei:
-                    logger.debug(f"refresh current only skip others {preferred['imei']} != imei")
-                    break
+                    logger.debug(f"refresh current only skip others {preferred['imei']} != {imei}")
+                    continue
                 found = False
                 for device in self.device_dict.values():
                     if device.get('adb_imei') == imei:
@@ -263,12 +263,12 @@ class DeviceManager:
             self.use_windows_capture()
             if not isinstance(self.interaction, Win32Interaction):
                 self.interaction = Win32Interaction(self.capture_method)
-            preferred['connected'] = self.capture_method.connected()
+            preferred['connected'] = self.capture_method is not None and self.capture_method.connected()
         else:
             width, height = self.get_resolution()
             if self.config.get('capture') == "windows":
                 self.ensure_hwnd(None, preferred.get('full_path'), width, height, preferred['player_id'])
-                self.use_windows_capture({'can_bit_blt': True}, require_bg=True, use_bit_blt_only=True)
+                self.use_windows_capture({'can_bit_blt': True}, require_bg=True, use_bit_blt_only=False)
             else:
                 if not isinstance(self.capture_method, ADBCaptureMethod):
                     logger.debug(f'use adb capture')

ok-script-0.0.96/ok/capture/adb/WindowsCaptureFactory.py

@@ -0,0 +1,42 @@
+from ok.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def update_capture_method(config, capture_method, hwnd, require_bg=False, use_bit_blt_only=False):
+    try:
+        if config.get('can_bit_blt'):
+            logger.debug(
+                f"try BitBlt method {config} {hwnd} current_type:{type(capture_method)}")
+            from ok.capture.windows.BitBltCaptureMethod import BitBltCaptureMethod
+            target_method = BitBltCaptureMethod
+            capture_method = get_capture(capture_method, target_method, hwnd)
+            if capture_method.test_is_not_pure_color():
+                return capture_method
+            else:
+                logger.info("test_is_not_pure_color failed, can't use BitBlt")
+        if use_bit_blt_only:
+            return None
+        from ok.capture.windows.WindowsGraphicsCaptureMethod import windows_graphics_available
+        if windows_graphics_available():
+            from ok.capture.windows.WindowsGraphicsCaptureMethod import WindowsGraphicsCaptureMethod
+            target_method = WindowsGraphicsCaptureMethod
+            capture_method = get_capture(capture_method, target_method, hwnd)
+            return capture_method
+
+        if not require_bg:
+            from ok.capture.windows.DesktopDuplicationCaptureMethod import DesktopDuplicationCaptureMethod
+            target_method = DesktopDuplicationCaptureMethod
+            capture_method = get_capture(capture_method, target_method, hwnd)
+            return capture_method
+    except Exception as e:
+        logger.error(f'update_capture_method exception, return None: ', e)
+
+
+def get_capture(capture_method, target_method, hwnd):
+    if not isinstance(capture_method, target_method):
+        if capture_method is not None:
+            capture_method.close()
+        capture_method = target_method(hwnd)
+    capture_method.hwnd_window = hwnd
+    return capture_method

{ok-script-0.0.86 → ok-script-0.0.96}/ok/capture/windows/BitBltCaptureMethod.py

@@ -10,7 +10,7 @@ from typing_extensions import override
 
 from ok.capture.windows.BaseWindowsCaptureMethod import BaseWindowsCaptureMethod
 from ok.capture.windows.utils import try_delete_dc, BGRA_CHANNEL_COUNT
-from ok.capture.windows.window import get_window_bounds
+from ok.color.Color import is_close_to_pure_color
 from ok.logging.Logger import get_logger
 
 # This is an undocumented nFlag value for PrintWindow
@@ -60,12 +60,17 @@ class BitBltCaptureMethod(BaseWindowsCaptureMethod):
             return False
         return True
 
-
-def bit_blt_test_hwnd(hwnd):
-    x, y, border, title_height, width, height, scaling, ext_left_bounds, ext_top_bounds = get_window_bounds(
-        hwnd)
-    frame = bit_blt_capture_frame(hwnd, border, title_height, width, height, ext_left_bounds, ext_top_bounds)
-    return frame is not None
+    def test_is_not_pure_color(self):
+        frame = self.do_get_frame()
+        if frame is None:
+            logger.error(f'Failed to test_is_not_pure_color frame is None {self.hwnd_window}')
+            return False
+        else:
+            if is_close_to_pure_color(frame):
+                logger.error(f'Failed to test_is_not_pure_color failed {self.hwnd_window}')
+                return False
+            else:
+                return True
 
 
 def bit_blt_capture_frame(hwnd, border, title_height, width, height, ext_left_bounds, ext_top_bounds,

{ok-script-0.0.86 → ok-script-0.0.96}/ok/capture/windows/WindowsGraphicsCaptureMethod.py

@@ -23,7 +23,7 @@ logger = get_logger(__name__)
 class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
     name = "Windows Graphics Capture"
     description = "fast, most compatible, capped at 60fps"
-    last_frame = None
+    last_dx_frame = None
     last_frame_time = 0
     frame_pool = None
     item = None
@@ -38,67 +38,78 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
 
     def frame_arrived_callback(self, x, y):
         try:
-            frame = self.frame_pool.TryGetNextFrame()
+            self.last_frame_time = time.time()
+            next_frame = self.frame_pool.TryGetNextFrame()
+            if next_frame is not None:
+                self.last_dx_frame = next_frame
+            else:
+                logger.warning('frame_arrived_callback TryGetNextFrame returned None')
         except Exception as e:
             logger.error(f"TryGetNextFrame error {e}")
             self.close()
             return
+
+    def convert_dx_frame(self):
+        frame = self.last_dx_frame
+        self.last_dx_frame = None
         if not frame:
+            logger.warning('convert_dx_frame self.last_dx_frame is none')
+            return None
+
+        need_reset_framepool = False
+        if frame.ContentSize.Width != self.last_size.Width or frame.ContentSize.Height != self.last_size.Height:
+            need_reset_framepool = True
+            self.last_size = frame.ContentSize
+
+        if need_reset_framepool:
+            logger.info('need_reset_framepool')
+            self.reset_framepool(frame.ContentSize)
             return
-        self.last_frame_time = time.time()
-        img = None
-        with frame:
-            need_reset_framepool = False
-            need_reset_device = False
-            if frame.ContentSize.Width != self.last_size.Width or frame.ContentSize.Height != self.last_size.Height:
-                need_reset_framepool = True
-                self.last_size = frame.ContentSize
+        need_reset_device = False
 
-            if need_reset_framepool:
-                self.reset_framepool(frame.ContentSize)
-                return
-            tex = None
+        tex = None
 
-            cputex = None
-            try:
-                from ok.rotypes.Windows.Graphics.DirectX.Direct3D11 import IDirect3DDxgiInterfaceAccess
-                from ok.rotypes.roapi import GetActivationFactory
-                tex = frame.Surface.astype(IDirect3DDxgiInterfaceAccess).GetInterface(
-                    d3d11.ID3D11Texture2D.GUID).astype(d3d11.ID3D11Texture2D)
-                desc = tex.GetDesc()
-                desc2 = d3d11.D3D11_TEXTURE2D_DESC()
-                desc2.Width = desc.Width
-                desc2.Height = desc.Height
-                desc2.MipLevels = desc.MipLevels
-                desc2.ArraySize = desc.ArraySize
-                desc2.Format = desc.Format
-                desc2.SampleDesc = desc.SampleDesc
-                desc2.Usage = d3d11.D3D11_USAGE_STAGING
-                desc2.CPUAccessFlags = d3d11.D3D11_CPU_ACCESS_READ
-                desc2.BindFlags = 0
-                desc2.MiscFlags = 0
-                cputex = self.dxdevice.CreateTexture2D(ctypes.byref(desc2), None)
-                self.immediatedc.CopyResource(cputex, tex)
-                mapinfo = self.immediatedc.Map(cputex, 0, d3d11.D3D11_MAP_READ, 0)
-                img = np.ctypeslib.as_array(ctypes.cast(mapinfo.pData, PBYTE),
-                                            (desc.Height, mapinfo.RowPitch // 4, 4))[
-                      :, :desc.Width].copy()
-                self.immediatedc.Unmap(cputex, 0)
-            except OSError as e:
-                if e.winerror == d3d11.DXGI_ERROR_DEVICE_REMOVED or e.winerror == d3d11.DXGI_ERROR_DEVICE_RESET:
-                    need_reset_framepool = True
-                    need_reset_device = True
-                else:
-                    raise
-            finally:
-                if tex is not None:
-                    tex.Release()
-                if cputex is not None:
-                    cputex.Release()
-            if need_reset_framepool:
-                self.reset_framepool(frame.ContentSize, need_reset_device)
-                return self.get_frame()
-        self.last_frame = img
+        cputex = None
+        try:
+            from ok.rotypes.Windows.Graphics.DirectX.Direct3D11 import IDirect3DDxgiInterfaceAccess
+            from ok.rotypes.roapi import GetActivationFactory
+            tex = frame.Surface.astype(IDirect3DDxgiInterfaceAccess).GetInterface(
+                d3d11.ID3D11Texture2D.GUID).astype(d3d11.ID3D11Texture2D)
+            desc = tex.GetDesc()
+            desc2 = d3d11.D3D11_TEXTURE2D_DESC()
+            desc2.Width = desc.Width
+            desc2.Height = desc.Height
+            desc2.MipLevels = desc.MipLevels
+            desc2.ArraySize = desc.ArraySize
+            desc2.Format = desc.Format
+            desc2.SampleDesc = desc.SampleDesc
+            desc2.Usage = d3d11.D3D11_USAGE_STAGING
+            desc2.CPUAccessFlags = d3d11.D3D11_CPU_ACCESS_READ
+            desc2.BindFlags = 0
+            desc2.MiscFlags = 0
+            cputex = self.dxdevice.CreateTexture2D(ctypes.byref(desc2), None)
+            self.immediatedc.CopyResource(cputex, tex)
+            mapinfo = self.immediatedc.Map(cputex, 0, d3d11.D3D11_MAP_READ, 0)
+            img = np.ctypeslib.as_array(ctypes.cast(mapinfo.pData, PBYTE),
+                                        (desc.Height, mapinfo.RowPitch // 4, 4))[
+                  :, :desc.Width].copy()
+            self.immediatedc.Unmap(cputex, 0)
+            return img
+        except OSError as e:
+            if e.winerror == d3d11.DXGI_ERROR_DEVICE_REMOVED or e.winerror == d3d11.DXGI_ERROR_DEVICE_RESET:
+                need_reset_framepool = True
+                need_reset_device = True
+                logger.error('convert_dx_frame win error', e)
+            else:
+                raise e
+        finally:
+            if tex is not None:
+                tex.Release()
+            if cputex is not None:
+                cputex.Release()
+        if need_reset_framepool:
+            self.reset_framepool(frame.ContentSize, need_reset_device)
+            return self.get_frame()
 
     @property
     def hwnd_window(self):
@@ -139,7 +150,7 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
                 self.evtoken = item.add_Closed(delegate)
                 self.frame_pool = Direct3D11CaptureFramePool.CreateFreeThreaded(self.rtdevice,
                                                                                 DirectXPixelFormat.B8G8R8A8UIntNormalized,
-                                                                                1, item.Size)
+                                                                                2, item.Size)
                 self.session = self.frame_pool.CreateCaptureSession(item)
                 pool = self.frame_pool
                 pool.add_FrameArrived(
@@ -193,10 +204,10 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
     @override
     def do_get_frame(self):
         if self.start_or_stop():
-            frame = self.last_frame
-            self.last_frame = None
+            frame = self.convert_dx_frame()
+            if frame is None:
+                return
             latency = time.time() - self.last_frame_time
-            self.last_frame_time = time.time()
 
             frame = self.crop_image(frame)
 
@@ -205,18 +216,20 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
                 if new_width <= 0 or new_width <= 0:
                     logger.warning(f"get_frame size <=0 {new_width}x{new_height}")
                     frame = None
-            if latency > 1:
+            if latency > 2:
                 logger.warning(f"latency too large return None frame: {latency}")
                 return None
             else:
+                # logger.debug(f'frame latency: {latency}')
                 return frame
 
     def reset_framepool(self, size, reset_device=False):
+        logger.info(f'reset_framepool')
         from ok.rotypes.Windows.Graphics.DirectX import DirectXPixelFormat
         if reset_device:
             self.create_device()
         self.frame_pool.Recreate(self.rtdevice,
-                                 DirectXPixelFormat.B8G8R8A8UIntNormalized, 1, size)
+                                 DirectXPixelFormat.B8G8R8A8UIntNormalized, 2, size)
 
     def crop_image(self, frame):
         if frame is not None:

ok-script-0.0.96/ok/capture/windows/dump.py

@@ -0,0 +1,81 @@
+import os
+import signal
+import sys
+import threading
+import traceback
+
+from ok.util.path import get_path_relative_to_exe
+
+
+def get_thread_name(thread_id):
+    for thread in threading.enumerate():
+        if thread.ident == thread_id:
+            return thread.name
+    return ""  # Return empty string if the thread name is not found
+
+
+def dump_threads():
+    # Get the stack trace for each thread
+    thread_dumps = []
+    for thread_id, frame in sys._current_frames().items():
+        thread_name = get_thread_name(thread_id)
+        thread_dump = f"Stack for thread {thread_id} (Name: {thread_name}):\n"
+        thread_dump += "".join(traceback.format_stack(frame))
+        thread_dumps.append(thread_dump)
+
+    # Write the thread dumps to a file
+    output_file = get_path_relative_to_exe(os.path.join('logs', "thread_dumps.txt"))
+    print(f'Dumping threads to {output_file}')
+
+    with open(output_file, "w", encoding='utf-8') as f:
+        f.write("\n\n".join(thread_dumps))
+
+    # subprocess.Popen(r'explorer /select,"{}"'.format(output_file))
+
+
+def kill_dump():
+    print("Killing dump")
+    dump_threads()
+    sys.exit(0)
+
+
+def console_handler(event):
+    import win32con
+    if event == win32con.CTRL_C_EVENT:
+        print("CTRL+C event")
+        dump_threads()
+        sys.exit(0)
+    elif event == win32con.CTRL_CLOSE_EVENT:
+        print("Close event")
+    elif event == win32con.CTRL_LOGOFF_EVENT:
+        print("Logoff event")
+    elif event == win32con.CTRL_SHUTDOWN_EVENT:
+        print("Shutdown event")
+    # Perform clean-up tasks here
+    print("Performing clean-up...")
+    # sys.exit(0)  # Exit the program
+    return True
+
+
+if __name__ == '__main__':
+
+    import psutil
+    import faulthandler
+
+    # Enable the fault handler
+    faulthandler.enable()
+
+    # Iterate over all running processes
+    for proc in psutil.process_iter(['pid', 'name', 'status', 'exe']):
+        # Check if the process is unresponsive
+        # print(proc.info['exe'])
+        if proc.info['name'] == 'python.exe':
+            # Dump the traceback
+            print(f'dump {proc.pid} {proc.cmdline()} {proc.info["pid"] == os.getpid()}')
+            # faulthandler.dump_traceback(file=sys.stderr, all_threads=True)
+            # Kill the process
+            # os.kill(proc.info['pid'], signal.SIGTERM)
+
+    # faulthandler.dump_traceback(file=sys.stderr, all_threads=True)
+    # Kill the process
+    os.kill(16916, signal.SIGTERM)

{ok-script-0.0.86 → ok-script-0.0.96}/ok/color/Color.py

@@ -1,3 +1,6 @@
+import os
+from collections import defaultdict
+
 import cv2
 import numpy as np
 
@@ -16,6 +19,29 @@ white_color = {
 }
 
 
+def is_close_to_pure_color(image, max_colors=5000, percent=0.97):
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    # Step 2: Initialize a dictionary to count color frequencies
+    color_counts = defaultdict(int)
+    # Step 3: Go through each pixel and count
+    for row in image:
+        for pixel in row:
+            # Convert the pixel tuple to a hashable type for counting
+            color = tuple(pixel)
+            color_counts[color] += 1
+            if len(color_counts) > max_colors:
+                return False
+
+    # Step 4: Find the most dominant color and its percentage
+    dominant_color = max(color_counts, key=color_counts.get)
+    dominant_count = color_counts[dominant_color]
+    total_pixels = image.shape[0] * image.shape[1]
+    percentage = (dominant_count / total_pixels)
+
+    return percentage > percent
+
+
 def calculate_colorfulness(image, box=None):
     if box is not None:
         image = image[box.y:box.y + box.height, box.x:box.x + box.width, :3]
@@ -146,3 +172,11 @@ def calculate_color_percentage(image, color_ranges, box=None):
     total_pixels = image.size / 3  # Divide by 3 for an RGB image
     percentage = target_pixels / total_pixels
     return percentage
+
+
+if __name__ == '__main__':
+    file = 'C:\\Users\\ok\Downloads\\ok-baijing (2)\\screenshots\\1.png'
+    exists = os.path.exists(file)
+    image = cv2.imread(file
+                       )
+    print(is_close_to_pure_color(image))

ok-script-0.0.96/ok/feature/CompressCoco.py

@@ -0,0 +1,75 @@
+import json
+import os
+import sys
+
+import cv2
+import numpy as np
+from PIL import Image
+from PIL.PngImagePlugin import PngInfo
+
+from ok.feature.FeatureSet import read_from_json
+
+
+def compress_coco(coco_json, canny_upper, canny_lower) -> None:
+    feature_dict, *_ = read_from_json(coco_json, canny_lower=canny_lower, canny_upper=canny_upper)
+    with open(coco_json, 'r') as file:
+        image_dict = {}
+        data = json.load(file)
+        coco_folder = os.path.dirname(coco_json)
+        image_map = {image['id']: image['file_name'] for image in data['images']}
+        category_map = {category['id']: category['name'] for category in data['categories']}
+
+        for annotation in data['annotations']:
+            image_id = annotation['image_id']
+            category_id = annotation['category_id']
+
+            feature = feature_dict.get(category_map[category_id])
+            if feature:
+                # Load and scale the image
+                image_path = str(os.path.join(coco_folder, image_map[image_id]))
+                image_features = image_dict.get(image_path, [])
+                image_features.append(feature)
+                image_dict[image_path] = image_features
+
+        # Loop through the image_dict and write all the image_feature associated with it in a new PNG
+        for image_path, features in image_dict.items():
+            background = None
+            for feature in features:
+                # Create a white background
+                if background is None:
+                    original_image = cv2.imread(image_path)
+                    background = np.full_like(original_image,
+                                              255)  # Create white background with the same shape as original_image
+
+                # Paste the feature onto the background
+                x, y = feature.x, feature.y
+                h, w = feature.mat.shape[:2]
+                background[y:y + h, x:x + w] = feature.mat
+
+            # Add metadata
+            metadata = {
+                "ok_compressed": "1"
+            }
+
+            # Save the image with metadata
+            save_image_with_metadata(background, image_path)
+
+
+def save_image_with_metadata(image, image_path):
+    # Convert OpenCV image (numpy array) to PIL Image
+    pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+
+    metadata = PngInfo()
+
+    # Add metadata
+    metadata.add_text('ok_compressed', '1')
+    metadata.add_text("Author", "ok_compress")
+    metadata.add_text("Description", "This is a sample image")
+
+    # Save the image with metadata
+    pil_image.save(image_path, 'PNG', optimize=True, pnginfo=metadata)
+
+
+if __name__ == '__main__':
+    json_file = sys.argv[1]
+    compress_coco(json_file)

{ok-script-0.0.86 → ok-script-0.0.96}/ok/feature/Feature.py

@@ -2,7 +2,7 @@ import numpy as np
 
 
 class Feature:
-    def __init__(self, mat: np.ndarray, x: int, y: int, width: int, height: int) -> None:
+    def __init__(self, mat: np.ndarray, x: int, y: int) -> None:
         """
         Initialize a Feature with an image (Mat) and its bounding box coordinates.
 
@@ -14,10 +14,16 @@ class Feature:
             height (int): The height of the bounding box.
         """
         self.mat = mat
-        self.x = x
-        self.y = y
-        self.width = width
-        self.height = height
+        self.x = round(x)
+        self.y = round(y)
+
+    @property
+    def width(self):
+        return self.mat.shape[1]
+
+    @property
+    def height(self):
+        return self.mat.shape[0]
 
     def __str__(self) -> str:
         return f'self.x: {self.x}, self.y: {self.y}, width: {self.width}, height: {self.height}'