ST Slide Hành động Thờ

T i
gia
n
1 Slide mở đầu = Tên nhóm + Mở slide
Thành viên + Đề tài Xin chào mọi người nhóm mình là
nhóm… với các thành viên… và
hôm nay bọn mình sẽ nói về chủ đề:
Đổi màu một hình tròn theo 3 màu
được lựa chọn.
2 Slide 2: Tại sao bọn mình lại chọn đề tài
Mục đích đề tài này ? Chính xác thì việc đổi màu
1.Trong thiết kế đồ họa một hình tròn có ý nghĩa gì ? Trên
Ảnh 1 thực tế việc việc đổi màu một hình
2.Trong thiết kế game tròn có rất nhiều ứng dụng như:
Ảnh 2 1.Trong thiết kế đồ họa:Đổi màu
một hình tròn có thể được sử dụng
để tạo ra các hiệu ứng hình ảnh đặc
biệt. Ví dụ, bạn có thể tạo ra ánh
sáng lóa, hiệu ứng mờ, hiệu ứng
lăng kính hoặc hiệu ứng phát sáng
xung quanh hình tròn.
2. Trong thiết kế game: việc đổi
màu một hình tròn có thể được sử
dụng để thể hiện trạng thái, điểm số
hoặc tương tác của nhân vật hoặc
đối tượng trong trò chơi. Ví dụ,
hình tròn có thể thay đổi màu khi
nhân vật tham gia trận đấu, khi
nhân vật thay đổi trạng thái như đói
hoặc no, hay biến thành màu đỏ khi
nhân vật vào vùng nguy hiểm…
4 Slide 3: 3. Trong cuộc sống đổi màu một
Mục đích đề tài hình tròn có thể biểu thị của việc
1.Trong đời sống thay đổi trạng thái của một phòng
Ảnh 3 + Ảnh 4 như đừng làm phiền, không có
trong phòng, đang trong một cuộc
họp,làm ơn gõ cửa,…
Hay trong công việc, trong các tài
liệu, bảng điểm, sơ đồ, đồ thị hoặc
 bất kỳ tài liệu nào cần sự nhấn
mạnh, bạn có thể sử dụng việc đổi
màu một hình tròn để ghi chú, làm
nổi bật hoặc phân biệt các phần tử
quan trọng
5 Ảnh: Để đổi màu một hình tròn bọn mình
Visual Studio sẽ dùng Visual Stuido 2022 và viết
C++ bằng ngôn ngữ C++ cùng với thư
OpenGL viện OpenGL

6 Ảnh code: Đầu tiên chúng ta khai báo thư viện

