spacr 0.3.22__tar.gz → 0.3.31__tar.gz

{spacr-0.3.22/spacr.egg-info → spacr-0.3.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.3.22
+Version: 0.3.31
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson

{spacr-0.3.22 → spacr-0.3.31}/setup.py

@@ -67,7 +67,7 @@ dependencies = [
 
 setup(
     name="spacr",
-    version="0.3.22",
+    version="0.3.31",
     author="Einar Birnir Olafsson",
     author_email="olafsson@med.umich.com",
     description="Spatial phenotype analysis of crisp screens (SpaCr)",

{spacr-0.3.22 → spacr-0.3.31}/spacr/app_annotate.py

@@ -20,7 +20,7 @@ def initiate_annotation_app(parent_frame):
         settings['img_size'] = list(map(int, settings['img_size'].split(',')))  # Convert string to list of integers
         settings['percentiles'] = list(map(int, settings['percentiles'].split(',')))  # Convert string to list of integers
         settings['normalize'] = settings['normalize'].lower() == 'true'
-
+        settings['normalize_channels'] = settings['normalize_channels'].split(',')
         try:
             settings['measurement'] = settings['measurement'].split(',') if settings['measurement'] else None
             settings['threshold'] = None if settings['threshold'].lower() == 'none' else int(settings['threshold'])
@@ -38,7 +38,6 @@ def initiate_annotation_app(parent_frame):
                 settings[key] = None
 
         settings_window.destroy()
-
         annotate_app(parent_frame, settings)
     
     start_button = spacrButton(settings_window, text="annotate", command=start_annotation_app, show_text=False)

{spacr-0.3.22 → spacr-0.3.31}/spacr/deep_spacr.py

@@ -610,264 +610,168 @@ def train_model(dst, model_type, train_loaders, epochs=100, learning_rate=0.0001
             
     return model, model_path
 
-def visualize_saliency_map(settings):
-    from spacr.utils import SaliencyMapGenerator, print_progress
-    from spacr.io import TarImageDataset  # Assuming you have a dataset class
-    from torchvision.utils import make_grid
-
+def generate_activation_map(settings):
+    
+    from .utils import SaliencyMapGenerator, GradCAMGenerator, SelectChannels, activation_maps_to_database, activation_correlations_to_database
+    from .utils import print_progress, save_settings, calculate_activation_correlations
+    from .io import TarImageDataset
+    from .settings import get_default_generate_activation_map_settings
+    
+    torch.cuda.empty_cache()
+    gc.collect()
+    
+    plt.clf()
     use_cuda = torch.cuda.is_available()
     device = torch.device("cuda" if use_cuda else "cpu")
-
+    
+    source_folder = os.path.dirname(os.path.dirname(settings['dataset']))
+    settings['src'] = source_folder
+    settings = get_default_generate_activation_map_settings(settings)
+    save_settings(settings, name=f"{settings['cam_type']}_settings", show=False)
+    
+    if settings['model_type'] == 'maxvit' and settings['target_layer'] == None:
+        settings['target_layer'] = 'base_model.blocks.3.layers.1.layers.MBconv.layers.conv_b'
+    if settings['cam_type'] in ['saliency_image', 'saliency_channel']:
+        settings['target_layer'] = None
+    
     # Set number of jobs for loading
-    if settings['n_jobs'] is None:
+    n_jobs = settings['n_jobs']
+    if n_jobs is None:
         n_jobs = max(1, cpu_count() - 4)
-    else:
-        n_jobs = settings['n_jobs']
 
     # Set transforms for images
-    if settings['normalize']:
-        transform = transforms.Compose([
-            transforms.ToTensor(),
-            transforms.CenterCrop(size=(settings['image_size'], settings['image_size'])),
-            transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))])
-    else:
-        transform = transforms.Compose([
-            transforms.ToTensor(),
-            transforms.CenterCrop(size=(settings['image_size'], settings['image_size']))])
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.CenterCrop(size=(settings['image_size'], settings['image_size'])),
+        transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) if settings['normalize_input'] else None,
+        SelectChannels(settings['channels'])
+    ])
 
     # Handle dataset path
