Annotation of researchv10dc/vol2/Faces/How/pico.fcts, revision 1.1.1.1

1.1       root        1: barts:
                      2: x new = old[sqrt(x*512),clamp(y+sin(x)/(x+50))]
                      3: 
                      4: pjw.1
                      5: x new=$pjw[x_cart((r = r_polar(x,y)+(sin(r_polar(x, y)))/100), a=a_polar(x,y)), y_cart(r,a)]
                      6: pg.1
                      7: x new=$td[x_cart((r = r_polar(x,y)), (a=a_polar(x,y)+(sin(a_polar(x, y)))/300)), y_cart(r,a)]
                      8: td.3
                      9: x new=$td[x_cart((r = r_polar(x,y)+(sin(a_polar(x, y)))/300), (a=a_polar(x,y))), y_cart(r,a)]
                     10: howard.1
                     11: x new=$howard[x_cart((r = r_polar(x,y)-(sin(a_polar(x, y)))/300), (a=a_polar(x,y))), y_cart(r,a)]
                     12: ftg.1
                     13:  x new=$ftg[x_cart((r = r_polar(x,y)+(sin(a_polar(x, y)))/300), (a=a_polar(x,y)-(sin(r_polar(x, y)))/300)), y_cart(r,a)]
                     14: clowns-nose:
                     15: x new=$Pg[x_cart((r = r_polar(x,y)-(sin(a_polar(x, y)))/300), (a=a_polar(x,y))), y_cart(r,a)]
                     16: 
                     17: ken swirl:
                     18: x new=old[xclamp(x_cart(r=r_polar(x,y),a=(a_polar(x,y)+r/3))),yclamp(y_cart(r,a))]
                     19: 
                     20: lincoln transformation
                     21: x new=old[x_cart(r=(r_polar(x,y)/8)*8,a=(a_polar(x,y)/8)*8), y_cart(r,a)]
                     22: 
                     23: fading
                     24: x new=(x<X/3)?$1:(x>X*2/3)?$2:3*((x-X/3)*$2+(X*2/3-x)*$1)/X
                     25: x new=(y<Y/6)?$1:(y>Y/3)?$2:6*((y-Y/6)*$2+(Y/3-y)*$1)/Y
                     26: 
                     27: random split
                     28: x {
                     29:        global int r;
                     30:        r = X/2
                     31:        for (y = 0; y < Y; y++)
                     32:        {       r = r+(rand()%3)-1
                     33:                for (x = 0; x < r; x++)
                     34:                        new[x,y] = $1[x,y];
                     35:                x--
                     36:                for (x++; x < X; x++)
                     37:                        new[x,y] = $2[x-180,clamp(y-20)]
                     38:        }
                     39: }
                     40: 
                     41: weird
                     42: x new=($1>$2)?$2:$1
                     43: x new=($1>100)?$1:$2
                     44: 
                     45: charicature:
                     46: x new=old[x_cart(r=sqrt(256*r_polar(x,y)),a=a_polar(x,y)), y_cart(r,a)]
                     47: 
                     48: inverse charicature:
                     49: x new=old[x_cart(r=pow(r_polar(x,y), 2)/256,a=a_polar(x,y)), y_cart(r,a)]
                     50: 
                     51: doug's fctns:
                     52: x new=old[xclamp(x+Sin(720*x)/150), yclamp(y+Sin(720*y)/150)]
                     53: x new=old[xclamp(x + Cos(((x-512)*36000)/512)/128), y]
                     54: x new=$1*((512-(x-512)*(x-512)-(y-512)*(y-512))>>14)
                     55: 
                     56: random smearing
                     57: x new = old[clamp(x+(rand()&15)),clamp(y+(rand()&15))]
                     58: 
                     59: mapping of square onto disc
                     60: x new=old[xclamp(a_polar(x,y)*2), yclamp(r_polar(x,y)*2)]
                     61: 
                     62: mapping onto a sphere:
                     63: def bubble(R) {
                     64:        int rx, Rx, dx, ex, xy, OX, OY
                     65:        int ry, Ry, dy, ey, a, R2
                     66:        /* use R = 200 */
                     67:        OX=X/2
                     68:        OY=Y/2
                     69:        R2 = R*R
                     70:        for (y = 0; y < Y; y++)
                     71:        {       ey = y-OY
                     72:                ry = R2 - ey*ey
                     73:                Ry = sqrt(ry)
                     74:                for (x = 0; x < X; x++)
                     75:                {       ex = x-OX
                     76:                        if (abs(ex) <= Ry)
                     77:                        {       rx = R2 - ex*ex
                     78:                                Rx = sqrt(rx)
                     79:                                xy = sqrt(rx+ry-R2)
                     80:                                dx = X-(2*R*atan(ex, xy))/180
                     81:                                dy = Y-(2*R*atan(ey, xy))/180
                     82:                        }
                     83:                        else
                     84:                        {       dx = x
                     85:                                dy = y
                     86:                        }
                     87:                        new[x,y] = old[dx, dy]
                     88:                }
                     89:        }
                     90: }
                     91: 
                     92: def oil(h) {
                     93:        int v, a, b, mfp
                     94:        array histo[256]
                     95: 
                     96:        for (y = h; y < 512-h; y++)
                     97:        {       new[0,y] = 0;
                     98:                for (x = h; x < 512-h; x++)
                     99:                {       for (a = v = 0; a < 256; a++)
                    100:                                histo[a] = 0
                    101:                        for (a = y-h; a <= y+h; a++)
                    102:                        for (b = x-h; b <= x+h; b++)
                    103:                        {       histo[old[b,a]]++
                    104:                        }
                    105:                        for (a = b = 0; a < 256; a++)
                    106:                        {       if (histo[a] > b)
                    107:                                {       b = histo[a]
                    108:                                        mfp = a
                    109:                                }
                    110:                        }
                    111:                        new[x,y] = mfp;
                    112:                }
                    113:        }
                    114: }
                    115: 
                    116: x new=0        
                    117: x new[x, yclamp(y - $clouds[x,y]/4)]=$clouds   /* bentley drip */
                    118: x new=old
                    119: x {
                    120:        int r
                    121:        array yshift[Y]
                    122: 
                    123:        for (y = 0; y < Y; y++)
                    124:        {       if (rand() < 2000)
                    125:                        r=(rand()&127)-64
                    126:                yshift[y] = r
                    127:        }
                    128:        
                    129:        for (y=0; y<Y; y++)
                    130:        {       if (rand() < 2000)
                    131:                        r=(rand()&127)-64
                    132:                for (x=0; x<X; x++)
                    133:                        new[x,y] = old[clamp(x+r), clamp(y+yshift[x])]
                    134:        }
                    135: }
                    136: 
                    137: def tilt(an, XL, YL, D) {
                    138:        int dx, dy, d, ex, ey
                    139:        int sa, ca
                    140:        /* try x { tile(60, 612, 800, 2048); }
                    141:        sa = sin(-an)
                    142:        ca = cos(-an)
                    143: 
                    144:        for (y = 0; y < Y; y++)
                    145:        for (x = 0; x < X; x++)
                    146:        {       d  = ((x-XL)*sa)/ca
                    147:                ex = ((x-XL)*D)/(d+D)
                    148:                ey = ((y-YL)*D)/(d+D)
                    149:                dx = XL + (ex*1024)/ca
                    150:                dy = YL + ey
                    151:                new[x,y] = old[xclamp(dx),yclamp(dy)]
                    152:        }
                    153: }

unix.superglobalmegacorp.com

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