microlive 1.0.12__py3-none-any.whl → 1.0.19__py3-none-any.whl

microlive/imports.py

@@ -23,7 +23,11 @@ from numba import njit, types
 from numba.typed import List as TypedList
 import cv2
 import io
-import fpdf
+# Optional PDF generation support
+try:
+    from fpdf import FPDF
+except ImportError:
+    FPDF = None  # PDF generation will be skipped if fpdf not installed
 import json
 
 # Import third-party libraries

microlive/microscopy.py

@@ -1423,6 +1423,13 @@ class Intensity():
         optimize_spot_size: Search for optimal spot size (5-11 px). Slower. Defaults to False.
         allow_subpixel_repositioning: Search ±2px for better center. Defaults to False.
         fast_gaussian_fit: Use moment-based (fast) vs full Gaussian fit. Defaults to True.
+        snr_method: Method for calculating signal-to-noise ratio. Options:
+            - 'peak' (default): Uses the maximum pixel value in the spot region as signal.
+              This is the standard definition of SNR: (max_spot - mean_bg) / std_bg.
+              Recommended for most applications.
+            - 'disk_doughnut': Uses mean disk intensity as signal instead of peak value.
+              Calculates SNR as: (mean_disk - mean_bg) / std_bg.
+              More robust when data is very noisy or spots are dim.
     
     Attributes:
         number_spots: Number of spots to measure.
@@ -1431,7 +1438,7 @@ class Intensity():
     
     def __init__(self, original_image, spot_size=5, array_spot_location_z_y_x=None, 
                  use_max_projection=False, optimize_spot_size=False, allow_subpixel_repositioning=False,
-                 fast_gaussian_fit=True):
+                 fast_gaussian_fit=True, snr_method='peak'):
         self.original_image = original_image
         if array_spot_location_z_y_x is None:
             self.array_spot_location_z_y_x = np.array([[0, 0, 0]])
@@ -1449,6 +1456,7 @@ class Intensity():
         self.optimize_spot_size = optimize_spot_size
         self.allow_subpixel_repositioning = allow_subpixel_repositioning
         self.fast_gaussian_fit = fast_gaussian_fit
+        self.snr_method = snr_method
 
     def two_dimensional_gaussian(self, xy, amplitude, x0, y0, sigma_x, sigma_y, offset):
         """Evaluate 2D Gaussian at given coordinates."""
