J.J.'s Blogs

Python | OpenCV 與深度學習框架整合

2026-03-02T01:00:00.000Z

📚 前言

在前一篇我們學會了 多物件偵測與追蹤 (YOLO + DeepSORT)，這是偏向「應用層」的做法，直接利用 OpenCV 的 DNN 模組載入模型並完成任務。
然而，若要進一步開發專案或研究，就需要更高的彈性與可擴充性。

整合 PyTorch 或 TensorFlow/Keras 的好處在於：

可以載入各種預訓練模型（ResNet、MobileNet、YOLOv5 等）。
能使用自己訓練或微調過的模型，針對特定場景最佳化。
支援 GPU 加速，大幅提升即時推論效能。
允許修改網路結構、增加新層，甚至自行訓練，滿足研究與開發需求。
結合 OpenCV 的影像處理能力，打造更靈活的應用。

這樣不僅能「跑起來」，還能「改得動」，真正把電腦視覺應用推向研究與實務的下一步。

🎨 範例圖片/影片

這裡我們使用 Pexels 提供的免費圖片素材：Street Image。
下載後將檔名改為 street.jpg，在程式碼範例中使用。這張圖片中有車輛與行人，非常適合用來測試物件分類與定位。

這裡我們使用 Pexels 提供的免費影片素材：Street Video。
下載後將檔名改為 street.mp4，在程式碼範例中使用。影片中有車輛與行人，非常適合用來測試物件分類與定位。

🔎 原理說明

OpenCV：負責影像擷取、前處理與顯示。
深度學習框架：負責模型載入、推論與微調。
整合方式：框架輸出推論結果，OpenCV 負責繪製邊界框或文字。

📂 模型下載與使用說明

PyTorch

使用 torchvision.models 載入預訓練模型 (ResNet、MobileNet 等)。
可進行微調或自訂網路結構。

TensorFlow/Keras

使用 tf.keras.applications 載入預訓練模型 (MobileNetV2、ResNet50 等)。
API 友善，適合快速應用與部署。

🧠 函式與參數說明

PyTorch — `torchvision.models`

resnet18(weights=ResNet18_Weights.DEFAULT)：載入 ResNet18 預訓練模型，建議使用 weights 參數取代舊版的 pretrained=True，避免警告。
model.eval()：切換到推論模式。
weights.transforms()：取得官方推薦的前處理流程。
torch.topk(probs, 5)：取出前 5 個類別與機率。

TensorFlow/Keras — `tf.keras.applications`

MobileNetV2(weights="imagenet")：載入 MobileNetV2 預訓練模型。
preprocess_input(x)：對輸入影像做正規化。
model.predict(x)：進行推論，輸出 1000 類別的分數。
decode_predictions(preds, top=5)：解碼分類結果，顯示前 5 個預測類別與機率。

💻 範例程式 — PyTorch 整合 (ResNet18)

import torch
from torchvision.models import resnet18, ResNet18_Weights
import cv2
from PIL import Image

weights = ResNet18_Weights.DEFAULT
model = resnet18(weights=weights)
model.eval()

preprocess = weights.transforms()

img = cv2.imread("street.jpg")
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
pil_img = Image.fromarray(img_rgb)

input_tensor = preprocess(pil_img).unsqueeze(0)

with torch.no_grad():
    outputs = model(input_tensor)
    probs = torch.nn.functional.softmax(outputs[0], dim=0)

# 取前 5 個類別
top5 = torch.topk(probs, 5)

for idx, score in zip(top5.indices, top5.values):
    label = weights.meta["categories"][idx]
    print(f"{label}: {score:.4f}")

圖：使用 PyTorch ResNet18 對影像進行分類，Top-5 預測結果顯示模型的信心分布

📊 ResNet18 Top-5 預測結果

排名	類別 (Label)	機率 (Probability)
1	police van	0.3636
2	ambulance	0.2735
3	garbage truck	0.1055
4	tow truck	0.0890
5	minivan	0.0556

💻 範例程式 — TensorFlow/Keras 整合 (MobileNetV2)

import tensorflow as tf
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions
import cv2
import numpy as np

model = MobileNetV2(weights="imagenet")

img = cv2.imread("street.jpg")
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_resized = cv2.resize(img_rgb, (224, 224))

x = np.expand_dims(img_resized, axis=0)
x = preprocess_input(x)

preds = model.predict(x)

# 顯示前五個預測結果
results = decode_predictions(preds, top=5)[0]
for (imagenet_id, label, prob) in results:
    print(f"{label}: {prob:.4f}")

圖：使用 TensorFlow/Keras MobileNetV2 對影像進行分類，顯示前 5 個預測結果

📊 MobileNetV2 Top-5 預測結果

排名	類別 (Label)	機率 (Probability)
1	minivan	0.2867
2	minibus	0.2489
3	police van	0.1733
4	cab	0.0288
5	limousine	0.0198

🛠️ 與 OpenCV 結合的應用

即時影像分類：用框架載入模型，OpenCV 負責影像擷取與顯示。
物件偵測：用 PyTorch/TensorFlow 載入 YOLOv5/SSD 模型，OpenCV 負責繪製邊界框。
追蹤整合：框架提供特徵抽取，OpenCV + DeepSORT 負責追蹤。

⚠️ 注意事項

版本相容性：建議使用 Python 3.8–3.11，避免 3.12+ 的套件相容性問題。
GPU 支援：若要使用 CUDA，需安裝對應版本的 PyTorch/TensorFlow。
資料集準備：若要進行微調或訓練，需準備符合格式的影像資料集。

📊 應用場景

智慧交通：用框架載入 YOLOv5，結合 OpenCV 即時顯示。
人流分析：用 ResNet/MobileNet 做分類，OpenCV 負責影像擷取。
零售應用：用框架模型辨識商品，OpenCV 顯示結果。

🎯 結語

本篇我們學會了如何將 OpenCV 與深度學習框架整合，不再只是「跑起來」，而是能夠載入、修改、甚至微調模型。
這讓我們的應用更靈活，能同時滿足研究與實務需求。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV 官方文件 — Tutorials
OpenCV 官方文件 — Python Tutorials
PyTorch 官方安裝指南
 TensorFlow/Keras 官方文件
 Pexels — 免費圖片與影片素材

Python | OpenCV 多物件偵測與追蹤

2026-03-01T01:00:00.000Z

📚 前言

在前一篇我們學會了 物件分類與定位。
這一篇要進一步介紹 多物件偵測與追蹤 (Multi-Object Detection & Tracking)。
偵測是同時找到多個物件的位置，追蹤則是持續更新它們的移動並維持 ID。這是進入智慧監控與交通分析的重要技術。

🎨 範例圖片/影片

🔎 原理說明

多物件偵測：同時輸出多個邊界框與類別。
追蹤 (Tracking)：持續更新物件位置，並維持唯一 ID。
常見方法：
- YOLO (You Only Look Once)：即時多物件偵測。
- SSD (Single Shot Detector)：輕量化偵測模型。
- DeepSORT：結合偵測結果，維持物件 ID。

📂 模型下載與使用說明

YOLOv3-tiny (Darknet)

檔案名稱：
- yolov3-tiny.cfg
- yolov3-tiny.weights
下載來源：
- YOLO 官方網站 — pjreddie.com/darknet/yolo

使用方式：

1	net = cv2.dnn.readNetFromDarknet("yolov3-tiny.cfg", "yolov3-tiny.weights")

💡 YOLOv3-tiny 是輕量化版本，適合即時應用。

🧠 函式與參數說明

📌 `cv2.dnn.readNetFromDarknet()`

載入 YOLO 模型

1	net = cv2.dnn.readNetFromDarknet(cfg, weights)

cfg：模型結構檔案。
weights：訓練好的權重檔案。

📌 `cv2.dnn.blobFromImage()`

將圖片轉換成 DNN 輸入格式

1	blob = cv2.dnn.blobFromImage(image, scalefactor, size, mean, swapRB, crop)

image：輸入圖片。
scalefactor：縮放比例，常用 1/255.0。
size：輸入大小 (width, height)，例如 (416, 416)。
mean：減去的平均值，常用 (0, 0, 0)。
swapRB：是否交換 R 與 B 通道，常用 True。
crop：是否裁切圖片，常用 False。

💻 範例程式 — YOLO 多物件偵測 (圖片)

import cv2

net = cv2.dnn.readNetFromDarknet("models/yolov3-tiny.cfg", "models/yolov3-tiny.weights")
layer_names = net.getLayerNames()
output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]

img = cv2.imread("street.jpg")
(h, w) = img.shape[:2]
blob = cv2.dnn.blobFromImage(img, 1/255.0, (416, 416), swapRB=True, crop=False)

net.setInput(blob)
outputs = net.forward(output_layers)

for output in outputs:
    for detection in output:
        scores = detection[5:]
        class_id = int(scores.argmax())
        confidence = scores[class_id]
        if confidence > 0.5:
            box = detection[0:4] * [w, h, w, h]
            (centerX, centerY, width, height) = box.astype("int")
            x = int(centerX - width / 2)
            y = int(centerY - height / 2)
            cv2.rectangle(img, (x, y), (x + int(width), y + int(height)), (0, 255, 0), 2)

cv2.imshow("YOLO Object Detection", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：圖片多物件偵測，框選多個物件

💻 範例程式 — YOLO 多物件偵測 (影片)

import cv2

net = cv2.dnn.readNetFromDarknet("models/yolov3-tiny.cfg", "models/yolov3-tiny.weights")
layer_names = net.getLayerNames()
output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]

cap = cv2.VideoCapture("street.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    (h, w) = frame.shape[:2]
    blob = cv2.dnn.blobFromImage(frame, 1/255.0, (416, 416), swapRB=True, crop=False)

    net.setInput(blob)
    outputs = net.forward(output_layers)

    for output in outputs:
        for detection in output:
            scores = detection[5:]
            class_id = int(scores.argmax())
            confidence = scores[class_id]
            if confidence > 0.5:
                box = detection[0:4] * [w, h, w, h]
                (centerX, centerY, width, height) = box.astype("int")
                x = int(centerX - width / 2)
                y = int(centerY - height / 2)
                cv2.rectangle(frame, (x, y), (x + int(width), y + int(height)), (0, 255, 0), 2)

    cv2.imshow("YOLO Video Detection", frame)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：影片多物件偵測，逐幀框選多個物件

💻 範例程式 — YOLO + DeepSORT 多物件追蹤

# 範例僅示意，需安裝 deep_sort 套件
# pip install deep-sort-realtime

from deep_sort_realtime.deepsort_tracker import DeepSort
import cv2

net = cv2.dnn.readNetFromDarknet("models/yolov3-tiny.cfg", "models/yolov3-tiny.weights")
layer_names = net.getLayerNames()
output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]

tracker = DeepSort(max_age=30)

cap = cv2.VideoCapture("street.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    (h, w) = frame.shape[:2]
    blob = cv2.dnn.blobFromImage(frame, 1/255.0, (416, 416), swapRB=True, crop=False)
    net.setInput(blob)
    outputs = net.forward(output_layers)

    detections = []
    for output in outputs:
        for detection in output:
            scores = detection[5:]
            class_id = int(scores.argmax())
            confidence = scores[class_id]
            if confidence > 0.5:
                box = detection[0:4] * [w, h, w, h]
                (centerX, centerY, width, height) = box.astype("int")
                x = int(centerX - width / 2)
                y = int(centerY - height / 2)
                detections.append(([x, y, int(width), int(height)], confidence, class_id))

    tracks = tracker.update_tracks(detections, frame=frame)
    for track in tracks:
        if not track.is_confirmed():
            continue
        x1, y1, x2, y2 = track.to_ltrb()
        track_id = track.track_id
        cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 255), 2)
        cv2.putText(frame, f"ID {track_id}", (int(x1), int(y1)-10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,255), 2)

    cv2.imshow("YOLO + DeepSORT Tracking", frame)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：影片多物件偵測與追蹤，持續追蹤多個物件並維持唯一 ID

🛠️ 使用 DeepSORT 常見問題與解決辦法

在整合 YOLO 與 DeepSORT 的過程中，常會遇到一些環境或套件相容性的問題：

ModuleNotFoundError: No module named 'pkg_resources'
- 原因：Python 3.12+ 移除了 pkg_resources，導致 DeepSORT 初始化失敗。
- 解決：改用 Python 3.10 或 3.11 建立虛擬環境，並安裝 setuptools。
ModuleNotFoundError: No module named 'torch'
- 原因：PyTorch 尚未安裝。
- 解決：在虛擬環境中安裝 PyTorch 與 TorchVision：
  1
  pip install torch torchvision
ModuleNotFoundError: No module named 'torchvision'
- 原因：TorchVision 尚未安裝。
- 解決：補安裝 TorchVision：
  1
  pip install torchvision
環境衝突或安裝不完整
- 症狀：明明安裝了套件，仍然報錯。
- 解決：確認 Python 解譯器路徑正確，必要時刪掉 .venv，重新建立乾淨的虛擬環境，並一次安裝所有依賴：
  1
  2
  3
  4
  python3.10 -m venv .venv310
  .\.venv310\Scripts\activate
  pip install --upgrade pip wheel setuptools
  pip install numpy opencv-python torch torchvision deep-sort-realtime

💡 建議建立 requirements.txt，一次安裝所有依賴，避免逐一補套件。

⚠️ 注意事項

YOLO 模型檔案需先下載並放在專案目錄。
YOLOv3-tiny 適合即時應用，但準確度有限。
DeepSORT 需要額外的 ReID 模型，才能維持物件 ID。
偵測速度與準確度會因模型不同而有差異。

📊 應用場景

交通監控：同時追蹤多輛車輛。
群眾分析：統計人流數量與移動路徑。
智慧零售：追蹤顧客行為。
安全監控：辨識並追蹤可疑人物。

🎯 結語

本篇我們學會了如何使用 OpenCV 與 YOLO 模型進行 多物件偵測與追蹤，並結合 DeepSORT 維持物件 ID。
這是從「物件分類與定位」延伸而來的重要技術，能應用在交通監控、群眾分析與智慧零售等場景。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV 官方文件 — Tutorials
OpenCV 官方文件 — Python Tutorials
YOLO 官方網站 — pjreddie.com/darknet/yolo
deep-sort-realtime GitHub
Pexels — 免費圖片與影片素材

Python | OpenCV 物件分類與定位

2026-02-28T01:00:00.000Z

📚 前言

在前一篇我們學會了 人臉偵測與追蹤。
這一篇要進一步介紹 物件分類與定位 (Object Classification & Localization)。
分類是判斷「這是什麼物件」，定位則是標記「它在哪裡」。這是進入多物件偵測與追蹤之前的重要基礎。

🎨 範例圖片/影片

🔎 原理說明

分類 (Classification)：利用 CNN/DNN 模型判斷物件的類別，例如「人」、「車」、「狗」。
定位 (Localization)：輸出邊界框座標 (x, y, w, h)，標記物件位置。
OpenCV DNN 模組：支援 Caffe、TensorFlow、ONNX 等模型，可用於物件分類與定位。

📂 模型下載與使用說明

MobileNet SSD (Caffe)

