Merge branch 'main' of https://github.com/RamesTheGeneric/ProjectBabble

Author: RamesTheGeneric

BabbleApp/Locale/English/locale.json

@@ -16,6 +16,7 @@
 	"general.recalibrate": "Recalibrate Address",
 	"general.recalibrateTooltip": "OSC address we use for recalibrating",
 	"general.uvcCameraSettings": "UVC Camera Settings",
+	"general.windowFocus": "Interface Paused",
 	"general.useRedChannel": "Use Red Channel",
 	"general.useRedChannelTooltip": "Uses only the red channel for Omnicept capture",
 	"general.xResolution": "X Resolution",

BabbleApp/Locale/OwO/locale.json

@@ -16,6 +16,7 @@
 	"general.recalibrate": "Wecawibwate Addwess :3",
 	"general.recalibrateTooltip": "OSC addwess we use fow wecawibwating OwO",
 	"general.uvcCameraSettings": "UVC Camewa Settings UwU",
+	"general.windowFocus": "Intwaface Pawused",
 	"general.useRedChannel": "Use Wed Channew >w<",
 	"general.useRedChannelTooltip": "Uses onwy the wed channew fow Omnicept captuwe nya~",
 	"general.xResolution": "X Wesowution :3",

BabbleApp/Locale/Pirate Speak/locale.json

@@ -16,6 +16,7 @@
 	"general.recalibrate": "Recalibrate Yer Bearings",
 	"general.recalibrateTooltip": "OSC bearings we use fer recalibratin'",
 	"general.uvcCameraSettings": "Spyglass Settings",
+	"general.windowFocus": "Interfayce Be Paused",
 	"general.useRedChannel": "Use th' Red Channel",
 	"general.useRedChannelTooltip": "Uses only th' red channel fer Omnicept plunderin'",
 	"general.xResolution": "X Marks th' Spot",

BabbleApp/babble_processor.py

@@ -51,6 +51,7 @@ def __init__(
         capture_queue_incoming: "queue.Queue(maxsize=2)",
         image_queue_outgoing: "queue.Queue(maxsize=2)",
         cam_id,
+        osc_queue: queue.Queue,
     ):
         self.main_config = BabbleSettingsConfig
         self.config = config
@@ -63,6 +64,7 @@ def __init__(
         self.cancellation_event = cancellation_event
         self.capture_event = capture_event
         self.cam_id = cam_id
+        self.osc_queue = osc_queue
 
         # Image state
         self.previous_image = None
@@ -130,15 +132,19 @@ def output_images_and_update(self, output_information: CamInfo):
                 axis=1,
             )
             self.image_queue_outgoing.put((image_stack, output_information))
+            if self.image_queue_outgoing.qsize() > 1:
+                self.image_queue_outgoing.get()
+                
             self.previous_image = self.current_image
             self.previous_rotation = self.config.rotation_angle
+
+            # Relay information to OSC
+            self.osc_queue.put((None, output_information))
         except:  # If this fails it likely means that the images are not the same size for some reason.
             print(
                 f'\033[91m[{lang._instance.get_string("log.error")}] {lang._instance.get_string("error.size")}.\033[0m'
             )
 
-            pass
-
     def capture_crop_rotate_image(self):
         # Get our current frame
 
@@ -225,7 +231,7 @@ def run(self):
                     self.current_image,
                     self.current_frame_number,
                     self.current_fps,
-                ) = self.capture_queue_incoming.get(block=True, timeout=0.2)
+                ) = self.capture_queue_incoming.get(block=True, timeout=0.1)
             except queue.Empty:
                 # print("No image available")
                 continue
@@ -250,10 +256,10 @@ def run(self):
             run_model(self)
             if self.settings.use_calibration:
                 self.output = cal.cal_osc(self, self.output)
-
             # else:
             #   pass
             # print(self.output)
+            
             self.output_images_and_update(CamInfo(self.current_algo, self.output))
 
     def get_framesize(self):

BabbleApp/babbleapp.py

@@ -129,7 +129,7 @@ def main():
     # Check to see if we have an ROI. If not, bring up ROI finder GUI.
 
     # Spawn worker threads
-    osc_queue: queue.Queue[tuple[bool, int, int]] = queue.Queue(maxsize=2)
+    osc_queue: queue.Queue[tuple[bool, int, int]] = queue.Queue(maxsize=10)
     osc = VRChatOSC(cancellation_event, osc_queue, config)
     osc_thread = threading.Thread(target=osc.run)
     # start worker threads
@@ -206,6 +206,8 @@ def main():
                 background_color=bg_color_highlight,
             ),
         ],
