Abstract
The Wound Healing Assay is a standard technique for studying cell motility, yet it faces challenges in reproducibility and data interpretation. Here we present WoundPy, a Python-based executable software featuring a user-friendly interface for semi-automatic, researcher-supervised Region of Interest detection. WoundPy streamlines image analysis and management of replicates, providing rapid graphical outputs. A key pre-processing feature is the automated vertical wound alignment, which eliminates operator-dependent errors typical of optical microscopy. Velocity results are calculated as absolute values from multi-time-point imaging. The software was tested on three datasets from biological experiments, and a comparison with ImageJ Wound Healing Size tool revealed a significant underestimation of the wound area by the latter compared to WoundPy. In conclusion, this new software offers an extremely streamlined approach that easily enables to perform an analysis that is both accurate and fast, drastically reducing the time required for both numerical data acquisition and its subsequent analysis.
Introduction
Notwithstanding advances in cell culture techniques and analytical methodologies, the wound healing assay remains necessary in many cases to conduct experiments using two-dimensional culture models for investigating cell motility. Wound healing is a complex cellular and biochemical process necessary to restore structurally damaged tissue (). This intricate mechanism encompasses phenomena such as cytoskeletal remodelling (), the acquisition of cell polarity associated with the redistribution of membrane phospholipids () and adhesion molecules (), as well as the formation of Lamellipodia, Filopodia, Pseudopodia, or Invadopodia - cytosolic protrusions that drive and determine the cell movement ().
Cell migration guides morphogenic processes during embryogenesis and remains pivotal in the adult organism for physiological and pathological responses. Notably, it drives leukocyte recruitment during inflammation and is essential for the fibroblast and endothelial cell movements required for wound healing (). Mostly, cell motility plays a prominent role in the study of pathological conditions. For instance, a cancer cell undergoing epithelial-mesenchymal transition acquire the ability to activate migratory and invasive program. These processes allow neoplastic cells to enter lymphatic and blood vessels for dissemination into the circulation, and then undergo metastatic growth in distant organs (). Most notably in cancer-related settings, the use of techniques such as the Wound Healing Assay (WHA) facilitates the assessment of the capability of the molecules under investigation to reduce the invasive and migratory potential of cancer cells. This allows an efficient preliminary screening strategy (), enabling the early exclusion of compounds that are ineffective in reducing the motility of metastatic cells in vitro, thereby preventing the unnecessary and economically demanding application of downstream molecular analyses.
However, it is well known in the literature that the different analysis software tools currently in use are labour intensive, inaccurate () and the scratch wound assay has low reproducibility (). This is mainly attributable to operator errors during wound alignment lacking live imaging support, as well as the automated Region of Interest (ROI) detection found in some tools. Such automation not only restricts user intervention but also frequently introduces algorithm-dependent systematic errors. Therefore, although WHA, as it is currently known, may be regarded as an outdated technique, it remains a cornerstone of basic research since, when properly analyzed, it enables the rapid and reproducible acquisition of important data.
To date, existing free tools for WHA analysis are primarily designed to minimize operator error during the detection of the wound area (ROI) (; ; ; ). Notably, the ImageJ Wound Healing Size Tool () employs a macro based on variance calculation, which exploits the texture difference between the high-variance cell monolayer and the smooth, cell-free gap to segment the ROI via intensity thresholding. While this tool allows the researcher to adjust critical parameters - including the variance filter radius, saturation percentage, and threshold values - it lacks real-time interactivity, requiring the entire analysis pipeline to be executed de novo for every parameter modification. This workflow significantly hinders the throughput of WHA analysis, particularly for large-scale experiments involving multiple experimental conditions, time points, and numerous replicates. Moreover, the ImageJ tool often fails to accurately detect wounds that are near closure or exhibit only small open areas. More advanced computational tools use complex image processing algorithms, each optimized for specific advantages: some specialize in refining automatic ROI detection across extensive datasets for long-duration time-lapse series (; ), while others are tailored for high-resolution motility assays (), offering precise discrimination between cell-covered regions and cell-free gaps. However, few of these tools facilitate direct comparison between experimental conditions and time points (; ), thereby relegating the post-processing of raw data to the user.
Certain tools enable velocity calculation, variously defined as mean front velocity (; ; ; ), closure rate (; ), or local velocity (; ; ; ). Mean front velocity is typically derived as half the rate of wound width reduction over time; however, without effective automation in determining the mean front position, this approach is prone to significant operator error. Conversely, closure rate is calculated as the time derivative of the percentage change in open area, providing only a relative measure rather than an absolute quantification of cell motility. Finally, sophisticated software suites allow for the calculation of absolute local velocity, but often necessitate advanced instrumentation - such as lens-free imaging for high-frequency temporal acquisition or fluorescence labeling for single-cell tracking in live microscopy. Consequently, these approaches are often cost-prohibitive and require technical resources beyond standard light microscopy. Lastly, few tools facilitate direct image-overlay analysis to visualize newly covered regions, a feature generally restricted to automated workflows that ensure a fixed field of view (; ). When images are acquired manually, such analysis is susceptible to significant error arising from human operator misalignment.
To the best of our knowledge, no currently available open-source tool featuring a user-friendly interface - executable without programming expertise - simultaneously provides time-efficient ROI detection for WHA images, scratch area measurement, direct comparison between time points within the same replicate, and aggregated quantitative analysis for comparing different conditions across biological replicates. In essence, despite the ease of image acquisition, the analytical pipeline for WHA remains incompletely automated.
Here we present WoundPy, a Python-based standalone executable tool (.exe and.app) designed to drastically reduce WHA analysis time. The tool features rapid experimental setup configuration and enables dynamic, user-guided ROI correction via the adjustment of intuitive parameters (threshold, variance radius, contrast, and minimum area). Additionally, WoundPy introduces a wound alignment function across time points, facilitating accurate analysis and cleaner data presentation even for standard light microscopy datasets. This alignment capability further expands visualization options through topological image analysis. Moreover, a key innovative feature of WoundPy is the ability to calculate the absolute velocities along the entire wound front across time points via automated ROI analysis. Following rapid ROI definition, the software yields quantitative data on wound areas and velocities (including means and standard deviations across replicates), time-dependent plots for area and velocity, cumulative histograms, topological analysis plots, and time-point overlay images for effective data presentation. The WoundPy workflow is illustrated in Figure 1.
FIGURE 1
Methods
Image acquisition and datasets
The images used for the validation of WoundPy originate from three distinct datasets. The images from the first two experimental setups were acquired using a MotiCam S6 camera on an AE 2000 (Motic) optical microscope at ×4 magnification, with a scale of 192 pixels/mm. The images from the third setup belong to a public image set BBBC019v2 from the Broad Bioimage Benchmark Collection (); specifically we used the MDCK set of images, acquired with an LSM-510 microscope (Zeiss, Germany) in non-confocal mode. The first dataset consist of images acquired for the study by (), while the second dataset was generated within the scope of an ongoing project. The first experimental setup consisted of three biological replicates using the MDA-MB-231 cell line, with three time points (0 h, 24 h, and 30 h) and two conditions (CTRL and SL-treated). The second setup included four replicates using MDA-MB-231 cells, evaluated at two time points (0 h and 24 h) across three conditions (CTRL, TreatA, and TreatB, where treatments represent potential motility inhibitors). The third setup included a single replicate using MDCK/YFP-membrane cells, with two timepoints and several conditions. Since the timepoints and conditions are not declared, timepoints of 0 h and 24 h were assumed for the test, and the conditions were renamed to L1, L2, L4, L5, L6, and L7, following the names of the images available in the dataset. The three experimental setups used for WoundPy validation are summarized in Table 1.
TABLE 1
| Experimental setup | Cell line | Timepoints (h) | Conditions | n° of replicas |
|---|---|---|---|---|
| 1 | MDA-MB-231 | 0, 24, 30 | CTRL, SL | 3 |
| 2 | MDA-MB-231 | 0, 24 | CTRL, TreatA, TreatB | 4 |
| 3 | MDCK/YFP | 0, 24 | L1, L2, L4, L5, L6, L7 | 1 |
Summary of the experimental setups used to validate WoundPy and compare results with data obtained from other tools.
Software architecture
WoundPy is a Python-based tool (version 3.12.6; Python Software Foundation, https://www.python.org/). To run the tool directly from the source code, users must install the required dependencies using the provided requirements.txt file (which pins the exact library versions used) and execute the main.py script. The software is compiled into a standalone executable (.exe and.app) and is structured around three core open-source Python files: main.py, pages.py, and analyzer.py. The first module handles application initialization and frame navigation, the second manages the Graphical User Interface (GUI) and input parameter collection, while the third contains all computational algorithms for data output. These algorithms are described in the following sections.
ROIs detection
The ROI recognition method is implemented in the detect_wound_area function using the Python OpenCV (
) and NumPy (
) libraries. First, the parameters radius of variance, threshold, contrast and minimum area are collected. Then image is converted from BGR to grayscale (cv2.cvtColor). Subsequently,
Histogram Stretchingis applied, controlled by the contrast parameter. A saturation percentage is calculated as
. The percentiles
and
of the gray distribution are then computed based on
and
. The image is clipped and normalized so that pixels between
and
span the full 0–255 range. This step enhances the cell texture against the flat background, even under suboptimal lighting conditions.
self.default_params = {“radius”: 20, “threshold”: 80, “contrast”: 1, “min_area”: 200, “is_closed”: False}
def detect_wound_area(self, img_bgr, params=None):
if params is None: params = self.default_params
if params.get(“is_closed”, False):
return np.zeros((img_bgr.shape[0], img_bgr.shape[1]), dtype=np.uint8)
gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
contrast = params.get(“contrast”, 1)
sat = contrast / 10
if sat > 0:
mi, ma = np.percentile(gray, (sat, 100 - sat))
gray = np.clip((gray - mi) * (255.0 / (ma - mi + 1e-5)), 0, 255).astype(np.uint8)
The algorithm exploits the high local variance (complex texture) of the cell monolayer compared to the low variance (uniform color) of the cell-free gap. A kernel of size is defined. The local mean () and the mean of squares () are calculated by applying a box filter (cv2.blur) with dimensions . The local variance is computed using the standard computational formula as in Equation 1:
In the code, this is implemented as
. The result is normalized (cv2.normalize) to the 0–255 range (8-bit) to obtain a “variance map”. For binarization, a fixed à is applied to the variance map using the threshold parameter. Since the wound exhibits low variance, an inverse threshold (THRESH_BINARY_INV) is used: pixels with variance below the threshold value become white (255), while others become black (0). To remove noise (small holes in the monolayer or islands within the wound), morphological operations with a
elliptical structuring element are applied (opening removes small background noise; closing fills small black holes within the white mask).
k = (params.get(“radius”, 20) * 2) + 1
f = gray.astype(np.float32)
mu = cv2.blur(f, (k, k))
mu2 = cv2.blur(f * f, (k, k))
var = cv2.normalize(mu2 - mu * mu, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)_, mask = cv2.threshold(var, params.get(“threshold”, 100), 255, cv2.THRESH_BINARY_INV)
kern = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kern, iterations=2)
mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kern, iterations=2)
Finally, contours are identified (cv2.findContours). A minimum admissible area is calculated based on the min_area parameter, and only contours exceeding this threshold are retained and drawn on the final mask. This allows for the exclusion of artifacts while preserving fragmented wounds (multiple ROIs).
cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
final = np.zeros_like(mask)
area_threshold = (mask.shape[0] * mask.shape[1]) * (params.get(“min_area”, 10) / 10000.0)
if cnts:
valid = [c for c in cnts if cv2.contourArea(c) > area_threshold]
if valid:
cv2.drawContours(final, valid, -1, 255, -1)
return final
Preprocessing: wounds alignment
Aligning wounds to the center of the image reduces errors when comparing different time points and, consequently, in velocity calculations. The alignment function is defined in the align_data method, which relies on NumPy matrix operations. The algorithm assumes vertical wounds; based on this assumption, it centers the horizontal coordinate of the gap’s centroid. The image is binarized (0 and 1), and the sum of white pixels (1, open area) is calculated along the -axis for every position. This produces a vector representing the topological profile of the scratch. Once the maximum (or the center of the maximum plateau) w_center is identified, the necessary shift is calculated as in Equation 2:
Using this value, a matrix circular shift operation is performed, moving the final band of width “shift” to the beginning of the matrix.
def align_data(self, img_bgr, mask):
mask_n = mask.astype(np.float32) / 255.0
sums = np.sum(mask_n, axis=0)
if np.max(sums) == 0: return img_bgr, mask
w_center = int(np.round(np.mean(np.where(sums == np.max(sums))[0])))
shift = int(np.round((mask.shape[1] + 1) / 2)) - w_center
return np.roll(img_bgr, shift, axis=1), np.roll(mask, shift, axis=1)
It is important to note that both the alignment and the subsequent velocity calculation strictly assume a vertical orientation of the wound. It is the user’s responsibility to pre-rotate any images exhibiting significant deviations from the vertical axis prior to importing them into WoundPy.
Calculation: absolute velocity
The software calculates the mean cell front advancement velocity based on free area variation. Unlike simple Closure Rate (often expressed in %/h), WoundPy converts this data into real physical velocity ( or ) assuming a bilateral closure model. The methods for calculating absolute velocities are defined as _compute_initial_final_vectors and _compute_over_time_vectors, both leveraging NumPy for matrix operations.
In the first case, for each pair of time points ( and ), the algorithm retrieves the respective binary masks, and . A “differential mask” () is computed to identify the pixels of the newly covered area (i.e., pixels where the wound has “healed”). The logic operation is described in Equation 3:
In the code, the operation performed is diff = m0 - (2 * mf), resulting in a matrix with a value of 0 at pixel positions covering the area at
, one on the newly covered area, and −1 on the area still open at
.
def _compute_over_time_vectors(self, buf):
df = self._buf_to_df(buf)
px_per_um = self._get_px_per_um()
for (rep, cond), group in df.groupby([“Replica”, “Condition”]):
times = sorted(group[“Time_Num”].unique())
if len(times) < 2: continue
idx0 = group.loc[group[“Time_Num”] == times[0], “idx”].values[0]
ref_shape = buf[idx0][“Mask”].shape
for i in range(len(times) - 1):
t_curr, t_next = times[i], times[i + 1]
idx_c = group.loc[group[“Time_Num”] == t_curr, “idx”].values[0]
idx_n = group.loc[group[“Time_Num”] == t_next, “idx”].values[0]
mc = buf[idx_c][“Mask”].astype(np.float32) / 255.0
mn = buf[idx_n][“Mask”].astype(np.float32) / 255.0
mc = self._ensure_same_size(ref_shape, mc)
mn = self._ensure_same_size(ref_shape, mn)
diff = mc - (2 * mn)
gray_counts = np.sum(diff == 1, axis=1)
delta_t = max(t_next - t_curr, 1.0)
vel_vec = gray_counts / (px_per_um * 2 * delta_t)
self.velocity_over_time_data.append({“Replica”: rep, “Condition”: cond,
“T_Start”: t_curr, “T_End”: t_next, “Vector”: vel_vec})
Subsequently, rather than summing the total area, the algorithm sums the healed pixels for each single horizontal row (for each value) of the image. This generates a count vector, gray_counts, where each element represents how many pixels were “closed” at that specific wound height. This approach makes the calculation robust against irregular wound topology and independent of horizontal alignment, provided the wound at is completely contained within the wound at . In this regard, alignment minimizes errors associated with lateral shifts.
For each row , the front velocity is calculated assuming that the reduction in wound width results from the simultaneous advancement of two opposing fronts (left and right). The formula applied is described in Equation 4:
Where is the number of pixels covered by cells on row in the time interval , is the user-defined physical scale factor, and the division by two accounts for the two migration fronts.
Since each image row provides an independent velocity value, an image with a height of 1000 pixels yields a spatial sample of 1000 velocities, enabling the construction of histograms and Gaussian curves that map the distribution of migration velocities along the wound edge. The mean velocity for each image is considered the mean absolute front velocity for that replicate. Importantly, the associated standard deviation (SD) reflects the spatial and topological heterogeneity of the migration front along the y-axis, rather than biological or statistical confidence.
In the second method, the algorithm iterates through all consecutive available time points (
to
,
to
, …). For each interval
, it calculates a local velocity vector
, and the mean of this vector is saved as a scalar value. This allows for the distinction, for example, between constant migration and migration that is slow in the early hours of treatment and accelerates subsequently.
def _compute_initial_final_vectors(self, buf):
df = self._buf_to_df(buf)
px_per_um = self._get_px_per_um()
for (rep, cond), group in df.groupby([“Replica”, “Condition”]):
t_min, t_max = group[“Time_Num”].min(), group[“Time_Num”].max()
if t_min == t_max: continue
idx0 = group.loc[group[“Time_Num”] == t_min, “idx”].values[0]
idxf = group.loc[group[“Time_Num”] == t_max, “idx”].values[0]
m0 = buf[idx0][“Mask”].astype(np.float32) / 255.0
mf = buf[idxf][“Mask”].astype(np.float32) / 255.0
mf = self._ensure_same_size(m0.shape, mf)
diff = m0 - (2 * mf)
gray_counts = np.sum(diff == 1, axis=1)
delta_t = max(t_max - t_min, 1.0)
self.velocity_vectors_dict[f”R{rep}_{cond}”] = gray_counts / (px_per_um * 2 *
delta_t)
Statistical analysis and PDF generation
To characterize the heterogeneity of cell migration within the population, WoundPy aggregates the row-wise absolute velocity vectors derived from the Initial-Final analysis in order to present such variability in empirical probability density functions. The method _plot_velocity_pdf performs a data pooling operation where, for each experimental condition, velocity values from all biological replicates are combined into a single statistical dataset all_values (
). While this pooling effectively visualizes the overall morphological and migratory variability across the entire cell population, it is important to clarify that any cross-condition statistical inference must be based on replicate-level summaries. For formal statistical testing between treatments, the true biological replicate serves as the independent experimental unit (e.g., n = 3 or 4), avoiding pseudoreplication. The empirical probability distribution of migration velocities is computed using the NumPy library via histogram analysis (np.histogram) with a resolution of 100 bins. The histogram is normalized (density = True) to ensure that the integral of the function equals 1, defining it as a Probability Density Function (PDF). For statistical modeling, the tool leverages the scipy.stats module from the SciPy library (
). Specifically, the norm.fit function is employed to estimate the population parameters - mean
and standard deviation
- by minimizing the likelihood function on the empirical data. When the “PDF + fitted” option is selected, these parameters are passed to the norm.pdf function to generate and overlay the theoretical Gaussian distribution curve
onto the empirical plot, allowing for a visual assessment of the normality of the migration behavior.
def _plot_velocity_pdf(self, out_dir, fit_gaussian=False):
try:
[...]
all_values = []
for vec in self.velocity_vectors_dict.values():
all_values.extend(vec)
[...]
for i, cond in enumerate(conditions):
vectors = []
replicas = self.setup_data.get(“replicas”, [])
for r in range(len(replicas)):
key = f”R{r + 1}_{cond}”
if key in self.velocity_vectors_dict:
vectors.append(self.velocity_vectors_dict[key])
if not vectors: continue
data = np.concatenate(vectors)
counts, bins = np.histogram(data, bins=100, density=True)
mu, std = norm.fit(data)
plot_items.append({[...] “counts”: counts, “mu”: mu, “std”: std})
[...]
if fit_gaussian:
pdf_fitted = norm.pdf(x_range, item[“mu”], item[“std”])
[...]
Results
Tool structure
Upon launching WoundPy, a Welcome Page is displayed.
Clicking “Start New Analysis” opens the Experimental Setup Page, where users can define experimental time points (hours) and conditions, as well as specify the directories containing the WHA images. For experiments with numerous time points, the “Auto (discrete)” function generates equally spaced time points based on the total experiment duration and the desired number of points (e.g., a 72-h experiment with five points results in 0 h, 18 h, 36 h, 54 h, and 72 h). Condition names must exactly match the substrings within the image filenames or folder names.
The software supports three distinct directory structures (Modes) for individual replicate folders. For the “Flat (all in one)” mode the software expects all images to be contained within a single root folder. The “Nested by Condition” mode is particularly useful for automated acquisition setups with numerous time points, where organization by condition is logical. Conversely, the “Nested by Timepoint” mode facilitates manual acquisition workflows, where images for all conditions are typically captured sequentially at each specific time point. Accepted image extensions are.png, .jpg, .jpeg, .tif, .tiff and.bmp. The expected directory structures for these modes are schematized in Supplementary Figure S1A.
Proceeding to the ROI and Calibration Page, the user is prompted to set the conversion factor in pixels/mm or pixels/μm (the default value is one pixel). Clicking “Detect and Review ROIs” opens a dialog window where each image can be selected to interactively adjust ROI detection parameters. These parameters, adjustable via sliders, include variance radius, variance threshold, contrast, and minimum area. Specifically, the Variance Radius defines the neighborhood size for texture calculation: increasing this value smooths the detection map, reducing noise sensitivity but potentially blurring the precise wound edge. The Variance Threshold sets the sensitivity for distinguishing cellular texture from the background; increasing this value treats lower-texture regions as empty space (expanding the detected wound area), while decreasing it captures fainter cellular structures. Contrast enhancement improves feature visibility before processing, aiding in the detection of cells with low refractive indices. Finally, the Minimum Area parameter acts as a size filter; increasing the value of this parameter eliminates isolated artifacts or debris within the gap. Since image characteristics vary depending on microscope quality, magnification, and the refractive properties of the culture medium (influenced by volume and pH), different images may require specific parameter tuning. WoundPy enables dynamic adjustment of these values, granting the operator full control over ROI definition correctness. Additionally, complete wound closure can be manually indicated by forcing the area value to 0. The dynamic ROI tuning window is shown in Supplementary Figure S1B.
Upon saving, the workflow proceeds to the Analysis Output Page, where the user selects the desired outputs. First, the wound alignment preprocessing option can be toggled: this operation aligns wounds from the same replicate and condition across different time points, mitigating human error in centering the field of view during light-microscopy acquisition. The possible outputs are described below; in all cases, a.txt log file recording the ROI definition parameters is saved in the output directory, thus making the analysis fully replicable. The Analysis Output Page is shown in Supplementary Figure S1C.
Outputs
RAW data (.csv)
These outputs provide.csv files containing absolute areas, normalized areas with respect to T0 (set to 100%), mean width values, mean front velocities between the initial and final time points, and interval velocities (if more than two time points are present). Where applicable, means and standard deviations are included.
Plots
These outputs generate time-course graphs and histograms for percentage areas and absolute velocities, as well as Probability Density Functions (PDFs) with relative mean values for all replicates (see Figures 2A–E). Time-course plots display the mean values of replicates at different time points for each condition, while histograms present data on percentage area reduction at the final time point and mean velocity between the initial and final points with standard deviations, where applicable. PDF plots represent the abundance distributions of absolute mean velocity values (initial-final), separated by condition, considering all absolute values along the wound fronts of all replicates. The “Fixed” output option allows for the overlay of Gaussian fits sharing the same mean and standard deviation.
FIGURE 2
Binary masks, vector maps and annotated images
The Binary Masks outputs provide the binary masks resulting from ROI detection, as well as their (eventual) post-alignment merged versions (see Supplementary Figure S2A).
The Vector Maps outputs offer an alternative, aesthetic visualization of the binary masks: similar to the masks described above, binary masks are overlaid with vectors indicating the direction of wound closure. This facilitates an immediate visual comparison between different conditions (see Figure 2 F).
The Annotated Images outputs provide images with wound contours overlayed as defined during ROI detection, along with annotations of the mean vertical wound fronts and their respective widths on each image (see Supplementary Figure S2B).
Scratch topography
This innovative generated plots display, for each -axis value, the total linear measure of open area at that coordinate (see Figure 3). Each plot thus features a plateau at time T0 centered in the image, while for subsequent times, these plateaus narrow into peaks as the wound closes. If alignment is selected, all peaks will be centered; otherwise, each will be located at a different abscissa depending on the shift present during image acquisition. Since peak width and height correspond to the open area, these topological plots represent an additional data presentation modality.
FIGURE 3
ImageJ comparison
Images from three different experimental setups (see Methods) were analyzed using both WoundPy and the Wound Healing Size tool of ImageJ () (hereinafter referred to as ImageJ) to provide a comparison of their estimated area and width measurements. Rather than claiming an absolute ground truth, we established a reference baseline representing expert-supervised segmentation. WoundPy measurements were performed using this expert-supervised semi-automatic approach. Since human validation will always remain the final step following the application of any analytical tool, in the case of WoundPy, this step is directly integrated into the dynamic parameter definition phase. To validate the robustness of the manual tuning, we assessed inter-operator variability by having three researchers independently perform the dynamic parameter definition on a representative subset of images (the first three replicates of Setup 2). This analysis demonstrated a high inter-operator agreement, yielding a mean Pearson’s r of 0.972 and a mean Coefficient of Variation (CV) of 13.69%. The raw data files used for this correlation assessment are provided in the “Inter-operator variance” folder, alongside the main datasets. Then, for each image, segmentation parameters (radius, threshold, contrast) were dynamically adjusted by an experienced researcher until the detected ROI boundaries visually coincided perfectly with the biological wound edges. Since WoundPy stems from the need to more rapidly identify the optimal parameters for use in ImageJ, the exact parameters determined via WoundPy were subsequently input into the ImageJ tool to ensure a direct comparison under identical settings. This approach specifically isolates and highlights the algorithmic differences between the two software tools, evaluating differences relative to the expert-supervised WoundPy segmentation rather than evaluating absolute accuracy against an independent standard. ImageJ measurements were therefore performed first by applying the same parameters selected for WoundPy, and subsequently using the default parameters of the ImageJ tool (radius = 20, threshold = 100, percentage of saturated pixels = 0.001). A value of contrast = 1 in WoundPy corresponds to an ImageJ value of percentage of saturated pixels = 0.001. For the third dataset, it was necessary to apply a threshold value in ImageJ that was 10 times higher than the one determined using WoundPy; indeed, given the specific image quality of this dataset, the original value failed to yield a proper definition of the Region of Interest (ROI). In instances where the ROI was fragmented, ImageJ analysis was restricted to the largest detected area: in such cases, ROI fragments were manually merged to measure the total area, though the width measurement remained unavailable; this primarily affected images during the healing phase (). Furthermore, the area measurement was also occasionally unavailable (Setup 3) due to ImageJ’s inability to detect the ROI with either default or user-defined parameters. Figure 4 A presents the graphical results of the area comparison, while Figure 4 B displays the width data.
FIGURE 4
The area analysis revealed different behaviors of ImageJ compared to WoundPy depending on the timepoint of the analyzed image: for images at T0 ( in setup one and in setup 2), ImageJ seems to performs a measurement similar to WoundPy with a slight underestimation; for images at subsequent timepoints, the measurement error by ImageJ increases as the size of the fragmented wound increases. To determine if the ImageJ error is significant compared to the WoundPy measurement, linear regressions of the different subpopulations were evaluated, yielding the equations reported in Table 2A. Statistical tests were performed on the intercept and slope of the simple linear regression using one-sample Student’s t-tests. The intercept test against a null hypothesis of verifies the presence of a constant bias, i.e., a systematic error between the two methods, while the slope test against the null hypothesis of determines the existence of a proportional bias, i.e., an error that increases with varying ROI size. Statistical analysis shows that ImageJ underestimates areas when the ROI is small and fragmented in setup 1, and this error grows as the total ROI area increases. Conversely, underestimation is systematic for T0 images in setup 2 as also shown in Figure 5; as the ROI area increases, the use of default parameters in this case decreases the error (, values approach the bisector). Underestimation or overestimation in other cases is not significant.
TABLE 2
| A | Setup | Population | IJ params | Linear fit | Slope vs. 1 | Vs. 0 | |
|---|---|---|---|---|---|---|---|
| | 1 | User defined | 0.512 | ns | |||
| | 1 | Default | 0.585 | ns | |||
| | 1 | User defined | 0.908 | ns | ns | ||
| | 1 | Default | 0.800 | ns | ns | ||
| | 2 | User defined | 0.833 | ns | ns | ||
| | 2 | Default | 0.757 | ns | ns | ||
| | 2 | User defined | 0.983 | ns | |||
| | 2 | Default | 0.967 | ||||
| | 3 | - | User defined | 0.654 | ns (1:1) | ns | |
| | 3 | - | Default | 0.001 | ns |
| B | Setup | Population | IJ params | Linear fit | Slope vs. 1 | vs. 0 | |
|---|---|---|---|---|---|---|---|
| | 1 | User defined | Insufficient data | - | - | - | |
| | 1 | Default | Insufficient data | - | - | - | |
| | 1 | User defined | 0.824 | ns | ns | ||
| | 1 | Default | 0.496 | ns | ns | ||
| | 2 | User defined | 1.000 | ||||
| | 2 | Default | 0.950 | ns | |||
| | 2 | User defined | 0.968 | ns | |||
| | 2 | Default | 0.970 | ||||
| | 3 | - | User defined | 0.805 | ns (1:1) | ns | |
| | 3 | - | Default | 0.491 | ns |
Reports the comparison data for the different tools.
Table 2: (A) Linear fit values of area measurements are reported for the different populations and analysis methods for both experimental setups. Significance test results are also reported: in setup 1, analyses performed with both methods on the small area population carry an error that increases linearly and significantly compared to WoundPy; in setup 2, analyses performed with both methods suffer from significant error on the T0 population due to systematic underestimation; in Setup 3, the detection performed using default parameters fails regardless of the actual size of the area. (B) Linear fit values of width measurements are reported for the different populations and analysis methods for both experimental setups. Significance test results are also reported. In setup 1, analyses performed with both ImageJ methods on the small width population yielded no data. In setup 2, the error is significant for the small width population analyzed with default parameters, while analyses performed with both methods suffer from significant error on the T0 population due to systematic underestimation. In Setup 3, the underestimation of the width when using default parameters is systematic. Significance levels are reported in the table as ns: , , , . When , the comparison resulted in a virtually null p-value due to the zero-inflated nature of the distribution in the healed condition.
FIGURE 5
ImageJ measurements that failed to detect the wound width were excluded from the regression analysis to prevent distortion of the linear fit, but for completeness were retained in the graphical representation as the WoundPy measure only. The width analysis also revealed differences in trends across the different subpopulations at T0 and (threshold at for setup one and for setup 2). Table 2B reports the corresponding linear regressions. Statistical analysis indicates that underestimation is systematic in setup two for T0 images, while the error is proportional with overestimation for images analyzed with default parameters. As with the area, in the case of width, the underestimation error decreases as the T0 wound grows () when the analysis is performed with default parameters.
To further evaluate the agreement between WoundPy and the standard ImageJ tool, a Bland-Altman analysis was performed on both wound area and width measurements (see Figure 6). The Bland-Altman plots visually confirm the systematic negative bias (underestimation) introduced by ImageJ relative to WoundPy across the different experimental setups. The solid black line represents perfect agreement (zero difference), while the dashed lines indicate the mean bias for each parameter setting. The predominantly negative bias values, coupled with wide Limits of Agreement (LOA), clearly illustrate that ImageJ consistently underestimates the wound size. Furthermore, in several cases (such as in Setup one and Setup two for the area), the negative difference visibly increases as the mean wound size grows, visually corroborating the proportional bias identified by the linear regression analysis.
FIGURE 6
Discussion
Despite current analysis software tools being frequently labor-intensive and inaccurate, the Wound Healing Assay (WHA) remains an indispensable cornerstone of basic research, as it allows for the examination of complex biological processes aimed at a fast identification of compounds capable of inhibiting cell migration. The WHA has often been criticized as obsolete due to low reproducibility associated with operator errors and automated tools for Region of Interest (ROI) detection (; ). However, the optimization of this technique from an analytical perspective constitutes a value of fundamental importance in cell migration research, given the assay’s inherent simplicity of execution.
With the development of WoundPy, we provide a comprehensive workflow that fully automates both the analytical calculation and data plotting processes. Unlike other software solutions that often require complex scripts or fragmented plugins, WoundPy is distributed as a standalone executable capable of managing datasets efficiently. The robustness of the tool was successfully validated on three real biological datasets, encompassing diverse experimental conditions and biological replicates.
A distinct technical strength that sets WoundPy apart from basic analysis tools is the implementation of a preprocessing phase dedicated to wound alignment. While software facilitating temporal overlay analysis often necessitates expensive automated microscopes to guarantee a fixed field of view, WoundPy democratizes this capability by computationally correcting the human error intrinsic to manual acquisition with standard optical microscopes. This function is crucial for data quality: without alignment, plate positioning errors can generate overlapping topological profiles that falsify the calculation of newly covered areas and, consequently, the estimation of migration velocity. This innovation renders the analysis reliable even in laboratories equipped with standard instrumentation.
WoundPy marks a significant advancement over classical methods that are limited to reporting the percentage Closure Rate or mean front velocity (often manually drawn), metrics that offer only relative measures or are subject to operator error. Our approach converts the variation in cell-free area into an absolute physical velocity ( or ) by analyzing wound closure row-by-row along the image height. This method generates a broad statistical sample of velocity vectors for each replicate, allowing for the derivation of real physical data that is directly comparable across different experiments.
The superiority of the expert-supervised semi-automatic segmentation implemented in WoundPy emerged clearly in the direct comparison with the standard ImageJ tool, as illustrated in the quantitative results (Figure 4). Our validation demonstrated that while ImageJ performs adequately on standardized samples (T0), it introduces systematic errors in complex images. Statistical analysis revealed that ImageJ, compared to WoundPy, tends to systematically underestimate wound area and width relative to the expert-supervised WoundPy segmentation when the gap becomes fragmented, with an error that grows proportionally to the complexity of the ROI, or when the initial contrast of the image is low. In contrast, WoundPy allows for dynamic and interactive parameter tuning for each individual image, ensuring that even the most irregular ROI fragments are correctly detected and included in the final calculation.
Furthermore, ImageJ forces the researcher to restart the entire pipeline even for a single small parameter change: WoundPy reduces analysis time by allowing real-time ROI modification. The generation of a log file guarantees substantial reproducibility of the analysis across all replicates, and their management through different folder nesting modes facilitates image handling in experiments with a large amount of data.
In spite of the significant advancements introduced by WoundPy, certain limitations inherent to the current algorithmic approach must be acknowledged. First, the preprocessing alignment module and the subsequent row-by-row absolute velocity calculation are mathematically optimized for vertically oriented wounds. While the software can handle slight deviations typical of manual scratching, significant deviations from the vertical axis may compromise the accuracy of the alignment and the resulting vector maps, necessitating that users pre-rotate such images before import. Secondly, the segmentation engine itself is built on variance-based texture analysis combined with human supervision, rather than Deep Learning (DL) models. While this keeps the tool lightweight and accessible - removing the need for high-end GPUs or massive training datasets - it implies that detection sensitivity depends on the local contrast between cells and the medium. Currently, WoundPy is distributed as a standalone Windows (.exe) and macOS (.app) executable to maximize accessibility for researchers without programming expertise, though this does limit native use on macOS or Linux.
Future developments of the tool will aim to potentially integrate pre-trained lightweight neural networks to enhance segmentation robustness in high-noise conditions.
Statements
Data availability statement
All image datasets, corresponding software outputs, ImageJ comparison data, the software source code and executable (.exe) files are available in an online repository on Zenodo ().
Author contributions
EG: Conceptualization, Data curation, Formal Analysis, Investigation, Methodology, Software, Visualization, Writing – original draft, Writing – review and editing. MB: Funding acquisition, Resources, Supervision, Validation, Writing – review and editing. NM: Conceptualization, Resources, Validation, Writing – review and editing. GL: Conceptualization, Data curation, Investigation, Project administration, Resources, Supervision, Validation, Writing – original draft, Writing – review and editing.
Funding
The author(s) declared that financial support was received for this work and/or its publication. This study was carried out within the Space It Up project funded by the Italian Space Agency, ASI, and the Ministry of University and Research, MUR, under contract n. 2024-5-E.0 - CUP n. I53D24000060005
Acknowledgments
The authors would like to thank Marco Lorica for their technical assistance in generating the macOS application bundle (.app) for the cross-platform distribution of WoundPy.
Conflict of interest
All authors are partners of BioLuna Srl. The authors declare that this affiliation does not pose any conflict of interest regarding the publication of this manuscript.
Generative AI statement
The author(s) declared that generative AI was not used in the creation of this manuscript.
Any alternative text (alt text) provided alongside figures in this article has been generated by Frontiers with the support of artificial intelligence and reasonable efforts have been made to ensure accuracy, including review by the authors wherever possible. If you identify any issues, please contact us.
Publisher’s note
All claims expressed in this article are solely those of the authors and do not necessarily represent those of their affiliated organizations, or those of the publisher, the editors and the reviewers. Any product that may be evaluated in this article, or claim that may be made by its manufacturer, is not guaranteed or endorsed by the publisher.
Supplementary material
The Supplementary Material for this article can be found online at: https://www.frontiersin.org/articles/10.3389/fcell.2026.1919916/full#supplementary-material
References
1
AscioneF.GuarinoA. M.CalabròV.GuidoS.CasertaS. (2017a). A novel approach to quantify the wound closure dynamic. Exp. Cell Res.352 (2), 175–183. 10.1016/j.yexcr.2017.01.005
2
AscioneF.CasertaS.GuidoS. (2017b). The wound healing assay revisited: a transport phenomena approach. Chem. Eng. Sci.160, 200–209. 10.1016/j.ces.2016.11.014
3
BaharE.YoonH. (2021). Modeling and predicting the cell migration properties from scratch wound healing assay on cisplatin-resistant ovarian cancer cell lines using artificial neural network. Healthcare9 (7), 911. 10.3390/healthcare9070911
4
BurridgeK.Chrzanowska-WodnickaM. (1996). Focal adhesions, contractility, and signaling. Annu. Rev. Cell Dev. Biol.12 (1), 463–519. 10.1146/annurev.cellbio.12.1.463
5
ChungH. H.BellefeuilleS. D.MillerH. N.GaborskiT. R. (2018). Extended live-tracking and quantitative characterization of wound healing and cell migration with SiR-Hoechst. Exp. Cell Res.373 (1–2), 198–210. 10.1016/j.yexcr.2018.10.014
6
De CillisA.GarzarelliV.FoscariniA.GigliG.TurcoA.PrimiceriE.et al (2025). 3D-printed barriers with machine learning powered image analysis for enhanced wound healing assays. Mater. Des.259, 114746. 10.1016/j.matdes.2025.114746
7
DoğruD.ÖzdemirG. D.ÖzdemirM. A.ErcanU. K.Topaloğlu AvşarN.GürenO. (2024). An automated in vitro wound healing microscopy image analysis approach utilizing U-net-based deep learning methodology. BMC Med. Imaging24 (1), 158. 10.1186/s12880-024-01332-2
8
ErdemY. S.Yalçin ÖzuysalÖ.Pesen OkvurD.Töreyi̇NB.ÜnayD. (2021). An image segmentation method for wound healing assay images. Nat. Appl. Sci. J.4 (1), 30–37. 10.38061/idunas.853356
9
FriedlP.WolfK. (2003). Tumour-cell invasion and migration: diversity and escape mechanisms. Nat. Rev. Cancer3 (5), 362–374. 10.1038/nrc1075
10
GalanteE.LentiniG.MontiN. (2026). Woundpy Data Source. 10.5281/zenodo.20530720
11
Garcia-FossaF.GaalV.De JesusM. B. (2020). PyScratch: an ease of use tool for analysis of scratch assays. Comput. Methods Programs Biomed.193, 105476. 10.1016/j.cmpb.2020.105476
12
GebäckT.SchulzM. M. P.KoumoutsakosP.DetmarM. (2009). TScratch: a novel and simple software tool for automated analysis of monolayer wound healing assays: short technical reports. BioTechniques46 (4), 265–274. 10.2144/000113083
13
GnerucciA.FaraoniP.SereniE.RanaldiF. (2020). Scratch assay microscopy: a reaction–diffusion equation approach for common instruments and data. Math. Biosci.330, 108482. 10.1016/j.mbs.2020.108482
14
GollapudiS. (2019). “OpenCV with python,” in Learn Computer Vision Using Opencv (Berkeley, CA: Apress), 31–50. 10.1007/978-1-4842-4261-2_2
15
GradaA.Otero-VinasM.Prieto-CastrilloF.ObagiZ.FalangaV. (2017). Research techniques made simple: analysis of collective cell migration using the wound healing assay. J. Invest. Dermatol.137 (2), e11–e16. 10.1016/j.jid.2016.11.020
16
GuyJ.-B.EspenelS.VallardA.Battiston-MontagneP.WoznyA. S.ArdailD.et al (2017). Evaluation of the cell invasion and migration process: a comparison of the video microscope-based scratch wound assay and the Boyden Chamber assay. J. Vis. Exp.129, 56337. 10.3791/56337
17
HarrisC. R.MillmanK. J.van der WaltS. J.GommersR.VirtanenP.CournapeauD.et al (2020). Array programming with NumPy. Nature585 (7825), 357–362. 10.1038/s41586-020-2649-2
18
HulkowerK. I.HerberR. L. (2011). Cell migration and invasion assays as tools for drug discovery. Pharmaceutics3 (1), 107–124. 10.3390/pharmaceutics3010107
19
JonkmanJ. E. N.CathcartJ. A.XuF.BartoliniM. E.AmonJ. E.StevensK. M.et al (2014). An introduction to the wound healing assay using live-cell microscopy. Cell Adhes. Migr.8 (5), 440–451. 10.4161/cam.36224
20
KauanovaS.UrazbayevA.VorobjevI. (2021). The frequent sampling of wound scratch assay reveals the “Opportunity” window for quantitative evaluation of cell motility-impeding drugs. Front. Cell Dev. Biol.9, 640972. 10.3389/fcell.2021.640972
21
LauffenburgerD. A.HorwitzA. F. (1996). Cell migration: a physically integrated molecular process. Cell84 (3), 359–369. 10.1016/S0092-8674(00)81280-5
22
LentiniG.QuerquiA.GiulianiA.VernaR.BizzarriM. (2025). Inositol and PIP2/PIP3 ratio: at the crossroad of the biodynamic interface between cells and their microenvironment. Biomolecules15 (3), 451. 10.3390/biom15030451
23
LjosaV.SokolnickiK. L.CarpenterA. E. (2012). Annotated high-throughput microscopy image sets for validation. Nat. Methods9 (7), 637. 10.1038/nmeth.2083
24
MontiN.AntinoriD.ProiettiS.PiombaroloA.QuerquiA.LentiniG.et al (2025). miRNAs from zebrafish embryo extracts inhibit breast cancer invasiveness and migration by modulating miR-218-5p/PI3K pathway. Int. J. Mol. Sci.26 (8), 3812. 10.3390/ijms26083812
25
PollardT. D.BorisyG. G. (2003). Cellular motility driven by assembly and disassembly of actin filaments. Cell112 (4), 453–465. 10.1016/S0092-8674(03)00120-X
26
SchedaR.VitaliS.GiampieriE.PagniniG.ZironiI. (2021). Study of wound healing dynamics by single pseudo-particle tracking in phase contrast images acquired in time-lapse. Entropy23 (3), 284. 10.3390/e23030284
27
Suarez-ArnedoA.FigueroaF. T.ClavijoC.ArbeláezP.CruzJ. C.Muñoz-CamargoC. (2020). An image J plugin for the high throughput image analysis of in vitro scratch wound healing assays. PLoS ONE15 (7), e0232565. 10.1371/journal.pone.0232565
28
Vang MouritzenM.JenssenH. (2018). Optimized scratch assay for in vitro testing of cell migration with an automated optical camera. J. Vis. Exp.138, 57691. 10.3791/57691
29
VarankarS. S.BapatS. A. (2018). Migratory metrics of wound healing: a quantification approach for in vitro scratch assays. Front. Oncol.8, 633. 10.3389/fonc.2018.00633
30
VašinkováM.KrumniklM.GharibianA.MičulekO.KriegováE.GajdošP. (2025). A novel method for evaluating and visualizing scratch wound healing assays using level-set and image sector analysis. PNAS Nexus4 (11), pgaf355. 10.1093/pnasnexus/pgaf355
31
VirtanenP.GommersR.OliphantT. E.HaberlandM.ReddyT.CournapeauD.et al (2020). SciPy 1.0: fundamental algorithms for scientific computing in python. Nat. Methods17 (3), 261–272. 10.1038/s41592-019-0686-2
32
YaothakJ.KhongkowP.UlhakaK. (2025). Development of an automated image analysis system for quantitative evaluation of wound healing assays. J. Adv. Res. Appl. Sci. Eng. Technol.60 (3), 196–207. 10.37934/araset.65.1.196207
Summary
Keywords
migration, optical microscopy, python, software, wound healing assay
Citation
Galante E, Bizzarri M, Monti N and Lentini G (2026) WoundPy: an improved automatized method for in vitro cell motility investigation based on wound alignment and absolute velocity profiling. Front. Cell Dev. Biol. 14:1919916. doi: 10.3389/fcell.2026.1919916
Received
25 June 2026
Revised
09 August 2026
Accepted
11 August 2026
Published
07 September 2026
Volume
14 - 2026
Edited by
Bojana Gligorijevic, Temple University, United States
Reviewed by
Daniel Chavarria, Vanderbilt University, United States
Tatsat Banerjee, Johns Hopkins University, United States
Updates
Copyright
© 2026 Galante, Bizzarri, Monti and Lentini.
This is an open-access article distributed under the terms of the Creative Commons Attribution License (CC BY). The use, distribution or reproduction in other forums is permitted, provided the original author(s) and the copyright owner(s) are credited and that the original publication in this journal is cited, in accordance with accepted academic practice. No use, distribution or reproduction is permitted which does not comply with these terms.
*Correspondence: G. Lentini, guglielmo.lentini@uniroma1.it
Disclaimer
All claims expressed in this article are solely those of the authors and do not necessarily represent those of their affiliated organizations, or those of the publisher, the editors and the reviewers. Any product that may be evaluated in this article or claim that may be made by its manufacturer is not guaranteed or endorsed by the publisher.