def find_faces(self, image):
faces_raw = []
faces = []
if image.ndim < 2:
print('Unable to align img, ndim = %d' % ndim)
return faces, faces_raw
if image.ndim == 2:
image = facenet.to_rgb(image)
image = image[:, :, 0:3]
bounding_boxes, _ = align.detect_face.detect_face(image, self.minsize, self.pnet, self.rnet, self.onet, self.threshold, self.factor)
#nrof_faces = bounding_boxes.shape[0]
#print("nrof_faces " + str(nrof_faces))
img_size = np.asarray(image.shape)[0:2]
for det in bounding_boxes:
face = np.zeros((1, self.image_size_model, self.image_size_model, 3))
det = np.squeeze(det)
bb = np.zeros(4, dtype=np.int32)
bb[0] = np.maximum(det[0] - self.margin / 2, 0)
bb[1] = np.maximum(det[1] - self.margin / 2, 0)
bb[2] = np.minimum(det[2] + self.margin / 2, img_size[1])
bb[3] = np.minimum(det[3] + self.margin / 2, img_size[0])
cropped = image[bb[1]:bb[3], bb[0]:bb[2], :]
scaled = misc.imresize(cropped, (self.image_size, self.image_size), interp='bilinear')
faces_raw.append(scaled)
prewhiten = facenet.prewhiten(scaled)
facecrop = facenet.crop(prewhiten, False, self.image_size_model)
face[0,:,:,:] = facecrop
faces.append(face)
#self.save_img(faces_raw,"")
return faces, faces_raw
def classify(image, sess):
global model, class_names
np.random.seed(seed=np.sum(image))
# Get input and output tensors
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name(
"phase_train:0")
embedding_size = embeddings.get_shape()[1]
# Run forward pass to calculate embeddings
print('Calculating features for image')
emb_array = np.zeros((1, embedding_size))
images = np.zeros((1, 160, 160, 3))
if image.ndim == 2:
image = facenet.to_rgb(image)
image = facenet.prewhiten(image)
image = facenet.crop(image, False, 160)
image = facenet.flip(image, False)
images[0, :, :, :] = image
feed_dict = {images_placeholder: images, phase_train_placeholder: False}
emb_array[0:1, :] = sess.run(embeddings, feed_dict=feed_dict)
###
predictions = model.predict_proba(emb_array)[0]
best_class_indices = ind = np.argpartition(predictions, -3)[-3:]
best_class_indices = best_class_indices[np.argsort(
predictions[best_class_indices])][::-1]
best_class_probabilities = predictions[best_class_indices]
return np.array(class_names)[best_class_indices], best_class_probabilities
def align_data_with_bb(image_paths, image_size, margin, pnet, rnet, onet,image_size_for_pretrain):
try:
minsize = 20 # minimum size of face
threshold = [ 0.6, 0.7, 0.7 ] # three steps's threshold
factor = 0.709 # scale factor
nrof_samples = len(image_paths)
img_list = [None] * nrof_samples
for i in range(nrof_samples):
# print (i)
b_box = []
img = misc.imread(os.path.expanduser(image_paths[i]))
print ("246")
print (img.shape)
img_size = np.asarray(img.shape)[0:2]
bounding_boxes, _ = align.detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)
print (bounding_boxes)
det = np.squeeze(bounding_boxes[0,0:4])
bb = np.zeros(4, dtype=np.int32)
bb[0] = np.maximum(det[0]-margin/2, 0)
bb[1] = np.maximum(det[1]-margin/2, 0)
bb[2] = np.minimum(det[2]+margin/2, img_size[1])
bb[3] = np.minimum(det[3]+margin/2, img_size[0])
cropped = img[bb[1]:bb[3],bb[0]:bb[2],:]
cropped = cv2.cvtColor(cropped, cv2.COLOR_BGR2RGB)
img_to_norm = cv2.cvtColor(cropped, 37)
img_to_norm[0] = cv2.equalizeHist(img_to_norm[0])
prewhitened = cv2.cvtColor(img_to_norm, 39)
res = cv2.fastNlMeansDenoisingColored(prewhitened, None, 10, 10, 7, 21)
if len(b_box) == 0:
print ("2")
b_box.append(bb[0])
b_box.append(bb[1])
b_box.append(bb[2])
b_box.append(bb[3])
# cv2.rectangle(img,(bb[0],bb[1]),(bb[2],bb[3]),(255,0,0),2)
crop_img = img[bb[1]:bb[3],bb[0]:bb[2],:]
# return_img = img
crop_img = facenet.crop(crop_img, None, image_size_for_pretrain)
crop_img = facenet.flip(crop_img, None)
# img = crop(img, do_random_crop, image_size)
# img = flip(img, do_random_flip)
resize=misc.imresize(crop_img, (image_size_for_pretrain, image_size_for_pretrain), interp='bilinear')
return_img = resize
aligned = misc.imresize(res, (image_size_for_pretrain, image_size_for_pretrain), interp='bilinear')
prewhitened = facenet.prewhiten(aligned)
img_list[i] = prewhitened
images = np.stack(img_list)
return images, return_img
except:
traceback.print_exc()
pass
def load_image(img, image_size, do_prewhiten=True):
image = np.zeros((1, image_size, image_size, 3))
if img.ndim == 2:
img = facenet.to_rgb(img)
if do_prewhiten:
img = facenet.prewhiten(img)
img = facenet.crop(img, False, image_size)
img = facenet.flip(img, False)
image[0, :, :, :] = img
return image
def resize_image(img, image_size, do_prewhiten=True):
print(img.shape)
if img.ndim == 2:
img = to_rgb(img)
if do_prewhiten:
img = prewhiten(img)
img = crop(img, False, image_size)
img = flip(img, False)
img = np.expand_dims(img, axis=0)
#images[:,:,:,:] = img
#return images
return img
def load_images():
dataset = facenet.get_dataset('dataset')
paths, labels = facenet.get_image_paths_and_labels(dataset)
img_list = []
for image in paths:
img = cv2.imread(image) #reading
img = facenet.crop(img, False, 160) #crop
prewhitened = facenet.prewhiten(img) #some adjustments
img_list.append(prewhitened)
images = np.stack(img_list)
return images
def load_data(img_paths, flip, img_size, do_prewhiten=True):
m = len(img_paths)
imgs = np.zeros((m, img_size, img_size, 3))
for i in range(m):
img = misc.imread(img_paths[i])
if img.ndim == 2:
img = facenet.to_rgb(img)
if do_prewhiten:
img = facenet.prewhiten(img)
img = facenet.crop(img, False, image_size)
if flip:
img = np.fliplr(img)
imgs[i, :, :, :] = img
return imgs
def prepare_images(self,
image,
box,
image_size,
do_random_crop=False,
do_random_flip=False,
do_prewhiten=True):
img = np.array(image.crop(box=(box[0], box[1], box[2], box[3])))
img = resize(img, (image_size, image_size))
if img.ndim == 2:
img = facenet.to_rgb(img)
if do_prewhiten:
img = prewhiten(img)
img = facenet.crop(img, do_random_crop, image_size)
img = facenet.flip(img, do_random_flip)
return img
def get_face_in_frame(frame, aligned_list):
images = np.zeros((len(aligned_list), img_size, img_size, 3))
i = 0
for face_pos in aligned_list:
if face_pos[0] < 0 or face_pos[1] < 0:
continue
else:
img = frame[face_pos[1]:face_pos[3], face_pos[0]:face_pos[2], ]
if img.ndim == 2:
img = facenet.to_rgb(img)
img = misc.imresize(img, (img_size, img_size), interp='bilinear')
img = facenet.prewhiten(img)
img = facenet.crop(img, False, img_size)
images[i, :, :, :] = img
i += 1
return images
def load_img(img,
do_random_crop,
do_random_flip,
image_size,
do_prewhiten=True):
'''
Process the captured images from the webcam, prewhitening, cropping and
flipping as required. Returns processed image.
'''
images = np.zeros((1, image_size, image_size, 3))
if img.ndim == 2:
img = to_rgb(img)
if do_prewhiten:
img = prewhiten(img)
img = crop(img, do_random_crop, image_size)
img = flip(img, do_random_flip)
images[:, :, :, :] = img
return images
def recognize(model):
g_recognition = tf.Graph()
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.2)
with g_recognition.as_default():
with tf.Session(
graph=g_recognition,
config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
# Load the model
facenet.load_model(model)
# Get input and output tensors
images_placeholder = g_recognition.get_tensor_by_name("input:0")
embeddings = g_recognition.get_tensor_by_name("embeddings:0")
phase_train_placeholder = g_recognition.get_tensor_by_name(
"phase_train:0")
embedding_size = embeddings.get_shape()[1]
emb_array = np.zeros((1, embedding_size))
images = np.zeros((1, 160, 160, 3))
img = None
while True:
if img is None:
img = yield None
img = crop(img, False, 160)
img = flip(img, False)
images[0, :, :, :] = img
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
start_index = 0
end_index = 1
emb_array[start_index:end_index, :] = sess.run(
embeddings, feed_dict=feed_dict)
img = yield emb_array
def image_array_align_data(self,
image_arr,
image_path,
image_size=160,
margin=32,
gpu_memory_fraction=1.0,
detect_multiple_faces=True):
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
print('Creating networks and loading parameters')
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(
gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = align.detect_face.create_mtcnn(sess, None)
img = image_arr
bounding_boxes, _ = align.detect_face.detect_face(
img, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
nrof_successfully_aligned = 0
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
det_arr = []
img_size = np.asarray(img.shape)[0:2]
if nrof_faces > 1:
if detect_multiple_faces:
for i in range(nrof_faces):
det_arr.append(np.squeeze(det[i]))
else:
bounding_box_size = (det[:, 2] - det[:, 0]) * (det[:, 3] -
det[:, 1])
img_center = img_size / 2
offsets = np.vstack([
(det[:, 0] + det[:, 2]) / 2 - img_center[1],
(det[:, 1] + det[:, 3]) / 2 - img_center[0]
])
offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
index = np.argmax(
bounding_box_size - offset_dist_squared *
2.0) # some extra weight on the centering
det_arr.append(det[index, :])
else:
det_arr.append(np.squeeze(det))
images = np.zeros((nrof_faces, image_size, image_size, 3))
for i, det in enumerate(det_arr):
det = np.squeeze(det)
bb = np.zeros(4, dtype=np.int32)
bb[0] = np.maximum(det[0] - margin / 2, 0)
bb[1] = np.maximum(det[1] - margin / 2, 0)
bb[2] = np.minimum(det[2] + margin / 2, img_size[1])
bb[3] = np.minimum(det[3] + margin / 2, img_size[0])
cropped = img[bb[1]:bb[3], bb[0]:bb[2], :]
# 进行图片缩放 cv2.resize(img,(w,h))
scaled = imresize(cropped, (image_size, image_size),
interp='bilinear')
nrof_successfully_aligned += 1
# print(scaled)
# scaled=self.prewhiten(scaled)
# 保存检测的头像
filename_base = './img/'
filename = os.path.basename(image_path)
filename_name, file_extension = os.path.splitext(filename)
output_filename_n = "{}/{}_{}{}".format(
filename_base, filename_name, i, file_extension)
imsave(output_filename_n, scaled)
scaled = facenet.prewhiten(scaled)
scaled = facenet.crop(scaled, False, 160)
scaled = facenet.flip(scaled, False)
images[i] = scaled
if nrof_faces > 0:
return images
else:
# 如果没有检测到人脸 直接返回一个1*3的0矩阵 多少维度都行 只要能和是不是一个图片辨别出来就行
return np.zeros((1, 3))