寻求skimage/Python中衡量细胞核边缘粗糙度的凹度指标

Great question—you’re spot-on that standard metrics like the nuclear contour index (perimeter/sqrt(area)) or basic convex hull measures don’t fit your use case: they either penalize smooth ellipses vs circles, or fail to distinguish between the widespread tiny indentations you care about and single large indentations that aren’t relevant.

Below are three skimage-based approaches tailored to measure edge roughness specifically, with a focus on differentiating those small, frequent indentations from isolated large ones:

1. Local Curvature Variance #

This metric targets the local fluctuations in edge direction—exactly what makes an edge look "jagged" from many small indentations. Smooth circles/ellipses have nearly constant curvature, so their variance will be near zero. A circle with hundreds of tiny indentations will have high curvature variance, while a shape with one large indentation will only have a small spike in curvature (so overall variance stays low).

Implementation with skimage: #

import numpy as np
from skimage.measure import find_contours
from skimage.filters import gaussian

def edge_curvature_variance(binary_mask):
    # Extract the outermost contour of the nucleus
    contours = find_contours(binary_mask, level=0.5)
    if not contours:
        return 0.0
    contour = contours[0]
    
    # Smooth the contour to reduce noise interference
    smoothed_contour = gaussian(contour.T, sigma=1).T
    
    # Calculate direction vectors between consecutive contour points
    dx = np.diff(smoothed_contour[:, 0])
    dy = np.diff(smoothed_contour[:, 1])
    angles = np.arctan2(dy, dx)
    
    # Compute changes in direction (curvature proxy)
    angle_diffs = np.diff(angles)
    # Handle angle wrapping (-π to π range)
    angle_diffs = np.mod(angle_diffs + np.pi, 2 * np.pi) - np.pi
    
    # Variance of these changes = roughness indicator
    return np.var(angle_diffs)

2. Convex Hull Local Distance Variance #

Instead of using a single convex hull ratio (which treats all indentations the same), this metric looks at the distribution of distances from the original edge to the convex hull. Many small indentations will create a wide spread of small distance values (high variance), while one large indentation will only have a few points with large distances (low variance).

Implementation with skimage: #

import numpy as np
from skimage.measure import find_contours
from skimage.morphology import convex_hull_image
from scipy.spatial.distance import cdist

def convex_hull_local_variance(binary_mask):
    # Extract original nucleus contour
    contours = find_contours(binary_mask, level=0.5)
    if not contours:
        return 0.0
    contour = contours[0]
    
    # Generate convex hull mask and extract its contour
    convex_hull_mask = convex_hull_image(binary_mask)
    hull_contours = find_contours(convex_hull_mask, level=0.5)
    if not hull_contours:
        return 0.0
    hull_contour = hull_contours[0]
    
    # Calculate minimum distance from each contour point to the convex hull
    all_distances = np.min(cdist(contour, hull_contour), axis=1)
    # Only consider points that are inside the convex hull (indentations)
    indentation_distances = all_distances[all_distances > 1e-6]
    
    if len(indentation_distances) == 0:
        return 0.0
    
    # Variance of indentation distances = roughness (small vs large indentations)
    return np.var(indentation_distances)

3. Fractal Dimension #

Fractal dimension measures the "complexity" of the edge—smooth shapes like circles/ellipses have a dimension close to 1, while jagged edges with many small details approach 2. This is a great overall roughness metric, though it’s less precise at distinguishing between small widespread indentations and single large ones compared to the above two methods.

Implementation with skimage: #

from skimage.measure import fractal_dimension

def edge_fractal_dimension(binary_mask):
    # Calculate fractal dimension of the edge (using the mask to focus on the object)
    return fractal_dimension(binary_mask, mask=binary_mask)

Key Notes for Your Workflow: #

• Preprocessing: Always apply a small Gaussian blur (skimage.filters.gaussian) to your binary masks first to eliminate salt-and-pepper noise, which can skew edge metrics.
• Multi-Object Handling: If working with multiple nuclei, use skimage.measure.label to segment individual objects, then compute metrics for each nucleus separately.
• Normalization: For consistent results across nuclei of different sizes, normalize your metrics by the object’s perimeter or area (e.g., divide curvature variance by perimeter).

内容的提问来源于stack exchange，提问作者Uğur Dinç