Fix CPU/GPU switching in cupy-dependent scripts

Replace bare 'import cupy' at module level with try/except ImportError
blocks that fall back to numpy on machines without cupy/cucim installed.

Changes per script:
- intersection.py: safe cupy import + GPU_AVAILABLE flag
- combine_labels.py: safe cupy/cupyx import + added CPU fallback
  merge_labels_cpu() using cle directly
- counts_validation.py: safe cucim/cupy import + GPU_AVAILABLE flag
- segmentation_instances_clahe.py: safe cupy/cucim import with skimage
  fallbacks + to_numpy helper replacing all cp.asnumpy() calls
- get_basic_regionprops.py: safe cupy/cucim import + replaced .get()
  calls with float() for numpy compatibility
- ROI_colocalization_regionprops.py: safe cupy/cucim import + replaced
  .get() calls with float()/int() for numpy compatibility
- segmentation_validation_f1_score.py: removed cupy entirely (sklearn
  requires numpy arrays, not cupy arrays)

Author: macromeer

scripts/ROI_colocalization_regionprops.py

@@ -3,8 +3,14 @@
 import argparse
 import numpy as np
 import pandas as pd
-import cupy as cp
-from cucim.skimage.measure import regionprops
+try:
+    import cupy as cp
+    from cucim.skimage.measure import regionprops
+    GPU_AVAILABLE = cp.cuda.is_available()
+except ImportError:
+    import numpy as cp
+    from skimage.measure import regionprops
+    GPU_AVAILABLE = False
 from skimage.io import imread
 from tqdm import tqdm
 
