代码

opencv_transform/annotation.py

@@ -0,0 +1,17 @@
+
+#Object annotation class:
+class BodyPart:
+	
+	def __init__(self, name, xmin, ymin, xmax, ymax, x, y, w, h):
+		self.name = name
+		#Bounding Box:
+		self.xmin = xmin
+		self.ymin = ymin
+		self.xmax = xmax
+		self.ymax = ymax
+		#Center:
+		self.x = x
+		self.y = y
+		#Dimensione:
+		self.w = w
+		self.h = h

opencv_transform/dress_to_correct.py

@@ -0,0 +1,64 @@
+import cv2
+import math
+import numpy as np
+import os
+
+# create_correct ===============================================================
+# return:
+#	(<Boolean> True/False), depending on the transformation process
+def create_correct(cv_dress):
+
+	#Production dir:
+	return correct_color(cv_dress, 5)
+
+# correct_color ==============================================================================
+# return:
+# <RGB> image corrected
+def correct_color(img, percent):
+
+	assert img.shape[2] == 3
+	assert percent > 0 and percent < 100
+
+	half_percent = percent / 200.0
+
+	channels = cv2.split(img)
+
+	out_channels = []
+	for channel in channels:
+		assert len(channel.shape) == 2
+		# find the low and high precentile values (based on the input percentile)
+		height, width = channel.shape
+		vec_size = width * height
+		flat = channel.reshape(vec_size)
+
+		assert len(flat.shape) == 1
+
+		flat = np.sort(flat)
+
+		n_cols = flat.shape[0]
+
+		low_val  = flat[math.floor(n_cols * half_percent)]
+		high_val = flat[math.ceil( n_cols * (1.0 - half_percent))]
+
+		# saturate below the low percentile and above the high percentile
+		thresholded = apply_threshold(channel, low_val, high_val)
+		# scale the channel
+		normalized = cv2.normalize(thresholded, thresholded.copy(), 0, 255, cv2.NORM_MINMAX)
+		out_channels.append(normalized)
+
+	return cv2.merge(out_channels)
+
+#Color correction utils
+def apply_threshold(matrix, low_value, high_value):
+	low_mask = matrix < low_value
+	matrix = apply_mask(matrix, low_mask, low_value)
+
+	high_mask = matrix > high_value
+	matrix = apply_mask(matrix, high_mask, high_value)
+
+	return matrix
+
+#Color correction utils
+def apply_mask(matrix, mask, fill_value):
+	masked = np.ma.array(matrix, mask=mask, fill_value=fill_value)
+	return masked.filled()

opencv_transform/mask_to_maskref.py

@@ -0,0 +1,41 @@
+import numpy as np
+import cv2
+import os
+
+###
+#
+#	maskdet_to_maskfin 
+#	
+#
+###
+
+# create_maskref ===============================================================
+# return:
+#	maskref image
+def create_maskref(cv_mask, cv_correct):
+
+	#Create a total green image
+	green = np.zeros((512,512,3), np.uint8)
+	green[:,:,:] = (0,255,0)      # (B, G, R)
+
+	#Define the green color filter
+	f1 = np.asarray([0, 250, 0])   # green color filter
+	f2 = np.asarray([10, 255, 10])
+	
+	#From mask, extrapolate only the green mask		
+	green_mask = cv2.inRange(cv_mask, f1, f2) #green is 0
+
+	# (OPTIONAL) Apply dilate and open to mask
+	kernel = np.ones((5,5),np.uint8) #Try change it?
+	green_mask = cv2.dilate(green_mask, kernel, iterations = 1)
+	#green_mask = cv2.morphologyEx(green_mask, cv2.MORPH_OPEN, kernel)
+
+	# Create an inverted mask
+	green_mask_inv = cv2.bitwise_not(green_mask)
+
+	# Cut correct and green image, using the green_mask & green_mask_inv
+	res1 = cv2.bitwise_and(cv_correct, cv_correct, mask = green_mask_inv)
+	res2 = cv2.bitwise_and(green, green, mask = green_mask)
+
+	# Compone:
+	return cv2.add(res1, res2)