@@ -1551,11 +1559,23 @@ class Intensity():
     def calculate_intensity(self):
         """Calculate intensity metrics for all spots across all channels.
         
+        The signal-to-noise ratio (SNR) calculation method is controlled by the
+        `snr_method` parameter set during class initialization:
+        
+        - **'peak'** (default): Uses the maximum pixel value in the spot region 
+          as the signal. This is the standard definition of SNR commonly used 
+          in microscopy: SNR = (max_spot - mean_background) / std_background.
+          
+        - **'disk_doughnut'**: Uses the mean disk intensity as signal instead 
+          of the peak value. This method is more robust for very noisy data 
+          or dim spots where the maximum value may be unreliable due to noise.
+          SNR = (mean_disk - mean_background) / std_background.
+        
         Returns:
             tuple: 8-element tuple of arrays, each with shape [N_spots, N_channels]:
                 - intensities: Background-subtracted intensity (disk - doughnut mean).
                 - intensities_std: Standard deviation within disk region.
-                - intensities_snr: Signal-to-noise ratio (disk-bg) / std(bg).
+                - intensities_snr: Signal-to-noise ratio (calculation depends on snr_method).
                 - intensities_background_mean: Mean background from doughnut.
                 - intensities_background_std: Std of background from doughnut.
                 - psfs_amplitude: PSF peak amplitude from Gaussian fit (or NaN).
@@ -1577,11 +1597,31 @@ class Intensity():
             donut_values = tem_img[~np.isnan(tem_img)].astype('uint16')
             return donut_values
 
-        def signal_to_noise_ratio(values_disk, values_donut):
-            mean_disk = np.mean(values_disk.astype(float))
+        def signal_to_noise_ratio(values_disk, values_donut, snr_method='peak'):
+            """Calculate signal-to-noise ratio for a spot.
+            
+            Args:
+                values_disk: Pixel values in the spot disk region.
+                values_donut: Pixel values in the background doughnut region.
+                snr_method: 'peak' uses max pixel value as signal (standard),
+                           'disk_doughnut' uses mean disk intensity (robust for noisy data).
+            
+            Returns:
+                tuple: (SNR, mean_background, std_background)
+            """
             mean_donut = np.mean(values_donut.astype(float))
             std_donut = np.std(values_donut.astype(float))
-            SNR = (mean_disk - mean_donut) / std_donut if std_donut > 0 else 0
+            
+            if snr_method == 'peak':
+                # Standard SNR: use peak (maximum) pixel value as signal
+                max_disk = np.max(values_disk.astype(float))
+                signal = max_disk - mean_donut
+            else:
+                # disk_doughnut method: use mean disk intensity as signal
+                mean_disk = np.mean(values_disk.astype(float))
+                signal = mean_disk - mean_donut
+            
+            SNR = signal / std_donut if std_donut > 0 else 0
             return SNR, mean_donut, std_donut
 
         def disk_donut(values_disk, values_donut, spot_size):
@@ -1749,7 +1789,7 @@ class Intensity():
                 # Use the updated integer positions for the final intensity crop
                 crop_disk_and_donut = return_crop(frame_data[:,:,i], current_x_int, current_y_int, spot_range=crop_range)
                 values_donut = return_donut(crop_disk_and_donut, spot_size=best_size)
-                intensities_snr[sp,i], intensities_background_mean[sp,i], intensities_background_std[sp,i] = signal_to_noise_ratio(values_disk, values_donut)
+                intensities_snr[sp,i], intensities_background_mean[sp,i], intensities_background_std[sp,i] = signal_to_noise_ratio(values_disk, values_donut, self.snr_method)
                 # disk_donut calculation
                 intensities[sp,i], intensities_std[sp,i] = disk_donut(values_disk, values_donut, spot_size=best_size)
                 intensities_total[sp,i] = np.sum(values_disk)
@@ -3908,7 +3948,8 @@ class BigFISH():
         
         # Select isolated spots (cluster_id < 0) and set cluster_size to 1
         spots_no_clusters = clusters_and_spots_big_fish[clusters_and_spots_big_fish[:,-1] < 0].copy()
-        spots_no_clusters[:,-1] = 1  # Replace cluster_id with cluster_size=1
+        if len(spots_no_clusters) > 0:
+            spots_no_clusters[:,-1] = 1  # Replace cluster_id with cluster_size=1
         
         # Select cluster centroids with cluster_size > 1
         clusters_no_spots = clusters[clusters[:,-2] > 1]
@@ -4972,6 +5013,7 @@ class DataProcessing():
         self.fast_gaussian_fit = fast_gaussian_fit
         # This number represent the number of columns that doesnt change with the number of color channels in the image
         self.NUMBER_OF_CONSTANT_COLUMNS_IN_DATAFRAME = 18
+        
     def get_dataframe(self):
         '''
         This method extracts data from the class SpotDetection and returns the data as a dataframe.
@@ -5122,7 +5164,7 @@ class DataProcessing():
                     array_spots_nuc[:,10:13] = spots_nuc[:,:3]   # populating coord 
                     array_spots_nuc[:,13] = 1                   # is_nuc
                     array_spots_nuc[:,14] = 0                   # is_cluster
-                    array_spots_nuc[:,15] = 0                   # cluster_size
+                    array_spots_nuc[:,15] = spots_nuc[:,3]      # cluster_size (use actual detected value)
                     array_spots_nuc[:,16] =  spot_type          # spot_type
                     array_spots_nuc[:,17] =  is_cell_in_border  # is_cell_fragmented
             
@@ -5131,7 +5173,7 @@ class DataProcessing():
                     array_spots_cytosol_only[:,10:13] = spots_cytosol_only[:,:3]    # populating coord 
                     array_spots_cytosol_only[:,13] = 0                             # is_nuc
                     array_spots_cytosol_only[:,14] = 0                             # is_cluster
-                    array_spots_cytosol_only[:,15] = 1                            # cluster_size
+                    array_spots_cytosol_only[:,15] = spots_cytosol_only[:,3]       # cluster_size (use actual detected value)
                     array_spots_cytosol_only[:,16] =  spot_type                    # spot_type
                     array_spots_cytosol_only[:,17] =  is_cell_in_border            # is_cell_fragmented
                 if (detected_cyto_clusters == True): #(detected_cyto == True) and 

microlive/pipelines/pipeline_FRAP.py

@@ -1,7 +1,14 @@
-"""Pipeline module for MicroLive.
+"""Pipeline module for MicroLive FRAP analysis.
 
-This module is part of the microlive package.
+This module is part of the microlive package and provides functions for
+Fluorescence Recovery After Photobleaching (FRAP) analysis.
+
+The pipeline uses a pretrained Cellpose model for nuclei segmentation that
+is automatically downloaded from GitHub on first use.
 """
