def Detection_Faces(img_path):
face_detector = FaceDetector()
img = cv2.imread(img_path)
rgb_img = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2RGB)
thresh = 0.85
bboxes = face_detector.predict(rgb_img, thresh)
return bboxes
def test(request):
# 获取 上传的 图片信息
img = request.FILES.get('img')
# 获取上传图片的名称
img_name = img.name
# 获取后缀
ext = os.path.splitext(img_name)[1]
# 加时间防止重名
now = time.time()
# 重新规定图片名称，图片类型
img_name = f'imgs{now}{ext}'
# 图片保存路径
# img_path = os.path.join(settings.IMG_ROOT, img_name)
BASE_DIR = Path(__file__).resolve().parent.parent
img_path = os.path.join(os.path.join(BASE_DIR, "imgs/input"), img_name)
# 写入 上传图片的 内容
with open(img_path, 'ab') as fp:
# 如果上传的图片非常大， 那么通过 img对象的 chunks() 方法 分割成多个片段来上传
for chunk in img.chunks():
fp.write(chunk)
face_detector = FaceDetector()
print(img_path)
img = cv2.imread(img_path)
rgb_img = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2RGB)
bboxes = face_detector.predict(rgb_img, 0.8)
ann_img = annotate_image(img, bboxes)
cv2.imwrite('C:/Users/Administrator/Desktop/HelloWorld/static/test1.png',
ann_img)
return render(request, 'face.html')
def __init__(self):
self.fa = FaceDetector()
self.fa2 = dlib.get_frontal_face_detector()
self.fa3 = cv2.dnn.readNetFromCaffe(
"./models/deploy.prototxt.txt",
"./models/res10_300x300_ssd_iter_140000.caffemodel")
self.fa4 = dlib.cnn_face_detection_model_v1(
"./models/mmod_human_face_detector.dat")
self.thresh = 0.5
def facedect(self):
face_detector = FaceDetector()
self.progressbar.setValue(0)
if self.videoname != None:
cap = cv2.VideoCapture(self.videoname)
frame_width = int(cap.get(3))
frame_height = int(cap.get(4))
filename = self.videoname
filename = filename.split('/')
filename = filename[-1].split('.')
fourcc = cv2.VideoWriter_fourcc(*'DIVX')
out = cv2.VideoWriter(
'{0}/masked_{1}.avi'.format(self.outputpath, filename[0]),
fourcc, 25.0, (frame_width, frame_height))
ret = True
i = 0
frames = []
num_frame = 0
while ret:
ret, frame = cap.read()
if ret:
frames.append(frame)
num_frame += 1
step = 1
for i, frame in enumerate(frames):
rgb_img = cv2.cvtColor(frame.copy(), cv2.COLOR_BGR2RGB)
# Receives RGB numpy image (HxWxC) and
# returns (x_center, y_center, width, height, prob) tuples.
bboxes = face_detector.predict(rgb_img, 0.8)
# Use this utils function to annotate the image.
ann_img = annotate_image(frame, bboxes)
out.write(ann_img)
if (i / num_frame * 100) - step > 0:
step += 1
print(step)
self.progressbar.setValue(step)
cap.release()
out.release()
def __init__(self):
file_paths, configs = read_config()
if Camera.detector is None:
print('[INFO] loading face detector...')
Camera.detector = FaceDetector()
if Camera.embedder is None:
# load our serialized face embedding model from disk
print('[INFO] loading embedder from {}'.format(
file_paths['embedder_path']))
Camera.embedder = cv2.dnn.readNetFromTorch(
file_paths['embedder_path'])
if Camera.recognizer is None:
# load the actual face recognition model along with the label encoder
print('[INFO] loading face recognizer from {}'.format(
file_paths['recognizer_path']))
Camera.recognizer = pickle.loads(
open('output/recognizer.pickle', 'rb').read())
if Camera.le is None:
print('[INFO] loading le from {}'.format(file_paths['le_path']))
Camera.le = pickle.loads(open('output/le.pickle', 'rb').read())
print('[INFO] Confidence value is set to {}'.format(
configs['confidence']))
Camera.confidence = float(configs['confidence'])
Camera.max_retry_count = int(configs['max_retry_count'])
class FaceTrackServer(object):
faces = []
face_locations = []
face_relative_locations = []
cam_h = None
cam_w = None
camera_address = None
def __init__(self, down_scale_factor=0.25):
assert 0 <= down_scale_factor <= 1
self.down_scale_factor = down_scale_factor
self.face_detector = FaceDetector()
def get_cam_info(self):
return {
'camera': {
'width': self.cam_w,
'height': self.cam_h,
'address': self.camera_address
}
}
def reset(self):
self.face_relative_locations = []
self.face_locations = []
self.faces = []
def process(self, frame):
self.reset()
self.cam_h, self.cam_w, _ = frame.shape
# Resize frame of video to 1/4 size for faster face recognition processing
# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_img = cv2.cvtColor(frame.copy(), cv2.COLOR_BGR2RGB)
self.face_locations = self.face_detector.predict(rgb_img)
# Display the results
if len(self.face_locations) > 1:
self.face_locations = []
for x, y, w, h, _ in self.face_locations:
# Scale back up face locations since the frame we detected in was scaled to 1/4 size
x1 = int((x - int(w / 2)) * (1 - 0.1))
y1 = int((y - int(h / 2)) * (1 - 0.1))
x2 = int((x + int(w / 2)) * (1 + 0.1))
y2 = int((y + int(h / 2)) * (1 + 0.1))
_face_area = frame[y1:y2, x1:x2, :]
if _face_area.size != 0:
self.faces.append(_face_area)
print('[FaceTracker Server] Found {} faces!'.format(len(self.faces)))
return self.faces
def get_faces_loc(self):
return self.face_locations
def get_faces(self):
return self.faces
def createFaceDetector(self):
'''Instantiate the face detection network.'''
start = datetime.now()
fdet_network = FaceDetector()
elapsed = datetime.now() - start
# Assign the attributes
self.fdet_network = fdet_network
self.t_face_det = elapsed
def process_and_encode(dataset):
print("[LOG] Collecting images ...")
images = []
for direc, _, files in tqdm(os.walk(dataset)):
for file in files:
if file.endswith("jpg"):
images.append(os.path.join(direc,file))
# initialize the list of known encodings and known names
known_encodings = []
known_names = []
print("[LOG] Encoding faces ...")
model=vggface()
vgg_face_descriptor = Model(inputs=model.layers[0].input, outputs=model.layers[-2].output)
face_detector = FaceDetector()
face_alignment_predictor = face_alignment.FaceAlignment(face_alignment.LandmarksType._2D,flip_input=False)
for image_path in tqdm(images):
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
boxes = face_detector.predict(image)
if(boxes==[]):
warnings.warn('system could not detect face in this image %s'%(image_path))
continue
(x,y,w,h,prob)=boxes[0]
#TODO align faces
x1 = int(x - w/2)
y1 = int(y - h/2)
x2 = int(x + w/2)
y2 = int(y + h/2)
part_image = image[y1:y2,x1:x2]
landmarks=face_alignment_predictor.get_landmarks(part_image)
if(landmarks!=[] and landmarks!=None):
part_image=execute_alignment(part_image,landmarks)
part_image=preprocess_image(part_image)
encoding = vgg_face_descriptor.predict(part_image)[0,:]
# the person's name is the name of the folder where the image comes from
name = image_path.split(os.path.sep)[-2]
if len(encoding) > 0 :
known_encodings.append(encoding)
known_names.append(name)
np.savez('data/encodings/encoding_vggface.npz',encodings=known_encodings,names=known_names)
return
class FADetector():
def __init__(self):
self.fa = FaceDetector()
self.fa2 = dlib.get_frontal_face_detector()
self.fa3 = cv2.dnn.readNetFromCaffe(
"./models/deploy.prototxt.txt",
"./models/res10_300x300_ssd_iter_140000.caffemodel")
self.fa4 = dlib.cnn_face_detection_model_v1(
"./models/mmod_human_face_detector.dat")
self.thresh = 0.5
#DLIB SIMPLE LANDMARK DETECTION + CPU YOLO FACE DETECTION
def cv2dnn_facedetection(self, rgb, pad=20):
h, w = rgb.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(rgb, (300, 300)), 1.0,
(300, 300), (103.93, 116.77, 123.68))
self.fa3.setInput(blob)
detections = self.fa3.forward()
#get driver bounding box based on rightmost position
rightmost = -1
for i in range(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
if confidence > 0.7 and box[0] > rightmost:
rightmost = box[0]
box = box.astype("int")
bbox = dlib.rectangle(box[0], box[1], box[2], box[3])
if rightmost == -1: return
return rgb[bbox.top():bbox.bottom(), bbox.left():bbox.right()]
#YOLO FACE DETECTION FROM https://github.com/iitzco/faced
def yolo_facedetection(self, rgb):
bbox = self.fa.predict(rgb, self.thresh)
box = bbox[0]
l = box[1] - box[2] // 2
t = box[0] - box[3] // 2
r = box[1] + box[2] // 2
b = box[0] + box[3] // 2
return rgb[t:b, l:r]
#CNN FACE DETECTION FROM DLIB
def dlibcnn_facedetection(self, rgb, save=False):
dets = self.fa4(rgb, 0)
d = dets[0]
return rgb[d.rect.top():d.rect.bottom(), d.rect.left():d.rect.right()]
def __init__(self, down_scale_factor=0.25):
assert 0 <= down_scale_factor <= 1
self.down_scale_factor = down_scale_factor
self.face_detector = FaceDetector()
def run(mode, localPath):
global font
global success
global totalInferenceDuration
print("CUDE usage status : " + str(dlib.DLIB_USE_CUDA))
#faced
face_detector = FaceDetector()
startTS = time.time()
""" Load models """
predictor_path = "assets/shape_predictor_5_face_landmarks.dat"
face_rec_model_path = "assets/dlib_face_recognition_resnet_model_v1.dat"
facerec = dlib.face_recognition_model_v1(face_rec_model_path)
sp = dlib.shape_predictor(predictor_path)
""" Check local/stream availability """
if (mode == "stream"):
# initialize the video stream and allow the cammera sensor to warmup
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
w = int(vs.get(3))
h = int(vs.get(4))
time.sleep(2.0)
elif (mode == "local"):
vidcap = cv2.VideoCapture(localPath)
success, frame = vidcap.read()
fps = vidcap.get(cv2.CAP_PROP_FPS)
frameCtr = 0
w = int(vidcap.get(3))
h = int(vidcap.get(4))
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
out = cv2.VideoWriter('output.avi', fourcc, 15, (w, h))
while success:
processStartTs = time.time()
""" Acquire the next frame """
if (mode == "stream"):
frame = vs.read()
elif (mode == "local"):
success, frame = vidcap.read()
frameCtr += 1
""" grab the frame from the threaded video stream and resize it
to have a maximum width of 400 pixels """
try:
frame = imutils.resize(frame, width=400)
except AttributeError:
continue
try:
rgb_img = cv2.cvtColor(frame.copy(), cv2.COLOR_BGR2RGB)
except:
break
inferenceStartTs = time.time()
#faced (thresh argument can be added, 0.85 by default-)
bboxes = face_detector.predict(rgb_img)
inferenceEndTs = time.time()
totalInferenceDuration += inferenceEndTs - inferenceStartTs
helpers.min_clusters = len(bboxes)
if (mode == "stream"):
timestamp = calendar.timegm(time.gmtime())
elif (mode == "local"):
timestamp = float(frameCtr / fps)
for x, y, w, h, p in bboxes:
top = int(y + h / 2)
left = int(x - w / 2)
bottom = int(y - h / 2)
right = int(x + w / 2)
cv2.rectangle(frame, (left, bottom), (right, top), (99, 44, 255),
1)
cv2.putText(frame, str(p), (left, top + 5), font, 0.2,
(255, 255, 255), 1, cv2.LINE_AA)
shape = sp(frame, dlib.rectangle(left, bottom, right, top))
# Compute the 128D vector that describes the face in img identified by
face_descriptor = facerec.compute_face_descriptor(frame, shape)
bestIndex = cluster_faces.match(face_descriptor)
if (bestIndex >= 0):
cv2.putText(frame,
str(helpers.unique_persons[bestIndex]["uuid"]),
(left, top + 10), font, 0.2, (0, 255, 255), 1,
cv2.LINE_AA)
data = [{
"uuid": helpers.unique_persons[bestIndex]["uuid"],
"timestamp": timestamp
}]
helpers.individual_stats.extend(data)
else:
cv2.putText(frame, "Learning...", (left, top + 10), font, 0.2,
(0, 255, 255), 1, cv2.LINE_AA)
data = [{
"label": 0,
"timestamp": timestamp,
"encoding": face_descriptor
}]
helpers.candidate_persons.extend(data)
try:
frame = imutils.resize(frame, width=720)
except AttributeError:
continue
cv2.putText(frame,
"FPS : " + str(int(1 / (time.time() - processStartTs))),
(20, 30), font, 1, (0, 255, 0), 3, cv2.LINE_AA, False)
out.write(frame)
#cv2.imshow("Frame", frame)
if (len(helpers.candidate_persons) >=
(helpers.MIN_FACES_PER_CLUSTER * helpers.min_clusters)):
cluster_faces.cluster()
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
# do a bit of cleanup
if (mode == "stream"):
vs.stop()
endTS = time.time()
out.release()
print("Total number of unique faces = ", len(helpers.unique_persons))
print("Total duration")
print(endTS - startTS)
print("Total inference duration")
print(totalInferenceDuration)
class FaceTrackServer(object):
face_detector = FaceDetector()
faces = []
face_locations = []
face_relative_locations = []
cam_h = None
cam_w = None
camera_address = None
def __init__(self, down_scale_factor=0.25):
assert 0 <= down_scale_factor <= 1
self.down_scale_factor = down_scale_factor
def get_cam_info(self):
return {
'camera': {
'width': self.cam_w,
'height': self.cam_h,
'address': self.camera_address
}
}
def reset(self):
self.face_relative_locations = []
self.face_locations = []
self.faces = []
def process(self, frame, called_from_encode=False):
self.reset()
self.cam_h, self.cam_w, _ = frame.shape
# Resize frame of video to 1/4 size for faster face recognition processing
small_frame = cv2.resize(frame, (0, 0),
fx=self.down_scale_factor,
fy=self.down_scale_factor)
# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_small_frame = small_frame[:, :, ::-1]
face_annotations = self.face_detector.predict(rgb_small_frame)
# Display the results
for (x, y, w, h, prob) in face_annotations:
x1 = int(x - w / 2)
y1 = int(y - h / 2)
x2 = int(x + w / 2)
y2 = int(y + h / 2)
self.face_locations.append((y1, x2, y2, x1))
for y1_sm, x2_sm, y2_sm, x1_sm in self.face_locations:
# Scale back up face locations since the frame we detected in was scaled to 1/4 size
x1 = int(x1_sm / self.down_scale_factor)
x2 = int(x2_sm / self.down_scale_factor)
y1 = int(y1_sm / self.down_scale_factor)
y2 = int(y2_sm / self.down_scale_factor)
x1_rltv = x1 / self.cam_w
x2_rltv = x2 / self.cam_w
y1_rltv = y1 / self.cam_h
y2_rltv = y2 / self.cam_h
_face_area = frame[x1:x2, y1:y2, :]
if _face_area.size == 0:
continue
self.faces.append(_face_area)
self.face_relative_locations.append(
[x1_rltv, y1_rltv, x2_rltv, y2_rltv])
# cv2.imshow('faces', frame[y1:y2, x1:x2, :])
# cv2.waitKey(0)
if (called_from_encode == False):
print('[FaceTracker Server] Found {} faces!'.format(len(
self.faces)))
return self.faces
def get_faces_loc(self, relative=True):
if relative:
return self.face_relative_locations
else:
return self.face_locations
def get_faces(self):
return self.faces
def face_finder():
fps = 12
#camera_addr="/dev/video0"
camera_ip = "10.32.89.135"
camera_addr = "rtsp://*****:*****@" + camera_ip
#camera_addr='0'
camera_addr = "/dev/video1"
print("Connecting to " + camera_ip + " ...")
vcap = cv2.VideoCapture(camera_addr)
vcap.set(20, 1) #buffer size = 1
vcap.set(
cv2.CAP_PROP_FPS,
60) #camera.fps = fps Se tiene que configurar en la camara tambien
vcap.set(cv2.CAP_PROP_FRAME_WIDTH, 720)
vcap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
#vcap.set(cv2.CV_CAP_PROP_FPS, 60)
vcap.set(15, -10)
ret, frame = vcap.read(
) #hay que leerlo una vez para poder ver sus propiedades
#print (frame.shape)
frame_size_x = vcap.get(3) #guarda el tama;o del frame
frame_size_y = vcap.get(4)
print("Succesfully connected :D")
actors = init_actors_multi()
#print('initial actors shape' + str(actors['pos'].shape))
boxes = init_boxes()
face_detector = FaceDetector()
counter = 0
centers = []
while True:
start = time.time()
vcap.grab() #leer imagen de vcap
ret, frame = vcap.retrieve(0)
boxes = np.empty([0, 4], dtype=int)
if ret: #revisa que si recibio una imagen
#print("vcap worked")
#frame_small = cv2.resize(frame, (int(frame_size_x/factor), int(frame_size_y/factor)))
frame_ann = frame
rgb_img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
bboxes = face_detector.predict(rgb_img, thresh=0.8)
#frame_ann = annotate_image(frame, bboxes)
#transform boxes into x,y,w,h starting in corner
for bb in bboxes:
x, y, w, h = bb[0:4]
x = x - w / 2
y = y - w / 2
boxes = np.vstack([boxes, [int(x), int(y), int(w), int(h)]])
#print('boxes: '+str(boxes))
actors_new = scene_multi(boxes, actors, frame_size_x, frame_size_y)
appeared = init_actors_multi()
for i in range(actors_new['id'].shape[0]):
unique = True
box = actors_new['pos'][i, 0]
center_x, center_y = get_box_center(box)
plot_traj(frame_ann, centers, center_x, center_y)
x, y, w, h = expand_box(box, 2, frame_size_x, frame_size_y)
cv2.rectangle(frame_ann, (x, y), (x + w, y + h), (0, 255, 0), 1)
for j in range(actors['id'].shape[0]):
#check if it existed already, else, append it to the appeared array
if (actors_new['id'][i] == actors['id'][j]):
unique = False
if unique:
appeared['id'] = np.vstack(
[appeared['id'], actors_new['id'][i]])
appeared['pos'] = np.vstack(
[appeared['pos'], [actors_new['pos'][i]]])
print(x, y, w, h)
face_crop = frame[y:y + h, x:x + w]
cv2.imwrite('findings/' + str(time.time()) + '.jpg', face_crop)
cv2.rectangle(frame_ann, (x, y), (x + w, y + h), (0, 255, 255),
4)
counter += 1
#print("Finding " + actors_new['id'][i][0] + ' saved')
if len(centers) > 0 and actors_new['id'].shape[0] == 0:
centers.pop(0)
try:
cv2.imshow("test", frame_ann)
except:
pass
cv2.waitKey(1)
print('appeared: ' + str(appeared['id']))
actors = actors_new
leisure_time = max(1 / fps - (time.time() - start), 0)
#print("leisure_time at " + str(fps) + "fps = " + str(leisure_time))
print("counter", counter)
time.sleep(leisure_time)
return True
from faced import FaceDetector
from faced.utils import annotate_image
# Config
webcam_index = 0 # 0 for built-in webcam, 1 for external webcam (generally)
max_face_size = 220 # based on the actual_face_size of people very close to the camera
max_x = 640 # basically the webcam frame width
max_y = 200 # max distance at which we detect people (based on the actual_face_size)
print_fps = True # print FPS to stdout
show_webcam = True
show_map = True # show a map of the people in window while running
map_width = 400
map_height = 400
face_detector = FaceDetector()
video_capture = cv2.VideoCapture(webcam_index)
fps = 0.0
while True:
ret, frame = video_capture.read() # frame shape 640*480*3
if frame.shape[0] == 0:
break
t1 = time.time()
rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# bboxes = face_detector.predict(rgb_frame, thresh)
bboxes = face_detector.predict(rgb_frame)
import cv2
import os
import sys
from faced import FaceDetector
from faced.utils import annotate_image
if len(sys.argv) < 3:
print('rutas de videos no entregadas')
exit(-1)
face_detector = FaceDetector()
DEBUG = bool(int(0 if os.getenv('DEBUG') is None else os.getenv('DEBUG')))
BLUR = int(23 if os.getenv('BLUR') is None else os.getenv('BLUR'))
FACED_ACC = float(
0.85 if os.getenv('FACED_ACC') is None else os.getenv('FACED_ACC'))
video = cv2.VideoCapture(sys.argv[1])
x_offset = 50
y_offset = 50
frame_index = 0
frame_w = int(video.get(3))
frame_h = int(video.get(4))
(major_ver, minor_ver, subminor_ver) = (cv2.__version__).split('.')
if int(major_ver) < 3:
fps = video.get(cv2.cv.CV_CAP_PROP_FPS)
print("Frames per second using video.get(cv2.cv.CV_CAP_PROP_FPS): {0}".
import os
print(os.getcwd())
os.chdir(".../faced-master/")
import cv2
from faced import FaceDetector
from faced.utils import annotate_image
from time import process_time
#___________________________________________________For Image______________________________________________________
face_detector = FaceDetector()
img = cv2.imread("face_det.jpg")
rgb_img = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2RGB)
# Receives RGB numpy image (HxWxC) and
# returns (x_center, y_center, width, height, prob) tuples.
bboxes = face_detector.predict(rgb_img, 0.7)
# Use this utils function to annotate the image.
ann_img = annotate_image(img, bboxes)
#save img
cv2.imwrite('face_detd.jpg', ann_img)
# Show the image
cv2.imshow('Result', ann_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
vcap.set(20,1)
vcap.set(5,6)
ret, frame = vcap.read() #hay que leerlo una vez para poder ver sus propiedades
print (frame.shape)
frame_size_x = vcap.get(3) #guarda el tama;o del frame
frame_size_y = vcap.get(4)
print("Succesfully connected :D")
actors={
'id':np.empty([0,1], dtype = str),
'pos':np.empty([0,4], dtype = int)
}
face_detector = FaceDetector()
while True:
ret, frame = vcap.read()
boxes = []
if ret: #revisa que si se haya recibido una imagen para que no se rompa
print("vcap worked")
frame_small = cv2.resize(frame, (int(frame_size_x/factor), int(frame_size_y/factor)))
rgb_img = cv2.cvtColor(frame_small, cv2.COLOR_BGR2RGB)
bboxes = face_detector.predict(rgb_img, thresh=0.6)
#print(bboxes)
for i in bboxes:
x,y,w,h = i[0:4]
boxes.append([x,y,w,h])
import cv2
import numpy as np
from faced import FaceDetector
from get_landmark import get_landmark
face_detector = FaceDetector() # load from faced
def getFaceCoordinate(bboxes):
"""
Return bbox from faced to face coordinate in ( x , y , x1 , y1 ) format and confidence
Parameter
-----------
bboxes: tuple
bbox from faced's predict. ( x , y , w , h , c )
Returns
-----------
coordinate: np array
[ x , y , x1 , y1 ]
confidence: float
0.00 ~ 1.00
"""
converted_bboxes = []
c = 0
for bbox in bboxes:
def _download_fec_data(tmp_dir, meta, target_shape):
nonfailed = [None for _ in range(len(meta))]
last_idx = 0
detector = FaceDetector()
detect_threshold = 0.7
# For now just download all images and consider filtering for presence
# of faces a secondary step
for i, item in enumerate(meta):
failed = False
face_data = {}
for case in ["a", "b", "c"]:
url = item[case]["url"]
# Use the URL as a filename to avoid collisions for
# different images with the same filename
filename = url.replace("/", "-")
try:
generator_utils.maybe_download(tmp_dir, filename, url)
image_path = os.path.join(tmp_dir, filename)
img = _read_image(image_path)
bounds = item[case]["bounds"]
cropped = _crop_to_fractional_xy_bbox(img, bounds)
if cropped.shape[0] != cropped.shape[1]:
failed = True
#cropped = _normalize_dimensions(cropped, target_shape)
face_data[case] = cropped
# For now this should be fine. But alternatively could
# hash the image content.
# This being to give unique filename to which to write the
# cropped image, given primary images may have multiple faces
# within them thus we will be over-writing and mixing up faces
# if we write different cropped regions of a primary image to the
# same file.
string_bounds = "-".join([str(thing) for thing in bounds])
cropped_filename = "cropped@" + string_bounds + "#" + filename
item[case]["cropped_filename"] = cropped_filename
predictions = detector.predict(cropped, detect_threshold)
has_face = len(predictions) > 0
if not has_face:
failed = True
except:
tf.logging.info("Exception case.")
failed = True
# End of for case in ["a", "b", "c"]
if not failed:
# If we have detected faces in all three cases let's build and write an
# example.
for case in ["a", "b", "c"]:
out_path = os.path.join(tmp_dir,
item[case]["cropped_filename"])
cv2.imwrite(out_path, face_data[case])
if not failed:
nonfailed[last_idx] = item
last_idx += 1
nonfailed = nonfailed[:last_idx]
nonfailed_file = os.path.join(tmp_dir, "nonfailed.json")
with tf.gfile.Open(nonfailed_file, "w") as f:
f.write(json.dumps(nonfailed))
return nonfailed
def main(mode: int = 0,
device: int = 0,
size: int = 480,
cfg: str = 'YOLOv3-cfg',
weights: str = 'YOLOv3-wider_16000.weights',
ratio: float = 1.0,
facemarks: bool = False,
mosaic: bool = False) -> None:
#
# detection algorithm [0:hog, 1:haar, 2:YOLO, 3:faced]
#
import cv2
if mode == 0:
print(f'detecting faces: dlib hog/cnn.')
elif mode == 1:
print(f'detecting faces: AdaBoost using haarcascade.')
global face_cascade
face_cascade = cv2.CascadeClassifier(
'haarcascade_frontalface_default.xml')
elif mode == 2:
print(f'detecting faces: YOLOv3.')
global YOLOnet
YOLOnet = cv2.dnn.readNetFromDarknet(cfg, weights)
YOLOnet.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
YOLOnet.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)
elif mode == 3:
print(f'detecting faces: faced(FaceDetector).')
global face_detector
face_detector = FaceDetector()
else:
print(f'detecting faces: unknown={mode}.')
return
#
# window for video capture
#
# import cv2
windowName = 'Video'
cv2.namedWindow(windowName)
# cv2.namedWindow(windowName, cv2.WINDOW_NORMAL)
cv2.setWindowProperty(windowName, cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_FULLSCREEN)
cv2.waitKey(10)
cv2.setWindowProperty(windowName, cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_NORMAL)
#
# vide capture
# Macbook12: fps=30.0, w=848.0, h=480.0
# iMac5K : fps=29.97002997002997, w=960.0, h=544.0, detecting faces: YOLOv3.
#
print(f'video capture device: {device}')
video_capture = cv2.VideoCapture(device)
if not video_capture.isOpened():
print(f'Couldnt open video file or webcam, device={device}.')
raise ImportError(
f'Couldnt open video file or webcam, device={device}.')
video_capture.set(cv2.CAP_PROP_FPS, 60) # カメラFPSを60FPSに設定
video_capture.set(cv2.CAP_PROP_FRAME_WIDTH, size) # カメラ画像の横幅を1280に設定 (640)
# video_capture.set(cv2.CAP_PROP_FRAME_HEIGHT, size) # カメラ画像の縦幅を720に設定 (480)
print(f"video capture device: fps={video_capture.get(cv2.CAP_PROP_FPS)}")
print(
f"video capture device: w={video_capture.get(cv2.CAP_PROP_FRAME_WIDTH)}"
)
print(
f"video capture device: h={video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT)}"
)
#
# count
#
count = 0
#
# down sampling ratio
#
down_sampling_ratio = 1.0 / ratio
#
# fps
#
tm = cv2.TickMeter()
tm.start()
fps_count = 0
fps_count_max = 10
fps_number = 0
#
# capture video frame
#
while (video_capture.isOpened() == True):
#
# grab a single frame of video
#
ret, frame = video_capture.read()
if not ret:
print(f"-")
continue
# print( f"." )
#
# flip
#
frame = cv2.flip(frame, 1) # Flip camera horizontaly
#
# Resize frame of video to 1/4 size for faster face recognition processing
# frame_buffer = imutils.resize(frame, width=480)
#
if ratio > 1.0:
# frame_buffer = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
frame_buffer = cv2.resize(frame, (0, 0),
fx=down_sampling_ratio,
fy=down_sampling_ratio)
else:
frame_buffer = frame
#
# convert the image from BGR color (which OpenCV uses) to RGB color (which faced uses)
# rgb_frame = frame[:, :, ::-1]
# rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
#
rgb_frame = cv2.cvtColor(frame_buffer, cv2.COLOR_BGR2RGB)
#
# Find all the faces and face enqcodings in the frame of video
#
face_locations = []
if mode == 0:
name = "hog" # hog or cnn
face_locations = faced.face_locations(
rgb_frame, number_of_times_to_upsample=1, model=name)
elif mode == 1:
# global face_cascade
face_locations = face_locations_by_haarcascade(
rgb_frame, face_cascade)
elif mode == 2:
# global YOLOnet
face_locations = face_locations_by_YOLO(rgb_frame, YOLOnet)
elif mode == 3:
face_locations = face_locations_by_FaceDetector(rgb_frame)
else:
print(f'detecting faces: unknown={mode}.')
return
#
# check faces: (top, right, bottom, left)
#
if len(face_locations) > 0:
x = face_locations[0][3] # x : left
y = face_locations[0][0] # y : top
w = face_locations[0][1] - x # x + w : right
h = face_locations[0][2] - y # y + h : bottom
# print( f"face_locations={face_locations}, 0:x={x:3d}, y={y:3d}, w={w:3d}, h={h:3d}", end="")
print(
f'face_locations:{len(face_locations):2d} persons, x={x:3d}, y={y:3d}, w={w:3d}, h={h:3d} : ',
end='\n')
#
# face encoding features(vector)
#
face_encodings = faced.face_encodings(rgb_frame, face_locations)
#
# Loop through each face in this frame of video
#
for (top, right, bottom,
left), face_encoding in zip(face_locations, face_encodings):
#
# See if the face is a match for the known face(s)
#
matches = faced.compare_faces(known_face_encodings,
face_encoding,
tolerance=0.6)
#
# If a match was found in known_face_encodings, just use the first one.
# if True in matches:
# first_match_index = matches.index(True)
# name = known_face_names[first_match_index]
# Or instead, use the known face with the smallest distance to the new face
#
name = "Unknown"
face_distances = faced.face_distance(known_face_encodings,
face_encoding)
best_match_index = np.argmin(face_distances)
if matches[best_match_index]:
name = known_face_names[best_match_index]
# print( f" !!!found...{name} d({best_match_index})={face_distances[best_match_index]}", end="\n" )
# print( f"{name}\td[{best_match_index:2d}]={face_distances[best_match_index]:6.4f},\t", end="" )
print(
f"{name}:d[{best_match_index:2d}]={face_distances[best_match_index]:6.4f},\t",
end="\n")
#
# face landmarks
#
if facemarks == True:
rgb_frame = draw_face_landmarks(rgb_frame, top, right,
bottom, left, name)
pass
else:
# print( f"1 {name}\td[{best_match_index:2d}]={face_distances[best_match_index]:6.4f},\t", end="\n" )
pass
# if facemarks == True:
# rgb_frame = draw_face_landmarks(rgb_frame, top, right, bottom, left, name)
#
# Scale back up face locations since the frame we detected in was scaled to 1/4 size
#
if ratio > 1.0:
top *= int(ratio)
right *= int(ratio)
bottom *= int(ratio)
left *= int(ratio)
#
# mosaic
#
if mosaic == True:
rgb_frame = mosaic_area(rgb_frame,
left,
top,
right - left,
bottom - top,
ratio=0.05)
#
# Draw a box,label(name) around the face
#
print(f'facemarks={facemarks}, name={name}')
if facemarks == False:
cv2.rectangle(rgb_frame, (left, top), (right, bottom),
(0, 0, 255), 2)
cv2.rectangle(rgb_frame, (left, bottom - 35), (right, bottom),
(0, 0, 255), cv2.FILLED)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(rgb_frame, name, (left + 6, bottom - 6), font, 1.0,
(255, 255, 255), 1, cv2.LINE_AA)
else:
x = left
y = top
w = right - left
h = bottom - top
# img = cv2.line(img,(0,0),(511,511),(255,0,0),5)
s = [(x, y + int(h / 3)), (x, y), (x + int(w / 3), y)]
cv2.line(rgb_frame,
s[0],
s[1],
color=(0, 255, 0),
thickness=3,
lineType=cv2.LINE_AA)
cv2.line(rgb_frame,
s[1],
s[2],
color=(0, 255, 0),
thickness=3,
lineType=cv2.LINE_AA)
s = [(x + w - int(w / 3), y), (x + w, y),
(x + w, y + int(h / 3))]
cv2.line(rgb_frame,
s[0],
s[1],
color=(0, 255, 0),
thickness=3,
lineType=cv2.LINE_AA)
cv2.line(rgb_frame,
s[1],
s[2],
color=(0, 255, 0),
thickness=3,
lineType=cv2.LINE_AA)
s = [(x, y + h - int(h / 3)), (x, y + h),
(x + int(w / 3), y + h)]
cv2.line(rgb_frame,
s[0],
s[1],
color=(0, 255, 0),
thickness=3,
lineType=cv2.LINE_AA)
cv2.line(rgb_frame,
s[1],
s[2],
color=(0, 255, 0),
thickness=3,
lineType=cv2.LINE_AA)
s = [(x + w - int(w / 3), y + h), (x + w, y + h),
(x + w, y + h - int(h / 3))]
cv2.line(rgb_frame,
s[0],
s[1],
color=(0, 255, 0),
thickness=3,
lineType=cv2.LINE_AA)
cv2.line(rgb_frame,
s[1],
s[2],
color=(0, 255, 0),
thickness=3,
lineType=cv2.LINE_AA)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(rgb_frame, name, (left + 6, bottom - 6), font, 1.0,
(0, 255, 0), 1, cv2.LINE_AA)
if len(face_locations) > 0:
print(f'.')
#
# fps
#
if fps_count == fps_count_max:
tm.stop()
fps_number = fps_count_max / tm.getTimeSec()
tm.reset()
tm.start()
fps_count = 0
cv2.putText(rgb_frame,
'FPS:{:.2f}'.format(fps_number), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX,
1.0, (0, 255, 0),
thickness=2,
lineType=cv2.LINE_AA)
fps_count += 1
# Display the resulting image
if ret:
frame = cv2.cvtColor(rgb_frame, cv2.COLOR_RGB2BGR)
cv2.imshow(windowName, frame)
pass
#
# keyboard operation
#
global key_save
global key_facelandmarks
global key_mosaic
global key_quit
c = cv2.waitKey(1) & 0xff
if c == ord(key_quit) or c == 27:
break
elif c == ord(key_save): # spaceで保存 32
# cv2.imwrite( './filename_' + str(count) + '.jpg', frame ) #001~連番で保存
bewrite = True
filename = "screenshot_" + str(count) + ".jpg"
while os.path.exists(filename):
print('skip:' + filename)
count += 1
filename = "screenshot_" + str(count) + ".jpg"
if count >= 100:
beWrite = False
if bewrite:
cv2.imwrite(filename, frame) #001~連番で保存
count += 1
print('save done:' + filename)
elif c == ord(key_facelandmarks):
facemarks = not facemarks
elif c == ord(key_mosaic):
mosaic = not mosaic
elif c == ord(key_facelandmarks_ext):
global facelandmarks_ext
facelandmarks_ext += 1
_, facelandmarks_ext = divmod(facelandmarks_ext, 3)
#
# release handle to the webcam
#
video_capture.release()
cv2.destroyWindow(windowName)
cv2.destroyAllWindows()
# @Last Modified time: 2019-10-31 11:46:21
import os
import cv2
import time
from faced import FaceDetector
# filename = 'obama.jpg'
model = 'faced'
scale = 1
path = '../data/29--Students_Schoolkids/'
for fn in os.listdir(path):
filename = fn
raw_img = cv2.imread(os.path.join(path, filename))
out_file = '../data'
detector = FaceDetector()
name = fn.split('.')
name = name[0]
out_file = os.path.join(out_file, name.replace('jpg', 'txt'))
t0 = time.time()
print('start')
face_locations = detector.predict(raw_img, 0.5)
t1 = time.time()
print(f'took {round(t1-t0, 3)} to get {len(face_locations)} faces')
for (x, y, w, h, _) in face_locations:
x1 = x - int(w / 2)
x2 = x + int(w / 2)
y1 = y - int(h / 2)
y2 = y + int(h / 2)
# print(x1, y1, x2-x1, y2-y1)
import youtube_dl
import cv2
import face_recognition
import sklearn
from sklearn.datasets import fetch_lfw_people
from faced import FaceDetector
from faced.utils import annotate_image
lfw_people = fetch_lfw_people()
face_detector = FaceDetector()
def process_video(vidfile):
# start processing video
input_movie = cv2.VideoCapture(vidfile)
length = int(input_movie.get(cv2.CAP_PROP_FRAME_COUNT))
# Write the resulting image to the output video file
codec = int(input_movie.get(cv2.CAP_PROP_FOURCC))
fps = int(input_movie.get(cv2.CAP_PROP_FPS))
frame_width = int(input_movie.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(input_movie.get(cv2.CAP_PROP_FRAME_HEIGHT))
output_movie = cv2.VideoWriter('output.mp4', codec, fps,
(frame_width, frame_height))
frame_num = 0
while frame_num < length:
ret, frame = input_movie.read()
frame_num += 1
if not ret:
import cv2
from time import time
from faced import FaceDetector
from faced import utils
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
logging.basicConfig(format='%(asctime)s %(message)s')
# for local testing
model_path = "../faced/models/"
face_detector = FaceDetector()
img_path = "faces.jpg"
thresh = 0.8
bgr_img = cv2.imread(img_path)
rgb_img = cv2.cvtColor(bgr_img.copy(), cv2.COLOR_BGR2RGB)
# Receives RGB numpy image (HxWxC) and
# returns (x_center, y_center, width, height, prob) tuples.
logger.info('starting face detection ...')
start_time = time()
face_detection_list = face_detector.predict(frame=rgb_img, thresh=thresh)
detected_faces = len(face_detection_list)
end_time = time()
duration = end_time - start_time
logger.info(f'face detection took {duration:.2f} seconds')
logger.info(f'found boxes: {detected_faces}')
increase_box_percentage = 0.5
for i in range(detected_faces):
def on_created(self, event):
print(f'event type: {event.event_type} path : {event.src_path}')
time.sleep(2)
try:
# the "on_created" event is called by a partially upload file
# cut excess filename after '.png'
#/var/nextcloud_data/c4p/files/camera_footage/Ko-retina.png.ocTransferId1983807786.part
# /camera_footage/camera_1/raw_footage
# /camera_footage/camera_1/anonymized_footage
# todo : anonymizing more than 1 face
# todo : put face over face
sucessful_anonymization = False
filetype = find_filetype(event.src_path)
print("filetype", filetype)
path_to_file = event.src_path.split(filetype, 1)[0] + filetype
print("path to file", path_to_file)
camera_folder = get_camera_folder(path_to_file)
print("camera_id", camera_folder)
picture_id = get_picture_id(path_to_file, camera_folder, filetype)
print("picture_id", picture_id)
an_path = get_path_for_anonymous_pic(anonymous_folder,
camera_folder, picture_id,
filetype)
print("path to anonymous file", an_path)
face_detector = FaceDetector()
print("reading image", path_to_file)
img = cv2.imread(path_to_file)
rgb_img = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2RGB)
if thresh:
bboxes = face_detector.predict(rgb_img, thresh)
else:
bboxes = face_detector.predict(rgb_img)
# anonymize
if not bboxes == []:
try:
print("bboxes containing face", bboxes)
print("creating anonymous picture")
ann_img = annotate_image(img, bboxes)
print("write anonymized version to anonymous folder")
cv2.imwrite(an_path, ann_img)
sucessful_anonymization = True
except Exception as ex:
print(ex)
print("Anonymizing failed")
print("writing anonymized version failed")
sucessful_anonymization = False
# delete original if sucessfully anonymized
if sucessful_anonymization:
if os.path.exists(path_to_file):
os.remove(path_to_file)
else:
print("Tried deleting, but the file does not exist",
path_to_file)
# no faces found, picture is already anonymous
else:
print("no face found")
if os.path.exists(path_to_file):
os.rename(path_to_file, an_path)
print("refreshing owncloud")
subprocess.call(cwd + "/refresh_nextcloud.sh", shell=True)
except Exception as e:
print(e)
print("Anonymizing failed")
