Merge branch 'autocalibrator' into main

Author: SummerSigh

BabbleApp/Locale/Afrikaans/locale.json

@@ -150,6 +150,8 @@
 	"calibration.maxLeftValue": "Max Left Value",
 	"calibration.minRightValue": "Min Right Value",
 	"calibration.maxRightValue": "Max Right Value",
+	"algorithm.clearCalibration": "Clear Calibration",
+	"algorithm.clearCalibrationTooltip": "Reset all calibration values to their defaults",
 	"general.theme": "Theme",
 	"general.theme.system": "System",
 	"general.theme.light": "Light",

BabbleApp/Locale/English/locale.json

@@ -24,6 +24,7 @@ def __init__(
         self.gui_gpu_index = f"GPUINDEX{widget_id}"
         self.calib_deadzone = f"CALIBDEADZONE{widget_id}"
         self.main_config = main_config
+        self.main_config.settings.widget_id = widget_id
         self.config = main_config.settings
         self.osc_queue = osc_queue
         self.runtime_list = ("Default (ONNX)", "ONNX")
@@ -153,6 +154,14 @@ def __init__(
                     background_color=bg_color_highlight,
                 ),
             ],
+            [
+                sg.Button(
+                    lang._instance.get_string("algorithm.clearCalibration"),
+                    key=f"-CLEARCALIBRATION{widget_id}-",
+                    button_color=("white", "#d9534f"),
+                    tooltip=lang._instance.get_string("algorithm.clearCalibrationTooltip"),
+                ),
+            ],
         ]
 
         self.cancellation_event = (
@@ -200,6 +209,12 @@ def render(self, window, event, values):
                 window[self.gui_inference_threads].update(value)
                 values[self.gui_inference_threads] = value
 
+        # --- Begin patch: handle clear calibration button ---
+        if event == f"-CLEARCALIBRATION{self.main_config.settings.widget_id}-":
+            if hasattr(self.main_config.settings, "calibration_filter") and hasattr(self.main_config.settings.calibration_filter, "clear_calibration"):
+                self.main_config.settings.calibration_filter.clear_calibration()
+                sg.popup(lang._instance.get_string("algorithm.calibrationCleared"), title="Calibration Reset")
+        # --- End patch ---
         elif event == self.gui_gpu_index:
             value = values[self.gui_gpu_index]
             if not is_valid_int_input(value):

BabbleApp/algo_settings_widget.py

@@ -137,6 +137,18 @@ def __init__(
         self.one_euro_filter = OneEuroFilter(
             noisy_point, min_cutoff=min_cutoff, beta=beta
         )
+        # Persistent calibrator instance for continuous calibration
+        self._calibrator = None
+
+    def process_output(self, output_array):
+        # Called after model inference, applies calibration if enabled
+        if self.settings.use_calibration:
+            if self._calibrator is None or (hasattr(self._calibrator, 'calibrator') and self._calibrator.calibrator is not None and self._calibrator.calibrator.num_blendshapes != len(output_array)):
+                from osc_calibrate_filter import cal
+                self._calibrator = cal(self.settings)
+            return self._calibrator.cal_osc(output_array)
+        else:
+            return output_array
 
     def output_images_and_update(self, output_information: CamInfo):
         try:
@@ -267,8 +279,11 @@ def run(self):
             )  # copy this frame to have a clean image for blink algo
 
             run_model(self)
-            if self.settings.use_calibration:
-                self.output = cal.cal_osc(self, self.output)
+            # Replace the old calibration logic with the new persistent calibrator usage
+            # if self.settings.use_calibration:
+            #     self.output = cal(self.settings).cal_osc(self.output)
+            # New code:
+            self.output = self.process_output(self.output)
             # else:
             #   pass
             # print(self.output)

BabbleApp/babble_processor.py

@@ -378,13 +378,13 @@ async def main_loop(window, config, cams, settings, thread_manager):
             config.cam_display_id = Tab.SETTINGS
             config.save()
 
-        elif (
+        elif (  
             values[UIConstants.ALGO_SETTINGS_RADIO_NAME]
             and config.cam_display_id != Tab.ALGOSETTINGS
         ):
             cams[0].stop()
             settings[0].stop()
-            settings[2].stop()
+            settings[2].stop()  
             settings[1].start()
             window[UIConstants.CAM_NAME].update(visible=False)
             window[UIConstants.SETTINGS_NAME].update(visible=False)

BabbleApp/babbleapp.py

@@ -11,7 +11,7 @@
 import serial.tools.list_ports
 from lang_manager import LocaleStringManager as lang
 from colorama import Fore
-from config import BabbleConfig, BabbleSettingsConfig
+from config import BabbleConfig, BabbleSettingsConfig, BabbleCameraConfig
 from PIL import Image
 from io import BytesIO
 from utils.misc_utils import get_camera_index_by_name, list_camera_names, os_type

BabbleApp/camera.py

@@ -33,8 +33,6 @@ def __init__(self, widget_id: Tab, main_config: BabbleConfig, osc_queue: Queue):
         self.gui_tracking_fps = f"-TRACKINGFPS{widget_id}-"
         self.gui_tracking_bps = f"-TRACKINGBPS{widget_id}-"
         self.gui_output_graph = f"-OUTPUTGRAPH{widget_id}-"
-        self.gui_restart_calibration = f"-RESTARTCALIBRATION{widget_id}-"
-        self.gui_stop_calibration = f"-STOPCALIBRATION{widget_id}-"
         self.gui_mode_readout = f"-APPMODE{widget_id}-"
         self.gui_roi_message = f"-ROIMESSAGE{widget_id}-"
         self.gui_vertical_flip = f"-VERTICALFLIP{widget_id}-"
@@ -128,22 +126,6 @@ def __init__(self, widget_id: Tab, main_config: BabbleConfig, osc_queue: Queue):
                     tooltip=lang._instance.get_string("camera.rotationTooltip"),
                 ),
             ],
