simba-uw-tf-dev 4.6.7__py3-none-any.whl → 4.6.8__py3-none-any.whl

simba/plotting/gantt_creator_mp.py

@@ -8,16 +8,37 @@ import gc
 import multiprocessing
 import os
 import platform
+import sys
 from copy import deepcopy
 from typing import List, Optional, Union
 
 import cv2
-import matplotlib
+
+is_pycharm_ipython = True
+try:
+    module_names = list(sys.modules.keys())
+    if any('pydev' in str(mod).lower() for mod in module_names):
+        is_pycharm_ipython = True
+    elif 'IPython' in sys.modules or 'ipython' in sys.modules:
+        is_pycharm_ipython = True
+    else:
+        is_pycharm_ipython = False
+except Exception:
+    is_pycharm_ipython = True
+
+if not is_pycharm_ipython:
+    if 'MPLBACKEND' not in os.environ:  os.environ['MPLBACKEND'] = 'Agg'
+    try:
+        import matplotlib
+        matplotlib.use('Agg', force=False)
+    except (RecursionError, RuntimeError, ValueError, SystemError):
+        import matplotlib
+else:
+    import matplotlib
+
 import numpy as np
 import pandas as pd
 
-matplotlib.use('Agg')
-
 from simba.mixins.config_reader import ConfigReader
 from simba.mixins.plotting_mixin import PlottingMixin
 from simba.utils.checks import (
@@ -28,6 +49,7 @@ from simba.utils.data import (create_color_palette, detect_bouts, get_cpu_pool,
                               terminate_cpu_pool)
 from simba.utils.enums import Formats, Options
 from simba.utils.errors import NoSpecifiedOutputError
+from simba.utils.lookups import get_fonts
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     create_directory, find_core_cnt,
@@ -51,6 +73,7 @@ def gantt_creator_mp(data: np.array,
                      width: int,
                      height: int,
                      font_size: int,
+                     font: str,
                      font_rotation: int,
                      palette: np.ndarray,
                      hhmmss: bool):
@@ -72,6 +95,7 @@ def gantt_creator_mp(data: np.array,
                                                width=width,
                                                height=height,
                                                font_size=font_size,
+                                               font=font,
                                                font_rotation=font_rotation,
                                                video_name=video_name,
                                                save_path=None,
@@ -139,9 +163,11 @@ class GanttCreatorMultiprocess(ConfigReader, PlottingMixin):
                  height: int = 480,
                  font_size: int = 8,
                  font_rotation: int = 45,
+                 font: Optional[str] = None,
                  palette: str = 'Set1',
                  core_cnt: int = -1,
-                 hhmmss: bool = False):
+                 hhmmss: bool = False,
+                 clf_names: Optional[List[str]] = None):
 
         check_file_exist_and_readable(file_path=config_path)
         if (not frame_setting) and (not video_setting) and (not last_frm_setting):
@@ -157,6 +183,8 @@ class GanttCreatorMultiprocess(ConfigReader, PlottingMixin):
         check_int(name=f"{self.__class__.__name__} core_cnt",value=core_cnt, min_value=-1, unaccepted_vals=[0], max_value=find_core_cnt()[0])
         self.core_cnt = find_core_cnt()[0] if core_cnt == -1 or core_cnt > find_core_cnt()[0] else core_cnt
         self.width, self.height, self.font_size, self.font_rotation, self.hhmmss = width, height, font_size, font_rotation, hhmmss
+        if font is not None:
+            check_str(name=f'{self.__class__.__name__} font', value=font, options=list(get_fonts().keys()), raise_error=True)
         ConfigReader.__init__(self, config_path=config_path, create_logger=False)
         if isinstance(data_paths, list):
             check_valid_lst(data=data_paths, source=f'{self.__class__.__name__} data_paths', valid_dtypes=(str,), min_len=1)
@@ -166,9 +194,12 @@ class GanttCreatorMultiprocess(ConfigReader, PlottingMixin):
         else:
             data_paths = deepcopy(self.machine_results_paths)
         for file_path in data_paths: check_file_exist_and_readable(file_path=file_path)
