Detecting human skin using thresholds.

The main idea was to make the original work more accessible by implementing the algorithm in Python while keeping a fast execution time through vectorization.
The differences with the original work are explained in a section below.

N. Brancati, G. De Pietro,M. Frucci, and L. Gallo. “Human skin detection through correlation rules between the YCb and YCr subspaces based on dynamic color clustering”. Computer Vision and Image Understanding 155, 2017, pp. 33–42. https://doi.org/10.1016/j.cviu.2016.12.001

Credits to the authors of the original version: https://github.com/nadiabrancati/skin_detection/

Keep in mind that some images will be more difficult to classify than others: materials with skin-like colors (wood, copper, leather, clay), conditions that modify an image appearance (lighting, camera color science, motion blur), and the wide range of skin tones that the human skin may assume represent the main challenges of skin detection.

Furthermore, these outcomes are not representative in any way of detector performance, as they were not carefully chosen; see the relative section for general performance.

Install pip requirements

pip install -r requirements.txt

Predict skin pixels of an image

python skin_ycbcr.py image_in.jpg image_out.png

The skin pixels clusters assume a trapezoidal shape in the YCb and YCr color subspaces. Moreover, the shape and size of the trapezium vary according to many factors, such as the illumination conditions. In high illumination conditions, the base of the trapezium results larger.

Besides, the chrominance components of a skin pixel P with coordinates (P_Y, P_Cb, P_Cr) in the YCbCr space exhibit the following behavior: the further is the (P_Y, P_Cr) point from the longer base of the trapezium in the YCr subspace, the further is the (P_Y, P_Cb) point from the longer base of the trapezium in the YCb subspace, and vice versa.

The aforementioned observations are the base of the method: it tries to define image-specific trapeziums in the YCb and YCr color subspaces and then verifies that the correlation rules between the two subspaces reflect the inversely proportional behavior of the chrominance components.

Computation of the correlation rules parameters. Adapted from the original paper (Brancati et al. 2017)

Algorithm overview

1. Input image RGB to YCbCr
2. Cr_max and Cb_min computation
3. Image-wise computation of the correlation rules parameters
4. Image-wise correlation rules check

In the original work, the last two points described in the algorithm overview are computed pixel-wise.

In this work, vectorization is applied to make the python implementation a lot faster.

While vectorization improved execution time, the computation of vertices of the trapezium is still not optimized and is run by the python interpreter, taking up to 95% of the execution time and making it a lot slower than the original C implementation.

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
1       0.008    0.008    0.403    0.403   skin_ycbcr.py:171(skin_detect)
2       0.370    0.185    0.389    0.195   skin_ycbcr.py:86(calculateValueMinMaxY)

Detection performance could be improved by being more consistent with data types, since the difference in accuracy with the original work is only given by the various casting operations performed on the matrices.

The metrics are calculated as follows.
Initially, the metrics are measured for all the instances, then the average and population standard deviation for each metric are computed.

For each dataset: predictions are performed on the test set.

Here are the differences in detection performance with the original work recorded on the same sets.