+        # Keep at bottom!
+        [sg.Text(f'- - -  {lang._instance.get_string("general.windowFocus")}  - - -', key="-WINFOCUS-", background_color=bg_color_clear, text_color="#F0F0F0", justification="center", expand_x=True, visible=False)],
     ]
 
     if config.cam_display_id in [Tab.CAM]:
@@ -229,10 +231,12 @@ def main():
         f"{appversion}", layout, icon="Images/logo.ico", background_color=bg_color_clear
     )
 
+    tint = 33
+    fs = False
     # GUI Render loop
     while True:
         # First off, check for any events from the GUI
-        event, values = window.read(timeout=1)
+        event, values = window.read(timeout=tint)
 
         # If we're in either mode and someone hits q, quit immediately
         if event in ("Exit", sg.WIN_CLOSED):
@@ -258,6 +262,25 @@ def main():
             )
             return
 
+        try:
+            # If window isn't in focus increase timeout and stop loop early
+            if window.TKroot.focus_get():
+                if fs:
+                    fs = False
+                    tint = 33
+                    window["-WINFOCUS-"].update(visible=False)
+                    window["-WINFOCUS-"].hide_row()
+                    window.refresh()
+            else:
+                if not fs:
+                    fs = True
+                    tint = 100
+                    window["-WINFOCUS-"].update(visible=True)
+                    window["-WINFOCUS-"].unhide_row()
+                continue
+        except KeyError:
+            pass
+
         if values[CAM_RADIO_NAME] and config.cam_display_id != Tab.CAM:
             cams[0].start()
             settings[0].stop()

BabbleApp/babbleapp.spec

