} else {		y = MIN(pPtr[3], pointPtr[1]);		y = MAX(y, pPtr[1]);	    }	} else if (pPtr[3] == pPtr[1]) {	    /*	     * Horizontal edge.	     */	    y = pPtr[1];	    if (pPtr[0] >= pPtr[2]) {		x = MIN(pPtr[0], pointPtr[0]);		x = MAX(x, pPtr[2]);		if ((pointPtr[1] < y) && (pointPtr[0] < pPtr[0])			&& (pointPtr[0] >= pPtr[2])) {		    intersections++;		}	    } else {		x = MIN(pPtr[2], pointPtr[0]);		x = MAX(x, pPtr[0]);		if ((pointPtr[1] < y) && (pointPtr[0] < pPtr[2])			&& (pointPtr[0] >= pPtr[0])) {		    intersections++;		}	    }	} else {	    double m1, b1, m2, b2;	    int lower;			/* Non-zero means point below line. */	    /*	     * The edge is neither horizontal nor vertical.  Convert the	     * edge to a line equation of the form y = m1*x + b1.  Then	     * compute a line perpendicular to this edge but passing	     * through the point, also in the form y = m2*x + b2.	     */	    m1 = (pPtr[3] - pPtr[1])/(pPtr[2] - pPtr[0]);	    b1 = pPtr[1] - m1*pPtr[0];	    m2 = -1.0/m1;	    b2 = pointPtr[1] - m2*pointPtr[0];	    x = (b2 - b1)/(m1 - m2);	    y = m1*x + b1;	    if (pPtr[0] > pPtr[2]) {		if (x > pPtr[0]) {		    x = pPtr[0];		    y = pPtr[1];		} else if (x < pPtr[2]) {		    x = pPtr[2];		    y = pPtr[3];		}	    } else {		if (x > pPtr[2]) {		    x = pPtr[2];		    y = pPtr[3];		} else if (x < pPtr[0]) {		    x = pPtr[0];		    y = pPtr[1];		}	    }	    lower = (m1*pointPtr[0] + b1) > pointPtr[1];	    if (lower && (pointPtr[0] >= MIN(pPtr[0], pPtr[2]))		    && (pointPtr[0] < MAX(pPtr[0], pPtr[2]))) {		intersections++;	    }	}	/*	 * Compute the distance to the closest point, and see if that	 * is the best distance seen so far.	 */	dist = hypot(pointPtr[0] - x, pointPtr[1] - y);	if (dist < bestDist) {	    bestDist = dist;	}    }    /*     * We've processed all of the points.  If the number of intersections     * is odd, the point is inside the polygon.     */    if (intersections & 0x1) {	return 0.0;    }    return bestDist;}/* *-------------------------------------------------------------- * * TkPolygonToArea -- * *	Determine whether a polygon lies entirely inside, entirely *	outside, or overlapping a given rectangular area. * * Results: *	-1 is returned if the polygon given by polyPtr and numPoints *	is entirely outside the rectangle given by rectPtr.  0 is *	returned if the polygon overlaps the rectangle, and 1 is *	returned if the polygon is entirely inside the rectangle. * * Side effects: *	None. * *-------------------------------------------------------------- */intTkPolygonToArea(polyPtr, numPoints, rectPtr)    double *polyPtr;		/* Points to an array coordinates for				 * closed polygon:  x0, y0, x1, y1, ...				 * The polygon may be self-intersecting. */    int numPoints;		/* Total number of points at *polyPtr. */    register double *rectPtr;	/* Points to coords for rectangle, in the				 * order x1, y1, x2, y2.  X1 and y1 must				 * be lower-left corner. */{    int state;			/* State of all edges seen so far (-1 means				 * outside, 1 means inside, won't ever be				 * 0). */    int count;    register double *pPtr;    /*     * Iterate over all of the edges of the polygon and test them     * against the rectangle.  Can quit as soon as the state becomes     * "intersecting".     */    state = TkLineToArea(polyPtr, polyPtr+2, rectPtr);    if (state == 0) {	return 0;    }    for (pPtr = polyPtr+2, count = numPoints-1; count >= 2;	    pPtr += 2, count--) {	if (TkLineToArea(pPtr, pPtr+2, rectPtr) != state) {	    return 0;	}    }    /*     * If all of the edges were inside the rectangle we're done.     * If all of the edges were outside, then the rectangle could     * still intersect the polygon (if it's entirely enclosed).     * Call TkPolygonToPoint to figure this out.     */    if (state == 1) {	return 1;    }    if (TkPolygonToPoint(polyPtr, numPoints, rectPtr) == 0.0) {	return 0;    }    return -1;}/* *-------------------------------------------------------------- * * TkOvalToPoint -- * *	Computes the distance from a given point to a given *	oval, in canvas units. * * Results: *	The return value is 0 if the point given by *pointPtr is *	inside the oval.  If the point isn't inside the *	oval then the return value is approximately the distance *	from the point to the oval.  If the oval is filled, then *	anywhere in the interior is considered "inside";  if *	the oval isn't filled, then "inside" means only the area *	occupied by the outline. * * Side effects: *	None. * *-------------------------------------------------------------- */	/* ARGSUSED */doubleTkOvalToPoint(ovalPtr, width, filled, pointPtr)    double ovalPtr[4];		/* Pointer to array of four coordinates				 * (x1, y1, x2, y2) defining oval's bounding				 * box. */    double width;		/* Width of outline for oval. */    int filled;			/* Non-zero means oval should be treated as				 * filled;  zero means only consider outline. */    double pointPtr[2];		/* Coordinates of point. */{    double xDelta, yDelta, scaledDistance, distToOutline, distToCenter;    double xDiam, yDiam;    /*     * Compute the distance between the center of the oval and the     * point in question, using a coordinate system where the oval     * has been transformed to a circle with unit radius.     */    xDelta = (pointPtr[0] - (ovalPtr[0] + ovalPtr[2])/2.0);    yDelta = (pointPtr[1] - (ovalPtr[1] + ovalPtr[3])/2.0);    distToCenter = hypot(xDelta, yDelta);    scaledDistance = hypot(xDelta / ((ovalPtr[2] + width - ovalPtr[0])/2.0),	    yDelta / ((ovalPtr[3] + width - ovalPtr[1])/2.0));    /*     * If the scaled distance is greater than 1 then it means no     * hit.  Compute the distance from the point to the edge of     * the circle, then scale this distance back to the original     * coordinate system.     *     * Note: this distance isn't completely accurate.  It's only     * an approximation, and it can overestimate the correct     * distance when the oval is eccentric.     */    if (scaledDistance > 1.0) {	return (distToCenter/scaledDistance) * (scaledDistance - 1.0);    }    /*     * Scaled distance less than 1 means the point is inside the     * outer edge of the oval.  If this is a filled oval, then we     * have a hit.  Otherwise, do the same computation as above     * (scale back to original coordinate system), but also check     * to see if the point is within the width of the outline.     */    if (filled) {	return 0.0;    }    if (scaledDistance > 1E-10) {	distToOutline = (distToCenter/scaledDistance) * (1.0 - scaledDistance)		- width;    } else {	/*	 * Avoid dividing by a very small number (it could cause an	 * arithmetic overflow).  This problem occurs if the point is	 * very close to the center of the oval.	 */	xDiam = ovalPtr[2] - ovalPtr[0];	yDiam = ovalPtr[3] - ovalPtr[1];	if (xDiam < yDiam) {	    distToOutline = (xDiam - width)/2;	} else {	    distToOutline = (yDiam - width)/2;	}    }    if (distToOutline < 0.0) {	return 0.0;    }    return distToOutline;}/* *-------------------------------------------------------------- * * TkOvalToArea -- * *	Determine whether an oval lies entirely inside, entirely *	outside, or overlapping a given rectangular area. * * Results: *	-1 is returned if the oval described by ovalPtr is entirely *	outside the rectangle given by rectPtr.  0 is returned if the *	oval overlaps the rectangle, and 1 is returned if the oval *	is entirely inside the rectangle. * * Side effects: *	None. * *-------------------------------------------------------------- */intTkOvalToArea(ovalPtr, rectPtr)    register double *ovalPtr;	/* Points to coordinates definining the				 * bounding rectangle for the oval: x1, y1,				 * x2, y2.  X1 must be less than x2 and y1				 * less than y2. */    register double *rectPtr;	/* Points to coords for rectangle, in the				 * order x1, y1, x2, y2.  X1 and y1 must				 * be lower-left corner. */{    double centerX, centerY, radX, radY, deltaX, deltaY;    /*     * First, see if oval is entirely inside rectangle or entirely     * outside rectangle.     */    if ((rectPtr[0] <= ovalPtr[0]) && (rectPtr[2] >= ovalPtr[2])	    && (rectPtr[1] <= ovalPtr[1]) && (rectPtr[3] >= ovalPtr[3])) {	return 1;    }    if ((rectPtr[2] < ovalPtr[0]) || (rectPtr[0] > ovalPtr[2])	    || (rectPtr[3] < ovalPtr[1]) || (rectPtr[1] > ovalPtr[3])) {	return -1;    }    /*     * Next, go through the rectangle side by side.  For each side     * of the rectangle, find the point on the side that is closest     * to the oval's center, and see if that point is inside the     * oval.  If at least one such point is inside the oval, then     * the rectangle intersects the oval.     */    centerX = (ovalPtr[0] + ovalPtr[2])/2;    centerY = (ovalPtr[1] + ovalPtr[3])/2;    radX = (ovalPtr[2] - ovalPtr[0])/2;    radY = (ovalPtr[3] - ovalPtr[1])/2;    deltaY = rectPtr[1] - centerY;    if (deltaY < 0.0) {	deltaY = centerY - rectPtr[3];	if (deltaY < 0.0) {	    deltaY = 0;	}    }    deltaY /= radY;    deltaY *= deltaY;    /*     * Left side:     */    deltaX = (rectPtr[0] - centerX)/radX;    deltaX *= deltaX;    if ((deltaX + deltaY) <= 1.0) {	return 0;    }    /*     * Right side:     */    deltaX = (rectPtr[2] - centerX)/radX;    deltaX *= deltaX;    if ((deltaX + deltaY) <= 1.0) {	return 0;    }    deltaX = rectPtr[0] - centerX;    if (deltaX < 0.0) {	deltaX = centerX - rectPtr[2];	if (deltaX < 0.0) {	    deltaX = 0;	}    }    deltaX /= radX;    deltaX *= deltaX;    /*     * Bottom side:     */    deltaY = (rectPtr[1] - centerY)/radY;    deltaY *= deltaY;    if ((deltaX + deltaY) < 1.0) {	return 0;    }    /*     * Top side:     */    deltaY = (rectPtr[3] - centerY)/radY;    deltaY *= deltaY;    if ((deltaX + deltaY) < 1.0) {	return 0;    }    return -1;}/* *-------------------------------------------------------------- * * TkIncludePoint -- * *	Given a point and a generic canvas item header, expand *	the item's bounding box if needed to include the point. * * Results: *	None. * * Side effects: *	The boudn. * *-------------------------------------------------------------- */	/* ARGSUSED */voidTkIncludePoint(itemPtr, pointPtr)    register Tk_Item *itemPtr;		/* Item whose bounding box is					 * being calculated. */    double *pointPtr;			/* Address of two doubles giving					 * x and y coordinates of point. */{    int tmp;    tmp = (int) (pointPtr[0] + 0.5);    if (tmp < itemPtr->x1) {	itemPtr->x1 = tmp;    }    if (tmp > itemPtr->x2) {	itemPtr->x2 = tmp;    }    tmp = (int) (pointPtr[1] + 0.5);    if (tmp < itemPtr->y1) {	itemPtr->y1 = tmp;    }    if (tmp > itemPtr->y2) {	itemPtr->y2 = tmp;    }}/* *-------------------------------------------------------------- * * TkBezierScreenPoints -- * *	Given four control points, create a larger set of XPoints *	for a Bezier spline based on the points. * * Results: *	The array at *xPointPtr gets filled in with numSteps XPoints *	corresponding to the Bezier spline defined by the four  *	control points.  Note:  no output point is generated for the *	first input point, but an output point *is* generated for *	the last input point. * * Side effects: *	None. * *-------------------------------------------------------------- */voidTkBezierScreenPoints(canvas, control, numSteps, xPointPtr)    Tk_Canvas canvas;			/* Canvas in which curve is to be					 * drawn. */    double control[];			/* Array of coordinates for four					 * control points:  x0, y0, x1, y1,					 * ... x3 y3. */    int numSteps;			/* Number of curve points to					 * generate.  */    register XPoint *xPointPtr;		/* Where to put new points. */{    int i;    double u, u2, u3, t, t2, t3;    for (i = 1; i <= numSteps; i++, xPointPtr++) {	t = ((double) i)/((double) numSteps);	t2 = t*t;	t3 = t2*t;	u = 1.0 - t;	u2 = u*u;	u3 = u2*u;	Tk_CanvasDrawableCoords(canvas,		(control[0]*u3 + 3.0 * (control[2]*t*u2 + control[4]*t2*u)		    + control[6]*t3),		(control[1]*u3 + 3.0 * (control[3]*t*u2 + control[5]*t2*u)		    + control[7]*t3),		&xPointPtr->x, &xPointPtr->y);    }}/* *-------------------------------------------------------------- * * TkBezierPoints -- * *	Given four control points, create a larger set of points *	for a Bezier spline based on the points. * * Results: *	The array at *coordPtr gets filled in with 2*numSteps *	coordinates, which correspond to the Bezier spline defined *	by the four control points.  Note:  no output point is *	generated for the first input point, but an output point *	*is* generated for the last input point. *