-    if os.path.exists(settings['dataset']):
-        tar_path = settings['dataset']
-    else:
+    if not os.path.exists(settings['dataset']):
         print(f"Dataset not found at {settings['dataset']}")
         return
-    
-    if settings.get('save', False):
-        if settings['dtype'] not in ['uint8', 'uint16']:
-            print("Invalid dtype in settings. Please use 'uint8' or 'uint16'.")
-            return
 
     # Load the model
     model = torch.load(settings['model_path'])
     model.to(device)
-    model.eval()  # Ensure the model is in evaluation mode
+    model.eval()
 
-    # Create directory for saving saliency maps if it does not exist
-    if settings.get('save', False):
-        dataset_dir = os.path.dirname(tar_path)
-        dataset_name = os.path.splitext(os.path.basename(tar_path))[0]
-        save_dir = os.path.join(dataset_dir, dataset_name, 'saliency_maps')
+    # Create directory for saving activation maps if it does not exist
+    dataset_dir = os.path.dirname(settings['dataset'])
+    dataset_name = os.path.splitext(os.path.basename(settings['dataset']))[0]
+    save_dir = os.path.join(dataset_dir, dataset_name, settings['cam_type'])
+    batch_grid_fldr = os.path.join(save_dir, 'batch_grids')
+    
+    if settings['save']:
         os.makedirs(save_dir, exist_ok=True)
-        print(f"Saliency maps will be saved in: {save_dir}")
-
+        print(f"Activation maps will be saved in: {save_dir}")
+        
+    if settings['plot']:
+        os.makedirs(batch_grid_fldr, exist_ok=True)
+        print(f"Batch grid maps will be saved in: {batch_grid_fldr}")
+    
     # Load dataset
-    dataset = TarImageDataset(tar_path, transform=transform)
-    data_loader = DataLoader(dataset, batch_size=settings['batch_size'], shuffle=True, num_workers=n_jobs, pin_memory=True)
-
-    # Initialize SaliencyMapGenerator
-    cam_generator = SaliencyMapGenerator(model)
+    dataset = TarImageDataset(settings['dataset'], transform=transform)
+    data_loader = DataLoader(dataset, batch_size=settings['batch_size'], shuffle=settings['shuffle'], num_workers=n_jobs, pin_memory=True)
+
+    # Initialize generator based on cam_type
+    if settings['cam_type'] in ['gradcam', 'gradcam_pp']:
+        cam_generator = GradCAMGenerator(model, target_layer=settings['target_layer'], cam_type=settings['cam_type'])
+    elif settings['cam_type'] in ['saliency_image', 'saliency_channel']:
+        cam_generator = SaliencyMapGenerator(model)
+        
     time_ls = []
-
     for batch_idx, (inputs, filenames) in enumerate(data_loader):
         start = time.time()
+        img_paths = []
         inputs = inputs.to(device)
