def applyPolyMask(eye, show=True): polymask = None eye.wip = cv2.bitwise_and(eye.wip, eye.polyMask) # eye.wip = cv2.bitwise_and(eye.wip, eye.manyPolyMask) if show: m3Show.imshow(eye.wip, "masked") return eye
def contrast(inputImg, show): inputImg = PIL.Image.fromarray(inputImg) outputImg = ImageEnhance.Contrast(inputImg).enhance(1.4) if (show): m3Show.imshow(outputImg, "Contrast") outputImg = np.asarray(outputImg) return outputImg
def makeCircularMask(photo, show=True, onlyOne=True): # for photo in photoArray: # print("photo") # photo = inputImg for face in photo.faces: # print("facee") for eye in face.eyes: # print("eye") maskImg = np.zeros_like(eye.wip) if not isinstance(eye.circle, type(None)): # firstCircle = eye.circle[0] if onlyOne: i = eye.circle[0][0] # print("i", i) # print("onlyone", i[0], i[1], i[2]) cv2.circle(maskImg, (i[0], i[1]), i[2], (255, 255, 255), -1) else: for i in eye.circle[0, :]: # print("i", i) cv2.circle(maskImg, (i[0], i[1]), i[2], (255, 255, 255), -1) if (show): m3Show.imshow(maskImg, "mask") eye.mask = maskImg return photo
def batchcc(photoArray): for photo in photoArray: for face in photo.faces: for eye in face.eyes: ret, thresh1 = cv2.threshold(eye.iris,1,255,cv2.THRESH_BINARY) m3Show.imshow( eye.testMask, "MANMADE:") m3Show.imshow(thresh1, "thresh1:") compare(eye.testMask,thresh1) return photoArray
def generateComparison(photoArray, outputName=None, attrs=None, folderName=None, exportFullMask=False, CSV=True, settings=None): # print("generateComparison os.makedirs("EXPORTS/" + folderName + "/", exist_ok=True) for photo in photoArray: facesToSave = [] if (exportFullMask): os.makedirs("EXPORTS/" + folderName + "/", exist_ok=True) cv2.imwrite( "EXPORTS/" + folderName + "/" + os.path.basename(photo.path) + "_FullMask" + ".jpg", photo.fullMask) for face in photo.faces: if not (type(face.eyes) == type(None)): # TODO: fix this for eye in face.eyes: # print(attrs) for attr in eye.__dict__.items(): # print("attr", attr) if attr[0] in attrs: # if # print("attr[1].itemsize", attr[1].size) if attr[1].size > 1: # print(attr[0],attr[1], type(attr[1]), attr[1].shape) facesToSave.append(attr[1]) # else: # facesToSave.append(eye.image) # if (len(eyesToSave) > 1): # facesToSave.append(eyesToSave) # else: # facesToSave.append(eyesToSave[0]) now = datetime.now() now_string = now.strftime("%d-%m-%Y--%H-%M-%S") # print(facesToSave[0], type(facesToSave[0])) output = concat(facesToSave, direction="v") m3Show.imshow(output, "generateComparison output") if (folderName is not None): cv2.imwrite( "EXPORTS/" + folderName + "/" + os.path.basename(photo.path) + "_" + ".jpg", output) else: cv2.imwrite("EXPORTS/COMPARISONS/" + now_string + ".jpg", output) m3CSV.makeCSV(photoArray, "EXPORTS/" + folderName + "/" + folderName + ".csv") file = open("EXPORTS/" + folderName + "/" + "settings.txt", "w+") count = 1 # for element in m3F.funcArrToStr(): # print("element",element) file.write(str(settings)) # count += 1 file.close() return photoArray
def findEyes2(photo, division, show=True): # downScaledDim = (round(w/100 *(scalePercent)),round(h/100 * (scalePercent))) h, w, c = photo.originalImage.shape downScaledDim = ((round(w / division)), round(h / division)) copy = photo.originalImage.copy() pil_image = Image.fromarray(copy) inputImg = copy img = cv2.resize(inputImg, downScaledDim) dimToScaleUp = division detector = dlib.get_frontal_face_detector() dets = detector(img, 1) print("dets", dets) print("Number of faces detected: {}".format(len(dets))) for index, data in enumerate(dets): if index == 0: # print("Detection {}: Left: {} Top: {} Right: {} Bottom: {}".format( # k, d.left(), d.top(), d.right(), d.bottom())) # Get the landmarks/parts for the face in box d. shape = predictor(img, data) print("kkkk", index) # for part in shape.part # print("shape.parts():", shape.parts()) # print("Part 0: {}, Part 1: {} ...".format(shape.part(0), # shape.part(1))) points = [] imgwithPoints = img.copy() for i in range(shape.num_parts): point = shape.part(i) # for x, y in set: imgwithPoints = cv2.rectangle(imgwithPoints, (point.x - 10, point.y - 10), (point.x + 10, point.y + 10), (0, 0, 255), -1) points.append([point.x * division, point.y * division]) cv2.imwrite( "pointsss" + datetime.now().strftime("%d-%m-%Y--%H-%M-%S") + ".jpg", imgwithPoints) m3Show.imshow(imgwithPoints, "imgwithPoints") for eye in photo.faces[0].eyes: cropRect = eye.cropRect print("cropRect", cropRect) for x, y in points: #"The box is a 4-tuple defining the left, upper, right, and lower pixel coordinate" # print("x, y", x,y) imgwithPoints = img.copy() if (x > cropRect[0] and x < cropRect[2]): if (y > cropRect[1] and y < cropRect[3]): # print("in bounds x, y", x, y) eye.manyLandmarkPoints.append([x, y]) imgwithPoints = cv2.rectangle( imgwithPoints, (x - 100, y - 100), (x + 100, y + 100), (0, 0, 255), -1) m3Show.imshow(imgwithPoints, "in bounds! imgwithPoints") return photo
def findEyes194(photo, division, show=True, ): img = photo.loResImage detector = dlib.get_frontal_face_detector() foundFaces = detector(img, 1) # print("foundFaces", foundFaces) # print("Number of faces detected: {}".format(len(foundFaces))) for index, data in enumerate(foundFaces): if index == 0: shape = predictor(img, data) e0points = [] e1points = [] for i in range(shape.num_parts): point = shape.part(i) # if (i >= 48 and i <= 69): # if (i >= 40 and i <= 75): # e1points.append([round(point.x ), round(point.y )]) if (i >= 20 and i <= 50): # e0points.append([round(point.x ), round(point.y )]) # print("points", points) eyePoints = [e1points,e0points] eyeCount = 0 for eye in photo.faces[0].eyes: # print("eyeCount",eyeCount) cropRect = eye.cropRect # print("cropRect", cropRect) # eye.manyLandmarkPoints = [] points = eyePoints[eyeCount] # ys = [] # print("points", points) margin = eye.margin upscaledLandmarks = [] m3Show.imshow(eye.image,"eye.image") for x, y in points: # ys.append(y) # ensure that the points are within the croprect from 68 landmarks # croprect: "The box is a 4-tuple defining the left, upper, right, and lower pixel coordinate" if (x * division > cropRect[0] and x * division < cropRect[2]): if (y * division > cropRect[1] and y * division< cropRect[3]): # upscaledLandmarks.append([((x - (cropRect[0]-(margin*division))) ), ((y-(cropRect[1]-(margin*division))) )]) # print("cropRect", eye.cropRect) # upscaledLandmarks.append([(((x * division)- ((cropRect[0]) - 0))) , ((((y*division) -((cropRect[1]) - 0)))) ]) # eye.manyLandmarkPoints.append([x, y]) # upscaledLandmarks.append([((x - (cropRect[0]-margin)) * division), ((y-(cropRect[1]-margin)) * division)]) upscaledLandmarks.append([((x - (eye.minX-eye.margin)) * division), ((y-(eye.minY-eye.margin)) * division)]) # print("194upscaledLandmarks",upscaledLandmarks) # eye.mask194 = makePolyMask(photo.originalImage, upscaledLandmarks) eye.mask194 = makePolyMask(eye.image, upscaledLandmarks) # cv2.imwrite("EXPORTS/COMPARISONS/mask194.jpg", eye.mask194) eyeCount += 1 return photo
def makeCircularOutline(eye, circles, show=False, dest=None): # for face in photo.faces: # for eye in face.eyes: maskImg = eye.image.copy() if not isinstance(eye.circle, type(None)): # firstCircle = eye.circle[0] for i in circles[0, :]: print("i", i) cv2.circle(maskImg, (i[0], i[1]), i[2], (255, 255, 255), 2) # eye.mask = maskImg # setattr(eye, dest, maskImg) if (show): m3Show.imshow(maskImg, "mask") return maskImg
def makeSmaller(eye, show=True, scale=5, debug=True, minimum=50): h, w, c = eye.image.shape # print("originalShape", h,w,c) # mini downScaledDim = ((round(w / scale)), round(h / scale)) inputImg = eye.wip.copy() inputImg = cv2.resize(inputImg, downScaledDim) # if inputImg.shape[1] > minimum eye.wip = inputImg m3Show.imshow(eye.wip, "makeSmaller") # eye. if debug: print("makeSmaller: Shape : ", inputImg.shape) return eye
def applyCircMask(photo, show=True, useOriginal=True): # for photo in photoArray: # print(photo) for face in photo.faces: for eye in face.eyes: if (eye.mask is None): m3F.printRed("THERE'S NOT MASK") break # print("eye.image.shape", eye.image.shape) # print("eye.mask.shape", eye.mask.shape) if useOriginal: eye.iris = cv2.bitwise_and(eye.image, eye.mask) else: eye.iris = cv2.bitwise_and(eye.wip, eye.mask) if show: m3Show.imshow(eye.iris, "masked") return photo
def makeManyPolyMask(photo, show=True): # ********************************************************************** # polyMask = np.zeros_like(photo.originalImage) # ********************************************************************** for face in photo.faces: for eye in face.eyes: polyMask = np.zeros_like(eye.image) print("manyLandmarkPoints", eye.manyLandmarkPoints) polyMask = cv2.fillPoly(polyMask, np.int_([eye.manyLandmarkPoints]), (255, 255, 255)) # m3Show.imshow(polyMask, "POLYMASK") # epm = m3Class.Eye(np.asarray(pil_image.crop(left)), left, lEyeCoor) # epm = polyMask.crop(eye.cropRect) # eye.manyPolyMask = m3F.typeSwap(m3F.typeSwap(polyMask).crop(eye.cropRect)) eye.manyPolyMask = polyMask # if show: m3Show.imshow(eye.manyPolyMask, "manypoly") return photo
def loadMasksForComparison(photoArray, maskFolder): maskImgs = glob.glob(maskFolder + "*.*g") # load folder of masked images # print("maskImgs", maskImgs) maskImgs.sort() # sort filenames, so 001test comes first, and so on # print("maskImgs", maskImgs) count = 0 for photo in photoArray: # print("LOADING: ", maskImgs[count], "FOR ", photo.path) photo.testMask = cv2.imread(maskImgs[count], -1) m3Show.imshow(photo.testMask, "photo.testMask") count += 1 for face in photo.faces: for eye in face.eyes: eye.testMask = m3F.typeSwap( m3F.typeSwap(photo.testMask).crop(eye.cropRect)) # typeswap, as we want # to use a pillow func on np-array. return photoArray
def fullImgEyeOutline(photo, show): fullMask = photo.originalImage.copy() x, y, channels = fullMask.shape for face in photo.faces: for eye in face.eyes: if not isinstance(eye.mask, type(None)): coor = eye.cropRect # fullMask[coor[0]:x, coor[1]:y] = eye.mask for i in eye.circle[0, :]: print("i", i) cv2.circle(fullMask, (coor[0]+i[0], coor[1]+i[1]), i[2], (0, 255, 0), 2) print("coor", coor) #fullMask[coor[1]:coor[1]+eye.mask.shape[0], coor[0]:coor[0]+eye.mask.shape[1]] = eye.mask photo.mask = fullMask if (show): m3Show.imshow(photo.originalImage, "full original") m3Show.imshow(photo.mask, "full mask") return photo
def mask(eye, img=None, mask=None, dest=None, show=True): # print(eye.__dict__.items()) print("img", img) print("mask", mask) # m3Show.imshow(img, "mask masked") # m3Show.imshow(mask, "to compare") # print("eye in mask",eye) img = returnAttr(eye, img) mask = returnAttr(eye, mask) if (img is None or mask is None): setattr(eye, dest, np.zeros_like(img)) m3F.printRed(" IMG OR MASK WAS NONE. NOT MASKING") eye.noCircles = True return eye # print("img.shape", img.shape) # print( "mask.shape", mask.shape) # destination = returnAttr(eye, dest) bah = cv2.bitwise_and(img, mask) setattr(eye, dest, bah) if show: m3Show.imshow(img, "image to be masked") m3Show.imshow(mask, "mask") m3Show.imshow(bah, "result") # print(eye.__dict__.items()) return eye
def findEyes2(photo, division, show=True): detector = dlib.get_frontal_face_detector() # downScaledDim = (round(w/100 *(scalePercent)),round(h/100 * (scalePercent))) h, w, c = photo.originalImage.shape downScaledDim = ((round(w / division)), round(h / division)) copy = photo.originalImage.copy() pil_image = Image.fromarray(copy) inputImg = copy img = cv2.resize(inputImg, downScaledDim) dimToScaleUp = division predictor = dlib.shape_predictor ("MODELS/shape_predictor_194_face_landmarks.dat") dets = detector(img, 1) print("dets", dets) print("Number of faces detected: {}".format(len(dets))) for k, d in enumerate(dets): # print("Detection {}: Left: {} Top: {} Right: {} Bottom: {}".format( # k, d.left(), d.top(), d.right(), d.bottom())) # Get the landmarks/parts for the face in box d. shape = predictor(img, d) print("kkkk", k) # for part in shape.part # print("shape.parts():", shape.parts()) # print("Part 0: {}, Part 1: {} ...".format(shape.part(0), # shape.part(1))) imgwithPoints = img.copy() for i in range(shape.num_parts): p = shape.part(i) print("p", p) # for x, y in set: imgwithPoints = cv2.rectangle(imgwithPoints, (p.x - 10, p.y - 10), (p.x + 10, p.y + 10), (0, 0, 255), -1) cv2.imwrite( "pointsss" + datetime.now().strftime("%d-%m-%Y--%H-%M-%S") + ".jpg", imgwithPoints) m3Show.imshow(imgwithPoints, "imgwithPoints")
def makePolyMask(photoForDims, polys, show=True): # polyMask = np.zeros_like(photo.originalImage) polyMask = np.zeros_like(photoForDims) # print("polyMask.shape",polyMask.shape) # print("EYE COOR", eye.landmarkPoints) # print("np.int_(polys)", np.int_([polys])) polyMask = cv2.fillPoly(polyMask, np.int_([polys]), (255, 255, 255)) # polymask = cv2.fillConvexPoly(polyMask, np.int_([eye.landmarkPoints]), (255, 255, 255),1000) # polymask = cv2.drawContours(polyMask, np.int_([eye.landmarkPoints]),-1, (255, 255, 255), 2) # polymask = cv2.approxPolyDP(np.int_([eye.landmarkPoints]),4, True) # xs, ys = [], [] # for x, y in eye.eye.landmarkPoints: # xs.append(x) # ys.append(y) # polymask = cv2.poly # print(polymask) if show: m3Show.imshow(polyMask, "POLYMASK") # epm = m3Class.Eye(np.asarray(pil_image.crop(left)), left, lEyeCoor) # epm = polyMask.crop(eye.cropRect) # eye.polyMask = m3F.typeSwap(m3F.typeSwap(polyMask).crop(eye.cropRect)) return polyMask
def makeCircularMask(img, circles, show=True, onlyOne=True): # for photo in photoArray: # print("photo") # photo = inputImg # print("eye") maskImg = np.zeros_like(img) # if not isinstance(eye.circle, type(None)): # firstCircle = eye.circle[0] if circles is not None: if onlyOne: i = circles[0][0] # print("i", i) # print("onlyone", i[0], i[1], i[2]) cv2.circle(maskImg, (i[0], i[1]), i[2], (255, 255, 255), -1) else: for i in circles[0, :]: # print("i", i) cv2.circle(maskImg, (i[0], i[1]), i[2], (255, 255, 255), -1) else: return maskImg if (show): m3Show.imshow(maskImg, "mask") return maskImg
def canny(inputImg, show=True, thresh1=100, thresh2=100): out = cv2.Canny(inputImg, thresh1, thresh2) if show: m3Show.imshow(out, "canny") return out
def pixelcomparison(inputImg, inputImg2, show): orgHandMask = inputImg orgAutoMask = inputImg2 m3Show.imshow(orgHandMask,"handMask") height,width= orgHandMask.shape imgSize=height*width TruePositive = 0.0 FalsePositive = 0.0 FalseNegative = 0.0 handMaskAccumLum = 0.0 autoMaskAccumLum = 0.0 autoMask = orgAutoMask.astype("float64") handMask = orgHandMask.astype("float64") for y in range(height): for x in range(width): autoMask[y,x]= (orgAutoMask[y,x]/255) handMask[y,x]= (orgHandMask[y,x]/255) if (autoMask[y,x] == handMask[y,x]): TruePositive += handMask[y,x] if (autoMask[y,x] < handMask[y,x]): FalseNegative += (handMask[y,x]-autoMask[y,x]) TruePositive += autoMask[y,x]/handMask[y,x] if (autoMask[y,x] > handMask[y,x]): FalsePositive += autoMask[y,x] - handMask[y,x] TruePositive += handMask[y,x]/autoMask[y,x] handMaskAccumLum += handMask[y,x] autoMaskAccumLum += autoMask[y,x] print(autoMask) print ("handMaskAccumLum",handMaskAccumLum) print("TruePositive",TruePositive) print("FalseNegative",FalseNegative) print("FalsePositive",FalsePositive) TruePositive= (TruePositive/handMaskAccumLum)*100 FalseNegative=(FalseNegative/handMaskAccumLum) *100 FalsePositive1=(FalsePositive/autoMaskAccumLum)*100 FalsePositive=(FalsePositive/handMaskAccumLum)*100 print("TruePositive%",TruePositive,"% of accumulated pixel values of handmask") print("FalseNegative%",FalseNegative,"% of accumulated pixel values of handmask") print("FalsePositive%",FalsePositive,"% of accumulated pixel values of handmask") print("FalsePositive%",FalsePositive1,"% of accumulated pixel values of automask") autoMask = autoMask*255 handMask = handMask*255 autoMask = orgAutoMask.astype("uint8") handMask = orgHandMask.astype("uint8") M3Show.imshow(orgHandMask,"handMask") M3Show.imshow(orgAutoMask,"autoMask")
def findEyes(photo, division, show=True): # print("photo type", type(photo)) h, w, c = photo.originalImage.shape # downScaledDim = (round(w/100 *(scalePercent)),round(h/100 * (scalePercent))) downScaledDim = ((round(w / division)), round(h / division)) copy = photo.originalImage.copy() pil_image = Image.fromarray(copy) inputImg = copy inputImg = cv2.resize(inputImg, downScaledDim) dimToScaleUp = division # if show: # print("originalShape", h, w, c) # print("downScaledDim", downScaledDim) # m3Show.imshow(m3F.typeSwap(pil_image), "image to find eyes on") # m3Show.imshow(photo.originalImage, " FINDEYS TEST") # print("proccesing", inputImgPath), # inputImg = cv2.imread(inputImgPath) face_landmarks_list = face_recognition.face_landmarks(inputImg) #print("I found {} face(s) in this photograph.".format(len(face_landmarks_list))) #print("face_landmarks_list type was", type(face_landmarks_list)) # Create a PIL imagedraw object so we can draw on the picture # pil_image = Image.fromarray(inputImg) if (len(face_landmarks_list) == 0): m3F.printRed(" found no faces in this picture") plt.imshow(cv2.cvtColor(inputImg, cv2.COLOR_RGB2BGR)) plt.show() return [m3Class.Face(noFaceImg=inputImg)] faces = [] for face_landmarks in face_landmarks_list: lEyeCoor = face_landmarks['left_eye'] rEyeCoor = face_landmarks['right_eye'] print() mg = (lEyeCoor[3][0] - lEyeCoor[0][0]) * 0.2 * 10 # ********************************************************************** imgwithPoints = inputImg.copy() for eye in (lEyeCoor, rEyeCoor): for x, y in eye: imgwithPoints = cv2.rectangle(imgwithPoints, (x - 2, y - 20), (x + 20, y + 20), (0, 0, 255), -1) # ********************************************************************** # if debug: # m3Show.imshow(imgwithPoints, "with points") eyes = [] for eyeLandmarkPoints in lEyeCoor, rEyeCoor: xs, ys = [], [] for x, y in eyeLandmarkPoints: xs.append(x) ys.append(y) print("x y ", x, y) xs.sort(reverse=True) ys.sort(reverse=True) maxX = xs[0] maxY = ys[0] xs.sort(reverse=False) ys.sort(reverse=False) minX = xs[0] minY = ys[0] # print("maxX,maxY,minX,minY", maxX, maxY, minX, minY) margin = round((maxX - minX) * 0.2) cropRect = (minX - margin, minY - margin, maxX + margin, maxY + margin) cropRect = [round(division * num) for num in cropRect] # for num in margin: num * division if show: m3Show.imshow(np.asarray(pil_image.crop(cropRect)), "cropRect") upscaledLandmarks = [] for x, y in eyeLandmarkPoints: upscaledLandmarks.append((x * division, y * division)) # y = y * division # print("upscaledLandmarks", upscaledLandmarks) eyes.append( m3Class.Eye(np.asarray(pil_image.crop(cropRect)), cropRect, upscaledLandmarks)) faces.append(m3Class.Face(eyes)) return faces
def pixelcomparison(photoArray, eyeAttr="", show=True): for photo in photoArray: for face in photo.faces: for eye in face.eyes: if eye.noCircles is True: eye.TP = 0 eye.FN = 0 eye.FP = 0 eye.TPFN = 0 eye.TN = 0 eye.rTP = 0 eye.rFN = 0 eye.rFP = 0 eye.rTN = 0 eye.rHandAccum = 0 eye.rAutoAccum = 0 else: # ret, autoThresh = cv2.threshold(eye.iris,1,255,cv2.THRESH_BINARY) orgAutoMask = getattr(eye, eyeAttr) print("orgAutoMask", eyeAttr) # cv2.imwrite(orgAutoMask, ) # m3Show.imshow("orgAutoMask", orgAutoMask) # m3Show.imshow("orgHandMask",eye.testMask ) # file = open("EXPORTS/" + "blur4.txt","w+") # file.write(np.array2string(orgAutoMask,max_line_width=None, precision=None, suppress_small=None, threshold=10000000)) # count += 1 # file.close() # ret, orgAutoMask = cv2.threshold(orgAutoMask,1,255,cv2.THRESH_BINARY) # ret, orgHandMask = cv2.threshold(eye.testMask,1,255,cv2.THRESH_BINARY) orgHandMask = eye.testMask m3Show.imshow(eye.testMask, "testmask") # ret, orgHandMask = cv2.threshold(orgHandMask,1,255,cv2.THRESH_BINARY) # print("orgHandMask", eye.testMask) # print( orgAutoMask.shape, "orgAutoMask", orgHandMask.shape, "orgHandMask") # print("orgHandMask", eye.testMask) # orgAutoMask=cv2.cvtColor(orgAutoMask, cv2.COLOR_BGR2GRAY) # orgHandMask=cv2.cvtColor(orgHandMask, cv2.COLOR_BGR2GRAY) # orgHandMask = m3F.getRed(orgHandMask, False) # orgAutoMask = m3F.getRed(orgAutoMask, False) # m3Show.imshow(orgAutoMask, "orgAutoMask") # m3Show.imshow(orgHandMask, "orgHandMask") # m3Show.imshow(orgHandMask,"handMask") height, width, c = orgHandMask.shape imgSize = height * width TruePositive = 0.0 TrueNegative = 0.0 FalsePositive = 0.0 FalseNegative = 0.0 handMaskAccumLum = 0.0 autoMaskAccumLum = 0.0 autoMask = orgAutoMask.astype("float64") handMask = orgHandMask.astype("float64") # print("autoMask", autoMask) TPi, FNi, FPi, TNi = None, None, None, None # TPi = np.ndarray(shape=(autoMask.shape), dtype=np.uint8) # FNi = np.ndarray(shape=(autoMask.shape), dtype=np.uint8) # FPi = np.ndarray(shape=(autoMask.shape), dtype=np.uint8) orgAutoMask TPi = np.zeros_like(orgAutoMask) TNi = np.zeros_like(orgAutoMask) FNi = np.zeros_like(orgAutoMask) FPi = np.zeros_like(orgAutoMask) print(autoMask.shape, "autoMask", handMask.shape, "handMask") for y in range(height): for x in range(width): autoMask[y, x, 0] = (orgAutoMask[y, x, 0] / 255) handMask[y, x, 0] = (orgHandMask[y, x, 0] / 255) # TPi = np.zeros_like(eye.image) # print("autoMask[y,x,0]", autoMask[y,x,0],"handMask[y,x,0]",handMask[y,x,0]) # if (autoMask[y,x,0] == handMask[y,x,0]): # TruePositive += handMask[y,x,0] # TPi[y,x] = (0,255,0) # if (autoMask[y,x,0] == 0 and handMask[y,x,0] == 0): # # TruePositive += handMask[y,x,0] # TNi[y,x] = (0,127,0) # # elif (autoMask[y,x,0] < handMask[y,x,0]): # FalseNegative += (handMask[y,x,0]-autoMask[y,x,0]) # # TruePositive += autoMask[y,x,0]/handMask[y,x,0] # TruePositive += handMask[y,x,0]/autoMask[y,x,0] # FNi[y,x] = (255,0,0) # # elif (autoMask[y,x,0] > handMask[y,x,0]): # FalsePositive += autoMask[y,x,0] - handMask[y,x,0] # TruePositive += autoMask[y,x,0]/handMask[y,x,0] # FPi[y,x] = (0,0,255) if (autoMask[y, x, 0] == handMask[y, x, 0]): TruePositive += handMask[y, x, 0] TPi[y, x] = (0, 255, 0) TrueNegative += 1 - handMask[y, x, 0] if (autoMask[y, x, 0] == 0 and handMask[y, x, 0] == 0): TNi[y, x] = (0, 127, 0) # TN += 1 if (autoMask[y, x, 0] < handMask[y, x, 0]): FalseNegative += (handMask[y, x, 0] - autoMask[y, x, 0]) TruePositive += autoMask[y, x, 0] FNi[y, x] = (255, 0, 0) TrueNegative += 1 - handMask[y, x, 0] if (autoMask[y, x, 0] > handMask[y, x, 0]): FalsePositive += autoMask[y, x, 0] - handMask[y, x, 0] TruePositive += handMask[y, x, 0] FPi[y, x] = (0, 0, 255) TrueNegative += 1 - autoMask[y, x, 0] handMaskAccumLum += handMask[y, x, 0] autoMaskAccumLum += autoMask[y, x, 0] # print(autoMask) # print("handMaskAccumLum", handMaskAccumLum) print("TruePositive", TruePositive) print("FalseNegative", FalseNegative) print("FalsePositive", FalsePositive) eye.rTP = TruePositive eye.rFN = FalseNegative eye.rFP = FalsePositive eye.rTN = TrueNegative eye.rHandAccum = handMaskAccumLum eye.rAutoAccum = autoMaskAccumLum TruePositive = (TruePositive / handMaskAccumLum) * 100 FalseNegative = (FalseNegative / handMaskAccumLum) * 100 FalsePositive1 = (FalsePositive / autoMaskAccumLum) * 100 FalsePositive = (FalsePositive / handMaskAccumLum) * 100 TrueNegative = (TrueNegative / handMaskAccumLum) * 100 eye.TP = TruePositive eye.FN = FalseNegative eye.FP = FalsePositive eye.TN = TrueNegative eye.TPFN = FalseNegative + TruePositive eye.TPi = TPi # eye.TPi = TPi eye.FNi = FNi eye.FPi = FPi eye.TNi = TNi # m3Show.imshow(eye.TPi, "TPI") # m3Show.imshow(eye.FNi, "FNi") # m3Show.imshow(eye.FPi, "FPi") # m3Show.imshow(eye.TNi, "TNi") # eye.TP = TruePositive print("TruePositive%", TruePositive, "% of accumulated pixel values of handmask") print("FalseNegative%", FalseNegative, "% of accumulated pixel values of handmask") print("FalsePositive%", FalsePositive, "% of accumulated pixel values of handmask") print("FalsePositive%", FalsePositive1, "% of accumulated pixel values of automask") print("FalseNegative + TruePositive", FalseNegative + TruePositive) autoMask = autoMask * 255 handMask = handMask * 255 autoMask = orgAutoMask.astype("uint8") handMask = orgHandMask.astype("uint8") # M3Show.imshow(orgHandMask,"handMask") # M3Show.imshow(orgAutoMask,"autoMask") return photoArray
def batchProcess2(inputFolder, functionArray, export): # print("batchProcess ran with folder: " + inputFolder) inputImages = glob.glob(inputFolder + "*.*g") outputFolder = "../PICTURES" # if not (os.path.exists(outputFolder)): # if outfolder does not exist, create it # print("inputImages", inputImages) if (export): now = datetime.now() now_string = now.strftime("-%d-%m-%Y---%H-%M-%S") outputFolder = os.getcwd() + "/EXPORTS/" + inputFolder.replace( "PICTURES/", "").replace("/", "") + now_string # print("path", outputFolder) os.mkdir(outputFolder) # print("../PICTURES/" + datetime.date()) # print("output folder did not exist,", outputFolder, "created.") # ********************************************************************** # IF FACE faceArray = [] didEyes = False for function in functionArray: if (function.__name__ == "findEyes"): didEyes = True eyeFunc = function currentFunction = functionArray[function] for imagePath in inputImages: inputImage = cv2.imread(imagePath, -1) currentFunction["inputImg"] = inputImage face = m3Class.Immer(inputImage, imagePath) face.eyes = function(**currentFunction) faceArray.append(face) functionArray.pop(eyeFunc) # ********************************************************************** if (didEyes): inputImages = faceArray for imagePath in inputImages: m3Show.imshow(imagePath.orginalImage, "original photo") print("************************************************************\ ****************************************************") # -1 means "return the loaded image as is (with alpha channel)." if (didEyes): inputImage = imagePath else: print("processing: " + imagePath) inputImage = cv2.imread(imagePath, -1) for function in functionArray: currentFunction = functionArray[function] # print("current function: ", current) currentFunctionName = function.__name__ print("function name ", function.__name__) # m3F.imshow(inputImage, "BATCH DEBUGGING") # https://realpython.com/python-kwargs-and-args/ if (didEyes): if (imagePath.eyes is not None): for eye in imagePath.eyes: # print("eye coor: " + str(eye.coordinates)) if (currentFunctionName == "findCircleSimple" or currentFunctionName == "makeCircularMask" or currentFunctionName == "makeCircularOutline"): currentFunction["inputImg"] = eye eye = function(**currentFunction) elif not (currentFunctionName == "makeFullMask" or currentFunctionName == "makePolyMask" or currentFunctionName == "applyPolyMask" or currentFunctionName == "makeComparison" or currentFunctionName == "fullImgEyeOutline"): currentFunction["inputImg"] = eye.image eye.image = function(**currentFunction) # elif not (currentFunctionName == "makeFullMask"): # currentFunction["inputImg"] = eye.image # eye.image = function(**currentFunction) if (currentFunctionName == "makeFullMask" or currentFunctionName == "makePolyMask" or currentFunctionName == "applyPolyMask" or currentFunctionName == "fullImgEyeOutline"): print("FULL OR POLY") currentFunction["inputImg"] = imagePath imagePath = function(**currentFunction) if (currentFunctionName == "makeComparison"): currentFunction["faceArray"] = faceArray currentFunction["functionArray"] = functionArray function(**currentFunction) else: currentFunction["inputImg"] = inputImage outputImage = function(**currentFunction) inputImage = outputImage if (export and not didEyes): imagePath2 = imagePath.path.replace(inputFolder, "") outPath = outputFolder + "/" + imagePath2 # print("OUT PATH: ", outPath) cv2.imwrite(outPath, outputImage)
def findEyes68(photo, division, show=True, debug=False): h, w, c = photo.originalImage.shape downScaledDim = ((round(w/division)), round(h/division)) copy = photo.originalImage.copy() pil_image = Image.fromarray(copy) inputImg = copy inputImg = cv2.resize(inputImg, downScaledDim) photo.loResImage = inputImg if debug: print("originalShape", h, w, c) print("downScaledDim", downScaledDim) m3Show.imshow(m3F.typeSwap(pil_image), "image to find eyes on") face_landmarks_list = face_recognition.face_landmarks(inputImg) if debug: print("I found {} face(s) in this photograph.".format(len(face_landmarks_list))) print("face_landmarks_list type was", type(face_landmarks_list)) if (len(face_landmarks_list) == 0): m3F.printRed(" found no faces in this picture") plt.imshow(cv2.cvtColor(inputImg, cv2.COLOR_RGB2BGR)) plt.show() return [m3Class.Face(noFaceImg=inputImg)] faces = [] for face_landmarks in face_landmarks_list: LeftEyeLandmarks = face_landmarks['left_eye'] rightEyeLandmarks = face_landmarks['right_eye'] # imgwithPoints = inputImg.copy() # for eye in (LeftEyeLandmarks, rightEyeLandmarks): # for x, y in eye: # imgwithPoints = cv2.rectangle(imgwithPoints, (x - 20, y - 20), (x + 20, y + 20), (0, 0, 255), -1) # ********************************************************************** # if debug: # m3Show.imshow(imgwithPoints, "with points") eyes = [] for eyeLandmarkPoints in LeftEyeLandmarks, rightEyeLandmarks: xs, ys = [], [] for x, y in eyeLandmarkPoints: xs.append(x) ys.append(y) # print("x y ", x, y) xs.sort(reverse=True) ys.sort(reverse=True) maxX = xs[0] maxY = ys[0] xs.sort(reverse=False) ys.sort(reverse=False) minX = xs[0] minY = ys[0] # print("maxX,maxY,minX,minY", maxX, maxY, minX, minY) # ********************************************************************** margin = round((maxX - minX) * 0.2 ) cropRect = (minX - margin, minY - margin, maxX + margin, maxY + margin) cropRectNoMargin = (minX , minY , maxX, maxY ) # ********************************************************************** # margin = round((maxX - minX) * 0.2) # cropRect = (minX, minY, # maxX, maxY) # ********************************************************************** cropRect = [round(division*num) for num in cropRect] # for num in margin: num * division if show: m3Show.imshow(np.asarray(pil_image.crop(cropRect)), "cropRect") upscaledLandmarks = [] # croprect: "The box is a 4-tuple defining the left, upper, right, and lower pixel coordinate" croppedEye = np.asarray(pil_image.crop(cropRect)) # print("croppedEye.shape", croppedEye.shape) # print("cropRect", cropRect, [round(num/division) for num in cropRect]) for x, y in eyeLandmarkPoints: upscaledLandmarks.append([((x - (minX-margin)) * division), ((y-(minY-margin)) * division)]) # upscaledLandmarks.append([x * division, y *division]) # print("minX, x, minY, y, division", (minX, x, minY, y, division, margin)) # # x = x * division # y = y * division # left = cropRect[0] + margin # top = cropRect[1] + margin # upscaledLandmarks.append((x-left)-(y-top)) # y = y * division # print("upscaledLandmarks", upscaledLandmarks) e = m3Class.Eye(croppedEye, cropRect, upscaledLandmarks) print(upscaledLandmarks) e.mask68 = makePolyMask(croppedEye, upscaledLandmarks) # cv2.imwrite("EXPORTS/COMPARISONS/mask68.jpg", e.mask68) e.margin = margin e.CRnoMargin = cropRectNoMargin e.minX = minX e.minY = minY eyes.append(e) faces.append(m3Class.Face(eyes)) return faces
def sobel(inputImg, show=True): out = cv2.Sobel(inputImg, inputImg.depth(), 0, 1, 3) if show: m3Show.imshow(out, "show")