You Only Look Once

1: from ultralytics import YOLO
2: model = YOLO('yolov8n.pt') #從 Ultralytics 自己托管的伺服器下載模型
3: print(model.names)

1: pip install numpy==1.26.4
2: pip install ultralytics

 1: import cv2
 2: from ultralytics import YOLO
 3: 
 4: # 載入預訓練模型
 5: model = YOLO("yolov8n.pt")
 6: 
 7: # 啟用 MacBook 的內建 webcam
 8: cap = cv2.VideoCapture(0)  # 0 是預設攝影機裝置
 9: 
10: # 檢查攝影機是否成功打開
11: if not cap.isOpened():
12:     print("❌ 無法打開攝影機")
13:     exit()
14: 
15: while True:
16:     ret, frame = cap.read()
17:     if not ret:
18:         print("❌ 無法讀取畫面")
19:         break
20: 
21:     # 進行 YOLO 偵測
22:     results = model(frame, verbose=False)
23:     annotated_frame = results[0].plot()
24: 
25:     # 顯示偵測結果
26:     cv2.imshow("YOLOv8 Live Detection", annotated_frame)
27: 
28:     # 按下 q 鍵離開
29:     if cv2.waitKey(1) & 0xFF == ord('q'):
30:         break
31: 
32: # 釋放資源
33: cap.release()
34: cv2.destroyAllWindows()
35: 

 1: import cv2
 2: 
 3: # 載入 Haar 人臉偵測模型（OpenCV 內建）
 4: face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
 5: 
 6: # 開啟攝影機（0 = 預設 webcam）
 7: cap = cv2.VideoCapture(0)
 8: 
 9: # 檢查攝影機是否開啟成功
10: if not cap.isOpened():
11:     print("❌ 無法開啟攝影機")
12:     exit()
13: 
14: while True:
15:     # 讀取一張影像
16:     ret, frame = cap.read()
17:     if not ret:
18:         print("❌ 無法讀取畫面")
19:         break
20: 
21:     # 轉成灰階影像（人臉偵測通常在灰階上進行）
22:     gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
23: 
24:     # 偵測人臉
25:     faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)
26: 
27:     # 畫出每一張人臉的位置
28:     for (x, y, w, h) in faces:
29:         cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
30: 
31:     # 顯示畫面
32:     cv2.imshow("Face Detection (press q to quit)", frame)
33: 
34:     # 按下 q 鍵結束
35:     if cv2.waitKey(1) & 0xFF == ord('q'):
36:         break
37: 
38: # 釋放資源
39: cap.release()
40: cv2.destroyAllWindows()
41: 

1: pip install face_recognition opencv-python

 1: from PIL import ImageFont, ImageDraw, Image
 2: import cv2, face_recognition, platform, pickle
 3: from ultralytics import YOLO
 4: import numpy as np
 5: 
 6: # 根據作業系統自動選擇中文字型
 7: system = platform.system()
 8: if system == "Windows":
 9:     font_path = "C:/Windows/Fonts/msjh.ttc"  # 微軟正黑體
10: elif system == "Darwin":
11:     font_path = "/System/Library/Fonts/STHeiti Medium.ttc"  # macOS 華文黑體
12: else:
13:     font_path = "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc"  # Linux (這個需自己安裝思源黑體)
14: font = ImageFont.truetype(font_path, 32)
15: 
16: # 啟用 MacBook 的內建 webcam
17: cap = cv2.VideoCapture(0)  # 0 是預設攝影機裝置
18: 
19: # 底下的pkl要改成你自己的路徑
20: with open("/Users/letranger/Downloads/images/encodings.pkl", "rb") as f:
21:     known_encodings, known_names = pickle.load(f)
22: 
23: model = YOLO("yolov8n.pt")
24: 
25: 
26: 
27: while True:
28:     ret, frame = cap.read()
29:     results = model(frame)
30: 
31:     for box in results[0].boxes.xyxy:
32:         x1, y1, x2, y2 = map(int, box)
33:         face_img = frame[y1:y2, x1:x2]
34:         rgb_face = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
35: 
36:         encodings = face_recognition.face_encodings(rgb_face)
37:         if encodings:
38:             match = face_recognition.compare_faces(known_encodings, encodings[0])
39:             name = known_names[match.index(True)] if True in match else "未知"
40: 
41:             # 將 OpenCV 圖像轉成 PIL 格式來畫中文字
42:             frame_pil = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
43:             draw = ImageDraw.Draw(frame_pil)
44:             draw.text((x1, y1-40), name, font=font, fill=(0, 255, 0))  # 顯示中文
45: 
46:             # 轉回 OpenCV 圖像
47:             frame = cv2.cvtColor(np.array(frame_pil), cv2.COLOR_RGB2BGR)
48: 
49:     cv2.imshow("Face Recognition + YOLO", frame)
50:     if cv2.waitKey(1) & 0xFF == ord('q'):
51:         break

 1: import cv2,
 2: import pickle
 3: import platform
 4: import face_recognition
 5: from ultralytics import YOLO
 6: from PIL import Image, ImageDraw, ImageFont
 7: import numpy as np
 8: 
 9: # 載入 YOLOv8 模型
