simba-uw-tf-dev 4.6.4__py3-none-any.whl → 4.6.6__py3-none-any.whl

simba/sandbox/proboscis_to_tip.py

@@ -0,0 +1,28 @@
+import os
+from simba.mixins.feature_extraction_mixin import FeatureExtractionMixin
+from simba.mixins.config_reader import ConfigReader
+from simba.utils.read_write import read_df, get_fn_ext, read_video_info, write_df
+
+CONFIG_PATH = r"C:\troubleshooting\srami0619\project_folder\project_config.ini"
+BASE = 'prob_base'
+TIP = 'prob_tip'
+
+
+config = ConfigReader(config_path=CONFIG_PATH, read_video_info=True, create_logger=False)
+animal_cnt = config.animal_cnt
+for file_cnt, file_path in enumerate(config.outlier_corrected_paths):
+    file_name = get_fn_ext(file_path)[1]
+    _, px_per_mm, fps = read_video_info(video_name=file_name, video_info_df=config.video_info_df)
+    data_df = read_df(file_path=file_path)
+    save_path = os.path.join(config.features_dir, f'{file_name}.csv')
+    for animal_id in range(1, animal_cnt+1):
+        print(f'Analysing file {file_name}, animal {animal_id} ({file_cnt + 1}/{len(config.outlier_corrected_paths)})')
+        base_cols = [f'{BASE}_{animal_id}_x', f'{BASE}_{animal_id}_y']
+        tip_cols = [f'{TIP}_{animal_id}_x', f'{TIP}_{animal_id}_y']
+        prob_data, tip_data = data_df[base_cols], data_df[tip_cols]
+        data_df[f'animal_{animal_id}_base_tip_distance'] = FeatureExtractionMixin().keypoint_distances(a=prob_data.values, b=tip_data.values, px_per_mm=px_per_mm, in_centimeters=False)
+    write_df(df=data_df, file_type='csv', save_path=save_path, verbose=True)
+
+
+
+

simba/sandbox/test_directionality.py

@@ -0,0 +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!")

simba/sandbox/test_nonstatic_directionality.py

@@ -0,0 +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()

simba/sandbox/test_pycharm_cuda.py

@@ -0,0 +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!")

simba/sandbox/test_simba_install.py

@@ -0,0 +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)

simba/sandbox/test_static_directionality.py

@@ -0,0 +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()

simba/sandbox/test_static_directionality_2d.py

@@ -0,0 +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()

simba/sandbox/verify_env.py

@@ -0,0 +1,42 @@
+"""Verify CUDA environment is properly configured"""
+from numba import cuda
+import cupy as cp
+import numba
+
+print("="*60)
+print("CUDA Environment Verification")
+print("="*60)
+print(f"Numba version: {numba.__version__}")
+print(f"CuPy version: {cp.__version__}")
+print(f"CUDA available: {cuda.is_available()}")
+if cuda.is_available():
+    print(f"CUDA devices: {len(cuda.gpus)}")
+    for i, gpu in enumerate(cuda.gpus):
+        print(f"  GPU {i}: {gpu}")
+
+# Test the function
+print("\n" + "="*60)
+print("Testing directionality_to_nonstatic_target...")
+try:
+    from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
+    import numpy as np
+    
+    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)
+    
+    result = directionality_to_nonstatic_target(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target
+    )
+    print(f"✓ Function works! Result shape: {result.shape}")
+except Exception as e:
+    print(f"✗ Error: {e}")
+    import traceback
+    traceback.print_exc()
+
+print("\n" + "="*60)
+print("Environment is ready!")

simba/ui/pop_ups/fsttc_pop_up.py

@@ -7,25 +7,29 @@ from typing import Union
 from simba.data_processors.fsttc_calculator import FSTTCCalculator
 from simba.mixins.config_reader import ConfigReader
 from simba.mixins.pop_up_mixin import PopUpMixin
-from simba.ui.tkinter_functions import CreateLabelFrameWithIcon, Entry_Box
+from simba.ui.tkinter_functions import (CreateLabelFrameWithIcon, Entry_Box,
+                                        SimbaCheckbox)
 from simba.utils.checks import check_int
-from simba.utils.enums import Defaults, Formats, Keys, Links
+from simba.utils.enums import Formats, Keys, Links
 from simba.utils.errors import CountError
 
 
 class FSTTCPopUp(PopUpMixin, ConfigReader):
-    def __init__(self, config_path: Union[str, os.PathLike]):
+    def __init__(self,
+                 config_path: Union[str, os.PathLike]):
 
-        PopUpMixin.__init__(self, title="FORWARD SPIKE TIME TILING COEFFICIENTS", icon='dependency')
         ConfigReader.__init__(self, config_path=config_path, read_video_info=False)
+        if len(self.clf_names) < 2:
+            raise CountError(msg=f'Cannot compute FSTTC: Needs project with at least 2 classified behaviors, got {len(self.clf_names)}', source=self.__class__.__name__)
+
+        PopUpMixin.__init__(self, title="FORWARD SPIKE TIME TILING COEFFICIENTS", icon='dependency')
         settings_frm = CreateLabelFrameWithIcon( parent=self.main_frm, header="SETTINGS", icon_name=Keys.DOCUMENTATION.value, icon_link=Links.FSTTC.value,)
