nude.go

package nude

import (
	"fmt"
	"image"
	"math"
	"path/filepath"
	"sort"
)

func IsNude(imageFilePath string) (result bool, err error) {
	path, err := filepath.Abs(imageFilePath)
	if err != nil {
		return false, err
	}
	d := NewDetector(path)
	result, err = d.Parse()

	return
}

type Detector struct {
	filePath        string
	image           image.Image
	width           int
	height          int
	totalPixels     int
	pixels          Pixels
	SkinRegions     Regions
	detectedRegions Regions
	mergeRegions    [][]int
	lastFrom        int
	lastTo          int
	message         string
	result          bool
}

func NewDetector(path string) *Detector {
	d := &Detector{
		filePath: path,
	}
	return d
}

func (d *Detector) Parse() (result bool, err error) {
	img, err := decodeImage(d.filePath)
	if err != nil {
		return false, err
	}
	bounds := img.Bounds()
	d.image = img
	d.width = bounds.Size().X
	d.height = bounds.Size().Y
	d.lastFrom = -1
	d.lastTo = -1
	d.totalPixels = d.width * d.height

	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		width := bounds.Size().X
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			r, g, b, _ := d.image.At(x, y).RGBA()
			normR := r / 256
			normG := g / 256
			normB := b / 256
			currentIndex := x + y*width
			nextIndex := currentIndex + 1

			if !classifySkin(normR, normG, normB) {
				d.pixels = append(d.pixels, &Pixel{currentIndex, false, 0, x, y, false})
			} else {
				d.pixels = append(d.pixels, &Pixel{currentIndex, true, 0, x, y, false})

				region := -1
				checkIndexes := []int{
					nextIndex - 2,
					nextIndex - width - 2,
					nextIndex - width - 1,
					nextIndex - width,
				}
				checker := false

				for _, checkIndex := range checkIndexes {
					if checkIndex < 0 {
						continue
					}
					skin := d.pixels[checkIndex]
					if skin != nil && skin.isSkin {
						if skin.region != region &&
							region != -1 &&
							d.lastFrom != region &&
							d.lastTo != skin.region {
							d.addMerge(region, skin.region)
						}
						region = d.pixels[checkIndex].region
						checker = true
					}
				}

				if !checker {
					d.pixels[currentIndex].region = len(d.detectedRegions)
					d.detectedRegions = append(d.detectedRegions, Pixels{d.pixels[currentIndex]})
					continue
				} else {
					if region > -1 {
						if len(d.detectedRegions) >= region {
							d.detectedRegions = append(d.detectedRegions, Pixels{})
						}
						d.pixels[currentIndex].region = region
						d.detectedRegions[region] = append(d.detectedRegions[region], d.pixels[currentIndex])
					}
				}
			}
		}
	}

	d.merge(d.detectedRegions, d.mergeRegions)
	d.analyzeRegions()

	return d.result, err
}

func (d *Detector) addMerge(from, to int) {
	d.lastFrom = from
	d.lastTo = to

	fromIndex := -1
	toIndex := -1

	for index, region := range d.mergeRegions {
		for _, regionIndex := range region {
			if regionIndex == from {
				fromIndex = index
			}
			if regionIndex == to {
				toIndex = index
			}
		}
	}

	if fromIndex != -1 && toIndex != -1 {
		if fromIndex != toIndex {
			fromRegion := d.mergeRegions[fromIndex]
			toRegion := d.mergeRegions[toIndex]
			region := append(fromRegion, toRegion...)
			d.mergeRegions[fromIndex] = region
			d.mergeRegions = append(d.mergeRegions[:toIndex], d.mergeRegions[toIndex+1:]...)
		}
		return
	}

	if fromIndex == -1 && toIndex == -1 {
		d.mergeRegions = append(d.mergeRegions, []int{from, to})
		return
	}

	if fromIndex != -1 && toIndex == -1 {
		d.mergeRegions[fromIndex] = append(d.mergeRegions[fromIndex], to)
		return
	}

	if fromIndex == -1 && toIndex != -1 {
		d.mergeRegions[toIndex] = append(d.mergeRegions[toIndex], from)
		return
	}

}

// function for merging detected regions
func (d *Detector) merge(detectedRegions Regions, mergeRegions [][]int) {
	var newDetectedRegions Regions

	// merging detected regions
	for index, region := range mergeRegions {
		if len(newDetectedRegions) >= index {
			newDetectedRegions = append(newDetectedRegions, Pixels{})
		}
		for _, r := range region {
			newDetectedRegions[index] = append(newDetectedRegions[index], detectedRegions[r]...)
			detectedRegions[r] = Pixels{}
		}
	}

	// push the rest of the regions to the newDetectedRegions array
	// (regions without merging)
	for _, region := range detectedRegions {
		if len(region) > 0 {
			newDetectedRegions = append(newDetectedRegions, region)
		}
	}

	// clean up
	d.clearRegions(newDetectedRegions)
}

// clean up function
// only push regions which are bigger than a specific amount to the final resul
func (d *Detector) clearRegions(detectedRegions Regions) {
	for _, region := range detectedRegions {
		if len(region) > 30 {
			d.SkinRegions = append(d.SkinRegions, region)
		}
	}
}

