Return to pfill2.c CVS log

Up to [Research Unix] / researchv10dc / vol2 / Faces / How / src

Annotation of researchv10dc/vol2/Faces/How/src/pfill2.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: 
                      3: #define SZ     512
                      4: 
                      5: typedef struct Node {
                      6:        int x, y;
                      7:        struct Node *nxt;       /* contour */
                      8:        int soc;                /* node is start of new curve */
                      9: } Node;
                     10: 
                     11: Node *frst = (Node *) 0;
                     12: int lcnt=0;
                     13: extern int Factor;
                     14: 
                     15: zaplist()
                     16: {      Node *ptr = frst;
                     17:        Node *save;
                     18: 
                     19:        while (ptr)
                     20:        {       save = ptr->nxt;
                     21:                free(ptr);
                     22:                ptr = save;
                     23:        }
                     24:        frst = (Node *) 0;
                     25: }
                     26: 
                     27: addnode(n, m, p)
                     28: {      Node *tmp, *hunt, *last;
                     29: 
                     30:        tmp = (Node *) malloc(sizeof(Node));
                     31:        if (!tmp)
                     32:                return;
                     33: 
                     34:        tmp->nxt = (Node *) 0;
                     35:        tmp->x = n;
                     36:        tmp->y = m;
                     37:        tmp->soc = p;
                     38:        if (!frst)
                     39:                frst = tmp;
                     40:        else
                     41:        {       last = frst; hunt = last->nxt;
                     42:                while (hunt)
                     43:                {       last = hunt;
                     44:                        hunt = last->nxt;
                     45:                }
                     46:                last->nxt = tmp;
                     47:        }
                     48: }
                     49: 
                     50: compar(a, b)
                     51:        int *a, *b;
                     52: {
                     53:        return (*a>*b)?1:(*a<*b)?-1:0;
                     54: }
                     55: 
                     56: runcontour()
                     57: {      Node *hunt;
                     58:        int miny, maxy;
                     59:        int *xx;
                     60:        int x, y, cnt, total, partial;
                     61: 
                     62:        if (!frst)
                     63:                return;
                     64: 
                     65:        hunt = frst;
                     66:        miny = hunt->y; maxy = hunt->y;
                     67:        cnt = 0;
                     68:        while (hunt)
                     69:        {       if (hunt->y < miny) miny = hunt->y;
                     70:                if (hunt->y > maxy) maxy = hunt->y;
                     71:                hunt = hunt->nxt;
                     72:                cnt++;
                     73:        }
                     74:        xx = (int *) malloc(cnt * sizeof(int)); /* max # intersections */
                     75:        if (!xx)
                     76:        {       fprintf (stderr, "out of memory\n");
                     77:                return;
                     78:        }
                     79:        for (y = miny; y < maxy; y++)
                     80:        {       if ((cnt = intersect(xx, y)) <= 1)
                     81:                        continue;
                     82:                qsort(xx, cnt, sizeof(int), compar);
                     83:                for (x = total = 0; x < cnt-1; x += 2)
                     84:                        total += xx[x+1] - xx[x];
                     85:                for (x = partial = 0; x < cnt-1; x += 2)
                     86:                {       doline(xx[x], xx[x+1]+1, SZ-y, partial, total);
                     87:                        partial += xx[x+1] - xx[x];
                     88:        }       }
                     89:        free(xx);
                     90: }
                     91: 
                     92: doline(a, b, c, p, t)
                     93: {      int q;
                     94: 
                     95:        if (a >= b) return;
                     96:        lcnt++;
                     97:        if (lcnt%100 == 0)
                     98:                printf("}\ndef curve%d() {\n", lcnt);
                     99:        if (b-a == t)
                    100:                printf("mapper(%d,%d,0,%d,%d)\n", a, b, SZ-1, c);
                    101:        else
                    102:        {       if (p == 0)
                    103:                {       printf("setter(0, %d, %d, %d)\n", a, c, c*255/(SZ-1));
                    104:                        printf("mapper(%d,%d,0,(%d*%d)/%d,%d)\n",a,b,SZ-1,b-a,t,c);
                    105:                } else
                    106:                {       printf("x=(%d*%d)/%d;\n", SZ-1, p, t);
                    107:                        printf("y=x+(%d*%d)/%d;\n", SZ-1, (b-a), t);
                    108:                        printf("mapper(%d,%d,x,y,%d)\n", a, b, c);
                    109:                        if (p+b-a == t)
                    110:                        printf("setter(%d, %d, %d, %d)\n",b,SZ-1,c,c*255/(SZ-1));
                    111:                }
                    112:        }
                    113: }
                    114: 
                    115: #define Sign(n)        ((n>0)?1:0)     
                    116: 
                    117: intersect(xx, y)
                    118:        int *xx;
                    119: {
                    120:        Node *hunt, *last;
                    121:        int i, j, n, m;
                    122:        int nhit=0;
                    123: 
                    124:        last = frst;
                    125:        hunt = last->nxt;
                    126:        while (hunt)
                    127:        {       n = last->y - y;
                    128:                m = hunt->y - y;
                    129:                if (Sign(n) != Sign(m))
                    130:                {       i = last->x; j = hunt->x;
                    131:                        if (hunt->x > last->x)
                    132:                                xx[nhit++] = i + (j-i)*n/(n-m);
                    133:                        else
                    134:                                xx[nhit++] = i - (i-j)*n/(n-m);
                    135:                } /* else if (n == 0 && m == 0)
                    136:                {       if (hunt->x > last->x)
                    137:                                doline(last->x, hunt->x, SZ-y);
                    138:                        else
                    139:                                doline(hunt->x, last->x, SZ-y);
                    140:                } */
                    141:                last = hunt;
                    142:                hunt = last->nxt;
                    143:                if (hunt && hunt->soc)
                    144:                {       last = hunt;
                    145:                        hunt = last->nxt;
                    146:                }
                    147:        }
                    148:        return nhit;
                    149: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.