Return to pico.fcts CVS log

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

Annotation of researchv10dc/vol2/Faces/How/pico.fcts, revision 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: }

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