+        if clf_names is not None:
+            check_valid_lst(data=clf_names, source=f'{self.__class__.__name__} clf_names', valid_dtypes=(str,), valid_values=self.clf_names, min_len=1, raise_error=True)
+            self.clf_names = clf_names
         PlottingMixin.__init__(self)
         self.clr_lst = create_color_palette(pallete_name=palette, increments=len(self.body_parts_lst) + 1, as_int=True, as_rgb_ratio=True)
-        self.frame_setting, self.video_setting, self.data_paths, self.last_frm_setting = frame_setting, video_setting,data_paths, last_frm_setting
+        self.frame_setting, self.video_setting, self.data_paths, self.last_frm_setting, self.font = frame_setting, video_setting,data_paths, last_frm_setting, font
         if not os.path.exists(self.gantt_plot_dir): os.makedirs(self.gantt_plot_dir)
         if platform.system() == "Darwin":
             multiprocessing.set_start_method("spawn", force=True)
@@ -206,6 +237,7 @@ class GanttCreatorMultiprocess(ConfigReader, PlottingMixin):
                                      font_size=self.font_size,
                                      font_rotation=self.font_rotation,
                                      video_name=self.video_name,
+                                     font=self.font,
                                      save_path=os.path.join(self.gantt_plot_dir, f"{self.video_name}_final_image.png"),
                                      palette=self.clr_lst,
                                      hhmmss=self.hhmmss)
@@ -225,6 +257,7 @@ class GanttCreatorMultiprocess(ConfigReader, PlottingMixin):
                                               width=self.width,
                                               height=self.height,
                                               font_size=self.font_size,
+                                              font=self.font,
                                               font_rotation=self.font_rotation,
                                               video_name=self.video_name,
                                               palette=self.clr_lst,
@@ -254,18 +287,18 @@ class GanttCreatorMultiprocess(ConfigReader, PlottingMixin):
 #                                     font_rotation= 45)
 #     test.run()
 
-if __name__ == "__main__":
-    test = GanttCreatorMultiprocess(config_path=r"D:\troubleshooting\maplight_ri\project_folder\project_config.ini",
-                                    frame_setting=False,
-                                    video_setting=True,
-                                    data_paths=r"D:\troubleshooting\maplight_ri\project_folder\csv\machine_results\Trial_1_C24_D1_1.csv",
-                                    last_frm_setting=False,
-                                    width=640,
-                                    height= 480,
-                                    font_size=10,
-                                    font_rotation= 45,
-                                    core_cnt=16)
-    test.run()
+# if __name__ == "__main__":
+#     test = GanttCreatorMultiprocess(config_path=r"D:\troubleshooting\maplight_ri\project_folder\project_config.ini",
+#                                     frame_setting=False,
+#                                     video_setting=True,
+#                                     data_paths=r"D:\troubleshooting\maplight_ri\project_folder\csv\machine_results\Trial_1_C24_D1_1.csv",
+#                                     last_frm_setting=False,
+#                                     width=640,
+#                                     height= 480,
+#                                     font_size=10,
+#                                     font_rotation= 45,
+#                                     core_cnt=16)
+#     test.run()
 
 
 # test = GanttCreatorMultiprocess(config_path='/Users/simon/Desktop/envs/simba/troubleshooting/RAT_NOR/project_folder/project_config.ini',

simba/sandbox/analyze_runtimes.py