-            [
-                sg.Button(
-                    lang._instance.get_string("camera.startCalibration"),
-                    key=self.gui_restart_calibration,
-                    button_color=button_color,
-                    tooltip=lang._instance.get_string("camera.startCalibrationTooltip"),
-                    disabled=not self.settings_config.use_calibration,
-                ),
-                sg.Button(
-                    lang._instance.get_string("camera.stopCalibration"),
-                    key=self.gui_stop_calibration,
-                    button_color=button_color,
-                    tooltip=lang._instance.get_string("camera.startCalibrationTooltip"),
-                    disabled=not self.settings_config.use_calibration,
-                ),
-            ],
             [
                 sg.Checkbox(
                     f'{lang._instance.get_string("camera.enableCalibration")}:',
@@ -388,13 +370,14 @@ def render(self, window, event, values):
 
         if event == self.use_calibration:
             if self.settings_config.use_calibration == True:
-                window[self.gui_restart_calibration].update(disabled=False)
-                window[self.gui_stop_calibration].update(disabled=False)
                 print(f'[{lang._instance.get_string("log.info")}] {lang._instance.get_string("info.enabled")}')
+                # Optionally, trigger BlendShapeCalibrator reset/init here if needed
+                playSound(os.path.join("Audio", "start.wav"))
             else:
-                window[self.gui_restart_calibration].update(disabled=True)
-                window[self.gui_stop_calibration].update(disabled=True)
                 print(f'[{lang._instance.get_string("log.info")}] {lang._instance.get_string("info.disabled")}')
+                # Stop calibration if it was running
+                if self.babble_cnn.calibration_frame_counter is not None:
+                    self.babble_cnn.calibration_frame_counter = None
 
         if event == "{}+UP".format(self.gui_roi_selection):
             # Event for mouse button up in ROI mode
@@ -438,18 +421,15 @@ def render(self, window, event, values):
             #print(self.camera_list)
             window[self.gui_camera_addr].update(values=self.camera_list,size=(20,0))
 
-        if event == self.gui_restart_calibration:
+        
             if (
                 values[self.use_calibration] == True
             ):  # Don't start recording if the calibration filter is disabled.
-                self.babble_cnn.calibration_frame_counter = 1500
+                self.babble_cnn.calibration_frame_counter = None  # Disable old frame counter logic
+                # Optionally, trigger BlendShapeCalibrator reset/init here if needed
                 playSound(os.path.join("Audio", "start.wav"))
 
-        if event == self.gui_stop_calibration:
-            if (
-                self.babble_cnn.calibration_frame_counter != None
-            ):  # Only assign the variable if we are in calibration mode.
-                self.babble_cnn.calibration_frame_counter = 0
+        # Calibration is now controlled by the checkbox only
 
         needs_roi_set = self.config.roi_window_h <= 0 or self.config.roi_window_w <= 0
 

BabbleApp/camera_widget.py

@@ -5,7 +5,7 @@
 from utils.misc_utils import ensurePath
 from tab import Tab
 from pydantic import BaseModel
-from typing import Union
+from typing import Union, Optional
 from lang_manager import LocaleStringManager as lang
 
 CONFIG_FILE_NAME: str = "babble_settings.json"
@@ -25,6 +25,7 @@ class BabbleCameraConfig(BaseModel):
 
 
 class BabbleSettingsConfig(BaseModel):
+    widget_id: Optional[int] = None
     gui_min_cutoff: str = "3"
     gui_speed_coefficient: str = "0.9"
     gui_osc_address: str = "127.0.0.1"