Bỏ qua tới nội dung chính

Trước khi có đồ họa máy tính

Đồ họa máy tính: biến những con số thành hình ảnh

Máy tính vẽ ảnh ra sao: raster hóa tam giác, ma trận và phép chiếu phối cảnh, ánh sáng Lambert và Phong, dò tia, GPU — và nên bắt đầu học đồ họa từ đâu.

Ban biên tập OpenER

Cập nhật 09/11/2026 · 19 phút đọc · CC BY 4.0

Tối thứ bảy, cậu em chơi một ván đua xe trên điện thoại: chiếc xe ôm cua, ánh đèn đường loang trên thân xe bóng loáng. Phòng bên, cả nhà xem lại một phim hoạt hình của Pixar. Còn ở văn phòng thiết kế đầu ngõ, kiến trúc sư xoay mô hình ngôi nhà ba tầng cho chủ nhà xem mặt tiền lúc hoàng hôn.

Không khung hình nào trong ba cảnh đó do người vẽ tay. Máy tính chỉ giữ một bản mô tả thế giới bằng con số — tọa độ các góc của từng mặt, màu và độ bóng của vật liệu, vị trí đèn và máy quay — rồi tính ra màu của từng điểm ảnh: sáu mươi lần mỗi giây với game, có khi hàng giờ cho một khung hình phim. Biến con số thành hình ảnh là việc của đồ họa máy tính (computer graphics).

Trước khi có đồ họa máy tính

Trước khi máy biết vẽ, mọi hình ảnh kỹ thuật đều qua tay người. Kỹ sư ô tô, máy bay đứng trước bàn vẽ lớn với thước, compa, bút chì; sửa một chi tiết có khi phải vẽ lại cả tờ, rồi đắp mô hình đất sét cỡ thật để xem hình khối.

Đồ họa máy tính ra đời qua mấy bước:

  1. Vẽ nét và thiết kế bằng máy — thập niên 1950–1960. Những màn hình đầu tiên là màn hình vẽ nét (vector display): chùm electron chạy từ điểm này tới điểm kia như ngòi bút, vẽ được đường thẳng nhưng không tô được mảng màu. Năm 1960, ở hãng Boeing, William Fetter và đồng nghiệp đặt ra cụm từ "computer graphics". Các hãng xe đi đầu về thiết kế có máy tính hỗ trợ (computer-aided design — CAD): hệ thống DAC-1 của General Motors và IBM, trình làng năm 1964, đã thiết kế một nắp cốp xe rồi gửi thẳng số liệu sang máy phay; ở Renault, Pierre Bézier mô tả thân xe bằng những đường cong nay mang tên ông. (Chuyện Sketchpad năm 1963 được kể ở bài Tương tác người – máy.)
  2. Lưới điểm ảnh — thập niên 1970. Khi bộ nhớ đủ rẻ để lưu một màu cho từng điểm trên màn hình — vùng nhớ ấy gọi là bộ đệm khung (framebuffer) — màn hình chuyển sang kiểu quét từng hàng như tivi, gọi là raster. Câu hỏi của ngành đổi thành: mỗi điểm ảnh nên có màu gì?
  3. Trường phái Utah — 1971 đến 1975. Ở Đại học Utah, nhóm của David Evans và Ivan Sutherland quy tụ một lớp nghiên cứu sinh đặc biệt. Henri Gouraud (1971) và Bùi Tường Phong (1973) tìm ra cách tô bóng (shading) để một vật ghép từ mặt phẳng trông như mặt cong nhẵn. Edwin Catmull (1974) dùng bộ đệm độ sâu (z-buffer) để biết vật nào che vật nào, và dán ảnh lên bề mặt — dán vân (texture mapping). Năm 1975, Martin Newell dựng mô hình số của chiếc ấm trà nhà mình; ấm trà Utah (Utah teapot) thành bài "Hello, world" của ngành, còn chiếc ấm thật nay nằm ở Bảo tàng Lịch sử Máy tính ở California.
  4. Dò tia — 1980. Turner Whitted công bố cách dựng hình bằng dò tia (ray tracing): lần theo tia sáng, kể cả khi nó dội trên gương hay xuyên qua thủy tinh. Ảnh đẹp chưa từng thấy, nhưng máy thời đó phải tính rất lâu cho mỗi ảnh. Năm 1986, James Kajiya viết ra phương trình dựng hình (rendering equation), một tích phân mô tả toàn bộ ánh sáng trong cảnh.
  5. Phim và GPU — từ 1986. Steve Jobs mua bộ phận đồ họa của Lucasfilm, tách thành công ty Pixar do Catmull điều hành. Năm 1995, Toy Story ra rạp — phim truyện dài đầu tiên làm hoàn toàn bằng máy tính; theo tạp chí Wired thời đó, riêng bản cuối đã tốn khoảng 800.000 giờ máy. Năm 1999, NVIDIA bán GeForce 256 và gọi nó là "GPU đầu tiên"; năm 2018, dòng card RTX đưa dò tia vào game. Catmull và Pat Hanrahan, kiến trúc sư của phần mềm dựng hình RenderMan, nhận giải Turing năm 2019.