檔案名稱：
- MobileNetSSD_deploy.prototxt
- MobileNetSSD_deploy.caffemodel
下載來源：
- GitHub — MobileNetSSD prototxt
- GitHub — MobileNetSSD caffemodel

使用方式：

1	net = cv2.dnn.readNetFromCaffe("MobileNetSSD_deploy.prototxt", "MobileNetSSD_deploy.caffemodel")

💡 下載後的檔案名稱可能不一致，可以自行重新命名即可。

🧠 函式與參數說明

📌 `cv2.dnn.readNetFromCaffe()`

載入 Caffe 模型

1	net = cv2.dnn.readNetFromCaffe(prototxt, model)

prototxt：模型結構檔案。
model：訓練好的權重檔案。

📌 `cv2.dnn.blobFromImage()`

將圖片轉換成 DNN 輸入格式

1	blob = cv2.dnn.blobFromImage(image, scalefactor, size, mean, swapRB, crop)

image：輸入圖片。
scalefactor：縮放比例，常用 0.007843。
size：輸入大小 (width, height)，例如 (300, 300)。
mean：減去的平均值，常用 (127.5, 127.5, 127.5)。
swapRB：是否交換 R 與 B 通道，常用 False。
crop：是否裁切圖片，常用 False。

💻 範例程式 — 圖片物件分類與定位

import cv2

net = cv2.dnn.readNetFromCaffe("models/MobileNetSSD_deploy.prototxt", "models/MobileNetSSD_deploy.caffemodel")

CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
           "bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
           "dog", "horse", "motorbike", "person", "pottedplant",
           "sheep", "sofa", "train", "tvmonitor"]

img = cv2.imread("street.jpg")
(h, w) = img.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(img, (300, 300)), 0.007843, (300, 300), 127.5)

net.setInput(blob)
detections = net.forward()

for i in range(detections.shape[2]):
    confidence = detections[0, 0, i, 2]
    if confidence > 0.5:
        idx = int(detections[0, 0, i, 1])
        box = detections[0, 0, i, 3:7] * [w, h, w, h]
        (x1, y1, x2, y2) = box.astype("int")
        label = CLASSES[idx]
        cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
        cv2.putText(img, label, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 2)

cv2.imshow("Object Classification & Localization", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：圖片物件分類與定位，框選並標記物件類別

💻 範例程式 — 影片物件分類與定位

import cv2

net = cv2.dnn.readNetFromCaffe("models/MobileNetSSD_deploy.prototxt", "models/MobileNetSSD_deploy.caffemodel")

CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
           "bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
           "dog", "horse", "motorbike", "person", "pottedplant",
           "sheep", "sofa", "train", "tvmonitor"]

cap = cv2.VideoCapture("street.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    (h, w) = frame.shape[:2]
    blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 0.007843, (300, 300), 127.5)

    net.setInput(blob)
    detections = net.forward()

    for i in range(detections.shape[2]):
        confidence = detections[0, 0, i, 2]
        if confidence > 0.5:
            idx = int(detections[0, 0, i, 1])
            box = detections[0, 0, i, 3:7] * [w, h, w, h]
            (x1, y1, x2, y2) = box.astype("int")
            label = CLASSES[idx]
            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
            cv2.putText(frame, label, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 2)

    cv2.imshow("Video Object Classification & Localization", frame)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：影片物件分類與定位，逐幀框選並標記物件類別

⚠️ 注意事項

模型檔案需先下載並放在專案目錄。
MobileNet SSD 適合即時應用，但準確度有限。
若需要更高準確度，可以使用 YOLO 或 Faster R-CNN。
偵測速度與準確度會因模型不同而有差異。

📊 應用場景

自駕車：辨識道路上的車輛與行人。
監控系統：即時分類並定位可疑物件。
智慧零售：辨識商品種類與位置。
互動遊戲：追蹤玩家與物件位置。

🎯 結語

本篇我們學會了如何使用 OpenCV 物件分類與定位，透過 DNN 模型在圖片與影片中辨識物件並標記位置。
這是進入 多物件偵測與追蹤 的重要基礎，因為只有先理解「分類」與「定位」的概念，才能進一步處理多個物件的同時偵測與持續追蹤。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV 官方文件 — Tutorials
OpenCV 官方文件 — Python Tutorials
OpenCV GitHub — Haar Cascades
OpenCV GitHub — LBP Cascades
OpenCV GitHub — DNN Face Detector (deploy.prototxt)
GitHub — MobileNetSSD 模型
 Pexels — 免費影片素材

Python | OpenCV 人臉偵測與追蹤

2026-02-27T01:00:00.000Z

📚 前言

在前一篇我們學會了 即時馬賽克與模糊處理。
這一篇要進一步介紹 人臉偵測與追蹤，並且提供三種常見方式：

Haar Cascades
LBP Cascades
DNN (深度學習模型)

🎨 範例圖片/影片

這裡我們使用 Pexels 提供的免費圖片素材：Face Image。
下載後將檔名改為 face.jpg，在程式碼範例中使用。這張圖片中有多種臉部表情，非常適合用來測試追蹤演算法。

這邊一樣使用 Pexels 提供的免費影片素材：Face Video。
下載後將檔名改為 face.mp4，在程式碼範例中使用。這段影片中有明顯的移動物件，非常適合用來測試追蹤演算法。

🔎 三種方式比較

方法	檔案來源	優點	缺點
Haar Cascades	OpenCV GitHub	經典、教學常用	準確度有限，受光線影響
LBP Cascades	OpenCV GitHub	偵測速度快	準確度比 Haar 稍低
DNN (Caffe 模型)	OpenCV Model Zoo	準確度高，抗光線	模型檔案較大，需 DNN 模組

📂 檔案下載與使用說明

在進行人臉偵測與追蹤之前，需要先下載對應的模型檔案，並放到專案目錄或指定路徑。

Haar Cascades

檔案名稱：haarcascade_frontalface_default.xml
下載來源：OpenCV GitHub — haarcascades

使用方式：

1	face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

LBP Cascades

檔案名稱：lbpcascade_frontalface.xml
下載來源：OpenCV GitHub — lbpcascades

使用方式：

1	face_cascade = cv2.CascadeClassifier("lbpcascade_frontalface.xml")

DNN 模型 (Caffe)

檔案名稱：
- deploy.prototxt
- res10_300x300_ssd_iter_140000.caffemodel
下載來源：
- OpenCV GitHub — DNN Face Detector (deploy.prototxt)
- GitHub — res10_300x300_ssd_iter_140000.caffemodel

使用方式：

1	net = cv2.dnn.readNetFromCaffe("deploy.prototxt", "res10_300x300_ssd_iter_140000.caffemodel")

💡 建議將這些檔案放在專案的 models/ 目錄下，並在程式中指定完整路徑，避免找不到檔案的錯誤。

🧠 函式與參數說明

📌 `cv2.CascadeClassifier()`

載入人臉偵測模型

1	cv2.CascadeClassifier(filename)

filename：XML 模型檔案路徑，例如 haarcascade_frontalface_default.xml 或 lbpcascade_frontalface.xml。

📌 `detectMultiScale()`

偵測人臉區域

1	faces = face_cascade.detectMultiScale(img, scaleFactor, minNeighbors, flags, minSize, maxSize)

img：要偵測的灰階圖片或影片幀。
scaleFactor：縮放比例，常用 1.1，表示每次縮小 10%。
minNeighbors：判斷人臉的嚴格程度，數值越大越嚴格。
flags：可選參數，通常設為 cv2.CASCADE_SCALE_IMAGE。
minSize：最小人臉尺寸 (w, h)。
maxSize：最大人臉尺寸 (w, h)。

📌 `cv2.dnn.readNetFromCaffe()`

載入 DNN 模型

1	net = cv2.dnn.readNetFromCaffe(prototxt, model)

prototxt：模型結構檔案，例如 deploy.prototxt。
model：訓練好的權重檔案，例如 res10_300x300_ssd_iter_140000.caffemodel。

📌 `cv2.dnn.blobFromImage()`

將圖片轉換成 DNN 輸入格式

1	blob = cv2.dnn.blobFromImage(image, scalefactor, size, mean, swapRB, crop)

image：輸入圖片。
scalefactor：縮放比例，常用 1.0。
size：輸入大小 (width, height)，例如 (300, 300)。
mean：減去的平均值 (R, G, B)，例如 (104.0, 177.0, 123.0)。
swapRB：是否交換 R 與 B 通道，常用 False。
crop：是否裁切圖片，常用 False。

📌 `cv2.TrackerKCF_create()`

建立 KCF 追蹤器

1	tracker = cv2.TrackerKCF_create()

建立一個 KCF (Kernelized Correlation Filters) 追蹤器，用於追蹤人臉或物件。

📌 `tracker.init()`

初始化追蹤器

1	tracker.init(frame, bbox)

frame：影片幀。
bbox：初始框選區域 (x, y, w, h)。

📌 `tracker.update()`

更新追蹤器位置

1	success, box = tracker.update(frame)

frame：影片幀。
success：布林值，表示是否成功追蹤。
box：新的框選區域 (x, y, w, h)。

💻 範例程式 — Haar Cascades 人臉偵測 (圖片)

import cv2

face_cascade = cv2.CascadeClassifier("models/haarcascade_frontalface_default.xml")

img = cv2.imread("face.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

faces = face_cascade.detectMultiScale(gray, 1.1, 5)

for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)

cv2.imshow("Haar Face Detection", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：圖片人臉偵測，框選人臉區域

💻 範例程式 — LBP Cascades 人臉偵測 (影片)

import cv2

face_cascade = cv2.CascadeClassifier("models/lbpcascade_frontalface.xml")
cap = cv2.VideoCapture("face.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.1, 5)

    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)

    cv2.imshow("LBP Face Detection", frame)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：影片人臉偵測，逐幀框選人臉區域

💻 範例程式 — DNN 人臉偵測 (影片)

import cv2

net = cv2.dnn.readNetFromCaffe("models/deploy.prototxt", "models/res10_300x300_ssd_iter_140000.caffemodel")
cap = cv2.VideoCapture("face.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    h, w = frame.shape[:2]
    blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 1.0,
                                 (300, 300), (104.0, 177.0, 123.0))
    net.setInput(blob)
    detections = net.forward()

    for i in range(detections.shape[2]):
        confidence = detections[0, 0, i, 2]
        if confidence > 0.5:
            box = detections[0, 0, i, 3:7] * [w, h, w, h]
            (x1, y1, x2, y2) = box.astype("int")
            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 255), 2)

    cv2.imshow("DNN Face Detection", frame)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：影片人臉偵測 (DNN)，準確度更高

💻 範例程式 — 人臉偵測 + 追蹤

import cv2

# 使用 LBP 模型偵測人臉
face_cascade = cv2.CascadeClassifier("models/lbpcascade_frontalface.xml")
cap = cv2.VideoCapture("face.mp4")

tracker = None

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # 如果追蹤器尚未建立，先偵測人臉
    if tracker is None:
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray, 1.1, 5)

        if len(faces) > 0:
            (x, y, w, h) = faces[0]
            tracker = cv2.TrackerKCF_create()
            tracker.init(frame, (x, y, w, h))
    else:
        # 更新追蹤器位置
        success, box = tracker.update(frame)
        if success:
            (x, y, w, h) = [int(v) for v in box]
            cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 255), 2)
        else:
            # 若追蹤失敗，重置追蹤器
            tracker = None

    cv2.imshow("Face Tracking", frame)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：影片人臉偵測與追蹤，持續追蹤人臉位置

⚠️ 注意事項

Haar 與 LBP 模型需先下載 XML 檔案並放在專案目錄。
DNN 模型需下載 deploy.prototxt 與 res10_300x300_ssd_iter_140000.caffemodel。
偵測速度與準確度會因方法不同而有差異。
追蹤器需要先偵測到人臉才能開始追蹤，若人臉消失需重新偵測。

📊 應用場景

監控系統：即時偵測並追蹤人臉。
互動應用：遊戲或互動程式中追蹤玩家人臉。
隱私保護：結合馬賽克或模糊，遮蔽人臉。

🎯 結語

本篇我們學會了如何使用 OpenCV 人臉偵測與追蹤，並且比較了 Haar、LBP 與 DNN 三種方式。
這些技術在監控、互動應用與隱私保護中非常常見，後續可以延伸到 多物件偵測與追蹤，打造更智慧的影像系統。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV 官方文件 — Tutorials
OpenCV 官方文件 — Python Tutorials
OpenCV GitHub — Haar Cascades
OpenCV GitHub — LBP Cascades
OpenCV GitHub — DNN Face Detector (deploy.prototxt)
GitHub — DNN 模型 res10_300x300_ssd_iter_140000.caffemodel
Pexels — 免費影片素材

Python | OpenCV 即時馬賽克與模糊處理

2026-02-26T01:00:00.000Z

📚 前言

在前一篇我們學會了 圖片與影片即時標記與繪圖。
這一篇要進一步介紹 即時馬賽克與模糊處理，並結合滑鼠事件互動。
透過這項技術，我們可以在圖片或影片中框選區域，並即時套用馬賽克或模糊效果，常用於隱私保護、教學影片或監控系統。

🔎 原理說明

馬賽克 (Mosaic)：將區域縮小再放大，形成像素化效果。
模糊 (Blur)：使用高斯模糊或平均模糊，讓區域變得柔和不清晰。
滑鼠事件：透過 cv2.setMouseCallback() 框選區域，並即時套用效果。

🧠 函式與參數說明

📌 `cv2.resize()`

縮放圖片，用於馬賽克效果

1	cv2.resize(img, dsize, interpolation)

img：要縮放的圖片。
dsize：縮放後的大小 (width, height)。
interpolation：插值方式，例如 cv2.INTER_LINEAR 或 cv2.INTER_NEAREST。

📌 `cv2.GaussianBlur()`

高斯模糊

1	cv2.GaussianBlur(img, ksize, sigmaX)

img：要模糊的圖片。
ksize：模糊範圍大小 (width, height)，必須為奇數。
sigmaX：高斯函數在 X 方向的標準差。

💻 範例程式一 — 圖片即時馬賽克與模糊

import cv2

img = cv2.imread("test.png")  # 部落格頭像
backup = img.copy()

drawing = False
start_point = None
end_point = None
mode = "mosaic"  # 可切換 "mosaic" 或 "blur"

def mouse_event(event, x, y, flags, param):
    global drawing, start_point, end_point, img, backup

    if event == cv2.EVENT_LBUTTONDOWN:
        drawing = True
        start_point = (x, y)

    elif event == cv2.EVENT_MOUSEMOVE and drawing:
        img = backup.copy()
        cv2.rectangle(img, start_point, (x, y), (0, 0, 255), 2)

    elif event == cv2.EVENT_LBUTTONUP:
        drawing = False
        end_point = (x, y)

        x1, y1 = start_point
        x2, y2 = end_point
        roi = backup[min(y1,y2):max(y1,y2), min(x1,x2):max(x1,x2)]

        if roi.size > 0:
            if mode == "mosaic":
                mosaic = cv2.resize(roi, (20, 20), interpolation=cv2.INTER_LINEAR)
                mosaic = cv2.resize(mosaic, (roi.shape[1], roi.shape[0]), interpolation=cv2.INTER_NEAREST)
                backup[min(y1,y2):max(y1,y2), min(x1,x2):max(x1,x2)] = mosaic
            else:
                blur = cv2.GaussianBlur(roi, (25, 25), 30)
                backup[min(y1,y2):max(y1,y2), min(x1,x2):max(x1,x2)] = blur
            img = backup.copy()

