import cv2
import os
import numpy as np
import threading
import time
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
from deepface import DeepFace
from queue import Queue, Empty
import datetime
import logging
# Configuration
DATABASE_FOLDER = "database"
MODEL_NAME = "ArcFace"
DETECTOR_BACKEND = "ssd"
FRAME_SKIP = 4
MAX_QUEUE_SIZE = 2
SIMILARITY_THRESHOLD = 0.65
HISTORY_FOLDER = "historique"
# Email Configuration
EMAIL_ENABLED = True
EMAIL_FROM = "[email protected]"
EMAIL_PASSWORD = "uvfbgvkicjtzzpvp"
EMAIL_TO = "[email protected] , [email protected]"
EMAIL_SMTP_SERVER = "smtp.gmail.com"
EMAIL_SMTP_PORT = 587
EMAIL_COOLDOWN = 60
# RFID Configuration
RFID_ENABLED = True
RFID_PORT = "COM3"
RFID_BAUDRATE = 9600
RFID_EMERGENCY_CODES = ["1234567890", "0987654321"]
# Logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
filename='face_recognition.log'
)
logger = logging.getLogger(__name__)
# Global variables
face_database = []
processing_queue = Queue(maxsize=MAX_QUEUE_SIZE)
current_results = []
is_running = True
frame_count = 0
fps = 0
last_fps_update = time.time()
fps_counter = 0
last_email_time = 0
unknown_faces_detected = False
def create_directories():
directories = [DATABASE_FOLDER, "unknown_faces", HISTORY_FOLDER]
for directory in directories:
if not os.path.exists(directory):
os.makedirs(directory)
def init_database():
if not os.path.exists(DATABASE_FOLDER):
os.makedirs(DATABASE_FOLDER)
files = [f for f in os.listdir(DATABASE_FOLDER) if f.lower().endswith((".jpg",
".jpeg", ".png"))]
loaded = 0
for filename in files:
path = os.path.join(DATABASE_FOLDER, filename)
try:
img = cv2.imread(path)
if img is None:
continue
if max(img.shape[0], img.shape[1]) > 800:
scale = 800 / max(img.shape[0], img.shape[1])
img = cv2.resize(img, (0, 0), fx=scale, fy=scale)
result = DeepFace.represent(
img_path=img,
model_name=MODEL_NAME,
detector_backend=DETECTOR_BACKEND,
enforce_detection=True,
align=True
)
if result:
face_database.append({
"name": os.path.splitext(filename)[0],
"embedding": result[0]["embedding"]
})
loaded += 1
except Exception as e:
logger.error(f"Error loading {filename}: {str(e)}")
logger.info(f"Loaded {loaded} faces from database")
def save_recognized_face(frame, name, face_area):
try:
if not os.path.exists(HISTORY_FOLDER):
os.makedirs(HISTORY_FOLDER)
current_time = datetime.datetime.now()
timestamp = current_time.strftime("%Y-%m-%d_%H-%M-%S")
date_folder = os.path.join(HISTORY_FOLDER, current_time.strftime("%Y-%m-
%d"))
if not os.path.exists(date_folder):
os.makedirs(date_folder)
x, y, w, h = face_area
margin_x, margin_y = int(w * 0.2), int(h * 0.2)
x1 = max(0, x - margin_x)
y1 = max(0, y - margin_y)
x2 = min(frame.shape[1], x + w + margin_x)
y2 = min(frame.shape[0], y + h + margin_y)
face_img = frame[y1:y2, x1:x2]
label = f"{name} - {timestamp}"
cv2.putText(face_img, label, (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,
255, 0), 1)
filename = f"{name}_{timestamp}.jpg"
filepath = os.path.join(date_folder, filename)
cv2.imwrite(filepath, face_img)
return True
except Exception as e:
logger.error(f"Error saving recognized face: {str(e)}")
return False
def process_frames():
global current_results, unknown_faces_detected
while is_running:
try:
frame = processing_queue.get(timeout=0.5)
faces = DeepFace.extract_faces(
img_path=frame,
detector_backend=DETECTOR_BACKEND,
enforce_detection=False,
align=True
)
results = []
unknown_detected = False
for face in faces:
if face["confidence"] < 0.9:
continue
region = face["facial_area"]
x, y, w, h = region["x"], region["y"], region["w"], region["h"]
if not face_database:
results.append((x, y, w, h, "Unknown", 0, frame))
unknown_detected = True
continue
face_img = frame[max(0, y):min(frame.shape[0], y+h),
max(0, x):min(frame.shape[1], x+w)]
if face_img.shape[0] < 20 or face_img.shape[1] < 20:
continue
try:
embedding = DeepFace.represent(
img_path=face_img,
model_name=MODEL_NAME,
detector_backend="skip",
enforce_detection=False,
align=False
)[0]["embedding"]
db_embeddings = np.array([entry["embedding"] for entry in
face_database])
names = [entry["name"] for entry in face_database]
similarities = np.dot(db_embeddings, embedding) / (
np.linalg.norm(db_embeddings, axis=1) *
np.linalg.norm(embedding)
)
if similarities.size > 0:
best_idx = np.argmax(similarities)
score = (similarities[best_idx] + 1) / 2
if score > SIMILARITY_THRESHOLD:
label = names[best_idx]
results.append((x, y, w, h, label, score, None))
else:
results.append((x, y, w, h, "Unknown", score,
frame.copy()))
unknown_detected = True
except Exception as e:
results.append((x, y, w, h, "Unknown", 0, frame.copy()))
unknown_detected = True
current_results = results
unknown_faces_detected = unknown_detected
if unknown_detected:
send_email_notification()
processing_queue.task_done()
except Empty:
pass
except Exception as e:
logger.error(f"Process frame error: {str(e)}")
def enroll_face(frame, name):
try:
faces = DeepFace.extract_faces(
img_path=frame,
detector_backend=DETECTOR_BACKEND,
enforce_detection=True,
align=True
)
if not faces or faces[0]["confidence"] < 0.9:
return False
filename = f"{name}_{int(time.time())}.jpg"
path = os.path.join(DATABASE_FOLDER, filename)
region = faces[0]["facial_area"]
x, y, w, h = region["x"], region["y"], region["w"], region["h"]
margin_x, margin_y = int(w * 0.2), int(h * 0.2)
x1 = max(0, x - margin_x)
y1 = max(0, y - margin_y)
x2 = min(frame.shape[1], x + w + margin_x)
y2 = min(frame.shape[0], y + h + margin_y)
face_img = frame[y1:y2, x1:x2]
cv2.imwrite(path, face_img)
embedding = DeepFace.represent(
img_path=face_img,
model_name=MODEL_NAME,
detector_backend=DETECTOR_BACKEND,
enforce_detection=True
)[0]["embedding"]
face_database.append({"name": name, "embedding": embedding})
return True
except Exception as e:
logger.error(f"Enrollment failed: {str(e)}")
return False
def send_email_notification():
global last_email_time
if not EMAIL_ENABLED:
return
current_time = time.time()
if current_time - last_email_time < EMAIL_COOLDOWN:
return
last_email_time = current_time
threading.Thread(target=_send_email_worker).start()
def _send_email_worker():
try:
unknown_face = None
for face in current_results:
if face[4] == "Unknown" and face[6] is not None:
unknown_face = face
break
if unknown_face is None:
return
x, y, w, h, _, _, frame = unknown_face
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
msg = MIMEMultipart()
msg['From'] = EMAIL_FROM
msg['To'] = EMAIL_TO
msg['Subject'] = f"⚠️ SECURITY ALERT: Unknown Person Detected -
{timestamp}"
body = f"""
<html><body>
<h2>Security Alert: Unknown Person Detected</h2>
<p><b>Time:</b> {timestamp}</p>
<p>An unknown person has been detected by the security system.</p>
</body></html>
"""
msg.attach(MIMEText(body, 'html'))
alert_img = frame.copy()
cv2.rectangle(alert_img, (x, y), (x+w, y+h), (0, 0, 255), 2)
cv2.putText(alert_img, "Unknown", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(0, 0, 255), 2)
_, img_encoded = cv2.imencode('.jpg', alert_img)
img_attach = MIMEImage(img_encoded.tobytes())
img_attach.add_header('Content-Disposition', 'attachment',
filename=f'unknown_person_{timestamp}.jpg')
msg.attach(img_attach)
server = smtplib.SMTP(EMAIL_SMTP_SERVER, EMAIL_SMTP_PORT)
server.starttls()
server.login(EMAIL_FROM, EMAIL_PASSWORD)
server.send_message(msg)
server.quit()
except Exception as e:
logger.error(f"Email sending failed: {str(e)}")
def main():
global is_running, frame_count, fps, last_fps_update, fps_counter,
SIMILARITY_THRESHOLD
create_directories()
init_database()
process_thread = threading.Thread(target=process_frames, daemon=True)
process_thread.start()
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
known_persons = set()
last_recognized_person = None
try:
while True:
ret, frame = cap.read()
if not ret:
break
fps_counter += 1
now = time.time()
if now - last_fps_update >= 1.0:
fps = fps_counter
fps_counter = 0
last_fps_update = now
if frame_count % FRAME_SKIP == 0 and not processing_queue.full():
processing_queue.put(frame.copy())
current_frame_persons = set()
face_coords = {}
for result in current_results:
x, y, w, h, label, conf, _ = result
color = (0, 255, 0) if label != "Unknown" else (0, 0, 255)
cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
text = f"{label} ({conf*100:.1f}%)" if label != "Unknown" else
"Unknown"
cv2.putText(frame, text, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
color, 2)
if label != "Unknown":
current_frame_persons.add(label)
face_coords[label] = (x, y, w, h)
# Capture logic
for person in current_frame_persons:
if person not in known_persons:
save_recognized_face(frame.copy(), person, face_coords[person])
known_persons.add(person)
last_recognized_person = person
logger.info(f"New person detected: {person}")
# Reset tracking when no faces detected
if not current_frame_persons:
known_persons.clear()
last_recognized_person = None
# UI elements
cv2.putText(frame, f"FPS: {fps}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX,
0.7, (0, 255, 0), 2)
cv2.putText(frame, f"Thresh: {SIMILARITY_THRESHOLD:.2f}", (10, 60),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
if last_recognized_person:
cv2.putText(frame, f"Current: {last_recognized_person}", (10, 120),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
if unknown_faces_detected:
cv2.putText(frame, "ALERT: Unknown face detected", (frame.shape[1]
- 300, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
cv2.imshow('Face Recognition', frame)
key = cv2.waitKey(1) & 0xFF
if key == ord('q'):
break
elif key == ord('e'):
name = input("Enter name: ").strip()
if name:
threading.Thread(target=enroll_face, args=(frame.copy(),
name)).start()
elif key == ord('+'):
SIMILARITY_THRESHOLD = min(0.95, SIMILARITY_THRESHOLD + 0.05)
elif key == ord('-'):
SIMILARITY_THRESHOLD = max(0.3, SIMILARITY_THRESHOLD - 0.05)
finally:
is_running = False
process_thread.join(timeout=1.0)
cap.release()
cv2.destroyAllWindows()
if __name__ == "__main__":
main()