Đặt cạnh nhau:

Chưa có đồ họa máy tính
Có đồ họa máy tính
Bản vẽ kỹ thuật
Vẽ tay trên bàn vẽ; sửa một chi tiết là vẽ lại cả tờ
Sửa trên máy, xoay xem từ mọi phía, gửi thẳng số liệu sang máy gia công
Xem trước ngôi nhà
Đọc bản vẽ mặt bằng, tự tưởng tượng
Ảnh phối cảnh lúc nắng sớm, lúc lên đèn; đi dạo ảo từng phòng
Dữ liệu y tế, khoa học
Phim chụp phẳng, bảng số, đồ thị vẽ tay
Dựng hình 3D từ ảnh chụp cắt lớp, dữ liệu thời tiết thành hình động

Ngày nay vẫn có những nơi sống như thời chưa có đồ họa máy tính. Ở không ít vùng quê, nhà được xây theo kinh nghiệm của ông thợ cả và vài nét vẽ tay; chủ nhà chỉ thật sự thấy ngôi nhà khi đã đổ mái — muốn đổi ô cửa sổ lúc đó là phải đục tường. Cũng ngôi nhà ấy, một văn phòng thiết kế dựng được ảnh phối cảnh 3D trong một buổi chiều. Chữ "phối cảnh" dân xây dựng hay dùng cũng là tên phép toán ở ý tưởng thứ hai dưới đây.

Môn này trả lời câu hỏi gì

Đồ họa máy tính trả lời câu hỏi: cho một thế giới được mô tả bằng con số, làm sao tính ra bức ảnh mà một chiếc máy ảnh đặt trong thế giới đó sẽ chụp được — đủ thật, và đủ nhanh?

Câu hỏi tách thành ba mạch của mọi giáo trình:

  • Mô hình hóa (modeling): mô tả hình dạng bằng tam giác, đường cong, mặt cong.
  • Dựng hình (rendering): từ hình dạng, vật liệu, ánh sáng, tính ra màu từng điểm ảnh — bằng raster hóa (rasterization) nhanh cho game, hay dò tia chậm hơn nhưng thật hơn cho phim; hai đường ngày càng nhập lại.
  • Hoạt hình (animation): làm mọi thứ chuyển động, thường mượn mô phỏng từ bài Vật lý.

"Đủ thật" và "đủ nhanh" kéo về hai phía: phim chờ được hàng giờ cho một khung hình, game chỉ có một phần sáu mươi giây. Vì sao nên học? Vì đây là nơi đại số tuyến tính, giải tích và quang học thành thứ nhìn thấy được — sai một dấu trừ là thấy ngay trên màn hình.

Năm ý tưởng cốt lõi

1. Từ tam giác tới điểm ảnh: raster hóa

Ảnh trên màn hình là một lưới điểm ảnh, mỗi điểm ba con số đỏ, lục, lam — bài Nhập môn khoa học máy tính đã kể. Còn thế giới 3D trong game gần như luôn được ghép từ tam giác. Vì sao tam giác? Ba điểm bất kỳ luôn nằm trên một mặt phẳng, nên tam giác không bao giờ "vênh", và hình nào cũng xấp xỉ được bằng đủ nhiều tam giác.

Bước nối hai thế giới là raster hóa: cho một tam giác đã chiếu lên màn hình, tìm những điểm ảnh nằm trong nó. Card đồ họa dùng hàm cạnh (edge function): với mỗi cạnh, một phép nhân chéo cho biết điểm đang xét nằm ở phía nào của cạnh. Điểm nằm cùng một phía với cả ba cạnh là điểm ở trong tam giác:

python
def canh(a, b, p):
    """Dấu của kết quả cho biết điểm p nằm ở phía nào của đường thẳng đi từ a tới b."""
    return (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0])

A, B, C = (3, 1), (37, 7), (13, 15)        # ba đỉnh tam giác, tính bằng ô trên màn hình

for y in range(16):
    hang = ""
    for x in range(40):
        p = (x + 0.5, y + 0.5)              # tâm của điểm ảnh
        trong = canh(A, B, p) >= 0 and canh(B, C, p) >= 0 and canh(C, A, p) >= 0
        hang += "#" if trong else "."
    print(hang)
text
........................................
...###..................................
....########............................
.....############.......................
.....##################.................
......#######################...........
.......###########################......
........############################....
........#########################.......
.........#####################..........
..........#################.............
..........##############................
...........##########...................
............######......................
.............##.........................
........................................

Mép tam giác răng cưa vì mỗi điểm ảnh chỉ được hỏi một lần, ở tâm. Hỏi vài điểm trong mỗi ô rồi lấy trung bình — khử răng cưa (antialiasing) — mép sẽ mịn hơn.

Ba giá trị hàm cạnh còn cho nhiều hơn chữ "trong" hay "ngoài". Chia mỗi giá trị cho tổng của cả ba, ta được tọa độ trọng tâm (barycentric coordinates): điểm ảnh "nghiêng" về mỗi đỉnh bao nhiêu. Dùng chúng để pha màu của ba đỉnh là cách tô bóng của Gouraud. Dùng chúng để pha độ xa của ba đỉnh, ta biết điểm ảnh này cách mắt bao nhiêu và so với z-buffer: chỉ ghi màu mới nếu nó gần mắt hơn màu đang có, nên vẽ các tam giác theo thứ tự nào cũng đúng. Một khung hình game là việc này lặp lại cho hàng triệu tam giác.

2. Tọa độ thuần nhất và phép chiếu phối cảnh

Bài Đại số tuyến tính đã cho thấy ma trận xoay, phóng to một điểm, và nhiều phép biến đổi ghép được thành một ma trận. Đồ họa còn cần hai việc mà ma trận thông thường không làm được.

Việc thứ nhất là tịnh tiến (translation): dời một cái cây sang trái 3 mét. Phép nhân ma trận luôn giữ nguyên gốc tọa độ — số 0 nhân với gì cũng bằng 0 — nên không ma trận 3 × 3 nào dời được điểm. Mẹo là tọa độ thuần nhất (homogeneous coordinates): thêm cho mỗi điểm một tọa độ thứ tư bằng 1 và dùng ma trận 4 × 4; cột cuối của ma trận, nhân với số 1 ấy, chính là đoạn dời. Từ đây xoay, phóng to, tịnh tiến đều ghép được thành một ma trận 4 × 4.

Việc thứ hai là phép chiếu phối cảnh (perspective projection): vật càng xa trông càng nhỏ. Trên màn hình, đó là một phép chia: x và y chia cho độ xa z. Phép chia không phải phép nhân ma trận, nhưng tọa độ thứ tư lại giúp được: ma trận chiếu chép z vào ô thứ tư, gọi là w, và phần cứng chia cho w ở bước cuối. Thử với hàng cột điện cao 8 mét bên đường, nhìn từ mắt một người cao 1,5 mét:

python
def nhan(M, v):                               # ma trận nhân vector
    return [sum(m * x for m, x in zip(hang, v)) for hang in M]

# Tịnh tiến: hạ cả thế giới xuống 1,5 m để mắt người đứng xem nằm ở gốc tọa độ.
# Ma trận 3 × 3 không dịch chuyển được điểm; ma trận 4 × 4 thì được,
# nếu mỗi điểm mang thêm một tọa độ thứ tư bằng 1.
TINH_TIEN = [[1, 0, 0,  0],
             [0, 1, 0, -1.5],
             [0, 0, 1,  0],
             [0, 0, 0,  1]]

# Chiếu phối cảnh với tiêu cự 2: hàng cuối chép độ xa z sang tọa độ thứ tư w.
CHIEU = [[2, 0, 0, 0],
         [0, 2, 0, 0],
         [0, 0, 1, 0],
         [0, 0, 1, 0]]