#include <GL/glut.h> OpenGL và một số biến dùng nhiều
lần như:biến RED cho màu đỏ,
// Hằng số đại diện cho màu sắc GREEN cho màu xanh lá,
const float RED[] = { 1.0, 0.0, YELLOW cho màu vàng start cho
0.0 }; màu khởi đầu, và biến currentColor
const float GREEN[] = { 0.0, tức cho màu hiện tại để đổi màu
1.0, 0.0 }; liên tục
const float YELLOW[] = { 1.0,
1.0, 0.0 };
const float start[] = { 1.0, 1.0, 1.0
};
// Biến lưu trữ màu sắc hiện tại
của hình tròn
const float* currentColor = start;
7 Ảnh code: Tiếp đó chúng ta viết hàm vẽ thực
// Hàm vẽ thực đơn (3 màu) đơn, ở đây bọn mình sẽ vẽ 3 hình
void drawSquare(float x, float y, vuông có 3 màu tương ứng để dại
const float* color) { điện cho thực đơn vì vẽ 3 hình nên
glColor3fv(color); chúng ta sẽ dùng hàm và thay đổi
glBegin(GL_QUADS); tọa độ x, y để có 3 hình vuông với 3
glVertex2f(x, y); màu tương ứng
glVertex2f(x + 50, y);
glVertex2f(x + 50, y + 50);
glVertex2f(x, y + 50);
glEnd();
}
Ảnh code: Tiếp đó chúng ta sẽ vẽ đường tròn
// Hàm vẽ hình tròn bằng thuật toán midpoint.
void drawCircle(int centerX, int int x = 0; và int y = radius; khởi
centerY, int radius) { tạo hai biến x và y để đại diện cho
int x = 0; tọa độ của điểm trên đường tròn.
int y = radius; Ban đầu, x bằng 0 và y bằng bán
int d = 1 - radius; kính của đường tròn.
int d = 1 - radius; khởi tạo biến d
glBegin(GL_POINTS); để đánh giá lỗi của thuật toán
Midpoint ban đầu. Giá trị này sẽ
while (x <= y) { được cập nhật trong quá trình vẽ.
glVertex2i(centerX + x, glBegin(GL_POINTS); là lệnh bắt
centerY + y); đầu vẽ các điểm trên màn hình bằng
glVertex2i(centerX - x, OpenGL.
centerY + y); Trong vòng lặp while, thuật toán
glVertex2i(centerX + x, Midpoint được áp dụng để tính toán
centerY - y); các điểm trên đường tròn. Trong
glVertex2i(centerX - x, mỗi vòng lặp, bạn sử dụng
centerY - y); glVertex2i để vẽ các điểm tương
glVertex2i(centerX + y, ứng trên đường tròn. Lưu ý rằng
centerY + x); bạn vẽ tám điểm đối xứng qua tâm
glVertex2i(centerX - y, của đường tròn để tạo hình tròn đầy
centerY + x); đủ.
glVertex2i(centerX + y, Cập nhật biến d dựa trên giá trị của
centerY - x); d. Nếu d < 0, nó được cập nhật theo
glVertex2i(centerX - y, d += 2 * x + 3. Nếu d >= 0, nó
centerY - x);
được cập nhật theo d += 2 * (x - y)
+ 5, và giá trị y giảm đi 1.
if (d < 0) {
Cuối cùng, x được tăng lên 1 ở cuối
d += 2 * x + 3;
mỗi vòng lặp để tiến tới vẽ các
}
điểm tiếp theo trên đường tròn.
else {
Khi tất cả các điểm trên đường tròn
d += 2 * (x - y) + 5;
đã được vẽ xong, bạn kết thúc bằng
y--;
glEnd() để hoàn thành việc vẽ.
}

x++;
};

}
Ảnh code: Sau khi vẽ được hình tròn, chúng ta
// Hàm tô màu hình tròn bắt đầu tô màu hình tròn theo thuật
void scanlineFillCircle(int toán đường quét.
centerX, int centerY, int radius)
{ ta duyệt qua mỗi dòng ngang trong
for (int y = centerY - radius; y
<= centerY + radius; y++) {
float leftX = centerX -
sqrt(radius * radius - (y -
centerY) * (y - centerY));
float rightX = centerX +
sqrt(radius * radius - (y -
centerY) * (y - centerY));
for (int x = leftX; x <=
rightX; x++) {
glBegin(GL_POINTS);
glColor3fv(currentColor);
glVertex2i(x, y);
glEnd();
} khoảng cách từ trục y đến đường
} tròn trên cùng hoặc dưới cùng của
} dòng ngang hiện tại. Điều này được
rong hàm scanlineFillCircle, chúng
phạm vi từ centerY -
radius đến centerY + radius. Điều
này đảm bảo rằng chúng ta duyệt
qua tất cả các dòng ngang mà
đường tròn có thể chạm vào.
Với mỗi dòng ngang, chúng ta tính
toán giới hạn bên trái và bên phải
của dòng ngang trong đường tròn
bằng cách sử dụng công thức hình
học. Điều này được thực hiện bằng
cách tính toán vị trí x trái (leftX) và
x phải (rightX) trên dòng ngang,
dựa trên bán kính của đường tròn và
vị trí y.
Công thức sqrt(radius * radius - (y -
centerY) * (y - centerY)) tính toán
thực hiện bằng cách sử dụng định lý
Pythagoras để tính căn bậc hai của
hiệu số giữa bán kính và khoảng
cách từ tâm đến trục y.
centerX - sqrt(radius * radius - (y -
centerY) * (y - centerY)) tính toán
vị trí x trái trên dòng ngang.
centerX + sqrt(radius * radius - (y -
centerY) * (y - centerY)) tính toán
vị trí x phải trên dòng ngang.
Sau khi tính toán vị trí x trái (leftX)
và x phải (rightX), chúng ta duyệt
qua mỗi điểm trên dòng ngang
từ leftX đến rightX. Điều này đảm
bảo rằng chúng ta duyệt qua tất cả
các điểm nằm trong đường tròn trên
dòng ngang hiện tại.
Với mỗi điểm, chúng ta sử
dụng glBegin(GL_POINTS) để bắt
đầu vẽ điểm và glEnd() để kết thúc
vẽ điểm. Trong trường hợp này,
chúng ta sử dụng glVertex2i(x,
y) để vẽ điểm tại vị trí x và y,
và glColor3fv(currentColor) để đặt
màu sắc của điểm bằng màu hiện tại
(currentColor).
Tuy nhiên, lưu ý rằng cách thực
hiện này dựa trên việc sử dụng các
điểm đơn lẻ để vẽ đường tròn, và
không tận dụng được tính chất đối
xứng của đường tròn. Điều này có
thể dẫn đến hiệu suất không tốt đối
với các đường tròn lớn hoặc có lỗ
hổng bên trong. Để tối ưu hóa thuật
toán và tận dụng tính chất đối xứng,
bạn có thể khTrong đoạn mã trên,
chúng ta sử dụng thuật toán
"scanline" để tô màu một đường
tròn. Dưới đây là giải thích rõ ràng
cho từng phần của mã:
Hàm scanlineFillCircle nhận ba
tham số: centerX và centerY là tọa
độ của tâm đường tròn, và radius là
bán kính của đường tròn.
Chúng ta duyệt qua từng dòng
ngang trong đường tròn bằng cách
thiết lập một vòng lặp cho
biến y từ centerY -
radius đến centerY + radius.
Trong mỗi dòng ngang, chúng ta
tính toán giới hạn bên trái và bên
phải của dòng ngang trong đường
tròn.
Biến leftX là giới hạn bên trái và
được tính toán bằng công
thức centerX - sqrt(radius * radius -
(y - centerY) * (y - centerY)).
Biến rightX là giới hạn bên phải và
được tính toán bằng công