-        self.time_delta_eb = Entry_Box(settings_frm, "TIME-DELTA", "10", validation="numeric")
-        self.graph_cb_var = BooleanVar(value=False)
-        graph_cb = Checkbutton(settings_frm, font=Formats.FONT_REGULAR.value, text="CREATE GRAPH", variable=self.graph_cb_var)
-        self.join_bouts_within_delta_var = BooleanVar(value=False)
-        join_bouts_within_delta_cb = Checkbutton(settings_frm, text="JOIN BOUTS WITHIN TIME-DELTA", font=Formats.FONT_REGULAR.value, variable=self.join_bouts_within_delta_var,)
-        self.time_delta_at_onset_var = BooleanVar(value=False)
-        time_delta_at_onset_cb = Checkbutton( settings_frm, text="TIME-DELTA AT BOUT START", font=Formats.FONT_REGULAR.value, variable=self.time_delta_at_onset_var)
+        self.time_delta_eb = Entry_Box(parent=settings_frm, fileDescription="TIME-DELTA", labelwidth=25, validation="numeric", entry_box_width=20, img='timer_2')
+
+        graph_cb, self.graph_cb_var = SimbaCheckbox(parent=settings_frm, font=Formats.FONT_REGULAR.value, val=False, txt_img='line_chart_blue', txt="CREATE GRAPH")
+        join_bouts_within_delta_cb, self.join_bouts_within_delta_var = SimbaCheckbox(parent=settings_frm, font=Formats.FONT_REGULAR.value, val=False, txt_img='join_purple', txt="JOIN BOUTS WITHIN TIME-DELTA")
+        time_delta_at_onset_cb, self.time_delta_at_onset_var = SimbaCheckbox(parent=settings_frm, font=Formats.FONT_REGULAR.value, val=False, txt_img='play', txt="TIME-DELTA AT BOUT START")
+
         settings_frm.grid(row=0, column=0, sticky=NW)
         self.time_delta_eb.grid(row=0, column=0, sticky="NW")
         join_bouts_within_delta_cb.grid(row=1, column=0, sticky="NW")
@@ -43,22 +47,20 @@ class FSTTCPopUp(PopUpMixin, ConfigReader):
                 targets.append(behaviour)
 
         if len(targets) < 2:
-            raise CountError(
-                msg="FORWARD SPIKE TIME TILING COEFFICIENTS REQUIRE 2 OR MORE BEHAVIORS.",
-                source=self.__class__.__name__,
-            )
-
-        fsttc_calculator = FSTTCCalculator(
-            config_path=self.config_path,
-            time_window=self.time_delta_eb.entry_get,
-            join_bouts_within_delta=self.join_bouts_within_delta_var.get(),
-            time_delta_at_onset=self.time_delta_at_onset_var.get(),
-            behavior_lst=targets,
-            create_graphs=self.graph_cb_var.get(),
-        )
+            raise CountError(msg="FORWARD SPIKE TIME TILING COEFFICIENTS REQUIRE 2 OR MORE BEHAVIORS.", source=self.__class__.__name__,)
+
+        fsttc_calculator = FSTTCCalculator(config_path=self.config_path,
+                                           time_window=self.time_delta_eb.entry_get,
+                                           join_bouts_within_delta=self.join_bouts_within_delta_var.get(),
+                                           time_delta_at_onset=self.time_delta_at_onset_var.get(),
+                                           behavior_lst=targets,
+                                           create_graphs=self.graph_cb_var.get())
         fsttc_calculator.run()
 
 
-#ExtractAnnotationFramesPopUp(config_path=)
+
 
 #_ = FSTTCPopUp(config_path=r"C:\troubleshooting\multi_animal_dlc_two_c57\project_folder\project_config.ini")
+
+#_ = FSTTCPopUp(config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini")
+

simba/ui/pop_ups/kleinberg_pop_up.py

@@ -7,11 +7,12 @@ from typing import Union
 from simba.data_processors.kleinberg_calculator import KleinbergCalculator
 from simba.mixins.config_reader import ConfigReader
 from simba.mixins.pop_up_mixin import PopUpMixin
-from simba.ui.tkinter_functions import (CreateLabelFrameWithIcon, Entry_Box, SimbaButton, SimBADropDown, SimBALabel)
+from simba.ui.tkinter_functions import (CreateLabelFrameWithIcon, Entry_Box,
+                                        SimbaButton, SimBADropDown, SimBALabel)
 from simba.utils.checks import check_float, check_int
 from simba.utils.enums import Formats, Keys, Links
 from simba.utils.errors import NoChoosenClassifierError, NoDataError
-from simba.utils.read_write import str_2_bool, get_current_time
+from simba.utils.read_write import get_current_time, str_2_bool
 
 INSTRUCTIONS_TXT = 'Results in the project_folder/csv/machine_results folder are overwritten.\n If saving the originals, the original un-smoothened data is saved in a subdirectory of \nthe project_folder/csv/machine_results folder'
 

simba/utils/data.py

@@ -48,7 +48,6 @@ from simba.utils.errors import (BodypartColumnNotFoundError, CountError,
                                 InvalidFileTypeError, InvalidInputError,
                                 NoFilesFoundError, NoROIDataError,
                                 SimBAModuleNotFoundError)
-from simba.utils.lookups import get_current_time
 from simba.utils.printing import stdout_success, stdout_warning
 from simba.utils.read_write import (find_core_cnt, find_video_of_file,
                                     get_current_time, get_fn_ext,