cleanup, rename things

Author: RedHawk989

BabbleApp/BabbleCPU.py

@@ -15,7 +15,7 @@
 import importlib
 from osc import Tab
 from osc_calibrate_filter import *
-from eye import CamInfo, EyeInfoOrigin
+from tab import CamInfo, CamInfoOrigin
 from babble_model_loader import *
 import os
 os.environ["OMP_NUM_THREADS"] = "1"
@@ -36,7 +36,7 @@ async def delayed_setting_change(setting, value):
 
 
 
-class EyeProcessor:
+class BabbleProcessor:
     def __init__(
         self,
         config: "BabbleCameraConfig",
@@ -46,68 +46,35 @@ def __init__(
         capture_event: "threading.Event",
         capture_queue_incoming: "queue.Queue",
         image_queue_outgoing: "queue.Queue",
-        eye_id,
+        cam_id,
     ):
         self.main_config = BabbleSettingsConfig
         self.config = config
         self.settings = settings
-        self.eye_id = eye_id
+        self.cam_id = cam_id
         self.config_class = fullconfig
         # Cross-thread communication management
         self.capture_queue_incoming = capture_queue_incoming
         self.image_queue_outgoing = image_queue_outgoing
         self.cancellation_event = cancellation_event
         self.capture_event = capture_event
-        self.eye_id = eye_id
-
-        # Cross algo state
-        self.lkg_projected_sphere = None
-        self.xc = 20
-        self.yc = 20
-        self.cc_radius = 40
+        self.cam_id = cam_id
 
         # Image state
         self.previous_image = None
         self.current_image = None
         self.current_image_gray = None
         self.current_frame_number = None
         self.current_fps = None
-        self.threshold_image = None
-        self.thresh = None
-        # Calibration Values
-        self.xoff = 1
-        self.yoff = 1
-        # Keep large in order to recenter correctly
+
         self.calibration_frame_counter = None
-        self.eyeoffx = 1
-
-        self.xmax = -69420
-        self.xmin = 69420
-        self.ymax = -69420
-        self.ymin = 69420
-        self.blink_clear = False
-        self.cct = 200
+
         self.cccs = False
         self.ts = 10
         self.previous_rotation = self.config.rotation_angle
         self.roi_include_set = {"rotation_angle", "roi_window_x", "roi_window_y"}
 
-
-        self.out_y = 0.0
-        self.out_x = 0.0
-        self.rawx = 0.0
-        self.rawy = 0.0
-        self.eyeopen = 0.7
-        #blink
-        self.max_ints = []
-        self.max_int = 0
-        self.min_int = 4000000000000
-        self.frames = 0 
-
-        self.prev_x = None
-        self.prev_y = None
-        self.bd_blink = False
-        self.current_algo = EyeInfoOrigin.MODEL
+        self.current_algo = CamInfoOrigin.MODEL
         self.model = self.settings.gui_model_file
         self.use_gpu = self.settings.gui_use_gpu
         self.output = []
@@ -141,7 +108,7 @@ def __init__(
             beta=beta
         )
 
-    def output_images_and_update(self, threshold_image, output_information: CamInfo):
+    def output_images_and_update(self, output_information: CamInfo):
         try:
             image_stack = np.concatenate(
                 (
@@ -216,22 +183,9 @@ def capture_crop_rotate_image(self):
             pass
 
 
-    def UPDATE(self):
-
-        self.output_images_and_update(self.thresh, CamInfo(self.current_algo, self.out_x, self.out_y, 0, self.eyeopen))
-
-
-
-
-
     def run(self):
-        # Run the following somewhere
-        # self.daddy = External_Run_DADDY()
-
 
-        f = True
         while True:
-           # f = True
              # Check to make sure we haven't been requested to close
             if self.cancellation_event.is_set():
                 print("\033[94m[INFO] Exiting Tracking thread\033[0m")
@@ -277,5 +231,5 @@ def run(self):
             #else:
              #   pass
             #print(self.output)
-            self.output_images_and_update(self.thresh, CamInfo(self.current_algo, self.output))
+            self.output_images_and_update(CamInfo(self.current_algo, self.output))
 

BabbleApp/Benchmark/bench_hsrac.py

@@ -1,13 +1,12 @@
 import os
-import os
 import PySimpleGUI as sg
 import queue
 import requests
 import threading
 from babble_model_loader import *
 from camera_widget import CameraWidget
 from config import BabbleConfig
-from eye import CamInfo, Tab
+from tab import CamInfo, Tab
 from osc import VRChatOSCReceiver, VRChatOSC
 from general_settings_widget import SettingsWidget
 from algo_settings_widget import AlgoSettingsWidget
@@ -22,15 +21,11 @@
 # https://github.com/opencv/opencv/issues/17687
 os.environ["OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"] = "0"
 
-WINDOW_NAME = "EyeTrackApp"
-RIGHT_EYE_NAME = "-RIGHTEYEWIDGET-"
-LEFT_EYE_NAME = "-LEFTEYEWIDGET-"
+WINDOW_NAME = "Babble sApp"
+CAM_NAME = "-CAMWIDGET-"
 SETTINGS_NAME = "-SETTINGSWIDGET-"
 ALGO_SETTINGS_NAME = "-ALGOSETTINGSWIDGET-"
-
-LEFT_EYE_RADIO_NAME = "-LEFTEYERADIO-"
-RIGHT_EYE_RADIO_NAME = "-RIGHTEYERADIO-"
-BOTH_EYE_RADIO_NAME = "-BOTHEYERADIO-"
+CAM_RADIO_NAME = "-CAMRADIO-"
 SETTINGS_RADIO_NAME = "-SETTINGSRADIO-"
 ALGO_SETTINGS_RADIO_NAME = "-ALGOSETTINGSRADIO-"
 
@@ -90,7 +85,7 @@ def main():
     # start worker threads
     osc_thread.start()
 
-    eyes = [
+    cams = [
         CameraWidget(Tab.CAM, config, osc_queue),
     ]
 
@@ -103,63 +98,62 @@ def main():
         [
             sg.Radio(
                 "Cam",
-                "EYESELECTRADIO",
+                "TABSELECTRADIO",
                 background_color="#292929",
-                default=(config.eye_display_id == Tab.CAM),
-                key=RIGHT_EYE_RADIO_NAME,
+                default=(config.cam_display_id == Tab.CAM),
+                key=CAM_RADIO_NAME,
             ),
             sg.Radio(
                 "Settings",
-                "EYESELECTRADIO",
+                "TABSELECTRADIO",
                 background_color="#292929",
-                default=(config.eye_display_id == Tab.SETTINGS),
+                default=(config.cam_display_id == Tab.SETTINGS),
                 key=SETTINGS_RADIO_NAME,
             ),
             sg.Radio(
                 "Algo Settings",
-                "EYESELECTRADIO",
+                "TABSELECTRADIO",
                 background_color="#292929",
-                default=(config.eye_display_id == Tab.ALGOSETTINGS),
+                default=(config.cam_display_id == Tab.ALGOSETTINGS),
                 key=ALGO_SETTINGS_RADIO_NAME,
             ),
         ],
         [
             sg.Column(
-                eyes[0].widget_layout,
+                cams[0].widget_layout,
                 vertical_alignment="top",
-                key=RIGHT_EYE_NAME,
-                visible=(config.eye_display_id in [Tab.CAM]),
+                key=CAM_NAME,
+                visible=(config.cam_display_id in [Tab.CAM]),
                 background_color="#424042",
             ),
             sg.Column(
                 settings[0].widget_layout,
                 vertical_alignment="top",
                 key=SETTINGS_NAME,
-                visible=(config.eye_display_id in [Tab.SETTINGS]),
+                visible=(config.cam_display_id in [Tab.SETTINGS]),
                 background_color="#424042",
             ),
             sg.Column(
                 settings[1].widget_layout,
                 vertical_alignment="top",
                 key=ALGO_SETTINGS_NAME,
-                visible=(config.eye_display_id in [Tab.ALGOSETTINGS]),
+                visible=(config.cam_display_id in [Tab.ALGOSETTINGS]),
                 background_color="#424042",
             ),
         ],
     ]
 
 
-    if config.eye_display_id in [Tab.CAM]:
-        eyes[0].start()
-    if config.eye_display_id in [Tab.SETTINGS]:
+    if config.cam_display_id in [Tab.CAM]:
+        cams[0].start()
+    if config.cam_display_id in [Tab.SETTINGS]:
         settings[0].start()
-    if config.eye_display_id in [Tab.ALGOSETTINGS]:
+    if config.cam_display_id in [Tab.ALGOSETTINGS]:
         settings[1].start()
-        # self.main_config.eye_display_id
 
-    # the eye's needs to be running before it is passed to the OSC
+    # the cam needs to be running before it is passed to the OSC
     if config.settings.gui_ROSC:
-        osc_receiver = VRChatOSCReceiver(cancellation_event, config, eyes)
+        osc_receiver = VRChatOSCReceiver(cancellation_event, config, cams)
         osc_receiver_thread = threading.Thread(target=osc_receiver.run)
         osc_receiver_thread.start()
         ROSC = True
@@ -176,8 +170,8 @@ def main():
 
         # If we're in either mode and someone hits q, quit immediately
         if event == "Exit" or event == sg.WIN_CLOSED:
-            for eye in eyes:
-                eye.stop()
+            for cam in cams: #yes we only have one cam page but im just gonna leave this incase
+                cam.stop()
             cancellation_event.set()
             # shut down worker threads
             osc_thread.join()
@@ -188,46 +182,46 @@ def main():
             if ROSC:
                 osc_receiver.shutdown()
                 osc_receiver_thread.join()
-            print("\033[94m[INFO] Exiting EyeTrackApp\033[0m")
+            print("\033[94m[INFO] Exiting BabbleApp\033[0m")
             return
 
-        if values[RIGHT_EYE_RADIO_NAME] and config.eye_display_id != Tab.CAM:
-            eyes[0].start()
+        if values[CAM_RADIO_NAME] and config.cam_display_id != Tab.CAM:
+            cams[0].start()
             settings[0].stop()
             settings[1].stop()
-            window[RIGHT_EYE_NAME].update(visible=True)
+            window[CAM_NAME].update(visible=True)
             window[SETTINGS_NAME].update(visible=False)
             window[ALGO_SETTINGS_NAME].update(visible=False)
-            config.eye_display_id = Tab.CAM
+            config.cam_display_id = Tab.CAM
             config.save()
 
 
 
-        elif values[SETTINGS_RADIO_NAME] and config.eye_display_id != Tab.SETTINGS:
-            eyes[0].stop()
+        elif values[SETTINGS_RADIO_NAME] and config.cam_display_id != Tab.SETTINGS:
+            cams[0].stop()
             settings[1].stop()
             settings[0].start()
-            window[RIGHT_EYE_NAME].update(visible=False)
+            window[CAM_NAME].update(visible=False)
             window[SETTINGS_NAME].update(visible=True)
             window[ALGO_SETTINGS_NAME].update(visible=False)
-            config.eye_display_id = Tab.SETTINGS
+            config.cam_display_id = Tab.SETTINGS
             config.save()
 
 
-        elif values[ALGO_SETTINGS_RADIO_NAME] and config.eye_display_id != Tab.ALGOSETTINGS:
-            eyes[0].stop()
+        elif values[ALGO_SETTINGS_RADIO_NAME] and config.cam_display_id != Tab.ALGOSETTINGS:
+            cams[0].stop()
             settings[0].stop()
             settings[1].start()
-            window[RIGHT_EYE_NAME].update(visible=False)
+            window[CAM_NAME].update(visible=False)
             window[SETTINGS_NAME].update(visible=False)
             window[ALGO_SETTINGS_NAME].update(visible=True)
-            config.eye_display_id = Tab.ALGOSETTINGS
+            config.cam_display_id = Tab.ALGOSETTINGS
             config.save()
 
         # Otherwise, render all
-        for eye in eyes:
-            if eye.started():
-                eye.render(window, event, values)
+        for cam in cams:
+            if cam.started():
+                cam.render(window, event, values)
         for setting in settings:
             if setting.started():
                 setting.render(window, event, values)