@@ -97,7 +103,7 @@ def get_regionprops(label_img, intensity_img, file_path, label_id,channels, ROI_
             pass
         df.loc[i, f'{channels[1]} label id'] = int(prop.label)
         try:
-            df.loc[i, f'{channels[1]} Size'] = prop.area.get()  # area = pixel/voxel count (2D/3D)
+            df.loc[i, f'{channels[1]} Size'] = float(prop.area)  # area = pixel/voxel count (2D/3D)
         except ValueError:
             print(f"Skipping size for region {prop.label} due to numerical error.")
             df.loc[i, f'{channels[1]} Size'] = np.nan
@@ -122,22 +128,22 @@ def get_regionprops(label_img, intensity_img, file_path, label_id,channels, ROI_
             print(f"Skipping minor axis length for region {prop.label} due to numerical error.")
             df.loc[i, f'{channels[1]} MinorAxisLength'] = np.nan
         try:
-            df.loc[i, f'{channels[1]} MeanIntensity'] = prop.intensity_mean.get()
+            df.loc[i, f'{channels[1]} MeanIntensity'] = float(prop.intensity_mean)
         except ValueError:
             print(f"Skipping mean intensity for region {prop.label} due to numerical error.")
             df.loc[i, f'{channels[1]} MeanIntensity'] = np.nan
         try:
-            df.loc[i, f'{channels[1]} MedianIntensity'] = prop.median_intensity.get()
+            df.loc[i, f'{channels[1]} MedianIntensity'] = float(prop.median_intensity)
         except ValueError:
             print(f"Skipping median intensity for region {prop.label} due to numerical error.")
             df.loc[i, f'{channels[1]} MedianIntensity'] = np.nan
         try:
-            df.loc[i, f'{channels[1]} MaxIntensity'] = prop.intensity_max.get()
+            df.loc[i, f'{channels[1]} MaxIntensity'] = float(prop.intensity_max)
         except ValueError:
             print(f"Skipping max intensity for region {prop.label} due to numerical error.")
             df.loc[i, f'{channels[1]} MaxIntensity'] = np.nan
         try:
-            df.loc[i, f'{channels[1]} StdIntensity'] = prop.std_intensity.get()
+            df.loc[i, f'{channels[1]} StdIntensity'] = float(prop.std_intensity)
         except ValueError:
             print(f"Skipping std intensity for region {prop.label} due to numerical error.")
             df.loc[i, f'{channels[1]} StdIntensity'] = np.nan
@@ -174,15 +180,15 @@ def get_intensity_only_regionprops(ROI_mask, intensity_img, file_path, label_id,
         df.loc[0, f'{channels[0]} label id'] = label_id
         if ROI_size.lower() == 'y':
             # Calculate ROI size in pixels/voxels (works for both 2D and 3D)
-            roi_size = int(cp.sum(ROI_mask_gpu > 0).get())
+            roi_size = int(cp.sum(ROI_mask_gpu > 0))
             df.loc[0, f'{channels[0]} Size'] = roi_size
 
         # Intensity measurements
-        df.loc[0, f'{channels[1]} MeanIntensity'] = float(cp.mean(intensity_values).get())
-        df.loc[0, f'{channels[1]} MedianIntensity'] = float(cp.median(intensity_values).get())
-        df.loc[0, f'{channels[1]} StdIntensity'] = float(cp.std(intensity_values).get())
-        df.loc[0, f'{channels[1]} MaxIntensity'] = float(cp.max(intensity_values).get())
-        df.loc[0, f'{channels[1]} MinIntensity'] = float(cp.min(intensity_values).get())
+        df.loc[0, f'{channels[1]} MeanIntensity'] = float(cp.mean(intensity_values))
+        df.loc[0, f'{channels[1]} MedianIntensity'] = float(cp.median(intensity_values))
+        df.loc[0, f'{channels[1]} StdIntensity'] = float(cp.std(intensity_values))
+        df.loc[0, f'{channels[1]} MaxIntensity'] = float(cp.max(intensity_values))
+        df.loc[0, f'{channels[1]} MinIntensity'] = float(cp.min(intensity_values))
 
     return df
 

scripts/combine_labels.py

@@ -2,8 +2,14 @@
 import numpy as np
 from tifffile import imread, imwrite
 import argparse
-import cupy as cp
-import cupyx.scipy.ndimage as cpndi
+try:
+    import cupy as cp
+    import cupyx.scipy.ndimage as cpndi
+    GPU_AVAILABLE = cp.cuda.is_available()
+except ImportError:
+    import numpy as cp
+    import scipy.ndimage as cpndi
+    GPU_AVAILABLE = False
 from tqdm import tqdm
 import pyclesperanto_prototype as cle
 
@@ -49,18 +55,27 @@ def merge_labels_gpu(label1, label2):
 
     return result.astype(np.uint32)  # Convert back to uint32
 
+def merge_labels_cpu(label1, label2):
+    label1_img = imread(label1).astype(np.float32)
+    label2_img = imread(label2).astype(np.float32)
+    label1_cle = cle.push(label1_img)
+    label2_cle = cle.push(label2_img)
+    result_cle = cle.create_like(label1_cle)
+    cle.combine_labels(label1_cle, label2_cle, result_cle)
+    return cle.pull(result_cle).astype(np.uint32)
+
 
 
 for idx, filename in enumerate(tqdm(filenames, total=len(filenames), desc="Processing images")):
     label1 = os.path.join(args.input, filename + args.label1_tag)
     label2 = os.path.join(args.input, filename + args.label2_tag)
 
-    if cp.cuda.is_available():
+    if GPU_AVAILABLE:
         result = merge_labels_gpu(label1, label2)
         print('\nUsing GPU')
     else:
-        print('\nGPU not available. This script requires GPU.')
-        break
+        result = merge_labels_cpu(label1, label2)
+        print('\nUsing CPU')
 
     imwrite(os.path.join(args.input, filename + args.output_tag), 
             result, compression='zlib')

scripts/counts_validation.py

@@ -5,8 +5,14 @@
 import pandas as pd
 from tqdm import tqdm
 import sys
-from cucim.skimage.measure import regionprops as regionprops_gpu
-import cupy as cp
+try:
+    from cucim.skimage.measure import regionprops as regionprops_gpu
+    import cupy as cp
+    GPU_AVAILABLE = cp.cuda.is_available()
+except ImportError:
+    regionprops_gpu = None
+    import numpy as cp
+    GPU_AVAILABLE = False
 
 def parse_args():
     parser = argparse.ArgumentParser(description='Validate segmentation results against manual segmentation results.')
@@ -77,7 +83,7 @@ def main():
         sys.exit(1)
 
     results = []
-    use_gpu = cp.cuda.is_available()
+    use_gpu = GPU_AVAILABLE
 
     for gt_file, pred_file in tqdm(zip(ground_truths, predictions), total=len(ground_truths), desc="Processing images"):
         result = validate_segmentation(gt_file, pred_file, use_gpu)

scripts/get_basic_regionprops.py

@@ -3,8 +3,14 @@
 import sys
 import pandas as pd
 from skimage import io
-import cupy as cp
-from cucim.skimage.measure import regionprops
+try:
+    import cupy as cp
+    from cucim.skimage.measure import regionprops
+    GPU_AVAILABLE = cp.cuda.is_available()
+except ImportError:
+    import numpy as cp
+    from skimage.measure import regionprops
+    GPU_AVAILABLE = False
 from tqdm import tqdm
 import numpy as np
 
@@ -93,9 +99,9 @@ def get_regionprops(label_img_path, intensity_img_path=None):
         for i, prop in enumerate(props):
             df.loc[i, 'Filename'] = os.path.basename(label_img_path)
             df.loc[i, 'Labels_ID'] = int(prop.label) 
-            df.loc[i, 'Area'] = prop.area.get() * area_scale
+            df.loc[i, 'Area'] = float(prop.area) * area_scale
             df.loc[i, 'Area_Unit'] = area_unit
-            #df.loc[i, 'Perimeter'] = prop.perimeter.get()
+            #df.loc[i, 'Perimeter'] = float(prop.perimeter)
 
             # Check if the image is 3D and skip eccentricity
             if label_img.ndim == 3:
@@ -107,17 +113,17 @@ def get_regionprops(label_img_path, intensity_img_path=None):
             df.loc[i, 'MajorAxisLength_Unit'] = length_unit
             df.loc[i, 'MinorAxisLength'] = prop.minor_axis_length * length_scale
             df.loc[i, 'MinorAxisLength_Unit'] = length_unit
-            df.loc[i, 'MeanIntensity'] =  prop.intensity_mean.get()
-            df.loc[i, 'MaxIntensity'] =  prop.intensity_max.get()
+            df.loc[i, 'MeanIntensity'] = float(prop.intensity_mean)
+            df.loc[i, 'MaxIntensity'] = float(prop.intensity_max)
 
     else:
         props = regionprops(label_img)
         for i, prop in enumerate(props):
             df.loc[i, 'Filename'] = os.path.basename(label_img_path)
             df.loc[i, 'Labels_ID'] = int(prop.label) 
-            df.loc[i, 'Area'] = prop.area.get() * area_scale
+            df.loc[i, 'Area'] = float(prop.area) * area_scale
             df.loc[i, 'Area_Unit'] = area_unit
-            #df.loc[i, 'Perimeter'] = prop.perimeter.get()
+            #df.loc[i, 'Perimeter'] = float(prop.perimeter)
 
             # Check if the image is 3D and skip eccentricity
             if label_img.ndim == 3:

scripts/intersection.py

@@ -1,9 +1,15 @@
 import os
 from tifffile import imread, imwrite
 import argparse
-import cupy as cp
 from tqdm import tqdm
 
+try:
+    import cupy as cp
+    GPU_AVAILABLE = cp.cuda.is_available()
+except ImportError:
+    import numpy as cp
+    GPU_AVAILABLE = False
+
 """
 Description: This script creates a new image by intersecting two images. 
 This is done by setting the pixel values of the original image to zero where the mask image is zero.
@@ -43,7 +49,7 @@ def intersection_gpu(mask, original):
     mask = os.path.join(args.input, filename + args.maskfiles)
     original = os.path.join(args.input, filename + args.intersectfiles)
 
-    if cp.cuda.is_available():
+    if GPU_AVAILABLE:
         result = intersection_gpu(mask, original)
         print('\nUsing GPU')
     else:

scripts/segmentation_instances_clahe.py

@@ -1,13 +1,25 @@
 import os
 import glob
+import numpy as np
 import tifffile as tf
 import argparse
 from skimage import exposure
-import cupy as cp
-from cucim.skimage import morphology
-from cucim.skimage.filters import gaussian
-from cucim.skimage.filters.thresholding import threshold_otsu
-from cucim.skimage.measure import label
+try:
+    import cupy as cp
+    from cucim.skimage import morphology
+    from cucim.skimage.filters import gaussian
+    from cucim.skimage.filters.thresholding import threshold_otsu
+    from cucim.skimage.measure import label
+    GPU_AVAILABLE = cp.cuda.is_available()
+except ImportError:
+    import numpy as cp
+    from skimage import morphology
+    from skimage.filters import gaussian
+    from skimage.filters import threshold_otsu
+    from skimage.measure import label
+    GPU_AVAILABLE = False
+
+to_numpy = cp.asnumpy if GPU_AVAILABLE else np.asarray
 import pyclesperanto_prototype as cle
 from tqdm import tqdm
 
@@ -70,7 +82,7 @@ def intersect_clahe_go(mask,image, kernel_size, clip_limit, nbins, outline_sigma
     mask = cp.asarray(tf.imread(mask))
     image = cp.asarray(tf.imread(image))
     image[mask == 0] = 0    
-    image_clahe = exposure.equalize_adapthist(cp.asnumpy(image), kernel_size=kernel_size, clip_limit=clip_limit, nbins=nbins)
+    image_clahe = exposure.equalize_adapthist(to_numpy(image), kernel_size=kernel_size, clip_limit=clip_limit, nbins=nbins)
     image_gol = gaussian(cp.asarray(image_clahe), sigma=outline_sigma, preserve_range=True)
     threshold = threshold_otsu(image_gol)
     binary = image_gol >= threshold
@@ -79,7 +91,7 @@ def intersect_clahe_go(mask,image, kernel_size, clip_limit, nbins, outline_sigma
     label_image = cle.push(cp.asarray(label_image))
     label_image = cle.exclude_small_labels(label_image, None, LOWER_THRESHOLD)
     label_image = cle.exclude_large_labels(label_image, None, UPPER_THRESHOLD)
-    label_image = cp.asnumpy(label_image)
+    label_image = to_numpy(label_image)
     return label_image
 
 for idx, (mask_file, intensity_file) in enumerate(tqdm(zip(mask_files, intensity_files), 

scripts/segmentation_validation_f1_score.py

@@ -1,6 +1,6 @@
 import os
 import argparse
-import cupy as cp
+import numpy as np
 from skimage.io import imread
 import pandas as pd
 from sklearn.metrics import f1_score
@@ -57,7 +57,7 @@ def parse_args():
 for i in tqdm(range(len(predictions)), total=len(predictions), desc="Processing images"):
     prediction = imread(predictions[i])
     ground_truth = imread(ground_truths[i])
-    f1 = f1_score(cp.ravel(ground_truth), cp.ravel(prediction), average='micro') 
+    f1 = f1_score(np.ravel(ground_truth), np.ravel(prediction), average='micro')
 
     filename = os.path.basename(predictions[i])[:-11]