@@ -1,30 +1,30 @@
-"""Analyze runtime statistics for directionality_to_nonstatic_target"""
-import numpy as np
-from collections import defaultdict
-
-# Parse the runtime data
-data = {
-    10000: [0.4389, 0.0008, 0.0012],
-    100000: [0.0063, 0.0052, 0.0052],
-    1000000: [0.0768, 0.0306, 0.0239],
-    10000000: [0.2195, 0.2122, 0.2083],
-    50000000: [1.8936, 1.5664, 1.2548]
-}
-
-# Calculate statistics
-print("=" * 80)
-print(f"{'Observations':<15} {'Mean (s)':<12} {'Std (s)':<12} {'Min (s)':<12} {'Max (s)':<12} {'Throughput (M obs/s)':<20}")
-print("=" * 80)
-
-for obs_count in sorted(data.keys()):
-    times = np.array(data[obs_count])
-    mean_time = np.mean(times)
-    std_time = np.std(times)
-    min_time = np.min(times)
-    max_time = np.max(times)
-    throughput = obs_count / (mean_time * 1_000_000)  # Million observations per second
-    
-    print(f"{obs_count:<15,} {mean_time:<12.4f} {std_time:<12.4f} {min_time:<12.4f} {max_time:<12.4f} {throughput:<20.2f}")
-
-print("=" * 80)
-print("\nNote: First run typically includes JIT compilation overhead (especially for 10k observations)")
+"""Analyze runtime statistics for directionality_to_nonstatic_target"""
+import numpy as np
+from collections import defaultdict
+
+# Parse the runtime data
+data = {
+    10000: [0.4389, 0.0008, 0.0012],
+    100000: [0.0063, 0.0052, 0.0052],
+    1000000: [0.0768, 0.0306, 0.0239],
+    10000000: [0.2195, 0.2122, 0.2083],
+    50000000: [1.8936, 1.5664, 1.2548]
+}
+
+# Calculate statistics
+print("=" * 80)
+print(f"{'Observations':<15} {'Mean (s)':<12} {'Std (s)':<12} {'Min (s)':<12} {'Max (s)':<12} {'Throughput (M obs/s)':<20}")
+print("=" * 80)
+
+for obs_count in sorted(data.keys()):
+    times = np.array(data[obs_count])
+    mean_time = np.mean(times)
+    std_time = np.std(times)
+    min_time = np.min(times)
+    max_time = np.max(times)
+    throughput = obs_count / (mean_time * 1_000_000)  # Million observations per second
+    
+    print(f"{obs_count:<15,} {mean_time:<12.4f} {std_time:<12.4f} {min_time:<12.4f} {max_time:<12.4f} {throughput:<20.2f}")
+
+print("=" * 80)
+print("\nNote: First run typically includes JIT compilation overhead (especially for 10k observations)")

simba/sandbox/test_directionality.py

