static PyObject *
GetAttr(PaxFontObject *self, char *name)
{
struct Fontattr *p;
PyObject *result;
if (name[0] == '_' && strcmp(name, "__members__") == 0)
return MemberList();
result = Py_FindMethod(FontMethods, (PyObject *)self, name);
if (result != NULL)
return result;
PyErr_Clear();
for (p = Fontattrdefs; ; p++)
{
if (p->name == NULL)
{
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
if (strcmp(name, p->name) == 0)
break;
}
if (p->type[0] == 'X')
{
PyErr_SetString(PyExc_AttributeError,
"non-int attr not yet supported");
return NULL;
}
return PyInt_FromLong(*(int *)((char *)(self->font_struct) + p->offset));
}
/***************************************************************************
* *
* FUNCTION: AppendList *
* *
* PURPOSE: Append a list to another one. *
* *
* PARAMS: The two lists to append. *
* *
* RETURN: The first list modified if successful. *
* NULL else. *
* *
* IMPORTS: None *
* *
* NOTES: This function modify the first of lists passed, appending *
* all the object of second list. It is assumed that the two *
* lists contain object of the same type. *
* All the objects in L2 are inserted (if not presents) in L1.*
* *
***************************************************************************/
List AppendList(List L1, List L2)
{
pointer object;
if(!L1 || !L2) ErrorNULL("AppendList, not initialized List.\n");
PushCurrList(L2);
TailList(L2);
while(NextList(&object, L2))
if(!MemberList(object, L1)) InsertList(object, L2);
PopCurrList(L2);
return L1;
}
List IntersectList(List L0, List L1)
{
List InterList;
pointer object;
if(!L0 || !L1) ErrorNULL("IntersectList, not initialized List.\n");
InterList=CopyList(L0);
TailList(InterList);
while(NextList(&object, InterList))
if(!MemberList(object, L1)) DeleteList(object, InterList);
return InterList;
}
List UnionList(List L0, List L1)
{
List UList;
pointer object;
if(!L0 || !L1) ErrorNULL("UnionList, not initialized List.\n");
UList=CopyList(L0);
TailList(L1);
while(NextList(&object, L1))
if(!MemberList(object, UList)) InsertList(object, UList);
return UList;
}
boolean DeleteList(pointer object, List l)
{
boolean result=FALSE;
ListElem *OldCurr=l->C;
ListElem *OldCurrNext=NULL;
if(l->C) OldCurrNext = l->C->next;
if(MemberList(object,l)) result=DeleteCurrList(l);
else result=FALSE;
if(OldCurrNext!=l->C) l->C=OldCurr;
return result;
}
void DeWall(Point3 *v[], Point3 *BaseV, int *UsedPoint, int n, List Q, List T, enum Axis a)
{
List Ln=NULL_LIST,
La=NULL_LIST,
Lp=NULL_LIST;
Tetra *t;
ShortTetra *st;
Face *f;
int i,j;
UG g;
Plane alpha;
alpha.N.x=0;
alpha.N.y=0;
alpha.N.z=0;
alpha.off=0;
if(n>20)
if(UGScaleFlag) BuildUG(v,UsedPoint,n, (int)(n*UGScale),&g); /* Initialize Uniform Grid */
else BuildUG(v,UsedPoint,n, n,&g);
Ln=NewList(FIFO,sizeof(Face)); /* Initialize Active Face */
ChangeEqualObjectList(EqualFace,Ln); /* List Ln. */
if(n>40) HashList(n/4,HashFace,Ln);
La=NewList(FIFO,sizeof(Face)); /* Initialize Active Face */
ChangeEqualObjectList(EqualFace,La); /* List La. */
if(n>40) HashList(n/4,HashFace,La);
Lp=NewList(FIFO,sizeof(Face)); /* Initialize Active Face */
ChangeEqualObjectList(EqualFace,Lp); /* List Lp. */
if(n>40) HashList(n/4,HashFace,Lp);
switch(a)
{
case XAxis : qsort((void *)v, (size_t)n, sizeof(Point3 *),
(int (*)(const void *,const void *))XComp);
alpha.N.x = 1;
alpha.off = (v[n/2-1]->x+v[n/2]->x)/2;
break;
case YAxis : qsort((void *)v, (size_t)n, sizeof(Point3 *),
(int (*)(const void *,const void *))YComp);
alpha.N.y = 1;
alpha.off = (v[n/2-1]->y+v[n/2]->y)/2;
break;
case ZAxis : qsort((void *)v, (size_t)n, sizeof(Point3 *),
(int (*)(const void *,const void *))ZComp);
alpha.N.z = 1;
alpha.off = (v[n/2-1]->z+v[n/2]->z)/2;
break;
}
if(CountList(Q)==0)
{
t=FirstTetra(v,n);
for(i=0;i<4;i++)
{
switch (Intersect(t->f[i],&alpha))
{
case 0 : InsertList(t->f[i], La); break;
case 1 : InsertList(t->f[i], Lp); break;
case -1 : InsertList(t->f[i], Ln); break;
}
for(j=0;j<3;j++)
if(t->f[i]->v[j]->mark==-1) t->f[i]->v[j]->mark=1;
else t->f[i]->v[j]->mark++;
}
st=Tetra2ShortTetra(t,BaseV);
free(t);
InsertList(st,T);
SI.Face+=4;
}
else
{
while(ExtractList(&f,Q))
switch (Intersect(f,&alpha))
{
case 0 : InsertList(f, La); break;
case 1 : InsertList(f, Lp); break;
case -1 : InsertList(f, Ln); break;
}
}
while(ExtractList(&f,La))
{
if(n>20) t=FastMakeTetra(f,v,n,&g);
else t=MakeTetra(f,v,n);
if(t==NULL) SI.CHFace++;
else
{
st=Tetra2ShortTetra(t,BaseV);
if(SafeTetraFlag) if(MemberList(st, T))
Error("Cyclic Tetrahedra Creation\n",EXIT);
InsertList(st,T);
SI.Face+=3;
SI.Tetra++;
if(UpdateFlag)
if(SI.Tetra%50 == 0) printf("Tetrahedra Built %i\r",SI.Tetra++);
for(i=1;i<4;i++)
switch (Intersect(t->f[i],&alpha))
{
case 0 : if(MemberList(t->f[i],La))
{
DeleteCurrList(La);
SI.Face--;
for(j=0;j<3;j++)
t->f[i]->v[j]->mark--;
free(t->f[i]);
}
else
{
InsertList(t->f[i],La);
for(j=0;j<3;j++)
if(t->f[i]->v[j]->mark==-1) t->f[i]->v[j]->mark=1;
else t->f[i]->v[j]->mark++;
}
break;
case 1 : if(MemberList(t->f[i],Lp))
{
DeleteCurrList(Lp);
SI.Face--;
for(j=0;j<3;j++)
t->f[i]->v[j]->mark--;
free(t->f[i]);
}
else
{
InsertList(t->f[i],Lp);
for(j=0;j<3;j++)
if(t->f[i]->v[j]->mark==-1) t->f[i]->v[j]->mark=1;
else t->f[i]->v[j]->mark++;
}
break;
case -1: if(MemberList(t->f[i],Ln))
{
DeleteCurrList(Ln);
SI.Face--;
for(j=0;j<3;j++)
t->f[i]->v[j]->mark--;
free(t->f[i]);
}
else
{
InsertList(t->f[i],Ln);
for(j=0;j<3;j++)
if(t->f[i]->v[j]->mark==-1) t->f[i]->v[j]->mark=1;
else t->f[i]->v[j]->mark++;
}
break;
}
free(t->f[0]);
free(t);
}
free(f);
}
if(SI.WallSize==0) SI.WallSize=SI.Tetra;
/* if(n>20) EraseUG(&g); */
switch(a)
{
case XAxis : if(CountList(Ln)>0) DeWall(v, BaseV,UsedPoint,n/2, Ln,T,YAxis);
if(CountList(Lp)>0) DeWall(&(v[n/2]),BaseV,UsedPoint,n-(n/2),Lp,T,YAxis);
break;
case YAxis : if(CountList(Ln)>0) DeWall(v, BaseV,UsedPoint,n/2, Ln,T,ZAxis);
if(CountList(Lp)>0) DeWall(&(v[n/2]),BaseV,UsedPoint,n-(n/2),Lp,T,ZAxis);
break;
case ZAxis : if(CountList(Ln)>0) DeWall(v, BaseV,UsedPoint,n/2, Ln,T,XAxis);
if(CountList(Lp)>0) DeWall(&(v[n/2]),BaseV,UsedPoint,n-(n/2),Lp,T,XAxis);
break;
}
EraseList(Ln);
EraseList(La);
EraseList(Lp);
}