+import os
+import traceback
+
 from microlive.imports import *
 
 from skimage.feature import canny
@@ -12,6 +19,95 @@ from skimage.morphology import binary_opening, binary_closing
 from skimage.measure import label, regionprops
 from skimage.transform import hough_circle, hough_circle_peaks
 
+# Import model downloader with graceful fallback
+try:
+    from microlive.utils.model_downloader import get_frap_nuclei_model_path
+    _HAS_MODEL_DOWNLOADER = True
+except ImportError:
+    _HAS_MODEL_DOWNLOADER = False
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# GPU Detection and MPS Compatibility (aligned with microscopy.py)
+# =============================================================================
+
+class PatchMPSFloat64:
+    """
+    Context manager to safely monkeypatch torch.zeros on MPS devices 
+    to force float32 instead of float64 (which is not supported).
+    
+    Copied from microlive.microscopy for self-contained FRAP pipeline.
+    """
+    def __init__(self):
+        self.original_zeros = torch.zeros
+        self.is_mps = torch.backends.mps.is_available() and torch.backends.mps.is_built()
+
+    def __enter__(self):
+        if not self.is_mps:
+            return
+        
+        def patched_zeros(*args, **kwargs):
+            # Check if device is MPS (either string or torch.device)
+            device = kwargs.get('device', None)
+            is_target_device = False
+            if device is not None:
+                if isinstance(device, str) and 'mps' in device:
+                    is_target_device = True
+                elif isinstance(device, torch.device) and device.type == 'mps':
+                    is_target_device = True
+            
+            # Check if dtype is float64/double
+            dtype = kwargs.get('dtype', None)
+            is_target_dtype = (dtype == torch.float64 or dtype == torch.double)
+
+            if is_target_device and is_target_dtype:
+                kwargs['dtype'] = torch.float32
+            
+            return self.original_zeros(*args, **kwargs)
+        
+        torch.zeros = patched_zeros
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.is_mps:
+            torch.zeros = self.original_zeros
+
+
+def _detect_gpu():
+    """
+    Detect available GPU (CUDA or MPS) for Cellpose.
+    
+    Returns:
+        bool: True if GPU is available (CUDA or MPS), False otherwise.
+    """
+    os.environ['PYTORCH_ENABLE_MPS_FALLBACK'] = '1'
+    return torch.cuda.is_available() or torch.backends.mps.is_available()
+
+
+def _get_frap_nuclei_model():
+    """
+    Get the path to the pretrained FRAP nuclei segmentation model.
+    
+    Downloads from GitHub on first use, caches locally in ~/.microlive/models/.
+    Returns None if download fails, allowing fallback to default Cellpose model.
+    
+    Returns:
+        str or None: Path to the model file, or None if unavailable.
+    """
+    if not _HAS_MODEL_DOWNLOADER:
+        logger.debug("Model downloader not available, using default nuclei model")
+        return None
+    
+    try:
+        model_path = get_frap_nuclei_model_path()
+        logger.info(f"Using pretrained FRAP nuclei model: {model_path}")
+        return model_path
+    except Exception as e:
+        logger.warning(f"Could not load FRAP nuclei model: {e}. Using default.")
+        return None
+
 def read_lif_files_in_folder(folder_path):
     # create funtion that read all the .lif files in a folder and return the list of images
     list_folders = list(folder_path.glob('*.lif'))
