Dự án: đo kích thước chi tiết cơ khí bằng camera đã hiệu chuẩn

Bước 1. Hiệu chuẩn nội tại

import glob

import cv2
import numpy as np

COT, HANG, O = 9, 6, 10.0
objp = np.zeros((COT * HANG, 3), np.float32)
objp[:, :2] = np.mgrid[0:COT, 0:HANG].T.reshape(-1, 2) * O
vat, anh_pts = [], []
for f in sorted(glob.glob("du_an8/calib_*.png")):
    g = cv2.imread(f, cv2.IMREAD_GRAYSCALE)
    ok, c = cv2.findChessboardCornersSB(g, (COT, HANG), flags=cv2.CALIB_CB_ACCURACY)
    if ok:
        vat.append(objp)
        anh_pts.append(c)
rms, K, dist, _, _, _, _, e = cv2.calibrateCameraExtended(vat, anh_pts, g.shape[::-1], None, None,
                                                          flags=cv2.CALIB_FIX_K3)
fs = cv2.FileStorage("du_an8/camera.yaml", cv2.FILE_STORAGE_WRITE)
fs.write("camera_matrix", K)
fs.write("dist_coeffs", dist)
fs.write("rms_px", float(rms))
fs.release()
print(f"{len(anh_pts)} ảnh, RMS {rms:.3f} px, sai số từng ảnh lớn nhất {e.max():.3f} px")
print(f"fx {K[0, 0]:.1f}, fy {K[1, 1]:.1f}, cx {K[0, 2]:.1f}, cy {K[1, 2]:.1f}, k1 {dist[0, 0]:+.4f}, k2 {dist[0, 1]:+.4f}")

12 ảnh, RMS 0.019 px, sai số từng ảnh lớn nhất 0.029 px
fx 2599.9, fy 2599.9, cx 645.8, cy 478.1, k1 -0.0891, k2 +0.0211

Đối chiếu đáp án (fx = 2600, cx = 646, cy = 478, k1 = −0,09, k2 = +0,03): fx sai dưới 0,1%, đạt Y1.

Bước 2. Hiệu chuẩn mặt phẳng đo

import cv2
import numpy as np


def khu_meo(P):
    """Pixel ảnh gốc → pixel của camera không méo cùng K."""
    return cv2.undistortPoints(np.asarray(P, np.float64).reshape(-1, 1, 2), K, dist, P=K).reshape(-1, 2)


g = cv2.imread("du_an8/mat_phang.png", cv2.IMREAD_GRAYSCALE)
ok, goc = cv2.findChessboardCornersSB(g, (COT, HANG), flags=cv2.CALIB_CB_ACCURACY)
Hmm, _ = cv2.findHomography(khu_meo(goc), objp[:, :2].astype(np.float64))    # pixel khử méo → mm


def px_sang_mm(P):
    return cv2.perspectiveTransform(khu_meo(P).reshape(-1, 1, 2), Hmm).reshape(-1, 2)


du = np.linalg.norm(px_sang_mm(goc) - objp[:, :2], axis=1)
print(f"Sai số trên 54 góc: trung bình {1000 * du.mean():.1f} µm, lớn nhất {1000 * du.max():.1f} µm")
s_tam = np.mean(np.linalg.norm(np.diff(px_sang_mm(goc).reshape(HANG, COT, 2), axis=1), axis=2)) / \
    np.mean(np.linalg.norm(np.diff(goc.reshape(HANG, COT, 2), axis=1), axis=2))
print(f"Tỉ lệ trung bình quanh tâm ảnh: {1000 * s_tam:.2f} µm/px")
# Nếu so với một điểm của bàn cờ mà không khử méo:
H_tho, _ = cv2.findHomography(goc.reshape(-1, 2).astype(np.float64), objp[:, :2].astype(np.float64))
du_tho = np.linalg.norm(cv2.perspectiveTransform(goc.reshape(-1, 1, 2).astype(np.float64), H_tho).reshape(-1, 2)
                        - objp[:, :2], axis=1)
print(f"Cùng homography nhưng KHÔNG khử méo: sai số lớn nhất {1000 * du_tho.max():.1f} µm")

Sai số trên 54 góc: trung bình 1.2 µm, lớn nhất 3.5 µm
Tỉ lệ trung bình quanh tâm ảnh: 100.62 µm/px
Cùng homography nhưng KHÔNG khử méo: sai số lớn nhất 52.0 µm

