Return to spline.c CVS log

Up to [Research Unix] / researchv10no / libplot / libpen

Annotation of researchv10no/libplot/libpen/spline.c, revision 1.1

1.1     ! root        1: /*
        !             2: Produce spline (uniform knots, second order)
        !             3: from guiding points
        !             4: */
        !             5: 
        !             6: splin(mode, num, ff) 
        !             7: int num[], mode;
        !             8: double *ff[];
        !             9: {
        !            10:        int     i,  *np, n;
        !            11:        double  xa, ya, xc, yc, *xp, *yp, *xp0, *yp0, *xpe, *ype;
        !            12:        double **fp;
        !            13:        np = num;
        !            14:        fp = ff;
        !            15:        while((n = *np++)){
        !            16:                xp = *fp++; 
        !            17:                yp = xp + 1; 
        !            18:                xp0 = xp; 
        !            19:                yp0 = yp;
        !            20:                xpe = xp0 + 2 * (n - 1); 
        !            21:                ype = yp0 + 2 * (n - 1);
        !            22:                if (n < 3) { 
        !            23:                        line(*xp, *yp, *(xp + 2), *(yp + 2)); 
        !            24:                        continue;
        !            25:                }
        !            26:                if (mode == 4) {        /*closed curve*/
        !            27:                        xa = 0.5 * (*xpe + *(xpe - 2)); 
        !            28:                        xc = 0.5 * (*xpe + *xp0);
        !            29:                        ya = 0.5 * (*ype + *(ype - 2)); 
        !            30:                        yc = 0.5 * (*ype + *yp0);
        !            31:                        parabola(xa, ya, xc, yc, *xpe, *ype);
        !            32:                        xa = 0.5 * (*xpe + *xp0); 
        !            33:                        xc = 0.5 * (*(xp0 + 2) + *xp0);
        !            34:                        ya = 0.5 * (*ype + *yp0); 
        !            35:                        yc = 0.5 * (*(yp0 + 2) + *yp0);
        !            36:                        parabola(xa, ya, xc, yc, *xp0, *yp0);
        !            37:                }
        !            38:                else {  /*open curve with multiple endpoints*/
        !            39:                        if (mode % 2) /*odd mode makes first point double*/
        !            40:                                line(*xp0,*yp0,0.5*(*xp0+*(xp0+2)),0.5*(*yp0+*(yp0+2)));
        !            41:                }
        !            42:                xp += 2; 
        !            43:                yp += 2;
        !            44:                for (i = 1; i < (n - 1); i++, xp += 2, yp += 2) {
        !            45:                        xa = 0.5 * (*(xp - 2) + *xp); 
        !            46:                        xc = 0.5 * ( *xp + *(xp + 2));
        !            47:                        ya = 0.5 * (*(yp - 2) + *yp); 
        !            48:                        yc = 0.5 * ( *yp + *(yp + 2));
        !            49:                        parabola(xa, ya, xc, yc, *xp, *yp);
        !            50:                }
        !            51:                if(mode >= 2 && mode != 4)
        !            52:                        line(0.5*(*(xpe-2)+*xpe),0.5*(*(ype-2)+*ype),*xpe,*ype);
        !            53:        }
        !            54: }

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