bezier.c File Reference

#include <win32k.h>
#include <debug.h>

Include dependency graph for bezier.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	BEZIERSHIFTBITS   4
#define	BEZIERSHIFTUP(x)   ((x)<<BEZIERSHIFTBITS)
#define	BEZIERPIXEL   BEZIERSHIFTUP(1)
#define	BEZIERSHIFTDOWN(x)   (((x)+(1<<(BEZIERSHIFTBITS-1)))>>BEZIERSHIFTBITS)
#define	BEZIERMAXDEPTH   8
#define	BEZIER_INITBUFSIZE   (150)
#define	BEZIERMIDDLE(Mid, P1, P2)

Functions
static BOOL	BezierCheck (int level, POINT *Points)
static void	GDI_InternalBezier (POINT *Points, POINT **PtsOut, INT *dwOut, INT *nPtsOut, INT level)
POINT *	GDI_Bezier (const POINT *Points, INT count, INT *nPtsOut)

Macro Definition Documentation

BEZIER_INITBUFSIZE

#define BEZIER_INITBUFSIZE   (150)

Definition at line 46 of file bezier.c.

BEZIERMAXDEPTH

#define BEZIERMAXDEPTH   8

Definition at line 42 of file bezier.c.

BEZIERMIDDLE

#define BEZIERMIDDLE	(		Mid,
			P1,
			P2
	)

Value:

    (Mid).x=((P1).x+(P2).x + 1)/2;\
    (Mid).y=((P1).y+(P2).y + 1)/2;

Definition at line 52 of file bezier.c.

BEZIERPIXEL

#define BEZIERPIXEL   BEZIERSHIFTUP(1)

Definition at line 39 of file bezier.c.

BEZIERSHIFTBITS

#define BEZIERSHIFTBITS   4

Definition at line 37 of file bezier.c.

BEZIERSHIFTDOWN

#define BEZIERSHIFTDOWN

(

x

)

(((x)+(1<<(BEZIERSHIFTBITS-1)))>>BEZIERSHIFTBITS)

Definition at line 40 of file bezier.c.

BEZIERSHIFTUP

#define BEZIERSHIFTUP

(

x

)

((x)<<BEZIERSHIFTBITS)

Definition at line 38 of file bezier.c.

NDEBUG

#define NDEBUG

Definition at line 8 of file bezier.c.

Function Documentation

BezierCheck()

static BOOL BezierCheck ( int  level, POINT *  Points  )

static

Definition at line 64 of file bezier.c.

{
    INT dx, dy;
    dx=Points[3].x-Points[0].x;
    dy=Points[3].y-Points[0].y;
    if(abs(dy)<=abs(dx)){/* shallow line */
        /* check that control points are between begin and end */
        if(Points[1].x < Points[0].x){
            if(Points[1].x < Points[3].x)
                return FALSE;
        }else
            if(Points[1].x > Points[3].x)
                return FALSE;
        if(Points[2].x < Points[0].x){
            if(Points[2].x < Points[3].x)
                return FALSE;
        }else
            if(Points[2].x > Points[3].x)
                return FALSE;
        dx=BEZIERSHIFTDOWN(dx);
        if(!dx) return TRUE;
        if(abs(Points[1].y-Points[0].y-(dy/dx)*
                BEZIERSHIFTDOWN(Points[1].x-Points[0].x)) > BEZIERPIXEL ||
           abs(Points[2].y-Points[0].y-(dy/dx)*
                   BEZIERSHIFTDOWN(Points[2].x-Points[0].x)) > BEZIERPIXEL )
            return FALSE;
        else
            return TRUE;
    }else{ /* steep line */
        /* check that control points are between begin and end */
        if(Points[1].y < Points[0].y){
            if(Points[1].y < Points[3].y)
                return FALSE;
        }else
            if(Points[1].y > Points[3].y)
                return FALSE;
        if(Points[2].y < Points[0].y){
            if(Points[2].y < Points[3].y)
                return FALSE;
        }else
            if(Points[2].y > Points[3].y)
                return FALSE;
        dy=BEZIERSHIFTDOWN(dy);
        if(!dy) return TRUE;
        if(abs(Points[1].x-Points[0].x-(dx/dy)*
                BEZIERSHIFTDOWN(Points[1].y-Points[0].y)) > BEZIERPIXEL ||
           abs(Points[2].x-Points[0].x-(dx/dy)*
                   BEZIERSHIFTDOWN(Points[2].y-Points[0].y)) > BEZIERPIXEL )
            return FALSE;
        else
            return TRUE;
    }
}

