class Video_Reader:
def __init__(self):
self._mtcnn_file = '/media/nas2/Deepfakedeetectionchallenge/mtcnn-0.1.0-py3-none-any.whl'
self._THRESHOLD = 0.9
self._interpolate_FLAG = 1
self._detector = MTCNN()
self._output_path = '/media/nas2/Shengbang/DFDC_CNN_LSTM_DATA/'
def extract_frames_from_video(self, filename, num_frame, display=False):
pass
def extract_faces_from_video(self, filename, interpolate_scale, num_frame, face_size=150, display=False, return_faces=True):
# input: filename, interpolate scale you want, number of frame you want.
# output: frame_list, output bounding box.
#start_time = time.process_time()
if(interpolate_scale!=1):
self._interpolate_FLAG = interpolate_scale
if(filename[-4:]!= '.mp4'):
raise ValueError("Input must be a mp4 file.")
cap = cv2.VideoCapture(filename)
x_list = []
y_list = []
w_list = []
h_list = []
frame_list = []
if(cap.isOpened()==False):
return 0,0,0,0,0
for ii in range(num_frame):
ret, old_frame = cap.read()
if(ret == False):
return 0,0,0,0,0
frame = cv2.cvtColor(old_frame, cv2.COLOR_BGR2RGB)
frame_list.append(frame)
if(ii % int(num_frame / interpolate_scale) == 0 or ii == (num_frame - 1)):
faces = self._detector.detect_faces(frame)
# Two situation that we don't want this video
if (faces == []):
print('no face found')
#end_time = time.process_time()
#print('Time: ', end_time - start_time)
return 0,0,0,0,0
sorted(faces, key=lambda i: i['confidence'], reverse=True)
if faces[0]['confidence'] < self._THRESHOLD:
print('Fail to find a face')
#end_time = time.process_time()
#print('Time: ', end_time - start_time)
return 0,0,0,0,0
x,y,w,h=faces[0]['box']
x_list.append(x + w/2)
y_list.append(y + h/2)
w_list.append(w)
h_list.append(h)
cap.release()
output_x = list(range(num_frame))
output_y = list(range(num_frame))
output_x = self.cubic_interpolation(x_list, num_frame)
output_y = self.cubic_interpolation(y_list, num_frame)
w = np.mean(w_list)
h = np.mean(h_list)
# Display faces:
if(return_faces==True):
face_list = []
for ii, frame in enumerate(frame_list):
x = output_x[ii]
y = output_y[ii]
#face_list.append(frame[int(y-face_size/2):int(y+face_size/2), int(x-face_size/2):int(x+face_size/2)])
face_reg = frame[int(y-h/2):int(y+h/2), int(x-h/2):int(x+h/2)]
if(y<h/2 or x<h/2 or face_reg.shape[0]!=face_reg.shape[1] or face_reg.shape.count(0)>0):
print("ROI too big.", face_reg.shape)
return 0,0,0,0,0
#face_reg = cv2.cvtColor(face_reg, cv2.COLOR_RGB2GRAY)
face_reg = cv2.resize(face_reg, (299, 299))
face_list.append(face_reg)
if(display==True):
print('face region size: w:',w,'h:',h)
for face in face_list:
plt.figure()
plt.imshow(face)
plt.show()
plt.close()
#end_time = time.process_time()
#print('Time: ', end_time - start_time)
return face_list, output_x, output_y, w, h
else:
if(display==True):
print('face region size: w:',w,'h:',h)
for ii, frame in enumerate(frame_list):
x = output_x[ii]
y = output_y[ii]
cv2.rectangle(frame, (x-int(w/2), y-int(h/2)), (x+int(w/2), y+int(h/2)), (255, 255, 255), 10)
plt.figure()
plt.imshow(frame)
plt.show()
plt.close()
#end_time = time.process_time()
#print('Time: ', end_time - start_time)
return frame_list, output_x, output_y, w, h
def cubic_interpolation(self, input_list, length, show_spline=False):
# get scale info from output list.
input_array = np.array(input_list)
scale = int(length / (len(input_list) - 1))
x = np.array([i * scale for i in range(len(input_list))])
b_n = interpolate.make_interp_spline(x, input_array)
output_list = []
for ii in range(length):
output_list.append(int(b_n(ii)))
if(show_spline==True):
plt.plot([i * scale for i in range(len(input_list))], input_list)
plt.plot(range(len(output_list)), output_list)
plt.show()
return output_list
def set_face_detector_threshold(self, threshold):
self._THRESHOLD = threshold
def get_output_path(self):
return self._output_path
TRAIN_FAKE_DMAP_FOLDER = MAIN_PATH + 'train_fake_dmap'
IMG_PERCENT_PIXEL_THRESHOLD = 0.2
IMG_NOISE_THRESHOLD = 20
IMG_FORMAT = '.png'
#width = 300
#height = 300
ex = 0
video_frame_jump_fake = 10
video_frame_jump_real = 10
video_frame_jump_original = 10
# load detector
detector = MTCNN()
# Train Main Path
for k in range(1):
TRAIN_SUB_FOLDER = 'dfdc_train_part_' + str(k)
print(
f"Train samples: {len(os.listdir(os.path.join(TRAIN_FOLDER,TRAIN_SUB_FOLDER)))}"
)
train_list = list(os.listdir(os.path.join(TRAIN_FOLDER, TRAIN_SUB_FOLDER)))
ext_dict = []
for file in train_list:
file_ext = file.split('.')[1]
if (file_ext not in ext_dict):
from keras.preprocessing.image import img_to_array
import cv2
from keras.models import load_model
import numpy as np
from mtcnn import MTCNN
import json
detector = MTCNN()
# parameters for loading data and images
emotion_model_path = 'model/_mini_XCEPTION.102-0.66.hdf5'
# loading models
emotion_classifier = load_model(emotion_model_path, compile=False)
#emotion
EMOTIONS = [
"angry", "disgust", "scared", "happy", "sad", "surprised", "neutral"
]
def predict_emotion(face):
roi = cv2.resize(face, (64, 64))
roi = roi.astype("float") / 255.0
roi = img_to_array(roi)
roi = np.expand_dims(roi, axis=0)
preds = emotion_classifier.predict(roi)[0]
return dict((key, float(value)) for (key, value) in zip(EMOTIONS, preds))
def get_emotion(image):
r = detector.detect_faces(image)
"--update",
help="whether perform update the facebank",
action="store_true")
parser.add_argument("-tta",
"--tta",
help="whether test time augmentation",
action="store_true")
parser.add_argument("-c",
"--score",
help="whether show the confidence score",
action="store_true")
args = parser.parse_args()
conf = get_config(False)
mtcnn = MTCNN()
print('arcface loaded')
learner = face_learner(conf, True)
learner.threshold = args.threshold
if conf.device.type == 'cpu':
learner.load_state(conf, 'cpu_final.pth', True, True)
else:
learner.load_state(conf, 'final.pth', True, True)
learner.model.eval()
print('learner loaded')
if args.update:
targets, names = prepare_facebank(conf, learner.model, mtcnn, tta=args.tta)
print('facebank updated')
else:
class FaceDAndR:
def __init__(self):
self.detector = MTCNN()
self.vggface = VGGFace(model='resnet50',
include_top=False,
input_shape=(224, 224, 3),
pooling='avg')
def getCentroid(self, bbox):
cX = int((bbox[0] + bbox[2]) / 2.0)
cY = int((bbox[1] + bbox[3]) / 2.0)
return np.array((cX, cY))
def getDist(self, p1, p2):
return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
def rectInsideRect(self, r1, r2, thresh=32):
return r1[0] + thresh > r2[0] and r1[2] - thresh < r2[
2] and r1[1] + thresh > r2[1] and r1[3] - thresh < r2[3]
def extractFacesAndAssignToPeople(self,
frame,
bboxes,
ids,
cents,
requiredSize=(224, 224),
drawOnFrame=True):
results = self.detector.detect_faces(frame)
bboxes = bboxes.copy() #poping from these to improve performance
ids = ids.copy() #poping
cents = cents.copy() #poping
faces = []
for result in results:
x1, y1, width, height = result['box']
x2, y2 = x1 + width, y1 + height
face = frame[y1:y2, x1:x2]
#image = Image.fromarray(face)
#calculate distance
#find the closest
#check if it fits
#if it fits, remove and assign this face id of the person
centroid = self.getCentroid([x1, y1, x2, y2])
dist = [self.getDist(c, centroid) for c in cents]
if (len(dist) <= 0):
continue
ix = dist.index(min(dist))
_rect = bboxes[ix]
if not self.rectInsideRect([x1, y1, x2, y2], _rect):
continue
try:
image = cv2.resize(face, requiredSize)
_id = ids[ix]
face_array = np.asarray(image)
#adding embds too
embd = self.getEmbedding(face_array)
faces.append((face_array, (x1, y1, x2, y2), _id, embd))
ids.pop(ix)
cents.pop(ix)
bboxes.pop(ix)
except:
print("face size isn't fit for the model")
#draw
if drawOnFrame:
cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 255, 0), 3)
text = "ID:" + str(_id)
cv2.putText(frame, text, (x1, y1), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 255, 0), 2)
#image = image.resize(requiredSize)
return faces
def extractFaces(self, frame, requiredSize=(224, 224), drawOnFrame=True):
results = self.detector.detect_faces(frame)
faces = []
for result in results:
x1, y1, width, height = result['box']
x2, y2 = x1 + width, y1 + height
face = frame[y1:y2, x1:x2]
#image = Image.fromarray(face)
#draw
if drawOnFrame:
cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 255, 0), 3)
#image = image.resize(requiredSize)
try:
image = cv2.resize(face, requiredSize)
face_array = np.asarray(image)
faces.append((face_array, (x1, y1, x2, y2)))
except:
print("face size isn't fit for the model")
return faces
def getEmbedding(self, face):
samples = np.expand_dims(face, 0)
samples = (samples.astype('float64'))
# prepare the face for the model, e.g. center pixels
samples = preprocess_input(samples, version=2)
yhat = self.vggface.predict(samples)
return yhat
def is_match(self, emb1, emb2, thresh=0.39):
score = cosine(emb1, emb2)
#print(score)
if score <= thresh:
#print('>face is a Match (%.3f <= %.3f)' % (score, thresh))
return True
else:
#print('>face is NOT a Match (%.3f > %.3f)' % (score, thresh))
return False
class MxnetController:
def __init__(self):
self.detector = MTCNN()
self.embedding_model = self.get_embedding_model(
INSIGHT_MODEL_PATH, "fc1")
print('Embedding model loaded')
def calculate_score(self, emb1, emb2):
total_score = CosineSimilarity(emb1, emb2)
total_score -= MIN_COSINE_SIMILARITY
total_score /= (MAX_COSINE_SIMILARITY - MIN_COSINE_SIMILARITY)
total_score *= 100
total_score = 100 - total_score
return total_score
def calculate_embedding(self, image):
#detect for face
detect_result = self.detector.detect_faces(image)
for result in detect_result:
# print(type(result))
if result['confidence'] > DETECTION_SCORE_THRESHOLD:
# print(result)
bbox = np.array(result['box'])
bbox[bbox < 0] = 0
landmarks = format_landmarks(result['keypoints'])
image = preprocess(image,
bbox,
landmarks,
image_size=IMAGE_SIZE_STR)
embedding = self.get_embedding(image)
return embedding
def get_embedding(self, nimg):
nimg = cv2.cvtColor(nimg, cv2.COLOR_BGR2RGB)
nimg = np.transpose(nimg, (2, 0, 1))
embedding = self.get_feature(self.embedding_model, nimg).reshape(1, -1)
return embedding
def get_feature(self, emb_model, aligned):
input_blob = np.expand_dims(aligned, axis=0)
data = mx.nd.array(input_blob)
db = mx.io.DataBatch(data=(data, ))
emb_model.forward(db, is_train=False)
embedding = emb_model.get_outputs()[0].asnumpy()
embedding = preprocessing.normalize(embedding).flatten()
return embedding
def get_embedding_model(self,
model_str,
layer,
ctx=mx.cpu(),
image_size=(112, 112)):
_vec = model_str.split(',')
prefix = _vec[0]
epoch = int(_vec[1])
print('loading', prefix, epoch)
sym, arg_params, aux_params = mx.model.load_checkpoint(prefix, epoch)
all_layers = sym.get_internals()
sym = all_layers[layer + '_output']
emb_model = mx.mod.Module(symbol=sym, context=ctx, label_names=None)
emb_model.bind(data_shapes=[('data', (1, 3, image_size[0],
image_size[1]))])
emb_model.set_params(arg_params, aux_params)
return emb_model
class MTCNN_tf:
def __init__(self, threshold=[0.7], verbose=0):
self.threshold = threshold
self.detector = MTCNN()
self.verbose = verbose
def detect_faces_cv2(self, img):
pixels = np.uint16(img)
results = self.detector.detect_faces(pixels)
faces = []
bounds = []
confidences = []
for result in results:
if result['confidence'] >= self.threshold[-1]:
x1, y1, width, height = result['box']
x2, y2 = x1 + width, y1 + height
x1 = max(x1, 0)
y1 = max(y1, 0)
x2 = min(x2, pixels.shape[1] - 1)
y2 = min(y2, pixels.shape[0] - 1)
face = pixels[y1:y2, x1:x2].copy()
if face.shape[0] > 0 and face.shape[1] > 0:
faces.append(face)
bounds.append((x1, x2, y1, y2))
confidences.append(result['confidence'])
pixels = cv2.rectangle(pixels, (x1, y1), (x2, y2),
(255, 0, 0), 5)
return pixels, bounds, confidences, faces
def detect_faces_polys(self, path):
img = cv2.imread(path)
cv2_image, bounds, confidences, faces = self.detect_faces_cv2(img)
if self.verbose > 0:
plt.imshow(cv2.cvtColor(cv2_image, cv2.COLOR_BGR2RGB))
plt.show()
eq_bounds = []
for bound in bounds:
x1, x2, y1, y2 = bound
x1, x2 = min([x1, x2]), max([x1, x2])
y1, y2 = min([y1, y2]), max([y1, y2])
points = []
points.append((int(x1), int(y1)))
points.append((int(x2), int(y1)))
points.append((int(x2), int(y2)))
points.append((int(x1), int(y2)))
#points = adjust_bounds(points, equ._img.shape[1])
eq_bounds = eq_bounds + [points]
adj_bounds = [
adjust_bounds(eq_bound.copy(), img.shape[1])
for eq_bound in eq_bounds
]
polys = [
geometry.Polygon(adj_bound).buffer(0) for adj_bound in adj_bounds
]
return eq_bounds, adj_bounds, polys, confidences, faces
from mtcnn import MTCNN
import cv2
detector = MTCNN()
resl=(1280,720)
# cam = cv2.VideoCapture(0)
cam = cv2.VideoCapture('cropped.mp4')
out = cv2.VideoWriter('out.mp4',cv2.VideoWriter_fourcc(*'mp4v'), 25,resl)
while cam.isOpened():
ret, img = cam.read()
try:
img = cv2.resize(img, resl)
rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
except:
break
faces = detector.detect_faces(rgb)
for idx,bx in enumerate(faces):
x,y,w,h = bx['box']
cv2.rectangle(img,(x,y),(w+x,h+y),(0,255,0),2)
tp = y-15 if y-15 > 15 else y+15
cv2.putText(img,str(idx+1),(x,tp),cv2.FONT_HERSHEY_SIMPLEX,0.75,(0,255,0),2,cv2.LINE_AA)
cv2.putText(img,"Count: "+str(len(faces)),(10,60),cv2.FONT_HERSHEY_SIMPLEX,2.5,(0,0,255),4,cv2.LINE_AA)
cv2.imshow('webcam', img)
out.write(img)
if cv2.waitKey(1) & 0xff == 27:
break
help="whether perform update the facebank",
action="store_true")
parser.add_argument("-tta",
"--tta",
help="whether test time augmentation",
action="store_true")
parser.add_argument("-c",
"--score",
help="whether show the confidence score",
action="store_true")
args = parser.parse_args()
conf = get_config(False)
server = "http://127.0.0.1:5000/"
mtcnn = MTCNN()
print('mtcnn loaded')
# inital camera
img = []
img.append(cv2.imread('data/input/evans/evans_p.jpg'))
img.append(cv2.imread('data/input/hermsworth/hermsworth_p.jpg'))
img.append(cv2.imread('data/input/jeremy/jeremy.jpg'))
img.append(cv2.imread('data/input/mark/mark.jpg'))
img.append(cv2.imread('data/input/olsen/olsen.jpg'))
faces = []
re_img = Image.fromarray(img[0][..., ::-1])
re_img = mtcnn.align(re_img)
tolist_face = np.array(re_img).tolist()
def main(args):
# Create folder
now = datetime.now()
dt_string = now.strftime("%d%m%Y%H%M%S")
output_loc = os.path.join(args.output_loc, dt_string)
os.mkdir(output_loc)
with tf.device('/GPU:0'):
with tf.Graph().as_default():
with tf.Session() as sess:
# Load facenet model
print('Loading feature extraction model')
facenet.load_model(args.model_path)
# Create mtcnn model
detector = MTCNN()
# Create model classifer
model, class_names = load_model_classfier(
args.model_classfier_path)
# Read video
cap = cv2.VideoCapture(args.input_video)
# Get fpt from video
fps = cap.get(cv2.CAP_PROP_FPS)
# Get frame information
if args.frame_skip == 0:
frame_skip = int(fps)
else:
frame_skip = args.frame_skip
frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
frame_number = 0
# Not finding an exact face
# Create folder images for export video
if args.export_video:
images_video_dir = os.path.join(output_loc, 'images')
os.mkdir(images_video_dir)
count = frame_skip
print('Processing video...')
with tqdm(total=(frame_count), file=sys.stdout) as pbar:
while cap.isOpened():
# Extract the frame
ret, frame = cap.read()
if ret == True:
frame_number += 1
if frame_number == 1 or frame_number == count:
# Face Detection
detect_face(frame, args.id, frame_number,
frame_count, fps,
(model, class_names), output_loc,
detector, sess, args.export_video,
args.threshold)
count += frame_skip
elif args.export_video:
img_path = f'{images_video_dir}/{frame_number}.jpg'
cv2.imwrite(img_path, frame)
else:
break
pbar.update(1)
cap.release()
print('Successful write .txt file')
# Export video
if args.export_video:
print('Rendering video...')
out_video(images_video_dir, args.input_video, output_loc,
fps)
print('Successful export .mp4 file: ')
def main(_argv):
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu
logger = tf.get_logger()
logger.disabled = True
logger.setLevel(logging.FATAL)
set_memory_growth()
cfg = load_yaml(FLAGS.cfg_path)
model = ArcFaceModel(size=cfg['input_size'],
backbone_type=cfg['backbone_type'],
training=False)
ckpt_path = tf.train.latest_checkpoint('./checkpoints/' + cfg['sub_name'])
if ckpt_path is not None:
print("[*] load ckpt from {}".format(ckpt_path))
model.load_weights(ckpt_path)
else:
print("[*] Cannot find ckpt from {}.".format(ckpt_path))
exit()
if FLAGS.img_path:
print("Check Start!!!")
file_dir = "C:/Users/smgg/Desktop/dataset/superjunior/all3.jpeg"
npy_dir = "/SCLab/newTWICE_id/*,npy"
img_list = glob.glob(file_dir)
npy_list = glob.glob(npy_dir)
for img_name in img_list:
img = cv2.cvtColor(cv2.imread(img_name), cv2.COLOR_BGR2RGB)
detector = MTCNN()
data_list = detector.detect_faces(img)
for data in data_list:
xmin, ymin, width, height = data['box']
xmax = xmin + width
ymax = ymin + height
face_image = img[ymin:ymax, xmin: xmax, :]
face_image = cv2.cvtColor(face_image, cv2.COLOR_RGB2BGR)
# cv2.imshow('', face_image)
# cv2.waitKey(0)
img_resize = cv2.resize(face_image, (cfg['input_size'], cfg['input_size']))
img_resize = img_resize.astype(np.float32) / 255.
if len(img_resize.shape) == 3:
img_resize = np.expand_dims(img_resize, 0)
embeds = l2_norm(model(img_resize))
i = 0
cv2.rectangle(img, (xmin, ymin), (xmax, ymax), (0, 255, 0), 1)
for npy_name in npy_list:
name_embeds = np.load(npy_name)
# print(1)
if distance(embeds, name_embeds,1) < 0.37:
i = i + 1
name = npy_name.split('/')[5].split('\\')[1].split('.npy')[0]
cv2.putText(img, name, (xmin, ymin - 15*(i)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1,cv2.LINE_AA)
# else:
# cv2.putText(img, "Unknown", (xmin, ymin - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 1, cv2.LINE_AA)
# cv2.rectangle(img, (xmin, ymin), (xmax, ymax), (0, 255, 0), 1)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
cv2.imshow('', img)
cv2.waitKey(0)
scaled.append((np.array((Image.fromarray(frame)).resize(
(112, 96), Image.BILINEAR)) - 127.5) / 128)
return scaled
parser = argparse.ArgumentParser(description='PyTorch sphereface video')
parser.add_argument('--img', default='images', type=str)
parser.add_argument('--model',
'-m',
default='sphere20a_20171020.pth',
type=str)
parser.add_argument('--video', '-v', default='sample.mp4', type=str)
parser.add_argument('--embed', '-e', default='false', type=str)
args = parser.parse_args()
detector = MTCNN()
model = sphere20a()
model.load_state_dict(torch.load(args.model))
model.feature = True
emb_path = "embeddings"
img_path = args.img
if (args.embed == "true"):
embed_imgs(img_path, model, detector)
#resnet = InceptionResnetV1(pretrained='vggface2').eval()
#mtcnn = mtcn(keep_all=True)
v_cap = cv2.VideoCapture(args.video)
v_len = int(v_cap.get(cv2.CAP_PROP_FRAME_COUNT))
img_array = []
for count in range(v_len):
from model import Backbone, Arcface, MobileFaceNet, Am_softmax, l2_norm
from torchvision import transforms as trans
import PIL.Image as Image
from mtcnn import MTCNN
import torch
import cv2
import os
img_root_dir = '../img_align_celeba'
save_path = '../celeba_64'
device = torch.device('cuda:0')
mtcnn = MTCNN()
model = Backbone(50, 0.6, 'ir_se').to(device)
model.eval()
model.load_state_dict(torch.load('./saved_models/model_ir_se50.pth'))
# threshold = 1.54
test_transform = trans.Compose(
[trans.ToTensor(),
trans.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
# decoder = libnvjpeg.py_NVJpegDecoder()
ind = 0
embed_map = {}
for root, dirs, files in os.walk(img_root_dir):
files_len = len(files)
for idx, name in enumerate(files):
def __init__(self):
self._mtcnn_file = '/media/nas2/Deepfakedeetectionchallenge/mtcnn-0.1.0-py3-none-any.whl'
self._THRESHOLD = 0.9
self._interpolate_FLAG = 1
self._detector = MTCNN()
self._output_path = '/media/nas2/Shengbang/DFDC_CNN_LSTM_DATA/'
def __init__(self, logger=None):
self._logger = logger or getLogger(__name__)
self._detector = MTCNN()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import cv2
from mtcnn import MTCNN
import os
import glob
img_dir = "hkm/"
results_dir = img_dir + "results/"
detector = MTCNN()
files = []
for file in glob.glob(img_dir + "*.jpg"):
files.append(os.path.basename(file))
for file in files:
print("detecting files: " + file)
image = cv2.cvtColor(cv2.imread(img_dir + file), cv2.COLOR_BGR2RGB)
result = detector.detect_faces(image)
for i in result:
# Result is an array with all the bounding boxes detected. We know that for 'ivan.jpg' there is only one.
bounding_box = i['box']
keypoints = i['keypoints']
cv2.rectangle(image, (bounding_box[0], bounding_box[1]),
(bounding_box[0] + bounding_box[2],
bounding_box[1] + bounding_box[3]), (0, 155, 255), 2)
"""
This code will take care of surveillance.
"""
# pylint: disable=E1101
# pylint: disable=E0211
# pylint: disable=W0603
import datetime
import threading
import cv2
from mtcnn import MTCNN
from flask import Response, Flask, render_template
OUTPUT_IMAGE, LOCK, VIDEO_STREAM = None, threading.Lock(), cv2.VideoCapture(0)
DETECTOR = MTCNN()
APP = Flask(__name__, template_folder="frontend")
class Surveillance:
"""
This class contains all the methods of surveillance.
"""
@APP.route("/")
def index():
"""
Index page which will be hit when you open base URL.
"""
return render_template("index.html")
@classmethod
import numpy as np
import matplotlib.pyplot as plt
from mtcnn import MTCNN
from tensorflow.keras import models
# read image
if len(sys.argv) > 1:
img = plt.imread(sys.argv[1])
else:
img = plt.imread("images/facemask1.jpg")
#
# Face Detection : MTCNN
#
detector = MTCNN()
faces = detector.detect_faces(img)
# find bounding box of each face (with confidence>90%)
bbox = []
for face in faces:
box = face['box']
print(box)
keypoints = face['keypoints']
print(keypoints)
confidence = face['confidence']
print(confidence)
print()
if confidence >= 0.9: # check confidence > 90%
bbox.append(box)
def __init__(self):
self.detector = MTCNN()
self.embedding_model = self.get_embedding_model(
INSIGHT_MODEL_PATH, "fc1")
print('Embedding model loaded')
class FaceRecognition:
def __init__(self,block_size):
self.desc=Calculator(block_size)
self.detector=MTCNN()
def predictPath(self, path, model):
image=cv2.imread(path,0)
hist = self.desc.calc_hist(image[40:-70, 120:-180])
hist = np.array(hist)
prediction = model.predict(hist.reshape(1, -1))
return prediction
def predictImg(self,img,model): # Input : Gray Image; Output : Face Prediction
#image=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
hist = self.desc.calc_hist(img)
hist = np.array(hist)
prediction = model.predict(hist.reshape(1, -1))
return prediction
def find_face(self,img): # Input : BGR Image; Output : GRAY Image with bounded faces and resized to 360x480
imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
faces = self.detector.detect_faces(imgRGB)
if len(faces)==0:
return np.asarray([0,0,0])
i = 0
memo = {}
for face in faces:
key = "Face" + str (i)
x1, y1, w1, h1 = face['box']
# cv2.rectangle(imgRGB, (x1, y1), (x1 + w1, y1 + h1), (0, 255, 0), 3)
memo[key] = [x1, y1, w1, h1]
#memo.add (key, [x1, y1, w1, h1])
#imgRGB = imgRGB[y1:y1 + h1, x1:x1 + w1, :]
#imgfinal = cv2.cvtColor(imgRGB, cv2.COLOR_RGB2GRAY)
i += 1
##break
#imgfinal=cv2.resize(imgfinal,(360,480))
return memo
#return imgfinal
def captureData(self,path):
counter=0
i = 0
cap = cv2.VideoCapture(0,cv2.CAP_DSHOW)
while True:
ret, img = cap.read()
if counter%7==0:
imgFinal = self.find_face(img)
if not imgFinal is None:
filename=str(i)+'.jpeg'
cv2.imwrite(os.path.join(path,filename),imgFinal)
i += 1
print('No. of images : '+ str(i))
if cv2.waitKey(1) & 0xFF == ord('q'):
break
counter+=1
def trainRecognizer(self, trainPath, printAcc, testPath = None):
data = []
labels = []
print('Extracting Features.....')
for imageFolder in os.listdir(trainPath):
imagePath = os.path.join(trainPath, imageFolder)
for trainImg in os.listdir(imagePath):
image = cv2.imread(os.path.join(imagePath, trainImg))
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#print(gray[50:-70,130:-170].shape)
hist = self.desc.calc_hist(gray)
labels.append(int(imageFolder[-1]))
data.append(hist)
print("Processed folder " + imageFolder)
if imageFolder == "Subject09":
break
print('Completed Feature Extraction!')
print('Training Classifier.......')
temp = list(zip(data, labels))
random.shuffle(temp)
data, labels = zip(*temp)
model = KNeighborsClassifier(n_neighbors=1)
model.fit(data, labels)
print('Done Training')
if printAcc:
correct = 0
total = 0
print('Calculating accuracy....')
for imageFolder in os.listdir(testPath):
imagePath = os.path.join(testPath, imageFolder)
for testImg in os.listdir(imagePath):
image = cv2.imread(os.path.join(imagePath, testImg))
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
hist = self.desc.calc_hist(gray)
hist = np.array(hist)
prediction = model.predict(hist.reshape(1, -1))
total += 1
if prediction == int(imageFolder[-1]):
correct += 1
print("Done "+imageFolder)
tempacc = (correct/total)*100
print("Total : "+str(total)+" Correct : "+str(correct)+" Accuracy : "+str(tempacc))
if imageFolder == "Subject09":
break
acc = (correct/total)*100
print('Accuracy on test set is : '+str(acc)+'%')
return model
def __init__(self, threshold=[0.7], verbose=0):
self.threshold = threshold
self.detector = MTCNN()
self.verbose = verbose
def __init__(self,block_size):
self.desc=Calculator(block_size)
self.detector=MTCNN()
import dlib
import numpy as np
import cv2
import os
import glob
import imutils
import shutil
from mtcnn import MTCNN
path = "/home/whirldata/Documents/19.10.2019/DSC_0502.JPG"
img = cv2.imread(path)
face_detector = MTCNN()
# img = adjust_gamma(img)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# img = adjust_gamma(img)
# img = cv2.cvtColor(img,cv2.COLOR_YCrCb2RGB)
face_info = face_detector.detect_faces(img)
for i in face_info:
x, y, width, height = i["box"]
cv2.rectangle(img, (x, y), (x + width, y + height), (255, 0, 233), 3)
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
cv2.imwrite("face_detection.jpg", img)
print("Success")
def load_mtcnn_model(model_path):
mtcnn = MTCNN(model_path)
return mtcnn
def __init__(self):
self.detector = MTCNN()
self.vggface = VGGFace(model='resnet50',
include_top=False,
input_shape=(224, 224, 3),
pooling='avg')
def predict():
input_shape = (160, 160, 3)
mtcnn = MTCNN()
# 영상 불러오기
videos_path = 'test1.mp4'
vid_name = videos_path.split('/')[-1].split('.')[0]
# 프레임으로 나눠서 저장
cap = cv2.VideoCapture(videos_path)
frame = 0
detect_face_num = 0
heat_images = []
# def get_face_coord(img):
pred = 0
while (cap.isOpened()):
if frame == 10 or detect_face_num > 1:
break
ret, img = cap.read()
if ret == False:
break
# 얼굴 detect
face = mtcnn.detect_faces(img)
# 얼굴 없으면 다음 프레임
if not face:
continue
# 얼굴 위치
x1, y1, w, h = face[0]['box']
x2 = min(x1 + w, img.shape[1])
y2 = min(y1 + h, img.shape[0])
x1 = max(x1, 0)
y1 = max(y1, 0)
# 이미지 자르기
crop_img = img[y1:y2, x1:x2]
crop_img = cv2.resize(crop_img, (160, 160))
# 얼굴위치 저장
before_face_img_coord = [y1, y2, x1, x2]
detect_face_num += 1
# 이미지 전처리 및 예측
img_tensor = (crop_img.flatten() / 255.0).reshape(-1, 160, 160, 3)
#img_tensor = np.expand_dims(crop_img, axis=0)
#print(img_tensor.shape)
pred += model.predict(img_tensor)[0][1]
# 프레임 가져와서 히트맵 표시
conv_layer = model.get_layer("conv_7b")
heatmap_model = models.Model([model.inputs],
[conv_layer.output, model.output])
# # Get gradient of the winner class w.r.t. the output of the (last) conv. layer
with tf.GradientTape() as gtape:
conv_output, predictions = heatmap_model(img_tensor)
loss = predictions[:, np.argmax(predictions[0])]
grads = gtape.gradient(loss, conv_output)
pooled_grads = K.mean(grads, axis=(0, 1, 2))
heatmap = tf.reduce_mean(tf.multiply(pooled_grads, conv_output),
axis=-1)
heatmap = np.maximum(heatmap, 0)
max_heat = np.max(heatmap)
if max_heat == 0:
max_heat = 1e-10
heatmap /= max_heat
img = crop_img
# print(img)
heatmap2 = cv2.resize(heatmap, (img.shape[1], img.shape[0]))
heatmap2 = np.uint8(255 * heatmap2)
heatmap2 = cv2.applyColorMap(heatmap2, cv2.COLORMAP_JET)
hif = .5
superimposed_img = heatmap2 * hif + img
# print(superimposed_img.shape, heatmap2.shape)
type(superimposed_img)
heat_images.append(superimposed_img.tolist())
output = f'output_{vid_name}_{detect_face_num}.jpeg'
cv2.imwrite(output, superimposed_img)
# 정확도 판별(평균)
if detect_face_num:
acc = pred / detect_face_num
else:
acc = 0
print(acc)
# 정확도, 이미지 array -> json
return jsonify(acc=acc) # ,heat_images=heat_images
def initialize_detector(detector_backend):
global face_detector
home = str(Path.home())
if detector_backend == 'opencv':
opencv_path = get_opencv_path()
face_detector_path = opencv_path+"haarcascade_frontalface_default.xml"
eye_detector_path = opencv_path+"haarcascade_eye.xml"
if os.path.isfile(face_detector_path) != True:
raise ValueError("Confirm that opencv is installed on your environment! Expected path ",face_detector_path," violated.")
face_detector = cv2.CascadeClassifier(face_detector_path)
global eye_detector
eye_detector = cv2.CascadeClassifier(eye_detector_path)
elif detector_backend == 'ssd':
#check required ssd model exists in the home/.deepface/weights folder
#model structure
if os.path.isfile(home+'/.deepface/weights/deploy.prototxt') != True:
print("deploy.prototxt will be downloaded...")
url = "https://github.com/opencv/opencv/raw/3.4.0/samples/dnn/face_detector/deploy.prototxt"
output = home+'/.deepface/weights/deploy.prototxt'
gdown.download(url, output, quiet=False)
#pre-trained weights
if os.path.isfile(home+'/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel') != True:
print("res10_300x300_ssd_iter_140000.caffemodel will be downloaded...")
url = "https://github.com/opencv/opencv_3rdparty/raw/dnn_samples_face_detector_20170830/res10_300x300_ssd_iter_140000.caffemodel"
output = home+'/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel'
gdown.download(url, output, quiet=False)
face_detector = cv2.dnn.readNetFromCaffe(
home+"/.deepface/weights/deploy.prototxt",
home+"/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel"
)
elif detector_backend == 'dlib':
import dlib #this is not a must library within deepface. that's why, I didn't put this import to a global level. version: 19.20.0
global sp
face_detector = dlib.get_frontal_face_detector()
#check required file exists in the home/.deepface/weights folder
if os.path.isfile(home+'/.deepface/weights/shape_predictor_5_face_landmarks.dat') != True:
print("shape_predictor_5_face_landmarks.dat.bz2 is going to be downloaded")
url = "http://dlib.net/files/shape_predictor_5_face_landmarks.dat.bz2"
output = home+'/.deepface/weights/'+url.split("/")[-1]
gdown.download(url, output, quiet=False)
zipfile = bz2.BZ2File(output)
data = zipfile.read()
newfilepath = output[:-4] #discard .bz2 extension
open(newfilepath, 'wb').write(data)
sp = dlib.shape_predictor(home+"/.deepface/weights/shape_predictor_5_face_landmarks.dat")
elif detector_backend == 'mtcnn':
face_detector = MTCNN()
"--update",
help="whether perform update the facebank",
action="store_true")
parser.add_argument("-tta",
"--tta",
help="whether test time augmentation",
action="store_true")
parser.add_argument("-c",
"--score",
help="whether show the confidence score",
action="store_true")
args = parser.parse_args()
conf = get_config(False)
mtcnn = MTCNN()
print('mtcnn loaded')
learner = face_learner(conf, True)
learner.threshold = args.threshold
if conf.device.type == 'cpu':
learner.load_state(conf, 'cpu_final.pth', True, True)
else:
learner.load_state(conf, 'final.pth', True, True)
learner.model.eval()
print('learner loaded')
if args.update:
targets, names = prepare_facebank(conf,
learner.model,
mtcnn,
def get_detector():
return MTCNN()
from mtcnn import MTCNN
import cv2
import os
from PIL import ImageDraw, Image
import matplotlib.pyplot as plt
path = r"D:\BaiduNetdiskDownload\CelebA\Img\img_celeba.7z\img_celeba"
file = os.listdir(path)
img = cv2.cvtColor(cv2.imread("1.png"), cv2.COLOR_BGR2RGB)
detector = MTCNN()
data = detector.detect_faces(img)
print(data)
img = Image.fromarray(img, "RGB")
draw = ImageDraw.Draw(img)
#draw.rectangle([138, 70, 206, 260],outline="red",width=2)
draw.ellipse((176, 208, 186, 218), fill=(255, 0, 0), width=2)
draw.ellipse((295, 212, 305, 222), fill=(255, 0, 0), width=2)
plt.imshow(img)
plt.show()
