封闭图形填充

typedef struct EDGE
{
 int ymax;
 float x;
 float deltax;
 struct EDGE* nextEdge;
} EDGE;

float ymin = 0;
float ymax = 500;

EDGE* AEL = 0;
EDGE* ET = 0;

void InitET(float min, float max)
{
 int i = 0;
 int h = max-min+1;
 ymin = min;
 ymax = max;
 ET = (EDGE*)malloc(sizeof(EDGE)*h);
 for(i = 0;i<h;i++)
  ET[i].nextEdge = 0;
}

void InsertEdgeToET(int kind, EDGE *e)
{
 EDGE* et1;
 EDGE* et2;
 if((ET + kind)->nextEdge == 0)
 {
  (ET + kind)->nextEdge = e;
  return;
 }
 else
 {
  et1 = (ET+kind)->nextEdge;
  et2 = (ET+kind);
  while(et1)
  {
   if(et1->x > e->x)
   {
    et2->nextEdge = e;
    e->nextEdge = et1;
    return;
   }
   if(et1->x == e->x)
   {
    if(et1->deltax > e->deltax)
    {
     et2->nextEdge = e;
     e->nextEdge = et1;
     return;
    }
    else
    {
     et1 = et1->nextEdge;
     et2 = et2->nextEdge;
     et2->nextEdge = e;
     e->nextEdge = et1;
     return;
    }
   }
   et1 = et1->nextEdge;
   et2 = et2->nextEdge;
  }
  if(et1 == 0)
   et2->nextEdge = e;
 }
}

void DeleteET()
{
 int j,k;
 free(ET);
 ET = 0;
}

void SetEdit(int x1, int y1, int x2, int y2)
{
 int a;

 if(y1 < y2)
 {
  EDGE* e = (EDGE*)malloc(sizeof(EDGE));
  e->ymax = y2;
  e->x = x1;
  e->deltax = (float)(x1-x2)/(y1-y2);
  e->nextEdge = 0;
  a = y1 - ymin;
  InsertEdgeToET(a,e);
 }
 if(y1 > y2)
 {
  EDGE* e = (EDGE*)malloc(sizeof(EDGE));
  e->ymax = y1;
  e->x = x2;
  e->deltax = (float)(x1-x2)/(y1-y2);
  e->nextEdge = 0;
  a = y2 - ymin;
  InsertEdgeToET(a,e);
 }
}

void InsetEdgeToAEL(int y)
{
 EDGE* e;
 EDGE* et;
 EDGE* e1;
 EDGE* e2;
 e = et = (ET+y)->nextEdge;
 (ET+y)->nextEdge = 0;
 
 if(AEL == 0)
 {
  AEL = e;
  return;
 }
 while(e)
 {
  e1 = AEL;
  e2 = AEL->nextEdge;
  while(e2)
  {
   if(e1->x > et->x)
   {
    e = e->nextEdge;
    et->nextEdge = AEL;
    AEL = et;
    break;
   }
   if(e2->x > e->x)
   {
    e = e->nextEdge;
    e1->nextEdge = et;
    et->nextEdge = e2;
    break;
   }
   e1 = e1->nextEdge;
   e2 = e2->nextEdge;
  }
  if(e2 == 0)
  {
   e1->nextEdge = e;
   e = e->nextEdge;
   et->nextEdge = 0;
  }
  et = e;
 }
}

void Fill(Display *dpy,Drawable dra,GC *gc)
{
 AEL = 0;
 EDGE* ec;
 EDGE* ef;
 float x1,y1,x2,y2;
 int y,local;

 if((ET+0)->nextEdge != 0)
 {       
   InsetEdgeToAEL(0);
 }
 for(y = 0;y<=ymax-ymin;y++)
 {       

  ef = ec = AEL;
  local = 0;
  while(ec)
  {
   if(local%2 == 0)
   {
    x1 = ec->x;
    y1 = ymin+y;
   }
   else
   {
    x2 = ec->x;
    y2 = ymin+y;
    XDrawLine(dpy,dra,*gc,x1,y1,x2,y2);
   }
   ec->x += ec->deltax;//x = x+deltax
   
   if(ec->ymax == ymin+y)
   {         
    if(ec == AEL)
    {
     AEL = AEL->nextEdge;
     free(ec);
     ef = ec = AEL;
     local++;
     continue;
    }
    ef->nextEdge = ec->nextEdge;
    free(ec);
    ec = ef->nextEdge;
    local++;
    continue;
   }
   

   ef = ec;
   ec = ec->nextEdge;
   local++;
  }
  if((ET+y)->nextEdge != 0 && y != 0)
  {        
   InsetEdgeToAEL(y);
  }

 }
 
 for(y = 0;y<ymax-ymin+1;y++)
 {
  ET[y].nextEdge = 0;
 }
}