-        
-        saliency_maps, predicted_classes = cam_generator.compute_saliency_and_predictions(inputs)
-
-        if settings['saliency_mode'] not in ['mean', 'sum']:
-            print("To generate channel average or sum saliency maps set saliency_mode to 'mean' or 'sum', respectively.")
-
-        if settings['saliency_mode'] == 'mean':
-            saliency_maps = saliency_maps.mean(dim=1, keepdim=True)
-
-        elif settings['saliency_mode'] == 'sum':
-            saliency_maps = saliency_maps.sum(dim=1, keepdim=True)
-
-        # Example usage with the class
-        if settings.get('plot', False):
-            if settings['plot_mode'] not in ['mean', 'channel', '3-channel']:
-                print("Invalid plot_mode in settings. Please use 'mean', 'channel', or '3-channel'.")
-                return
-            else:
-                cam_generator.plot_saliency_grid(inputs, saliency_maps, predicted_classes, mode=settings['plot_mode'])
-
-        if settings.get('save', False):
-            for i in range(inputs.size(0)):
-                saliency_map = saliency_maps[i].detach().cpu().numpy()
-
-                # Check dtype in settings and normalize accordingly
-                if settings['dtype'] == 'uint16':
-                    saliency_map = np.clip(saliency_map, 0, 1) * 65535
-                    saliency_map = saliency_map.astype(np.uint16)
-                    mode = 'I;16'
-                elif settings['dtype'] == 'uint8':
-                    saliency_map = np.clip(saliency_map, 0, 1) * 255
-                    saliency_map = saliency_map.astype(np.uint8)
-                    mode = 'L'  # Grayscale mode for uint8
-
-                # Get the class prediction (0 or 1)
-                class_pred = predicted_classes[i].item()
-
-                save_class_dir = os.path.join(save_dir, f'class_{class_pred}')
-                os.makedirs(save_class_dir, exist_ok=True)
-                save_path = os.path.join(save_class_dir, filenames[i])
-
-                # Handle different cases based on saliency_map dimensions
-                if saliency_map.ndim == 3:  # Multi-channel case (C, H, W)
-                    if saliency_map.shape[0] == 3:  # RGB-like saliency map
-                        saliency_image = Image.fromarray(np.moveaxis(saliency_map, 0, -1), mode="RGB")  # Convert (C, H, W) to (H, W, C)
-                    elif saliency_map.shape[0] == 1:  # Single-channel case (1, H, W)
-                        saliency_map = np.squeeze(saliency_map)  # Remove the extra channel dimension
-                        saliency_image = Image.fromarray(saliency_map, mode=mode)  # Use grayscale mode for single-channel
-                    else:
-                        raise ValueError(f"Unexpected number of channels: {saliency_map.shape[0]}")
-
-                elif saliency_map.ndim == 2:  # Single-channel case (H, W)
-                    saliency_image = Image.fromarray(saliency_map, mode=mode)  # Keep single channel (H, W)
-
-                else:
-                    raise ValueError(f"Unexpected number of dimensions: {saliency_map.ndim}")
-
-                # Save the image
-                saliency_image.save(save_path)
 
