spacr 0.3.47__py3-none-any.whl → 0.3.52__py3-none-any.whl

spacr/chat_bot.py

@@ -0,0 +1,31 @@
+import os
+import torch
+from multiprocessing import Queue
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+# Disable parallelism warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+def load_model(model_queue):
+    """Load the Falcon-7B model and send the status via a queue."""
+    try:
+        print("Loading Falcon-7B model...")
+        tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-7b")
+
+        # Set `pad_token` to `eos_token` if not already set
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+
+        model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-7b")
+        model.config.pad_token_id = tokenizer.pad_token_id
+
+        # Send the loaded model and tokenizer back via the queue
+        model_queue.put((model, tokenizer, "Model loaded successfully!"))
+    except Exception as e:
+        model_queue.put((None, None, f"Error loading model: {e}"))
+
+def language_chat(tokenizer, model, user_input):
+    inputs = tokenizer(user_input, return_tensors="pt", padding=True, truncation=True)
+    outputs = model.generate(inputs.input_ids, max_length=256, pad_token_id=tokenizer.eos_token_id)
+    return tokenizer.decode(outputs[0], skip_special_tokens=True)
+

spacr/gui_elements.py

@@ -16,7 +16,8 @@ from collections import deque
 from skimage.draw import polygon, line
 from skimage.transform import resize
 from scipy.ndimage import binary_fill_holes, label
-from tkinter import ttk, scrolledtext 
+from tkinter import ttk, scrolledtext
+from skimage.color import rgb2gray 
 
 fig = None
 
@@ -1534,20 +1535,45 @@ class ModifyMaskApp:
         tk.Label(self.zoom_toolbar, text="Upper Percentile:", bg='black', fg='white').pack(side='left')
         self.upper_entry = tk.Entry(self.zoom_toolbar, textvariable=self.upper_quantile, bg='black', fg='white')
         self.upper_entry.pack(side='left')
-
-        
+    
     def load_image_and_mask(self, index):
+        # Load the image
         image_path = os.path.join(self.folder_path, self.image_filenames[index])
-        image = imageio.imread(image_path)        
+        image = imageio.imread(image_path)
+        print(f"Original Image shape: {image.shape}, dtype: {image.dtype}")
+
+        # Handle multi-channel or transparency issues
+        if image.ndim == 3:
+            if image.shape[2] == 4:  # If the image has an alpha channel (RGBA)
+                image = image[..., :3]  # Remove the alpha channel
+
+            # Convert RGB to grayscale using weighted average
+            image = np.dot(image[..., :3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)
+            print(f"Converted to grayscale: {image.shape}")
+
+        # Ensure the shape is (height, width) without extra channel
+        if image.ndim == 3 and image.shape[2] == 1:
+            image = np.squeeze(image, axis=-1)
+
+        if image.dtype != np.uint16:
+            # Scale the image to fit the 16-bit range (0–65535)
+            image = (image / image.max() * 65535).astype(np.uint16)
+            # eventually remove this images should not have to be 16 bit look into downstream function (non 16bit images are jsut black)
+
+        # Load the corresponding mask
         mask_path = os.path.join(self.masks_folder, self.image_filenames[index])
         if os.path.exists(mask_path):
-            print(f'loading mask:{mask_path} for image: {image_path}')
+            print(f'Loading mask: {mask_path} for image: {image_path}')
             mask = imageio.imread(mask_path)
+
+            # Ensure mask is uint8
             if mask.dtype != np.uint8:
-                mask = (mask / np.max(mask) * 255).astype(np.uint8)
+                mask = (mask / mask.max() * 255).astype(np.uint8)
         else:
+            # Create a new mask with the same size as the image
             mask = np.zeros(image.shape[:2], dtype=np.uint8)
-            print(f'loaded new mask for image: {image_path}')
+            print(f'Loaded new mask for image: {image_path}')
+
         return image, mask
     
     ####################################################################################################

spacr/gui_utils.py

@@ -76,8 +76,8 @@ def load_app(root, app_name, app_func):
         root.current_app_exit_func()
     else:
         proceed_with_app(root, app_name, app_func)
-    
-def parse_list_v1(value):
+
+def parse_list(value):
     """
     Parses a string representation of a list and returns the parsed list.
 
@@ -85,7 +85,7 @@ def parse_list_v1(value):
         value (str): The string representation of the list.
 
     Returns:
-        list: The parsed list.
+        list: The parsed list, which can contain integers, floats, or strings.
 
     Raises:
         ValueError: If the input value is not a valid list format or contains mixed types or unsupported types.
@@ -93,21 +93,20 @@ def parse_list_v1(value):
     try:
         parsed_value = ast.literal_eval(value)
         if isinstance(parsed_value, list):
-            # Check if the list elements are homogeneous (all int or all str)
-            if all(isinstance(item, int) for item in parsed_value):
-                return parsed_value
-            elif all(isinstance(item, str) for item in parsed_value):
-                return parsed_value
-            elif all(isinstance(item, float) for item in parsed_value):
+            # Check if all elements are homogeneous (either all int, float, or str)
+            if all(isinstance(item, (int, float, str)) for item in parsed_value):
                 return parsed_value
             else:
                 raise ValueError("List contains mixed types or unsupported types")
+        elif isinstance(parsed_value, tuple):
+            # Convert tuple to list if it’s a single-element tuple
+            return list(parsed_value) if len(parsed_value) > 1 else [parsed_value[0]]
         else:
             raise ValueError(f"Expected a list but got {type(parsed_value).__name__}")
     except (ValueError, SyntaxError) as e:
         raise ValueError(f"Invalid format for list: {value}. Error: {e}")
-    
-def parse_list(value):
+
+def parse_list_v1(value):
     """
     Parses a string representation of a list and returns the parsed list.
 
@@ -391,7 +390,7 @@ def convert_settings_dict_for_gui(settings):
         'nucleus_chann_dim': ('combo', chans, None),
         'pathogen_mask_dim': ('combo', chans, None),
         'pathogen_chann_dim': ('combo', chans, None),
-        'crop_mode': ('combo', ['cell', 'nucleus', 'pathogen', '[cell, nucleus, pathogen]', '[cell,nucleus, pathogen]'], ['cell']),
+        'crop_mode': ('combo', [['cell'], ['nucleus'], ['pathogen'], ['cell', 'nucleus'], ['cell', 'pathogen'], ['nucleus', 'pathogen'], ['cell', 'nucleus', 'pathogen']], ['cell']),
         'magnification': ('combo', [20, 40, 60], 20),
         'nucleus_channel': ('combo', chans_v2, None),
         'cell_channel': ('combo', chans_v2, None),

spacr/measure.py

@@ -1028,7 +1028,10 @@ def measure_crop(settings):
                 return
 
             if not isinstance(settings['crop_mode'], list):
-                print(f"WARNING: crop_mode should be a list with at least one element e.g. ['cell'] or ['cell','nucleus'] or [None]")
+                print(f"WARNING: crop_mode should be a list with at least one element e.g. ['cell'] or ['cell','nucleus'] or [None] got: {settings['crop_mode']}")
+                settings['crop_mode'] = [settings['crop_mode']]
+                settings['crop_mode'] = [str(crop_mode) for crop_mode in settings['crop_mode']]
+                print(f"Converted crop_mode to list: {settings['crop_mode']}")
                 return
             
             _save_settings_to_db(settings)