Wound Detection and Cell Velocity¶
The In Vitro Scratch Assay is a convenient protocol to analyze wound healing. This package provides tools to analyze cell velocity from time series of wound healing experiments. The package is installed via pip
$ pip install wound
To detect the wound on an image called ‘wound_t08.jpg’ we call wound.detect()
>>> import wound
>>> my_wound = wound.detect('wound_t08.jpg', sigma=25, thresh=.4)
>>> print(my_wound['area'])
71922.0
The result is a dictionary with values from the detection such as area and perimeter. We can plot the detected wound on the original image with Pillow
>>> from PIL import Image
>>> im = Image.open('wound_t08.jpg')
>>> c, r = my_wound['edge']
>>> coords = zip(r.astype(int), c.astype(int))
>>> _ = [im.putpixel(x, 255) for x in coords]
>>> im.save('result.png')
In order to analyze a time series experiment with multiple images we need a list of wound detection dictionaries. Let’s assume we have three images in our experiment, each taken with 1.5 hour intervals. We parse these to detect()
as a two lists
>>> images = ['1.png', '2.png', '3.png']
>>> time = [1.0, 2.5, 4.0]
>>> my_series = wound.detect(images, time)
This detects wounds on all images and assign an experimental time to each
of them in order. It is very important the images
and time
is have
the same order. The returned list my_series
can be used to fit
a velocity model (wound.Model
) with the function wound.Model.fit()
>>> model = wound.Model()
>>> model.fit(my_series)
<wound.velocity.Model object at 0x...>
When a model is fitted it can be used to predict cell velocity at desired time points with the models own wound.Model.predict()
function
>>> predict_time = [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
>>> velocity = model.predict(predict_time)
With the return_std=True
is passed to predict
the standard deviation of the velocity is returned as well.
Different ways to detect images¶
There are three different ways to give images to wound.detect()
.
You can parse a file path to the image
>>> path = 'wound_t08.jpg'
>>> my_wound = wound.detect(path)
or a PIL
image
>>> import PIL.Image
>>> pil_image = PIL.Image.open(path)
>>> my_wound = wound.detect(pil_image)
or even a numpy.ndarray
>>> import numpy
>>> array_image = numpy.asarray(pil_image)
>>> my_wound = wound.detect(array_image)
For all of these cases you can parse a single image or a list of images.
Package Reference¶
Here is a listed the avaible classes and functions in the package. The Index gives an alternative alphabetchic listing of the package content.

class
wound.
Model
(area_kwargs=None, perimeter_kwargs=None)[source]¶ Wound velocity model.
The model is based on Gaussian Process Regression (GPR) and numerical differentiation. The GPR uses scikitlearn GPR class
sklearn.gaussian_process.GaussianProcessRegressor
.Parameters:  area_kwargs (dictionary) – The keyword arguments to the area GPR model.
 perimeter_kwargs (dictionary) – The keyword arguments to the perimeter GPR model.
Variables:  area (area model) – Instances of GaussianProcessRegressor from scikitlearn.
 perimeter (perimeter model) – Instances of GaussianProcessRegressor from scikitlearn.
 time (sequence) – Sequence of the input time points. Defined when fitted.
Notes
The keyword argument
kernel
is specifying the covariance function of the GPR models handling the area and perimeter. The default kernel is a sum of a linear and squared dotproduct kernel. See scikitlearn for the different kernels that can be used. Note that the kernel hyperparameters are optimized during fitting.
fit
(wounds)[source]¶ Fitting the velocity model to wound data.
Parameters: wounds (sequence of dictionaries) – A sequence of wound dictionaries representing an experimental time series of the wound healing assay, as returned by detect()
. The area, perimeter and time point of each wound is used to fit the overall velocity model.Returns: self – The velocity model in a fitted state. Return type: Model

predict
(time, return_std=False)[source]¶ Predicting a velocity curve of a wound healing experiment.
In addition to the mean of the predictive distribution, also its standard deviation (return_std=True) can be requested.
Parameters:  time (sequence) – Sequence of the desired time points of the prediction.
 return_std (boolean) – Whether to include the standard deviation of the prediction or not.
Returns: velocity, [vel_std] – Velocity and (optionally) it’s standard deviation. Returned either one array or (if return_std=True) as a tuple (velocity, vel_std).
Return type: 1d arrays

wound.
detect
(images, time=None, sigma=25, thresh=0.4, err=0.05, radius=None, scale=1)[source]¶ Detect wound on a image with uncertainty.
Parameters:  images (sequence of [file paths  numpy.ndarray  PIL.Image]) – Images to detect wound(s) from. A single image path, array, or PIL image can be passed outside a sequence.
 time (sequence) – The time points of the images (same order as images).
 sigma (scalar) – The standard deviation of the image smoothing. This should be roughly the same as the distance (in pixels) between cells at confluency.
 thresh (scalar) – Threshold factor to calculate wound boundary. Between zero and one.
 err (scalar) – Standard error of the threshold value to calculate uncertainty of the detection.
 radius (scalar, default is None) – If radius is not None and more than 2 images parsed
the algorithm uses the mean center of mass of the two first wounds
to define a circular zone of exclusion with radius
radius
in pixels. Subsequent wound candidates have to been inside this zone to be considered valid wounds.  scale (scalar, default is no scaling with
scale=1
) – Down scale factor to use on images for detection speed. Trades of accuracy versus cpu time. Ascale
of .5 will detect fast on a image of 25 % the original area. All other parameters are auto scaled. Return scale is not affected. Bigger than zero up to and with one.
Returns: wound(s) – Returns one dictionary (or a list of several) with the detected wound values
 area
 perimeter (without parts that touches image border)
 area and perimeter variances
 center of mass
 time
 edge (tuple of wound edge x and y coordinates)
 filename, (image file path if loaded from disk)
 image area
Returns
None
, for wounds that can not be detected.Return type: dictionary or a list of dictionaries
Notes
All image types and bit depth supported by Pillow can be used as input. If the images contain more than one color channel the sum of all channels will be used.

wound.
sort_and_cutoff
(wounds, min_area=0.05)[source]¶ Sort by time and cutoff based on minimum area.
Utillity function to sort wounds by time and filter out wounds by minimum area.
Parameters: min_area (float) – Percentage of the image size to consider a closed wound area. After this limit is hit the following time points will be excluded from the wound list. Range zero to one (ratio of image area). Returns: wounds – A wound list sorted by time point of the wounds. The following will remove wounds from the returned list:  wound area smaller than
min_area * image area
 wounds with later time point than the first removed
 None wounds
Return type: list of dictionaries  wound area smaller than