基于python的人脸识别门禁系统
人脸识别门禁系统是一种基于人脸识别技术的安全系统。在Python中，可以使用多种人脸识别库（如OpenCV和dlib）来实现这种门禁系统。以下是一个基于Python的人脸识别门禁系统的需求分析：
1. 用户注册系统：门禁系统需要一个用户注册系统，让用户在系统中注册账户并上传自己的照片。这些照片将用于后续的人脸识别。
2. 人脸检测系统：门禁系统需要一个人脸检测系统，以检测进入门禁区域的人脸。这个检测系统需要使用Python中的人脸识别库，例如OpenCV或dlib。
3. 人脸识别系统：门禁系统需要一个人脸识别系统，以识别进入门禁区域的人员是否在注册用户列表中。这个识别系统需要使用Python中的人脸识别库，例如OpenCV或dlib。
4. 数据库管理系统：门禁系统需要一个数据库管理系统，以存储注册用户列表和门禁记录。这个管理系统可以使用Python中的SQLite或MySQL等关系型数据库。
5. 记录管理系统：门禁系统需要一个记录管理系统，以记录进出门禁区域的人员信息，包括时间戳、人员姓名、进出状态等。这个管理系统可以使用Python中的日志模块或数据库管理系统中的表格来实现。
6. 报警系统：门禁系统需要一个报警系统，以在检测到未注册用户或异常情况时发出警报。这个报警系统可以使用Python中的声音或图像提示，或者将警报信息发送到管理员的手机或电子邮件中。
7. 界面设计系统：门禁系统需要一个友好的界面设计系统，以便管理员或用户能够方便地使用门禁系统。这个设计系统可以使用Python中的Tkinter或PyQt等界面库来实现。
基于上述需求分析，我们可以进行以下详细设计：
1. 用户注册系统：
用户注册系统需要实现以下功能：
a. 允许用户在系统中注册账户，并上传自己的照片。
b. 保存用户的注册信息和照片到数据库中。
c. 支持用户查看和修改自己的注册信息和照片。
实现方法：
a. 可以使用Python中的图形用户界面库，如Tkinter、PyQt等，设计一个注册界面，让用户输入自己的姓名、性别、年龄、联系方式等信息，并上传自己的照片。
b. 将用户的注册信息和照片保存到数据库中，可以使用Python中的关系型数据库MySQL或SQLite。
c. 允许用户通过界面或API访问自己的注册信息和照片，并支持用户修改自己的信息和照片。
2. 人脸检测系统：
人脸检测系统需要实现以下功能：
a. 检测门禁区域进入的人脸。
b. 在检测到人脸后，将人脸图像传递给人脸识别系统进行识别。
实现方法：
a. 可以使用Python中的OpenCV或dlib等人脸识别库来实现人脸检测功能。
b. 将检测到的人脸图像传递给人脸识别系统进行识别。
3. 人脸识别系统：
人脸识别系统需要实现以下功能：
a. 从数据库中读取已注册用户的信息和照片。
b. 对进入门禁区域的人脸进行识别，判断是否为已注册用户。
c. 如果是已注册用户，记录进出门禁区域的时间和状态，保存到数据库中。
实现方法：
a. 从数据库中读取已注册用户的信息和照片。
b. 使用Python中的人脸识别库，如OpenCV或dlib，对进入门禁区域的人脸进行识别，并判断是否为已注册用户。
c. 如果是已注册用户，记录进出门禁区域的时间和状态，并保存到数据库中。
4. 数据库管理系统：
数据库管理系统需要实现以下功能：
a. 管理已注册用户的信息和照片。
b. 管理门禁记录，包括人员姓名、进出时间和状态等。
实现方法：
a. 可以使用Python中的关系型数据库MySQL或SQLite来管理已注册用户的信息和照片。
b. 在门禁记录中，使用数据库管理系统中的表格来存储人员姓名、进出时间和状态等信息。
5. 记录管理系统：
记录管理系统需要实现以下功能：
a. 记录进出门禁区域的人员信息，包括时间戳、人员姓名、进出状态等。
b. 支持管理员查看和导出门禁记录。
实现方法：
a. 在人脸识别系统中记录进出门禁区域的人员信息，包括时间戳、人员姓名、进出状态等，并保存到数据库中。
b. 支持管理员通过界面或API访问门禁记录，并支持管理员导出门禁记录。
6. 报警系统：
报警系统需要实现以下功能：
a. 在检测到未注册用户或异常情况时发出警报。
b. 将警报信息发送到管理员的手机或电子邮件中。
实现方法：
a. 在人脸检测和识别系统中检测未注册用户或异常情况，并在检测到时发出警报。
b. 将警报信息通过Python中的手机短信或电子邮件模块发送给管理员。
7. 界面设计系统：
界面设计系统需要实现以下功能：
a. 提供一个友好的用户界面，方便管理员或用户使用门禁系统。
b. 支持用户注册、查看、修改自己的信息和照片。
c. 支持管理员查看门禁记录和导出记录。
实现方法：
a. 可以使用Python中的图形用户界面库，如Tkinter、PyQt等，设计一个友好的用户界面。
b. 提供用户注册、查看、修改自己的信息和照片的功能。
c. 提供管理员查看门禁记录和导出记录的功能，并支持管理员对记录进行筛选和搜索。
以下是一个基于Python的用户注册系统的示例代码，使用了Tkinter作为图形用户界面库，SQLite作为关系型数据库。这个系统实现了用户注册、查看、修改和删除自己的信息和照片等功能。
import tkinter as tk
from tkinter import filedialog
import sqlite3
# 创建用户注册系统的主界面
class UserRegistrationSystem(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
self.master = master
self.master.title("用户注册系统")
self.pack()
# 创建用户信息输入框
self.create_input()
# 创建用户照片上传按钮
self.create_upload_button()
# 创建注册和删除按钮
self.create_register_button()
self.create_delete_button()
# 创建用户信息显示框
self.create_text()
# 连接数据库
self.conn = sqlite3.connect('user.db')
self.cursor = self.conn.cursor()
self.create_table()
# 创建用户信息输入框
def create_input(self):
self.name_label = tk.Label(self, text="姓名：")
self.name_label.grid(row=0, column=0)
self.name_entry = tk.Entry(self)
self.name_entry.grid(row=0, column=1)
self.gender_label = tk.Label(self, text="性别：")
self.gender_label.grid(row=1, column=0)
self.gender_entry = tk.Entry(self)
self.gender_entry.grid(row=1, column=1)
self.age_label = tk.Label(self, text="年龄：")
self.age_label.grid(row=2, column=0)
self.age_entry = tk.Entry(self)
self.age_entry.grid(row=2, column=1)
self.phone_label = tk.Label(self, text="联系方式：")
self.phone_label.grid(row=3, column=0)
self.phone_entry = tk.Entry(self)
self.phone_entry.grid(row=3, column=1)
# 创建用户照片上传按钮
def create_upload_button(self):
self.upload_button = tk.Button(self, text="上传照片", command=self.upload_photo)
self.upload_button.grid(row=4, column=0)
# 创建注册按钮
def create_register_button(self):
self.register_button = tk.Button(self, text="注册", command=self.register_user)
self.register_button.grid(row=4, column=1)
# 创建删除按钮
def create_delete_button(self):
self.delete_button = tk.Button(self, text="删除", command=self.delete_user)
self.delete_button.grid(row=4, column=2)
# 创建用户信息显示框
def create_text(self):
self.text = tk.Text(self, width=30, height=10)
self.text.grid(row=5, columnspan=3)
# 上传用户照片
def upload_photo(self):
# 打开文件对话框
filename = filedialog.askopenfilename(initialdir="/", title="选择照片",
filetypes=(("jpeg files", "*.jpg"), ("all files", "*.*")))
self.photo_path = filename
# 注册用户
def register_user(self):
name = self.name_entry.get()
gender = self.gender_entry.get()
age = self.age_entry.get()
phone = self.phone_entry.get()
# 将用户信息存入数据库
if name and gender and age and phone and self.photo_path:
with open(self.photo_path, 'rb') as f:
photo = f.read()
self.cursor.execute("INSERT INTO user (name, gender, age, phone, photo) VALUES (?, ?, ?, ?, ?)",
(name, gender, age, phone, photo))
self.conn.commit()
self.show_message("注册成功！")
else:
self.show_message("请填写所有信息并上传照片！")
# 删除用户
def delete_user(self):
name = self.name_entry.get()
# 从数据库中删除用户信息
if name:
self.cursor.execute("DELETE FROM user WHERE name=?", (name,))
self.conn.commit()
self.show_message("删除成功！")
else:
self.show_message("请输入姓名！")
# 显示用户信息
def show_message(self, message):
self.text.delete('1.0', tk.END)
self.text.insert('1.0', message)
# 创建用户信息表格
def create_table(self):
self.cursor.execute('''CREATE TABLE IF NOT EXISTS user
(id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
gender TEXT NOT NULL,
age INTEGER NOT NULL,
phone TEXT NOT NULL , photo BLOB NOT NULL)''')
# 查询用户信息
def query_user(self, name):
self.cursor.execute("SELECT * FROM user WHERE name=?", (name,))
result = self.cursor.fetchone()
return result
# 更新用户信息
def update_user(self, name, gender, age, phone, photo_path):
with open(photo_path, 'rb') as f:
photo = f.read()
self.cursor.execute("UPDATE user SET gender=?, age=?, phone=?, photo=? WHERE name=?",
(gender, age, phone, photo, name))
self.conn.commit()
self.show_message("更新成功！")
# 显示用户信息
def show_user(self, name):
result = self.query_user(name)
if result:
self.show_message("姓名：{}\n性别：{}\n年龄：{}\n联系方式：{}".format(result[1], result[2], result[3], result[4]))
with open('photo.jpg', 'wb') as f:
f.write(result[5])
img = tk.PhotoImage(file='photo.jpg')
label = tk.Label(self, image=img)
label.grid(row=6, columnspan=3)
label.image = img
else:
self.show_message("用户不存在！")
# 运行用户注册系统
if __name__ == "__main__":
root = tk.Tk()
app = UserRegistrationSystem(master=root)
app.mainloop()一个基本的用户注册系统，允许用户输入姓名、性别、年龄、联系方式等信息，并上传自己的照片。用户注册信息和照片会被保存到SQLite数据库中，用户可以通过界面或API访问自己的注册信息和照片，并支持用户修改自己的信息和照片。这个示例代码还可以进一步扩展，增加更多的功能和优化用户体验。
以下是使用OpenCV实现人脸检测系统的代码示例：
import cv2
# 加载人脸检测器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
# 加载人脸识别器
recognizer = cv2.face.LBPHFaceRecognizer_create()
# 加载训练好的人脸识别模型
recognizer.read('trained_model.yml')
# 打开摄像头
cap = cv2.VideoCapture(0)
while True:
# 读取摄像头画面
ret, frame = cap.read()
# 将画面转换为灰度图像
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 检测人脸
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
# 处理每一个检测到的人脸
for (x, y, w, h) in faces:
# 在检测到的人脸周围画一个矩形框
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
# 提取人脸图像
face_roi_gray = gray[y:y+h, x:x+w]
face_roi_color = frame[y:y+h, x:x+w]
# 将人脸图像传递给人脸识别器进行识别
label, confidence = recognizer.predict(face_roi_gray)
# 将识别结果显示在画面上
if confidence < 100:
text = 'Person ' + str(label)
else:
text = 'Unknown'
cv2.putText(frame, text, (x, y - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
# 显示处理后的画面
cv2.imshow('Face Detection', frame)
# 按下q键退出程序
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# 释放摄像头资源
cap.release()
# 关闭所有窗口
cv2.destroyAllWindows()
在上述代码中，我们首先加载了人脸检测器和人脸识别器，然后打开摄像头开始读取画面。对于每一帧画面，我们先将其转换为灰度图像，然后使用人脸检测器检测其中的人脸。对于每一个检测到的人脸，我们在其周围画一个矩形框，并提取出人脸图像。然后将人脸图像传递给人脸识别器进行识别，并将识别结果显示在画面上。最后，我们通过按下q键来退出程序。
以下是一个基于OpenCV库的人脸识别系统，实现了从数据库中读取已注册用户的信息和照片，对进入门禁区域的人脸进行识别，并判断是否为已注册用户，如果是已注册用户则记录进出门禁区域的时间和状态，并保存到数据库中。
一个基本的示例代码，实际应用中还需要根据具体需求进行修改和完善。
import cv2
import numpy as np
import sqlite3
import datetime
# 连接数据库
conn = sqlite3.connect('users.db')
c = conn.cursor()
# 加载人脸识别器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
recognizer = cv2.face.LBPHFaceRecognizer_create()
# 加载已注册用户的信息和照片
c.execute('SELECT * FROM users')
users = c.fetchall()
labels = []
faces = []
for user in users:
labels.append(user[0])
img = cv2.imread(user[1])
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces.append(gray)
# 训练人脸识别器
recognizer.train(faces, np.array(labels))
# 打开摄像头
cap = cv2.VideoCapture(0)
while True:
# 读取摄像头画面
ret, frame = cap.read()
# 将画面转换为灰度图像
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 检测人脸
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
# 处理每一个检测到的人脸
for (x, y, w, h) in faces:
# 在检测到的人脸周围画一个矩形框
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
# 提取人脸图像
face_roi_gray = gray[y:y+h, x:x+w]
face_roi_color = frame[y:y+h, x:x+w]
# 将人脸图像传递给人脸识别器进行识别
label, confidence = recognizer.predict(face_roi_gray)
# 将识别结果显示在画面上
if confidence < 100:
# 如果是已注册用户，记录进出门禁区域的时间和状态，并保存到数据库中
user_data = c.execute("SELECT * FROM users WHERE id=?", (label,))
user = user_data.fetchone()
status = 'in' # 判断进出门禁区域的状态，这里假设所有用户初始状态都是进入门禁区域
now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') # 获取当前时间
c.execute("INSERT INTO records (user_id, status, time) VALUES (?, ?, ?)", (user[0], status, now))
conn.commit()
text = 'Person ' + str(user[0])
else:
text = 'Unknown'
cv2.putText(frame, text, (x, y - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
# 显示处理后的画面
cv2.imshow('Face Recognition', frame)
# 按下q键退出程序
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# 释放摄像头资源
cap.release()
# 关闭所有窗口
cv2.destroyAllWindows()
# 关闭数据库连接
conn.close()简单的记录管理系统的示例代码，使用Python编写，实现了记录进出门禁区域的人员信息，包括时间戳、人员姓名、进出状态等，并保存到数据库中；支持管理员通过界面或API访问门禁记录，并支持管理员导出门禁记录。
实际应用中还需要根据具体需求进行修改和完善。
import sqlite3
from flask import Flask, jsonify, request, send_file
import pandas as pd
# 连接数据库
conn = sqlite3.connect('records.db')
c = conn.cursor()
# 创建表格
c.execute('''CREATE TABLE IF NOT EXISTS records
(id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER,
status TEXT,
time TEXT)''')
# 创建Flask应用
app = Flask(__name__)
# 添加门禁记录
@app.route('/add_record', methods=['POST'])
def add_record():
user_id = request.form['user_id']
status = request.form['status']
time = request.form['time']
c.execute("INSERT INTO records (user_id, status, time) VALUES (?, ?, ?)", (user_id, status, time))
conn.commit()
return jsonify({'result': 'success'})
# 获取门禁记录
@app.route('/get_records', methods=['GET'])
def get_records():
query = "SELECT records.id, users.name, records.status, records.time FROM records LEFT JOIN users ON records.user_id=users.id"
records = c.execute(query).fetchall()
# 将记录转换为JSON格式
result = []
for record in records:
result.append({
'id': record[0],
'name': record[1],
'status': record[2],
'time': record[3]
})
return jsonify(result)
# 导出门禁记录
@app.route('/export_records', methods=['GET'])
def export_records():
query = "SELECT records.id, users.name, records.status, records.time FROM records LEFT JOIN users ON records.user_id=users.id"
records = c.execute(query).fetchall()
# 将记录转换为Pandas DataFrame
df = pd.DataFrame(records, columns=['id', 'name', 'status', 'time'])
# 将DataFrame导出为CSV文件
csv_file = 'records.csv'
df.to_csv(csv_file, index=False)
# 返回CSV文件
return send_file(csv_file, as_attachment=True)
if __name__ == '__main__':
app.run(debug=True)
# 关闭数据库连接
conn.close()在这个代码中，我们使用了Flask框架来实现一个简单的REST API。我们定义了三个路由：
1. `/add_record`：用于添加门禁记录。通过HTTP POST请求，向该路由传递用户ID、进出状态和时间戳，然后将这些信息插入到数据库中。
2. `/get_records`：用于获取门禁记录。通过HTTP GET请求，访问该路由，然后从数据库中获取所有门禁记录，并将其转换为JSON格式返回给客户端。
3. `/export_records`：用于导出门禁记录。通过HTTP GET请求，访问该路由，然后从数据库中获取所有门禁记录，并将其转换为CSV格式，并将CSV文件作为附件返回给客户端。
在实际应用中，我们需要进行更多的安全性和错误处理，这里只是为了演示基本的功能。
以下是一个基于人脸识别的报警系统的示例代码，使用Python编写，实现了在检测到未注册用户或异常情况时发出警报，并将警报信息发送到管理员的手机或电子邮件中。
请注意，这只是一个基本的示例代码，实际应用中还需要根据具体需求进行修改和完善。```python
import cv2
import numpy as np
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.image import MIMEImage
from twilio.rest import Client
# 加载人脸识别器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
recognizer = cv2.face.LBPHFaceRecognizer_create()
# 加载已注册用户的信息和照片
labels = []
faces = []
with open('users.txt', 'r') as f:
for line in f:
parts = line.strip().split(',')
labels.append(int(parts[0]))
img = cv2.imread(parts[1])
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces.append(gray)
# 训练人脸识别器
recognizer.train(faces, np.array(labels))
# Twilio账户信息（用于发送短信）
account_sid = 'your_account_sid'
auth_token = 'your_auth_token'
client = Client(account_sid, auth_token)
# 邮件账户信息（用于发送邮件）
email_address = 'your_email_address'
email_password = 'your_email_password'
smtp_server = 'your_smtp_server'
# 发送短信
def send_sms(to_number, message):
client.messages.create(
body=message,
from_='+15017122661',
to=to_number
)
# 发送邮件
def send_email(to_address, subject, message, image_file):
msg = MIMEMultipart()
msg['From'] = email_address
msg['To'] = to_address
msg['Subject'] = subject
text = MIMEText(message)
msg.attach(text)
with open(image_file, 'rb') as f:
img_data = f.read()
image = MIMEImage(img_data, name='image.jpg')
msg.attach(image)
with smtplib.SMTP(smtp_server, 587) as smtp:
smtp.starttls()
smtp.login(email_address, email_password)
smtp.send_message(msg)
# 打开摄像头
cap = cv2.VideoCapture(0)
while True:
# 读取摄像头画面
ret, frame = cap.read()
# 将画面转换为灰度图像
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 检测人脸
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
# 处理每一个检测到的人脸
for (x, y, w, h) in faces:
# 在检测到的人脸周围画一个矩形框
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
# 提取人脸图像
face_roi_gray = gray[y:y+h, x:x+w]
face_roi_color = frame[y:y+h, x:x+w]
# 将人脸图像传递给人脸识别器进行识别
label, confidence = recognizer.predict(face_roi_gray)
# 如果识别的置信度低于阈值，则认为是未注册用户，发出警报
if confidence > 70:
message = 'Unknown person detected!'
send_sms('+1234567890', message)
send_email('[email protected]', 'Alert', message, 'image.jpg')
cv2.putText(frame, 'Unknown', (x, y - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
# 显示处理后的画面
cv2.imshow('Face Recognition', frame)
# 按下q键退出程序
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# 释放摄像头资源
cap.release()
# 关闭所有窗口
cv2.destroyAllWindows()以下是一个使用Tkinter库实现的简单界面设计系统的示例代码，使用Python编写，实现了提供一个友好的用户界面，方便管理员或用户使用门禁系统；支持用户注册、查看、修改自己的信息和照片；支持管理员查看门禁记录和导出记录，并支持管理员对记录进行筛选和搜索。
请注意，这只是一个基本的示例代码，实际应用中还需要根据具体需求进行修改和完善。```python
import tkinter as tk
from tkinter import ttk
import sqlite3
from tkinter.filedialog import askopenfilename
import pandas as pd
# 连接数据库
conn = sqlite3.connect('records.db')
c = conn.cursor()
# 创建表格
c.execute('''CREATE TABLE IF NOT EXISTS users
(id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT,
email TEXT,
phone TEXT,
image TEXT)''')
# 创建表格
c.execute('''CREATE TABLE IF NOT EXISTS records
(id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER,
status TEXT,
time TEXT)''')
# 创建主窗口
root = tk.Tk()
root.title("Door Access System")
# 创建Notebook
notebook = ttk.Notebook(root)
notebook.pack()
# 创建用户注册页面
register_frame = ttk.Frame(notebook)
notebook.add(register_frame, text='Register')
# 创建用户信息显示页面
info_frame = ttk.Frame(notebook)
notebook.add(info_frame, text='My Info')
# 创建管理员页面
admin_frame = ttk.Frame(notebook)
notebook.add(admin_frame, text='Admin')
# 用户注册页面
def register():
name = name_entry.get()
email = email_entry.get()
phone = phone_entry.get()
image = image_path.get()
# 将用户信息插入到数据库中
c.execute("INSERT INTO users (name, email, phone, image) VALUES (?, ?, ?, ?)", (name, email, phone, image))
conn.commit()
# 清空表单
name_entry.delete(0, tk.END)
email_entry.delete(0, tk.END)
phone_entry.delete(0, tk.END)
image_path.set('')
# 显示成功消息
success_label.configure(text='Registration successful!')
# 创建用户注册表单
name_label = ttk.Label(register_frame, text='Name:')
name_label.grid(column=0, row=0, padx=10, pady=10)
name_entry = ttk.Entry(register_frame, width=30)
name_entry.grid(column=1, row=0, padx=10, pady=10)
email_label = ttk.Label(register_frame, text='Email:')
email_label.grid(column=0, row=1, padx=10, pady=10)
email_entry = ttk.Entry(register_frame, width=30)
email_entry.grid(column=1, row=1, padx=10, pady=10)
phone_label = ttk.Label(register_frame, text='Phone:')
phone_label.grid(column=0, row=2, padx=10, pady=10)
phone_entry = ttk.Entry(register_frame, width=30)
phone_entry.grid(column=1, row=2, padx=10, pady=10)
image_label = ttk.Label(register_frame, text='Image:')
image_label.grid(column=0, row=3, padx=10, pady=10)
image_path = tk.StringVar()
def select_image():
filename = askopenfilename()
image_path.set(filename)
select_button = ttk.Button(register_frame, text='Select', command=select_image)
select_button.grid(column=1, row=3, padx=10, pady=10)
register_button = ttk.Button(register_frame, text='Register', command=register)
register_button.grid(column=1, row=4, padx=10, pady=10)
success_label = ttk.Label(register_frame, foreground='green')
success_label.grid(column=1, row=5, padx=10, pady=10)
# 用户信息显示页面
def show_info():
user_id = info_id_entry.get()
query = "SELECT * FROM users WHERE id=?"
user = c.execute(query, (user_id,)).fetchone()
if user is not None:
name_entry.configure(state='normal')
email_entry.configure(state='normal')
phone_entry.configure(state='normal')
image_button.configure(state='normal')
name_entry.delete(0, tk.END)
email_entry.delete(0, tk.END)
phone_entry.delete(0, tk.END)
name_entry.insert(0, user[1])
email_entry.insert(0, user[2])
phone_entry.insert(0, user[3])
image_path.set(user[4])
image_button.configure(text='View Image', command=lambda: view_image(user[4]))
else:
name_entry.configure(state='disabled')
email_entry.configure(state='disabled')
phone_entry.configure(state='disabled')
image_button.configure(state='disabled')
image_path.set('')
info_image.configure(image='')
name_entry.grid(column=1, row=0, padx=10, pady=10)
email_entry.grid(column=1, row=1, padx=10, pady=10)
phone_entry.grid(column=1, row=2, padx=10, pady=10)
image_button.grid(column=1, row=3, padx=10, pady=10)
info_image.grid(column=2, row=0, rowspan=4, padx=10, pady=10)
def view_image(image_file):
img = tk.PhotoImage(file=image_file)
info_image.configure(image=img)
info_image.image = img
info_id_label = ttk.Label(info_frame, text='User ID:')
info_id_label.grid(column=0, row=0, padx=10, pady=10)
info_id_entry = ttk.Entry(info_frame, width=30)
info_id_entry.grid(column=1, row=0, padx=10, pady=10)
show_info_button = ttk.Button(info_frame, text='Show Info', command=show_info)
show_info_button.grid(column=1, row=1, padx=10, pady=10)
name_label = ttk.Label(info_frame, text='Name:')
email_label = ttk.Label(info_frame, text='Email:')
phone_label = ttk.Label(info_frame, text='Phone:')
image_label = ttk.Label(info_frame, text='Image:')
name_entry = ttk.Entry(info_frame, width=30, state='disabled')
email_entry = ttk.Entry(info_frame, width=30, state='disabled')
phone_entry = ttk.Entry(info_frame, width=30, state='disabled')
image_path = tk.StringVar()
image_button = ttk.Button(info_frame, text='View Image', state='disabled')
info_image = ttk.Label(info_frame)
# 管理员页面
def show_records():
status = status_var.get()
query = "SELECT records.id, users.name, records.status, records.time FROM records JOIN users ON records.user_id=users.id WHERE 1=1"
if status != 'All':
query += " AND records.status='" + status + "'"
if from_date_var.get() != '':
query += " AND records.time>='" + from_date_var.get() + "'"
if to_date_var.get() != '':
query += " AND records.time<='" + to_date_var.get() + " 23:59:59'"
records = c.execute(query).fetchall()
for i in record_tree.get_children():
record_tree.delete(i)
for record in records:
record_tree.insert('', 'end', values=(record[0], record[1], record[2], record[3]))
def export_records():
status = status_var.get()
query = "SELECT records.id, users.name, records.status, records.time FROM records JOIN users ON records.user_id=users.id WHERE 1=1"
if status != 'All':
query += " AND records.status='" + status + "'"
if from_date_var.get() != '':
query += " AND records.time>='" + from_date_var.get() + "'"
if to_date_var.get() != '':
query += " AND records.time<='" + to_date_var.get() + " 23:59:59'"
records = c.execute(query).fetchall()
df = pd.DataFrame(records, columns=['ID', 'Name', 'Status', 'Time'])
df.to_csv('records.csv', index=False)
status_var = tk.StringVar(value='All')
status_label = ttk.Label(admin_frame, text='Status:')
status_label.grid(column=0, row=0, padx=10, pady=10)
status_combobox = ttk.Combobox(admin_frame, textvariable=status_var, values=('All', 'In', 'Out'), state='readonly', width=10)
status_combobox.grid(column=1, row=0, padx=10, pady=10)
from_date_label = ttk.Label(admin_frame, text='From:')
from_date_label.grid(column=2, row=0, padx=10, pady=10)
from_date_var = tk.StringVar()
from_date_entry = ttk.Entry(admin_frame, textvariable=from_date_var, width=10)
from_date_entry.grid(column=3, row=0, padx=10, pady=10)
to_date_label = ttk.Label(admin_frame, text='To:')
to_date_label.grid(column=4, row=0, padx=10, pady=10)
to_date_var = tk.StringVar()
to_date_entry = ttk.Entry(admin_frame, textvariable=to_date_var, width=10)
to