+        # Compute activation maps and predictions
+        if settings['cam_type'] in ['gradcam', 'gradcam_pp']:
+            activation_maps, predicted_classes = cam_generator.compute_gradcam_and_predictions(inputs)
+        elif settings['cam_type'] in ['saliency_image', 'saliency_channel']:
+            activation_maps, predicted_classes = cam_generator.compute_saliency_and_predictions(inputs)
+                
+        # Move activation maps to CPU
+        activation_maps = activation_maps.cpu()
+
+        # Sum saliency maps for 'saliency_image' type
+        if settings['cam_type'] == 'saliency_image':
+            summed_activation_maps = []
+            for i in range(activation_maps.size(0)):
+                activation_map = activation_maps[i]                
+                #print(f"1: {activation_map.shape}")
+                activation_map_sum = activation_map.sum(dim=0, keepdim=False)
+                #print(f"2: {activation_map.shape}")
+                activation_map_sum = np.squeeze(activation_map_sum, axis=0)
+                #print(f"3: {activation_map_sum.shape}")
+                summed_activation_maps.append(activation_map_sum)
+            activation_maps = torch.stack(summed_activation_maps)
+
+        # For plotting
+        if settings['plot']:
+            fig = cam_generator.plot_activation_grid(inputs, activation_maps, predicted_classes, overlay=settings['overlay'], normalize=settings['normalize'])
+            pdf_save_path = os.path.join(batch_grid_fldr,f"batch_{batch_idx}_grid.pdf")
+            fig.savefig(pdf_save_path, format='pdf')
+            print(f"Saved batch grid to {pdf_save_path}")
+            #plt.show()
+            display(fig)
+                    
+        for i in range(inputs.size(0)):
+            activation_map = activation_maps[i].detach().numpy()
+
+            if settings['cam_type'] in ['saliency_image', 'gradcam', 'gradcam_pp']:
+                #activation_map = activation_map.sum(axis=0) 
+                activation_map = (activation_map - activation_map.min()) / (activation_map.max() - activation_map.min())
+                activation_map = (activation_map * 255).astype(np.uint8)
+                activation_image = Image.fromarray(activation_map, mode='L')
+
+            elif settings['cam_type'] == 'saliency_channel':
+                # Handle each channel separately and save as RGB
+                rgb_activation_map = np.zeros((activation_map.shape[1], activation_map.shape[2], 3), dtype=np.uint8)
+                for c in range(min(activation_map.shape[0], 3)):  # Limit to 3 channels for RGB
+                    channel_map = activation_map[c]
+                    channel_map = (channel_map - channel_map.min()) / (channel_map.max() - channel_map.min())
+                    rgb_activation_map[:, :, c] = (channel_map * 255).astype(np.uint8)
+                activation_image = Image.fromarray(rgb_activation_map, mode='RGB')
+
+            # Save activation maps
+            class_pred = predicted_classes[i].item()
+            parts = filenames[i].split('_')
+            plate = parts[0]
+            well = parts[1]
+            save_class_dir = os.path.join(save_dir, f'class_{class_pred}', str(plate), str(well))
+            os.makedirs(save_class_dir, exist_ok=True)
+            save_path = os.path.join(save_class_dir, f'{filenames[i]}')
+            if settings['save']:
+                activation_image.save(save_path)
+            img_paths.append(save_path)
+        
+        if settings['save']:
+            activation_maps_to_database(img_paths, source_folder, settings)
+            
+        if settings['correlation']:
+            df = calculate_activation_correlations(inputs, activation_maps, filenames, manders_thresholds=settings['manders_thresholds'])
+            if settings['plot']:
+                display(df)
+            if settings['save']:
+                activation_correlations_to_database(df, img_paths, source_folder, settings)
 
         stop = time.time()
         duration = stop - start
         time_ls.append(duration)
         files_processed = batch_idx * settings['batch_size']
-        files_to_process = len(data_loader)
-        print_progress(files_processed, files_to_process, n_jobs=n_jobs, time_ls=time_ls, batch_size=settings['batch_size'], operation_type="Generating Saliency Maps")
-
-    print("Saliency map generation complete.")
-
-def visualize_saliency_map_v1(src, model_type='maxvit', model_path='', image_size=224, channels=[1,2,3], normalize=True, class_names=None, save_saliency=False, save_dir='saliency_maps'):
+        files_to_process = len(data_loader) * settings['batch_size']
+        print_progress(files_processed, files_to_process, n_jobs=n_jobs, time_ls=time_ls, batch_size=settings['batch_size'], operation_type="Generating Activation Maps")
 