opencv_transform/maskdet_to_maskfin.py

@@ -0,0 +1,519 @@
+import numpy as np
+import cv2
+import os
+import random
+
+#My library:
+from opencv_transform.annotation import BodyPart
+
+###
+#
+#	maskdet_to_maskfin 
+#	
+#	steps:
+#		1. Extract annotation
+#			1.a: Filter by color
+#			1.b: Find ellipses
+#			1.c: Filter out ellipses by max size, and max total numbers
+#			1.d: Detect Problems
+#			1.e: Resolve the problems, or discard the transformation
+#		2. With the body list, draw maskfin, using maskref
+#
+###
+
+# create_maskfin ==============================================================================
+# return:
+#	(<Boolean> True/False), depending on the transformation process
+def create_maskfin(maskref, maskdet):
+	
+	#Create a total green image, in which draw details ellipses
+	details = np.zeros((512,512,3), np.uint8)
+	details[:,:,:] = (0,255,0)      # (B, G, R)
+
+	#Extract body part features:
+	bodypart_list = extractAnnotations(maskdet);
+
+	#Check if the list is not empty:
+	if bodypart_list:
+		
+		#Draw body part in details image:
+		for obj in bodypart_list:
+
+			if obj.w < obj.h:
+				aMax = int(obj.h/2) #asse maggiore
+				aMin = int(obj.w/2) #asse minore
+				angle = 0 #angle
+			else:
+				aMax = int(obj.w/2)
+				aMin = int(obj.h/2)
+				angle = 90
+
+			x = int(obj.x)
+			y = int(obj.y)
+
+			#Draw ellipse
+			if obj.name == "tit":
+				cv2.ellipse(details,(x,y),(aMax,aMin),angle,0,360,(0,205,0),-1) #(0,0,0,50)
+			elif obj.name == "aur":
+				cv2.ellipse(details,(x,y),(aMax,aMin),angle,0,360,(0,0,255),-1) #red
+			elif obj.name == "nip":
+				cv2.ellipse(details,(x,y),(aMax,aMin),angle,0,360,(255,255,255),-1) #white
+			elif obj.name == "belly":
+				cv2.ellipse(details,(x,y),(aMax,aMin),angle,0,360,(255,0,255),-1) #purple
+			elif obj.name == "vag":
+				cv2.ellipse(details,(x,y),(aMax,aMin),angle,0,360,(255,0,0),-1) #blue
+			elif obj.name == "hair":
+				xmin = x - int(obj.w/2)
+				ymin = y - int(obj.h/2)
+				xmax = x + int(obj.w/2)
+				ymax = y + int(obj.h/2)
+				cv2.rectangle(details,(xmin,ymin),(xmax,ymax),(100,100,100),-1)
+
+		#Define the green color filter
+		f1 = np.asarray([0, 250, 0])   # green color filter
+		f2 = np.asarray([10, 255, 10])
+		
+		#From maskref, extrapolate only the green mask		
+		green_mask = cv2.bitwise_not(cv2.inRange(maskref, f1, f2)) #green is 0
+
+		# Create an inverted mask
+		green_mask_inv = cv2.bitwise_not(green_mask)
+
+		# Cut maskref and detail image, using the green_mask & green_mask_inv
+		res1 = cv2.bitwise_and(maskref, maskref, mask = green_mask)
+		res2 = cv2.bitwise_and(details, details, mask = green_mask_inv)
+
+		# Compone:
+		maskfin = cv2.add(res1, res2)
+		return maskfin
+	
+# extractAnnotations ==============================================================================
+# input parameter:
+# 	(<string> maskdet_img): relative path of the single maskdet image (es: testimg1/maskdet/1.png)
+# return:
+#	(<BodyPart []> bodypart_list) - for failure/error, return an empty list []
+def extractAnnotations(maskdet):
+
+	#Load the image
+	#image = cv2.imread(maskdet_img)
+
+	#Find body part
+	tits_list = findBodyPart(maskdet, "tit")
+	aur_list = findBodyPart(maskdet, "aur")
+	vag_list = findBodyPart(maskdet, "vag")
+	belly_list = findBodyPart(maskdet, "belly")
+
+	#Filter out parts basing on dimension (area and aspect ratio):
+	aur_list = filterDimParts(aur_list, 100, 1000, 0.5, 3);
+	tits_list = filterDimParts(tits_list, 1000, 60000, 0.2, 3);
+	vag_list = filterDimParts(vag_list, 10, 1000, 0.2, 3);
+	belly_list = filterDimParts(belly_list, 10, 1000, 0.2, 3);
+
+	#Filter couple (if parts are > 2, choose only 2)
+	aur_list = filterCouple(aur_list);
+	tits_list = filterCouple(tits_list);
+
+	#Detect a missing problem:
+	missing_problem = detectTitAurMissingProblem(tits_list, aur_list) #return a Number (code of the problem)
+
+	#Check if problem is SOLVEABLE:
+	if (missing_problem in [3,6,7,8]):
+		resolveTitAurMissingProblems(tits_list, aur_list, missing_problem)
+	
+	#Infer the nips:
+	nip_list = inferNip(aur_list)
+
+	#Infer the hair:
+	hair_list = inferHair(vag_list)
+
+	#Return a combined list:
+	return tits_list + aur_list + nip_list + vag_list + hair_list + belly_list
+
+# findBodyPart ==============================================================================
+# input parameters:
+# 	(<RGB>image, <string>part_name)
+# return
+#	(<BodyPart[]>list)
+def findBodyPart(image, part_name):
+
+	bodypart_list = [] #empty BodyPart list
+
+	#Get the correct color filter:
+	if part_name == "tit":
+		#Use combined color filter 
+		f1 = np.asarray([0, 0, 0])   # tit color filter
+		f2 = np.asarray([10, 10, 10])
+		f3 = np.asarray([0, 0, 250])   # aur color filter
+		f4 = np.asarray([0, 0, 255])
+		color_mask1 = cv2.inRange(image, f1, f2)
+		color_mask2 = cv2.inRange(image, f3, f4)
+		color_mask = cv2.bitwise_or(color_mask1, color_mask2) #combine
+	
+	elif part_name == "aur":
+		f1 = np.asarray([0, 0, 250])   # aur color filter
+		f2 = np.asarray([0, 0, 255])
+		color_mask = cv2.inRange(image, f1, f2)
+	
+	elif part_name == "vag":
+		f1 = np.asarray([250, 0, 0])   # vag filter
+		f2 = np.asarray([255, 0, 0])
+		color_mask = cv2.inRange(image, f1, f2)
+
+	elif part_name == "belly":
+		f1 = np.asarray([250, 0, 250])   # belly filter
+		f2 = np.asarray([255, 0, 255])
+		color_mask = cv2.inRange(image, f1, f2)
+
+	#find contours:
+	contours, hierarchy = cv2.findContours(color_mask,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
+
+	#for every contour:
+	for cnt in contours:
+
+		if len(cnt)>5: #at least 5 points to fit ellipse
+
+			#(x, y), (MA, ma), angle = cv2.fitEllipse(cnt)
+			ellipse = cv2.fitEllipse(cnt)
+
+			#Fit Result:
+			x = ellipse[0][0] #center x
+			y = ellipse[0][1] #center y
+			angle = ellipse[2] #angle
+			aMin = ellipse[1][0]; #asse minore
+			aMax = ellipse[1][1]; #asse maggiore
+
+			#Detect direction:
+			if angle == 0:
+				h = aMax
+				w = aMin
+			else:
+				h = aMin
+				w = aMax
+			
+			#Normalize the belly size:
+			if part_name == "belly":
+				if w<15:
+					w *= 2
+				if h<15:
+					h *= 2
+
+			#Normalize the vag size:
+			if part_name == "vag":
+				if w<15:
+					w *= 2
+				if h<15:
+					h *= 2
+
+			#Calculate Bounding Box:
+			xmin = int(x - (w/2))
+			xmax = int(x + (w/2))
+			ymin = int(y - (h/2))
+			ymax = int(y + (h/2))
+
+			bodypart_list.append(BodyPart(part_name, xmin, ymin, xmax, ymax, x, y, w, h ))
+
+	return bodypart_list
+
+# filterDimParts ==============================================================================
+# input parameters:
+# 	(<BodyPart[]>list, <num> minimum area of part,  <num> max area, <num> min aspect ratio, <num> max aspect ratio)
+def filterDimParts(bp_list, min_area, max_area, min_ar, max_ar):
+
+	b_filt = []
+
+	for obj in bp_list:
+
+		a = obj.w*obj.h #Object AREA
+		
+		if ((a > min_area)and(a < max_area)):
+
+			ar = obj.w/obj.h #Object ASPECT RATIO
+
+			if ((ar>min_ar)and(ar<max_ar)):
+
+				b_filt.append(obj)
+
+	return b_filt
+
+# filterCouple ==============================================================================
+# input parameters:
+# 	(<BodyPart[]>list)
+def filterCouple(bp_list):
+
+	#Remove exceed parts
+	if (len(bp_list)>2):
+
+		#trovare coppia (a,b) che minimizza bp_list[a].y-bp_list[b].y
+		min_a = 0
+		min_b = 1
+		min_diff = abs(bp_list[min_a].y-bp_list[min_b].y)
+		
+		for a in range(0,len(bp_list)):
+			for b in range(0,len(bp_list)):
+				#TODO: avoid repetition (1,0) (0,1)
+				if a != b:
+					diff = abs(bp_list[a].y-bp_list[b].y)
+					if diff<min_diff:
+						min_diff = diff
+						min_a = a
+						min_b = b
+		b_filt = []
+
+		b_filt.append(bp_list[min_a])
+		b_filt.append(bp_list[min_b])
+
+		return b_filt
+	else:
+		#No change
+		return bp_list
+
+
+
+# detectTitAurMissingProblem ==============================================================================
+# input parameters:
+# 	(<BodyPart[]> tits list, <BodyPart[]> aur list)
+# return
+#	(<num> problem code)
+#   TIT  |  AUR  |  code |  SOLVE?  |
+#    0   |   0   |   1   |    NO    |
+#    0   |   1   |   2   |    NO    |
+#    0   |   2   |   3   |    YES   |
+#    1   |   0   |   4   |    NO    |
+#    1   |   1   |   5   |    NO    |
+#    1   |   2   |   6   |    YES   |
+#    2   |   0   |   7   |    YES   |
+#    2   |   1   |   8   |    YES   |
+def detectTitAurMissingProblem(tits_list, aur_list):
+
+	t_len = len(tits_list)
+	a_len = len(aur_list)
+
+	if (t_len == 0):
+		if (a_len == 0):
+			return 1
+		elif (a_len == 1):
+			return 2
+		elif (a_len == 2):
+			return 3
+		else:
+			return -1
+	elif (t_len == 1):
+		if (a_len == 0):
+			return 4
+		elif (a_len == 1):
+			return 5
+		elif (a_len == 2):
+			return 6
+		else:
+			return -1
+	elif (t_len == 2):
+		if (a_len == 0):
+			return 7
+		elif (a_len == 1):
+			return 8
+		else:
+			return -1
+	else:
+		return -1
+
+# resolveTitAurMissingProblems ==============================================================================
+# input parameters:
+# 	(<BodyPart[]> tits list, <BodyPart[]> aur list, problem code)
+# return
+#	none
+def resolveTitAurMissingProblems(tits_list, aur_list, problem_code):
+
+	if problem_code == 3:
+
+		random_tit_factor = random.randint(2, 5) #TOTEST
+
+		#Add the first tit:
+		new_w = aur_list[0].w * random_tit_factor #TOTEST
+		new_x = aur_list[0].x
+		new_y = aur_list[0].y
+
+		xmin = int(new_x - (new_w/2))
+		xmax = int(new_x + (new_w/2))
+		ymin = int(new_y - (new_w/2))
+		ymax = int(new_y + (new_w/2))
+
+		tits_list.append(BodyPart("tit", xmin, ymin, xmax, ymax, new_x, new_y, new_w, new_w ))
+
+		#Add the second tit:
+		new_w = aur_list[1].w * random_tit_factor #TOTEST
+		new_x = aur_list[1].x
+		new_y = aur_list[1].y
+
+		xmin = int(new_x - (new_w/2))
+		xmax = int(new_x + (new_w/2))
+		ymin = int(new_y - (new_w/2))
+		ymax = int(new_y + (new_w/2))
+
+		tits_list.append(BodyPart("tit", xmin, ymin, xmax, ymax, new_x, new_y, new_w, new_w ))
+
+	elif problem_code == 6:
+
+		#Find wich aur is full:
+		d1 = abs(tits_list[0].x - aur_list[0].x)
+		d2 = abs(tits_list[0].x - aur_list[1].x)
+
+		if d1 > d2:
+			#aur[0] is empty
+			new_x = aur_list[0].x
+			new_y = aur_list[0].y
+		else:
+			#aur[1] is empty
+			new_x = aur_list[1].x
+			new_y = aur_list[1].y
+
+		#Calculate Bounding Box:
+		xmin = int(new_x - (tits_list[0].w/2))
+		xmax = int(new_x + (tits_list[0].w/2))
+		ymin = int(new_y - (tits_list[0].w/2))
+		ymax = int(new_y + (tits_list[0].w/2))
+
+		tits_list.append(BodyPart("tit", xmin, ymin, xmax, ymax, new_x, new_y, tits_list[0].w, tits_list[0].w ))
+
+	elif problem_code == 7:
+
+		#Add the first aur:
+		new_w = tits_list[0].w * random.uniform(0.03, 0.1) #TOTEST
+		new_x = tits_list[0].x
+		new_y = tits_list[0].y
+
+		xmin = int(new_x - (new_w/2))
+		xmax = int(new_x + (new_w/2))
+		ymin = int(new_y - (new_w/2))
+		ymax = int(new_y + (new_w/2))
+
+		aur_list.append(BodyPart("aur", xmin, ymin, xmax, ymax, new_x, new_y, new_w, new_w ))
+
+		#Add the second aur:
+		new_w = tits_list[1].w * random.uniform(0.03, 0.1) #TOTEST
+		new_x = tits_list[1].x
+		new_y = tits_list[1].y
+
+		xmin = int(new_x - (new_w/2))
+		xmax = int(new_x + (new_w/2))
+		ymin = int(new_y - (new_w/2))
+		ymax = int(new_y + (new_w/2))
+		
+		aur_list.append(BodyPart("aur", xmin, ymin, xmax, ymax, new_x, new_y, new_w, new_w ))
+
+	elif problem_code == 8:
+
+		#Find wich tit is full:
+		d1 = abs(aur_list[0].x - tits_list[0].x)
+		d2 = abs(aur_list[0].x - tits_list[1].x)
+
+		if d1 > d2:
+			#tit[0] is empty
+			new_x = tits_list[0].x
+			new_y = tits_list[0].y
+		else:
+			#tit[1] is empty
+			new_x = tits_list[1].x
+			new_y = tits_list[1].y
+
+		#Calculate Bounding Box:
+		xmin = int(new_x - (aur_list[0].w/2))
+		xmax = int(new_x + (aur_list[0].w/2))
+		ymin = int(new_y - (aur_list[0].w/2))
+		ymax = int(new_y + (aur_list[0].w/2))
+		aur_list.append(BodyPart("aur", xmin, ymin, xmax, ymax, new_x, new_y, aur_list[0].w, aur_list[0].w ))
+
+# detectTitAurPositionProblem ==============================================================================
+# input parameters:
+# 	(<BodyPart[]> tits list, <BodyPart[]> aur list)
+# return
+#	(<Boolean> True/False)
+def detectTitAurPositionProblem(tits_list, aur_list):
+
+	diffTitsX = abs(tits_list[0].x - tits_list[1].x)
+	if diffTitsX < 40:
+		print("diffTitsX")
+		#Tits too narrow (orizontally)
+		return True
+
+	diffTitsY = abs(tits_list[0].y - tits_list[1].y)
+	if diffTitsY > 120:
+		#Tits too distanced (vertically)
+		print("diffTitsY")
+		return True
+
+	diffTitsW = abs(tits_list[0].w - tits_list[1].w)
+	if ((diffTitsW < 0.1)or(diffTitsW>60)):
+		print("diffTitsW")
+		#Tits too equals, or too different (width)
+		return True
+
+	#Check if body position is too low (face not covered by watermark)
+	if aur_list[0].y > 350: #tits too low
+		#Calculate the ratio between y and aurs distance
+		rapp = aur_list[0].y/(abs(aur_list[0].x - aur_list[1].x))
+		if rapp > 2.8:
+			print("aurDown")
+			return True
+
+	return False
+
+# inferNip ==============================================================================
+# input parameters:
+# 	(<BodyPart[]> aur list)
+# return
+#	(<BodyPart[]> nip list)
+def inferNip(aur_list):
+	nip_list = []
+
+	for aur in aur_list:
+
+		#Nip rules:
+		# - circle (w == h)
+		# - min dim: 5
+		# - bigger if aur is bigger
+		nip_dim = int(5 + aur.w*random.uniform(0.03, 0.09))
+
+		#center:
+		x = aur.x
+		y = aur.y
+
+		#Calculate Bounding Box:
+		xmin = int(x - (nip_dim/2))
+		xmax = int(x + (nip_dim/2))
+		ymin = int(y - (nip_dim/2))
+		ymax = int(y + (nip_dim/2))
+
+		nip_list.append(BodyPart("nip", xmin, ymin, xmax, ymax, x, y, nip_dim, nip_dim ))
+
+	return nip_list
+
+# inferHair (TOTEST) ==============================================================================
+# input parameters:
+# 	(<BodyPart[]> vag list)
+# return
+#	(<BodyPart[]> hair list)
+def inferHair(vag_list):
+	hair_list = []
+
+	#70% of chanche to add hair
+	if random.uniform(0.0, 1.0) > 0.3:
+
+		for vag in vag_list:
+
+			#Hair rules:
+			hair_w = vag.w*random.uniform(0.4, 1.5)
+			hair_h = vag.h*random.uniform(0.4, 1.5) 
+
+			#center:
+			x = vag.x
+			y = vag.y - (hair_h/2) - (vag.h/2)
+
+			#Calculate Bounding Box:
+			xmin = int(x - (hair_w/2))
+			xmax = int(x + (hair_w/2))
+			ymin = int(y - (hair_h/2))
+			ymax = int(y + (hair_h/2))
+
+			hair_list.append(BodyPart("hair", xmin, ymin, xmax, ymax, x, y, hair_w, hair_h ))
+
+	return hair_list

opencv_transform/nude_to_watermark.py

@@ -0,0 +1,28 @@
+import cv2
+import numpy as np
+import os
+
+# create_watermark ===============================================================
+# return:
+#	(<Boolean> True/False), depending on the transformation process
+def create_watermark(nude):
+
+	# Add alpha channel if missing
+	# if nude.shape[2] < 4:
+	# 	nude = np.dstack([nude, np.ones((512, 512), dtype="uint8") * 255])
+
+	# watermark = cv2.imread("fake.png", cv2.IMREAD_UNCHANGED)
+	
+	# f1 = np.asarray([0, 0, 0, 250])   # red color filter
+	# f2 = np.asarray([255, 255, 255, 255])
+	# mask = cv2.bitwise_not(cv2.inRange(watermark, f1, f2))
+	# mask_inv = cv2.bitwise_not(mask)
+
+	# res1 = cv2.bitwise_and(nude, nude, mask = mask)
+	# # res2 = cv2.bitwise_and(nude, nude, mask = mask)
+	# # res2 = cv2.bitwise_and(watermark, watermark, mask = mask_inv)
+	# res = res1
+
+	# alpha = 0.6
+	# return cv2.addWeighted(res, alpha, nude, 1 - alpha, 0) 
+	return nude