@@ -6,7 +6,7 @@ block_cipher = None
 a = Analysis(['babbleapp.py'],
              pathex=[],
              binaries=[],
-             datas=[("Audio/*", "Audio"), ("Images/*", "Images/")],
+             datas=[("Audio", "Audio"), ("Images", "Images"), ("Locale", "Locale"), ("Models", "Models")],
              hiddenimports=[],
              hookspath=[],
              runtime_hooks=[],

BabbleApp/camera.py

@@ -12,17 +12,17 @@
 from config import BabbleConfig, BabbleSettingsConfig
 from utils.misc_utils import get_camera_index_by_name, list_camera_names
 from enum import Enum
+import sys
 
 WAIT_TIME = 0.1
+BUFFER_SIZE = 32768
 MAX_RESOLUTION: int = 600
-
 # Serial communication protocol:
-# header-begin (2 bytes)
-# header-type (2 bytes)
-# packet-size (2 bytes)
-# packet (packet-size bytes)
-ETVR_HEADER = b"\xff\xa0"
-ETVR_HEADER_FRAME = b"\xff\xa1"
+#  header-begin (2 bytes) "\xff\xa0"
+#  header-type (2 bytes)  "\xff\xa1"
+#  packet-size (2 bytes)
+#  packet (packet-size bytes)
+ETVR_HEADER = b"\xff\xa0\xff\xa1"
 ETVR_HEADER_LEN = 6
 
 
@@ -48,8 +48,6 @@ def __init__(
         self.settings = settings
         self.camera_index = camera_index
         self.camera_list = list_camera_names()
-        # The variable is not used
-        # self.camera_address = config.capture_source
         self.camera_status_outgoing = camera_status_outgoing
         self.camera_output_outgoing = camera_output_outgoing
         self.capture_event = capture_event
@@ -59,15 +57,10 @@ def __init__(
 
         self.serial_connection = None
         self.last_frame_time = time.time()
-        self.frame_number = 0
         self.fps = 0
         self.bps = 0
         self.start = True
         self.buffer = b""
-        self.pf_fps = 0
-        self.prevft = 0
-        self.newft = 0
-        self.fl = [0]
         self.FRAME_SIZE = [0, 0]
 
         self.error_message = f'{Fore.YELLOW}[{lang._instance.get_string("log.warn")}] {lang._instance.get_string("info.enterCaptureOne")} {{}} {lang._instance.get_string("info.enterCaptureTwo")}{Fore.RESET}'
@@ -175,28 +168,18 @@ def get_cv2_camera_picture(self, should_push):
                 raise RuntimeError(lang._instance.get_string("error.frame"))
             self.FRAME_SIZE = image.shape
             frame_number = self.cv2_camera.get(cv2.CAP_PROP_POS_FRAMES)
-            # Calculate the fps.
-            yeah = time.time()
-            delta_time = yeah - self.last_frame_time
-            self.last_frame_time = yeah
-            if delta_time > 0:
-                self.bps = len(image) / delta_time
-            self.frame_number = self.frame_number + 1
-            self.fps = (self.fps + self.pf_fps) / 2
-            self.newft = time.time()
-            self.fps = 1 / (self.newft - self.prevft)
-            self.prevft = self.newft
-            self.fps = int(self.fps)
-            if len(self.fl) < 60:
-                self.fl.append(self.fps)
-            else:
-                self.fl.pop(0)
-                self.fl.append(self.fps)
-            self.fps = sum(self.fl) / len(self.fl)
-            # self.bps = image.nbytes
+            # Calculate FPS
+            current_frame_time = time.time()    # Should be using "time.perf_counter()", not worth ~3x cycles?
+            delta_time = current_frame_time - self.last_frame_time
+            self.last_frame_time = current_frame_time
+            current_fps = 1 / delta_time if delta_time > 0 else 0
+            # Exponential moving average (EMA). ~1100ns savings, delicious..
+            self.fps = 0.02 * current_fps + 0.98 * self.fps
+            self.bps = image.nbytes * self.fps
+
             if should_push:
-                self.push_image_to_queue(image, frame_number, self.fps)
-        except Exception as e:
+                self.push_image_to_queue(image, frame_number + 1, self.fps)
+        except Exception:
             print(
                 f'{Fore.YELLOW}[{lang._instance.get_string("log.warn")}] {lang._instance.get_string("warn.captureProblem")}{Fore.RESET}'
             )
@@ -207,7 +190,7 @@ def get_next_packet_bounds(self):
         beg = -1
         while beg == -1:
             self.buffer += self.serial_connection.read(2048)
-            beg = self.buffer.find(ETVR_HEADER + ETVR_HEADER_FRAME)
+            beg = self.buffer.find(ETVR_HEADER)
         # Discard any data before the frame header.
         if beg > 0:
             self.buffer = self.buffer[beg:]
@@ -225,7 +208,8 @@ def get_next_jpeg_frame(self):
 
     def get_serial_camera_picture(self, should_push):
         conn = self.serial_connection
-        if conn is None:
+        # Stop spamming "Serial capture source problem" if connection is lost
+        if conn is None or self.camera_status == CameraState.DISCONNECTED:
             return
         try:
             if conn.in_waiting:
@@ -240,34 +224,25 @@ def get_serial_camera_picture(self, should_push):
                             f'{Fore.YELLOW}[{lang._instance.get_string("log.warn")}] {lang._instance.get_string("warn.frameDrop")}{Fore.RESET}'
                         )
                         return
-                    # Discard the serial buffer. This is due to the fact that it
-                    # may build up some outdated frames. A bit of a workaround here tbh.
-                    if conn.in_waiting >= 32768:
-                        print(
-                            f'{Fore.CYAN}[{lang._instance.get_string("log.info")}] {lang._instance.get_string("info.discardingSerial")} ({conn.in_waiting} bytes){Fore.RESET}'
-                        )
-                        conn.reset_input_buffer()
-                        self.buffer = b""
-                    # Calculate the fps.
-                    yeah = time.time()
-                    delta_time = yeah - self.last_frame_time
-                    self.last_frame_time = yeah
-                    if delta_time > 0:
-                        self.bps = len(jpeg) / delta_time
-                    self.fps = (self.fps + self.pf_fps) / 2
-                    self.newft = time.time()
-                    self.fps = 1 / (self.newft - self.prevft)
-                    self.prevft = self.newft
-                    self.fps = int(self.fps)
-                    if len(self.fl) < 60:
-                        self.fl.append(self.fps)
-                    else:
-                        self.fl.pop(0)
-                        self.fl.append(self.fps)
-                    self.fps = sum(self.fl) / len(self.fl)
-                    self.frame_number = self.frame_number + 1
+                    # Calculate FPS
+                    current_frame_time = time.time()    # Should be using "time.perf_counter()", not worth ~3x cycles?
+                    delta_time = current_frame_time - self.last_frame_time
+                    self.last_frame_time = current_frame_time
+                    current_fps = 1 / delta_time if delta_time > 0 else 0
+                    # Exponential moving average (EMA). ~1100ns savings, delicious..
+                    self.fps = 0.02 * current_fps + 0.98 * self.fps
+                    self.bps = len(jpeg) * self.fps
+
                     if should_push:
-                        self.push_image_to_queue(image, self.frame_number, self.fps)
+                        self.push_image_to_queue(image, int(current_fps), self.fps)
+                # Discard the serial buffer. This is due to the fact that it,
+                # may build up some outdated frames. A bit of a workaround here tbh.
+                # Do this at the end to give buffer time to refill.
+                if conn.in_waiting >= BUFFER_SIZE:
+                    print(f'{Fore.CYAN}[{lang._instance.get_string("log.info")}] {lang._instance.get_string("info.discardingSerial")} ({conn.in_waiting} bytes){Fore.RESET}')
+                    conn.reset_input_buffer()
+                    self.buffer = b""
+
         except Exception:
             print(
                 f'{Fore.YELLOW}[{lang._instance.get_string("log.warn")}] {lang._instance.get_string("info.serialCapture")}{Fore.RESET}'
@@ -288,11 +263,10 @@ def start_serial_connection(self, port):
         if not any(p for p in com_ports if port in p):
             return
         try:
-            conn = serial.Serial(
-                baudrate=3000000, port=port, xonxoff=False, dsrdtr=False, rtscts=False
-            )
+            rate = 115200 if sys.platform == "darwin" else 3000000  # Higher baud rate not working on macOS
+            conn = serial.Serial(baudrate=rate, port=port, xonxoff=False, dsrdtr=False, rtscts=False)
             # Set explicit buffer size for serial.
-            conn.set_buffer_size(rx_size=32768, tx_size=32768)
+            conn.set_buffer_size(rx_size=BUFFER_SIZE, tx_size=BUFFER_SIZE)
 
             print(
                 f'{Fore.CYAN}[{lang._instance.get_string("log.info")}] {lang._instance.get_string("info.ETVRConnected")} {port}{Fore.RESET}'

BabbleApp/camera_widget.py

@@ -75,6 +75,7 @@ def __init__(self, widget_id: Tab, main_config: BabbleConfig, osc_queue: Queue):
             self.capture_queue,
             self.image_queue,
             self.cam_id,
+            self.osc_queue,
         )
 
         self.camera_status_queue = Queue(maxsize=2)
@@ -262,18 +263,15 @@ def __init__(self, widget_id: Tab, main_config: BabbleConfig, osc_queue: Queue):
         self.figure = None
         self.is_mouse_up = True
         self.in_roi_mode = False
-        self.movavg_fps_queue = deque(maxlen=120)
-        self.movavg_bps_queue = deque(maxlen=120)
+        self.bps = 0
 
     def _movavg_fps(self, next_fps):
-        self.movavg_fps_queue.append(next_fps)
-        fps = round(sum(self.movavg_fps_queue) / len(self.movavg_fps_queue))
-        millisec = round((1 / fps if fps else 0) * 1000)
-        return f"{fps} FPS {millisec} MS"
+        # next_fps is already averaged
+        return f"{round(next_fps)} FPS {round((1 / next_fps if next_fps else 0) * 1000)} ms"
 
     def _movavg_bps(self, next_bps):
-        self.movavg_bps_queue.append(next_bps)
-        return f"{sum(self.movavg_bps_queue) / len(self.movavg_bps_queue) * 0.001 * 0.001 * 8:.3f} Mbps"
+        self.bps = round(0.02 * next_bps + 0.98 * self.bps)
+        return f"{self.bps * 0.001 * 0.001 * 8:.3f} Mbps"
 
     def started(self):
         return not self.cancellation_event.is_set()
@@ -518,8 +516,5 @@ def render(self, window, event, values):
                 imgbytes = cv2.imencode(".ppm", maybe_image)[1].tobytes()
                 window[self.gui_tracking_image].update(data=imgbytes)
 
-                # Relay information to OSC
-                if cam_info.info_type != CamInfoOrigin.FAILURE:
-                    self.osc_queue.put((self.cam_id, cam_info))
             except Empty:
                 pass

BabbleApp/landmark_processor.py

@@ -117,7 +117,7 @@ def __init__(
 
     def get_frame(self):
         return self.current_image_gray_clean
-    
+
     def infer_frame(self, image):
         return write_image(self, image)
 
@@ -130,12 +130,14 @@ def output_images_and_update(self, output_information: CamInfo):
                 axis=1,
             )
             self.image_queue_outgoing.put((image_stack, output_information))
+            if self.image_queue_outgoing.qsize() > 1:
+                self.image_queue_outgoing.get()
+
             self.previous_image = self.current_image
             self.previous_rotation = self.config.rotation_angle
         except: # If this fails it likely means that the images are not the same size for some reason.
             print('\033[91m[{lang._instance.get_string("log.error")}] Size of frames to display are of unequal sizes.\033[0m')
 
-            pass
     def capture_crop_rotate_image(self):
         # Get our current frame