-    from spacr.utils import SaliencyMapGenerator, preprocess_image
-
-    use_cuda = torch.cuda.is_available()
-    device = torch.device("cuda" if use_cuda else "cpu")
-
-    # Load the entire model object
-    model = torch.load(model_path)
-    model.to(device)
-
-    # Create directory for saving saliency maps if it does not exist
-    if save_saliency and not os.path.exists(save_dir):
-        os.makedirs(save_dir)
-
-    # Collect all images and their tensors
-    images = []
-    input_tensors = []
-    filenames = []
-    for file in os.listdir(src):
-        if not file.endswith('.png'):
-            continue
-        image_path = os.path.join(src, file)
-        image, input_tensor = preprocess_image(image_path, normalize=normalize, image_size=image_size, channels=channels)
-        images.append(image)
-        input_tensors.append(input_tensor)
-        filenames.append(file)
-
-    input_tensors = torch.cat(input_tensors).to(device)
-    class_labels = torch.zeros(input_tensors.size(0), dtype=torch.long).to(device)  # Replace with actual class labels if available
-
-    # Generate saliency maps
-    cam_generator = SaliencyMapGenerator(model)
-    saliency_maps = cam_generator.compute_saliency_maps(input_tensors, class_labels)
-
-    # Convert saliency maps to numpy arrays
-    saliency_maps = saliency_maps.cpu().numpy()
-
-    N = len(images)
-
-    dst = os.path.join(src, 'saliency_maps')
-
-    for i in range(N):
-        fig, axes = plt.subplots(1, 3, figsize=(20, 5))
-        
-        # Original image
-        axes[0].imshow(images[i])
-        axes[0].axis('off')
-        if class_names:
-            axes[0].set_title(f"Class: {class_names[class_labels[i].item()]}")
-
-        # Saliency Map
-        axes[1].imshow(saliency_maps[i, 0], cmap='hot')
-        axes[1].axis('off')
-        axes[1].set_title("Saliency Map")
-
-        # Overlay
-        overlay = np.array(images[i])
-        overlay = overlay / overlay.max()
-        saliency_map_rgb = np.stack([saliency_maps[i, 0]] * 3, axis=-1)  # Convert saliency map to RGB
-        overlay = (overlay * 0.5 + saliency_map_rgb * 0.5).clip(0, 1)
-        axes[2].imshow(overlay)
-        axes[2].axis('off')
-        axes[2].set_title("Overlay")
-
-        plt.tight_layout()
-        plt.show()
-
-        # Save the saliency map if required
-        if save_saliency:
-            os.makedirs(dst, exist_ok=True)
-            saliency_image = Image.fromarray((saliency_maps[i, 0] * 255).astype(np.uint8))
-            saliency_image.save(os.path.join(dst, f'saliency_{filenames[i]}'))
-
-def visualize_grad_cam(src, model_path, target_layers=None, image_size=224, channels=[1, 2, 3], normalize=True, class_names=None, save_cam=False, save_dir='grad_cam'):
-
-    from spacr.utils import GradCAM, preprocess_image, show_cam_on_image, recommend_target_layers
-
-    use_cuda = torch.cuda.is_available()
-    device = torch.device("cuda" if use_cuda else "cpu")
-    
-    model = torch.load(model_path)
-    model.to(device)
-    
-    # If no target layers provided, recommend a target layer
-    if target_layers is None:
-        target_layers, all_layers = recommend_target_layers(model)
-        print(f"No target layer provided. Using recommended layer: {target_layers[0]}")
-        print("All possible target layers:")
-        for layer in all_layers:
-            print(layer)
-    
-    grad_cam = GradCAM(model=model, target_layers=target_layers, use_cuda=use_cuda)
-
-    if save_cam and not os.path.exists(save_dir):
-        os.makedirs(save_dir)
-
-    images = []
-    filenames = []
-    for file in os.listdir(src):
-        if not file.endswith('.png'):
-            continue
-        image_path = os.path.join(src, file)
-        image, input_tensor = preprocess_image(image_path, normalize=normalize, image_size=image_size, channels=channels)
-        images.append(image)
-        filenames.append(file)
-
-        input_tensor = input_tensor.to(device)
-        cam = grad_cam(input_tensor)
-        cam_image = show_cam_on_image(np.array(image) / 255.0, cam)
-
-        fig, ax = plt.subplots(1, 2, figsize=(10, 5))
-        ax[0].imshow(image)
-        ax[0].axis('off')
-        ax[0].set_title("Original Image")
-        ax[1].imshow(cam_image)
-        ax[1].axis('off')
-        ax[1].set_title("Grad-CAM")
-        plt.show()
-
-        if save_cam:
-            cam_pil = Image.fromarray(cam_image)
-            cam_pil.save(os.path.join(save_dir, f'grad_cam_{file}'))
+    torch.cuda.empty_cache()
+    gc.collect()
+    print("Activation map generation complete.")
 
 def visualize_classes(model, dtype, class_names, **kwargs):
 