Ảnh code:
// Hàm xử lý sự kiện nhấn chuột
void mouseClick(int button, int
state, int x, int y) {
if (button ==
GLUT_LEFT_BUTTON &&
thức centerX + sqrt(radius * radius
- (y - centerY) * (y - centerY)).
Trong công thức trên, chúng ta sử
dụng định lý Pythagoras để tính
toán khoảng cách từ tâm đường tròn
đến dòng ngang hiện tại. Chúng ta
trừ tọa độ y của dòng ngang từ tọa
độ y của tâm đường tròn, sau đó
tính căn bậc hai của hiệu số giữa
bán kính và khoảng cách đó.
Tiếp theo, chúng ta duyệt qua từng
điểm trên dòng ngang
từ leftX đến rightX. Chúng ta sử
dụng vòng lặp for cho biến x trong
phạm vi từ leftX đến rightX.
Trong mỗi điểm trên dòng ngang,
chúng ta sử
dụng glBegin(GL_POINTS) để bắt
đầu vẽ điểm và glEnd() để kết thúc
vẽ điểm.
Sử dụng glColor3fv(currentColor),
chúng ta đặt màu sắc của điểm bằng
màu hiện tại (currentColor). Lưu ý
rằng currentColor cần được khai
báo và cung cấp màu sắc trước khi
gọi hàm scanlineFillCircle.
Cuối cùng, chúng ta sử
dụng glVertex2i(x, y) để vẽ điểm
tại tọa độ x và y trên màn hình.
Điều này tạo ra các điểm liên tiếp
trên dòng ngang và tạo nên hình
dạng của đường tròn
Cuối cùng ta viết hàm xử lý sự kiện
chuột để đổi màu của hình tròn:
Hàm mouseClick là một hàm xử lý
sự kiện khi người dùng nhấn chuột
trong một ứng dụng sử dụng
OpenGL (có lẽ sử dụng thư viện
state == GLUT_DOWN) { GLUT). Hàm này được gọi khi có
sự kiện click chuột xảy ra, và nó
nhận vào bốn tham số:
if (x >= 0 && x <= 50 && button: Đây là nút chuột mà người
y >= 350 && y <= 400) { dùng đã nhấn (ví dụ: chuột trái,
currentColor = RED; chuột phải, ...).
} state: Trạng thái của nút chuột (ví
else if (x >= 60 && x <= dụ: nếu state == GLUT_DOWN,
110 && y >= 350 && y <= 400) nghĩa là nút chuột đã được nhấn,
{ còn state == GLUT_UP, nghĩa là
currentColor = GREEN; nút chuột đã được nhả ra).
} x: Tọa độ x của con trỏ chuột tại
else if (x >= 120 && x <= thời điểm sự kiện xảy ra.
170 && y >= 350 && y <= 400) y: Tọa độ y của con trỏ chuột tại
{ thời điểm sự kiện xảy ra.
currentColor = Các tọa độ x và y thường được đo
YELLOW; trong không gian màn hình, với gốc
} tọa độ tại góc trên bên trái của cửa
glutPostRedisplay(); // sổ.
Request to redraw the scene Hàm mouseClick trong ví dụ của
} bạn thực hiện các việc sau:
} Kiểm tra xem nút chuột đã được
nhấn và nếu đúng thì xem xét tọa
độ (x, y) của con trỏ chuột.
Nếu tọa độ (x, y) của con trỏ chuột
nằm trong một phạm vi cụ thể (ví
dụ: (x, y) nằm trong một hình chữ
nhật đã xác định), thì hàm này thực
hiện một hành động cụ thể. Trong
trường hợp của bạn, nó đặt màu
hiện tại (currentColor) dựa vào vị
trí con trỏ chuột. Nếu con trỏ chuột
nằm trong một trong ba hình chữ
nhật được xác định, nó đặt màu
currentColor thành RED,
GREEN, hoặc YELLOW tương
ứng.
Cuối cùng, sau khi đã đặt màu
currentColor, hàm gọi
 glutPostRedisplay() để yêu cầu
