我正在用用户界面代码帮助某人可视化数学图像分析。在这个过程中，我们将把2D形状的一部分分割成三角形，并在UI上填充其中一些三角形。
我们正在寻找一种填充算法，它可以确保如果两个三角形共享一条边(特别是，如果三角形的任何两个顶点相同(，那么无论绘制顺序和锯齿如何，在这两个三角形之间的线上都不会有空白的未提取像素。(如果一些像素画两次也没关系。(在任意缩放的情况下，结果应该看起来不错。有些三角形在某些地方可能是非常薄的薄片，宽度低至1像素。
理想情况下，它也应该是一个合理有效的填充算法！
在三角形渲染中不会使用抗锯齿，因为最终图像的深度需要为1位。
上下文是一个图像识别应用程序，因此所有顶点坐标都将精确到一个像素。
考虑到需求，似乎有一个简单的解决方案。
首先，光栅化三角形边。您可以使用Bresenham的线条绘制算法(如下面的代码所示(或任何有效的方法。然后填充中间的区域。这将适用于任意薄的三角形。
要确保不存在间隙，无论三角形的绘制顺序如何，也无论提供给三角形绘图代码的顶点的顺序如何，都需要以与共享边的三角形相同的方式光栅化共享边相同的方式意味着每次都有相同的像素。
为了保证每次从相同的顶点坐标对中获得相同的像素，你基本上都想建立一个固定的顺序，也就是说，建立一个规则，无论给定的顺序如何，总是从给定的两个顶点中选择相同的一个顶点。
执行此顺序的一个简单方法是将线(三角形边(视为二维向量，如果它指向负y的方向，或者平行于x轴并指向负x的方向，则翻转其方向。是时候欣赏一些ASCII艺术了！：(
3 2 1
| /
| /
|/
4 --------+--------- 0
/|
/ |
/ |
5 6 7
4 -> 0
5 -> 1
6 -> 2
7 -> 3
看，这里的线段，比如说，1和线段5实际上是同一种东西，唯一的区别是从原点的端点到另一个端点的方向。因此，我们通过将段4到7转换为段0到3来将这些情况减半，并消除方向模糊。IOW，我们选择沿着增加y的方向，或者，如果y在边上是相同的，沿着增加x的方向。
以下是如何在代码中做到这一点：
#include <stddef.h>
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#define SCREEN_HEIGHT 22
#define SCREEN_WIDTH 78
// Simulated frame buffer
char Screen[SCREEN_HEIGHT][SCREEN_WIDTH];
void SetPixel(long x, long y, char color)
{
if ((x < 0) || (x >= SCREEN_WIDTH) ||
(y < 0) || (y >= SCREEN_HEIGHT))
{
return;
}
if (Screen[y][x] == ' ')
Screen[y][x] = color;
else
Screen[y][x] = '*';
}
void Visualize(void)
{
long x, y;
for (y = 0; y < SCREEN_HEIGHT; y++)
{
for (x = 0; x < SCREEN_WIDTH; x++)
{
printf("%c", Screen[y][x]);
}
printf("n");
}
}
typedef struct
{
long x, y;
unsigned char color;
} Point2D;
// min X and max X for every horizontal line within the triangle
long ContourX[SCREEN_HEIGHT][2];
#define ABS(x) ((x >= 0) ? x : -x)
// Scans a side of a triangle setting min X and max X in ContourX[][]
// (using the Bresenham's line drawing algorithm).
void ScanLine(long x1, long y1, long x2, long y2)
{
long sx, sy, dx1, dy1, dx2, dy2, x, y, m, n, k, cnt;
sx = x2 - x1;
sy = y2 - y1;
/*
3 2 1
| /
| /
|/
4 --------+--------- 0
/|
/ |
/ |
5 6 7
4 -> 0
5 -> 1
6 -> 2
7 -> 3
*/
if (sy < 0 || sy == 0 && sx < 0)
{
k = x1; x1 = x2; x2 = k;
k = y1; y1 = y2; y2 = k;
sx = -sx;
sy = -sy;
}
if (sx > 0) dx1 = 1;
else if (sx < 0) dx1 = -1;
else dx1 = 0;
if (sy > 0) dy1 = 1;
else if (sy < 0) dy1 = -1;
else dy1 = 0;
m = ABS(sx);
n = ABS(sy);
dx2 = dx1;
dy2 = 0;
if (m < n)
{
m = ABS(sy);
n = ABS(sx);
dx2 = 0;
dy2 = dy1;
}
x = x1; y = y1;
cnt = m + 1;
k = n / 2;
while (cnt--)
{
if ((y >= 0) && (y < SCREEN_HEIGHT))
{
if (x < ContourX[y][0]) ContourX[y][0] = x;
if (x > ContourX[y][1]) ContourX[y][1] = x;
}
k += n;
if (k < m)
{
x += dx2;
y += dy2;
}
else
{
k -= m;
x += dx1;
y += dy1;
}
}
}
void DrawTriangle(Point2D p0, Point2D p1, Point2D p2)
{
long y;
for (y = 0; y < SCREEN_HEIGHT; y++)
{
ContourX[y][0] = LONG_MAX; // min X
ContourX[y][1] = LONG_MIN; // max X
}
ScanLine(p0.x, p0.y, p1.x, p1.y);
ScanLine(p1.x, p1.y, p2.x, p2.y);
ScanLine(p2.x, p2.y, p0.x, p0.y);
for (y = 0; y < SCREEN_HEIGHT; y++)
{
if (ContourX[y][1] >= ContourX[y][0])
{
long x = ContourX[y][0];
long len = 1 + ContourX[y][1] - ContourX[y][0];
// Can draw a horizontal line instead of individual pixels here
while (len--)
{
SetPixel(x++, y, p0.color);
}
}
}
}
int main(void)
{
Point2D p0, p1, p2, p3;
// clear the screen
memset(Screen, ' ', sizeof(Screen));
// generate random triangle coordinates
srand((unsigned)time(NULL));
// p0 - p1 is going to be the shared edge,
// make sure the triangles don't intersect
for (;;)
{
p0.x = rand() % SCREEN_WIDTH;
p0.y = rand() % SCREEN_HEIGHT;
p1.x = rand() % SCREEN_WIDTH;
p1.y = rand() % SCREEN_HEIGHT;
p2.x = rand() % SCREEN_WIDTH;
p2.y = rand() % SCREEN_HEIGHT;
p3.x = rand() % SCREEN_WIDTH;
p3.y = rand() % SCREEN_HEIGHT;
{
long vsx = p0.x - p1.x;
long vsy = p0.y - p1.y;
long v1x = p0.x - p2.x;
long v1y = p0.y - p2.y;
long v2x = p0.x - p3.x;
long v2y = p0.y - p3.y;
long z1 = vsx * v1y - v1x * vsy;
long z2 = vsx * v2y - v2x * vsy;
// break if p2 and p3 are on the opposite sides of p0-p1
if (z1 * z2 < 0) break;
}
}
printf("%ld:%ld %ld:%ld %ld:%ld %ld:%ldnn",
p0.x, p0.y,
p1.x, p1.y,
p2.x, p2.y,
p3.x, p3.y);
// draw the triangles
p0.color = '-';
DrawTriangle(p0, p3, p1);
p1.color = '+';
DrawTriangle(p1, p2, p0);
Visualize();
return 0;
}
样本输出：
30:10 5:16 16:6 59:17
+++
++++++++
++++++++++++
+++++++++++++++++
+++++++++++++++****---
+++++++++++++****-----------
++++++++++****-------------------
++++++*****----------------------------
+++****-------------------------------------
****---------------------------------------------
*-----------------------------------------------------
-
图例：
- 三角形1的"+"-像素
- "-"-三角形2的像素
- "*"-三角形1和2之间共享的边的像素
请注意，即使没有未填充的间隙(像素(，其像素(在共享边上(被覆盖的三角形(因为在其顶部绘制了另一个三角形(如果太薄，可能会显示为不相交或形状笨拙。示例：
2:20 12:8 59:15 4:17
*++++++
*+++++++++++++
*+++++++++++++++++++++
-*++++++++++++++++++++++++++++
-*++++++++++++++++++++++++++++++++++++
*+++++++++++++++++++++++++++++++++++++++++++
*+++++++++++++++++++++++++++++++++++++++++++++++++++
*+++++++++++++++++++++++++++++++++++++++++++++++++++++
*+++++++++++++++++++++++++++++++++++++++++++
-*+++++++++++++++++++++++++++++++
-*+++++++++++++++++++++
*++++++++++
*
我意识到不鼓励只使用链接的答案，但我已经在博客上写过这个确切的问题。Fabian Giesen还将其作为其优秀系列的一部分进行了讨论，优化软件遮挡剔除。
其要点是，您应该选择填充规则，该规则确定如何打破两个面之间共享像素的平局。为微软的Direct3D API指定并充分记录了一个这样的填充规则。它可以使用类似于Bresenham的直线算法的算法来实现，但必须格外注意舍入和边缘的情况。
即使这里接受的答案也不能以一致的方式处理负x斜率，尽管由于您的输出只有1位，并且不需要插入任何属性，所以这可能无关紧要。
您对相邻三角形的关注是有效的。如果两个三角形共享一条边，则需要确保沿该边的每个像素都"只属于"一个三角形或另一个三角形。如果这些像素中的一个不属于任何一个三角形，则存在间隙。如果它属于两个三角形，则存在过度绘制(效率低下(，并且颜色可能取决于三角形的渲染顺序(可能不具有确定性(。
由于您没有使用抗锯齿，所以这实际上并不太难。与其说它是一个聪明的算法，不如说它需要一个谨慎的实现。
光栅化三角形的典型方法是从上到下计算作为三角形一部分的水平线段。要做到这一点，可以跟踪当前的左边缘和右边缘，并基本上为每条扫描线的每条边缘进行x截距计算。它也可以通过两个Bresenheim风格的线条绘制算法一起运行来完成。实际上，光栅化相当于对函数的多次调用，该函数在某条扫描线y处从某个左坐标x0到某个右坐标x1绘制水平线段。
void DrawHLine(int y, int x0, int x1);
通常，要做的是确保光栅化器以一致的方式舍入x截距，以便无论x坐标是一个三角形的右边缘还是相邻三角形的左边缘的一部分，都能一致地计算x坐标。这保证了沿共享边的每个像素都属于两个三角形。
我们通过调整DrawHLine来解决双重所有权，使其填充从包含x0到不包含x1的像素。因此，共享边上的所有双拥有像素都被定义为属于共享边右侧的三角形。
它不是最有效的，但你可以在包含三角形的正方形上循环，并测试每个像素是否在三角形内。
伪码：
for(x : minX -> maxX)
for(y : minY -> maxY)
if(triangle.contains(x,y))
drawPixel(x,y);
其中minX是三个顶点之间的最小X坐标，对于maxX、minY和maxY也是如此。
对于更快的算法，你可以先进行一些快速而肮脏的填充(例如slashmais flood填充(，然后对边缘周围的像素进行填充。
这里介绍三角点测试。
这是一个研究得很好的问题。了解bresenham线条绘制算法。
http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
我的答案满足假设。阿德里安·麦卡锡在回答中所说的是真的。我的算法是基于类似的想法，它是有效的。即使在我看来，不考虑像素的覆盖也是不公平的。然而，我不表示N-1像素的水平线，否则三角形，如果它是一个"碎片"，就不会被表示。
例如：假设我们有两个相邻的三角形：
ABC [A (27.15) -B (32.15) -C (37.15)];
DEF [A (29.15) -B (32.15) -C (35.15)];
表示会重叠，但结果应该是类型的水平段
++-------------------------++
因此，仅仅排除最后一个像素以避免覆盖是不够的。
为了表示填充的三角形，以便您可以使用创建的函数来表示填充的多边形(例如：四边形(，因为它们总是可以划分为三角形，所以必须能够排除边的表示，否则，三角形的一侧会被相邻三角形的一侧覆盖(显示透明多边形的问题(。这是我的算法的C实现，用于表示任何类型的三角形。我建议你试试，因为它很快，虽然很复杂，而且效率很高。它是我的CCD_ 8算法的变体。表示水平段的例程的实现，我将其重新绑定给您(对于水平段的表示，我已经用Line ()指令替换了对Put(Shadow(HorizLine ()的调用，因为我对DrawHLine()的实现不能插入本文中；然而这里我使用Line()指令仅用于绘制水平段(。
这个函数最初是为使用RAM中的缓冲区而提供的，我自己的格式称为OBP，它与RASTER格式的区别只有两个原因：扫描线与16字节对齐。在数据之前有一个16字节的标题(每个像素为8位(；此标头包含前2个字中图像的大小(在汇编实现中，您可以选择是否充分利用CPU寄存器，而不是RAM中的变量，因为32位寄存器可以包含两个维度，并且在图像的中等规模上，点的几何位置也可以包含在32位寄存器中(。这里唯一需要做的就是重写对Line()函数的调用，因为要指定三角形一侧的颜色(可能与其他一侧不同，透明或不存在(，有必要修改对象的属性，而不是将颜色直接作为参数传递给line()函数，尽管曾经可以调用SetColor()函数，这在这里只是指示性的。
她是头(triangle.h(：
#define R_OBP_Al 16 /* 16 Byte alignment; it must always be 2^N */
#define DimOBP_H 16 /* 16 Byte of OBP HEADER; it must always be >=4 */
#define True 1 /* Boolean value for true condition */
#define False 0 /* Boolean value for false condition */
typedef char TShadowTable[256]; /* Array for shadows */
typedef TShadowTable *T_Shadow_Table_Ptr; /* Pointer to an array for shadows */
typedef struct {short int X;
short int Y;} T_Coord_XY;
typedef struct {unsigned short int X;
unsigned short int Y;} T_Pos_Coord_XY;
typedef struct {unsigned short int DimX;
unsigned short int DimY;} T_Dim_XY;
typedef struct {T_Pos_Coord_XY XY; /* Coordinates of the clipping-region */
T_Dim_XY Dim_XY; /* Dimensions of the clipping-region */ } T_Clipp_Rect;
typedef T_Clipp_Rect *T_Clipp_Rect_Ptr; /* Pointer to clipping-region's type */
typedef struct {T_Coord_XY XY; /* Coordinates of the rectangle */
T_Dim_XY Dim_XY; /* Dimensions of the rectangle */ } T_Rect;
typedef T_Rect *T_Rect_Ptr; /* Pointer to a rectangle */
typedef char Boolean; /* Boolean type */
void Triangle_Wind(short int X1,
short int Y1,
short int X2,
short int Y2,
short int X3,
short int Y3,
short int FillColor,
short int BrdColAB,
short int BrdColBC,
short int BrdColCA
/* , T_Shadow_Table_Ptr ShadowTable,
void *OBPVBuff
T_Clipp_Rect_Ptr Clipp */);
以下是函数和示例(triangle.c(：
#include <graphics.h>
#include <conio.h>
#include <string.h>
#include <stdio.h>
#include "triangle.h"
static int *DefColors[16]=
{0FF000000H, /* Black */
0FF7F0000H, /* Blue */
0FF007F00H, /* Green */
0FF7F7F00H, /* Cyan */
0FF00007FH, /* Red */
0FF7F007FH, /* Magenta */
0FF007F7FH, /* Brown */
0FF7F7F7FH, /* LightGray */
0FF3F3F3FH, /* DarkGray */
0FFFF0000H, /* LightBlue */
0FF00FF00H, /* LightGreen */
0FFFFFF00H, /* LightCyan */
0FF0000FFH, /* LightRed */
0FFFF00FFH, /* LightMagenta */
0FF00FFFFH, /* Yellow */
0FFFFFFFFH /* White */ };
int main(void)
{
/* int gd = DETECT;
int gm;
initgraph(&gd, &gm, "C:\TC\BGI"); */
Triangle_Wind(80,80,320,200,160,300,
4,1,2,7);
getch();
/* closegraph(); */
return 0;
}
/* Here it is the body of the triangle routine: */
void Triangle_Wind(short int X1,
short int Y1,
short int X2,
short int Y2,
short int X3,
short int Y3,
short int FillColor,
short int BrdColAB,
short int BrdColBC,
short int BrdColCA
/* , T_Shadow_Table_Ptr ShadowTable,
void *OBPVBuff
T_Clipp_Rect_Ptr Clipp */)
{short int A=0;
short int B=1;
short int C=2; /* Identificat. vertici triangoli per ordinam. colori */
short int C1=BrdColAB;
short int C2=BrdColBC;
short int C3=BrdColCA; /* Var. temp. per i colori */
short int XT; /* X1-XT è il segmento orizzontale da disegnare */
short int OY2; /* Valore iniziale coord. Y 2° vertice del triangolo */
short int B1L;
short int B1H; /* Coord. X 1° e ultimo punto 1° bordo (segm. orizz.) */
short int B2L;
short int B2H; /* Coord. X 1° e ultimo punto 2° bordo (segm. orizz.) */
short int D0; /* Dimensione 1° bordo (segm. orizz.) */
short int D1; /* Dimensione parte centrale segm. orizz. */
short int D2; /* Dimensione 2° bordo (segm. orizz.) */
short int Tmp; /* Variabile temporanea x scambio di 2 variabili */
short int Col1; /* Colore 1° bordo segm. orizz. */
short int Col2; /* Colore 2° bordo segm. orizz. */
short int CntX1; /* Contat. per coord. X 1° punto segm. orizz. (Bresenham) */
short int IncX1; /* Increm. contat. per coord. X 1° punto segm. or. (Bresenham) */
short int CntY1; /* Contat. per coord. Y 1° punto segm. orizz. (Bresenham) */
short int Lim1; /* Limite per contat. coord. X e Y 1° punto segm. or. (Bresenham) */
short int DirX1; /* Increm. coord. X 1° punto segm. orizz. */
short int IncY1; /* Increm. contat. per coord. Y 1° punto segm. or. (Bresenham) */
short int FX1; /* Valore iniziale coord. X1 segm. orizz. X1-XT */
short int CntXT; /* Contat. per coord. X 2° punto segm. orizz. (Bresenham) */
short int IncXT; /* Increm. contat. per coord. X 2° punto segm. or. (Bresenham) */
short int CntYT; /* Contat. per coord. Y 2° punto segm. orizz. (Bresenham) */
short int LimT; /* Limite per contat. coord. X e Y 2° punto segm. or. (Bresenham) */
short int DirXT; /* Increm. coord. X 2° punto segm. orizz. */
short int IncYT; /* Increm. contat. per coord. Y 2° punto segm. or. (Bresenham) */
short int FXT; /* Valore iniziale coord. XT segm. orizz. X1-XT */
T_Rect Segm; /* Record per la rappresentazione di un segm. orizz. */
Boolean F1; /* 1° cond. iniz. (eccezione), rappresentaz. triang. */
Boolean F24; /* 2° cond. iniz. (eccezione), rappresentaz. triang. */
Boolean Overflow=False; /* FALSE: Calcola segm. orizz.; TRUE: Ha finito */
Boolean Internal; /* Variabile temp.; salva il val. iniz. di Overflow */
Boolean Finished=True; /* FALSE: 2° semi-triang.; TRUE: 1° semi-triang.} */
/* Ordina i vertici in base alla coordinata Y */
if (Y1>Y2)
{Tmp=X1;
X1=X2;
X2=Tmp;
Tmp=Y1;
Y1=Y2;
Y2=Tmp;
Tmp=A;
A=B;
B=Tmp;}
if (Y2>Y3)
{Tmp=X2;
X2=X3;
X3=Tmp;
Tmp=Y2;
Y2=Y3;
Y3=Tmp;
Tmp=B;
B=C;
C=Tmp;}
if (Y1>Y2)
{Tmp=X1;
X1=X2;
X2=Tmp;
Tmp=Y1;
Y1=Y2;
Y2=Tmp;
Tmp=A;
A=B;
B=Tmp;}
/* Calcola il colore effettivo dei lati A-B, B-C e C-A del triangolo */
switch (27*A+9*B+C)
{case 19:{BrdColAB=C3;
BrdColCA=C1;
break;}
case 29:{BrdColBC=C3;
BrdColCA=C2;
break;}
case 45:{BrdColAB=C2;
BrdColBC=C3;
BrdColCA=C1;
break;}
case 55:{BrdColAB=C3;
BrdColBC=C1;
BrdColCA=C2;
break;}
case 63:{BrdColAB=C2;
BrdColBC=C1;
break;
}}
/* Calc. incr. e limiti, inizial. i cont. lato A-C (Bresenham) */
DirXT=-1;
IncXT=X1-X3;
if (X1<X3)
{DirXT=1;
IncXT=-IncXT;}
IncXT+=1;
CntXT=IncXT>>1;
IncYT=Y3-Y1+1;
CntYT=IncYT>>1;
LimT=IncXT;
if (IncXT<IncYT)
LimT=IncYT;
/* Imposta i valori iniziali delle var. locali */
XT=X1;
OY2=Y2;
F1=(Y1>=Y2) || (Y2!=Y3);
F24=((Y1!=Y2) || (Y2>=Y3)) &&
((Y1>=Y2) || (Y2>=Y3));
/* Disegna il primo vertice del triangolo */
if ((X1=X2) && (X2=X3) &&
(Y1=Y2) && (Y2=Y3))
{/* Segm->XY->X=X1;
Segm->XY->Y=Y1;
Segm->Dim_XY->DimX=1; */
Col1=BrdColAB;
if (Col1<0)
Col1=BrdColCA;
if (Col1<0)
Col1=FillColor;
if (Col1>=0)
{setcolor(DefColors[Col1]);
line(X1,Y1,X1,Y1);}
/* if (Col1<256)
PutHorizLine(&Segm,OBPVBuff,Col1,Clipp)
else
PutShadowHorizLine(&Segm,OBPVBuff,ShadowTable,Clipp); */}
/* Disegna il triangolo */
do
{/* Calc. incr. e limiti, inizial. i cont. lato A-B (Bresenham) */
DirX1=-1;
IncX1=X1-X2;
if (X1<X2)
{DirX1=1;
IncX1=-IncX1;}
IncX1+=1;
CntX1=IncX1>>1;
IncY1=Y2-Y1+1;
CntY1=IncY1>>1;
Lim1=IncX1;
if (IncX1<IncY1)
Lim1=IncY1;
FX1=X1;
FXT=XT;
/* Rappresenta un semi-triangolo */
while ((X1!=X2) || (Y1!=Y2))
{
/* Calcola i 4 estremi del segmento orizzontale da disegnare */
do
{Internal=Overflow;
if (Overflow)
{CntY1-=Lim1;
CntYT-=LimT;
Y1+=1;}
Overflow=True;
Tmp=CntY1+IncY1;
if (Tmp<Lim1)
{CntY1=Tmp;
CntX1+=IncX1;
if (CntX1>=Lim1)
{CntX1-=Lim1;
X1+=DirX1;}
Overflow=False;}
Tmp=CntYT+IncYT;
if (Tmp<LimT)
{CntYT=Tmp;
CntXT+=IncXT;
if (CntXT>=LimT)
{CntXT-=LimT;
XT+=DirXT;}
Overflow=False;}
if (Internal)
{FX1=X1;
FXT=XT;}
} while (!Overflow);
/* Ordina (ord. ascend.) i 4 estremi del segmento orizzontale */
B1L=FX1;
B1H=X1;
if (B1L>B1H)
{Tmp=B1L;
B1L=B1H;
B1H=Tmp;}
B2L=FXT;
B2H=XT;
if (B2L>B2H)
{Tmp=B2L;
B2L=B2H;
B2H=Tmp;}
Col1=BrdColAB;
Col2=BrdColCA;
if ((B2L<B1L) || (B2H<B1H))
{Tmp=B1L;
B1L=B2L;
B2L=Tmp;
Tmp=B1H;
B1H=B2H;
B2H=Tmp;
Tmp=Col1;
Col1=Col2;
Col2=Tmp;}
/* Calcola la posizione e la dimensione dei 2 bordi del segm. orizz. */
D1=B1H-B1L+1;
D0=B2L-B1H-1;
D2=B2H-B2L+1;
/* Ove possibile, unisce bordi con parte centrale del segm. orizz. */
if (D0>0)
{if (FillColor==Col2) /* Parte0 unita a parte2, parte0 esistente */
{D0+=D2;
D2=0;}
if (Col1==FillColor) /* Parte0 unita a parte1, parte0 esistente */
{B1H=B1L-1;
D0+=D1;
D1=0;}}
else
{D0=0;
if (Col1==Col2) /* Parte1 unita a parte2, parte0 inesistente */
{D1=B2H-B1L+1;
D2=0;}}
/* Rappresenta il primo bordo del segm. orizz. */
/* Segm->XY->Y=Y1;
Segm->XY->X=B1L;
Segm->Dim_XY->DimX=D1; */
if ((Col1>=0) && (D1>0))
{setcolor(DefColors[Col1]);
line(B1L,Y1,B1L+D1-1,Y1);}
/* if (Col1<256)
PutHorizLine(&Segm,OBPVBuff,Col1,Clipp)
else
PutShadowHorizLine(&Segm,OBPVBuff,ShadowTable,Clipp); */
/* Rappresenta la parte centrale del segm. orizz. */
if (((Y1!=OY2) ||
(!Finished || F1) && (Finished || F24)) && (D0>0))
{
/* Segm->XY->X=B1H+1;
Segm->Dim_XY->DimX=D0; */
if ((FillColor>=0) && (D0!=0))
{setcolor(DefColors[FillColor]);
line(B1H+1,Y1,B1H+D0,Y1);}
/* if (FillColor<256)
PutHorizLine(&Segm,OBPVBuff,FillColor,Clipp)
else
PutShadowHorizLine(&Segm,OBPVBuff,ShadowTable,Clipp); */
}
/* Rappresenta il secondo bordo del segm. orizz. */
/* Segm->XY->X=B2L;
Segm->Dim_XY->DimX=D2; */
if ((Col2>=0) && (D2>0))
{setcolor(DefColors[Col2]);
line(B2L,Y1,B2L+D2-1,Y1);}
/* if (Col2<256)
PutHorizLine(&Segm,OBPVBuff,Col2,Clipp)
else
PutShadowHorizLine(&Segm,OBPVBuff,ShadowTable,Clipp); */
}
X2=X3;
Y2=Y3;
BrdColAB=BrdColBC;
Finished=!Finished;
} while (!Finished);
}
您正在寻找的是floodfill算法。
这是一个。
另一个链接。
你可以在谷歌上搜索"floodfill算法"了解更多信息。
[编辑]
也许这个网站[基于着色器的线框绘制]可以提供更多的想法。