def __init__(self): self.pre_model = create_model() self.pre_model.load_weights('./deep/weights/nn4.small2.v1.h5') self.alignment = AlignDlib('./deep/models/landmarks.dat') self.metadata = None self.embedded = None self.classifier = None
def __init__(self): dst_dir = 'models' dst_file = os.path.join(dst_dir, 'landmarks.dat') if not os.path.exists(dst_file): os.makedirs(dst_dir) download_landmarks(dst_file) # Create CNN model and load pretrained weights (OpenFace nn4.small2) self.nn4_small2_pretrained = create_model() self.nn4_small2_pretrained.load_weights('models/nn4.small2.v1.h5') self.metadata = self.load_metadata('faces') # Initialize the OpenFace face alignment utility self.alignment = AlignDlib('models/landmarks.dat') # Get embedding vectorsf # self.embedded = np.zeros((self.metadata.shape[0], 128)) self.embedded = np.zeros((0, 128)) # Train images custom_metadata = self.load_metadata("faces") self.metadata = np.append(self.metadata, custom_metadata) self.update_embeddings() self.train_images()
def __init__(self): # Initialize the dlib face alignment utility self.alignment = AlignDlib('shape_predictor_68_face_landmarks.dat') self.detector = dlib.get_frontal_face_detector() # Load the model self.model = load_model('weights_final.hdf5', custom_objects={ 'triplet_loss': self.triplet_loss, 'tf': tf }) # Get the web camera feed self.cap = cv2.VideoCapture(0) # Defining variables self.threshold = 0.7 self.base_images = [] self.distances = [] self.set_new_person = False self.saving = False self.pressed = 0 self.next_base_image = 0 self.names = [] self.saved_images = [] self.counter = 0 # Defining the path for image saving self.path = os.getcwd() + '\persons' # Delete previous directories if os.path.isdir(self.path): shutil.rmtree(self.path, onerror=self.onerror) # Create the 'persons' directory if not os.path.isdir(self.path): os.mkdir(self.path)
def __init__(self): dst_dir = 'models' dst_file = os.path.join(dst_dir, 'landmarks.dat') if not os.path.exists(dst_file): os.makedirs(dst_dir, exist_ok=True) url = 'http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2' decompressor = bz2.BZ2Decompressor() with urlopen(url) as src, open(dst_file, 'wb') as dst: data = src.read(1024) while len(data) > 0: dst.write(decompressor.decompress(data)) data = src.read(1024) # download_landmarks(self,dst_file) # Create CNN model and load pretrained weights (OpenFace nn4.small2) self.nn4_small2_pretrained = create_model() self.nn4_small2_pretrained.load_weights('models/nn4.small2.v1.h5') self.metadata = self.load_metadata('faces') # Initialize the OpenFace face alignment utility self.alignment = AlignDlib('models/landmarks.dat') # Get embedding vectorsf # self.embedded = np.zeros((self.metadata.shape[0], 128)) self.embedded = np.zeros((0, 128)) # Train images custom_metadata = self.load_metadata("faces") self.metadata = np.append(self.metadata, custom_metadata) self.update_embeddings() self.train_images()
class DeepFace: def __init__(self): self.pre_model = create_model() self.pre_model.load_weights('./deep/weights/nn4.small2.v1.h5') self.alignment = AlignDlib('./deep/models/landmarks.dat') self.metadata = None self.embedded = None self.classifier = None def pre_train(self, path): self.metadata = load_metadata(path) self.embedded = np.zeros((self.metadata.shape[0], 128)) for i, m in enumerate(self.metadata): img = load_image(m.image_path()) img = self.align_image(img) if img is None: continue # scale RGB values to interval [0,1] img = (img / 255.).astype(np.float32) # obtain embedding vector for image self.embedded[i] = self.pre_model.predict( np.expand_dims(img, axis=0))[0] targets = np.array([m.name for m in self.metadata]) # LabelEncoder可以将标签分配一个0—n_classes - 1 之间的编码 self.encoder = LabelEncoder() self.encoder.fit(targets) # 将各种标签分配一个可数的连续编号 self.y = self.encoder.transform(targets) def align_image(self, img): return self.alignment.align( 96, img, self.alignment.getLargestFaceBoundingBox(img), landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) def train(self, classifier=LinearSVC): X_train = self.embedded y_train = self.y self.classifier = globals()[classifier]() self.classifier.fit(X_train, y_train) def predict(self, img): img = self.align_image(img) if img is None: return str("UnKnown") img = (img / 255.).astype(np.float32) one_embedded = self.pre_model.predict(np.expand_dims(img, axis=0))[0] example_prediction = self.classifier.predict([one_embedded]) example_identity = self.encoder.inverse_transform( example_prediction)[0] return str(example_identity)
def load_image_alignment(path): alignment = AlignDlib('models/landmarks.dat') img = cv2.imread(path, 1) # detect face and return bounding box bb = alignment.getLargestFaceBoundingBox(img) jc_aligned = alignment.align(96, img, bb, landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) return jc_aligned
def predict(): """ Extracts from webcam feed and passes through served model and ML models to recognise faces :return: Name of the Person """ #Load served models channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) request_pb2 = predict_pb2.PredictRequest() request_pb2.model_spec.name = 'my_model' request_pb2.model_spec.signature_name = 'predict' #Extract image from webcam and convrt it to required format imgData = request.get_data() convertImage(imgData) im_orig = cv2.imread('app/output.png', 1) im_orig = im_orig[...,::-1] #Align image alignment = AlignDlib('app/landmarks.dat') bb = alignment.getAllFaceBoundingBoxes(im_orig) im_aligned = [] n = [] for i in bb: j = alignment.align(96, im_orig, i, landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) im_aligned.append(j) for n in im_aligned: n = (n / 255.).astype(np.float32) new_n = np.expand_dims(n, axis=0) #pass the face cropped images through the server DL model request_pb2.inputs['images'].CopyFrom(tf.contrib.util.make_tensor_proto(n, shape=[1, 96, 96, 3])) result_future = stub.Predict(request_pb2, 10.) embedded_t = tf.make_ndarray(result_future.outputs['scores']) #Pass the extracted embeddings into ML models to get the nearest neighbour example_predic = knn.predict(embedded_t) example_prob = svc.predict_proba(embedded_t) print(example_prob) if np.any(example_prob > 0.35): example_i = encoder.inverse_transform(example_predic)[0] print(example_i) else: print("Not a face from database...") maximum = np.max(example_prob, axis=1) index_of_maximum = np.where(example_prob == maximum) cdsid = {0:'P0', 1:'P1', 2:'P2', 3:'P3', 4:'P4', 5:'P5', 6:'P6', 7:'P7', 8:'P8', 9:'P9', 10:'P10', 11:'P11', 12:'P12', 13:'P13', 14:'P14', 15:'P15', 16:'P16', 17:'P17', 18:'P18', 19:'P19', 20:'P20'} print(cdsid[float(index_of_maximum[1])]) response = jsonify(cdsid[float(index_of_maximum[1])]) return response
def __init__(self, anchors, name): nn4_small2_pretrained = create_model() nn4_small2_pretrained.load_weights('weights/nn4.small2.v1.h5') self.nn4_small2_pretrained = nn4_small2_pretrained self.alignment = AlignDlib('models/landmarks.dat') anchors = [(img / 255.).astype(np.float32) for img in anchors] anchors_embeddings = [ self.nn4_small2_pretrained.predict(np.expand_dims(anchor, axis=0))[0] for anchor in anchors ] self.anchors_embeddings = anchors_embeddings self.name = name
def main_2(): # Initialize the OpenFace face alignment utility alignment = AlignDlib('models/landmarks.dat') cap = cv2.VideoCapture(0) ret, frame = cap.read() while (True): #b,g,r = cv2.split(frame) #frame = cv2.merge((r,g,b)) #frame = frame[...,::-1] #frame = cv2.resize(frame, (250,250)) # cv2.imwrite('img.jpg', frame) frame = load_image('img.jpg') bb = alignment.getLargestFaceBoundingBox(frame) # Transform image using specified face landmark indices and crop image to 96x96 jc_aligned = alignment.align( 96, frame, bb, landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) # Show original image plt.subplot(131) plt.imshow(frame) # Show original image with bounding box plt.subplot(132) plt.imshow(frame) plt.gca().add_patch( patches.Rectangle((bb.left(), bb.top()), bb.width(), bb.height(), fill=False, color='red')) # Show aligned image plt.subplot(133) plt.imshow(jc_aligned) plt.show() if cv2.waitKey(1) & 0xFF == ord('y'): #save on pressing 'y' cv2.destroyAllWindows() break _, frame = cap.read()
def init_sequential_model(): global model, alignment, df_train, train_paths model = create_squential_model() mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) NAME = 'CNN-{}'.format(int(time.time())) tboard_log_dir = os.path.join("logs", NAME) tensorboard_callback = TensorBoard(log_dir=tboard_log_dir, histogram_freq=1) model.fit(x=x_train, y=y_train, epochs=5, validation_data=(x_test, y_test), callbacks=[tensorboard_callback]) alignment = AlignDlib('weights/shape_predictor_68_face_landmarks.dat')
def normalization(metadata): def load_image(path): img = cv2.imread(path, 1) return img[..., ::-1] def align_image(img): return alignment.align(96, img, alignment.getLargestFaceBoundingBox(img), landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) alignment = AlignDlib('models/landmarks.dat') embedded = np.zeros((metadata.shape[0], 128)) for i, m in enumerate(metadata): # noinspection PyBroadException try: img = load_image(m.image_path()) img = align_image(img) img = (img / 255.).astype(np.float32) embedded[i] = nn4_small2_pretrained.predict(np.expand_dims(img, axis=0))[0] recognize_flag = 1 del img,metadata except Exception as e: recognize_flag = 0 return recognize_flag, embedded,i
def setup_landmarks(): dst_dir = 'models' dst_file = os.path.join(dst_dir, 'landmarks.dat') if not os.path.exists(dst_file): os.makedirs(dst_dir) download_landmarks(dst_file) alignment = AlignDlib('models/landmarks.dat') return alignment
def __init__(self, metadata): self.nn4_small2_pretrained = create_model() self.nn4_small2.load_weights('weights\nn4.small2.v1.h5') self.alignment = AlignDlib('models/landmarks.dat') self.svm_model = LinearSVC() self.recognizer = np.zeros((metadata.shape[0]), 128) embed_vec(metadata, self.recognizer) train_recog(metadata, self.recognizer, self.svm_model)
def plot_sample(): metadata = load_metadata('../data/chapter7/images/') # 初始化OpenFace人脸对齐工具,使用Dlib提供的68个关键点 alignment = AlignDlib('../data/chapter7/landmarks.dat') # 加载一张训练图像 img = load_image(metadata[45].get_image_path()) # 检测人脸并返回边框 bounding_box = alignment.getLargestFaceBoundingBox(img) # 使用指定的人脸关键点转换图像并截取96*96的人脸图像 aligned_img = alignment.align(96, img, bounding_box, landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) # 绘制原图 plt.subplot(1, 3, 1) plt.imshow(img) plt.xticks([]) plt.yticks([]) # 绘制带人脸边框的原图 plt.subplot(1, 3, 2) plt.imshow(img) plt.gca().add_patch(patches.Rectangle( (bounding_box.left(), bounding_box.top()), bounding_box.width(), bounding_box.height(), fill=False, color='red' )) plt.xticks([]) plt.yticks([]) # 绘制对齐后截取的96*96人脸图像 plt.subplot(1, 3, 3) plt.imshow(aligned_img) plt.xticks([]) plt.yticks([]) plt.show()
def create_pretrain_model(): nn4_small2 = create_model() nn4_small2.load_weights(MODEL_FILE_H5) alignment = AlignDlib(LANDMARKER_FILE) def align_image(img): return alignment.align(96, img, alignment.getLargestFaceBoundingBox(img), landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) metadata = load_metadata(IMAGE_DIR) embedded = np.zeros((metadata.shape[0], 128)) for i, m in enumerate(metadata): img = load_image(m.get_image_path()) img = align_image(img) # 数据规范化 img = (img / 255.).astype(np.float32) # 获取人脸特征向量 embedded[i] = nn4_small2.predict(np.expand_dims(img, axis=0))[0] print('Process', i, m, 'Finish') def distance(emb1, emb2): return np.sum(np.square(emb1 - emb2)) def show_pair(idx1, idx2): plt.figure(figsize=(8, 3)) plt.suptitle( f'Distance = {distance(embedded[idx1], embedded[idx2]):.2f}') plt.subplot(121) plt.imshow(load_image(metadata[idx1].get_image_path())) plt.xticks([]) plt.yticks([]) plt.subplot(122) plt.imshow(load_image(metadata[idx2].get_image_path())) plt.xticks([]) plt.yticks([]) show_pair(1, 45) show_pair(28, 47) show_pair(46, 47) plt.show() return embedded
def normalization_Flask(img): def load_image_Flask(img): return img[..., ::-1] def align_image_Flask(img): return alignment.align(96, img, alignment.getLargestFaceBoundingBox(img), landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) alignment = AlignDlib('models/landmarks.dat') embedded = np.zeros((1, 128)) try: img = load_image_Flask(img) img = align_image_Flask(img) img = (img / 255.).astype(np.float32) embedded= nn4_small2_pretrained.predict(np.expand_dims(img, axis=0))[0] recognize_flag = 1 except Exception as e: recognize_flag = 0 return recognize_flag, embedded
def create_pretrain_model(): nn4_small2 = load_model(MODEL_FILE_H5, custom_objects={'tf': tf}) alignment = AlignDlib(LANDMARKER_FILE) def align_image(img): return alignment.align(96, img, alignment.getLargestFaceBoundingBox(img), landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) metadata = load_metadata(IMAGE_DIR) embedded = np.zeros((metadata.shape[0], 128)) for i, m in enumerate(metadata): img = load_image(m.get_image_path()) img = align_image(img) # 数据规范化 img = (img / 255.).astype(np.float32) # 获取人脸特征向量 embedded[i] = nn4_small2.predict(np.expand_dims(img, axis=0))[0] print('Process', i, m, 'Finish') return embedded
import numpy from PIL import Image import time import cv2 import dlib from align import AlignDlib import time import numpy as np data_path = '/home/dl-linux/Desktop/face_recognition/CASIA-maxpy-clean/' data_save_path = '/home/dl-linux/Desktop/face_recognition/save/' if not os.path.isdir(data_save_path): os.makedirs(data_save_path) alignment = AlignDlib('models/landmarks.dat') def align_image(img): bb = alignment.getLargestFaceBoundingBox(img) if bb is None: #print 'OMG' bb = dlib.rectangle(int(46), int(47), int(201), int(202)) #print 'bb:'+ str(type(bb)) return alignment.align(250, img, bb, landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE), bb i = 0
from model import create_model from align import AlignDlib import glob import imutils import os # INITIALIZE MODELS nn4_small2 = create_model() nn4_small2.summary() # load dữ liệu để tối ưu mô hình cnn nn4_small2.load_weights('weights/nn4.small2.v1.h5') # bộ dữ liệu 68 điểm đặc trưng để căn chỉnh mặt. alignment = AlignDlib('shape_predictor_68_face_landmarks.dat') # LOAD Image Data train_paths = glob.glob("image/*") print(train_paths) train_paths_v2 = glob.glob("image/csdl/*") nb_classes = len(train_paths) df_train = pd.DataFrame(columns=['index', 'image', 'label', 'name']) index = 0 for i, train_path in enumerate(train_paths): name = train_path.split("\\")[-1] images = glob.glob(train_path + "/*") for image in images: df_train.loc[len(df_train)] = [index, image, i, name]
import cv2 #import matplotlib.pyplot as plt #import matplotlib.patches as patches from align import AlignDlib #get_ipython().run_line_magic('matplotlib', 'inline') def load_image(path): img = cv2.imread(path, 1) # OpenCV loads images with color channels # in BGR order. So we need to reverse them return img[...,::-1] # Initialize the OpenFace face alignment utility alignment = AlignDlib('models/landmarks.dat') # Load an image of Jacques Chirac jc_orig = load_image(metadata[6].image_path()) # Detect face and return bounding box bb = alignment.getLargestFaceBoundingBox(jc_orig) # Transform image using specified face landmark indices and crop image to 96x96 jc_aligned = alignment.align(96, jc_orig, bb, landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) # Show original image # plt.subplot(131) # plt.imshow(jc_orig) # # Show original image with bounding box
def load_image(path): img = cv2.imread(path, 1) # OpenCV 默认使用 BGR 通道加载图像,转换为 RGB 图像 return img[..., ::-1] metadata = load_metadata('images') # 人脸检测、对齐和提取 import matplotlib.pyplot as plt import matplotlib.patches as patches from align import AlignDlib # 初始化 OpenFace 人脸对齐工具,使用 Dlib 提供的 68 个关键点 alignment = AlignDlib('landmarks.dat') # 加载一张训练图像 img = load_image(metadata[0].image_path()) # 检测人脸并返回边框 bb = alignment.getLargestFaceBoundingBox(img) # 使用指定的人脸关键点转换图像并截取 96x96 的人脸图像 aligned_img = alignment.align(96, img, bb, landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) # 绘制原图 # plt.figure(1) # plt.subplot(131) # plt.imshow(img) # plt.xticks([])
from keras.models import load_model from face_recognition1 import find_id from eye_detect_recog_final import eye_ext from model import create_model import os start=time.time() from align import AlignDlib def sortKeyFunc(s): return int(os.path.basename(s)[6:-4]) files = sorted(glob(r"E:\projectImplementation\projectFiles\frames\testcase1\*.jpg")) files.sort(key=sortKeyFunc) # print(os.path.basename(files[1])[6:-4]) alignment = AlignDlib('models/landmarks.dat') eye_cascade_left= cv2.CascadeClassifier("E:\\projectImplementation\\projectFiles\\left_eye_haar.xml") trainedModel = load_model('my-model1-20190419-230910.h5') def load_image(path): img = cv2.imread(path, 1) im = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) return im i=1 abhi_att=[] aman_att=[] anomaly=[] abhi_emotion=[] aman_emotion=[] for file in files:
if choice == 3: # Rotate 180 and flip horizontally src = cv2.rotate(src, rotateCode=cv2.ROTATE_180) src = cv2.flip(src, flipCode=1) if choice == 4: # Rotate 90 counter-clockwise src = cv2.rotate(src, rotateCode=cv2.ROTATE_90_COUNTERCLOCKWISE) if choice == 5: # Rotate 90 counter-clockwise and flip horizontally src = cv2.rotate(src, rotateCode=cv2.ROTATE_90_COUNTERCLOCKWISE) src = cv2.flip(src, flipCode=1) return src alignment = AlignDlib( '/Users/siddhartham/Sid/PycharmProjects/Deep-Face-Recognition-Using-Inception-Model-Keras-OpenCV-Dlib/models/landmarks.dat' ) def align_image(img): return alignment.align(96, img, alignment.getLargestFaceBoundingBox(img), landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) from glob import glob def assure_path_exists(path): dir = os.path.dirname(path)
import os import numpy as np import cv2 import dlib from align import AlignDlib from model import create_model import pickle alignment = AlignDlib('models/landmarks.dat') model = '/home/legion/Documents/DeepLearning/face-recognition/Caffe model/res10_300x300_ssd_iter_140000.caffemodel' prototxt = '/home/legion/Documents/DeepLearning/face-recognition/Caffe model/deploy.prototxt.txt' nn4_small2_pretrained = create_model() nn4_small2_pretrained.load_weights('weights/nn4.small2.v1.h5') knn = pickle.load(open('knn_model.sav', 'rb')) svc = pickle.load(open('svc_model.sav', 'rb')) # landmark indices INNER_EYES_AND_BOTTOM_LIP = [39, 42, 57] OUTER_EYES_AND_NOSE = [36, 45, 33] net = cv2.dnn.readNetFromCaffe(prototxt, model) """ def recognise(img): (h, w) = img.shape[:2] net.setInput(blob) blob = cv2.dnn.blobFromImage(cv2.resize(img, (300, 300)), 1.0, (300, 300), (104.0, 177.0, 123.0)) detections = net.forward() for i in range(0, detections.shape[2]): confidence = detections[0, 0, i, 2]
class WebcamTest(): def __init__(self): # Initialize the dlib face alignment utility self.alignment = AlignDlib('shape_predictor_68_face_landmarks.dat') self.detector = dlib.get_frontal_face_detector() # Load the model self.model = load_model('weights_final.hdf5', custom_objects={ 'triplet_loss': self.triplet_loss, 'tf': tf }) # Get the web camera feed self.cap = cv2.VideoCapture(0) # Defining variables self.threshold = 0.7 self.base_images = [] self.distances = [] self.set_new_person = False self.saving = False self.pressed = 0 self.next_base_image = 0 self.names = [] self.saved_images = [] self.counter = 0 # Defining the path for image saving self.path = os.getcwd() + '\persons' # Delete previous directories if os.path.isdir(self.path): shutil.rmtree(self.path, onerror=self.onerror) # Create the 'persons' directory if not os.path.isdir(self.path): os.mkdir(self.path) def onerror(self, func, path, exc_info): """ Error handler for `shutil.rmtree`. If the error is due to an access error (read only file) it attempts to add write permission and then retries. If the error is for another reason it re-raises the error. Usage : `shutil.rmtree(path, onerror=onerror)` """ import stat if not os.access(path, os.W_OK): # Is the error an access error ? os.chmod(path, stat.S_IWUSR) func(path) else: raise # take a bounding predicted by dlib and convert it # to the format (x, y, w, h) as we would normally do # with OpenCV def rect_to_bb(self, rect): x = rect.left() y = rect.top() w = rect.right() - x h = rect.bottom() - y # return a tuple of (x, y, w, h) return (x, y, w, h) # The model calculates the distance between the two images def prediction(self, network, pic_1, pic_2): # increase img dimensions img1 = np.expand_dims(pic_1, axis=0) img1 = np.expand_dims(img1, axis=3) img2 = np.expand_dims(pic_2, axis=0) img2 = np.expand_dims(img2, axis=3) # calculate the network's prediction on img1 and img2 preds = network.predict([img1, img2, img1])[0] pred1 = preds[:128] pred2 = preds[128:256] # calculate the distance between the two images dist = np.sum(np.square(pred1 - pred2)) # print("distance between pictures: {:2.4f}".format(dist)) return dist def triplet_loss(self, y_true, y_pred, alpha=0.2): """ Implementation of the triplet loss function Arguments: y_true -- true labels, required when you define a loss in Keras, you don't need it in this function. y_pred -- python list containing three objects: anchor -- the encodings for the anchor data positive -- the encodings for the positive data (similar to anchor) negative -- the encodings for the negative data (different from anchor) Returns: loss -- real number, value of the loss """ anchor = y_pred[:, :128] positive = y_pred[:, 128:256] negative = y_pred[:, 256:] # distance between the anchor and the positive pos_dist = K.sum(K.square(anchor - positive), axis=1) # distance between the anchor and the negative neg_dist = K.sum(K.square(anchor - negative), axis=1) # compute loss basic_loss = pos_dist - neg_dist + alpha loss = K.maximum(basic_loss, 0.0) return loss # Aligns the given image def image_processing(self, image): # Detect face and return bounding box rect = self.alignment.getLargestFaceBoundingBox(image) img_aligned = self.alignment.align( 64, image, rect, landmarkIndices=AlignDlib.INNER_EYES_AND_BOTTOM_LIP) return img_aligned # Saves the given image with the given name def save_pictures(self, image, path, name, extension): img_item = path + '\\' + name + "." + extension cv2.imwrite(img_item, image) # The main part of the class def cycle(self): # Capture frame-by-frame ret, frame = self.cap.read() # Turn the image into a greyscale gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # Detect the faces rects = self.detector(gray, 1) for rect in rects: (x, y, w, h) = self.rect_to_bb(rect) roi_gray = gray[y:y + h, x:x + w] roi_color = frame[y:y + h, x:x + w] # Align the image aligned_image = self.alignment.align( 64, gray, rect, landmarkIndices=AlignDlib.INNER_EYES_AND_BOTTOM_LIP) # If the alignment was succesful if aligned_image is not None: # If there is a new recording save the recorded images (the saving part is done in the 'webacm_app.py') if self.set_new_person: self.counter += 1 if self.counter % 10 == 0: if len(self.saved_images) < 10: self.saved_images.append(aligned_image) else: self.counter = 0 # Create a directory for the new person and save the person's images if self.saving: self.path_person = self.path + '\\' + self.names[-1] os.mkdir(self.path_person) for (i, picture) in enumerate(self.base_images[-1]): self.save_pictures(picture, self.path_person, self.names[-1] + '_' + str(i), 'jpg') self.saving = False # Calculate the average distance from the save distance for i in range(len(self.base_images)): average_distance = 0 for base_image in self.base_images[i]: average_distance += self.prediction( self.model, aligned_image / 255.0, base_image / 255.0) self.distances[i] = average_distance / len( self.base_images[i]) # If the picture alignment was unsucessful, then the distance belonging to the picture is four else: for i in range(len(self.distances)): self.distances[i] = 4 if self.set_new_person: color = (0, 255, 0) else: color = (255, 0, 0) # BGR stroke = 2 end_cord_x = x + w end_cord_y = y + h cv2.rectangle(frame, (x, y), (end_cord_x, end_cord_y), color, stroke) min_index = 0 # Calculate the minimum distances from all person for (i, distance) in enumerate(self.distances): if distance < self.distances[min_index]: min_index = i # Display the distance values on the feed if len(self.distances ) > 0 and self.distances[min_index] < self.threshold: font = cv2.FONT_HERSHEY_SIMPLEX name = self.names[min_index] + "{:2.2f}".format( self.distances[min_index]) color = (255, 255, 255) stroke = 1 cv2.putText(frame, name, (x, y), font, 1, color, stroke, cv2.LINE_AA) else: font = cv2.FONT_HERSHEY_SIMPLEX color = (255, 255, 255) stroke = 1 if len(self.distances) > 0: name = "{:2.2f}".format(self.distances[min_index]) cv2.putText(frame, name, (x, y), font, 1, color, stroke, cv2.LINE_AA) return frame
# It aligns the faces from the pictures. When a picture can not be processed by # the aligner, the picture is substituted with a previously cropped picture # downloaded from the 'http://conradsanderson.id.au/lfwcrop/' website ################################################################################# # This library let's us work with hdf5 format files. import tables # Used for image processing and face detection. import cv2 # Import the necessary packages for face aligning import dlib from align import AlignDlib # Initialize the OpenFace face alignment utility alignment = AlignDlib('shape_predictor_68_face_landmarks.dat') # Creating the HDF5 file. img_dtype = tables.UInt8Atom() data_shape = (0, 64, 64) hdf5_path = 'dataset_lfw.hdf5' hdf5_write = tables.open_file(hdf5_path, mode='w') storage = hdf5_write.create_earray(hdf5_write.root, 'images', img_dtype, shape=data_shape) # Defining lists needed for the algorithm y_labels = [] y_storage = [] x_images = [] # Load the dataset made by the 'setMaker.py' program hdf5_path = 'dataset_lfw_set.hdf5'
metadata = load_metadata('images') # Creating CNN model nn4_small2_pretrained = create_model() print('1. Model Created Successfully') #Loading pre-trained weights nn4_small2_pretrained.load_weights('weights/nn4.small2.v1.h5') print('2. Weights Loaded Successfully') # Initialize the OpenFace face alignment utility alignment = AlignDlib('models/landmarks.dat') print('3. Openface utility intialized Successfully') #Generating the embedding for dataset images embedded = np.zeros((metadata.shape[0], 128)) for i, m in enumerate(metadata): img = load_image(m.image_path()) img = align_image(img) # scale RGB values to interval [0,1] img = (img / 255.).astype(np.float32) # obtain embedding vector for image
""" Created on Sat Dec 14 00:01:58 2019 @author: Bharath """ import cv2 import numpy as np import matplotlib.patches as patches import matplotlib.pyplot as plt from align import AlignDlib import dlib from model import create_model import os alignment = AlignDlib('shape_predictor_68_face_landmarks.dat') face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') nn4_small2_pretrained = create_model() nn4_small2_pretrained.load_weights('weights/nn4.small2.v1.h5') def distance(emb1, emb2): return np.sum(np.square(emb1 - emb2)) embeddeds = np.zeros((128, 1)) for filename in os.listdir('employees'): print(filename) img_path = 'employees/' + filename
def findd(): import cv2 import matplotlib.pyplot as plt import matplotlib.patches as patches import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' import PIL.Image as Image import numpy as np from model import create_model from keras import backend as K import tensorflow as tf from align import AlignDlib from keras import backend as K tf.keras.backend.clear_session() K.clear_session() alignment = AlignDlib('models/landmarks.dat') # img= load_image('E:\\projectImplementation\\projectFiles\\imageee.png') img = cv2.imread('E:\\projectImplementation\\projectFiles\\imageee.png', 1) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) bb = alignment.getLargestFaceBoundingBox(img) im_aligned = alignment.align(96, img, bb, landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) anjani = np.load('anjani.npy') aman = np.load('aman.npy') rapaka = np.load('rapaka.npy') akc = np.load('akc.npy') abhi = np.load('abhishek.npy') hemanth = np.load('hemanth.npy') subham = np.load('subham.npy') vivek = np.load('vivek.npy') nn4_small2_pretrained = create_model() nn4_small2_pretrained.load_weights('nn4.small2.v1.h5') im_aligned = (im_aligned / 255.).astype(np.float32) im_aligned = np.expand_dims(im_aligned, axis=0) embedded = nn4_small2_pretrained.predict(im_aligned)[0] # print(embedded) # tf.keras.backend.clear_session() # K.clear_session() distances = [] distances.append(np.linalg.norm(embedded - anjani)) distances.append(np.linalg.norm(embedded - abhi)) distances.append(np.linalg.norm(embedded - subham)) distances.append(np.linalg.norm(embedded - rapaka)) distances.append(np.linalg.norm(embedded - hemanth)) distances.append(np.linalg.norm(embedded - aman)) distances.append(np.linalg.norm(embedded - akc)) fin = min(distances) if (fin == distances[0]): return "Anjani" if (fin == distances[1]): return "Abhishek" if (fin == distances[2]): return "Subham" if (fin == distances[3]): return "Rapaka" if (fin == distances[4]): return "Hemanth" if (fin == distances[5]): return "Aman" if (fin == distances[6]): return "Akshay"
import cv2 import matplotlib.pyplot as plt import matplotlib.patches as patches import os from align import AlignDlib # img_path = 'images/Arnold_Schwarzenegger/Arnold_Schwarzenegger_0002.jpg' # img_path = 'data/n000149/0391_01.jpg' path = 'vggface2_test/test' faces = os.listdir(path) out_path = 'vggface2_test/aligned/' # Initialize the OpenFace face alignment utility alignment = AlignDlib('models/landmarks.dat') for face in faces: os.system('mkdir ' + out_path+face) pics = os.listdir(path+face) for pic in pics: img = cv2.imread(path+face+'/'+pic, 1) bb = alignment.getLargestFaceBoundingBox(img) # img_aligned = alignment.align(96, img, bb, landmarkIndices=AlignDlib.OUTER_EYES_AND_NOSE) if img_aligned is not None: cv2.imshow('img',img) cv2. # cv2.imwrite(out_path+face+'/'+pic, img_aligned) print(pic)