Referenced by GDI_InternalBezier().

GDI_Bezier()

POINT * GDI_Bezier	(	const POINT *	Points,
		INT	count,
		INT *	nPtsOut
	)

Definition at line 189 of file bezier.c.

{
    POINT *out;
    INT Bezier, dwOut = BEZIER_INITBUFSIZE, i;
 
    if (count == 1 || (count - 1) % 3 != 0) {
        DPRINT1("Invalid no. of points %d\n", count);
    return NULL;
    }
    *nPtsOut = 0;
 
    out = ExAllocatePoolWithTag(PagedPool, dwOut * sizeof(POINT), TAG_BEZIER);
    if (!out) return NULL;
 
    for(Bezier = 0; Bezier < (count-1)/3; Bezier++) {
    POINT ptBuf[4];
    memcpy(ptBuf, Points + Bezier * 3, sizeof(POINT) * 4);
    for(i = 0; i < 4; i++) {
        ptBuf[i].x = BEZIERSHIFTUP(ptBuf[i].x);
        ptBuf[i].y = BEZIERSHIFTUP(ptBuf[i].y);
    }
        GDI_InternalBezier( ptBuf, &out, &dwOut, nPtsOut, BEZIERMAXDEPTH );
    }
    DPRINT("Produced %d points\n", *nPtsOut);
    return out;
}

Referenced by IntGdiPolyBezier(), NtGdiPolyDraw(), PATH_AddFlatBezier(), and PATH_StrokePath().

GDI_InternalBezier()

static void GDI_InternalBezier ( POINT *  Points, POINT **  PtsOut, INT *  dwOut, INT *  nPtsOut, INT  level  )

static

Todo:

FIXME!

Definition at line 121 of file bezier.c.

{
    if(*nPtsOut == *dwOut) {
        *dwOut *= 2;
        *PtsOut = ExAllocatePoolWithTag(PagedPool, *dwOut * sizeof(POINT), TAG_BEZIER);
        if (*PtsOut == NULL)
        {
            NT_ASSERT(FALSE);
            return;
        }
    }
 
    if(!level || BezierCheck(level, Points)) {
        if(*nPtsOut == 0) {
            (*PtsOut)[0].x = BEZIERSHIFTDOWN(Points[0].x);
            (*PtsOut)[0].y = BEZIERSHIFTDOWN(Points[0].y);
            *nPtsOut = 1;
        }
    (*PtsOut)[*nPtsOut].x = BEZIERSHIFTDOWN(Points[3].x);
        (*PtsOut)[*nPtsOut].y = BEZIERSHIFTDOWN(Points[3].y);
        (*nPtsOut) ++;
    } else {
        POINT Points2[4]; /* for the second recursive call */
        Points2[3]=Points[3];
        BEZIERMIDDLE(Points2[2], Points[2], Points[3]);
        BEZIERMIDDLE(Points2[0], Points[1], Points[2]);
        BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]);
 
        BEZIERMIDDLE(Points[1], Points[0],  Points[1]);
        BEZIERMIDDLE(Points[2], Points[1], Points2[0]);
        BEZIERMIDDLE(Points[3], Points[2], Points2[1]);
 
        Points2[0]=Points[3];
 
        /* do the two halves */
        GDI_InternalBezier(Points, PtsOut, dwOut, nPtsOut, level-1);
        GDI_InternalBezier(Points2, PtsOut, dwOut, nPtsOut, level-1);
    }
}

Referenced by GDI_Bezier(), and GDI_InternalBezier().