cv2.namedWindow("Image Effect")
cv2.setMouseCallback("Image Effect", mouse_event)

while True:
    cv2.imshow("Image Effect", img)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cv2.destroyAllWindows()

圖：圖片即時馬賽克與模糊，滑鼠框選區域後套用效果

💻 範例程式二 — 影片即時馬賽克與模糊

import cv2

cap = cv2.VideoCapture("video.mp4")

drawing = False
start_point = None
end_point = None
mode = "blur"  # 可切換 "mosaic" 或 "blur"

def mouse_event(event, x, y, flags, param):
    global drawing, start_point, end_point

    if event == cv2.EVENT_LBUTTONDOWN:
        drawing = True
        start_point = (x, y)

    elif event == cv2.EVENT_MOUSEMOVE and drawing:
        end_point = (x, y)

    elif event == cv2.EVENT_LBUTTONUP:
        drawing = False
        end_point = (x, y)

cv2.namedWindow("Video Effect")
cv2.setMouseCallback("Video Effect", mouse_event)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    if start_point and end_point:
        x1, y1 = start_point
        x2, y2 = end_point
        roi = frame[min(y1,y2):max(y1,y2), min(x1,x2):max(x1,x2)]

        if roi.size > 0:
            if mode == "mosaic":
                mosaic = cv2.resize(roi, (20, 20), interpolation=cv2.INTER_LINEAR)
                mosaic = cv2.resize(mosaic, (roi.shape[1], roi.shape[0]), interpolation=cv2.INTER_NEAREST)
                frame[min(y1,y2):max(y1,y2), min(x1,x2):max(x1,x2)] = mosaic
            else:
                blur = cv2.GaussianBlur(roi, (25, 25), 30)
                frame[min(y1,y2):max(y1,y2), min(x1,x2):max(x1,x2)] = blur

        cv2.rectangle(frame, start_point, end_point, (0, 0, 255), 2)

    cv2.imshow("Video Effect", frame)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：影片即時馬賽克與模糊，滑鼠框選區域後套用效果

⚠️ 注意事項

框選座標需在圖片或影片範圍內，否則會出錯。
馬賽克效果依縮放大小決定顆粒粗細。
模糊效果需選擇合適的 ksize，數值越大模糊越明顯。
在影片範例中需依影片 FPS 調整 cv2.waitKey() 的數值。

📊 應用場景

隱私保護：遮蔽人臉或敏感資訊。
教學影片：模糊背景，凸顯重點。
監控系統：即時隱藏不必要的資訊。
互動應用：讓使用者自由選擇區域並套用效果。

🎯 結語

本篇我們學會了如何使用 OpenCV 即時馬賽克與模糊處理，透過滑鼠事件在圖片或影片中框選區域並套用效果。
這樣的互動方式讓影像處理更靈活，後續可以延伸到 人臉偵測與追蹤，打造更智慧的影像應用。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials
Pexels — 免費影片素材

Python | OpenCV 圖片與影片即時標記與繪圖

2026-02-25T01:00:00.000Z

📚 前言

在前一篇我們學會了 滑鼠與鍵盤事件互動。
這一篇要介紹 圖片與影片即時標記與繪圖，並且加入滑鼠事件互動。
透過這項技術，我們可以在單張圖片或播放影片時，用滑鼠圈選矩形區域，動態標記內容。這在教學、監控或互動應用中非常常見。

🔎 原理說明

圖片：載入單張圖片，透過滑鼠事件在圖片上繪製矩形。
影片：逐幀讀取影片或攝影機影像，並在每一幀上根據滑鼠座標繪製矩形。
滑鼠事件：透過 cv2.setMouseCallback() 監聽滑鼠操作。

🧠 函式與參數說明

📌 `cv2.setMouseCallback()`

設定滑鼠事件回呼函式

1	cv2.setMouseCallback(winname, onMouse)

winname：視窗名稱。
onMouse：滑鼠事件處理函式。

📌 `cv2.rectangle()`

繪製矩形

1	cv2.rectangle(img, pt1, pt2, color, thickness)

img：要繪製的圖片或影片幀。
pt1：左上角座標 (x1, y1)。
pt2：右下角座標 (x2, y2)。
color：矩形顏色 (B, G, R)。
thickness：邊框粗細，若設為 -1 則填滿矩形。

💻 範例程式一 — 圖片即時滑鼠繪圖

import cv2

img = cv2.imread("test.png")
backup = img.copy()

drawing = False
start_point = None
end_point = None

def mouse_event(event, x, y, flags, param):
    global drawing, start_point, end_point, img

    if event == cv2.EVENT_LBUTTONDOWN:   # 左鍵按下，開始框選
        drawing = True
        start_point = (x, y)

    elif event == cv2.EVENT_MOUSEMOVE and drawing:  # 框選過程
        img = backup.copy()
        cv2.rectangle(img, start_point, (x, y), (0, 0, 255), 2)

    elif event == cv2.EVENT_LBUTTONUP:   # 左鍵放開，完成框選
        drawing = False
        end_point = (x, y)
        cv2.rectangle(img, start_point, end_point, (0, 255, 0), 2)

cv2.namedWindow("Image Drawing")
cv2.setMouseCallback("Image Drawing", mouse_event)

while True:
    cv2.imshow("Image Drawing", img)
    if cv2.waitKey(1) & 0xFF == ord('q'):  # 按下 q 鍵退出
        break

cv2.destroyAllWindows()

圖：圖片即時滑鼠繪圖，使用滑鼠框選矩形區域

💻 範例程式二 — 影片即時滑鼠繪圖

import cv2

cap = cv2.VideoCapture("video.mp4")

drawing = False
start_point = None
end_point = None

def mouse_event(event, x, y, flags, param):
    global drawing, start_point, end_point

    if event == cv2.EVENT_LBUTTONDOWN:   # 左鍵按下，開始框選
        drawing = True
        start_point = (x, y)

    elif event == cv2.EVENT_MOUSEMOVE and drawing:  # 框選過程
        end_point = (x, y)

    elif event == cv2.EVENT_LBUTTONUP:   # 左鍵放開，完成框選
        drawing = False
        end_point = (x, y)

cv2.namedWindow("Video Drawing")
cv2.setMouseCallback("Video Drawing", mouse_event)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # 如果正在框選或已完成框選，畫矩形
    if start_point and end_point:
        cv2.rectangle(frame, start_point, end_point, (0, 0, 255), 2)

    cv2.imshow("Video Drawing", frame)

    if cv2.waitKey(30) & 0xFF == ord('q'):  # 按下 q 鍵退出
        break

cap.release()
cv2.destroyAllWindows()

圖：影片即時滑鼠繪圖，使用滑鼠框選矩形區域

⚠️ 注意事項

滑鼠事件必須綁定在 cv2.namedWindow() 建立的視窗上。
框選座標需在圖片或影片範圍內，否則會出錯。
在圖片範例中使用 backup.copy()，避免矩形疊加造成畫面混亂。
在影片範例中需依影片 FPS 調整 cv2.waitKey() 的數值，常用 30 毫秒。

📊 應用場景

圖片標註：在圖片上框選重點區域。
教學影片標註：在影片中即時框選重點。
監控系統：即時標記偵測到的物件。
互動應用：讓使用者在圖片或影片中自由繪製。

🎯 結語

本篇我們學會了如何使用 OpenCV 圖片與影片即時標記與繪圖，透過滑鼠事件在圖片或影片中框選矩形。
這樣的互動方式讓標記更靈活，後續可以延伸到 即時馬賽克或模糊處理，打造更實用的影像應用。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials
Pexels — 免費影片素材

Python | OpenCV 滑鼠與鍵盤事件互動

2026-02-24T01:00:00.000Z

📚 前言

在前一篇我們學會了 光流分析 (Optical Flow)。
這一篇要介紹 滑鼠與鍵盤事件互動，這是 OpenCV 提供的基礎功能之一。
透過事件回呼 (callback) 與按鍵控制，我們可以讓程式更具互動性，例如：

滑鼠點擊選取 ROI 區域
按鍵控制圖片顯示或儲存
結合互動操作進行物件追蹤或圖片編輯

🔎 原理說明

滑鼠事件：透過 cv2.setMouseCallback() 設定事件回呼函式，偵測滑鼠在視窗中的操作。
鍵盤事件：透過 cv2.waitKey() 取得使用者按下的鍵盤按鍵，進行互動控制。

🧠 函式與參數說明

📌 `cv2.setMouseCallback()`

用途：設定滑鼠事件回呼函式。

1	cv2.setMouseCallback("Window", mouse_event)

“Window”：視窗名稱。
mouse_event：自訂的事件函式。

📌 滑鼠事件回呼函式

1 2	def mouse_event(event, x, y, flags, param): ...

event：事件類型，例如 cv2.EVENT_LBUTTONDOWN (左鍵按下)、cv2.EVENT_RBUTTONDOWN (右鍵按下)、cv2.EVENT_MOUSEMOVE (滑鼠移動)。
x, y：滑鼠座標位置。
flags：事件狀態，例如是否按下 Ctrl、Shift。
param：額外參數，可自訂傳入。

🏷️ 常見滑鼠事件 (event)

cv2.EVENT_LBUTTONDOWN：左鍵按下
cv2.EVENT_LBUTTONUP：左鍵放開
cv2.EVENT_RBUTTONDOWN：右鍵按下
cv2.EVENT_RBUTTONUP：右鍵放開
cv2.EVENT_MBUTTONDOWN：中鍵按下
cv2.EVENT_MOUSEMOVE：滑鼠移動
cv2.EVENT_LBUTTONDBLCLK：左鍵雙擊

🏷️ 常見滑鼠旗標 (flags)

cv2.EVENT_FLAG_CTRLKEY：Ctrl 鍵按下
cv2.EVENT_FLAG_SHIFTKEY：Shift 鍵按下
cv2.EVENT_FLAG_ALTKEY：Alt 鍵按下
cv2.EVENT_FLAG_LBUTTON：左鍵按住
cv2.EVENT_FLAG_RBUTTON：右鍵按住
cv2.EVENT_FLAG_MBUTTON：中鍵按住

📌 `cv2.waitKey()`

用途：等待鍵盤事件。

1	key = cv2.waitKey(0)

0：無限等待。
正數：等待指定毫秒數。
回傳值：按下的鍵盤代碼 (ASCII)。

🏷️ ASCII 簡介

ASCII (American Standard Code for Information Interchange)：一種字元編碼標準，用數字表示字母、數字與符號。
例如：ord('a') = 97，ord('A') = 65。
在 OpenCV 中，cv2.waitKey() 會回傳按鍵的 ASCII 值，我們可以用 ord() 來比對。

圖：ASCII 編碼表

來源：ASCII 編碼表

💻 範例程式 — 滑鼠事件互動

import cv2
import numpy as np

# 滑鼠事件回呼函式
def mouse_event(event, x, y, flags, param):
    if event == cv2.EVENT_LBUTTONDOWN:   # 左鍵按下
        print(f"左鍵點擊位置: ({x}, {y})")
        cv2.circle(img, (x, y), 5, (0, 0, 255), -1)  # 在點擊位置畫紅色圓點
    elif event == cv2.EVENT_RBUTTONDOWN: # 右鍵按下
        print(f"右鍵點擊位置: ({x}, {y})")
        cv2.rectangle(img, (x-10, y-10), (x+10, y+10), (0, 255, 0), 2)  # 畫綠色方框
    elif event == cv2.EVENT_MOUSEMOVE:   # 滑鼠移動
        print(f"滑鼠移動位置: ({x}, {y})")

# 建立視窗
cv2.namedWindow("Image")
cv2.setMouseCallback("Image", mouse_event)

# 建立一張白色圖片
img = 255 * np.ones((400, 600, 3), dtype=np.uint8)

while True:
    cv2.imshow("Image", img)
    if cv2.waitKey(1) & 0xFF == ord('q'):  # 按下 q 鍵退出
        break

cv2.destroyAllWindows()

圖：滑鼠事件互動，點擊位置會顯示圓點或方框

💻 範例程式 — 滑鼠事件互動 (座標、畫點、連線)

import cv2
import numpy as np

points = []  # 儲存點座標

def mouse_event(event, x, y, flags, param):
    global points
    if event == cv2.EVENT_LBUTTONDOWN:   # 左鍵按下
        print(f"左鍵點擊位置: ({x}, {y})")
        points.append((x, y))
        cv2.circle(img, (x, y), 5, (0, 0, 255), -1)  # 畫紅色圓點
        if len(points) >= 2:
            cv2.line(img, points[-2], points[-1], (255, 0, 0), 2)  # 連線

# 建立視窗
cv2.namedWindow("Image")
cv2.setMouseCallback("Image", mouse_event)

# 建立一張白色圖片
img = 255 * np.ones((400, 600, 3), dtype=np.uint8)

while True:
    cv2.imshow("Image", img)
    if cv2.waitKey(1) & 0xFF == ord('q'):  # 按下 q 鍵退出
        break

cv2.destroyAllWindows()

圖：滑鼠事件互動，點擊位置會顯示圓點並連線

💻 範例程式 — 滑鼠圈選框框並馬賽克化

import cv2

img = cv2.imread("test.png")  # 部落格頭像
backup = img.copy()           # 保留原始圖片

# 儲存框選座標
rect_start = None
rect_end = None
drawing = False

def mouse_event(event, x, y, flags, param):
    global rect_start, rect_end, drawing, img, backup

    if event == cv2.EVENT_LBUTTONDOWN:   # 左鍵按下，開始框選
        rect_start = (x, y)
        drawing = True

    elif event == cv2.EVENT_MOUSEMOVE and drawing:  # 框選過程
        img = backup.copy()
        cv2.rectangle(img, rect_start, (x, y), (0, 0, 255), 2)

    elif event == cv2.EVENT_LBUTTONUP:   # 左鍵放開，完成框選
        rect_end = (x, y)
        drawing = False

        # 取得框選範圍
        x1, y1 = rect_start
        x2, y2 = rect_end
        roi = backup[min(y1,y2):max(y1,y2), min(x1,x2):max(x1,x2)]

        # 對 ROI 區域進行馬賽克化
        if roi.size > 0:
            mosaic = cv2.resize(roi, (20, 20), interpolation=cv2.INTER_LINEAR)
            mosaic = cv2.resize(mosaic, (roi.shape[1], roi.shape[0]), interpolation=cv2.INTER_NEAREST)
            backup[min(y1,y2):max(y1,y2), min(x1,x2):max(x1,x2)] = mosaic
            img = backup.copy()
            print(f"框選區域已馬賽克化: ({x1}, {y1}) ~ ({x2}, {y2})")

cv2.namedWindow("Mosaic Demo")
cv2.setMouseCallback("Mosaic Demo", mouse_event)

while True:
    cv2.imshow("Mosaic Demo", img)
    if cv2.waitKey(1) & 0xFF == ord('q'):  # 按下 q 鍵退出
        break

cv2.destroyAllWindows()