-    from spacr.utils import class_visualization
+    from .utils import class_visualization
 
     for target_y in range(2):  # Assuming binary classification
         print(f"Visualizing class: {class_names[target_y]}")

{spacr-0.3.22 → spacr-0.3.31}/spacr/gui.py

@@ -57,6 +57,7 @@ class MainApp(tk.Tk):
             "Map Barcodes": (lambda frame: initiate_root(self, 'map_barcodes'), "Map barcodes to data."),
             "Regression": (lambda frame: initiate_root(self, 'regression'), "Perform regression analysis."),
             "Recruitment": (lambda frame: initiate_root(self, 'recruitment'), "Analyze recruitment data."),
+            "Activation": (lambda frame: initiate_root(self, 'activation'), "Generate activation maps of computer vision models and measure channel-activation correlation."),
             "Plaque": (lambda frame: initiate_root(self, 'analyze_plaques'), "Analyze plaque data.")
         }
 

{spacr-0.3.22 → spacr-0.3.31}/spacr/gui_core.py

@@ -379,10 +379,13 @@ def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var,
     index_control = index_control_var
 
 def import_settings(settings_type='mask'):
-    from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
     global vars_dict, scrollable_frame, button_scrollable_frame
-    from .settings import generate_fields, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model, set_default_generate_barecode_mapping, set_default_umap_image_settings, get_analyze_recruitment_default_settings
 
+    from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
+    from .settings import generate_fields, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model
+    from .settings import set_default_generate_barecode_mapping, set_default_umap_image_settings, get_analyze_recruitment_default_settings
+    from .settings import get_default_generate_activation_map_settings
+    #activation
     def read_settings_from_csv(csv_file_path):
         settings = {}
         with open(csv_file_path, newline='') as csvfile:
@@ -422,6 +425,8 @@ def import_settings(settings_type='mask'):
         settings = set_default_umap_image_settings(settings={})
     elif settings_type == 'recruitment':
         settings = get_analyze_recruitment_default_settings(settings={})
+    elif settings_type == 'activation':
+        settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
         settings = {}
     elif settings_type == 'convert':
@@ -436,8 +441,10 @@ def import_settings(settings_type='mask'):
 
 def setup_settings_panel(vertical_container, settings_type='mask'):
     global vars_dict, scrollable_frame
-    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings
-    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings
+    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks
+    from .settings import get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings
+    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+    from .settings import generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_default_generate_activation_map_settings
     from .gui_utils import convert_settings_dict_for_gui
     from .gui_elements import set_element_size
 
@@ -480,6 +487,8 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
         settings = get_perform_regression_default_settings(settings={})
     elif settings_type == 'recruitment':
         settings = get_analyze_recruitment_default_settings(settings={})
+    elif settings_type == 'activation':
+        settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
         settings = {'src':'path to images'}
     elif settings_type == 'convert':

{spacr-0.3.22 → spacr-0.3.31}/spacr/gui_elements.py

@@ -20,6 +20,47 @@ from tkinter import ttk, scrolledtext
 
 fig = None
 