def len_man_hinh(diem):
    x, y, z, w = nhan(CHIEU, nhan(TINH_TIEN, diem + [1]))
    return x / w, y / w                       # chia cho w, tức là chia cho độ xa

for xa in [10, 20, 40, 80]:                   # cột điện cao 8 m, bên phải người xem 3 m
    x_goc, y_goc = len_man_hinh([3, 0, xa])
    x_ngon, y_ngon = len_man_hinh([3, 8, xa])
    print(f"cột cách {xa:2d} m: lệch khỏi tâm {x_goc:.3f}, cao {y_ngon - y_goc:.3f}")
text
cột cách 10 m: lệch khỏi tâm 0.600, cao 1.600
cột cách 20 m: lệch khỏi tâm 0.300, cao 0.800
cột cách 40 m: lệch khỏi tâm 0.150, cao 0.400
cột cách 80 m: lệch khỏi tâm 0.075, cao 0.200

Xa gấp đôi thì cột thấp đi một nửa và dồn vào gần tâm một nửa: cả hàng cột hội tụ về điểm tụ (vanishing point) giữa màn hình — luật phối cảnh mà các nghệ sĩ Phục Hưng ở Ý tìm ra từ thế kỷ XV, nay là một hàng trong ma trận.

3. Ánh sáng: định luật cosin và đốm sáng của Phong