@@ -1,47 +1,47 @@
-"""Test directionality_to_nonstatic_target function"""
-import sys
-import numpy as np
-
-print(f"Python: {sys.executable}")
-print("="*60)
-
-try:
-    from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
-    print("✓ Function imported successfully")
-except Exception as e:
-    print(f"✗ Error importing function: {e}")
-    import traceback
-    traceback.print_exc()
-    sys.exit(1)
-
-# Create test data
-print("\nCreating test data...")
-left_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-right_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-nose = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-target = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-
-print(f"left_ear shape: {left_ear.shape}, dtype: {left_ear.dtype}")
-print(f"right_ear shape: {right_ear.shape}, dtype: {right_ear.dtype}")
-print(f"nose shape: {nose.shape}, dtype: {nose.dtype}")
-print(f"target shape: {target.shape}, dtype: {target.dtype}")
-
-# Test the function
-print("\nTesting directionality_to_nonstatic_target...")
-try:
-    result = directionality_to_nonstatic_target(
-        left_ear=left_ear,
-        right_ear=right_ear,
-        nose=nose,
-        target=target
-    )
-    print(f"✓ SUCCESS! Result shape: {result.shape}")
-    print(f"Result: {result}")
-except Exception as e:
-    print(f"✗ Error running function: {e}")
-    import traceback
-    traceback.print_exc()
-    sys.exit(1)
-
-print("\n" + "="*60)
-print("Test passed!")
+"""Test directionality_to_nonstatic_target function"""
+import sys
+import numpy as np
+
+print(f"Python: {sys.executable}")
+print("="*60)
+
+try:
+    from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
+    print("✓ Function imported successfully")
+except Exception as e:
+    print(f"✗ Error importing function: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+# Create test data
+print("\nCreating test data...")
+left_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+right_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+nose = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+target = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+
+print(f"left_ear shape: {left_ear.shape}, dtype: {left_ear.dtype}")
+print(f"right_ear shape: {right_ear.shape}, dtype: {right_ear.dtype}")
+print(f"nose shape: {nose.shape}, dtype: {nose.dtype}")
+print(f"target shape: {target.shape}, dtype: {target.dtype}")
+
+# Test the function
+print("\nTesting directionality_to_nonstatic_target...")
+try:
+    result = directionality_to_nonstatic_target(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}")
+    print(f"Result: {result}")
+except Exception as e:
+    print(f"✗ Error running function: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+print("\n" + "="*60)
+print("Test passed!")

simba/sandbox/test_nonstatic_directionality.py

@@ -1,27 +1,27 @@
-"""Test directionality_to_nonstatic_target with int64"""
-import numpy as np
-from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
-
-print("Testing directionality_to_nonstatic_target with int64...")
-
-left_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
-right_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
-nose = np.random.randint(0, 500, (100, 2)).astype(np.int64)
-target = np.random.randint(0, 500, (100, 2)).astype(np.int64)
-
-print(f"Arrays shape: {left_ear.shape}, dtype: {left_ear.dtype}")
-
-try:
-    result = directionality_to_nonstatic_target(
-        left_ear=left_ear,
-        right_ear=right_ear,
-        nose=nose,
-        target=target,
-        verbose=True
-    )
-    print(f"✓ SUCCESS! Result shape: {result.shape}, dtype: {result.dtype}")
-    print(f"First 5 results:\n{result[:5]}")
-except Exception as e:
-    print(f"✗ Error: {e}")
-    import traceback
-    traceback.print_exc()
+"""Test directionality_to_nonstatic_target with int64"""
+import numpy as np
+from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
+
+print("Testing directionality_to_nonstatic_target with int64...")
+
+left_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+right_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+nose = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+target = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+
+print(f"Arrays shape: {left_ear.shape}, dtype: {left_ear.dtype}")
+
+try:
+    result = directionality_to_nonstatic_target(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target,
+        verbose=True
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}, dtype: {result.dtype}")
+    print(f"First 5 results:\n{result[:5]}")
+except Exception as e:
+    print(f"✗ Error: {e}")
+    import traceback
+    traceback.print_exc()

simba/sandbox/test_pycharm_cuda.py

@@ -1,51 +1,51 @@
-"""Test script to verify PyCharm CUDA environment setup"""
-import sys
-print(f"Python version: {sys.version}")
-print(f"Python path: {sys.executable}")
-
-try:
-    from numba import cuda
-    print(f"\nNumba CUDA available: {cuda.is_available()}")
-    if cuda.is_available():
-        print(f"CUDA devices: {len(cuda.gpus)}")
-except Exception as e:
-    print(f"\nError importing numba.cuda: {e}")
-
-try:
-    import cupy as cp
-    print(f"CuPy version: {cp.__version__}")
-    # Test CuPy
-    x = cp.array([1, 2, 3, 4, 5])
-    print(f"CuPy test array: {x.get()}")
-except Exception as e:
-    print(f"Error importing cupy: {e}")
-
-try:
-    import numpy as np
-    print(f"NumPy version: {np.__version__}")
-except Exception as e:
-    print(f"Error importing numpy: {e}")
-
-try:
-    import cv2
-    print(f"OpenCV version: {cv2.__version__}")
-except Exception as e:
-    print(f"Error importing cv2: {e}")
-
-# Test SimBA CUDA imports
-try:
-    from simba.data_processors.cuda.geometry import is_inside_rectangle
-    print("\n✓ Successfully imported simba.data_processors.cuda.geometry")
-    
-    # Quick test
-    test_points = np.array([[150, 150], [300, 300], [50, 50]], dtype=np.int32)
-    test_rect = np.array([[100, 100], [400, 400]], dtype=np.int32)
-    result = is_inside_rectangle(x=test_points, y=test_rect)
-    print(f"✓ is_inside_rectangle test passed: {result}")
-except Exception as e:
-    print(f"\n✗ Error importing SimBA CUDA functions: {e}")
-    import traceback
-    traceback.print_exc()
-
-print("\n" + "="*50)
-print("Environment check complete!")
+"""Test script to verify PyCharm CUDA environment setup"""
+import sys
+print(f"Python version: {sys.version}")
+print(f"Python path: {sys.executable}")
+
+try:
+    from numba import cuda
+    print(f"\nNumba CUDA available: {cuda.is_available()}")
+    if cuda.is_available():
+        print(f"CUDA devices: {len(cuda.gpus)}")
+except Exception as e:
+    print(f"\nError importing numba.cuda: {e}")
+
+try:
+    import cupy as cp
+    print(f"CuPy version: {cp.__version__}")
+    # Test CuPy
+    x = cp.array([1, 2, 3, 4, 5])
+    print(f"CuPy test array: {x.get()}")
+except Exception as e:
+    print(f"Error importing cupy: {e}")
+
+try:
+    import numpy as np
+    print(f"NumPy version: {np.__version__}")
+except Exception as e:
+    print(f"Error importing numpy: {e}")
+
+try:
+    import cv2
+    print(f"OpenCV version: {cv2.__version__}")
+except Exception as e:
+    print(f"Error importing cv2: {e}")
+
+# Test SimBA CUDA imports
+try:
+    from simba.data_processors.cuda.geometry import is_inside_rectangle
+    print("\n✓ Successfully imported simba.data_processors.cuda.geometry")
+    
+    # Quick test
+    test_points = np.array([[150, 150], [300, 300], [50, 50]], dtype=np.int32)
+    test_rect = np.array([[100, 100], [400, 400]], dtype=np.int32)
+    result = is_inside_rectangle(x=test_points, y=test_rect)
+    print(f"✓ is_inside_rectangle test passed: {result}")
+except Exception as e:
+    print(f"\n✗ Error importing SimBA CUDA functions: {e}")
+    import traceback
+    traceback.print_exc()
+
+print("\n" + "="*50)
+print("Environment check complete!")

simba/sandbox/test_simba_install.py

@@ -1,41 +1,41 @@
-"""Test SimBA installation in conda environment"""
-import sys
-print(f"Python: {sys.executable}")
-
-try:
-    import simba
-    print("✓ SimBA imported successfully!")
-except Exception as e:
-    print(f"✗ Error importing SimBA: {e}")
-    import traceback
-    traceback.print_exc()
-    sys.exit(1)
-
-try:
-    from simba.data_processors.cuda.geometry import is_inside_rectangle
-    print("✓ CUDA geometry functions imported!")
-except Exception as e:
-    print(f"✗ Error importing CUDA functions: {e}")
-    import traceback
-    traceback.print_exc()
-    sys.exit(1)
-
-try:
-    import cupy as cp
-    import numpy as np
-    print(f"✓ CuPy {cp.__version__} available")
-    
-    # Quick test
-    test_points = np.array([[150, 150], [300, 300], [50, 50]], dtype=np.int32)
-    test_rect = np.array([[100, 100], [400, 400]], dtype=np.int32)
-    result = is_inside_rectangle(x=test_points, y=test_rect)
-    print(f"✓ CUDA function test passed: {result}")
-except Exception as e:
-    print(f"✗ Error testing CUDA: {e}")
-    import traceback
-    traceback.print_exc()
-    sys.exit(1)
-
-print("\n" + "="*50)
-print("All tests passed! SimBA is ready to use.")
-print("="*50)
+"""Test SimBA installation in conda environment"""
+import sys
+print(f"Python: {sys.executable}")
+
+try:
+    import simba
+    print("✓ SimBA imported successfully!")
+except Exception as e:
+    print(f"✗ Error importing SimBA: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+try:
+    from simba.data_processors.cuda.geometry import is_inside_rectangle
+    print("✓ CUDA geometry functions imported!")
+except Exception as e:
+    print(f"✗ Error importing CUDA functions: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+try:
+    import cupy as cp
+    import numpy as np
+    print(f"✓ CuPy {cp.__version__} available")
+    
+    # Quick test
+    test_points = np.array([[150, 150], [300, 300], [50, 50]], dtype=np.int32)
+    test_rect = np.array([[100, 100], [400, 400]], dtype=np.int32)
+    result = is_inside_rectangle(x=test_points, y=test_rect)
+    print(f"✓ CUDA function test passed: {result}")
+except Exception as e:
+    print(f"✗ Error testing CUDA: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+print("\n" + "="*50)
+print("All tests passed! SimBA is ready to use.")
+print("="*50)

simba/sandbox/test_static_directionality.py

@@ -1,26 +1,26 @@
-"""Test directionality_to_static_targets function"""
-import numpy as np
-from simba.data_processors.cuda.geometry import directionality_to_static_targets
-
-print("Testing directionality_to_static_targets...")
-
-left_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-right_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-nose = np.random.randint(0, 500, (10, 2)).astype(np.int32)
-target = np.array([250, 250], dtype=np.int32)
-
-print(f"target shape: {target.shape}, dtype: {target.dtype}")
-
-try:
-    result = directionality_to_static_targets(
-        left_ear=left_ear,
-        right_ear=right_ear,
-        nose=nose,
-        target=target
-    )
-    print(f"✓ SUCCESS! Result shape: {result.shape}")
-    print(f"Result:\n{result}")
-except Exception as e:
-    print(f"✗ Error: {e}")
-    import traceback
-    traceback.print_exc()
+"""Test directionality_to_static_targets function"""
+import numpy as np
+from simba.data_processors.cuda.geometry import directionality_to_static_targets
+
+print("Testing directionality_to_static_targets...")
+
+left_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+right_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+nose = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+target = np.array([250, 250], dtype=np.int32)
+
+print(f"target shape: {target.shape}, dtype: {target.dtype}")
+
+try:
+    result = directionality_to_static_targets(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}")
+    print(f"Result:\n{result}")
+except Exception as e:
+    print(f"✗ Error: {e}")
+    import traceback
+    traceback.print_exc()

simba/sandbox/test_static_directionality_2d.py

@@ -1,26 +1,26 @@
-"""Test directionality_to_static_targets with correct 1D target"""
-import numpy as np
-from simba.data_processors.cuda.geometry import directionality_to_static_targets
-
-print("Testing directionality_to_static_targets with 1D target (correct)...")
-
-left_ear = np.random.randint(0, 500, (100, 2)).astype(np.int32)
-right_ear = np.random.randint(0, 500, (100, 2)).astype(np.int32)
-nose = np.random.randint(0, 500, (100, 2)).astype(np.int32)
-target = np.array([250, 250], dtype=np.int32)  # 1D array for static target
-
-print(f"target shape: {target.shape}, dtype: {target.dtype}")
-
-try:
-    result = directionality_to_static_targets(
-        left_ear=left_ear,
-        right_ear=right_ear,
-        nose=nose,
-        target=target
-    )
-    print(f"✓ SUCCESS! Result shape: {result.shape}")
-    print(f"First 5 results:\n{result[:5]}")
-except Exception as e:
-    print(f"✗ Error: {e}")
-    import traceback
-    traceback.print_exc()
+"""Test directionality_to_static_targets with correct 1D target"""
+import numpy as np
+from simba.data_processors.cuda.geometry import directionality_to_static_targets
+
+print("Testing directionality_to_static_targets with 1D target (correct)...")
+
+left_ear = np.random.randint(0, 500, (100, 2)).astype(np.int32)
+right_ear = np.random.randint(0, 500, (100, 2)).astype(np.int32)
+nose = np.random.randint(0, 500, (100, 2)).astype(np.int32)
+target = np.array([250, 250], dtype=np.int32)  # 1D array for static target
+
+print(f"target shape: {target.shape}, dtype: {target.dtype}")
+
+try:
+    result = directionality_to_static_targets(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}")
+    print(f"First 5 results:\n{result[:5]}")
+except Exception as e:
+    print(f"✗ Error: {e}")
+    import traceback
+    traceback.print_exc()