+def create_menu_bar(root):
+    from .gui import initiate_root
+    gui_apps = {
+        "Mask": lambda: initiate_root(root, settings_type='mask'),
+        "Measure": lambda: initiate_root(root, settings_type='measure'),
+        "Annotate": lambda: initiate_root(root, settings_type='annotate'),
+        "Make Masks": lambda: initiate_root(root, settings_type='make_masks'),
+        "Classify": lambda: initiate_root(root, settings_type='classify'),
+        "Umap": lambda: initiate_root(root, settings_type='umap'),
+        "Train Cellpose": lambda: initiate_root(root, settings_type='train_cellpose'),
+        "ML Analyze": lambda: initiate_root(root, settings_type='ml_analyze'),
+        "Cellpose Masks": lambda: initiate_root(root, settings_type='cellpose_masks'),
+        "Cellpose All": lambda: initiate_root(root, settings_type='cellpose_all'),
+        "Map Barcodes": lambda: initiate_root(root, settings_type='map_barcodes'),
+        "Regression": lambda: initiate_root(root, settings_type='regression'),
+        "Activation": lambda: initiate_root(root, settings_type='activation'),
+        "Recruitment": lambda: initiate_root(root, settings_type='recruitment')
+    }
+
+    # Create the menu bar
+    menu_bar = tk.Menu(root, bg="#008080", fg="white")
+
+    # Create a "SpaCr Applications" menu
+    app_menu = tk.Menu(menu_bar, tearoff=0, bg="#008080", fg="white")
+    menu_bar.add_cascade(label="SpaCr Applications", menu=app_menu)
+
+    # Add options to the "SpaCr Applications" menu
+    for app_name, app_func in gui_apps.items():
+        app_menu.add_command(
+            label=app_name,
+            command=app_func
+        )
+
+    # Add a separator and an exit option
+    app_menu.add_separator()
+    app_menu.add_command(label="Help", command=lambda: webbrowser.open("https://spacr.readthedocs.io/en/latest/?badge=latest"))
+    app_menu.add_command(label="Exit", command=root.quit)
+
+    # Configure the menu for the root window
+    root.config(menu=menu_bar)
+
 def set_element_size():
 
     screen_width, screen_height = pyautogui.size()
@@ -2122,7 +2163,7 @@ class ModifyMaskApp:
         self.update_display()
 
 class AnnotateApp:
-    def __init__(self, root, db_path, src, image_type=None, channels=None, image_size=200, annotation_column='annotate', normalize=False, percentiles=(1, 99), measurement=None, threshold=None):
+    def __init__(self, root, db_path, src, image_type=None, channels=None, image_size=200, annotation_column='annotate', normalize=False, percentiles=(1, 99), measurement=None, threshold=None, normalize_channels=None):
         self.root = root
         self.db_path = db_path
         self.src = src
@@ -2148,7 +2189,8 @@ class AnnotateApp:
         self.update_queue = Queue()
         self.measurement = measurement
         self.threshold = threshold
-
+        self.normalize_channels = normalize_channels
+        print('self.normalize_channels',self.normalize_channels)
         style_out = set_dark_style(ttk.Style())
         self.font_loader = style_out['font_loader']
         self.font_size = style_out['font_size']
@@ -2157,7 +2199,6 @@ class AnnotateApp:
         self.active_color = style_out['active_color']
         self.inactive_color = style_out['inactive_color']
 
-
         if self.font_loader:
             self.font_style = self.font_loader.get_font(size=self.font_size)
         else:
@@ -2356,14 +2397,26 @@ class AnnotateApp:
     def load_single_image(self, path_annotation_tuple):
         path, annotation = path_annotation_tuple
         img = Image.open(path)
-        img = self.normalize_image(img, self.normalize, self.percentiles)
+        img = self.normalize_image(img, self.normalize, self.percentiles, self.normalize_channels)
         img = img.convert('RGB')
         img = self.filter_channels(img)
         img = img.resize(self.image_size)
         return img, annotation
-
+    
     @staticmethod
-    def normalize_image(img, normalize=False, percentiles=(1, 99)):
+    def normalize_image(img, normalize=False, percentiles=(1, 99), normalize_channels=None):
+        """
+        Normalize an image based on specific channels (R, G, B).
+
+        Args:
+            img (PIL.Image or np.array): Input image.
+            normalize (bool): Whether to normalize the image or not.
+            percentiles (tuple): Percentiles to use for intensity rescaling.
+            normalize_channels (list): List of channels to normalize. E.g., ['r', 'g', 'b'], ['r'], ['g'], etc.
+
+        Returns:
+            PIL.Image: Normalized image.
+        """
         img_array = np.array(img)
 
         if normalize:
@@ -2371,13 +2424,23 @@ class AnnotateApp:
                 p2, p98 = np.percentile(img_array, percentiles)
                 img_array = rescale_intensity(img_array, in_range=(p2, p98), out_range=(0, 255))
             else:  # Color image or multi-channel image
-                for channel in range(img_array.shape[2]):
-                    p2, p98 = np.percentile(img_array[:, :, channel], percentiles)
-                    img_array[:, :, channel] = rescale_intensity(img_array[:, :, channel], in_range=(p2, p98), out_range=(0, 255))
+                # Create a map for the color channels
+                channel_map = {'r': 0, 'g': 1, 'b': 2}
+                
+                # If normalize_channels is not specified, normalize all channels
+                if normalize_channels is None:
+                    normalize_channels = ['r', 'g', 'b']
+                
+                for channel_name in normalize_channels:
+                    if channel_name in channel_map:
+                        channel_idx = channel_map[channel_name]
+                        p2, p98 = np.percentile(img_array[:, :, channel_idx], percentiles)
+                        img_array[:, :, channel_idx] = rescale_intensity(img_array[:, :, channel_idx], in_range=(p2, p98), out_range=(0, 255))
 
         img_array = np.clip(img_array, 0, 255).astype('uint8')
 
         return Image.fromarray(img_array)
+
     
     def add_colored_border(self, img, border_width, border_color):
         top_border = Image.new('RGB', (img.width, border_width), color=border_color)
@@ -2505,46 +2568,6 @@ class AnnotateApp:
         else:
             print('Waiting for pending updates to finish before quitting')
 
-def create_menu_bar(root):
-    from .gui import initiate_root
-    gui_apps = {
-        "Mask": lambda: initiate_root(root, settings_type='mask'),
-        "Measure": lambda: initiate_root(root, settings_type='measure'),
-        "Annotate": lambda: initiate_root(root, settings_type='annotate'),
-        "Make Masks": lambda: initiate_root(root, settings_type='make_masks'),
-        "Classify": lambda: initiate_root(root, settings_type='classify'),
-        "Umap": lambda: initiate_root(root, settings_type='umap'),
-        "Train Cellpose": lambda: initiate_root(root, settings_type='train_cellpose'),
-        "ML Analyze": lambda: initiate_root(root, settings_type='ml_analyze'),
-        "Cellpose Masks": lambda: initiate_root(root, settings_type='cellpose_masks'),
-        "Cellpose All": lambda: initiate_root(root, settings_type='cellpose_all'),
-        "Map Barcodes": lambda: initiate_root(root, settings_type='map_barcodes'),
-        "Regression": lambda: initiate_root(root, settings_type='regression'),
-        "Recruitment": lambda: initiate_root(root, settings_type='recruitment')
-    }
-
-    # Create the menu bar
-    menu_bar = tk.Menu(root, bg="#008080", fg="white")
-
-    # Create a "SpaCr Applications" menu
-    app_menu = tk.Menu(menu_bar, tearoff=0, bg="#008080", fg="white")
-    menu_bar.add_cascade(label="SpaCr Applications", menu=app_menu)
-
-    # Add options to the "SpaCr Applications" menu
-    for app_name, app_func in gui_apps.items():
-        app_menu.add_command(
-            label=app_name,
-            command=app_func
-        )
-
-    # Add a separator and an exit option
-    app_menu.add_separator()
-    app_menu.add_command(label="Help", command=lambda: webbrowser.open("https://spacr.readthedocs.io/en/latest/?badge=latest"))
-    app_menu.add_command(label="Exit", command=root.quit)
-
-    # Configure the menu for the root window
-    root.config(menu=menu_bar)
-
 def standardize_figure(fig):
     from .gui_elements import set_dark_style
     from matplotlib.font_manager import FontProperties