parser.add_argument('--dir', type=str, default=fileDir, help='video directory')
parser.add_argument('--num', type=int, default=1000, help='num of images')
parser.add_argument('--dim', type=int, default=96, help='alignment dimension')
args = parser.parse_args()
print(args)
videoCapture = cv2.VideoCapture(os.path.join(args.dir, '001.mp4'))
if not videoCapture.isOpened(): sys.exit('video not opened')
template = np.load(os.path.join(fileDir, 'template.npy'))
delaunay = scipy.spatial.Delaunay(template)
facePredictor = os.path.join(fileDir, 'shape_predictor_68_face_landmarks.dat')
alignDlib = openface.AlignDlib(facePredictor)
alignment = alignment.Alignment(args.dim, template, delaunay.simplices)
print('processing images...')
for index in range(args.num):
ret, rawImage = videoCapture.read()
if not ret: break
boundingBox = alignDlib.getLargestFaceBoundingBox(rawImage)
landmarks = alignDlib.findLandmarks(rawImage, boundingBox)
alignedImage = alignment.align(rawImage, landmarks)
dlibModelDir, "shape_predictor_68_face_landmarks.dat"))
parser.add_argument('--networkModel',
type=str,
help="Path to Torch network model.",
default=os.path.join(openfaceModelDir, 'nn4.small2.v1.t7'))
parser.add_argument('--imgDim',
type=int,
help="Default image dimension.",
default=96)
parser.add_argument('--verbose', action='store_true')
parser.add_argument('--cuda', action='store_true')
args = parser.parse_args()
align = openface.AlignDlib(args.dlibFacePredictor)
net = openface.TorchNeuralNet(args.networkModel,
imgDim=args.imgDim,
cuda=args.cuda)
redis_ready = False
def debug_print(str):
if debug is True:
print(str)
def info_print(str):
if info is True:
print(str)
def alignMain(args):
openface.helper.mkdirP(args.outDir)
check = os.listdir(os.path.normpath(args.outDir)).__contains__(args.name)
print(check)
sock.sendall((str(check) + "\n").encode())
if not check:
os.mkdir(os.path.join(args.outDir, args.name))
else:
shutil.rmtree(os.path.join(args.outDir, args.name))
os.mkdir(os.path.join(args.outDir, args.name))
print('directory created')
sock.sendall('directory created\n'.encode())
imgs = list(iterImgs(args.inputDir))
sock.sendall("length\n".encode())
sock.sendall((str(len(imgs) * 3) + "\n").encode())
# Shuffle so multiple versions can be run at once.
random.shuffle(imgs)
landmarkMap = {
'outerEyesAndNose': openface.AlignDlib.OUTER_EYES_AND_NOSE,
'innerEyesAndBottomLip': openface.AlignDlib.INNER_EYES_AND_BOTTOM_LIP
}
if args.landmarks not in landmarkMap:
raise Exception("Landmarks unrecognized: {}".format(args.landmarks))
landmarkIndices = landmarkMap[args.landmarks]
align = openface.AlignDlib(args.dlibFacePredictor)
nFallbacks = 0
cnt = 0
for imgObject in imgs:
print("=== {} ===".format(imgObject.path))
s = os.path.normpath(args.inputDir) + '/' + imgObject.name
img = cv2.imread(s)
if img is None:
sock.sendall(" + Unable to load.\n".encode())
sock.send("processed\n".encode())
width = img.shape[1]
height = img.shape[0]
check = False
if width > 600:
width = 600
check = True
if height > 600:
height = 600
check = True
if check:
img = cv2.resize(img, (width, height),
interpolation=cv2.INTER_LINEAR)
cv2.imwrite(
os.path.normpath(args.inputDir) + '/1' + imgObject.name, img)
im = Image.open(
os.path.normpath(args.inputDir) + '/1' + imgObject.name)
os.remove(os.path.normpath(args.inputDir) + '/1' + imgObject.name)
contrast = ImageEnhance.Contrast(im)
bright = ImageEnhance.Brightness(im)
sock.sendall(("=== {} ===\n".format(imgObject.path)).encode())
outDir = os.path.join(args.outDir, args.name)
#outDir = os.path.join(args.outDir, imgObject.cls)
openface.helper.mkdirP(outDir)
outputPrefix = os.path.join(outDir,
os.path.splitext(imgObject.name)[0])
j = 0
i = 0.7
t = False
for k in range(1, 3, 1):
for l in range(1, 4):
if k != 1 and l == 1:
continue
elif t:
im = Image.open(s)
contrast = ImageEnhance.Contrast(im)
bright = ImageEnhance.Brightness(im)
if k == 1:
imgName = outputPrefix + ".png"
elif l == 2:
imgObject = contrast.enhance(i)
imgObject = np.array(imgObject)
imgName = outputPrefix + "_" + str(j) + ".png"
elif l == 3:
imgObject = bright.enhance(i)
imgObject = np.array(imgObject)
imgName = outputPrefix + "_" + str(j + 1) + ".png"
if k == 1:
rgb = imgObject.getRGB()
print(type(rgb))
else:
rgb = imgObject
cnt = cnt + 1
sock.sendall(("cnt " + str(cnt) + "\n").encode())
if rgb is None:
if args.verbose:
print(" + Unable to load.")
sock.sendall(" + Unable to load.\n".encode())
sock.send("processed\n".encode())
outRgb = None
else:
outRgb = align.align(args.size,
rgb,
landmarkIndices=landmarkIndices,
skipMulti=args.skipMulti)
if outRgb is None and args.verbose:
print(" + Unable to align." + " " + str(k) + " " +
str(l))
sock.sendall(" + Unable to align.\n".encode())
sock.send("processed\n".encode())
if args.fallbackLfw and outRgb is None:
nFallbacks += 1
deepFunneled = "{}/{}.jpg".format(
os.path.join(args.fallbackLfw, imgObject.cls),
imgObject.name)
shutil.copy(
deepFunneled, "{}/{}.jpg".format(
os.path.join(args.outDir, imgObject.cls),
imgObject.name))
if outRgb is not None:
if args.verbose:
print(" + Writing aligned file to disk.")
sock.sendall(
" + Writing aligned file to disk.\n".encode())
outBgr = cv2.cvtColor(outRgb, cv2.COLOR_RGB2BGR)
cv2.imwrite(imgName, outBgr)
sock.sendall("processed\n".encode())
if k == 1:
x = outputPrefix + ".png"
s = x
t = True
sock.sendall("write to index\n".encode())
sock.sendall((x + '\n').encode())
break
if k != 1:
i += 0.3
j += 2
if args.fallbackLfw:
print('nFallbacks:', nFallbacks)
def alignMain(args):
openface.helper.mkdirP(args.outputDir)
print("alignMail call")
imgs = list(iterImgs(args.inputDir))
print('imgs : ')
print(imgs)
print("------------------------------")
# Shuffle so multiple versions can be run at once.
random.shuffle(imgs)
landmarkMap = {
'outerEyesAndNose': openface.AlignDlib.OUTER_EYES_AND_NOSE,
'innerEyesAndBottomLip': openface.AlignDlib.INNER_EYES_AND_BOTTOM_LIP
}
if args.landmarks not in landmarkMap:
raise Exception("Landmarks unrecognized: {}".format(args.landmarks))
landmarkIndices = landmarkMap[args.landmarks]
align = openface.AlignDlib(args.dlibFacePredictor)
nFallbacks = 0
for imgObject in imgs:
print("=== {} ===".format(imgObject.path))
outDir = os.path.join(args.outputDir, imgObject.cls)
openface.helper.mkdirP(outDir)
outputPrefix = os.path.join(outDir, imgObject.name)
imgName = outputPrefix + ".png"
if os.path.isfile(imgName):
if args.verbose:
print(" + Already found, skipping.")
else:
rgb = imgObject.getRGB()
if rgb is None:
if args.verbose:
print(" + Unable to load.")
outRgb = None
else:
outRgb = align.align(args.size, rgb,
landmarkIndices=landmarkIndices,
skipMulti=args.skipMulti)
if outRgb is None and args.verbose:
print(" + Unable to align.")
if args.fallbackLfw and outRgb is None:
nFallbacks += 1
deepFunneled = "{}/{}.jpg".format(os.path.join(args.fallbackLfw,
imgObject.cls),
imgObject.name)
shutil.copy(deepFunneled, "{}/{}.jpg".format(os.path.join(args.outputDir,
imgObject.cls),
imgObject.name))
if outRgb is not None:
if args.verbose:
print(" + Writing aligned file to disk.")
outBgr = cv2.cvtColor(outRgb, cv2.COLOR_RGB2BGR)
cv2.imwrite(imgName, outBgr)
if args.fallbackLfw:
print('nFallbacks:', nFallbacks)
_thread.start_new_thread(networkServer.rpcServer, ())
print("yo")
except Exception as e:
print("error in rpc thread")
logger.error(e, exc_info=True)
predictor_model = "models/shape_predictor_68_face_landmarks.dat"
face_recognition_model = 'models/dlib_face_recognition_resnet_model_v1.dat'
fName = "classifier.pkl"
#webcam number
cap = cv2.VideoCapture(0)
face_detector = dlib.get_frontal_face_detector()
face_encoder = dlib.face_recognition_model_v1(face_recognition_model)
face_pose_predictor = dlib.shape_predictor(predictor_model)
face_aligner = openface.AlignDlib(predictor_model)
# face_name = "Adnan Sayed"
saveCountReset = False
outOfRecording = 40
count = 0
saveImgLoc = "../untitled/Image"
def saveCapturedImg(image):
im = Image.fromarray(image)
with open("data/configs.json") as df:
data = json.load(df)
dlibFacePredictor = os.path.join(dlibModelDir, "shape_predictor_68_face_landmarks.dat")
torchNetworkModel = os.path.join(openfaceModelDir, 'nn4.small2.v1.t7')
labelsPath = os.path.join(generatedDir, 'labels.csv')
repsPath = os.path.join(generatedDir, 'reps.csv')
imgDim = 96
imgSize = 96
landmarks = 'outerEyesAndNose'
ldaDim = 1
align_pred = openface.AlignDlib(dlibFacePredictor)
net = openface.TorchNeuralNet(torchNetworkModel, imgDim=imgDim,
cuda=True)
def getRep(imgPath, args, multiple=False):
start = time.time()
bgrImg = cv2.imread(imgPath)
if bgrImg is None:
raise Exception("Unable to load image: {}\n".format(imgPath))
rgbImg = cv2.cvtColor(bgrImg, cv2.COLOR_BGR2RGB)
if args.verbose:
print(" + Original size: {}".format(rgbImg.shape))
print("Loading the image took {} seconds.".format(time.time() - start))
import openface
import cv2
import os
# some initial variable setup (!)
# TODO figure out what this is doing
modelDir = '/root/openface/models/'
dlibModelDir = os.path.join(modelDir, 'dlib')
align = openface.AlignDlib(
os.path.join(dlibModelDir, "shape_predictor_68_face_landmarks.dat"))
imgDim = 96
openfaceModelDir = os.path.join(modelDir, 'openface')
net = openface.TorchNeuralNet(
os.path.join(openfaceModelDir, 'nn4.small2.v1.t7'), imgDim)
def getRep(imgPath):
# load some image
bgrImg = cv2.imread(imgPath)
# couldn't load image
if bgrImg is None:
return None
# load some other image (rgb?)
rgbImg = cv2.cvtColor(bgrImg, cv2.COLOR_BGR2RGB)
# build the bounding box
bb = align.getLargestFaceBoundingBox(rgbImg)
def __init__(self):
self.training = True
self.trainingEvent = threading.Event()
self.trainingEvent.set()
self.alarmState = 'Disarmed' #disarmed, armed, triggered
self.alarmTriggerd = False
self.alerts = []
self.cameras = []
self.peopleDB = []
self.camera_threads = []
self.camera_facedetection_threads = []
self.people_processing_threads = []
self.svm = None
self.video_frame1 = None
self.video_frame2 = None
self.video_frame3 = None
self.fileDir = os.path.dirname(os.path.realpath(__file__))
self.luaDir = os.path.join(self.fileDir, '..', 'batch-represent')
self.modelDir = os.path.join(self.fileDir, '..', 'models')
self.dlibModelDir = os.path.join(self.modelDir, 'dlib')
self.openfaceModelDir = os.path.join(self.modelDir, 'openface')
parser = argparse.ArgumentParser()
parser.add_argument('--dlibFacePredictor',
type=str,
help="Path to dlib's face predictor.",
default=os.path.join(
self.dlibModelDir,
"shape_predictor_68_face_landmarks.dat"))
parser.add_argument('--networkModel',
type=str,
help="Path to Torch network model.",
default=os.path.join(self.openfaceModelDir,
'nn4.small2.v1.t7'))
parser.add_argument('--imgDim',
type=int,
help="Default image dimension.",
default=96)
parser.add_argument('--cuda', action='store_true')
parser.add_argument('--unknown',
type=bool,
default=False,
help='Try to predict unknown people')
self.args = parser.parse_args()
self.align = openface.AlignDlib(self.args.dlibFacePredictor)
self.net = openface.TorchNeuralNet(self.args.networkModel,
imgDim=self.args.imgDim,
cuda=self.args.cuda)
#////////////////////////////////////////////////////Initialization////////////////////////////////////////////////////
#self.change_alarmState()
#self.trigger_alarm()
#self.trainClassifier() # add faces to DB and train classifier
#default IP cam
#self.cameras.append(Camera.VideoCamera("rtsp://*****:*****@192.168.1.64/Streaming/Channels/2"))
#self.cameras.append(Camera.VideoCamera("rtsp://*****:*****@192.168.1.64/Streaming/Channels/2"))
#self.cameras.append(Camera.VideoCamera("rtsp://*****:*****@192.168.1.64/Streaming/Channels/2"))
#self.cameras.append(Camera.VideoCamera("http://192.168.1.48/video.mjpg"))
#self.cameras.append(Camera.VideoCamera("http://192.168.1.48/video.mjpg"))
#self.cameras.append(Camera.VideoCamera("http://192.168.1.48/video.mjpg"))
#self.cameras.append(Camera.VideoCamera("http://192.168.1.37/video.mjpg"))
#self.cameras.append(Camera.VideoCamera("http://192.168.1.37/video.mjpg"))
#self.cameras.append(Camera.VideoCamera("debugging/iphone_distance1080pHD.m4v"))
self.cameras.append(Camera.VideoCamera("debugging/Test.mov"))
#self.cameras.append(Camera.VideoCamera("debugging/Test.mov"))
#self.cameras.append(Camera.VideoCamera("debugging/rotationD.m4v"))
#self.cameras.append(Camera.VideoCamera("debugging/example_01.mp4"))
#self.change_alarmState()
#self.trigger_alarm()
self.getFaceDatabaseNames()
#self.trainClassifier() # add faces to DB and train classifier
#processing frame threads- for detecting motion and face detection
for i, cam in enumerate(self.cameras):
self.proccesing_lock = threading.Lock()
thread = threading.Thread(name='frame_process_thread_' + str(i),
target=self.process_frame,
args=(cam, ))
thread.daemon = False
self.camera_threads.append(thread)
thread.start()
#Threads for alignment and recognition
# for i, cam in enumerate(self.cameras):
# #self.proccesing_lock = threading.Lock()
# thread = threading.Thread(name='face_process_thread_' + str(i),target=self.people_processing,args=(cam,))
# thread.daemon = False
# self.people_processing_threads.append(thread)
# thread.start()
#Thread for alert processing
self.alerts_lock = threading.Lock()
thread = threading.Thread(name='alerts_process_thread_',
target=self.alert_engine,
args=())
thread.daemon = False
thread.start()
from tornado import gen
import sys
import os
import logging
OPENFACE_ROOT = os.path.abspath(os.path.join(__file__, '../../openface'))
sys.path.append(OPENFACE_ROOT)
import openface
FORMAT = '[%(levelname)1.1s %(asctime)s %(name)s:%(lineno)d] %(message)s'
logger = logging.getLogger("lib.openface")
IMAGE_SIZE = 96
ALIGN = openface.AlignDlib(
OPENFACE_ROOT + "/models/dlib/shape_predictor_68_face_landmarks.dat")
NET = None
@gen.coroutine
def hash_face(image, bb=None, alignedFace=None):
global NET
if NET is None:
logging.debug("Loading openface network")
NET = openface.TorchNeuralNet(OPENFACE_ROOT +
"/models/openface/nn4.small2.v1.t7",
imgDim=IMAGE_SIZE,
cuda=False)
# this function can take a while to run, so we defer to the ioloop in face
# there are other things that need to be taken care of. Since this
def loadOpenfaceAlignerModel(models_dir,
model='shape_predictor_68_face_landmarks.dat',
debug=False):
openface_aligner = openface.AlignDlib(
os.path.join(models_dir, 'openface', model))
return openface_aligner
def __init__(self):
self.face_aligner = openface.AlignDlib(self.predictor_model)
class Arg:
def __init__(self, dlibFacePredictor = os.path.join(
dlibModelDir,
"shape_predictor_68_face_landmarks.dat"),
networkModel=os.path.join(
openfaceModelDir,
'nn4.small2.v1.t7'), imgDim = 96, captureDevice = 0, width = 320, height = 240, threshold= 0.5, classifierModel = SVC(kernel = 'rbf', C= 5), cuda = False):
self.dlibFacePredictor = dlibFacePredictor
self.networkModel = networkModel
self.imgDim = imgDim
self.captureDevice = captureDevice
self.width = width
self.height = height
self.classifierModel = classifierModel
self.cuda = cuda
'''
getRep returns the feature of each faces
'''
def getRep(bgrImg, net):
start = time.time()
if bgrImg is None:
raise Exception("Unable to load image/frame")
rgbImg = cv2.cvtColor(bgrImg, cv2.COLOR_BGR2RGB)
start = time.time()
# Get the largest face bounding box
# bb = align.getLargestFaceBoundingBox(rgbImg) #Bounding box
# Get all bounding boxes
bb = align.getAllFaceBoundingBoxes(rgbImg)
if bb is None:
# raise Exception("Unable to find a face: {}".format(imgPath))
return None
start = time.time()
alignedFaces = []
for box in bb:
alignedFaces.append(
align.align(
args.imgDim,
rgbImg,
box,
landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE))
if alignedFaces is None:
raise Exception("Unable to align the frame")
start = time.time()
reps = []
for alignedFace in alignedFaces:
reps.append(net.forward(alignedFace))
# print reps
return reps
'''
infer() returns the predicted people in the frame as well as
the corresponding information (e.g. summary of shared posts and similarty between he/she and you) stored in server.
'''
def infer(img, args):
#assume all attendee profile pictures have been downloaded into ./attendee/, with attendee id being file name
image_list = []
id_list = []
for filename in glob.glob('attendee/*.png'): #assuming gif
im=Image.open(filename)
id_list.append(filename)
image_list.append(im)
net = openface.TorchNeuralNet(args.networkModel, args.imgDim)
reps = getRep(img, net) #return the detected and aligned faces in the video frame
persons = []
infos = []
similarities = []
for rep in reps:
try:
rep = rep.reshape(1, -1)
except:
print "No Face detected"
return (None, None, None)
start = time.time()
for attendee_img in image_list:
d = rep-getRep(attendee_img, net)
distances.append(np.dot(d,d))
# print predictions
minI = np.argmin(distances) #Returns the indices of the maximum values along an axis.
attendee_id = id_list[minI]
url = serverAttendeeRoot + "/" + attendee_id
r = requests.get(url)
person = r.json()['name']
info = r.json()['info']
similarity = r.json()['similarity']
persons.append(person)
infos.append(info)
similarities.append(similarity)
return (persons, infos,similarities)
if __name__ == '__main__':
args = Arg()
align = openface.AlignDlib(args.dlibFacePredictor)
net = openface.TorchNeuralNet(
args.networkModel,
imgDim=args.imgDim, cuda = args.cuda)
# Capture device. Usually 0 will be webcam and 1 will be usb cam.
video_capture = cv2.VideoCapture(args.captureDevice)
video_capture.set(3, args.width)
video_capture.set(4, args.height)
while True:
ret, frame = video_capture.read()
persons, infos, similarities = infer(frame, args)
if persons == None: continue
for i, value in enumerate(similarities):
#if the similarities between you and this attendee is greater than 0.7, mark green
if similarities[i] > 0.7:
cv2.putText(frame, "Name: {} Info: {}".format(person, info),
(50, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
#otherwise, mark white
else:
cv2.putText(frame, "Name: {} Info: {}".format(person, info),
(50, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
cv2.imshow('', frame)
# quit the program on the press of key 'q'
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything is done, release the capture
video_capture.release()
cv2.destroyAllWindows()
def affine_transformation(human_files=None,
pred=None,
detec=None,
preview=False,
image_num=None,
blur=False,
frame=False,
image_clear=None,
rect=None):
'''
For each Image in the dataset
+ Extract the key points
+ Do affine transformation
+ Store it
'''
#Affine transformation
falsy_dir = '../dataset/falsy/'
face_aligner = openface.AlignDlib(auxilary.path_to_shape_predictor)
affine_dir = '../dataset/lfw_affine/'
if frame:
alignedFace = face_aligner.align(96, image_clear, rect, \
landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE)
return alignedFace
if preview:
# for i ,human_file in enumerate(human_files):
# folders = (get_folder_from_path(human_file))
# folders = folders.split('\\')
# if folders[0] == 'LeBron_James':
# print (i, human_file)
# input("e")
image_count = len(human_files) - 1
rand_int = np.random.random_integers(0, image_count)
print(f'picked random image number: {rand_int}')
# rand_int = image_num
human_file = human_files[rand_int]
while not os.path.exists(human_file):
rand_int = np.random.random_integers(0, image_count)
human_file = human_files[rand_int]
state, shape, rect, image = facial_landmarks.get_shape(
human_file, pred, detec)
while not state:
state, shape, rect, image = facial_landmarks.get_shape(
human_file, pred, detec)
image = facial_landmarks.draw_landmarks(image, shape, rect, blur=blur)
alignedFace = face_aligner.align(96, image, rect, \
landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE)
cv2.imshow("Aligned Face", alignedFace)
cv2.waitKey(0)
cv2.destroyAllWindows()
return alignedFace, get_name_from_path(human_file), human_file
for i, human_file in enumerate(human_files):
state, shape, rect, image = facial_landmarks.get_shape(
human_file, pred, detec)
if state:
file_path = affine_dir + get_folder_from_path(human_file)
create_folder(affine_dir + get_name_from_path(human_file))
alignedFace = face_aligner.align(96, image, rect, \
landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE)
cv2.imwrite(file_path, alignedFace)
# plt.imshow(face_aligned)
else:
print('Sorry, that image does not have faces!')
file_name = human_file.split('/')
file_name = file_name[len(file_name) - 1]
file_name = file_name.split('\\')
falsy_img_pth = falsy_dir + file_name[len(file_name) - 1]
os.replace(human_file, falsy_img_pth)
if i % 100 == 0:
print(f'Working: .... iteration {i}')
fileDir = os.path.dirname(os.path.realpath(__file__))
SERVER_IMG_DIM = 80
SERVER_CUDA = False
SERVER_MODE = "Stateful"
SERVER_DLIB_FACEPREDICTOR = os.path.join(
fileDir, "FacePredictor",
"shape_predictor_68_face_landmarks.dat") # Path to dlib's face predictor
SERVER_OPENFACE_MODEL = os.path.join(
fileDir, "Openface", "nn4.small2.v1.t7") # Opencface torch net model
SERVER_PRETRAINED = os.path.join(fileDir, "Pretrained", "classifier.pkl")
SERVER_MULT_FACE_INFER = True
align = openface.AlignDlib(SERVER_DLIB_FACEPREDICTOR)
# Output folder for performance measure
SERVER_PROFILE_ENABLE = True
SERVER_PROFILE_DIR = os.path.join(fileDir, 'Profile')
# Parallel computing optimization
SERVER_FACE_SEARCH_OPTIMIZE = True
SERVER_FACE_SEARCH_PADDING = 0.5
SERVER_USE_PYTORCH = False
if SERVER_USE_PYTORCH:
from OpenFacePytorch.loadOpenFace import prepareOpenFace
net = prepareOpenFace(useCuda=False).eval()
else:
net = openface.TorchNeuralNet(SERVER_OPENFACE_MODEL,
import argparse
import os
from scipy import misc
import numpy as np
import time
import pickle
import openface
from scipy.misc import imsave
# path managing
fileDir = os.path.dirname(os.path.realpath(__file__))
modelDir = os.path.join(fileDir, '..', 'models') # path to the model directory
dlibModelDir = os.path.join(modelDir, 'dlib') # dlib face detector model
openfaceModelDir = os.path.join(modelDir, 'openface')
dlib_aligner = openface.AlignDlib(dlibModelDir +
"/shape_predictor_68_face_landmarks.dat")
def align_face(image, output_size=96, skip_multi=False):
outRgb = dlib_aligner.align(
output_size,
image,
landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE,
skipMulti=skip_multi)
# out Rgb might be none
return outRgb
def align_images_in_folder(in_folder,
cleanup=False,
save=False,
def face_augmentation_server():
print 'starting up!'
align = openface.AlignDlib(SHAPE_PREDICTOR_PATH)
net = openface.TorchNeuralNet(FACE_NN_PATH)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((HOST, PORT))
sock.listen(1)
print "server started"
# signal to the lambda that the server is ready
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
count = 0
not_connected = True
while (not_connected):
try:
s.connect(('localhost', 10001))
not_connected = False
except:
print 'waiting for host to come up', count
if (count >= 30):
print 'waited too long'
sys.exit(-1)
time.sleep(1)
count += 1
s.close()
end = False
while (not end):
conn, addr = sock.accept()
print 'connection made'
print 'getting data'
img_base64 = ''
while True:
data = conn.recv(MAX_BUFFER_SIZE)
if (data[-1] == ':'):
img_base64 += data[:-1]
break
img_base64 += data
print 'checking end condition'
poison_symbol = img_base64[0]
img_base64 = img_base64[1:]
if (poison_symbol == 'S'):
end == True
conn.close()
sock.close()
break
# process image
print 'decode image'
bio = io.BytesIO(base64.b64decode(img_base64))
compressed_img = np.fromstring(bio.read(), dtype=np.uint8)
bgrImg = cv2.imdecode(compressed_img, cv2.IMREAD_COLOR)
rgbImg = cv2.cvtColor(bgrImg, cv2.COLOR_BGR2RGB)
print 'augmenting image'
augmented_images = augment_image(rgbImg)
print 'getting face vectors'
face_feature_vectors = []
for rgbImg in augmented_images:
try:
print 'adding vector'
face_feature_vector = get_face_vector(rgbImg, align, net)
face_feature_vectors.append(face_feature_vector)
except Exception as e:
sys.stderr.write(str(e) + '\n')
# send back resulting face feature vectors
print 'sending back face vectors'
output_csv = ''
for vector in face_feature_vectors:
output_csv += ','.join(map(str, vector)) + '\n'
conn.sendall(output_csv + ':')
# close connection
print 'closing connection'
conn.close()
print 'done'
from utilityScripts import get_frame_from_video
import faceSpoofValidation
mlbp = features.MultiScaleLocalBinaryPatterns((8, 1), (8, 2), (16, 2))
faceSpoofValidator = faceSpoofValidation.FaceSpoofValidator(
mlbp, "classifiers/casia.pkllinear")
faceFrames = get_frame_from_video.get_frames(
"/home/doru/Desktop/Licenta/Implementation/databases/"
"cbsr_antispoofing/test_release/1/3.avi",
1000,
)
align = openface.AlignDlib(
"/home/doru/Desktop/Licenta/Implementation/models/dlib/shape_predictor_68_face_landmarks"
".dat")
for frame in faceFrames:
start = time.time()
# Get all bounding boxes
bbs = align.getAllFaceBoundingBoxes(frame)
if bbs is None or len(bbs) == 0:
raise Exception("No faces detected")
alignedFaces = []
for box in bbs:
alignedFaces.append(
align.align(
import cv2
import openface
bgrImg = cv2.imread('test.jpg')
rgbImg = cv2.cvtColor(bgrImg, cv2.COLOR_BGR2RGB)
align = openface.AlignDlib('shape_predictor_68_face_landmarks.dat')
net = openface.TorchNeuralNet()
bb = align.getLargestFaceBoundingBox(rgbImg)
alignedFace = align.align(
96, rgbImg, bb, landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE)
rep = net.forward(alignedFace)
print rep
total_dist = 0
for pt, pred in zip(pt_labels, landmarks):
dist = np.linalg.norm(pt - pred)
total_dist = total_dist + dist
avg_dist = np.divide(total_dist, 68)
return np.divide(avg_dist, norm)
if __name__ == "__main__":
i_images = indoorDF['imgPath']
i_points = indoorDF['points']
o_images = outdoorDF['imgPath']
o_points = outdoorDF['points']
g_images = globalDF['imgPath']
g_points = globalDF['points']
face_model = openface.AlignDlib(dlib_model)
total_indoor = 0
total_outdoor = 0
tot_indoor_det = 0
tot_outdoor_det = 0
resultsDF = pd.DataFrame(columns=('experiment','type','loss',\
'total_detected','avg_loss'))
iter_count = 0
for img, pts in zip(i_images, i_points):
rgbImg = cv2.imread(img)
landmarks = get_landmarks(face_model, rgbImg)
if landmarks is not None:
cleaned = clean_points(pts)
tot_indoor_det = tot_indoor_det + 1
for (x, y) in landmarks:
cv2.circle(rgbImg, (x, y), 1, (0, 0, 255), -1)
buff = 1024
import keras
keras.backend.set_learning_phase(0) #set test phase
model = keras.models.load_model('gaze_1017_middle50.h5')
import tensorflow as tf
graph = tf.get_default_graph()
import openface
modelDir = os.path.join('/Users/dialog/openface/models')
dlibModelDir = os.path.join(modelDir, 'dlib')
#openfaceModelDir = os.path.join(modelDir, 'openface')
align_path = os.path.join(dlibModelDir,
"shape_predictor_68_face_landmarks.dat")
align = openface.AlignDlib(align_path)
def predict(model, x_data):
"""
視線の推定を行う関数
"""
y = model.predict(x_data)[0]
#print(y)
return y
def getRep(bgrImg):
"""
読み込んだ画像から目の部分を抽出する関数
"""
def forward(self, aligned):
return np.array(self.net.compute_face_descriptor(self.lastimg, aligned))
def align(self, a, img, box, landmarkIndices):
self.lastimg = img
return self.sp(img, box)
DLIB_NN = DlibNetAdapter()
fileDir = os.path.dirname(os.path.realpath(__file__))
modelDir = os.path.join(fileDir, '..', 'models')
dlibModelDir = os.path.join(modelDir, 'dlib')
openfaceModelDir = os.path.join(modelDir, 'openface')
DEF_ALIGN = openface.AlignDlib(DLIB_MODEL)
DEF_DETECTOR = DEF_ALIGN
#DEF_DETECTOR = opencv_detector
DEF_NET = openface.TorchNeuralNet(NN_MODEL, imgDim=IMG_DIM, cuda=CUDA)
if TRACKING_ENABLED:
TRACKER = tracking.Tracking(dlib.correlation_tracker)
else:
TRACKER = None
# scale rectangle to factor
def scaleRect(rect, factor):
r_l = int(rect.left()*factor)
r_t = int(rect.top()*factor)
r_r = int(rect.right()*factor)
r_b = int(rect.bottom()*factor)
# This code takes pictures from a folder, recognizes the faces in them and colours the boundingBoxes black.
# Made for testing.
import openface
import cv2
import os
import sys
from scipy import misc
from PIL import Image
args = sys.argv
#args[1]: The path to the file 'shape_predictor_68_face_landmarks.dat' found in the openface/models/dlib folder.
align = openface.AlignDlib(args[1])
#args[2]: The path to a folder with pictures (of people)
path = args[2]
for file in os.listdir("output"):
os.remove("output/" + file)
for file in os.listdir(path):
a = raw_input("Press enter to continue, 0 and enter to quit: ")
if a == "0":
break
image = misc.imread(path + "/" + file)
print("File: " + file)
boundingBoxes = align.getAllFaceBoundingBoxes(image)
amount = len(boundingBoxes)
if amount == 0:
print("Didn't find any faces.")
app = Flask(__name__, static_url_path = "")
# global variables
brokerURL = ''
outputs = []
timer = None
lock = threading.Lock()
camera = None
cameraURL = ''
total_size = 0
threshold = 1.0
imageDemension = 96
align = openface.AlignDlib('/root/openface/models/dlib/shape_predictor_68_face_landmarks.dat')
net = openface.TorchNeuralNet('/root/openface/models/openface/nn4.small2.v1.t7', imageDemension)
saveLocation = ''
featuresOfTarget = None
targetedFeaturesIsSet = False
@app.errorhandler(400)
def not_found(error):
return make_response(jsonify( { 'error': 'Bad request' } ), 400)
@app.errorhandler(404)
def not_found(error):
return make_response(jsonify( { 'error': 'Not found' } ), 404)
@app.route('/admin', methods=['POST'])
# coding:utf-8
import os
import openface
import cv2
import pickle
import numpy as np
fileDir = os.path.dirname(os.path.realpath(__file__))
modelDir = os.path.join(fileDir, '..', 'models')
classifierDir = os.path.join(fileDir, '..', 'generated-embeddings')
dlibModelDir = os.path.join(modelDir, 'dlib')
openfaceModelDir = os.path.join(modelDir, 'openface')
predict = os.path.join(dlibModelDir, 'shape_predictor_68_face_landmarks.dat')
torchmodel = os.path.join(openfaceModelDir, 'nn4.small2.v1.t7')
align = openface.AlignDlib(predict)
net = openface.TorchNeuralNet(torchmodel)
landmarkIndices = openface.AlignDlib.OUTER_EYES_AND_NOSE
predictdatabase = os.path.join(classifierDir, 'classifier.pkl') # 人脸数据库
# 获取人脸的处理
def getRep(img):
bgrImg = cv2.imread(img)
rgbImg = cv2.cvtColor(bgrImg, cv2.COLOR_BGR2RGB)
bbs = align.getAllFaceBoundingBoxes(rgbImg)
reps = []
for bb in bbs:
facelandmarks = align.findLandmarks(rgbImg, bb)
alignedFace = align.align(96,
rgbImg,
bb,
from pathlib import Path
from sklearn.neighbors import KNeighborsClassifier
from sklearn import linear_model
dir_path = os.path.dirname(os.path.realpath(__file__))
model_dir = os.path.join(dir_path, 'models')
faces_dir = os.path.join(dir_path, 'faces')
dlib_face_predictor = os.path.join(model_dir,
'shape_predictor_68_face_landmarks.dat')
network_model = os.path.join(model_dir, 'nn4.small2.v1.t7')
img_dim = 96
align = openface.AlignDlib(dlib_face_predictor)
net = openface.TorchNeuralNet(network_model, img_dim)
def face_rep(rgb_img):
bb = align.getLargestFaceBoundingBox(rgb_img)
alignedFace = align.align(
img_dim,
rgb_img,
bb,
landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE)
return net.forward(alignedFace)
def read_path(img_path):
import openface
import cv2
import dlib
from glob import glob
from utils.imutils import *
from scipy.spatial.distance import euclidean
import pandas as pd
PREDICTOR_PATH = "shape_predictor_68_face_landmarks.dat"
INNER_EYES_MOUTH_AND_NOSE = openface.AlignDlib.INNER_EYES_AND_BOTTOM_LIP
FACE_SIZE = 128
IN_PATH = "./MultiEmoVA-images/images/all/*.jpg"
FEATURES_OUT_PATH = "./features/"
# Create facial landmark detector using dlib model
align = openface.AlignDlib(PREDICTOR_PATH)
num_faces_in_image = {}
context2 = []
context3 = []
context4 = []
# Loop over images in the dataset to extract features
for image_path in glob(IN_PATH):
# Extract image name
image_id = image_path.split("/")[-1][:-4]
# Read in image and detect faces
image = cv2.imread(image_path)
faces = align.getAllFaceBoundingBoxes(image)
# This Script gets Executed inside the 'bamos/openface' Docker Container #
import openface # The Openface package is imported inside the Docker Container
import numpy as np
import os
import socket
MODEL_DIR = os.path.join(os.path.dirname(__file__), 'models')
DLIB_DIR = os.path.join(MODEL_DIR, 'dlib')
OPENFACE_DIR = os.path.join(MODEL_DIR, 'openface')
DIM = 96
ADDRESS = ('', 8989)
align = openface.AlignDlib(
os.path.join(DLIB_DIR, "shape_predictor_68_face_landmarks.dat"))
net = openface.TorchNeuralNet(os.path.join(OPENFACE_DIR, "nn4.small2.v1.t7"),
DIM)
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(ADDRESS)
try:
while True:
server.listen(5)
connection, address = server.accept()
shape = np.frombuffer(connection.recv(3 * 4), np.int32)
length = np.prod(shape)
image = np.empty(shape, np.uint8)
sys.path.append(os.path.abspath(os.path.join(cur_path, '../util/')))
from img_hash import EXTS, phash, otsu_hash, otsu_hash2, hamming
from img_histo import gray_histo, rgb_histo, yuv_histo, hsv_histo, abs_dist
from img_gist import gist
from kmeans import eculidean_dist, norm0_dist
from img_hog import hog2, hog3, hog_lsh_list, hog_histo
from img_sift import sift2, sift_histo
from lsh import LSH_hog, LSH_sift
from rerank import blending, ensembling
import cPickle
import openface
openfacedir = '/home/ubuntu/Documents/openface'
modelDir = osp.join(openfacedir, 'models/dlib',
"shape_predictor_68_face_landmarks.dat")
align = openface.AlignDlib(modelDir)
netDir = osp.join(openfacedir, 'models/openface', 'nn4.small2.v1.t7')
net = openface.TorchNeuralNet(netDir, imgDim=96, cuda=False)
upload_prefix = './static/upload/'
SETNAME = 'lfw_raw'
with open('../static/url.pkl') as fh:
urldat = cPickle.load(fh)
app = Flask(__name__)
# db = SQLAlchemy(app)r
UPLOAD_FOLDER = upload_prefix
# ALLOWED_EXTENSIONS = set(['pdf', 'png', 'jpg', 'jpeg', 'gif'])
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
api = Api(app)
from Testing_Face_detector import Image_Sliding
import os
import openface
import pandas as pd
from sklearn.svm import SVC
import face_recognition
import cv2
import pickle
#
path = "../Images"
face_encodings = []
Names = []
face_aligner = openface.AlignDlib("shape_predictor_68_face_landmarks.dat")
def encoding_images():
for root, directory, filenames in os.walk(path):
for file_ in filenames:
path_image = os.path.join(".", root, file_)
# print(path_image)
image = cv2.imread(path_image)
image_new = cv2.resize(image, (300, 300))
image_ = cv2.resize(image, (300, 300))
# cv2.imshow("", image)
# cv2.waitKey()
name = file_.split('.')
name__ = ""
for n in name:
if n == '.' or n == 'jpeg' or n == 'jpg' or n == 'png' or n == 'PNG':
pass
TFILE = "traindata.csv"
MPATH = "Mugshot/"
PPATH = "Test/"
L = []
Y = []
input_image_size = 160
persons = 0
predictor_path = "shape_predictor_68_face_landmarks.dat"
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(predictor_path)
facenet.load_model("20170512-110547/20170512-110547.pb")
# Create a HOG face detector using the built-in dlib class
face_pose_predictor = dlib.shape_predictor(predictor_path)
face_aligner = openface.AlignDlib(predictor_path)
def prewhiten(x):
mean = np.mean(x)
std = np.std(x)
std_adj = np.maximum(std, 1.0 / np.sqrt(x.size))
y = np.multiply(np.subtract(x, mean), 1 / std_adj)
return y
def facialPoints(img):
global detector
global predictor
global face_pose_predicitor
global face_aligner