Thứ tự góc mà findChessboardCornersSB trả về quyết định gốc và chiều của hệ mm. Với phép đo kích thước (khoảng cách, đường kính) điều này không quan trọng vì mọi hệ trực chuẩn đều cho cùng khoảng cách. Nếu cần tọa độ tuyệt đối (gửi vị trí cho robot), phải cố định thứ tự như bài Hiệu chuẩn camera đã nhắc. Dòng cuối cho thấy homography không thay được khử méo: bỏ bước khử méo, sai số trên chính các góc dùng để fit đã lên hàng chục micromet.

Bước 3. Đo một chi tiết

import math

import cv2
import numpy as np


def tim_canh(anh, tam, huong, dai=40, cuc=-1, nguong=20):
    """Caliper: quét đoạn dài `dai` px qua `tam` theo `huong`; trả về điểm cạnh subpixel (x, y) hoặc None.
    cuc = -1: cạnh sáng → tối theo chiều quét."""
    hx, hy = np.asarray(huong, np.float64) / np.hypot(*huong)
    t = np.arange(-dai / 2, dai / 2 + 1)
    mx = (tam[0] + t * hx).astype(np.float32).reshape(1, -1)
    my = (tam[1] + t * hy).astype(np.float32).reshape(1, -1)
    p = cv2.remap(anh, mx, my, cv2.INTER_CUBIC).ravel().astype(np.float64)
    gr = np.zeros_like(p)
    gr[1:-1] = (p[2:] - p[:-2]) / 2 * cuc
    k = int(np.argmax(gr))
    if gr[k] < nguong or k < 2 or k > len(gr) - 3:
        return None
    a, b, c = gr[k - 1], gr[k], gr[k + 1]
    s = t[k] + 0.5 * (a - c) / (a - 2 * b + c)
    return tam[0] + s * hx, tam[1] + s * hy


def fit_duong(P):
    c = P.mean(axis=0)
    v = np.linalg.svd(P - c)[2][0]
    return c, np.array([-v[1], v[0]])                    # điểm trên đường, pháp tuyến đơn vị


def fit_tron(P):
    A = np.column_stack([P, np.ones(len(P))])
    D, E, F = np.linalg.lstsq(A, -(P ** 2).sum(axis=1), rcond=None)[0]
    return np.array([-D / 2, -E / 2]), math.sqrt(D * D / 4 + E * E / 4 - F)