Hình đã đúng chỗ, giờ cần đúng màu. Buổi trưa nắng chiếu thẳng xuống, sân phơi lúa nóng rát; buổi chiều cũng mặt trời ấy nhưng chiếu xiên, sân chỉ ấm. Chùm sáng chiếu xiên trải ra trên diện tích rộng hơn, nên mỗi mét vuông nhận ít ánh sáng hơn. Định luật cosin của Lambert (Lambert's cosine law), công bố năm 1760, nói chính xác điều đó: độ sáng của một mặt nhám tỷ lệ với cosin của góc giữa pháp tuyến (normal) — mũi tên vuông góc với mặt — và hướng tới nguồn sáng. Chiếu thẳng: cos 0° = 1, sáng nhất. Xiên 60°: cos 60° = 0,5, còn một nửa. Chiếu sát mặt: bằng 0. Với hai vector độ dài 1, cosin chính là tích vô hướng — phép tính của bài Đại số tuyến tính, nay quyết định độ sáng của từng điểm ảnh.

Vật bóng thì khác. Quả táo, chiếc mũ bảo hiểm, thân xe máy mới có một đốm sáng phản chiếu (specular highlight) chạy theo mắt người nhìn. Năm 1973, trong luận án tiến sĩ ở Utah, Bùi Tường Phong — sinh năm 1942 ở Hà Nội, lớn lên ở Sài Gòn rồi sang Pháp học kỹ sư — đưa ra công thức cho đốm sáng ấy: nó sáng nhất khi mắt nằm đúng hướng tia sáng dội lại như gương, và tắt dần khi lệch đi, nhanh hay chậm tùy một số mũ — số mũ càng cao, đốm càng nhỏ và vật càng bóng. Mô hình phản xạ Phong (Phong reflection model) cộng ba phần: ánh sáng nền (ambient), phần nhám theo Lambert (diffuse) và phần bóng (specular). Ông còn đề xuất tô bóng Phong (Phong shading): thay vì tính màu ở ba đỉnh rồi pha như Gouraud — dễ làm mất một đốm sáng nằm giữa tam giác — hãy pha pháp tuyến rồi tính ánh sáng tại từng điểm ảnh. Bài báo của ông in năm 1975 trên tạp chí Communications of the ACM; cũng năm ấy, ông mất ở California khi mới 32 tuổi. Game hiện nay dùng những mô hình dựa trên vật lý (physically based) chi tiết hơn, nhưng vẫn chia ánh sáng thành phần nhám và phần bóng như ông.

4. Dò tia: đi ngược đường ánh sáng

Raster hóa hỏi: tam giác này phủ những điểm ảnh nào? Dò tia hỏi ngược lại: điểm ảnh này nhìn thấy gì? Từ mắt, bắn một tia qua từng điểm ảnh, tìm vật đầu tiên tia chạm vào, rồi tính ánh sáng ở đó. Ánh sáng thật đi từ đèn tới mắt; ta đi ngược lại vì chỉ những tia tới được mắt mới đáng tính.

Với một quả cầu, câu hỏi "tia có chạm không" là một phương trình bậc hai, đúng loại học ở lớp 9: biệt thức âm thì tia trượt, không âm thì nghiệm nhỏ hơn là chỗ chạm gần mắt nhất. Đoạn dưới vẽ một quả cầu được chiếu từ phía trên bên trái, bằng đúng định luật cosin ở ý trước:

python
import math

def tich(u, v):                                   # tích vô hướng
    return sum(a * b for a, b in zip(u, v))

TAM, R = (0, 0, 3), 1                             # quả cầu bán kính 1, tâm cách mắt 3
DEN = (-0.577, 0.577, -0.577)                     # hướng tới đèn: phía trên, bên trái, gần mắt
BANG = ".:-=+*#%@"                                # từ tối tới sáng

def mau(d):
    """Bắn một tia từ mắt (gốc tọa độ) theo hướng d, trả về một ký tự."""
    # Điểm t·d nằm trên mặt cầu khi |t·d − TAM|² = R²: một phương trình bậc hai theo t
    a, b, c = tich(d, d), -2 * tich(d, TAM), tich(TAM, TAM) - R * R
    delta = b * b - 4 * a * c
    if delta < 0:
        return " "                                # tia trượt quả cầu: thấy nền
    t = (-b - math.sqrt(delta)) / (2 * a)         # giao điểm gần mắt hơn
    n = [(t * d[i] - TAM[i]) / R for i in range(3)]   # pháp tuyến tại giao điểm
    sang = max(0, tich(n, DEN))                   # định luật cosin của Lambert
    return BANG[round(sang * (len(BANG) - 1))]

for hang in range(20):
    y = 0.5 - (hang + 0.5) / 20                   # mỗi hàng ký tự là một hàng điểm ảnh
    print("".join(mau(((cot + 0.5) / 40 - 0.5, y, 1)) for cot in range(40)))
text
              %%%%%%###**+
           @@@@%%%%%###***++=
         @@@@@%%%%%####***++==-
        @@@@%%%%%%####***+++==-:
       @@@%%%%%%#####***+++===-::
      %%%%%%%%#####****+++===--:..
      %%%%%######****++++===--::..
      ########*****++++====--::...
      *####******+++++===---::....
       *******+++++====---:::....
        ++++++++=====---:::.....
         ========----::::......
           ------::::........
              ............

Cái hay của dò tia là những hiệu ứng khó trở nên tự nhiên. Muốn có bóng đổ (shadow): từ chỗ chạm, bắn thêm một tia về phía đèn; tia bị chặn thì điểm đó nằm trong bóng. Muốn có gương: bắn tia phản xạ, và màu ở đó là màu mà tia mới nhìn thấy — tức là gọi lại chính hàm mau. Đó là ý của Whitted năm 1980: dò tia đệ quy (recursive ray tracing). Phim ngày nay đi xa hơn với dò đường đi (path tracing): bắn hàng trăm tia ngẫu nhiên cho mỗi điểm ảnh để ước lượng tích phân ánh sáng của Kajiya — chính là phương pháp Monte Carlo trong bài Xác suất và thống kê.

Cảnh thật có hàng triệu tam giác, không thể thử từng cái cho từng tia. Trình dò tia xếp chúng vào một cây các hộp lồng nhau — cây hộp bao (bounding volume hierarchy — BVH): tia không đi qua một hộp thì bỏ luôn mọi thứ bên trong, nên mỗi tia chỉ phải thử vài chục hộp. Một bài học của Cấu trúc dữ liệu và giải thuật, áp vào không gian.

5. GPU: mỗi điểm ảnh một việc nhỏ, làm cùng một lúc

Trên máy chạy thử, hàm mau ở trên mất gần mười giây cho một khung hình Full HD — 1920 × 1080, hơn hai triệu điểm ảnh. Game chỉ có 1/60 giây, khoảng 17 mili giây, cho cả khung hình. Chậm cỡ năm, sáu trăm lần — mà mới chỉ một quả cầu, không bóng đổ, mỗi điểm ảnh một tia.

Nhưng nhìn kỹ đoạn code: lời gọi mau cho điểm ảnh này không cần biết gì về điểm ảnh bên cạnh. Hai triệu lời gọi chạy cùng lúc được, nếu có đủ người làm. Đồ họa có dạng ấy từ đầu tới cuối: mỗi đỉnh nhân ma trận riêng, mỗi điểm ảnh tính ánh sáng riêng. Card đồ họa sinh ra để khai thác đúng điều này: thay vì vài nhân rất thông minh như CPU, nó có hàng nghìn đơn vị tính đơn giản — lối song song bài Kiến trúc máy tính đã giới thiệu. Mỗi khung hình đi qua một đường ống đồ họa (graphics pipeline) gồm chính những ý ở trên:

  1. Bước đỉnh: nhân mỗi đỉnh với ma trận 4 × 4 (ý 2); sau đó phần cứng tự chia cho w.
  2. Raster hóa: tìm các điểm ảnh của từng tam giác (ý 1).
  3. Bước điểm ảnh: tính ánh sáng, dán vân (ý 3).
  4. Kiểm độ sâu: so với z-buffer, ghi màu vào bộ đệm khung.

Bước 1 và 3 là những chương trình nhỏ do lập trình viên viết, gọi là shader — cái tên có từ RenderMan của Pixar. Từ khoảng năm 2001, GPU cho lập trình các bước này, và người ta sớm nhận ra shader thực chất là phép tính song song trên hàng triệu con số, chẳng cần là màu. Năm 2007, NVIDIA ra CUDA để lập trình GPU như một máy tính song song; năm 2012, AlexNet huấn luyện trên GPU mở đầu thời học sâu, như bài Học máy kể. Năm 2018, GPU có thêm mạch riêng để duyệt cây hộp bao, nên game bắt đầu dò tia ngay lúc chơi cho bóng đổ và phản chiếu, rồi khử nhiễu để bù cho số tia ít ỏi.

Đồ họa máy tính nằm ở đâu trong chồng tầng

Trong chồng tầng của bài Từ electron đến ứng dụng, đồ họa nằm ở tầng ứng dụng, nhưng hiếm môn nào đi xuyên xuống phần cứng sâu như nó:

  • Trên cùng: bộ máy làm game (game engine) như Unity, Unreal; phần mềm dựng phim như Blender; CAD, bản đồ, trình duyệt web.
  • Ở giữa: các giao diện lập trình đồ họa — OpenGL, Direct3D, Vulkan, Metal, WebGPU — và trình điều khiển của card, nơi shader được dịch sang lệnh thật của từng con chip.
  • Dưới cùng: GPU, bộ nhớ đồ họa, màn hình.

Đưa lên

Một khung hình — lưới điểm ảnh sẵn sàng hiện lên màn hình, sáu mươi lần mỗi giây hoặc hơn — từ một bản mô tả cảnh gồm tam giác, vật liệu, đèn và máy quay.

Giấu đi

Hàng triệu tam giác bị cắt, bị che, bị bỏ; hàng tỷ phép nhân; và việc ánh sáng thật phức tạp hơn mọi công thức. Làm đồ họa giỏi là biết xấp xỉ ở chỗ mắt người không nhận ra.

Học trước và học sau

· 6 môn

Đại số tuyến tính

Linear Algebra

Vector, ma trận, tích vô hướng — ngôn ngữ của mọi phép biến đổi và phép tính ánh sáng. Nên học trước; không cần tới trị riêng hay SVD.

Xem chủ đề trên OpenER: Linear Algebra

Lập trình

Programming

Bài tập đồ họa là những chương trình lớn, thường viết bằng C++. Nên học trước.

Xem chủ đề trên OpenER: Programming

Vật lý

Physics

Quang học cho ánh sáng và vật liệu, cơ học cho hoạt hình: vải bay, nước chảy trên màn hình đều là mô phỏng.

Xem chủ đề trên OpenER: Physics

Tính toán song song

Parallel Computing

Lập trình GPU cho cả đồ họa lẫn việc khác: chia việc cho hàng nghìn luồng, và hiểu vì sao tốc độ không tăng như mong đợi.

Xem chủ đề trên OpenER: Parallel Computing

Thị giác máy tính

Computer Vision

Bài toán ngược của đồ họa: từ ảnh chụp suy ra hình dạng, vị trí và ánh sáng của thế giới 3D.

Xem chủ đề trên OpenER: Computer Vision

Tương tác người – máy

Human-Computer Interaction

Hình đẹp chưa đủ: giao diện, thực tế ảo, biểu đồ còn phải dễ hiểu và dễ dùng với người thật.

Xem chủ đề trên OpenER: Human Computer Interaction

Ứng dụng thật và nghề nghiệp

  • Lập trình đồ họa và game: viết bộ dựng hình, shader, tối ưu để giữ đủ khung hình mỗi giây.
  • Phim hoạt hình và hiệu ứng hình ảnh (VFX): viết công cụ, trình dựng hình, mô phỏng tóc, khói, nước.
  • CAD, kiến trúc, bản đồ: phần mềm thiết kế, ảnh phối cảnh, bản đồ 3D, mô phỏng lái xe để thử xe tự lái.
  • Y tế: dựng hình 3D từ ảnh chụp cắt lớp CT, MRI để bác sĩ xem trước ca mổ.
  • Thực tế ảo và tăng cường (VR/AR): khung hình phải vừa nhanh vừa đều để người đeo kính không chóng mặt.
  • Web và GPU: trình duyệt dùng GPU để cuộn mượt, vẽ biểu đồ hàng triệu điểm; các hãng chip cần người viết driver và thư viện đồ họa.

Học xong làm được gì, bắt đầu từ đâu

Sau môn này bạn có thể:

  • tự viết một trình raster hóa và một trình dò tia nhỏ từ con số không, không cần thư viện đồ họa;
  • dùng ma trận 4 × 4 để đặt vật, đặt máy quay, chiếu phối cảnh — và gỡ được lỗi "nhân vật bay mất";
  • giải thích vì sao một cảnh trông giả: thiếu bóng đổ, ánh sáng sai hướng, đốm sáng không chạy theo mắt;
  • viết shader đơn giản và hiểu vì sao cảnh chạy giật khi quá nhiều tam giác hay quá nhiều đèn.

Nên biết trước: vector, ma trận, tích vô hướng ở mức chủ đề Linear Algebra, và lập trình ở mức viết được chương trình vài trăm dòng.

Bắt đầu trên OpenER: trang chủ đề Computer Graphics có các khóa học đã chọn lọc, và hướng dẫn học gợi ý thứ tự: phép biến đổi và máy quay, raster hóa, chiếu sáng, rồi dò tia. Khóa chính là CS 184/284A của Đại học California, Berkeley: bài tập lớn đầu tiên là tự viết trình raster hóa tam giác như ý tưởng 1, các bài sau làm lưới tam giác, trình dò đường đi có cây hộp bao, rồi mô phỏng vải. CS 4620 của Đại học Cornell do Steve Marschner, đồng tác giả sách chính của hướng dẫn, giảng; MIT 6.837 thêm phần hoạt hình và đường cong; khóa của Đại học California, San Diego trên edX kết thúc bằng việc tự viết một trình dò tia. Lời khuyên cho môn này: vẽ mọi thứ ra. Khi hình sai, đừng đọc số — tô pháp tuyến thành màu, tô độ sâu thành độ xám, lỗi thường tự lộ ra trên màn hình.

Tài liệu tham khảo

  • Steve Marschner, Peter Shirley — Fundamentals of Computer Graphics, ấn bản thứ 5 (CRC Press, 2021).
  • Peter Shirley, Trevor David Black, Steve Hollasch — loạt sách Ray Tracing in One Weekend, đọc miễn phí tại raytracing.github.io.
  • Tomas Akenine-Möller và cộng sự — Real-Time Rendering, ấn bản thứ 4 (2018).
  • Matt Pharr, Wenzel Jakob, Greg Humphreys — Physically Based Rendering: From Theory to Implementation, đọc miễn phí tại pbr-book.org.
  • UC Berkeley CS 184/284A — Computer Graphics, Spring 2025 (Ren Ng).
  • Cornell CS 4620 Introduction to Computer Graphics (Steve Marschner).
  • MIT 6.837 Computer Graphics (Fall 2012) — MIT OpenCourseWare.
  • UC San Diego — Computer Graphics (Ravi Ramamoorthi) trên edX.
  • Bui Tuong Phong — "Illumination for Computer Generated Pictures", Communications of the ACM, 18(6), 1975.
  • Turner Whitted — "An Improved Illumination Model for Shaded Display", Communications of the ACM, 23(6), 1980.

Ban biên tập OpenER, “Đồ họa máy tính: biến những con số thành hình ảnh”, OpenER, 2026. Phát hành theo CC BY 4.0: được chia sẻ, chỉnh sửa, kể cả thương mại, miễn ghi công tác giả và dẫn link bài gốc.