@@ -160,43 +256,111 @@ def find_frap_coordinates(image_TXY, frap_time, stable_FRAP_channel, min_diamete
         return None, None
 
 
-def segment_image(image_TXY, step_size=5, pretrained_model_segmentation=None, frap_time=None, pixel_dilation_pseudo_cytosol=10,stable_FRAP_channel=0,min_diameter=10):
+def segment_image(image_TXY, step_size=5, pretrained_model_segmentation='auto', frap_time=None, pixel_dilation_pseudo_cytosol=10,stable_FRAP_channel=0,min_diameter=10):
+    """
+    Segment nuclei in FRAP image stack using Cellpose.
+    
+    Args:
+        image_TXY: 3D image array (Time, X, Y).
+        step_size: Number of frames between segmentations.
+        pretrained_model_segmentation: Model to use:
+            - 'auto' (default): Auto-download and use FRAP-optimized model from GitHub
+            - None or 'nuclei': Use default Cellpose nuclei model
+            - str path: Use custom pretrained model at given path
+        frap_time: Frame index of FRAP event.
+        pixel_dilation_pseudo_cytosol: Pixels to dilate for pseudo-cytosol.
+        stable_FRAP_channel: Channel index for stable signal.
+        min_diameter: Minimum ROI diameter in pixels.
+    
+    Returns:
+        Tuple of (masks_TXY, background_mask, pseudo_cytosol_masks_TXY).
+    """
     num_pixels_to_dilate = 1
-    use_gpu = False  # or True if you want to try MPS on Apple Silicon
-    if pretrained_model_segmentation is not None:
+    
+    # GPU detection (aligned with microscopy.py)
+    use_gpu = _detect_gpu()
+    logger.debug(f"FRAP Pipeline: GPU available = {use_gpu}")
+    
+    # Ensure image is float32 for MPS compatibility
+    image_TXY = image_TXY.astype(np.float32)
+    
+    # Determine which model to use
+    if pretrained_model_segmentation == 'auto':
+        # Auto-download FRAP-optimized model from GitHub
+        pretrained_model_segmentation = _get_frap_nuclei_model()
+    
+    # Helper function to run Cellpose with error handling
+    def _run_cellpose_eval(model, image, model_type_fallback=None, **kwargs):
+        """Run Cellpose evaluation with MPS error handling and CPU fallback."""
+        nonlocal use_gpu
+        try:
+            with PatchMPSFloat64():
+                return model.eval(image, **kwargs)[0]
+        except RuntimeError as e:
+            if "sparse" in str(e) and torch.backends.mps.is_available():
+                logger.warning(f"MPS sparse error detected: {e}. Retrying with resample=False.")
+                try:
+                    kwargs['resample'] = False
+                    with PatchMPSFloat64():
+                        return model.eval(image, **kwargs)[0]
+                except RuntimeError as e2:
+                    logger.warning(f"MPS error persisted: {e2}. Falling back to CPU.")
+                    # Reinitialize model on CPU
+                    if model_type_fallback is not None:
+                        model = models.CellposeModel(gpu=False, model_type=model_type_fallback)
+                    else:
+                        model = models.CellposeModel(gpu=False, pretrained_model=pretrained_model_segmentation)
+                    use_gpu = False
+                    kwargs.pop('resample', None)  # Reset resample
+                    return model.eval(image, **kwargs)[0]
+            else:
+                logger.error(f"Cellpose RuntimeError: {e}")
+                logger.error(traceback.format_exc())
+                return np.zeros(image.shape[:2], dtype=np.uint16)
+        except Exception as e:
+            logger.error(f"Cellpose error: {e}")
+            logger.error(traceback.format_exc())
+            return np.zeros(image.shape[:2], dtype=np.uint16)
+    
+    # Initialize models
+    if pretrained_model_segmentation is not None and pretrained_model_segmentation != 'nuclei':
+        logger.info(f"Using pretrained model for nuclei segmentation")
         model_nucleus = models.CellposeModel(
             gpu=use_gpu,
             pretrained_model=pretrained_model_segmentation
         )
     else:
+        logger.info("Using default Cellpose nuclei model")
         model_nucleus = models.CellposeModel(
             gpu=use_gpu,
             model_type='nuclei'
         )
-    #model_cyto = models.Cellpose(gpu=False, model_type='cyto2')
-    model_cyto = models.CellposeModel( gpu=use_gpu, model_type='cyto2')
+    model_cyto = models.CellposeModel(gpu=use_gpu, model_type='cyto2')
+    
     num_steps = (image_TXY.shape[0] + step_size - 1) // step_size
     list_masks = []
     list_selected_mask_id = []
     list_selected_masks = []
     list_masks_cyto = []
+    
     # If frap_time is provided, segment the FRAP images and select the mask with maximum intensity change
     if frap_time is not None:
         # Ensure frap_time is within valid range
         if frap_time < 1 or frap_time >= image_TXY.shape[0] - 1:
             raise ValueError("frap_time must be within the range of the image stack.")
         # Segment the image at frap_time
-        #masks_frap = model_nucleus.eval(image_TXY[frap_time], normalize=True, channels=[0,0], flow_threshold=0.8, diameter=150, min_size=100)[0]
-        masks_frap = model_nucleus.eval(
+        masks_frap = _run_cellpose_eval(
+            model_nucleus,
             image_TXY[frap_time],
-            channels=[0, 0],          # ← add this!
+            model_type_fallback='nuclei',
+            channels=[0, 0],
             normalize=True,
             flow_threshold=1,
             diameter=150,
             min_size=50
-        )[0]
+        )
         # remove all the maks that are touching the border
-        masks_frap =remove_border_masks(masks_frap,min_size=50)
+        masks_frap = remove_border_masks(masks_frap, min_size=50)
         # Get unique mask labels (excluding background)
         mask_labels = np.unique(masks_frap)
         mask_labels = mask_labels[mask_labels != 0]
@@ -210,13 +374,10 @@ def segment_image(image_TXY, step_size=5, pretrained_model_segmentation=None, fr
                     selected_mask_frap = binary_dilation(selected_mask_frap, iterations=num_pixels_to_dilate).astype('int')
                     break
             else:
-                #selected_mask_id_frap = None
                 selected_mask_frap = None
         else:
-            #selected_mask_id_frap = None
             selected_mask_frap = None
     else:
-        #selected_mask_id_frap = None
         selected_mask_frap = None
     if selected_mask_frap is None:
         return None, None, None
@@ -224,19 +385,29 @@ def segment_image(image_TXY, step_size=5, pretrained_model_segmentation=None, fr
     for step in range(num_steps):
         i = step * step_size
         # Detecting masks in i-th frame
-        masks = model_nucleus.eval(
+        masks = _run_cellpose_eval(
+            model_nucleus,
             image_TXY[i],
-            channels=[0, 0],         
+            model_type_fallback='nuclei',
+            channels=[0, 0],
             normalize=True,
             flow_threshold=1,
             diameter=150,
             min_size=50
-        )[0]
+        )
         list_masks.append(masks)
-        masks =remove_border_masks(masks,min_size=50)
+        masks = remove_border_masks(masks, min_size=50)
         # Detect cytosol masks only every `step_size` frames
         if step % 2 == 0:
-            masks_cyto = model_cyto.eval(image_TXY[i], normalize=True, flow_threshold=0.5, diameter=250, min_size=100)[0]
+            masks_cyto = _run_cellpose_eval(
+                model_cyto,
+                image_TXY[i],
+                model_type_fallback='cyto2',
+                normalize=True,
+                flow_threshold=0.5,
+                diameter=250,
+                min_size=100
+            )
             list_masks_cyto.append(masks_cyto)
         if frap_time is None:
             # Selecting the mask that is in the center of the image
@@ -311,7 +482,7 @@ def segment_image(image_TXY, step_size=5, pretrained_model_segmentation=None, fr
 
 
 
-def create_image_arrays(list_concatenated_images, selected_image=0, FRAP_channel_to_quantify=0,pretrained_model_segmentation=None,frap_time=None, starting_changing_frame=40, step_size_increase=5,min_diameter=10):
+def create_image_arrays(list_concatenated_images, selected_image=0, FRAP_channel_to_quantify=0,pretrained_model_segmentation='auto',frap_time=None, starting_changing_frame=40, step_size_increase=5,min_diameter=10, segmentation_step_size=5):
     image_TZXYC = list_concatenated_images[selected_image] # shape (T Z Y X C)
     print('Image with shape (T Z Y X C):\n ' ,list_concatenated_images[selected_image].shape) # TZYXC
     print('Original Image pixel ', 'min: {:.2f}, max: {:.2f}, mean: {:.2f}, std: {:.2f}'.format(np.min(image_TZXYC), np.max(image_TZXYC), np.mean(image_TZXYC), np.std(image_TZXYC)) )
@@ -328,7 +499,7 @@ def create_image_arrays(list_concatenated_images, selected_image=0, FRAP_channel
     image_TXY_stable_FRAP = image_TZXYC[:,0,:,:,stable_FRAP_channel] # shape (T X Y)
     image_TXY_stable_FRAP_8bit = (image_TXY_stable_FRAP - np.min(image_TXY_stable_FRAP)) / (np.max(image_TXY_stable_FRAP) - np.min(image_TXY_stable_FRAP)) * 255
 
-    masks_TXY, background_mask, pseudo_cytosol_masks_TXY = segment_image(image_TXY_stable_FRAP_8bit, step_size=5, pretrained_model_segmentation=pretrained_model_segmentation,frap_time=frap_time,stable_FRAP_channel=FRAP_channel_to_quantify,min_diameter=min_diameter)
+    masks_TXY, background_mask, pseudo_cytosol_masks_TXY = segment_image(image_TXY_stable_FRAP_8bit, step_size=segmentation_step_size, pretrained_model_segmentation=pretrained_model_segmentation,frap_time=frap_time,stable_FRAP_channel=FRAP_channel_to_quantify,min_diameter=min_diameter)
    
     if masks_TXY is None:
         return None, None, None, None, None, None, None
@@ -969,7 +1140,25 @@ def plot_frap_quantification_all_images(df_tracking_all, save_plot=False, plot_n
     return  np.array(frames),  np.array(mean_values), np.array(std_values)
 
 
-def create_pdf(list_combined_image_paths,pdf_name, remove_original_images=False):
+def create_pdf(list_combined_image_paths, pdf_name, remove_original_images=False):
+    """Create a PDF document from a list of images.
+    
+    Args:
+        list_combined_image_paths: List of Path objects to images.
+        pdf_name: Output PDF file path.
+        remove_original_images: If True, delete original images after adding to PDF.
+    
+    Returns:
+        None
+    
+    Note:
+        Requires fpdf/fpdf2 package. If not installed, prints a warning and skips PDF creation.
+    """
+    if FPDF is None:
+        print(f"Warning: fpdf not installed. Skipping PDF creation: {pdf_name}")
+        print("Install with: pip install fpdf2")
+        return None
+    
     pdf = FPDF()
     pdf.set_auto_page_break(auto=True, margin=15)
     pdf.set_font("Arial", size=12)

microlive/pipelines/pipeline_folding_efficiency.py

@@ -239,31 +239,35 @@ def pipeline_folding_efficiency(original_lif_name, list_images,list_images_names
     plt.grid(axis='y', linestyle='--', alpha=0.7)
     plt.savefig(path_summary_wisker_plot, dpi=300, bbox_inches='tight')
     plt.show()
-    # Create PDF with images and quality text
-    pdf = FPDF()
-    pdf.set_auto_page_break(auto=True, margin=15)
-    pdf.set_font("Arial", size=12)
-    for i, image_path in enumerate(list_image_paths_for_pdf):
-        pdf.add_page()
-        pdf.set_xy(10, 10)
-        pdf.cell(0, 10, list_quality_text[i], 0, 1, 'L')
-        if low_quality_pdf:
-            img = Image.open(image_path)
-            base_width = 150  # Desired width in mm in the PDF
-            w_percent = (base_width / float(img.size[0]))
-            h_size = int((float(img.size[1]) * float(w_percent)))  # Height in mm to maintain aspect ratio
-            # Temporarily save resized image for quality adjustment
-            temp_path = Path(image_path).with_name(Path(image_path).stem + '_temp').with_suffix('.jpg')
-            img.save(temp_path, 'JPEG', quality=85)  # You can adjust quality to manage file size
-            pdf.image(str(temp_path), x=25, y=25, w=base_width, h=h_size)  # Now specifying both width and height
-            temp_path.unlink()  # Delete the temporary file
-        else:
-            # Directly embed the image at specified dimensions without resizing beforehand
-            img = Image.open(image_path)
-            w_percent = (150 / float(img.size[0]))
-            h_size = int((float(img.size[1]) * float(w_percent)))  # Calculate height to maintain aspect ratio
-            pdf.image(str(image_path), x=25, y=25, w=150, h=h_size)
-    pdf.output(path_summary_pdf)
+    # Create PDF with images and quality text (optional - requires fpdf)
+    if FPDF is not None:
+        pdf = FPDF()
+        pdf.set_auto_page_break(auto=True, margin=15)
+        pdf.set_font("Arial", size=12)
+        for i, image_path in enumerate(list_image_paths_for_pdf):
+            pdf.add_page()
+            pdf.set_xy(10, 10)
+            pdf.cell(0, 10, list_quality_text[i], 0, 1, 'L')
+            if low_quality_pdf:
+                img = Image.open(image_path)
+                base_width = 150  # Desired width in mm in the PDF
+                w_percent = (base_width / float(img.size[0]))
+                h_size = int((float(img.size[1]) * float(w_percent)))  # Height in mm to maintain aspect ratio
+                # Temporarily save resized image for quality adjustment
+                temp_path = Path(image_path).with_name(Path(image_path).stem + '_temp').with_suffix('.jpg')
+                img.save(temp_path, 'JPEG', quality=85)  # You can adjust quality to manage file size
+                pdf.image(str(temp_path), x=25, y=25, w=base_width, h=h_size)  # Now specifying both width and height
+                temp_path.unlink()  # Delete the temporary file
+            else:
+                # Directly embed the image at specified dimensions without resizing beforehand
+                img = Image.open(image_path)
+                w_percent = (150 / float(img.size[0]))
+                h_size = int((float(img.size[1]) * float(w_percent)))  # Calculate height to maintain aspect ratio
+                pdf.image(str(image_path), x=25, y=25, w=150, h=h_size)
+        pdf.output(path_summary_pdf)
+    else:
+        print(f"Warning: fpdf not installed. Skipping PDF creation: {path_summary_pdf}")
+        print("Install with: pip install fpdf2")
     
     # save metadata
     metadata_folding_efficiency(