việc vẽ lại cảnh (redraw) với màu
mới.

Ảnh code: Tiếp đó ta viết hàm display để hiện

// Hàm hiển thị thị các hình vẽ
void display(void) { glClearColor(1.0, 1.0, 1.0, 1.0);:
glClearColor(1.0, 1.0, 1.0,
Đây là lệnh để đặt màu nền của cửa
1.0); sổ. Trong trường hợp này, màu nền
được đặt thành màu trắng với giá trị
glClear(GL_COLOR_BUFFER_ RGBA (đỏ, xanh lam, xanh lá cây,
BIT); và độ trong suốt) lần lượt bằng 1.0.
drawSquare(0, 0, RED); glClear(GL_COLOR_BUFFER_
drawSquare(60, 0, GREEN); BIT);: Hàm này dùng để xóa nội
drawSquare(120, 0, dung trước đó trên cửa sổ vẽ
YELLOW); (OpenGL gọi nó là "color buffer").
drawCircle(300, 200,100); Bằng cách này, bạn xóa bất kỳ hình
fillCircle(300,200,150); ảnh hoặc hình vẽ trước đó trên cửa
glFlush(); sổ.
} drawSquare(0, 0, RED);,
drawSquare(60, 0, GREEN);,
drawSquare(120, 0, YELLOW);:
Đây là ba lời gọi để vẽ ba hình
vuông ở các vị trí khác nhau trên
cửa sổ. Các hình vuông được vẽ bởi
hàm drawSquare với các tham số
khác nhau (tọa độ và màu). Điều
này dẫn đến việc vẽ ba hình vuông
màu đỏ, xanh lam và màu vàng
tương ứng ở các vị trí khác nhau
trên cửa sổ.
drawCircle(300, 200, 100);: Lời
gọi này dùng để vẽ một đường tròn
tại tọa độ (300, 200) với bán kính
100. Hàm drawCircle đã được giải
thích trong các câu trả lời trước đó.
fillCircle(300, 200, 150);: Lời gọi
này dùng để tô màu một hình tròn
nằm trên đường tròn với tọa độ

