三角形三个顶点的颜色分别为红绿蓝，使用有效边表算法填充三角形

有效边表算法（ETB）是一种扫描线填充算法。以下是使用有效边表算法填充三角形的步骤：

1. 确定三角形的三个顶点的坐标，以及每个顶点的颜色。

2. 对三个顶点按照 y 坐标从小到大进行排序。

3. 针对每个边，计算出斜率倒数 m 和 y 轴截距 b。

4. 对于每一行扫描线，从有效边表中删除所有 yMax = y 的边，将 yMin = y 的边插入有效边表。

5. 对于每个被插入的边，按照 x 坐标从小到大进行排序。

6. 对于每个相邻的边对 (A, B)，使用 Bresenham 算法在两条边之间绘制水平线段，并填充指定颜色。

7. 重复步骤 4-6，直到扫描线扫描到三角形的最低点。

以下是一个实现该算法的示例代码（使用 Python 语言）：

class Vertex:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.color = color

class Edge:
    def __init__(self, vertex1, vertex2):
        if vertex1.y < vertex2.y:
            self.yMin = vertex1.y
            self.yMax = vertex2.y
            self.x = vertex1.x
            self.color = vertex1.color
        else:
            self.yMin = vertex2.y
            self.yMax = vertex1.y
            self.x = vertex2.x
            self.color = vertex2.color
        self.m = (vertex2.x - vertex1.x) / (vertex2.y - vertex1.y)
        self.b = vertex1.x - self.m * vertex1.y

def fillTriangle(vertices):
    # Step 1: Sort vertices by y coordinate
    vertices.sort(key=lambda v: v.y)

    # Step 2: Initialize edge table and active edge table
    edgeTable = [[] for i in range(len(vertices))]
    activeEdgeTable = []

    # Step 3: Fill edge table
    for i in range(len(vertices)):
        j = (i + 1) % len(vertices)
        edge = Edge(vertices[i], vertices[j])
        edgeTable[edge.yMin].append(edge)

    # Step 4: Scanline fill
    for y in range(vertices[0].y, vertices[2].y + 1):
        # Remove edges from active edge table
        activeEdgeTable = [edge for edge in activeEdgeTable if edge.yMax != y]

        # Add edges to active edge table
        activeEdgeTable += edgeTable[y]

        # Sort active edge table by x coordinate
        activeEdgeTable.sort(key=lambda edge: edge.x)

        # Fill between edges in active edge table
        for i in range(0, len(activeEdgeTable), 2):
            edge1 = activeEdgeTable[i]
            edge2 = activeEdgeTable[i + 1]
            for x in range(int(edge1.x), int(edge2.x) + 1):
                color = interpolateColor(edge1.color, edge2.color, (x - edge1.x) / (edge2.x - edge1.x))
                drawPixel(x, y, color)

        # Update x coordinate of edges in active edge table
        for edge in activeEdgeTable:
            edge.x += edge.m

def interpolateColor(color1, color2, t):
    r = int(color1[0] + t * (color2[0] - color1[0]))
    g = int(color1[1] + t * (color2[1] - color1[1]))
    b = int(color1[2] + t * (color2[2] - color1[2]))
    return (r, g, b)

def drawPixel(x, y, color):
    # Placeholder function to draw pixel with color
    pass

# Example usage
vertices = [
    Vertex(100, 50, (255, 0, 0)), # Red vertex
    Vertex(150, 200, (0, 255, 0)), # Green vertex
    Vertex(50, 150, (0, 0, 255)) # Blue vertex
]
fillTriangle(vertices)