func (d *Detector) analyzeRegions() bool {
	skinRegionLength := len(d.SkinRegions)

	// if there are less than 3 regions
	if skinRegionLength < 3 {
		d.message = fmt.Sprintf("Less than 3 skin regions (%v)", skinRegionLength)
		d.result = false
		return d.result
	}

	// sort the skinRegions
	sort.Sort(sort.Reverse(d.SkinRegions))

	// count total skin pixels
	totalSkinPixels := float64(d.SkinRegions.totalPixels())

	// check if there are more than 15% skin pixel in the image
	totalSkinParcentage := totalSkinPixels / float64(d.totalPixels) * 100
	if totalSkinParcentage < 15 {
		// if the parcentage lower than 15, it's not nude!
		d.message = fmt.Sprintf("Total skin parcentage lower than 15 (%v%%)", totalSkinParcentage)
		d.result = false
		return d.result
	}

	// check if the largest skin region is less than 35% of the total skin count
	// AND if the second largest region is less than 30% of the total skin count
	// AND if the third largest region is less than 30% of the total skin count
	biggestRegionParcentage := float64(len(d.SkinRegions[0])) / totalSkinPixels * 100
	secondLargeRegionParcentage := float64(len(d.SkinRegions[1])) / totalSkinPixels * 100
	thirdLargesRegionParcentage := float64(len(d.SkinRegions[2])) / totalSkinPixels * 100
	if biggestRegionParcentage < 35 &&
		secondLargeRegionParcentage < 30 &&
		thirdLargesRegionParcentage < 30 {
		d.message = "Less than 35%, 30%, 30% skin in the biggest regions"
		d.result = false
		return d.result
	}

	// check if the number of skin pixels in the largest region is less than 45% of the total skin count
	if biggestRegionParcentage < 45 {
		d.message = fmt.Sprintf("The biggest region contains less than 45%% (%v)", biggestRegionParcentage)
		d.result = false
		return d.result
	}

	// TODO:
	// build the bounding polygon by the regions edge values:
	// Identify the leftmost, the uppermost, the rightmost, and the lowermost skin pixels of the three largest skin regions.
	// Use these points as the corner points of a bounding polygon.

	// TODO:
	// check if the total skin count is less than 30% of the total number of pixels
	// AND the number of skin pixels within the bounding polygon is less than 55% of the size of the polygon
	// if this condition is true, it's not nude.

	// TODO: include bounding polygon functionality
	// if there are more than 60 skin regions and the average intensity within the polygon is less than 0.25
	// the image is not nude
	if skinRegionLength > 60 {
		d.message = fmt.Sprintf("More than 60 skin regions (%v)", skinRegionLength)
		d.result = false
		return d.result
	}

	// otherwise it is nude
	d.result = true
	return d.result
}

func (d *Detector) String() string {
	return fmt.Sprintf("#<nude.Detector result=%t, message=%s>", d.result, d.message)
}

// A Survey on Pixel-Based Skin Color Detection Techniques
func classifySkin(r, g, b uint32) bool {
	rgbClassifier := r > 95 &&
		g > 40 && g < 100 &&
		b > 20 &&
		maxRgb(r, g, b)-minRgb(r, g, b) > 15 &&
		math.Abs(float64(r-g)) > 15 &&
		r > g &&
		r > b

	nr, ng, _ := toNormalizedRgb(r, g, b)
	normalizedRgbClassifier := nr/ng > 1.185 &&
		(float64(r*b))/math.Pow(float64(r+g+b), 2) > 0.107 &&
		(float64(r*g))/math.Pow(float64(r+g+b), 2) > 0.112

	h, s, _ := toHsv(r, g, b)
	hsvClassifier := h > 0 &&
		h < 35 &&
		s > 0.23 &&
		s < 0.68

	// ycc doesnt work

	result := rgbClassifier || normalizedRgbClassifier || hsvClassifier
	return result
}

func maxRgb(r, g, b uint32) float64 {
	return math.Max(math.Max(float64(r), float64(g)), float64(b))
}

func minRgb(r, g, b uint32) float64 {
	return math.Min(math.Min(float64(r), float64(g)), float64(b))
}

func toNormalizedRgb(r, g, b uint32) (nr, ng, nb float64) {
	sum := float64(r + g + b)
	nr = float64(r) / sum
	ng = float64(g) / sum
	nb = float64(b) / sum

	return nr, ng, nb
}

func toHsv(r, g, b uint32) (h, s, v float64) {
	h = 0.0
	sum := float64(r + g + b)
	max := maxRgb(r, g, b)
	min := minRgb(r, g, b)
	diff := max - min

	if max == float64(r) {
		h = float64(g-b) / diff
	} else if max == float64(g) {
		h = 2 + float64(g-r)/diff
	} else {
		h = 4 + float64(r-g)/diff
	}

	h *= 60
	if h < 0 {
		h += 360
	}

	s = 1.0 - 3.0*(min/sum)
	v = (1.0 / 3.0) * max

	return h, s, v
}