圖：滑鼠事件互動，圈選框框後該區域會被馬賽克化

💻 範例程式 — 鍵盤事件互動 (調整亮度與對比度)

import cv2
import numpy as np

# 建立一張灰色圖片
img = np.ones((400, 600, 3), dtype=np.uint8) * 127
alpha, beta = 1.0, 0  # 對比度、亮度

while True:
    adjusted = cv2.convertScaleAbs(img, alpha=alpha, beta=beta)
    cv2.imshow("Keyboard Demo", adjusted)

    key = cv2.waitKey(0) & 0xFF

    if key == ord('+'):   # 增加亮度
        beta += 10
        print(f"亮度增加: {beta}")
    elif key == ord('-'): # 減少亮度
        beta -= 10
        print(f"亮度減少: {beta}")
    elif key == ord(']'): # 增加對比度
        alpha += 0.1
        print(f"對比度增加: {alpha}")
    elif key == ord('['): # 減少對比度
        alpha = max(0.1, alpha - 0.1)
        print(f"對比度減少: {alpha}")
    elif key == ord('r'): # 重置
        alpha, beta = 1.0, 0
        print("重置亮度與對比度")
    elif key == 27 or key == ord('q'): # ESC 或 q 鍵退出
        print("程式結束")
        break

cv2.destroyAllWindows()

圖：鍵盤事件互動，透過鍵盤調整亮度與對比度

💻 範例程式 — 鍵盤事件互動

import cv2
import numpy as np

# 建立一張白色圖片
img = 255 * np.ones((400, 600, 3), dtype=np.uint8)
backup = img.copy()  # 保留原始圖片

# 滑鼠事件：左鍵畫紅色圓點
def mouse_event(event, x, y, flags, param):
    global img
    if event == cv2.EVENT_LBUTTONDOWN:
        cv2.circle(img, (x, y), 5, (0, 0, 255), -1)
        print(f"畫紅點於座標: ({x}, {y})")

cv2.namedWindow("Demo")
cv2.setMouseCallback("Demo", mouse_event)

while True:
    cv2.imshow("Demo", img)
    key = cv2.waitKey(1) & 0xFF

    if key == ord('s'):   # 按下 s 鍵儲存圖片
        cv2.imwrite("output.png", img)
        print("圖片已儲存為 output.png")
    elif key == ord('c'): # 按下 c 鍵清除圖片 (回到原始白色)
        img = backup.copy()
        print("圖片已清除")
    elif key == ord('q'): # 按下 q 鍵退出
        print("程式結束")
        break

cv2.destroyAllWindows()

圖：鍵盤事件互動，支援滑鼠畫點，並可透過 s 鍵儲存圖片、c 鍵清除畫面、q 鍵退出

⚠️ 注意事項

滑鼠事件必須搭配 cv2.namedWindow() 與 cv2.setMouseCallback() 使用。
cv2.waitKey() 的回傳值需搭配 ord() 判斷字元。
不同作業系統的鍵盤代碼可能略有差異。
建議在迴圈中使用 cv2.waitKey(1)，避免程式卡住
滑鼠事件與鍵盤事件可以結合，例如：滑鼠框選 ROI，再用鍵盤確認或儲存。

📊 應用場景

ROI 選取：透過滑鼠框選物件區域。
互動式標註：人工標記圖片中的特徵點。
遊戲互動：結合鍵盤控制與圖片顯示。
圖片編輯：透過滑鼠與鍵盤操作進行裁切、儲存。

🎯 結語

本篇我們學會了如何使用 OpenCV 滑鼠與鍵盤事件互動，透過事件回呼與按鍵控制，讓程式更具互動性。
這些技術在 ROI 選取、圖片標註、互動式應用中非常常見，後續可以結合物件追蹤或光流分析，打造更完整的互動系統。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials
Pexels — 免費影片素材

Python | OpenCV 光流分析 (Optical Flow)

2026-02-23T01:00:00.000Z

📚 前言

在前一篇我們學會了 即時圖片中的物件追蹤。
這一篇要介紹 光流分析 (Optical Flow)，它是一種用來估計圖片中物件移動的方法。
光流分析常用於運動偵測、物件追蹤、影片穩定化等場景。

🎨 範例影片

這裡我們使用 Pexels 提供的免費影片素材：Tennis Video。
下載後將檔名改為 tennis.mp4，在程式碼範例中使用。這段影片中有明顯的移動物件，非常適合用來測試追蹤演算法。

🔎 原理說明

光流 (Optical Flow)：描述圖片中像素隨時間的移動。
兩種常用方法：
1. Lucas-Kanade Optical Flow：追蹤特徵點的移動，適合少量特徵點。
2. Dense Optical Flow (Farneback)：計算整張圖片的光流，適合分析整體運動。

🧠 函式與參數說明

📌 `cv2.goodFeaturesToTrack()`

用途：偵測圖片中的角點 (特徵點)。

1	p0 = cv2.goodFeaturesToTrack(old_gray, maxCorners=100, qualityLevel=0.3, minDistance=7)

maxCorners：最多偵測多少角點。
qualityLevel：角點品質閾值。
minDistance：角點之間的最小距離。

📌 `cv2.calcOpticalFlowPyrLK()`

用途：計算 Lucas-Kanade 光流，追蹤特徵點移動。

1	p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None)

old_gray：前一幀圖片 (灰階)。
frame_gray：當前圖片 (灰階)。
p0：前一幀的特徵點。
p1：計算後的新位置。
st：追蹤狀態 (1=成功, 0=失敗)。
err：誤差值。

📌 `cv2.calcOpticalFlowFarneback()`

用途：計算 Dense Optical Flow，分析整張圖片的運動。

1 2	flow = cv2.calcOpticalFlowFarneback(prvs, next, None, 0.5, 3, 15, 3, 5, 1.2, 0)

prvs：前一幀圖片 (灰階)。
next：當前圖片 (灰階)。
其他參數：控制金字塔層數、窗口大小、迭代次數等。

📌 `cv2.cartToPolar()`

用途：將光流的水平與垂直分量轉換為角度與大小。

1	mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])

mag：光流大小 (速度)。
ang：光流方向 (角度)。

💻 範例程式 — Lucas-Kanade Optical Flow

import cv2
import numpy as np

# 讀取影片
cap = cv2.VideoCapture("tennis.mp4")

# 讀取第一幀並轉灰階
ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)

# 偵測角點 (特徵點)
p0 = cv2.goodFeaturesToTrack(old_gray, maxCorners=100, qualityLevel=0.3, minDistance=7)

# 建立顏色用於繪製軌跡
mask = np.zeros_like(old_frame)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # 計算光流
    p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None)

    # 選取成功追蹤的點
    good_new = p1[st == 1]
    good_old = p0[st == 1]

    # 繪製軌跡
    for i, (new, old) in enumerate(zip(good_new, good_old)):
        x_new, y_new = new.ravel()
        x_old, y_old = old.ravel()
        mask = cv2.line(mask, (int(x_new), int(y_new)), (int(x_old), int(y_old)), (0, 255, 0), 2)
        frame = cv2.circle(frame, (int(x_new), int(y_new)), 5, (0, 0, 255), -1)

    img = cv2.add(frame, mask)
    cv2.imshow("Lucas-Kanade Optical Flow", img)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

    old_gray = frame_gray.copy()
    p0 = good_new.reshape(-1, 1, 2)

cap.release()
cv2.destroyAllWindows()

圖：Lucas-Kanade 光流分析，顯示特徵點的移動軌跡

💻 範例程式 — Dense Optical Flow (Farneback)

import cv2
import numpy as np

cap = cv2.VideoCapture("tennis.mp4")

ret, frame1 = cap.read()
prvs = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)

hsv = np.zeros_like(frame1)
hsv[..., 1] = 255  # 設定飽和度

while True:
    ret, frame2 = cap.read()
    if not ret:
        break

    next = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)

    # 計算光流
    flow = cv2.calcOpticalFlowFarneback(prvs, next, None,
                                        0.5, 3, 15, 3, 5, 1.2, 0)

    # 將光流轉換為顏色顯示
    mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
    hsv[..., 0] = ang * 180 / np.pi / 2
    hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
    bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)

    cv2.imshow("Dense Optical Flow", bgr)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

    prvs = next

cap.release()
cv2.destroyAllWindows()

圖：Dense Optical Flow，顯示整張圖片的運動方向與速度

⚠️ 注意事項

光流分析需要 連續影格，若影片斷裂或幀率過低，效果會不佳。
Lucas-Kanade 適合少量特徵點，Dense Optical Flow 適合整體運動分析。
光流結果容易受光線變化、遮擋影響。
建議在 灰階圖片上計算光流，以減少計算量。

📊 應用場景

運動分析：分析球員或球的移動軌跡。
監控系統：偵測移動物體。
影片穩定化：估計相機晃動並修正。
自動駕駛：分析道路上物件的移動。

🎯 結語

本篇我們學會了如何使用 OpenCV 光流分析 (Optical Flow)，並透過 Lucas-Kanade 與 Dense Optical Flow 方法來追蹤圖片中物件的移動。
這些技術在運動分析、監控與自動駕駛中非常常見，後續可以結合物件偵測與追蹤，打造更完整的系統。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials
Pexels — 免費影片素材

Python | OpenCV 即時圖片中的物件追蹤

2026-02-13T01:00:00.000Z

📚 前言

在前一篇我們學會了 視訊檔案處理與剪輯。
這一篇要介紹如何使用 OpenCV 即時圖片中的物件追蹤。
物件追蹤是電腦視覺的重要應用之一，常用於監控、運動分析、互動系統等場景。
除了攝影機，我們也可以用影片檔來模擬，方便測試追蹤效果。

🎨 範例影片

🔎 原理說明

物件追蹤 (Object Tracking)：在影片或即時圖片中，持續追蹤某個選定的目標。
流程：
1. 讀取來源 (攝影機 / 影片檔 / 網路串流)。
2. 選定要追蹤的物件區域 (ROI)。
3. 建立追蹤器 (Tracker)。
4. 在迴圈中更新追蹤結果，並顯示。

🧠 八種追蹤演算法比較

OpenCV 提供了八種追蹤器，各有速度與精準度上的差異：

演算法	速度	精準度	說明
BOOSTING	慢	差	最早期的追蹤器，速度慢且不精準
MIL	慢	差	比 BOOSTING 稍好，但仍不精準
GOTURN	中	中	需搭配深度學習模型才能運作
TLD	中	中	速度與精準度一般
MEDIANFLOW	中	中	對快速移動或跳動物件不準確
KCF	快	高	常用追蹤器，速度快但遮擋時不準
MOSSE	最快	高	速度最快，精準度略低於 KCF/CSRT
CSRT	快	最高	精準度最佳，但速度比 KCF 慢

建立追蹤器的語法 (新版 OpenCV 需使用 cv2.legacy)：

1
2
3

tracker = cv2.legacy.TrackerKCF_create()      # KCF
tracker = cv2.legacy.TrackerCSRT_create()     # CSRT
tracker = cv2.legacy.TrackerMOSSE_create()    # MOSSE

⚠️ 常見問題與解決方式

在新版 OpenCV (4.x) 中，如果直接使用 cv2.TrackerKCF_create() 會出現以下錯誤：

1	AttributeError: module 'cv2' has no attribute 'TrackerKCF_create'

解決方式：

安裝 opencv-contrib-python 套件，因為追蹤器屬於 contrib 模組：
1
pip install opencv-contrib-python

使用新版 API：

1	tracker = cv2.legacy.TrackerKCF_create()

這樣就能正常執行物件追蹤範例。

💻 範例程式 — 即時攝影機物件追蹤

import cv2

# 建立攝影機物件 (0 = 預設攝影機)
cap = cv2.VideoCapture(0)

# 讀取第一幀，作為選擇追蹤區域的基準
ret, frame = cap.read()
if not ret:
    print("無法讀取攝影機")
    cap.release()
    exit()

# 使用滑鼠選擇 ROI (欲追蹤的物件區域)
roi = cv2.selectROI("Select Object", frame, False)
cv2.destroyWindow("Select Object")

# 建立追蹤器 (這裡使用 CSRT，可改成 KCF 或 MOSSE)
tracker = cv2.legacy.TrackerCSRT_create()
tracker.init(frame, roi)

while True:
    # 逐幀讀取攝影機圖片
    ret, frame = cap.read()
    if not ret:
        break

    # 更新追蹤器狀態
    success, box = tracker.update(frame)

    if success:
        # 追蹤成功，繪製矩形框出物件
        x, y, w, h = [int(v) for v in box]
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
    else:
        # 追蹤失敗，顯示提示文字
        cv2.putText(frame, "Lost", (50, 50),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0,0,255), 2)

    # 顯示結果圖片
    cv2.imshow("Tracking", frame)

    # 按下 q 鍵退出
    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：即時追蹤選定的物件

註：由於本身沒有攝影鏡頭，所以無法示範效果。

💻 範例程式 — 使用影片檔進行物件追蹤

import cv2

# 讀取範例影片 (檔名改為 tennis.mp4)
cap = cv2.VideoCapture("tennis.mp4")

# 讀取第一幀，作為選擇追蹤區域的基準
ret, frame = cap.read()
if not ret:
    print("無法讀取影片")
    cap.release()
    exit()

# 使用滑鼠選擇 ROI (欲追蹤的物件區域)
roi = cv2.selectROI("Select Object", frame, False)
cv2.destroyWindow("Select Object")

# 建立追蹤器 (這裡使用 KCF，可改成 CSRT 或 MOSSE)
tracker = cv2.legacy.TrackerKCF_create()
tracker.init(frame, roi)

while True:
    # 逐幀讀取影片
    ret, frame = cap.read()
    if not ret:
        break

    # 更新追蹤器狀態
    success, box = tracker.update(frame)

    if success:
        # 追蹤成功，繪製矩形框出物件
        x, y, w, h = [int(v) for v in box]
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

    # 顯示結果圖片
    cv2.imshow("Tracking", frame)

    # 按下 q 鍵退出
    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：在影片檔中追蹤選定的物件

⚠️ 注意事項

追蹤器需要先選定 ROI，建議在第一幀選擇。
不同演算法有不同特性，需依場景選擇。
若物件消失或被遮擋，追蹤器可能失敗。
測試時可使用交通影片或運動影片，物件移動明顯，追蹤效果更佳。

📊 應用場景

監控系統：追蹤特定人物或車輛。
運動分析：追蹤球員或球的移動。
互動應用：即時追蹤手勢或物件。
自動化系統：追蹤工業流程中的物件。

🎯 結語

本篇我們學會了如何使用 OpenCV 即時圖片中的物件追蹤，並透過不同演算法持續追蹤選定的目標。
同時也解決了新版 OpenCV 中常見的錯誤，確保程式能在最新環境下正常執行。
除了攝影機，也能用影片檔來測試，方便在沒有攝影機的環境下練習。
這些技術在監控、運動分析與互動應用中非常常見，後續可以結合人臉偵測或特徵匹配，打造更完整的系統。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials
Pexels — 免費影片素材

Python | OpenCV 視訊檔案處理與剪輯

2026-02-12T01:00:00.000Z

📚 前言

在前一篇我們學會了 攝影機即時圖片讀取。
這一篇要介紹如何使用 OpenCV 處理與剪輯視訊檔案。
這是電腦視覺與多媒體應用的重要基礎，常用於影片分析、監控錄影、資料集製作等場景。

🔎 原理說明

視訊檔案讀取：透過 cv2.VideoCapture() 讀取影片檔。
視訊檔案儲存：透過 cv2.VideoWriter() 將影格寫入新影片。
剪輯與處理：可在迴圈中對每個影格進行操作，例如裁切、灰階化、加文字。

🧠 函式與參數說明

📌 `cv2.VideoCapture()`

用途：讀取影片檔或串流。

1	cap = cv2.VideoCapture("video.mp4")

“video.mp4”：影片檔路徑。
cap：影片物件。

📌 `cap.get()`

用途：取得影片屬性。

1
2
3

fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

CAP_PROP_FPS：每秒影格數。
CAP_PROP_FRAME_WIDTH：影格寬度。
CAP_PROP_FRAME_HEIGHT：影格高度。

📌 `cv2.VideoWriter()`

用途：建立影片輸出物件。

1 2	fourcc = cv2.VideoWriter_fourcc(*'XVID') out = cv2.VideoWriter("output.avi", fourcc, fps, (width, height))

fourcc：編碼格式，例如 'XVID'、'MJPG'。
fps：每秒影格數。
(width, height)：影格大小。
out：影片輸出物件。

💻 範例程式 — 讀取並顯示影片

import cv2

cap = cv2.VideoCapture("video.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        print("影片結束或無法讀取")
        break

    cv2.imshow("Video", frame)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：逐格讀取並顯示影片

💻 範例程式 — 儲存影片檔

import cv2

cap = cv2.VideoCapture("video.mp4")

# 取得影片屬性
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# 建立輸出物件
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter("output.avi", fourcc, fps, (width, height))

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # 在影格上加文字
    cv2.putText(frame, "OpenCV Demo", (50, 50),
                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    # 寫入輸出影片
    out.write(frame)

    cv2.imshow("Output", frame)
    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
out.release()
cv2.destroyAllWindows()

圖：將影片加上文字並輸出

💻 範例程式 — 剪輯影片 (裁切區域)

import cv2

cap = cv2.VideoCapture("video.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # 裁切區域 (y:100~400, x:200~600)
    cropped = frame[100:400, 200:600]

    cv2.imshow("Cropped", cropped)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：裁切影片區域並顯示

⚠️ 注意事項

VideoWriter 的編碼格式需安裝對應的編碼器，否則可能無法輸出。
FPS 與影格大小需與輸入影片一致，否則可能出現錯誤。
剪輯操作需注意效能，建議只處理必要的區域。

📊 應用場景

影片分析：逐格處理影片，提取特徵。
監控錄影：儲存即時圖片成影片檔。
資料集製作：裁切或標註影片，建立訓練資料。
影片剪輯：加文字、裁切、合併影片。

🎯 結語

本篇我們學會了如何使用 OpenCV 讀取、儲存與剪輯視訊檔案，並能在迴圈中對影格進行處理。
這些技術是電腦視覺與多媒體應用的基礎，後續可以結合特徵偵測、物件追蹤等功能，打造更完整的影片分析系統。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

Python | OpenCV 攝影機即時圖片讀取

2026-02-11T01:00:00.000Z

📚 前言

在前一篇我們學會了 圖片金字塔與多尺度分析。
這一篇要介紹如何使用 OpenCV 即時讀取攝影機圖片。
這是電腦視覺的基礎操作之一，常用於人臉偵測、物件追蹤、即時監控等應用。
即使沒有攝影機，也可以用影片檔或網路串流來模擬。

🔎 原理說明

即時讀取：透過 cv2.VideoCapture() 連接來源，持續讀取影格 (frame)。
流程：
1. 建立來源物件 (攝影機 / 影片檔 / 網路串流)。
2. 迴圈讀取影格。
3. 顯示影格。
4. 按下指定按鍵結束程式。

🧠 函式與參數說明

📌 `cv2.VideoCapture()`

用途：建立攝影機物件，讀取即時圖片。

1	cap = cv2.VideoCapture(0)

0：代表預設攝影機。
1, 2…：代表其他攝影機。
cap：攝影機物件。

📌 `cap.read()`

用途：讀取一個影格。

1	ret, frame = cap.read()

ret：是否成功讀取 (True/False)。
frame：讀取到的圖片。

📌 `cv2.imshow()`

用途：顯示圖片。

1	cv2.imshow("Camera", frame)

“Camera”：視窗名稱。
frame：要顯示的圖片。

💻 範例程式 — 即時讀取攝影機圖片

import cv2

# 建立攝影機物件 (0 = 預設攝影機)
cap = cv2.VideoCapture(0)

while True:
    # 讀取影格
    ret, frame = cap.read()
    if not ret:
        print("無法讀取圖片")
        break

    # 顯示圖片
    cv2.imshow("Camera", frame)

    # 按下 q 鍵退出
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 釋放攝影機資源
cap.release()
cv2.destroyAllWindows()

圖：即時讀取攝影機圖片並顯示

註：由於本身沒有攝影鏡頭，所以無法示範效果。

💻 範例程式 — 讀取影片檔

import cv2

# 讀取影片檔
cap = cv2.VideoCapture("video.mp4")

while True:
    ret, frame = cap.read()
    if not ret:
        print("影片結束或無法讀取")
        break

    cv2.imshow("Video", frame)

    # 按下 q 鍵退出
    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：從影片檔逐格讀取並顯示

💻 範例程式 — 讀取交通監視器 MJPEG 串流

import cv2

# MJPEG 串流 URL (交通監視器)
url = "https://cctvn.freeway.gov.tw/abs2mjpg/bmjpg?camera=73270"

cap = cv2.VideoCapture(url)

while True:
    ret, frame = cap.read()
    if not ret:
        print("無法讀取串流")
        break

    cv2.imshow("Traffic Camera", frame)

    # 按下 q 鍵退出
    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

圖：即時讀取交通監視器的 MJPEG 串流

⚠️ 注意事項

攝影機編號可能不同，0 是預設，若有多個攝影機可嘗試 1、2。
cv2.VideoCapture() 可讀取 攝影機、影片檔、網路串流。
MJPEG 串流需要網路連線，若 URL 無效或網路不通，會無法讀取。
即時圖片處理需要效能，建議在迴圈中避免過度複雜的運算。

📊 應用場景

人臉偵測：即時讀取並進行人臉辨識。
物件追蹤：即時追蹤移動物體。
監控系統：即時顯示並儲存圖片。
交通監控：讀取交通監視器串流，分析即時路況。
互動應用：即時圖片結合 AR/VR。

🎯 結語

本篇我們學會了如何使用 OpenCV 即時讀取攝影機圖片，並且能顯示影格。
即使沒有攝影機，也能用影片檔或網路串流來模擬。
這是電腦視覺的基礎操作，後續可以結合人臉偵測、物件追蹤等功能，打造更完整的應用。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials
1968-高速公路資訊網

Python | OpenCV 圖片金字塔與多尺度分析

2026-02-10T01:00:00.000Z

📚 前言

在前一篇我們學會了 相機校正與畸變矯正。
在圖片處理與電腦視覺中，常常需要在不同解析度下觀察圖片特徵。
例如：人臉偵測、物件追蹤、特徵匹配，都需要在多種尺度下分析圖片。
這時候就會用到 圖片金字塔 (Image Pyramid) 與 多尺度分析 (Multi-scale Analysis)。

🔎 原理說明

圖片金字塔：將圖片逐層縮小或放大，形成一個「金字塔結構」。
- 高層：解析度低，圖片小。
- 低層：解析度高，圖片大。
用途：
- 在不同尺度下偵測特徵。
- 加速演算法，避免在原始大圖片上做大量計算。
- 提供多層次的圖片表示，方便進行匹配或搜尋。

🧠 函式與參數說明

📌 `cv2.pyrDown()`

用途：將圖片縮小一半，並同時進行高斯模糊，避免縮小時產生鋸齒或 aliasing。

1	smaller = cv2.pyrDown(img)

img：輸入圖片。
smaller：縮小並平滑後的圖片。

📌 `cv2.pyrUp()`

用途：將圖片放大一倍，並同時進行插值與模糊，使放大後的圖片保持平滑。

1	larger = cv2.pyrUp(img)

img：輸入圖片。
larger：放大並平滑後的圖片。

📌 拉普拉斯金字塔 (Laplacian Pyramid)

用途：由高斯金字塔相鄰層的差異構成，常用於圖片壓縮與融合。
它能保留圖片的細節資訊，並在多尺度下進行分析。
例如：將兩張圖片利用拉普拉斯金字塔進行平滑融合，避免邊界突兀。

1 2	gaussian_expanded = cv2.pyrUp(gp[i], dstsize=gp[i-1].shape[1::-1]) laplacian = cv2.subtract(gp[i-1], gaussian_expanded)

gp：高斯金字塔。
gaussian_expanded：放大後的高斯圖片，與上一層對齊。
laplacian：相鄰層的差異，代表該層的細節資訊。

💻 範例程式 — 建立圖片金字塔

import cv2

img = cv2.imread("test.png")  # 部落格頭像

# 建立金字塔
smaller = cv2.pyrDown(img)
larger = cv2.pyrUp(img)

cv2.imshow("Original", img)
cv2.imshow("PyrDown", smaller)
cv2.imshow("PyrUp", larger)

cv2.waitKey(0)
cv2.destroyAllWindows()

圖：原始圖片、縮小一層、放大一層

💻 範例程式 — 多層金字塔

import cv2

img = cv2.imread("test.png")  # 部落格頭像

layer = img.copy()
gp = [layer]

# 建立高斯金字塔 (Gaussian Pyramid)
for i in range(3):
    layer = cv2.pyrDown(layer)
    gp.append(layer)

# 顯示不同層次
for i, layer in enumerate(gp):
    cv2.imshow(f"Layer {i}", layer)

cv2.waitKey(0)
cv2.destroyAllWindows()

圖：高斯金字塔 — 逐層縮小圖片

💻 範例程式 — 拉普拉斯金字塔 (Laplacian Pyramid)

拉普拉斯金字塔常用於圖片壓縮與重建。
它是由高斯金字塔相鄰層的差異構成。

import cv2

img = cv2.imread("test.png")  # 部落格頭像
layer = img.copy()
gp = [layer]

# 建立高斯金字塔
for i in range(3):
    layer = cv2.pyrDown(layer)
    gp.append(layer)

# 建立拉普拉斯金字塔
lp = []
for i in range(3, 0, -1):
    # 保證大小一致
    gaussian_expanded = cv2.pyrUp(gp[i], dstsize=gp[i-1].shape[1::-1])
    laplacian = cv2.subtract(gp[i-1], gaussian_expanded)
    lp.append(laplacian)

# 顯示拉普拉斯金字塔
for i, layer in enumerate(lp):
    cv2.imshow(f"Laplacian {i}", layer)

cv2.waitKey(0)
cv2.destroyAllWindows()

圖：拉普拉斯金字塔 — 顯示不同層次的差異

⚠️ 注意事項

pyrDown 與 pyrUp 只能處理圖片大小為偶數的情況，否則可能會有誤差。
金字塔層數不宜過多，否則圖片會過度模糊或失真。
拉普拉斯金字塔常用於圖片壓縮與融合。

📊 應用場景

人臉偵測：在不同尺度下搜尋人臉。
圖片融合：利用拉普拉斯金字塔進行平滑融合。
特徵匹配：在多尺度下比對圖片特徵。
圖片壓縮：利用金字塔結構進行高效壓縮。

🎯 結語

本篇我們學會了 圖片金字塔 (Image Pyramid) 與 多尺度分析 (Multi-scale Analysis)，並透過 OpenCV 的 pyrDown、pyrUp 建立高斯金字塔與拉普拉斯金字塔。
這些技術在電腦視覺中非常常見，尤其在人臉偵測、圖片融合與特徵匹配等應用中。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

Python | OpenCV 相機校正與畸變矯正

2026-02-09T01:00:00.000Z

📚 前言

在前一篇我們學會了 透視變換與圖片校正。
這一篇要介紹 相機校正 (Camera Calibration) 與 畸變矯正 (Distortion Correction)。
相機鏡頭常會造成桶狀或枕狀畸變，導致圖片變形。透過校正，我們能得到更精準的圖片，這在 AR、3D 重建、工業檢測 等應用中非常重要。

🎨 範例圖片

這裡我們使用 GitHub 專案 tarkers/Camera_Calibration_OpenCV 提供的棋盤格圖片。
下載 Test 資料夾，裡面有多張棋盤格照片，非常適合用來做校正。

🔎 原理說明

棋盤格：我們用棋盤格當作「標準尺」，因為它的格子大小固定。
流程：
1. 拍或下載多張棋盤格照片。
2. 找出棋盤格角落。
3. 用這些角落去計算相機的「內部參數」和「畸變係數」。
4. 用這些參數去修正照片。

🧠 函式與參數說明

📌 `cv2.findChessboardCorners()`

用途：偵測棋盤格圖片中的角點位置，作為相機校正的基礎資料。

1	ret, corners = cv2.findChessboardCorners(image, patternSize)

image：輸入圖片 (灰階)。
patternSize：棋盤格內角點數量，例如 (9,6)。
ret：是否成功找到角點。
corners：角點座標。

📌 `cv2.calibrateCamera()`

用途：利用多張棋盤格圖片的角點，計算相機的內部參數與畸變係數。

1	ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, imageSize, None, None)

objpoints：棋盤格的 3D 座標。
imgpoints：圖片中的 2D 座標。
imageSize：圖片大小。
mtx：相機矩陣 (焦距、主點位置)。
dist：畸變係數。
rvecs, tvecs：旋轉與平移向量。

📌 `cv2.undistort()`

用途：利用校正得到的相機矩陣與畸變係數，修正圖片的變形。

1	dst = cv2.undistort(img, mtx, dist, None, newcameramtx)

img：輸入圖片。
mtx：相機矩陣。
dist：畸變係數。
newcameramtx：優化後的相機矩陣。
dst：輸出矯正後的圖片。

💻 範例程式 — 相機校正

import cv2
import numpy as np
import glob

# 棋盤格大小 (內角點數量)
chessboard_size = (9, 6)

# 建立棋盤格的 3D 座標
objp = np.zeros((np.prod(chessboard_size), 3), np.float32)
objp[:,:2] = np.mgrid[0:chessboard_size[0], 0:chessboard_size[1]].T.reshape(-1,2)

objpoints = []  # 3D 點
imgpoints = []  # 2D 點

images = glob.glob("Test/*.jpg")

for fname in images:
    img = cv2.imread(fname)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    ret, corners = cv2.findChessboardCorners(gray, chessboard_size, None)
    if ret:
        objpoints.append(objp)
        imgpoints.append(corners)

        cv2.drawChessboardCorners(img, chessboard_size, corners, ret)
        cv2.imshow("Corners", img)
        cv2.waitKey(500)

cv2.destroyAllWindows()

# 相機校正
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)

print("Camera Matrix:\n", mtx)
print("Distortion Coefficients:\n", dist)

輸出：

Camera Matrix:
 [[532.35423658   0.         342.42264659]
 [  0.         532.53995406 235.04228201]
 [  0.           0.           1.        ]]
Distortion Coefficients:
 [[-2.73462172e-01 -3.85288349e-02  1.12629584e-03 -1.75411180e-04
   2.85170396e-01]]

圖：程式碼執行結果 — 取得相機矩陣與畸變係數

💻 範例程式 — 畸變矯正

import cv2
import numpy as np

# 手動輸入相機矩陣 (mtx)
mtx = np.array([[532.35423658,   0.        , 342.42264659],
                [  0.        , 532.53995406, 235.04228201],
                [  0.        ,   0.        ,   1.        ]])

# 手動輸入畸變係數 (dist)
dist = np.array([[-2.73462172e-01, -3.85288349e-02,
                   1.12629584e-03, -1.75411180e-04,
                   2.85170396e-01]])

# 讀取一張測試圖片
img = cv2.imread("Test/left01.jpg")
h, w = img.shape[:2]

# 計算最佳相機矩陣
newcameramtx, roi = cv2.getOptimalNewCameraMatrix(mtx, dist, (w,h), 1, (w,h))

# 矯正圖片
dst = cv2.undistort(img, mtx, dist, None, newcameramtx)

# 裁切 ROI (避免黑邊)
x, y, w, h = roi
dst = dst[y:y+h, x:x+w]

cv2.imshow("Original", img)
cv2.imshow("Undistorted", dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 修正鏡頭畸變後的圖片

⚠️ 注意事項

校正需要 多張棋盤格圖片，角度與距離要多樣化。
畸變矯正後可能需要裁切 ROI，避免黑邊。
相機校正結果依鏡頭與拍攝環境而異。

📊 應用場景

AR/VR：提升圖片精準度。
工業檢測：避免因畸變造成測量誤差。
3D 重建：確保投影模型正確。
攝影應用：修正廣角鏡頭的桶狀畸變。

🎯 結語

本篇我們學會了 相機校正與畸變矯正，並理解了如何利用棋盤格圖片計算相機矩陣與畸變係數，最後使用 cv2.undistort() 修正圖片。
這是電腦視覺中非常重要的一步，能讓後續的圖片處理與分析更加精準。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

Python | OpenCV 透視變換與圖片校正

2026-02-08T01:00:00.000Z

📚 前言

在前一篇我們學會了 特徵點偵測與匹配。
這一篇要介紹 透視變換 (Perspective Transform) 與 圖片校正 (Image Rectification)，這是圖片幾何處理的重要技巧，能將傾斜或變形的圖片校正回正常視角，常用於文件掃描、場景校正、投影轉換等應用。

🎨 範例圖片

圖：範例圖片 document.png — 傾斜的文件

圖：範例圖片 board.png — 傾斜的投影幕

🔎 透視變換原理

原理說明

透視變換是一種 射影變換 (Projective Transform)，能將圖片中的四邊形區域映射到另一個矩形區域。
常用於校正傾斜的文件、投影幕或場景。
核心函式是 cv2.getPerspectiveTransform() 與 cv2.warpPerspective()。

參數說明

1 2	cv2.getPerspectiveTransform(srcPoints, dstPoints) cv2.warpPerspective(src, M, dsize)

srcPoints：原始圖片中的四個點座標。
dstPoints：目標圖片中的四個點座標。
M：透視變換矩陣 (3x3)。
dsize：輸出圖片大小 (寬, 高)。

💻 範例程式 — 文件校正

import cv2
import numpy as np

img = cv2.imread("document.png")

# 假設透視後矩形的四個角點座標 (需人工量測或用工具選取)
pts1 = np.float32([[180,180],[620,130],[220,470],[580,500]])

# 設定校正後的矩形大小
width, height = 400, 300
pts2 = np.float32([[0,0],[width,0],[0,height],[width,height]])

M = cv2.getPerspectiveTransform(pts1, pts2)
dst = cv2.warpPerspective(img, M, (width, height))

cv2.imshow("Original", img)
cv2.imshow("Corrected", dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 原始傾斜文件與校正後的矩形文件

💻 範例程式 — 場景校正

import cv2
import numpy as np

img = cv2.imread("board.png")

# 使用生成時的四個角點
pts1 = np.float32([[80,100],[520,70],[120,320],[480,330]])
pts2 = np.float32([[0,0],[400,0],[0,300],[400,300]])

M = cv2.getPerspectiveTransform(pts1, pts2)
dst = cv2.warpPerspective(img, M, (400,300))

cv2.imshow("Original", img)
cv2.imshow("Corrected", dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 投影幕校正

📊 文件校正 vs 場景校正

類型	目的	角點來源	重點	常見應用
文件校正	把拍攝時傾斜的文件校正成正矩形，方便閱讀或 OCR 辨識	文件四角 (票據、身分證、書頁)	保持文字比例正確，避免字體拉伸	掃描文件、票據辨識、證件 OCR
場景校正	把場景中的矩形物件校正成正視角，方便顯示或分析	投影幕、看板、地板方格的四角	幾何對齊即可，比例不一定要符合真實物件	投影幕校正、AR 虛擬投影、場景重建

🧾 小結

文件校正：強調「文字比例正確」，目的是讓文件可讀性和 OCR 辨識效果更好。
場景校正：強調「幾何對齊」，目的是讓場景顯示或分析更方便。
技術上都是用 cv2.getPerspectiveTransform() + cv2.warpPerspective()，差別在 角點選取方式 和 輸出大小設定。

⚠️ 注意事項

四個角點座標必須正確，否則校正結果會失真。
建議搭配 特徵點偵測 或 邊緣檢測 自動取得角點。
輸出大小需根據目標矩形設定，否則可能造成拉伸。

📊 應用場景

文件掃描校正：將拍攝的傾斜文件校正成正矩形，方便 OCR 辨識。
投影幕校正：修正投影畫面傾斜，讓顯示內容保持比例。
場景重建：將相機拍攝的斜角場景轉換成俯視視角。
AR 應用：將虛擬物件正確投影到真實場景中。

🎯 結語

本篇我們學會了 透視變換與圖片校正，能將傾斜或變形的圖片轉換成正常視角。
這些技巧在 文件掃描、投影校正、場景重建、AR 等領域非常常見。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

Python | OpenCV 特徵點偵測與匹配

2026-02-07T01:00:00.000Z

📚 前言

在前一篇我們學會了 直方圖均衡化與圖片增強。
這一篇要介紹 特徵點偵測 (Feature Detection) 與 特徵匹配 (Feature Matching)，包含常見的 SIFT、ORB 演算法，以及 BFMatcher、FLANN 匹配方法，這些技巧在圖片比對、物件辨識、拼接 (Stitching) 等應用中非常重要。

🎨 範例圖片

在進行特徵匹配之前，我們需要兩張圖片：

test1.png：原始圖片（這裡使用部落格頭像 test.png）
test2.png：經過縮小或旋轉的版本，用來模擬真實場景中的角度或大小差異。

💻 範例程式 — 產生 test1.png 與 test2.png

import cv2
import numpy as np

# 讀取原始圖片 (部落格頭像)
img = cv2.imread("test.png")

# 儲存原始圖片為 test1.png
cv2.imwrite("test1.png", img)

# 縮小
small = cv2.resize(img, None, fx=0.7, fy=0.7)

# 旋轉
(h, w) = img.shape[:2]
M = cv2.getRotationMatrix2D((w//2, h//2), 30, 1.0)
rotated = cv2.warpAffine(img, M, (w, h))

# 透視變換 (模擬角度改變)
pts1 = np.float32([[0,0],[w,0],[0,h],[w,h]])
pts2 = np.float32([[50,50],[w-50,30],[30,h-50],[w-30,h-30]])
M = cv2.getPerspectiveTransform(pts1, pts2)
warped = cv2.warpPerspective(img, M, (w, h))

# 儲存其中一個版本作為 test2.png
cv2.imwrite("test2.png", rotated)

圖：原始圖片 test1.png (部落格頭像)

圖：旋轉後的圖片 test2.png，用於特徵匹配測試

🔎 SIFT (Scale-Invariant Feature Transform)

原理說明

SIFT 能偵測圖片中的 關鍵點 (Keypoints)，並計算其 描述子 (Descriptors)。
特點是對 縮放、旋轉、亮度變化 具有不變性。
適合用於精準的圖片匹配。

參數說明

1	cv2.SIFT_create(nfeatures=0, nOctaveLayers=3, contrastThreshold=0.04, edgeThreshold=10, sigma=1.6)

nfeatures：最多保留的特徵點數量，0 表示不限制。
nOctaveLayers：金字塔層數，預設 3。
contrastThreshold：對比度閾值，過低的特徵點會被忽略。
edgeThreshold：邊緣閾值，過強的邊緣點會被忽略。
sigma：高斯模糊的標準差。

💻 範例程式

import cv2

img = cv2.imread("test1.png")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

sift = cv2.SIFT_create()
keypoints, descriptors = sift.detectAndCompute(gray, None)

sift_img = cv2.drawKeypoints(img, keypoints, None, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

cv2.imshow("SIFT Keypoints", sift_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — SIFT 偵測到的特徵點

🔎 ORB (Oriented FAST and Rotated BRIEF)

原理說明

ORB 是 FAST + BRIEF 的改良版，速度快且效果好。
特點是 免費、輕量，適合即時應用。
對旋轉與縮放有一定不變性。

參數說明

1	cv2.ORB_create(nfeatures=500)

nfeatures：最多保留的特徵點數量。

💻 範例程式

import cv2

img = cv2.imread("test1.png")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

orb = cv2.ORB_create(nfeatures=500)
keypoints, descriptors = orb.detectAndCompute(gray, None)

orb_img = cv2.drawKeypoints(img, keypoints, None, color=(0,255,0), flags=0)

cv2.imshow("ORB Keypoints", orb_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — ORB 偵測到的特徵點

🔎 特徵匹配 — BFMatcher

原理說明

BFMatcher (Brute-Force Matcher) 逐一比較描述子，找出最佳匹配。
適合小型資料集，簡單直接。

參數說明

1	cv2.BFMatcher(normType=cv2.NORM_L2, crossCheck=False)

normType：距離度量方式，SIFT 用 cv2.NORM_L2，ORB 用 cv2.NORM_HAMMING。
crossCheck：是否雙向檢查匹配，預設 False。

💻 範例程式

import cv2

img1 = cv2.imread("test1.png", cv2.IMREAD_GRAYSCALE)
img2 = cv2.imread("test2.png", cv2.IMREAD_GRAYSCALE)

sift = cv2.SIFT_create()
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)

bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True)
matches = bf.match(des1, des2)
matches = sorted(matches, key=lambda x:x.distance)

match_img = cv2.drawMatches(img1, kp1, img2, kp2, matches[:20], None, flags=2)

cv2.imshow("BFMatcher", match_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — BFMatcher 匹配結果

🔎 特徵匹配 — FLANN

原理說明

FLANN (Fast Library for Approximate Nearest Neighbors) 適合大型資料集。
使用近似最近鄰演算法，比 BFMatcher 更快。
常用於圖片拼接、場景比對等需要大量匹配的應用。

參數說明

1	cv2.FlannBasedMatcher(indexParams, searchParams)

indexParams：索引參數，例如 dict(algorithm=1, trees=5)。
searchParams：搜尋參數，例如 dict(checks=50)。

💻 範例程式

import cv2

img1 = cv2.imread("test1.png", cv2.IMREAD_GRAYSCALE)
img2 = cv2.imread("test2.png", cv2.IMREAD_GRAYSCALE)

sift = cv2.SIFT_create()
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)

index_params = dict(algorithm=1, trees=5)
search_params = dict(checks=50)
flann = cv2.FlannBasedMatcher(index_params, search_params)

matches = flann.knnMatch(des1, des2, k=2)

good = []
for m, n in matches:
    if m.distance < 0.7 * n.distance:
        good.append(m)

match_img = cv2.drawMatches(img1, kp1, img2, kp2, good, None, flags=2)

cv2.imshow("FLANN Matcher", match_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — FLANN 匹配結果

📊 效果比較

方法	特點	適用情境
SIFT	精準、對縮放旋轉不變	高精度圖片比對
ORB	快速、免費、輕量	即時應用、嵌入式系統
BFMatcher	暴力匹配，簡單直接	小型資料集
FLANN	近似最近鄰，速度快	大型資料集

🚀 應用場景

特徵點偵測與匹配雖然看起來抽象，但在電腦視覺中非常常見，以下是幾個實際用途：

圖片拼接 (Image Stitching)：把多張照片自動拼接成全景圖，常見於手機相機的「全景模式」。
物件辨識 (Object Recognition)：偵測並辨識特定物件，例如商標、書籍封面、地標建築。
場景比對 (Scene Matching)：在不同角度或光線下拍攝的照片中，找出相同的場景，常用於 AR 或機器人定位。
文件比對 (Document Matching)：比對掃描文件或照片，確認是否為同一份文件，即使有縮放或旋轉。
追蹤與定位 (Tracking & Localization)：在影片中追蹤某個物件，或在地圖上定位相機位置，常用於無人機或機器人導航。
3D 重建 (3D Reconstruction)：從多張不同角度的照片中，找出共同特徵點，進而重建三維模型。

⚠️ 注意事項

SIFT 在部分 OpenCV 版本需額外安裝 opencv-contrib-python。
ORB 適合快速應用，但精度略低於 SIFT。
BFMatcher 適合小型資料集，FLANN 適合大型資料集。
特徵匹配常搭配 RANSAC 過濾錯誤匹配，提升準確度。

🎯 結語

本篇我們學會了 SIFT、ORB 特徵點偵測，以及 BFMatcher、FLANN 特徵匹配，能找出圖片中的關鍵點並進行比對。
這些技巧在 圖片拼接、物件辨識、場景比對、AR、導航、3D 重建 等領域都有廣泛應用。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

Python | OpenCV 直方圖均衡化與圖片增強

2026-02-06T01:00:00.000Z

📚 前言

在前一篇我們學會了 直線與圓形偵測 (霍夫變換)。
這一篇要介紹 直方圖均衡化 (Histogram Equalization) 與 圖片增強 (Image Enhancement)，包含 全域均衡化、CLAHE 自適應均衡化、彩色圖片均衡化 三種方法，這是圖片前處理的重要技巧，能改善圖片對比度，讓細節更清晰，常用於夜間圖片、醫學圖片或文件辨識。

🎨 範例圖片

圖：範例圖片 — 灰階暗圖，用於均衡化測試

圖：範例圖片 — 彩色暗圖，用於 Y 通道均衡化測試

🔎 全域直方圖均衡化

原理說明

將圖片的灰階值重新分配，使亮度分布更均勻。
適合整體偏暗或偏亮的圖片。
OpenCV 提供 cv2.equalizeHist()。

參數說明

1	cv2.equalizeHist(src)

src：輸入圖片，必須是單通道灰階 (uint8)。
回傳值：均衡化後的灰階圖片。

📌 注意：無法直接處理彩色圖片，需先轉換色彩空間。

💻 範例程式

import cv2

# 讀取灰階圖片
img = cv2.imread("dark.png", cv2.IMREAD_GRAYSCALE)

# 直方圖均衡化
equalized = cv2.equalizeHist(img)

cv2.imshow("Original", img)
cv2.imshow("Equalized", equalized)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 灰階圖片均衡化，對比度提升

🔎 CLAHE (自適應直方圖均衡化)

原理說明

將圖片分成小區塊，分別均衡化後再合併。
適合局部亮度差異大的圖片。
可避免全域均衡化造成雜訊過度增強。

參數說明

1	cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))

clipLimit：對比度限制值，防止過度增強。數值越大，對比度越強。
tileGridSize：分割區塊大小，例如 (8,8) 表示分成 8x8 區塊。

💻 範例程式

import cv2

# 讀取灰階圖片
img = cv2.imread("dark.png", cv2.IMREAD_GRAYSCALE)

# 建立 CLAHE 物件
clahe = cv2.createCLAHE(clipLimit=50.0, tileGridSize=(8,8))

# 套用 CLAHE
clahe_img = clahe.apply(img)

cv2.imshow("Original", img)
cv2.imshow("CLAHE", clahe_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — CLAHE 增強效果，局部對比度提升

🔎 彩色圖片均衡化

原理說明

彩色圖片不能直接均衡化，否則會破壞色彩。
正確做法是轉換到 YCrCb 色彩空間，只均衡化亮度通道 (Y)。

參數說明

1
2
3

cv2.cvtColor(src, cv2.COLOR_BGR2YCrCb)
cv2.equalizeHist(y_channel)
cv2.cvtColor(ycrcb, cv2.COLOR_YCrCb2BGR)

cv2.cvtColor：轉換色彩空間。
y_channel：Y 通道（亮度），只對這一通道做均衡化。
回傳值：保留色彩的均衡化圖片。

💻 範例程式

import cv2

# 讀取彩色圖片
img = cv2.imread("color.png")

# 轉換到 YCrCb
ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)

# 均衡化 Y 通道
ycrcb[:,:,0] = cv2.equalizeHist(ycrcb[:,:,0])

# 轉回 BGR
equalized_color = cv2.cvtColor(ycrcb, cv2.COLOR_YCrCb2BGR)

cv2.imshow("Original", img)
cv2.imshow("Equalized Color", equalized_color)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 彩色圖片均衡化，亮度提升但色彩保持不變

📊 效果比較

方法	特點	適用情境
`equalizeHist()`	全域均衡化，提升整體對比度	適合灰階圖片，整體偏暗或偏亮
CLAHE	局部均衡化，避免過度增強	適合醫學圖片、夜間圖片、局部亮度差異大
彩色均衡化 (Y 通道)	保留色彩，只增強亮度	適合彩色照片，避免色偏

⚠️ 注意事項

直方圖均衡化主要用於 灰階圖片，彩色圖片需轉換到 YCrCb 或 HSV，只處理亮度通道。
CLAHE 的 clipLimit 與 tileGridSize 需要依圖片調整，過大可能造成過度增強。
均衡化雖能改善對比度，但也可能放大雜訊，需搭配濾波或其他前處理。

🎯 結語

本篇我們學會了 直方圖均衡化、CLAHE 自適應均衡化 以及 彩色圖片均衡化，能有效改善圖片對比度，讓細節更清晰。
這些技巧在圖片前處理中非常常見，尤其在 夜間圖片、醫學圖片、文件辨識 等場景中非常有用。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

Python | OpenCV 直線與圓形偵測 (霍夫變換)

2026-02-05T01:00:00.000Z

📚 前言

在前一篇我們學會了 邊緣檢測與輪廓分析。
這一篇要介紹 霍夫變換 (Hough Transform)，它是一種常見的幾何特徵偵測方法，能有效找出圖片中的直線與圓形。
這些技巧廣泛應用於車道線偵測、圓形物件辨識、工業檢測等場景。

🎨 範例圖片

圖：範例圖片 lines.png — 含有多條直線

圖：範例圖片 circles.png — 含有多個圓形

圖：範例圖片 suzuka.png — 賽車道場景 (來源：GameApps)

圖：範例圖片 cans.png — 罐頭俯瞰圖 (來源：Techbang)

🔎 霍夫變換原理

原理說明

直線霍夫變換：將圖片中的每個邊緣點轉換到參數空間 (ρ, θ)，找出符合直線方程的點群。
圓形霍夫變換：利用邊緣點與圓心半徑的關係，在參數空間中找出可能的圓形。
OpenCV 提供了 cv2.HoughLines() 與 cv2.HoughCircles() 兩個函式。

🧠 函式與參數說明

📌 `cv2.HoughLines()`

1	cv2.HoughLines(image, rho, theta, threshold)

image：邊緣檢測後的二值化圖片 (通常用 Canny)。
rho：距離解析度，單位像素，常用值 = 1。
theta：角度解析度，單位弧度，常用值 = np.pi/180 (即 1 度)。
threshold：累加器閾值，至少多少個點支持才能判定為直線。

📌 `cv2.HoughCircles()`

1	cv2.HoughCircles(image, method, dp, minDist, param1, param2, minRadius, maxRadius)

image：灰階圖片，建議先模糊處理。
method：偵測方法，常用 cv2.HOUGH_GRADIENT。
dp：累加器解析度與圖片解析度的反比。dp=1 表示相同解析度。
minDist：不同圓心之間的最小距離。
param1：Canny 邊緣檢測的高閾值。
param2：累加器閾值，數值越小偵測越敏感。
minRadius：最小半徑。
maxRadius：最大半徑。

💻 範例程式 — 直線偵測

import cv2
import numpy as np

img = cv2.imread("lines.png")
cv2.imshow("Original", img)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

edges = cv2.Canny(gray, 50, 150)
lines = cv2.HoughLines(edges, 1, np.pi/180, 100)

for line in lines:
    rho, theta = line[0]
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a * rho
    y0 = b * rho
    x1 = int(x0 + 1000 * (-b))
    y1 = int(y0 + 1000 * (a))
    x2 = int(x0 - 1000 * (-b))
    y2 = int(y0 - 1000 * (a))
    cv2.line(img, (x1,y1), (x2,y2), (0,0,255), 2)

cv2.imshow("Detected Lines", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 偵測並標註圖片中的直線

💻 範例程式 — 圓形偵測

import cv2
import numpy as np

img = cv2.imread("circles.png")
cv2.imshow("Original", img)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.medianBlur(gray, 5)

circles = cv2.HoughCircles(
    gray, cv2.HOUGH_GRADIENT, dp=1, minDist=50,
    param1=100, param2=30, minRadius=20, maxRadius=100
)

if circles is not None:
    circles = np.uint16(np.around(circles))
    for i in circles[0,:]:
        cv2.circle(img, (i[0], i[1]), i[2], (0,255,0), 2)
        cv2.circle(img, (i[0], i[1]), 2, (0,0,255), 3)

cv2.imshow("Detected Circles", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 偵測並標註圖片中的圓形

💻 範例程式 — 實際應用：賽車道直線偵測

import cv2
import numpy as np

img = cv2.imread("suzuka.png")  # 賽車道圖片
cv2.imshow("Original", img)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 邊緣檢測
edges = cv2.Canny(gray, 100, 200)

# 霍夫直線偵測
lines = cv2.HoughLines(edges, 1, np.pi/180, 120)

if lines is not None:
    for line in lines:
        rho, theta = line[0]
        a = np.cos(theta)
        b = np.sin(theta)
        x0 = a * rho
        y0 = b * rho
        x1 = int(x0 + 1000 * (-b))
        y1 = int(y0 + 1000 * (a))
        x2 = int(x0 - 1000 * (-b))
        y2 = int(y0 - 1000 * (a))
        cv2.line(img, (x1,y1), (x2,y2), (0,0,255), 2)

cv2.imshow("Suzuka Circuit - Lines", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 偵測並標註賽車道中的直線

💻 範例程式 — 實際應用：罐頭圓形偵測

import cv2
import numpy as np

img = cv2.imread("cans.png")  # 罐頭俯瞰圖
cv2.imshow("Original", img)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.medianBlur(gray, 5)

# 霍夫圓形偵測
circles = cv2.HoughCircles(
    gray, cv2.HOUGH_GRADIENT, dp=1, minDist=100,
    param1=100, param2=50, minRadius=90, maxRadius=110
)

if circles is not None:
    circles = np.uint16(np.around(circles))
    for i in circles[0,:]:
        cv2.circle(img, (i[0], i[1]), i[2], (0,255,0), 2)  # 畫圓
        cv2.circle(img, (i[0], i[1]), 2, (0,0,255), 3)    # 畫圓心

cv2.imshow("Cans - Circles", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 偵測並標註罐頭的大圓形

⚠️ 注意事項

直線偵測：threshold 數值需依圖片調整，太小會產生雜訊，太大可能漏掉直線。
圓形偵測：param1 與 param2 控制靈敏度，需依圖片特性調整。
前處理：建議先做邊緣檢測或模糊處理，提升偵測效果。

📊 應用場景

車道線偵測：利用直線霍夫變換偵測道路標線。
工業檢測：偵測零件上的圓孔或直線結構。
醫學圖片：偵測血管或圓形結構。
日常應用：找出圖片中的幾何形狀，輔助後續分析。

🎯 結語

本篇我們學會了 霍夫變換 的直線與圓形偵測方法，並理解了 cv2.HoughLines() 與 cv2.HoughCircles() 的用法，成功在圖片中標註幾何特徵。
這些技巧在電腦視覺應用中非常常見，例如車道線偵測、工業檢測與醫學圖片分析。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

Python | OpenCV 邊緣檢測與輪廓分析

2026-02-04T01:00:00.000Z

📚 前言

在前一篇我們學會了 魔術棒填充顏色。
這一篇要介紹 邊緣檢測 (Edge Detection) 與 輪廓分析 (Contour Analysis)，包含常見的 Laplacian、Sobel、Canny 三種方法，並展示如何利用輪廓分析找出圖片中的物件邊界。

🔎 Laplacian 邊緣檢測

原理說明

Laplacian 是 二階導數運算，偵測圖片中灰階值變化最劇烈的地方。
適合快速找出邊界，但容易受雜訊影響。

參數說明

1	cv2.Laplacian(src, ddepth, ksize=1, scale=1, delta=0, borderType=cv2.BORDER_DEFAULT)

src：輸入圖片（通常是灰階）。
ddepth：輸出圖片的深度，常用 cv2.CV_64F 避免溢位。
ksize：卷積核大小，必須為正奇數，預設 1。數值越大，邊緣檢測越平滑。
scale：縮放因子，調整計算後的梯度值。
delta：加到結果上的偏移量。
borderType：邊界處理方式，預設 cv2.BORDER_DEFAULT。

💻 範例程式

import cv2

img = cv2.imread("test.png")  # 部落格頭像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

laplacian = cv2.Laplacian(gray, cv2.CV_64F)
laplacian = cv2.convertScaleAbs(laplacian)

cv2.imshow("Original", img)
cv2.imshow("Laplacian", laplacian)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — Laplacian 邊緣檢測，顯示灰階邊界

🔎 Sobel 邊緣檢測

原理說明

Sobel 是 一階導數運算，分別計算 水平 (x) 與 垂直 (y) 方向的梯度。
可以強調某一方向的邊緣，常用於圖片特徵提取。

參數說明

1	cv2.Sobel(src, ddepth, dx, dy, ksize=3, scale=1, delta=0, borderType=cv2.BORDER_DEFAULT)

src：輸入圖片（通常是灰階）。
ddepth：輸出圖片的深度，常用 cv2.CV_64F。
dx：x 方向的導數階數，通常設 1。
dy：y 方向的導數階數，通常設 1。
ksize：Sobel 核大小，必須為 1、3、5、7。數值越大，邊緣越平滑。
scale：縮放因子，調整梯度值。
delta：加到結果上的偏移量。
borderType：邊界處理方式。

💻 範例程式

import cv2

img = cv2.imread("test.png")  # 部落格頭像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)

sobelx = cv2.convertScaleAbs(sobelx)
sobely = cv2.convertScaleAbs(sobely)
sobel = cv2.addWeighted(sobelx, 0.5, sobely, 0.5, 0)

cv2.imshow("Sobel X", sobelx)
cv2.imshow("Sobel Y", sobely)
cv2.imshow("Sobel Combined", sobel)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — Sobel 邊緣檢測，分別顯示水平、垂直與合成邊界

🔎 Canny 邊緣檢測

原理說明

Canny 是最常用的邊緣檢測演算法，步驟包含：
1. 高斯模糊去雜訊
2. 計算梯度
3. 非極大值抑制
4. 雙閾值判斷
5. 邊緣連接
結果乾淨且穩定，適合後續輪廓分析。

參數說明

1	cv2.Canny(image, threshold1, threshold2, apertureSize=3, L2gradient=False)

image：輸入圖片（必須是灰階）。
threshold1：低閾值，用來判斷弱邊緣。
threshold2：高閾值，用來判斷強邊緣。
apertureSize：Sobel 核大小，預設 3。
L2gradient：布林值，若為 True 使用更精確的梯度計算 (L2 norm)，預設 False。

💻 範例程式

import cv2

img = cv2.imread("test.png")  # 部落格頭像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

canny = cv2.Canny(gray, 100, 200)

cv2.imshow("Original", img)
cv2.imshow("Canny", canny)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — Canny 邊緣檢測，邊界清晰乾淨

🧠 輪廓函式介紹

在 OpenCV 中，輪廓分析主要依靠兩個函式：

`cv2.findContours()`

功能：從二值化圖片或邊緣檢測結果中，找出所有輪廓。

語法：

1	contours, hierarchy = cv2.findContours(image, mode, method)

參數：
- image：通常是二值化或邊緣檢測後的圖片。
- mode：輪廓檢索方式，例如 cv2.RETR_EXTERNAL (只取外層輪廓)、cv2.RETR_TREE (完整階層)。
- method：近似方式，例如 cv2.CHAIN_APPROX_SIMPLE (壓縮水平/垂直冗餘點)。

`cv2.drawContours()`

功能：將偵測到的輪廓繪製到圖片上。

語法：

1	cv2.drawContours(image, contours, contourIdx, color, thickness)

參數：
- image：要繪製的圖片。
- contours：由 findContours() 找到的輪廓集合。
- contourIdx：指定要畫哪一個輪廓，-1 表示全部。
- color：繪製顏色，例如 (0,255,0)。
- thickness：線條粗細。

✨ 輪廓分析 (Contours)

💻 範例程式

import cv2

img = cv2.imread("test.png")  # 部落格頭像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
canny = cv2.Canny(gray, 100, 200)

contours, hierarchy = cv2.findContours(canny, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

output = img.copy()
cv2.drawContours(output, contours, -1, (0, 255, 0), 2)

cv2.imshow("Original", img)
cv2.imshow("Contours", output)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 輪廓分析，綠色線條標示物件邊界

📊 效果比較

方法	特點	優缺點
Laplacian	二階導數，快速找邊界	容易受雜訊影響
Sobel	一階導數，分方向偵測	可強調水平/垂直邊緣
Canny	綜合演算法，結果乾淨	計算較複雜，但最常用
findContours + drawContours	輪廓偵測與繪製	可進一步分析形狀與面積

⚠️ 注意事項

邊緣檢測前建議先做 高斯模糊，避免雜訊造成誤判。
findContours() 的回傳值在不同版本的 OpenCV 可能不同。
輪廓分析常搭配邊緣檢測，建議使用 Canny 作為前處理。

🎯 結語

本篇我們學會了 Laplacian、Sobel、Canny 三種邊緣檢測方法，並理解了 cv2.findContours() 與 cv2.drawContours() 的用法，成功找出圖片中的物件邊界。
這些技巧在電腦視覺中非常常見，例如物件偵測、圖片分割、形狀辨識等。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

Python | OpenCV 魔術棒填充顏色

2026-02-03T01:00:00.000Z

📚 前言

在前一篇我們學會了 圖片合成、疊加與相減。
這一篇要介紹 魔術棒填充顏色，利用 OpenCV 的 floodFill 函式，實作類似 Photoshop 的魔術棒工具，快速選取顏色區域並填充。

🎨 範例圖片

圖：範例圖片 — 測試用彩色區塊

🧠 floodFill 方法介紹

OpenCV 的 cv2.floodFill() 是一個用來「填色」的函式，它會從一個指定的像素點（稱為 種子點 seed point）開始，向周圍擴展，找出顏色相近的區域並進行填色。

🔍 基本語法

1	cv2.floodFill(image, mask, seedPoint, newVal, loDiff, upDiff, flags)

📌 參數說明

參數	說明
`image`	要填色的圖片（會被修改）
`mask`	遮罩，用來記錄哪些區域已被填色，大小需比原圖大 2 像素
`seedPoint`	起始點座標，例如 `(50, 50)`
`newVal`	要填入的顏色，例如 `(0, 255, 0)`
`loDiff` / `upDiff`	顏色容許差距，決定哪些像素算「相近」
`flags`	控制填色方式，例如 `FLOODFILL_FIXED_RANGE` 或 `FLOODFILL_MASK_ONLY`

🎯 運作原理

從 seedPoint 開始，檢查周圍像素是否與起始點顏色「相近」。
若在 loDiff 與 upDiff 範圍內，就納入填色區域。
更新 mask 或 image，依照 flags 決定是否真的填色。

💻 範例程式

import cv2
import numpy as np

# 讀取圖片
img = cv2.imread("floodfill_sample.png")

# 顯示原圖
cv2.imshow("Original Image", img)

# 建立遮罩 (比原圖大 2 像素)
h, w = img.shape[:2]
mask = np.zeros((h+2, w+2), np.uint8)

# 種子點 (假設使用者點選座標)
seed_point = (15, 15)

# 設定顏色範圍 (threshold)
loDiff = (10, 10, 10)
upDiff = (10, 10, 10)

# 執行 floodFill，直接在原圖上填色
cv2.floodFill(img, mask, seed_point, (0, 255, 0), loDiff, upDiff, flags=cv2.FLOODFILL_FIXED_RANGE)

# 顯示填色後的結果
cv2.imshow("FloodFill Result", img)

cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 原圖與填色結果

🔧 loDiff / upDiff 效果比較

在 floodFill() 中，loDiff 與 upDiff 控制顏色相似度範圍。
它們決定了「種子點顏色 ± 容許差距」的範圍，影響選取區域的大小。

範例說明

假設種子點顏色是 (200, 200, 200) (灰色)：

loDiff = (10,10,10)、upDiff = (10,10,10)
→ 只會選取 (190,190,190) 到 (210,210,210) 的像素，範圍很精準。
loDiff = (50,50,50)、upDiff = (50,50,50)
→ 會選取 (150,150,150) 到 (250,250,250) 的像素，範圍更寬鬆。

📊 效果比較表

設定值	選取範圍	特點
`loDiff=(10,10,10)` / `upDiff=(10,10,10)`	種子點 ±10	精準選取，區域小
`loDiff=(30,30,30)` / `upDiff=(30,30,30)`	種子點 ±30	適中，常用設定
`loDiff=(50,50,50)` / `upDiff=(50,50,50)`	種子點 ±50	範圍大，容易包含更多顏色

⚠️ 注意事項

遮罩大小必須比原圖大 2 像素，否則會出錯。
loDiff 與 upDiff 的設定影響選取範圍，需依圖片調整。
floodFill 可以搭配 FLOODFILL_MASK_ONLY 或 FLOODFILL_FIXED_RANGE 使用，效果不同。

🎯 結語

本篇我們學會了如何利用 OpenCV 實作 魔術棒顏色填充。
這個技巧能讓圖片編輯更直觀，並可延伸到互動式工具，例如滑鼠點選選取區域、即時顏色替換等。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

Python | OpenCV 圖片合成、疊加與相減

2026-02-02T01:00:00.000Z

📚 前言

在前一篇我們學會了 建立遮罩與基本運算。
這一篇要介紹 圖片合成、疊加與相減，並展示如何利用遮罩完成 去背 + 合成 的應用。

🎨 範例圖片

圖：三原色範例圖片 — 紅色、綠色、藍色圓形

圖：圖片來源 — OpenCV 官方 Github

圖：圖片相減範例圖片 — 黃色、白綠色圓形

➕ 圖片合成 (add)

原理說明

使用 cv2.add(img1, img2) 將兩張圖片相加。
像素值超過 255 時會被截斷為 255。
可以逐步相加，將三張圖片合成為一張「三原色比較圖」。

💻 範例程式

import cv2

# 讀取三張圖片
img1 = cv2.imread("red.png")
img2 = cv2.imread("green.png")
img3 = cv2.imread("blue.png")

# 確保大小一致
img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))
img3 = cv2.resize(img3, (img1.shape[1], img1.shape[0]))

# 先合成前兩張
temp = cv2.add(img1, img2)

# 再把結果與第三張合成
output = cv2.add(temp, img3)

cv2.imshow("Red", img1)
cv2.imshow("Green", img2)
cv2.imshow("Blue", img3)
cv2.imshow("Add Result", output)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 三張圖片合成為三原色比較圖

🌫️ 圖片權重疊加 (addWeighted)

原理說明

使用 cv2.addWeighted(img1, alpha, img2, beta, gamma)。
可模擬透明效果，常用於圖片融合。
alpha 與 beta 為權重比例，gamma 為亮度調整。

💻 範例程式

import cv2

img1 = cv2.imread("test.png")  # 部落格頭像
img2 = cv2.imread("OpenCV_logo_black.png")

img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))

output = cv2.addWeighted(img1, 0.8, img2, 0.2, 0)

cv2.imshow("Weighted Blend", output)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 頭像與 OpenCV logo 的透明融合

➖ 圖片相減 (subtract)

原理說明

使用 cv2.subtract(img1, img2)，會逐像素相減。
若結果為負數，會被截斷成 0（黑色）；若大於 255，則截斷為 255。
常用於差異檢測，找出兩張圖片不同的部分。

💻 範例程式

import cv2

# 讀取圖片
img1 = cv2.imread("white_green.png")   # 白色 + 綠色重疊的圖
img2 = cv2.imread("yellow.png")        # 黃色圓形的圖

# 確保大小一致
img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))

# 相減
output = cv2.subtract(img1, img2)

# 顯示結果
cv2.imshow("Image A (White+Green)", img1)
cv2.imshow("Image B (Yellow)", img2)
cv2.imshow("Subtract Result", output)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：程式碼執行結果 — 白色與綠色圖片減去黃色圖片

🎨 顏色相減示例

圖片 A 像素	圖片 B 像素	結果像素	說明
(255,255,255) 白色	(0,255,255) 黃色	(255,0,0) 藍色	白色減去黃色 → 只剩藍色
(0,255,0) 綠色	(0,255,255) 黃色	(0,0,0) 黑色	綠色減去黃色 → 負值截斷為黑色
(255,0,0) 紅色	(0,255,255) 黃色	(255,0,0) 紅色	紅色減去黃色 → 維持紅色

📊 小結

subtract() 的結果取決於兩張圖片的顏色差異。
白色減去黃色 → 只剩藍色分量。
綠色減去黃色 → 因為差值為負，結果變黑。
適合用來比較兩張相似圖片，找出差異區域。

🖼️ 去背 + 合成

原理說明

利用遮罩 (mask) 去除 logo 背景。
再用 add() 或 addWeighted() 將去背後的圖片合成到背景。

💻 範例程式

import cv2
import numpy as np

# 讀取 logo 與背景 (保持原始大小)
logo = cv2.imread("OpenCV_logo_black.png")
bg   = cv2.imread("test.png")

# 建立灰階遮罩
logo_gray = cv2.cvtColor(logo, cv2.COLOR_BGR2GRAY)

# 建立兩個遮罩：一個保留 logo，一個保留背景
# 白色區域灰階值很高，設定閾值 240
_, mask_logo = cv2.threshold(logo_gray, 240, 255, cv2.THRESH_BINARY_INV)  # 保留非白色區域 (logo)
_, mask_bg   = cv2.threshold(logo_gray, 240, 255, cv2.THRESH_BINARY)      # 保留白色區域 (背景)

# 去背：只保留 logo 部分
logo_no_bg = cv2.bitwise_and(logo, logo, mask=mask_logo)

# 建立 ROI (放置 logo 的區域)
# 這裡假設 logo 要放在背景左上角 (0:logo.shape[0], 0:logo.shape[1])
rows, cols = logo.shape[:2]
roi = bg[0:rows, 0:cols]

# 清空 ROI 中 logo 的位置
bg_roi = cv2.bitwise_and(roi, roi, mask=mask_bg)

# 合成：背景 ROI + logo
dst = cv2.add(bg_roi, logo_no_bg)
bg[0:rows, 0:cols] = dst

# 顯示結果
cv2.imshow("Logo Merge Result", bg)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖：利用遮罩去背後，將 OpenCV logo 合成到部落格頭像

📊 效果比較

函式	功能	常見用途
`add()`	圖片相加	合成圖片
`addWeighted()`	權重疊加	透明效果、圖片融合
`subtract()`	圖片相減	差異檢測
遮罩 + 合成	去背後合成	Logo 疊加、圖片合成

⚠️ 注意事項

圖片大小：add()、addWeighted()、subtract() 都要求兩張圖片大小一致，否則需要先用 cv2.resize() 調整。
像素值範圍：add() 與 subtract() 的結果會被截斷在 0–255 之間，超過 255 會變成 255，低於 0 會變成 0。
透明效果：addWeighted() 可以模擬透明疊加，但 OpenCV 本身不支援 alpha 通道顯示，若要真正透明背景需轉成 BGRA 並輸出 PNG。
遮罩合成：去背合成時，遮罩必須是灰階圖，且大小要與前景圖片一致。

🎯 結語

本篇我們學會了 圖片合成、疊加與相減，並展示了遮罩去背後的合成應用。這些技巧在圖片處理、資料集製作、圖片融合時非常常見。

在下一篇，我們將進一步探索 魔術棒填充顏色，學習如何利用 OpenCV 的區域選取與顏色填充技巧，讓圖片編輯更直觀。

📖 如在學習過程中遇到疑問，或是想了解更多相關主題，建議回顧一下 Python | OpenCV 系列導讀，掌握完整的章節目錄，方便快速找到你需要的內容。

註：以上參考了
OpenCV Tutorials
OpenCV-Python Tutorials

J.J.'s Blogs

Python | OpenCV 與深度學習框架整合

📚 前言

🎨 範例圖片/影片

🔎 原理說明

📂 模型下載與使用說明

PyTorch

TensorFlow/Keras

🧠 函式與參數說明

PyTorch — torchvision.models

TensorFlow/Keras — tf.keras.applications

💻 範例程式 — PyTorch 整合 (ResNet18)

📊 ResNet18 Top-5 預測結果

💻 範例程式 — TensorFlow/Keras 整合 (MobileNetV2)

📊 MobileNetV2 Top-5 預測結果

🛠️ 與 OpenCV 結合的應用

⚠️ 注意事項

📊 應用場景

🎯 結語

Python | OpenCV 多物件偵測與追蹤

📚 前言

🎨 範例圖片/影片

🔎 原理說明

📂 模型下載與使用說明

YOLOv3-tiny (Darknet)

🧠 函式與參數說明

📌 cv2.dnn.readNetFromDarknet()

📌 cv2.dnn.blobFromImage()

💻 範例程式 — YOLO 多物件偵測 (圖片)

💻 範例程式 — YOLO 多物件偵測 (影片)

💻 範例程式 — YOLO + DeepSORT 多物件追蹤

🛠️ 使用 DeepSORT 常見問題與解決辦法

⚠️ 注意事項

📊 應用場景

🎯 結語

Python | OpenCV 物件分類與定位

📚 前言

🎨 範例圖片/影片

🔎 原理說明

📂 模型下載與使用說明

MobileNet SSD (Caffe)

🧠 函式與參數說明

📌 cv2.dnn.readNetFromCaffe()

📌 cv2.dnn.blobFromImage()

💻 範例程式 — 圖片物件分類與定位

💻 範例程式 — 影片物件分類與定位

⚠️ 注意事項

📊 應用場景

🎯 結語

Python | OpenCV 人臉偵測與追蹤

📚 前言

🎨 範例圖片/影片

🔎 三種方式比較

📂 檔案下載與使用說明

Haar Cascades

LBP Cascades

DNN 模型 (Caffe)

🧠 函式與參數說明

📌 cv2.CascadeClassifier()

📌 detectMultiScale()

📌 cv2.dnn.readNetFromCaffe()

📌 cv2.dnn.blobFromImage()

📌 cv2.TrackerKCF_create()

📌 tracker.init()

📌 tracker.update()

💻 範例程式 — Haar Cascades 人臉偵測 (圖片)

💻 範例程式 — LBP Cascades 人臉偵測 (影片)

💻 範例程式 — DNN 人臉偵測 (影片)

💻 範例程式 — 人臉偵測 + 追蹤

⚠️ 注意事項

📊 應用場景

🎯 結語

Python | OpenCV 即時馬賽克與模糊處理

📚 前言

🔎 原理說明

🧠 函式與參數說明

📌 cv2.resize()

📌 cv2.GaussianBlur()

💻 範例程式一 — 圖片即時馬賽克與模糊

💻 範例程式二 — 影片即時馬賽克與模糊

PyTorch — `torchvision.models`

TensorFlow/Keras — `tf.keras.applications`

📌 `cv2.dnn.readNetFromDarknet()`

📌 `cv2.dnn.blobFromImage()`

📌 `cv2.dnn.readNetFromCaffe()`

📌 `cv2.dnn.blobFromImage()`

📌 `cv2.CascadeClassifier()`

📌 `detectMultiScale()`

📌 `cv2.dnn.readNetFromCaffe()`

📌 `cv2.dnn.blobFromImage()`

📌 `cv2.TrackerKCF_create()`

📌 `tracker.init()`

📌 `tracker.update()`

📌 `cv2.resize()`

📌 `cv2.GaussianBlur()`

📌 `cv2.setMouseCallback()`

📌 `cv2.rectangle()`

📌 `cv2.setMouseCallback()`

📌 `cv2.waitKey()`

📌 `cv2.goodFeaturesToTrack()`

📌 `cv2.calcOpticalFlowPyrLK()`

📌 `cv2.calcOpticalFlowFarneback()`

📌 `cv2.cartToPolar()`

📌 `cv2.VideoCapture()`

📌 `cap.get()`

📌 `cv2.VideoWriter()`