10: model = YOLO("yolov8n.pt")
11: 
12: # 載入臉部特徵資料
13: with open("/Users/letranger/Dropbox/YOLO8/faces/encodings.pkl", "rb") as f:
14:     known_encodings, known_names = pickle.load(f)
15: 
16: # 載入中文字型
17: system = platform.system()
18: if system == "Windows":
19:     font_path = "C:/Windows/Fonts/msjh.ttc"  # 微軟正黑體
20: elif system == "Darwin":
21:     font_path = "/System/Library/Fonts/STHeiti Medium.ttc"  # macOS 華文黑體
22: else:
23:     font_path = "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc"  # Linux 思源黑體（需自行安裝）
24: 
25: font = ImageFont.truetype(font_path, 28)
26: 
27: # 開啟攝影機
28: cap = cv2.VideoCapture(0)
29: 
30: while True:
31:     ret, frame = cap.read()
32:     if not ret:
33:         break
34: 
35:     results = model(frame)
36:     boxes = results[0].boxes
37:     cls_names = results[0].names
38: 
39:     # 用 PIL 畫圖，支援中文
40:     image_pil = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
41:     draw = ImageDraw.Draw(image_pil)
42: 
43:     for i, box in enumerate(boxes.xyxy):
44:         x1, y1, x2, y2 = map(int, box.tolist())
45:         cls_id = int(boxes.cls[i])
46: 
47:         # 如果是人，做臉部辨識
48:         if cls_id == 0:
49:             face_img = frame[y1:y2, x1:x2]
50:             rgb_face = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
51:             # 使用 face_recognition 進行臉部辨識
52:             encodings = face_recognition.face_encodings(rgb_face)
53: 
54:             name = "未知"
55:             if encodings:
56:                 matches = face_recognition.compare_faces(known_encodings, encodings[0])
57:                 if True in matches:
58:                     name = known_names[matches.index(True)]
59: 
60:             draw.rectangle([(x1, y1), (x2, y2)], outline="green", width=3)
61:             draw.text((x1, y1 - 30), name, font=font, fill=(0, 255, 0))
62: 
63:         else:
64:             label = cls_names[cls_id]
65:             draw.rectangle([(x1, y1), (x2, y2)], outline="blue", width=3)
66:             draw.text((x1, y1 - 30), label, font=font, fill=(0, 0, 255))
67: 
68:     # 顯示結果
69:     frame = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
70:     cv2.imshow("YOLO + Face Recognition 中文版", frame)
71:     if cv2.waitKey(1) & 0xFF == ord('q'):
72:         break
73: 
74: cap.release()
75: cv2.destroyAllWindows()
76: 

1: yolo detect train model=yolov8n.pt data=data.yaml epochs=50 imgsz=640

 1: import cv2
 2: import platform
 3: import numpy as np
 4: from PIL import Image, ImageDraw, ImageFont
 5: from ultralytics import YOLO
 6: 
 7: # 載入訓練好的模型，這裡的路徑要改成你自己的，實際的資料夾位址請參考上面訓練模型的結果
 8: model = YOLO("/Users/letranger/Desktop/YOLO/runs/detect/train11/weights/best.pt")
 9: 
10: # 根據作業系統選擇中文字型
11: system = platform.system()
12: if system == "Windows":
13:     font_path = "C:/Windows/Fonts/msjh.ttc"
14: elif system == "Darwin":
15:     font_path = "/System/Library/Fonts/STHeiti Medium.ttc"
16: else:
17:     font_path = "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc"  # Linux 思源黑體（需先安裝）
18: 
19: font = ImageFont.truetype(font_path, 28)
20: 
21: # 啟用攝影機
22: cap = cv2.VideoCapture(0)
23: 
24: # 可選：設定解析度提升偵測效果
25: cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
26: cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
27: 
28: while True:
29:     ret, frame = cap.read()
30:     if not ret:
31:         break
32: 
33:     # YOLO 推論（可加入 conf=0.1 降低門檻）
34:     results = model(frame, conf=0.1)
35: 
36:     # 使用 PIL 處理中文字繪圖
37:     image_pil = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
38:     draw = ImageDraw.Draw(image_pil)
39: 
40:     for box in results[0].boxes:
41:         cls_id = int(box.cls[0])
42:         conf = float(box.conf[0])
43:         label = f"{model.names[cls_id]} ({conf:.2f})"
44: 
45:         x1, y1, x2, y2 = map(int, box.xyxy[0])
46:         draw.rectangle([(x1, y1), (x2, y2)], outline=(255, 0, 0), width=3)
47:         draw.text((x1, y1 - 30), label, font=font, fill=(255, 0, 0))
48: 
49:     # 回轉為 OpenCV 顯示格式
50:     annotated = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
51:     cv2.imshow("YOLOv8 Real-Time Detection 中文版", annotated)
52: 
53:     key = cv2.waitKey(1) & 0xFF
54:     if key == ord('q'):
55:         break
56:     elif key == ord('s'):
57:         cv2.imwrite("snapshot.jpg", frame)
58:         print("📸 已儲存畫面 snapshot.jpg")
59: 
60: cap.release()
61: cv2.destroyAllWindows()

 1: import cv2
 2: import platform
 3: import numpy as np
 4: from PIL import Image, ImageDraw, ImageFont
 5: from ultralytics import YOLO
 6: 
 7: # 載入 COCO 模型與自訓模型
 8: model_coco = YOLO("yolov8n.pt")  # 原生 80 類
 9: model_custom = YOLO("/Users/letranger/Desktop/YOLO/runs/detect/train11/weights/best.pt")  # 你訓練的模型