Ảnh code:
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SI
NGLE | GLUT_RGB);
glutInitWindowSize(600,
400);
glutInitWindowPosition(100,
100);
glutCreateWindow("Vẽ hình
vuông và hình tròn");
gluOrtho2D(0, 600, 0, 400);
glutDisplayFunc(display);
glutMouseFunc(mouseClick);
glutMainLoop();
return 0;
}
(300, 200) và bán kính 150. Hàm
fillCircle đã được giải thích trong
câu trả lời trước.
glFlush();: Hàm này đảm bảo rằng
mọi thay đổi được vẽ lên cửa sổ sẽ
được hiển thị ngay lập tức.
Cuối cung ta viết hàm main:
int main(int argc, char** argv):
Đây là hàm main của chương trình.
Nó là hàm chính mà chương trình
sẽ bắt đầu thực thi từ đó.
glutInit(&argc, argv);: Hàm
glutInit được sử dụng để khởi tạo
thư viện GLUT. Nó nhận vào con
trỏ đến biến argc và mảng argv từ
hàm main để xử lý các tham số
dòng lệnh khi bạn chạy chương
trình.
glutInitDisplayMode(GLUT_SIN
GLE | GLUT_RGB);: Hàm này
được sử dụng để khai báo chế độ
hiển thị của cửa sổ đồ họa.
GLUT_SINGLE nghĩa là sử dụng
cửa sổ đơn và GLUT_RGB nghĩa
là sử dụng chế độ màu sắc RGBA
(đỏ, xanh lam, xanh lá cây, alpha)
cho việc vẽ.
glutInitWindowSize(600, 400);:
Hàm này được sử dụng để đặt kích
thước ban đầu của cửa sổ đồ họa.
Kích thước được đặt ở đây là 600
pixel theo chiều rộng và 400 pixel
theo chiều cao.
glutInitWindowPosition(100,
100);: Hàm này đặt vị trí ban đầu
của cửa sổ đồ họa trên màn hình. Ở
đây, cửa sổ sẽ được đặt tại vị trí có
tọa độ (100, 100) trên màn hình.
glutCreateWindow("Vẽ hình
vuông và hình tròn");: Hàm này
tạo ra một cửa sổ đồ họa với tiêu đề
"Vẽ hình vuông và hình tròn". Cửa
sổ này sẽ hiển thị khi chạy chương
trình.
gluOrtho2D(0, 600, 0, 400);: Hàm
gluOrtho2D đặt ma trận chiếu
(projection matrix) để xác định hệ
toạ độ 2D. Trong trường hợp này,
nó đặt hệ toạ độ từ (0, 0) ở góc trái
dưới của cửa sổ đến (600, 400) ở
góc phải trên. Điều này đảm bảo
rằng bạn có một hệ toạ độ 2D chuẩn
để làm việc trong cửa sổ.
glutDisplayFunc(display);: Hàm
này liên kết hàm display với việc
cập nhật cửa sổ đồ họa. Điều này
nghĩa là khi cửa sổ cần được vẽ lại,
hệ thống sẽ gọi hàm display để vẽ
nội dung trên cửa sổ.
glutMouseFunc(mouseClick);:
Hàm này liên kết hàm mouseClick
với việc xử lý sự kiện click chuột.
Khi người dùng nhấn chuột, hệ
thống sẽ gọi hàm mouseClick để
xử lý sự kiện này.
glutMainLoop();: Hàm này bắt
đầu vòng lặp chính của ứng dụng sử
dụng GLUT. Trong vòng lặp này,
chương trình sẽ tiếp tục thực thi và
xử lý sự kiện cho đến khi người
dùng đóng cửa sổ đồ họa hoặc thoát
ứng dụng.
return 0;: Kết thúc hàm main với
giá trị trả về 0 để thông báo rằng
chương trình đã hoàn thành mà
không có lỗi.
 Slide kết thúc: Nói gì đó tổng kết lại và cảm ơn
Cảm ơn

1. Thuật toán Midpoint Circle là một thuật toán đơn giản và hiệu quả để vẽ đường
tròn. Nó được gọi là "Midpoint" vì nó sử dụng giá trị "giữa" (midpoint) để quyết
định điểm tiếp theo trên đường tròn.

Dưới đây là cách thuật toán Midpoint Circle hoạt động:

Khởi tạo các biến: đặt x = 0, y = bán kính (radius), d = 1 - radius.

Bắt đầu vòng lặp while với điều kiện x <= y. Điều này đảm bảo rằng thuật toán chỉ
vẽ một nửa đường tròn và áp dụng đối xứng để vẽ phần còn lại.

Bên trong vòng lặp, chúng ta vẽ các điểm tương ứng với tám phần tử đối xứng trên
đường tròn. Điểm này được vẽ bằng cách gọi hàm glVertex2i để vẽ một điểm ở tọa
độ (x, y).

Tiếp theo, chúng ta cần quyết định điểm tiếp theo trên đường tròn. Điều này được
thực hiện bằng cách kiểm tra giá trị d.

Nếu d < 0, điểm tiếp theo nằm ở vị trí (x+1, y). Để cập nhật giá trị d, chúng ta thực
hiện d += 2 * x + 3.

Nếu d >= 0, điểm tiếp theo nằm ở vị trí (x+1, y-1). Để cập nhật giá trị d, chúng ta
thực hiện d += 2 * (x - y) + 5 và giảm giá trị y đi 1 đơn vị.

Kết thúc vòng lặp.

Ưu điểm của thuật toán Midpoint Circle:

Đơn giản và dễ hiểu: Thuật toán Midpoint Circle khá đơn giản và dễ hiểu, không
yêu cầu nhiều kiến thức toán học phức tạp.

Hiệu quả: Thuật toán này chỉ vẽ một nửa đường tròn và áp dụng đối xứng để vẽ
phần còn lại, giúp giảm số lượng lệnh vẽ được gọi và tiết kiệm tài nguyên tính
toán.
Hạn chế của thuật toán Midpoint Circle:

Không vẽ đường tròn hoàn hảo: Vì thuật toán chỉ vẽ một phần của đường tròn và
áp dụng đối xứng, nên đường tròn vẽ ra có thể không hoàn hảo, đặc biệt là khi bán
kính đường tròn lớn.

Không hỗ trợ điểm cong tạo thành đường cong: Thuật toán Midpoint Circle chỉ vẽ
các điểm rời rạc trên đường tròn. Nếu bạn muốn vẽ các đường cong mượt mà, bạn
cần sử dụng các thuật toán khác như Bresenham's Circle Algorithm hoặc thuật toán
vẽ đường tròn dựa trên phép biến đổi ma trận.

Hiệu suất bị ảnh hưởng bởi kích thước đường tròn: Thuật toán Midpoint Circle có
độ phức tạp thời gian O(r), trong đó r là bán kính của đường tròn. Vì vậy, hiệu suất
của thuật toán có thể bị ảnh hưởng nếu bán kính đường trònlớn. Với các bán kính
lớn, số lượng điểm cần vẽ cũng tăng, làm giảm hiệu suất của thuật toán.

2.. Dưới đây là một phương pháp thuật toán tô màu theo đường quét (scanline)
cho việc tô màu một đường tròn:

Khởi tạo tâm và bán kính của đường tròn (centerX, centerY, radius).

Duyệt qua từng dòng ngang trong phạm vi từ (centerY - radius) đến (centerY +
radius).

Với mỗi dòng ngang, tính toán giới hạn bên trái và bên phải của dòng ngang trong
đường tròn.

Tính toán vị trí x trái (leftX) và x phải (rightX) trên dòng ngang bằng cách sử dụng
công thức hình học: leftX = centerX - sqrt(radius^2 - (y - centerY)^2) và rightX =
centerX + sqrt(radius^2 - (y - centerY)^2).

Duyệt qua mỗi điểm trên dòng ngang từ leftX đến rightX.

Với mỗi điểm, sử dụng glVertex2i để vẽ điểm đó với màu hiện tại (currentColor).

Thuật toán tô màu theo đường quét (scanline fill) có những ưu điểm và hạn chế
sau:

Ưu điểm:
Tính toán đơn giản: Thuật toán scanline fill không yêu cầu tính toán phức tạp và
không đòi hỏi nhiều tài nguyên tính toán. Việc tính toán giới hạn bên trái và bên
phải của mỗi dòng ngang dễ dàng thực hiện bằng cách sử dụng công thức hình học
đơn giản.

Hiệu suất tốt cho hình dạng phức tạp: Thuật toán scanline fill hoạt động tốt đối với
các hình dạng phức tạp, bao gồm cả các hình dạng có lỗ hổng bên trong. Bằng cách
duyệt qua từng dòng ngang và tính toán giới hạn bên trái và bên phải, thuật toán có
thể tô màu các hình dạng không liên thông và có nhiều lỗ hổng một cách chính
xác.

Tận dụng tính chất đối xứng: Thuật toán scanline fill có thể tận dụng tính chất đối
xứng của các hình dạng để giảm số lượng tính toán và cải thiện hiệu suất. Bằng
cách chỉ tính toán giới hạn bên trái và bên phải cho một nửa đường tròn và sau đó
áp dụng đối xứng, ta có thể tô màu cả đường tròn một cách hiệu quả.

Hạn chế:

Không hiệu quả với các hình dạng lớn: Thuật toán scanline fill không hiệu quả khi
áp dụng cho các hình dạng lớn, đặc biệt là khi bán kính của hình tròn lớn. Vì thuật
toán dựa trên việc duyệt qua từng dòng ngang và tính toán giới hạn bên trái và bên
phải, số lượng điểm cần tính toán và vẽ trở nên lớn, ảnh hưởng đến hiệu suất và tốn
tài nguyên.

Không phù hợp với các hình dạng không liên tục: Thuật toán scanline fill không
phù hợp cho việc tô màu các hình dạng không liên tục, chẳng hạn như các hình
dạng có lỗ hổng không liên thông. Vì thuật toán dựa trên việc tính toán giới hạn
bên trái và bên phải trên từng dòng ngang, nó không thể xác định được các vùng
không liên thông trong hình dạng và không thể tô màu chính xác.

Không hỗ trợ các hình dạng phức tạp khác: Thuật toán scanline fill cũng không hỗ
trợ tô màu các hình dạng phức tạp khác ngoài đường tròn, chẳng hạn như các hình
dạng đa giác, elip, hay các hình dạng không đều. Việc tính toán giới hạn bên trái và
bên phải cho các hình dạng này trở nên phức tạp hơn và yêu cầu các phép tính toán
phức tạp hơn.

Tóm lại, thuật toán tô màu theo đường quét có những ưu điểm trong tính toán đơn
giản, hiệu suất tốt với hình dạng phức tạp và khả năng tận dụng tính chất đốixứng,
nhưng cũng có nhược điểm khi không hiệu quả với các hình dạng lớn, không phù
hợp với các hình dạng không liên tục và không hỗ trợ các hình dạng phức tạp khác
ngoài đường tròn.