Trong OpenCV, class cv2.VideoCapture đóng vai trò là chiếc "cầu nối" phần mềm giữa mã nguồn Python và nguồn cấp video (phần cứng camera, file video có sẵn trên ổ cứng hoặc luồng video qua mạng).

Về bản chất, nó là một trình quản lý luồng khung hình (frame stream manager), hoạt động theo cơ chế hàng đợi (queue) liên tục rút từng bức ảnh tĩnh ra để đưa vào bộ nhớ RAM cho chương trình xử lý.

1. Khởi tạo đối tượng (__init__)

Cú pháp phổ biến:

cap = cv2.VideoCapture(source)

Tham số source quyết định nguồn cấp dữ liệu:

• Số nguyên ($0, 1, 2, \dots$): Chỉ định camera phần cứng kết nối với máy tính.

  • 0: Camera mặc định (thường là webcam tích hợp của laptop).

  • 1, 2: Các webcam rời cắm qua cổng USB hoặc nguồn camera ảo.

• Chuỗi ký tự đường dẫn file: Đọc file video lưu trên máy (ví dụ: cap = cv2.VideoCapture("video.mp4")).

• Chuỗi URL luồng mạng: Đọc luồng video thời gian thực từ camera IP hoặc giao thức mạng (như RTSP, HTTP: cap = cv2.VideoCapture("rtsp://192.168.1.100:554/stream")).

2. Các phương thức quan trọng nhất

• cap.isOpened() $\rightarrow$ bool:

  • Kiểm tra xem việc mở camera hoặc file video có thành công hay không.

  • Trả về True nếu thiết bị đã sẵn sàng kết nối, False nếu bị lỗi (do camera đang bị ứng dụng khác như Zoom/Meet chiếm dụng, sai chỉ số index, hoặc file hỏng).

• cap.read() $\rightarrow$ (bool, ndarray):

  • Lấy khung hình tiếp theo từ luồng video.

  • Phương thức này thực chất kết hợp 2 thao tác ngầm:

    1. cap.grab(): Báo phần cứng chụp và chuyển dữ liệu khung hình vào bộ đệm.

    2. cap.retrieve(): Giải mã dữ liệu thô đó thành một ma trận ảnh NumPy (ndarray).

  • Trả về một tuple gồm 2 giá trị:

    • ret (boolean): Trạng thái lấy frame. Nếu lấy ảnh thành công sẽ là True; nếu hết video hoặc mất kết nối camera sẽ là False.

    • frame (numpy.ndarray): Bức ảnh dưới dạng ma trận 3 chiều theo hệ màu BGR.

• cap.release():

  • Giải phóng phần cứng camera và trả lại quyền điều khiển thiết bị cho hệ điều hành.

  • Nếu quên gọi lệnh này, đèn báo webcam có thể vẫn sáng và các phần mềm khác sẽ không mở được camera cho tới khi tiến trình Python bị tắt hoàn toàn.

3. Đọc và chỉnh sửa cấu hình phần cứng: get() và set()

VideoCapture cho phép đọc và thiết lập các thông số hoạt động của camera thông qua các hằng số thuộc tính (Properties):

# Lấy kích thước khung hình hiện tại
width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
fps = cap.get(cv2.CAP_PROP_FPS)

# Yêu cầu camera chạy ở độ phân giải HD 720p (1280x720)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)

Một số hằng số cấu hình hay dùng:

• cv2.CAP_PROP_FRAME_WIDTH: Chiều rộng khung hình.

• cv2.CAP_PROP_FRAME_HEIGHT: Chiều cao khung hình.

• cv2.CAP_PROP_FPS: Số khung hình/giây.

• cv2.CAP_PROP_POS_FRAMES: Vị trí khung hình hiện tại (hữu ích khi tua video file).

(Lưu ý: Phương thức set() có hiệu lực hay không còn phụ thuộc vào việc phần cứng webcam thực tế có hỗ trợ độ phân giải/thông số đó hay không).

4. Mẹo giải thích trực quan 

Để dễ hình dung, ta có thể ví VideoCapture như một băng chuyền ảnh:

1. VideoCapture(0) là hành động bấm công tắc khởi động băng chuyền nối từ camera vào máy tính.

2. Mỗi lần gọi cap.read(), băng chuyền sẽ đưa đúng 1 bức ảnh vào tay chương trình để xử lý.

3. Vòng lặp while True giúp ta liên tục nhặt từng bức ảnh từ băng chuyền với tốc độ cực nhanh (khoảng 30 lần mỗi giây), tạo nên cảm giác chuyển động liên tục của video.

4. Khi kết thúc, cap.release() là hành động bấm nút tắt hẳn băng chuyền để tiết kiệm điện và nhường camera cho người khác.

----------------------------------------------------------------------------------------

Tự tạo video mẫu bằng OpenCV ngay trên Colab

Thay vì phụ thuộc vào việc tải từ các đường link bên ngoài dễ bị lỗi mạng/chặn tải, chúng ta có thể dùng chính OpenCV và NumPy để tự tạo ra một đoạn video ngắn 120 khung hình (hình tròn di chuyển qua lại trên màn hình), sau đó nạp đoạn video này vào để xử lý:

import cv2
import numpy as np
import os

# =====================================================================
# BƯỚC 1: TỰ TẠO MỘT VIDEO MẪU HOÀN CHỈNH BẰNG NUMPY & OPENCV
# =====================================================================
input_video_path = "sample_video.mp4"
width, height = 640, 480
fps = 30.0
fourcc = cv2.VideoWriter_fourcc(*'mp4v')

# Tạo bộ ghi video gốc
creator = cv2.VideoWriter(input_video_path, fourcc, fps, (width, height), isColor=True)

print("🎬 Đang tự sinh video mẫu (120 frames)...")
for i in range(120):
    # Tạo khung hình nền đen
    frame = np.zeros((height, width, 3), dtype=np.uint8)
    
    # Vẽ một hình tròn màu xanh di chuyển ngang màn hình
    center_x = int((i / 120) * (width - 100)) + 50
    center_y = height // 2
    cv2.circle(frame, (center_x, center_y), 40, (0, 255, 0), -1)
    
    # Ghi chữ lên frame
    cv2.putText(frame, f"Original Video - Frame {i}", (30, 50), 
                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)
    
    creator.write(frame)

creator.release()

file_size_kb = os.path.getsize(input_video_path) / 1024
print(f"✅ Đã tạo thành công file video gốc: {input_video_path} ({file_size_kb:.1f} KB)")


# =====================================================================
# BƯỚC 2: MỞ VIDEO VỪA TẠO VÀ THỰC HIỆN XỬ LÝ (CHUYỂN XÁM & ĐÁNH SỐ)
# =====================================================================
cap = cv2.VideoCapture(input_video_path)

if not cap.isOpened():
    print("❌ Lỗi: Không thể mở file video!")
else:
    # Lấy thông số video gốc
    w   = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    h   = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps = cap.get(cv2.CAP_PROP_FPS)

    output_path = "processed_output.mp4"
    out = cv2.VideoWriter(output_path, fourcc, fps, (w, h), isColor=False)

    frame_count = 0
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        # Chuyển đổi khung hình sang ảnh xám
        gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        
        # Đóng dấu số thứ tự frame đã qua xử lý
        cv2.putText(gray_frame, f"PROCESSED: {frame_count}", (30, 100), 
                    cv2.FONT_HERSHEY_SIMPLEX, 1.0, 255, 2)

        out.write(gray_frame)
        frame_count += 1

    cap.release()
    out.release()
    print(f"🎉 Hoàn tất! Đã xử lý và lưu thành công {frame_count} frames vào file '{output_path}'!")

TRÍCH XUẤT MỘT KHUNG HÌNH (FRAMES) TỪ VIDEO:

import cv2
from google.colab.patches import cv2_imshow

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

if not cap.isOpened():
    print("❌ Lỗi: Không thể mở file video!")
else:
    # 1. Lấy tổng số frame thực tế của video
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    print(f"Tổng số frame của video: {total_frames}")

    # 2. Chọn frame cần xem (đảm bảo nhỏ hơn total_frames)
    target_frame_index = 50
    
    # 3. Dịch con trỏ đến frame mong muốn
    cap.set(cv2.CAP_PROP_POS_FRAMES, target_frame_index)

    # 4. Trích xuất frame ra bằng cap.read()
    ret, frame = cap.read()

    # 5. Kiểm tra và hiển thị
    if ret:
        print(f"✅ Đã trích xuất thành công frame thứ {target_frame_index}:")
        cv2_imshow(frame)
    else:
        print("❌ Không thể đọc được frame tại vị trí chỉ định!")

    cap.release()

Giải thích thêm về biến cap trong dòng lệnh :

# Mở file text: 'f' không phải là toàn bộ nội dung sách, mà là con trỏ file (File Handle)
with open("large_book.txt", "r") as f:
    line1 = f.readline()  # Đọc đúng dòng 1, chuyển con trỏ sang dòng 2
    line2 = f.readline()  # Đọc tiếp dòng 2

cap = cv2.VideoCapture("sample_video.mp4")
# 'cap' là File Handle của video
ret1, frame1 = cap.read()  # Giải mã frame 1 thành ma trận NumPy
ret2, frame2 = cap.read()  # Giải mã frame 2 thành ma trận NumPy
cap.release()              # Đóng file

all_frames = []
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    all_frames.append(frame)  # Lúc này all_frames mới thực sự là danh sách các frame

# SAI: frame.shape[:2] là (h, w)
out = cv2.VideoWriter("out.mp4", fourcc, fps, frame.shape[:2]) 

# ĐÚNG: Đảo ngược lại thành (w, h)
h, w = frame.shape[:2]
out = cv2.VideoWriter("out.mp4", fourcc, fps, (w, h))

out = cv2.VideoWriter(output_path, fourcc, fps, (w, h), isColor=False)

out.release()