def do_tam_kep(anh8, doi_mm=None):
    """Đo L, W, D, X (mm). doi_mm: hàm đổi mảng điểm pixel → mm (mặc định: hiệu chuẩn đầy đủ)."""
    doi_mm = doi_mm or px_sang_mm
    anh = anh8.astype(np.float32)
    _, bw = cv2.threshold(anh8, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    cs, hier = cv2.findContours(bw, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
    i = max(range(len(cs)), key=lambda j: cv2.contourArea(cs[j]))
    lo = [cs[j] for j in range(len(cs)) if hier[0][j][3] == i and cv2.contourArea(cs[j]) > 500]
    if not lo:
        raise ValueError("không thấy lỗ")
    (cx, cy), (w, h), _ = cv2.minAreaRect(cs[i])
    m = cv2.moments(lo[0])
    lx, ly = m["m10"] / m["m00"], m["m01"] / m["m00"]
    ux = np.array([cx - lx, cy - ly]) / math.hypot(cx - lx, cy - ly)    # hướng từ lỗ → tâm: trục +x chi tiết
    uy = np.array([-ux[1], ux[0]])
    dai, rong = max(w, h), min(w, h)
    canh = {}
    for ten, goc_canh, phap, nua, doc in (("trai", -1, ux, dai / 2, rong), ("phai", +1, ux, dai / 2, rong),
                                          ("tren", -1, uy, rong / 2, dai), ("duoi", +1, uy, rong / 2, dai)):
        doc_canh = np.array([phap[1], -phap[0]])                         # hướng chạy dọc cạnh
        diem = []
        for s in np.linspace(-0.35, 0.35, 15) * doc:
            tam = np.array([cx, cy]) + goc_canh * nua * phap + s * doc_canh
            q = tim_canh(anh, tam, -goc_canh * phap)                    # quét từ ngoài vào trong
            if q is not None:
                diem.append(q)
        canh[ten] = fit_duong(doi_mm(np.array(diem)))
    r0 = math.sqrt(cv2.contourArea(lo[0]) / math.pi)
    diem_lo = [tim_canh(anh, (lx + r0 * math.cos(a), ly + r0 * math.sin(a)), (math.cos(a), math.sin(a)))
               for a in np.linspace(0, 2 * math.pi, 120, endpoint=False)]
    tam_lo, ban_kinh = fit_tron(doi_mm(np.array([q for q in diem_lo if q is not None])))

    def kc(c1, c2):                                       # khoảng cách giữa hai đường gần song song
        n = c1[1] if np.dot(c1[1], c2[1]) > 0 else -c1[1]
        n = (n + c2[1]) / np.linalg.norm(n + c2[1])
        return abs(np.dot(c2[0] - c1[0], n))

    return {"L": kc(canh["trai"], canh["phai"]), "W": kc(canh["tren"], canh["duoi"]), "D": 2 * ban_kinh,
            "X": abs(np.dot(tam_lo - canh["trai"][0], canh["trai"][1]))}


kq = do_tam_kep(cv2.imread("du_an8/A_lan00.png", cv2.IMREAD_GRAYSCALE))
print("Chi tiết A, lần 0:", {k: round(float(v), 4) for k, v in kq.items()})

Chi tiết A, lần 0: {'L': 40.0164, 'W': 24.9922, 'D': 10.0087, 'X': 12.0068}

Bước 4. Báo cáo theo dung sai

import cv2

BAN_VE = {"L": (40.00, 0.05), "W": (25.00, 0.05), "D": (10.00, 0.03), "X": (12.00, 0.05)}


def bao_cao(ten, kq):
    print(f"Chi tiết {ten}")
    print("  kích thước | danh định | dung sai |  đo được | sai lệch | kết quả")
    tong = "OK"
    for k, (dd, ds) in BAN_VE.items():
        lech = kq[k] - dd
        ok = abs(lech) <= ds
        tong = tong if ok else "NG"
        print(f"      {k}      |  {dd:7.2f}  |  ±{ds:.2f}   | {kq[k]:8.3f} | {lech:+7.3f}  | {'OK' if ok else 'NG'}")
    print(f"  KẾT LUẬN: {tong}")
    return tong


for ten in "ABC":
    bao_cao(ten, do_tam_kep(cv2.imread(f"du_an8/{ten}.png", cv2.IMREAD_GRAYSCALE)))

Chi tiết A
  kích thước | danh định | dung sai |  đo được | sai lệch | kết quả
      L      |    40.00  |  ±0.05   |   40.016 |  +0.016  | OK
      W      |    25.00  |  ±0.05   |   24.992 |  -0.008  | OK
      D      |    10.00  |  ±0.03   |   10.006 |  +0.006  | OK
      X      |    12.00  |  ±0.05   |   12.007 |  +0.007  | OK
  KẾT LUẬN: OK
Chi tiết B
  kích thước | danh định | dung sai |  đo được | sai lệch | kết quả
      L      |    40.00  |  ±0.05   |   40.000 |  +0.000  | OK
      W      |    25.00  |  ±0.05   |   25.006 |  +0.006  | OK
      D      |    10.00  |  ±0.03   |   10.042 |  +0.042  | NG
      X      |    12.00  |  ±0.05   |   11.993 |  -0.007  | OK
  KẾT LUẬN: NG
Chi tiết C
  kích thước | danh định | dung sai |  đo được | sai lệch | kết quả
      L      |    40.00  |  ±0.05   |   40.066 |  +0.066  | NG
      W      |    25.00  |  ±0.05   |   25.011 |  +0.011  | OK
      D      |    10.00  |  ±0.03   |    9.998 |  -0.002  | OK
      X      |    12.00  |  ±0.05   |   12.023 |  +0.023  | OK
  KẾT LUẬN: NG

Kết quả hiển thị 3 chữ số thập phân (micromet) vì σ của hệ đo cỡ micromet (bước 5); hiển thị nhiều hơn là giả chính xác. B bị loại đúng vì lỗ Ø10,041 mm; C bị loại đúng vì dài 40,063 mm. Chú ý A: các kích thước nằm sát nhau quanh danh định nên rõ ràng OK; một chi tiết đo được, ví dụ, L = 40,048 mm thì sao? Với σ vài micromet, nó có thể là 40,052 thật. Đó là lý do dùng dải bảo vệ (bài Quy đổi pixel sang mm) khi kích thước đo được nằm trong khoảng ±3σ quanh giới hạn.

Bước 5. Độ lặp lại và so sánh với cách đo ngây thơ

import glob
import json

import cv2
import numpy as np

that = json.load(open("du_an8/dap_an.json"))["chi_tiet"]["A"]          # giá trị CMM của chi tiết A

# Cách ngây thơ: một hệ số mm/px lấy từ bàn cờ ở tâm ảnh, không khử méo, không homography
def ngay_tho(P):
    return np.asarray(P, np.float64) * s_tam


ket_qua = {"đầy đủ": [], "ngây thơ": []}
for f in sorted(glob.glob("du_an8/A_lan*.png")):
    g = cv2.imread(f, cv2.IMREAD_GRAYSCALE)
    ket_qua["đầy đủ"].append(do_tam_kep(g))
    ket_qua["ngây thơ"].append(do_tam_kep(g, doi_mm=ngay_tho))

for cach, ds in ket_qua.items():
    print(f"Cách đo {cach} (10 lần đặt lại chi tiết A)")
    print("  kt |  trung bình |  σ (µm) | 6σ/T (%) | bias (µm) | đạt Y5")
    for k, (dd, dsai) in BAN_VE.items():
        x = np.array([d[k] for d in ds])
        s = x.std(ddof=1)
        ty_le = 100 * 6 * s / (2 * dsai)
        print(f"  {k}  |  {x.mean():9.4f}  | {1000 * s:6.2f}  |  {ty_le:6.1f}  | {1000 * (x.mean() - that[k]):+8.2f}  | "
              f"{'đạt' if ty_le <= 20 else 'KHÔNG'}")

Cách đo đầy đủ (10 lần đặt lại chi tiết A)
  kt |  trung bình |  σ (µm) | 6σ/T (%) | bias (µm) | đạt Y5
  L  |    40.0156  |   0.82  |     4.9  |    +3.58  | đạt
  W  |    24.9928  |   1.30  |     7.8  |    +1.77  | đạt
  D  |    10.0091  |   1.66  |    16.6  |    +1.13  | đạt
  X  |    12.0058  |   1.64  |     9.8  |    +1.79  | đạt
Cách đo ngây thơ (10 lần đặt lại chi tiết A)
  kt |  trung bình |  σ (µm) | 6σ/T (%) | bias (µm) | đạt Y5
  L  |    40.0879  |  12.14  |    72.8  |   +75.85  | KHÔNG
  W  |    25.0406  |   9.59  |    57.5  |   +49.62  | KHÔNG
  D  |    10.0357  |   3.55  |    35.5  |   +27.73  | KHÔNG
  X  |    12.0393  |   4.19  |    25.1  |   +35.30  | KHÔNG

Đọc hai bảng:

• Hiệu chuẩn đầy đủ: σ từ 0,8 tới 1,7 µm, 6σ/T từ 5% tới khoảng 17% (D có dải dung sai hẹp nhất nên tỉ lệ cao nhất), bias từ +1 tới +4 µm. Đây là câu trả lời cho bài thực hành: "Đo 10 lần cùng một chi tiết, tính độ lệch chuẩn và so với dung sai yêu cầu": hệ đo đạt Y5, và với D thì ở mức "chấp nhận có điều kiện" theo hướng dẫn 10:1 / 4:1 của bài Quy đổi pixel sang mm.
• Số tia đo lỗ quyết định σ của D: phiên bản đầu của lời giải dùng 48 tia và được σ = 3,6 µm (6σ/T = 36%, không đạt); tăng lên 120 tia giảm σ khoảng √(120/48) ≈ 1,6 lần, về khoảng 1,7 µm. Đây là "núm vặn" rẻ nhất, trước khi nghĩ tới camera độ phân giải cao hơn.
• Cách ngây thơ trên cùng 10 ảnh: σ tăng 2–15 lần (3,5–12 µm) vì sai số giờ phụ thuộc vị trí và góc chi tiết trong ảnh (méo và nghiêng thay đổi theo vị trí), và bias lên tới +28 … +76 µm vì tỉ lệ lấy ở tâm bàn cờ không đại diện cho cả vùng chi tiết. Không kích thước nào đạt; L còn bị đẩy sát giới hạn trên dù chi tiết thật chỉ dài hơn danh định 12 µm. Một kỹ sư chỉ thử chi tiết đặt ở giữa ảnh sẽ không bao giờ thấy vấn đề này.
• Bias còn lại của cách đầy đủ có nguồn gốc giống bài Quy đổi pixel sang mm: vị trí biên phụ thuộc mờ quang học và lấy mẫu; ở trạm thật cần thêm bước bù biên bằng căn mẫu hoặc vòng chuẩn. Capstone 1 làm bước này.