10: 
11: # 字型載入
12: system = platform.system()
13: if system == "Windows":
14:     font_path = "C:/Windows/Fonts/msjh.ttc"
15: elif system == "Darwin":
16:     font_path = "/System/Library/Fonts/STHeiti Medium.ttc"
17: else:
18:     font_path = "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc"
19: 
20: font = ImageFont.truetype(font_path, 28)
21: 
22: # 開啟攝影機
23: cap = cv2.VideoCapture(0)
24: cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
25: cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
26: 
27: while True:
28:     ret, frame = cap.read()
29:     if not ret:
30:         break
31: 
32:     # 使用兩個模型推論
33:     results_coco = model_coco(frame, conf=0.3)
34:     results_custom = model_custom(frame, conf=0.1)
35: 
36:     # 開啟 PIL 畫布
37:     image_pil = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
38:     draw = ImageDraw.Draw(image_pil)
39: 
40:     # 畫 COCO 模型結果（藍框）
41:     for box in results_coco[0].boxes:
42:         cls_id = int(box.cls[0])
43:         conf = float(box.conf[0])
44:         label = f"{model_coco.names[cls_id]} ({conf:.2f})"
45:         x1, y1, x2, y2 = map(int, box.xyxy[0])
46:         draw.rectangle([(x1, y1), (x2, y2)], outline=(0, 0, 255), width=2)
47:         draw.text((x1, y1 - 30), label, font=font, fill=(0, 0, 255))
48: 
49:     # 畫自訓模型結果（紅框）
50:     for box in results_custom[0].boxes:
51:         cls_id = int(box.cls[0])
52:         conf = float(box.conf[0])
53:         label = f"{model_custom.names[cls_id]} ({conf:.2f})"
54:         x1, y1, x2, y2 = map(int, box.xyxy[0])
55:         draw.rectangle([(x1, y1), (x2, y2)], outline=(255, 0, 0), width=3)
56:         draw.text((x1, y1 - 30), label, font=font, fill=(255, 0, 0))
57: 
58:     # 顯示影像
59:     annotated = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
60:     cv2.imshow("YOLOv8 COCO + 自訓模型", annotated)
61: 
62:     key = cv2.waitKey(1) & 0xFF
63:     if key == ord('q'):
64:         break
65:     elif key == ord('s'):
66:         cv2.imwrite("snapshot.jpg", frame)
67:         print("📸 已儲存畫面 snapshot.jpg")
68: 
69: cap.release()
70: cv2.destroyAllWindows()
71: 

1: import subprocess
2: subprocess.run(["afplay", "/System/Library/Sounds/Glass.aiff"])

 1: import threading
 2: import subprocess
 3: import cv2
 4: from ultralytics import YOLO
 5: 
 6: model = YOLO("yolov8n.pt")
 7: 
 8: target_class = "person"
 9: target_class_id = list(model.names.values()).index(target_class)
10: 
11: # 啟用內建攝影機
12: cap = cv2.VideoCapture(0)
13: 
14: def beep():
15:     subprocess.run(["afplay", "/System/Library/Sounds/Glass.aiff"])
16: 
17: while True:
18:     ret, frame = cap.read()
19:     if not ret:
20:         break
21: 
22:     results = model(frame)
23:     annotated = results[0].plot()
24: 
25:     class_ids = results[0].boxes.cls.cpu().numpy().astype(int) if results[0].boxes.cls is not None else []
26: 
27:     # 偵測到目標類別就嗶一聲
28:     if target_class_id in class_ids:
29:         threading.Thread(target=beep).start()
30: 
31:     cv2.imshow("YOLOv8 Real-Time Detection", annotated)
32:     if cv2.waitKey(1) & 0xFF == ord('q'):
33:         break
34: 
35: cap.release()
36: cv2.destroyAllWindows()
37: