Adaptation des ent�tes.

Importation du code sur la gestion des Beziers et routines
g�om�triques. Modification du code de g�n�ration des Beziers.
Correction de bugs dans PolylineToPointDist, PolygonInBBox,
PolylineInBBox.

1 files changed, 1844 insertions, 0 deletions

diff --git a/generic/Geo.c b/generic/Geo.c
new file mode 100644
index 0000000..203d3d4
--- /dev/null
+++ b/generic/Geo.c
@@ -0,0 +1,1844 @@
+/*
+ * Geo.c -- Implementation of common geometric routines.
+ *
+ * Authors		: Patrick Lecoanet.
+ * Creation date	:
+ *
+ * $Id$
+ */
+
+/*
+ *  Copyright (c) 1993 - 1999 CENA, Patrick Lecoanet --
+ *
+ * This code is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This code is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this code; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+/*
+ * Much of the code here is inspired by (or copied from) the Tk code.
+ */
+
+
+#include "Geo.h"
+#include "WidgetInfo.h"
+
+#include <memory.h>
+
+
+static const char rcsid[] = "$Id$";
+static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ " $";
+
+
+/*
+ * Compute the origin of the rectangle given
+ * by position, anchor, width and height.
+ */
+void
+Anchor2Origin(RadarPoint	*position,
+	      RadarDim		width,
+	      RadarDim		height,
+	      RadarAnchor	anchor,
+	      RadarPoint	*origin)
+{
+  switch (anchor) {
+  case RadarAnchorCenter:
+    origin->x = position->x - width/2;
+    origin->y = position->y - height/2;
+    break;
+  case RadarAnchorNW:
+    *origin = *position;
+    break;
+  case RadarAnchorN:
+    origin->x = position->x - width/2;
+    origin->y = position->y;
+    break;
+  case RadarAnchorNE:
+    origin->x = position->x - width;
+    origin->y = position->y;
+    break;
+  case RadarAnchorE:
+    origin->x = position->x - width;
+    origin->y = position->y - height/2;
+    break;
+  case RadarAnchorSE:
+    origin->x = position->x - width;
+    origin->y = position->y - height;
+    break;
+  case RadarAnchorS:
+    origin->x = position->x - width/2;
+    origin->y = position->y - height;
+    break;
+  case RadarAnchorSW:
+    origin->x = position->x;
+    origin->y = position->y - height;
+    break;
+  case RadarAnchorW:
+    origin->x = position->x;
+    origin->y = position->y - height/2;
+    break;
+  }
+}
+
+
+/*
+ * Compute the anchor position given the bbox origin, width,
+ * height and the anchor.
+ */
+void
+Origin2Anchor(RadarPoint	*origin,
+	      RadarDim		width,
+	      RadarDim		height,
+	      RadarAnchor	anchor,
+	      RadarPoint	*position)
+{
+  switch (anchor) {
+  case RadarAnchorCenter:
+    position->x = origin->x + width/2;
+    position->y = origin->y + height/2;
+    break;
+  case RadarAnchorNW:
+    *position = *origin;
+    break;
+  case RadarAnchorN:
+    position->x = origin->x + width/2;
+    position->y = origin->y;
+    break;
+  case RadarAnchorNE:
+    position->x = origin->x + width;
+    position->y = origin->y;
+    break;
+  case RadarAnchorE:
+    position->x = origin->x + width;
+    position->y = origin->y + height/2;
+    break;
+  case RadarAnchorSE:
+    position->x = origin->x + width;
+    position->y = origin->y + height;
+    break;
+  case RadarAnchorS:
+    position->x = origin->x + width/2;
+    position->y = origin->y + height;
+    break;
+  case RadarAnchorSW:
+    position->x = origin->x;
+    position->y = origin->y + height;
+    break;
+  case RadarAnchorW:
+    position->x = origin->x;
+    position->y = origin->y + height/2;
+    break;
+  }
+}
+
+
+void
+BBox2XRect(RadarBBox	*bbox,
+	   XRectangle	*r)
+{
+  r->x = REAL_TO_INT(bbox->orig.x);
+  r->y = REAL_TO_INT(bbox->orig.y);
+  r->width = REAL_TO_INT(bbox->corner.x) - r->x;
+  r->height = REAL_TO_INT(bbox->corner.y) - r->y;
+}
+
+
+void
+GetStringBBox(char	*str,
+	      RadarFont	font,
+	      RadarPos	x,
+	      RadarPos	y,
+	      RadarBBox	*str_bbox)
+{
+  Tk_FontMetrics fm;
+
+  str_bbox->orig.x = x;
+  str_bbox->corner.x  = x + RadarTextWidth(font, str, strlen(str));
+  Tk_GetFontMetrics(font, &fm);
+  str_bbox->orig.y = y - fm.ascent;
+  str_bbox->corner.y = str_bbox->orig.y + fm.ascent + fm.descent;
+}
+
+
+void
+ResetBBox(RadarBBox *bbox)
+{
+  bbox->orig.x = bbox->orig.y = 0;
+  bbox->corner = bbox->orig;
+}
+
+
+void
+CopyBBox(RadarBBox *bbox_from,
+	 RadarBBox *bbox_to)
+{
+  bbox_to->orig = bbox_from->orig;
+  bbox_to->corner = bbox_from->corner;
+}
+
+
+void
+IntersectBBox(RadarBBox *bbox1,
+	      RadarBBox *bbox2,
+	      RadarBBox *bbox_inter)
+{
+  if ((bbox1->corner.x < bbox2->orig.x) ||
+      (bbox1->corner.y < bbox2->orig.y) ||
+      (bbox2->corner.x < bbox1->orig.x) ||
+      (bbox2->corner.y < bbox1->orig.y)) {
+    ResetBBox(bbox_inter);
+  }
+  else {
+    bbox_inter->orig.x = MAX(bbox1->orig.x, bbox2->orig.x);
+    bbox_inter->orig.y = MAX(bbox1->orig.y, bbox2->orig.y);
+    bbox_inter->corner.x = MIN(bbox1->corner.x, bbox2->corner.x);
+    bbox_inter->corner.y = MIN(bbox1->corner.y, bbox2->corner.y);
+  }
+}
+
+
+RadarBool
+IsEmptyBBox(RadarBBox *bbox)
+{
+  return (bbox->orig.x >= bbox->corner.x) || (bbox->orig.y >= bbox->corner.y);
+}
+
+
+void
+AddBBoxToBBox(RadarBBox *bbox,
+	      RadarBBox *bbox2)
+{
+  if (IsEmptyBBox(bbox2)) {
+    return;
+  }
+  if (IsEmptyBBox(bbox)) {
+    CopyBBox(bbox2, bbox);
+  }
+  else {
+    bbox->orig.x = MIN(bbox->orig.x, bbox2->orig.x);
+    bbox->orig.y = MIN(bbox->orig.y, bbox2->orig.y);
+    bbox->corner.x = MAX(bbox->corner.x, bbox2->corner.x);
+    bbox->corner.y = MAX(bbox->corner.y, bbox2->corner.y);
+  }
+}
+
+
+void
+AddPointToBBox(RadarBBox	*bbox,
+	       RadarPos		px,
+	       RadarPos		py)
+{
+  if (IsEmptyBBox(bbox)) {
+    bbox->orig.x = px;
+    bbox->orig.y = py;
+    bbox->corner.x = bbox->orig.x + 1;
+    bbox->corner.y = bbox->orig.y + 1;
+  }
+  else {
+    bbox->orig.x = MIN(bbox->orig.x, px);
+    bbox->orig.y = MIN(bbox->orig.y, py);
+    bbox->corner.x = MAX(bbox->corner.x, px + 1);
+    bbox->corner.y = MAX(bbox->corner.y, py + 1);
+  }
+}
+
+
+void
+AddPointsToBBox(RadarBBox	*bbox,
+		RadarPoint	*points,
+		int		num_points)
+{
+  int		x1, y1, x2, y2, cur;
+
+  if (points == NULL) {
+    return;
+  }
+  
+  if (num_points == 0) {
+    return;
+  }
+  
+  if (IsEmptyBBox(bbox)) {
+    x1 = points->x;
+    y1 = points->y;
+    x2 = x1 + 1;
+    y2 = y1 + 1;
+    num_points--;
+    points++;
+  }
+  else {
+    x1 = bbox->orig.x;
+    y1 = bbox->orig.y;
+    x2 = bbox->corner.x;
+    y2 = bbox->corner.y;
+  }
+
+  for ( ; num_points > 0; num_points--, points++) {
+    cur = points->x;
+    if (cur < x1) {
+      x1 = cur;
+    }
+    if (cur > x2) {
+      x2 = cur;
+    }
+    cur = points->y;
+    if (cur < y1) {
+      y1 = cur;
+    }
+    if (cur > y2) {
+      y2 = cur;
+    }
+  }
+  bbox->orig.x = x1;
+  bbox->orig.y = y1;
+  bbox->corner.x = x2 + 1;
+  bbox->corner.y = y2 + 1;
+}
+
+
+void
+AddStringToBBox(RadarBBox	*bbox,
+		char		*str,
+		RadarFont	font,
+		RadarPos	cx,
+		RadarPos	cy)
+{
+  RadarBBox	str_bbox;
+  
+  GetStringBBox(str, font, cx, cy, &str_bbox);
+  AddBBoxToBBox(bbox, &str_bbox);
+}
+
+RadarBool
+PointInBBox(RadarBBox	*bbox,
+	    RadarPos	x,
+	    RadarPos	y)
+{
+  return ((x >= bbox->orig.x) && (x < bbox->corner.x) &&
+	  (y >= bbox->orig.y) && (y < bbox->corner.y));
+}
+
+
+/*
+ * Tell where aa area is with respect to another area.
+ * Return -1 if the first is entirely outside the second,
+ * 1 if it is entirely inside and 0 otherwise.
+ */
+int
+BBoxInBBox(RadarBBox	*bbox1,
+	   RadarBBox	*bbox2)
+{
+  if ((bbox1->corner.x <= bbox2->orig.x) ||
+      (bbox1->orig.x >= bbox2->corner.x) ||
+      (bbox1->corner.y <= bbox2->orig.y) ||
+      (bbox1->orig.y >= bbox2->corner.y)) {
+    return -1;
+  }
+  if ((bbox2->orig.x <= bbox1->orig.x) &&
+      (bbox1->corner.x <= bbox2->corner.x) &&
+      (bbox2->orig.y <= bbox1->orig.y) &&
+      (bbox1->corner.y <= bbox2->corner.y)) {
+    return 1;
+  }
+  return 0;
+}
+
+/*
+ * Tell where a line is with respect to an area.
+ * Return -1 if the line is entirely outside the bbox, 1
+ * if it is entirely inside and 0 otherwise.
+ */
+int
+LineInBBox(RadarPoint	*p1,
+	   RadarPoint	*p2,
+	   RadarBBox	*bbox)
+{
+  RadarBool	p1_inside = PointInBBox(bbox, p1->x, p1->y);
+  RadarBool	p2_inside = PointInBBox(bbox, p2->x, p2->y);
+
+  if (p1_inside != p2_inside) {
+    return 0;
+  }
+
+  if (p1_inside && p2_inside) {
+    return 1;
+  }
+  
+  /*
+   * Segment may intersect area, check it more thoroughly.
+   */
+  /* Vertical line */
+  if (p1->x == p2->x) {
+    if (((p1->y >= bbox->orig.y) ^ (p2->y >= bbox->orig.y)) &&
+	(p1->x >= bbox->orig.x) &&
+	(p1->x <= bbox->corner.x)) {
+      return 0;
+    }
+  }
+  /* Horizontal line */
+  else if (p1->y == p2->y) {
+    if (((p1->x >= bbox->orig.x) ^ (p2->x >= bbox->orig.x)) &&
+	(p1->y >= bbox->orig.y) &&
+	(p1->y <= bbox->corner.y)) {
+      return 0;
+    }
+  }
+  /* Diagonal, do it the hard way. */
+  else {
+    double	slope = ((double) p2->y - p1->y) / ((double) p2->x - p1->x);
+    int		low, high, x, y;
+    int		bbox_width = bbox->corner.x - bbox->orig.x;
+    int		bbox_height = bbox->corner.y - bbox->orig.y;
+
+    /* Check against left edge */
+    if (p1->x < p2->x) {
+      low = p1->x;
+      high = p2->x;
+    }
+    else {
+      low = p2->x;
+      high = p1->x;
+    }
+
+    y = p1->y + (bbox->orig.x - p1->x) * slope;
+    if ((bbox->orig.x >= low) && (bbox->orig.x <= high) &&
+	(y >= bbox->orig.y) && (y <= bbox->corner.y))
+      return 0;
+
+    /* Check against right edge */
+    y += bbox_width * slope;
+    if ((y >= bbox->orig.y) && (y <= bbox->corner.y) &&
+	(bbox->corner.x >= low) && (bbox->corner.x <= high))
+      return 0;
+	
+    /* Check against bottom edge */
+    if (p1->y < p2->y) {
+      low = p1->y;
+      high = p2->y;
+    }
+    else {
+      low = p2->y;
+      high = p1->y;
+    }
+
+    x = p1->x + (bbox->orig.y - p1->y) / slope;
+    if ((x >= bbox->orig.x) && (x <= bbox->corner.x) &&
+	(bbox->orig.y >= low) && (bbox->orig.y <= high))
+      return 0;
+
+    /* Check against top edge */
+    x += bbox_height / slope;
+    if ((x >= bbox->orig.x) && (x <= bbox->corner.x) &&
+	(bbox->corner.y >= low) && (bbox->corner.y <= high))
+      return 0;
+  }
+
+  return -1;
+}
+
+
+/*
+ * ShiftLine --
+ *	Given two points describing a line and a distance, return
+ *	to points describing a line parallel to it at the given distance.
+ *	When looking the line from p1 to p2 the new line will be dist away
+ *	on its left. Negative values are allowed for dist, resulting in a line
+ *	on the right.
+ */
+void
+ShiftLine(RadarPoint	*p1,
+	  RadarPoint	*p2,
+	  RadarReal	dist,
+	  RadarPoint	*p3,
+	  RadarPoint	*p4)
+{
+  static int	shift_table[129];
+  RadarBool	dx_neg, dy_neg;
+  int		dx, dy;
+
+  /*
+   * Initialize the conversion table.
+   */
+  if (shift_table[0] == 0) {
+    int		i;
+    double	tangent, cosine;
+    
+    for (i = 0; i <= 128; i++) {
+      tangent = i/128.0;
+      cosine = 128/cos(atan(tangent)) + 0.5;
+      shift_table[i] = (int) cosine;
+    }
+  }
+
+  *p3 = *p1;
+  dx = p2->x - p1->x;
+  dy = p2->y - p1->y;
+  if (dx < 0) {
+    dx = -dx;
+    dx_neg = True;
+  }
+  else
+    dx_neg = False;
+  if (dy < 0) {
+    dy = -dy;
+    dy_neg = True;
+  }
+  else {
+    dy_neg = False;
+  }
+  if (dy <= dx) {
+    dy = ((dist * shift_table[(dy*128)/dx]) + 64) / 128;
+    if (!dx_neg) {
+      dy = -dy;
+    }
+    p3->y += dy;
+  }
+  else {
+    dx = ((dist * shift_table[(dx*128)/dy]) + 64) / 128;
+    if (dy_neg) {
+      dx = -dx;
+    }
+    p3->x += dx;
+  }
+
+  p4->x = p3->x + (p2->x - p1->x);
+  p4->y = p3->y + (p2->y - p1->y);
+}
+
+
+/*
+ * IntersectLines --
+ *	Given two lines described by two points, compute their intersection.
+ *	The function returns True if the lines are not parallel and False
+ *	otherwise.
+ */
+RadarBool
+IntersectLines(RadarPoint	*a1,
+	       RadarPoint	*a2,
+	       RadarPoint	*b1,
+	       RadarPoint	*b2,
+	       RadarPoint	*pi)
+{
+  int	dxadyb, dxbdya, dxadxb, dyadyb, p, q;
+
+  dxadyb = (a2->x - a1->x)*(b2->y - b1->y);
+  dxbdya = (b2->x - b1->x)*(a2->y - a1->y);
+  dxadxb = (a2->x - a1->x)*(b2->x - b1->x);
+  dyadyb = (a2->y - a1->y)*(b2->y - b1->y);
+  
+  if (dxadyb == dxbdya) {
+    return False;
+  }
+  
+  p = a1->x*dxbdya - b1->x*dxadyb + (b1->y - a1->y)*dxadxb;
+  q = dxbdya - dxadyb;
+  if (q < 0) {
+    p = -p;
+    q = -q;
+  }
+  if (p < 0) {
+    pi->x = -(-2*p + q)/(2*q); /*-(-p + q/2)/q;*/
+  }
+  else {
+    pi->x = (2*p + q)/(2*q); /*(p + q/2)/q;*/
+  }
+  
+  p = a1->y*dxadyb - b1->y*dxbdya + (b1->x - a1->x)*dyadyb;
+  q = dxadyb - dxbdya;
+  if (q < 0) {
+    p = -p;
+    q = -q;
+  }
+  if (p < 0) {
+    pi->y = -(-2*p + q)/(2*q); /*-(-p + q/2)/q;*/
+  }
+  else {
+    pi->y = (2*p + q)/(2*q); /*(p + q/2)/q;*/
+  }
+  
+  return True;
+}
+
+
+/*
+ * InsetPolygon --
+ *	Inset the given polygon by the given amount. The
+ *     value can be negative, in this case the polygon will
+ *     be outset.
+ */
+/**** A FINIR ****/
+void
+InsetPolygon(RadarPoint	*p,
+	     int	num_points,
+	     RadarDim	inset)
+{
+  RadarPoint	*p1, *p2;
+  RadarPoint	new_p1, new_p2;
+  RadarPoint	shift1, shift2;
+  int		i, processed_points;
+
+  processed_points = 0;
+  
+  if ((p->x == p[num_points-1].x) && (p->y == p[num_points-1].y)) {
+    num_points--;
+  }
+  for (p1 = p, p2 = p1+1, i = 0; i < num_points; i++, p1 = p2, p2++) {
+    /*
+     * Wrap to the first point.
+     */
+    if (i == num_points-1) {
+      p2 = p;
+    }
+    /*
+     * Skip duplicate vertices.
+     */
+    if ((p2->x == p1->x) && (p2->y == p1->y)) {
+      continue;
+    }
+    
+    ShiftLine(p1, p2, inset, &new_p1, &new_p2);
+
+    if (processed_points >= 1) {
+    }
+  }
+}
+
+
+/*
+ * Compute the two corner points of a thick line end.
+ * Two points describing the line segment and the width
+ * are given as input. If projecting is true this function
+ * mimics the X11 line projecting behaviour. The computed
+ * end is located around p2.
+ */
+void
+GetButtPoints(RadarPoint	*p1,
+	      RadarPoint	*p2,
+	      int		width,
+	      RadarBool		projecting,
+	      RadarPoint	*c1,
+	      RadarPoint	*c2)
+{
+  double	w_2 = width/2.0;
+  double	length = hypot(p2->x - p1->x, p2->y - p1->y);
+  double	delta_x, delta_y;
+  
+  if (length == 0.0) {
+    c1->x = c2->x = p2->x;
+    c1->y = c2->y = p2->y;
+  }
+  else {
+    delta_x = -w_2 * (p2->y - p1->y) / length;
+    delta_y = w_2 * (p2->x - p1->x) / length;
+    c1->x = p2->x + delta_x;
+    c2->x = p2->x - delta_x;
+    c1->y = p2->y + delta_y;
+    c2->y = p2->y - delta_y;
+    if (projecting) {
+      c1->x += delta_y;
+      c2->x += delta_y;
+      c1->y -= delta_x;
+      c2->y -= delta_x;
+    }
+  }
+}
+
+/*
+ * Compute the inside and outside points of the mitered
+ * corner formed by a thick line going through 3 points.
+ * If the angle formed by the three points is less than
+ * 11 degrees, False is returned an no points are computed.
+ * Else True is returned and the points are in c1, c2.
+ *
+ * If someday the code is switched to REAL coordinates, we
+ * must round each coordinate to the nearer integer to mimic
+ * the way pixels are drawn. Sample code: floor(p->x+0.5);
+ *
+ * Hmmm, the switch has been done but not the rounding ;-)
+ */
+RadarBool
+GetMiterPoints(RadarPoint	*p1,
+	       RadarPoint	*p2,
+	       RadarPoint	*p3,
+	       int		width,
+	       RadarPoint	*c1,
+	       RadarPoint	*c2)
+{
+  static double	deg11 = (11.0*2.0*M_PI)/360.0;
+  double	theta1;		/* angle of p2-p1 segment. */
+  double	theta2;		/* angle of p2-p3 segment. */
+  double	theta;		/* angle of the joint */
+  double	theta3;		/* angle of bisector of the joint toward
+				 * the external point of the joint. */
+  double	dist;		/* distance of the external points
+				 * of the corner from the mid point
+				 * p2. */
+  double	delta_x, delta_y; /* projection of (dist,theta3) on x
+				   * and y. */
+  
+  if (p2->y == p1->y) {
+    theta1 = (p2->x < p1->x) ? 0.0 : M_PI;
+  }
+  else if (p2->x == p1->x) {
+    theta1 = (p2->y < p1->y) ? M_PI/2.0 : -M_PI/2.0;
+  }
+  else {
+    theta1 = atan2(p1->y - p2->y, p1->x - p2->x);
+  }
+  if (p3->y == p2->y) {
+    theta2 = (p3->x > p2->x) ? 0.0 : M_PI;
+  }
+  else if (p3->x == p2->x) {
+    theta2 = (p3->y > p2->y) ? M_PI/2.0 : -M_PI/2.0;
+  }
+  else {
+    theta2 = atan2(p3->y - p2->y, p3->x - p2->x);
+  }
+  theta = theta1 - theta2;
+  if (theta > M_PI) {
+    theta -= 2.0*M_PI;
+  }
+  else if (theta < -M_PI) {
+    theta += 2*M_PI;
+  }
+  if ((theta < deg11) && (theta > -deg11)) {
+    return False;
+  }
+  /*
+   * Compute the distance of the internal and external
+   * corner points from the intersection p2 (considered
+   * at 0,0).
+   */
+  dist = 0.5*width / sin(0.5*theta);
+  dist = ABS(dist);
+
+  /*
+   * Compute the angle of the bisector of the joint that
+   * goes toward the outside of the joint (the left hand
+   * when looking from p1-p2).
+   */
+  theta3 = (theta1 + theta2)/2.0;
+  if (sin(theta3 - (theta1 + M_PI)) < 0.0) {
+    theta3 += M_PI;
+  }
+  
+  delta_x = dist * cos(theta3);
+  c1->x = p2->x + delta_x;
+  c2->x = p2->x - delta_x;
+  delta_y = dist * sin(theta3);
+  c1->y = p2->y + delta_y;
+  c2->y = p2->y - delta_y;
+  
+  return True;
+}
+
+/*
+ * Tell where a thick polyline is with respect to an area.
+ * Return -1 if the polyline is entirely outside the bbox, 1
+ * if it is entirely inside and 0 otherwise. The joints can
+ * be specified as JoinMiter, JoinRound, JoinBevel. The ends
+ * can be: CapRound, CapButt, CapProjecting.
+ */
+int
+PolylineInBBox(RadarPoint	*points,
+	       int		num_points,
+	       int		width,
+	       int		cap_style,
+	       int		join_style,
+	       RadarBBox	*bbox)
+{
+  int		count, inside = -1;
+  RadarBool	do_miter_as_bevel;
+  RadarPoint	poly[4];
+  
+  /*
+   * If the first point is inside the area, change inside
+   * accordingly.
+   */
+  if ((points[0].x >= bbox->orig.x) && (points[0].x <= bbox->corner.x) &&
+      (points[0].y >= bbox->orig.y) && (points[0].y <= bbox->corner.y)) {
+    inside = 1;
+  }
+
+  /*
+   * Now iterate through all the edges. Compute a polygon for
+   * each and test it against the area. At each vertex an oval
+   * of radius width/2 is also tested to account for round ends
+   * and joints.
+   */
+  do_miter_as_bevel = False;
+  for (count = num_points; count >= 2; count--, points++) {
+
+    /*
+     * Test a circle around the first point if CapRound or
+     * around every joint if JoinRound.
+     */
+    if (((cap_style == CapRound) && (count == num_points)) ||
+	((join_style == JoinRound) && (count != num_points))) {
+      if (OvalInBBox(points, width, width, bbox) != inside) {
+	return 0;
+      }
+    }
+    /*
+     * Build a polygon to represent an edge from the current
+     * point to the next. Special cases for the first and
+     * last edges to implement the line ends.
+     */
+    /*
+     * First vertex of the edge
+     */
+    if (count == num_points) {
+      GetButtPoints(&points[1], points, width,
+		    cap_style == CapProjecting, poly, &poly[1]);
+    }
+    /*
+     * Here we are at a joint starting a new edge. If the
+     * joint is mitered, start by carrying over the points
+     * from the previous edge. Otherwise compute new points
+     * for a butt end.
+     */
+    else if ((join_style == JoinMiter) && !do_miter_as_bevel) {
+      poly[0] = poly[3];
+      poly[1] = poly[2];
+    }
+    else {
+      GetButtPoints(&points[1], points, width, 0, poly, &poly[1]);
+      /*
+       * If the previous joint was beveled (or considered so),
+       * check the polygon that fill the bevel. It has more or
+       * less an X shape, i.e, it's self intersecting. If this
+       * is not ok, it may be necessary to permutte poly[1] &
+       * poly[2].
+       */
+      if ((join_style == JoinBevel) || do_miter_as_bevel) {
+	if (PolygonInBBox(poly, 4, bbox) != inside) {
+	  return 0;
+	}
+	do_miter_as_bevel = False;
+      }
+    }
+
+    /*
+     * Opposite vertex of the edge.
+     */
+    if (count == 2) {
+      GetButtPoints(points, &points[1], width, cap_style == CapProjecting,
+		    &poly[2], &poly[3]);
+    }
+    else if (join_style == JoinMiter) {
+      if (GetMiterPoints(points, &points[1], &points[2], width,
+			 &poly[2], &poly[3]) == False) {
+	do_miter_as_bevel = True;
+	GetButtPoints(points, &points[1], width, 0, &poly[2], &poly[3]);
+      }
+    }
+    else {
+      GetButtPoints(points, &points[1], width, 0, &poly[2], &poly[3]);
+    }
+
+    if (PolygonInBBox(poly, 4, bbox) != inside) {
+      return 0;
+    }
+  }
+
+  /*
+   * Test a circle around the last point if CapRound.
+   */
+  if (cap_style == CapRound) {
+    if (OvalInBBox(points, width, width, bbox) != inside) {
+      return 0;
+    }
+  }
+
+  return inside;
+}
+
+
+/*
+ * Tell where a polygon is with respect to an area.
+ * Return -1 if the polygon is entirely outside the bbox, 1
+ * if it is entirely inside and 0 otherwise.
+ */
+int
+PolygonInBBox(RadarPoint	*points,
+	      int		num_points,
+	      RadarBBox		*bbox)
+{
+  int		inside, count;
+  RadarPoint	*p, *head, *first, *second;
+  RadarBool	closed;
+  
+  p = head = points;
+  closed = True;
+  /*
+   * Check to see if closed. If not adjust num_points and
+   * record this.
+   */
+  if ((points[0].x != points[num_points-1].x) ||
+      (points[0].y != points[num_points-1].y)) {
+    closed = False;
+  }
+
+  /*
+   * Get the status of the first edge.
+   */
+  inside = LineInBBox(&points[0], &points[1], bbox);
+  if (inside == 0) {
+    return 0;
+  }
+  for (count = num_points; count > 0; p++, count--) {
+    first = &p[0];
+    /*
+     * Pretend the polygon is closed if this is not the case.
+     */
+    if (!closed && (count == 1)) {
+      second = head;
+    }
+    else {
+      second = &p[1];
+    }
+    
+    if (LineInBBox(first, second, bbox) != inside) {
+      return 0;
+    }
+  }
+
+  /*
+   * If all the edges are inside the area, the polygon is
+   * inside the area. If all the edges are outside, the polygon
+   * may completely enclose the area. Test if the origin of
+   * the area is inside the polygon to decide this.
+   */
+  if (inside == 1) {
+    return 1;
+  }
+
+  printf("PolygonInBBox, np = %d, x = %g, y = %g, dist = %g\n",
+	 num_points, bbox->orig.x, bbox->orig.y,
+	 PolygonToPointDist(points, num_points, &bbox->orig));
+  if (PolygonToPointDist(points, num_points, &bbox->orig) <= 0.0) {
+    return 0;
+  }
+  
+  return -1;
+}
+
+
+/*
+ * Tell where an oval is with respect to an area.
+ * Return -1 if the oval is entirely outside the bbox, 1
+ * if it is entirely inside and 0 otherwise.
+ */
+int
+OvalInBBox(RadarPoint	*center,
+	   int		width,
+	   int		height,
+	   RadarBBox	*bbox)
+{
+  RadarPoint	origin, corner;
+  int		w_2, h_2;
+  double	delta_x, delta_y;
+  
+  w_2 = (width+1)/2;
+  h_2 = (height+1)/2;
+  
+  origin.x = center->x - w_2;
+  origin.y = center->y - h_2;
+  corner.x = center->x + w_2;
+  corner.y = center->y + h_2;
+
+  /*
+   * This if the oval bbox is completely inside or outside
+   * of the area. Trivial case first.
+   */
+  if ((bbox->orig.x <= origin.x) && (bbox->corner.x >= corner.x) &&
+      (bbox->orig.y <= origin.y) && (bbox->corner.y >= corner.y)) {
+    return 1;
+  }
+  if ((bbox->corner.x < origin.x) || (bbox->orig.x > corner.x) ||
+      (bbox->corner.y < origin.y) || (bbox->orig.y > corner.y)) {
+    return -1;
+  }
+
+  /*
+   * Then test all sides of the area against the oval center.
+   * If the point of a side closest to the center is inside
+   * the oval, then the oval intersects the area.
+   */
+
+  /*
+   * Compute the square of the Y axis distance, reducing
+   * the oval to a unit circle to take into account the
+   * shape factor.
+   */
+  delta_y = bbox->orig.y - center->y;
+  if (delta_y < 0.0) {
+    delta_y = center->y - bbox->corner.y;
+    if (delta_y < 0.0) {
+      delta_y = 0.0;
+    }
+  }
+  delta_y /= h_2;
+  delta_y *= delta_y;
+
+  /*
+   * Test left and then right edges.
+   */
+  delta_x = (bbox->orig.x - center->x) / w_2;
+  delta_x *= delta_x;
+  if ((delta_x + delta_y) <= 1.0) {
+    return 0;
+  }
+  delta_x = (bbox->corner.x - center->x) / w_2;
+  delta_x *= delta_x;
+  if ((delta_x + delta_y) <= 1.0) {
+    return 0;
+  }
+  
+  /*
+   * Compute the square of the X axis distance, reducing
+   * the oval to a unit circle to take into account the
+   * shape factor.
+   */
+  delta_x = bbox->orig.x - center->x;
+  if (delta_x < 0.0) {
+    delta_x = center->x - bbox->corner.x;
+    if (delta_x < 0.0) {
+      delta_x = 0.0;
+    }
+  }
+  delta_x /= w_2;
+  delta_x *= delta_x;
+  
+  /*
+   * Test top and then bottom edges.
+   */
+  delta_y = (bbox->orig.y - center->y) / h_2;
+  delta_y *= delta_y;
+  if ((delta_x + delta_y) <= 1.0) {
+    return 0;
+  }
+  delta_y = (bbox->corner.y - center->y) / h_2;
+  delta_y *= delta_y;
+  if ((delta_x + delta_y) <= 1.0) {
+    return 0;
+  }
+
+  return -1;
+}
+
+
+/*
+ * Tell if a point is in an angular range whose center is 0,0.
+ * The range is specified by a starting angle and an angle extent.
+ * The use of a double here is important, don't change it. In some
+ * case we need to normalize a figure to take care of its shape and
+ * the result needs precision.
+ */
+RadarBool
+PointInAngle(int	start_angle,
+	     int	angle_extent,
+	     RadarPoint	*p)
+{
+  double	point_angle;
+  int		angle_diff;
+
+  if ((p->x == 0) && (p->y == 0)) {
+    point_angle = 0.0;
+  }
+  else {
+    point_angle = -atan2(p->y, p->x) * 180.0 / M_PI;
+  }
+  angle_diff = (REAL_TO_INT(point_angle) - start_angle) % 360;
+  if (angle_diff < 0) {
+    angle_diff += 360;
+  }
+  return ((angle_diff <= angle_extent) ||
+	  ((angle_extent < 0) && ((angle_diff - 360) >= angle_extent)));
+}
+
+
+/*
+ * Return the distance of the given point to the rectangle
+ * described by rect. Return negative values for points in
+ * the rectangle.
+ */
+double
+RectangleToPointDist(RadarBBox	*bbox,
+		     RadarPoint	*p)
+{
+  double	new_dist, dist;
+  RadarPoint	p1, p2;
+
+  p1.x = bbox->orig.x;
+  p1.y = p2.y = bbox->orig.y;
+  p2.x = bbox->corner.x;
+  dist = LineToPointDist(&p1, &p2, p);
+  if (dist == 0.0) {
+    return 0.0;
+  }
+
+  p1 = p2;
+  p2.y = bbox->corner.y;
+  new_dist = LineToPointDist(&p1, &p2, p);
+  dist = MIN(dist, new_dist);
+  if (dist == 0.0) {
+    return 0.0;
+  }
+
+  p1 = p2;
+  p2.x = bbox->orig.x;
+  new_dist = LineToPointDist(&p1, &p2, p);
+  dist = MIN(dist, new_dist);
+  if (dist == 0.0) {
+    return 0.0;
+  }
+  
+  p1 = p2;
+  p2.y = bbox->orig.y;
+  new_dist = LineToPointDist(&p1, &p2, p);
+  dist = MIN(dist, new_dist);
+
+  if (PointInBBox(bbox, p->x, p->y)) {
+    return -dist;
+  }
+  else {
+    return dist;
+  }
+}
+
+
+/*
+ * Return the distance of the given point to the line
+ * described by <xl1,yl1>, <xl2,yl2>..
+ */
+double
+LineToPointDist(RadarPoint	*p1,
+		RadarPoint	*p2,
+		RadarPoint	*p)
+{
+  double	x, y;
+  int		x_int, y_int;
+
+  /*
+   * First compute the closest point on the line. This is done
+   * separately for vertical, horizontal, other lines.
+   */
+
+  /* Vertical */
+  if (p1->x == p2->x) {
+    x = p1->x;
+    if (p1->y >= p2->y) {
+      y_int = MIN(p1->y, p->y);
+      y_int = MAX(y_int, p2->y);
+    }
+    else {
+      y_int = MIN(p2->y, p->y);
+      y_int = MAX(y_int, p1->y);
+    }
+    y = y_int;
+  }
+
+  /* Horizontal */
+  else if (p1->y == p2->y) {
+    y = p1->y;
+    if (p1->x >= p2->x) {
+      x_int = MIN(p1->x, p->x);
+      x_int = MAX(x_int, p2->x);
+    }
+    else {
+      x_int = MIN(p2->x, p->x);
+      x_int = MAX(x_int, p1->x);
+    }
+    x = x_int;
+  }
+
+  /*
+   * Other. Compute its parameters of form y = a1*x + b1 and
+   * then compute the parameters of the perpendicular passing
+   * through the point y = a2*x + b2, last find the closest point
+   * on the segment.
+   */
+  else {
+    double	a1, a2, b1, b2;
+
+    a1 = ((double) (p2->y - p1->y)) / ((double) (p2->x - p1->x));
+    b1 = p1->y - a1*p1->x;
+
+    a2 = -1.0/a1;
+    b2 = p->y - a2*p->x;
+
+    x = (b2 - b1) / (a1 - a2);
+    y = a1*x + b1;
+
+    if (p1->x > p2->x) {
+      if (x > p1->x) {
+	x = p1->x;
+	y = p1->y;
+      }
+      else if (x < p2->x) {
+	x = p2->x;
+	y = p2->y;
+      }
+    }
+    else {
+      if (x > p2->x) {
+	x = p2->x;
+	y = p2->y;
+      }
+      else if (x < p1->x) {
+	x = p1->x;
+	y = p1->y;
+      }
+    }
+  }
+
+  /* Return the distance */
+  return hypot(p->x - x, p->y - y);
+}
+
+
+/*
+ * Return the distance of the polygon described by
+ * points, to the given point. If the point is
+ * inside return values are negative.
+ */
+double
+PolygonToPointDist(RadarPoint	*points,
+		   int		num_points,
+		   RadarPoint	*p)
+{
+  double	best_distance;
+  int		intersections;
+  int		x_int, y_int;
+  RadarPoint	*first_point;
+  double	x, y, dist;
+  RadarPoint	p1, p2;
+
+  /*
+   * The algorithm iterates through all the edges of the polygon
+   * computing for each the distance to the point and whether a vertical
+   * ray starting at the point, intersects the edge. The smallest
+   * distance of all edges is stored in best_distance while intersections
+   * hold the count of edges to rays intersections. For more informations
+   * on how the distance is computed see LineToPointDist.
+   */
+  best_distance = 1.0e40;
+  intersections = 0;
+
+  first_point = points;
+
+  /*
+   * Check to see if closed. Adjust num_points to open it (the
+   * algorithm always consider a set of points as a closed polygon).
+   */
+  if ((points[0].x == points[num_points-1].x) &&
+      (points[0].y == points[num_points-1].y)) {
+    num_points--;
+  }
+
+  for ( ; num_points >= 1; num_points--, points++) {
+    p1 = points[0];
+    /*
+     * Wrap over to the first point.
+     */
+    if (num_points == 1) {
+      p2 = *first_point;
+    }
+    else {
+      p2 = points[1];
+    }
+    
+    /*
+     * First try to find the closest point on this edge.
+     */
+
+    /* Vertical edge */
+    if (p1.x == p2.x) {
+      x = p1.x;
+      if (p1.y >= p2.y) {
+	y_int = MIN(p1.y, p->y);
+	y_int = MAX(y_int, p2.y);
+      }
+      else {
+	y_int = MIN(p2.y, p->y);
+	y_int = MAX(y_int, p1.y);
+      }
+      y = y_int;
+    }
+
+    /* Horizontal edge */
+    else if (p1.y == p2.y) {
+      y = p1.y;
+      if (p1.x >= p2.x) {
+	x_int = MIN(p1.x, p->x);
+	x_int = MAX(x_int, p2.x);
+	if ((p->y < y) && (p->x < p1.x) && (p->x >= p2.x)) {
+	  intersections++;
+	}
+      }
+      else {
+	x_int = MIN(p2.x, p->x);
+	x_int = MAX(x_int, p1.x);
+	if ((p->y < y) && (p->x < p2.x) && (p->x >= p1.x)) {
+	  intersections++;
+	}
+      }
+      x = x_int;
+    }
+
+    /* Other */
+    else {
+      double	a1, b1, a2, b2;
+
+      a1 = ((double) (p2.y - p1.y)) / ((double) (p2.x - p1.x));
+      b1 = p1.y - a1 * p1.x;
+
+      a2 = -1.0/a1;
+      b2 = p->y - a2 * p->x;
+
+      x = (b2 - b1)/(a1 - a2);
+      y = a1 * x + b1; 
+
+      if (p1.x > p2.x) {
+	if (x > p1.x) {
+	  x = p1.x;
+	  y = p1.y;
+	}
+	else if (x < p2.x) {
+	  x = p2.x;
+	  y = p2.y;
+	}
+      }
+      else {
+	if (x > p2.x) {
+	  x = p2.x;
+	  y = p2.y;
+	}
+	else if (x < p1.x) {
+	  x = p1.x;
+	  y = p1.y;
+	}
+      }
+
+      if (((a1 * p->x + b1) > p->y) &&	/* True if point is lower */
+	  (p->x >= MIN(p1.x, p2.x)) &&
+	  (p->x < MAX(p1.x, p2.x))) {
+	intersections++;
+      }
+    }
+
+    /*
+     * Now compute the distance to the closest point and
+     * keep it if it is the shortest.
+     */
+    dist = hypot(p->x - x, p->y - y);
+    best_distance = MIN(best_distance, dist);
+    /*
+     * We can safely escape here if distance is zero.
+     */
+    if (best_distance == 0.0) {
+      return 0.0;
+    }
+  }
+
+  /*
+   * Well, all the edges are processed, if the
+   * intersection count is odd the point is inside.
+   */
+  if (intersections & 0x1) {
+    return -best_distance;
+  }
+  else {
+    return best_distance;
+  }
+}
+
+
+/*
+ * Return the distance of a thick polyline to the
+ * given point. Cap and Join parameters are considered
+ * in the process.
+ */
+double
+PolylineToPointDist(RadarPoint	*points,
+		    int		num_points,
+		    int		width,
+		    int		cap_style,
+		    int		join_style,		   
+		    RadarPoint	*p)
+{
+  RadarBool	miter2bevel = False;
+  int		count;
+  RadarPoint	*ptr;
+  RadarPoint	outline[5];
+  double	dist, best_dist, h_width;
+
+  best_dist = 1.0e36;
+  h_width = width/2.0;
+
+  for (count = num_points, ptr = points; count >= 2; count--, ptr++) {
+    if (((cap_style == CapRound) && (count == num_points)) ||
+	((join_style == JoinRound) && (count != num_points))) {
+      dist = hypot(ptr->x - p->x, ptr->y - p->y) - h_width;
+      if (dist <= 0.0) {
+	best_dist = 0.0;
+	goto done;
+      }
+      else if (dist < best_dist) {
+	best_dist = dist;
+      }
+    }
+    /*
+     * Build the polygonal outline of the current edge.
+     */
+    if (count == num_points) {
+      GetButtPoints(&ptr[1], ptr, width, cap_style==CapProjecting, outline, &outline[1]);
+    }
+    else if ((join_style == JoinMiter) && !miter2bevel) {
+      outline[0] = outline[3];
+      outline[1] = outline[2];
+    }
+    else {
+      GetButtPoints(&ptr[1], ptr, width, 0, outline, &outline[1]);
+      /*
+       * If joints are beveled, check the distance to the polygon
+       * that fills the joint.
+       */
+      if ((join_style == JoinBevel) || miter2bevel) {
+	outline[4] = outline[0];
+	dist = PolygonToPointDist(outline, 5, p);
+	if (dist <= 0.0) {
+	  best_dist = 0.0;
+	  goto done;
+	}
+	else if (dist < best_dist) {
+	  best_dist = dist;
+	}
+	miter2bevel = False;
+      }
+    }
+    if (count == 2) {
+      GetButtPoints(ptr, &ptr[1], width, cap_style==CapProjecting,
+		    &outline[2], &outline[3]);
+    }
+    else if (join_style == JoinMiter) {
+      if (GetMiterPoints(ptr, &ptr[1], &ptr[2], width,
+			 &outline[2], &outline[3]) == False) {
+	miter2bevel = True;
+	GetButtPoints(ptr, &ptr[1], width, 0, &outline[2], &outline[3]);
+      }
+      /*printf("2=%g+%g, 3=%g+%g\n",
+	outline[2].x, outline[2].y, outline[3].x, outline[3].y);*/
+    }
+    else {
+      GetButtPoints(ptr, &ptr[1], width, 0, &outline[2], &outline[3]);
+    }
+    outline[4] = outline[0];
+    /*printf("0=%g+%g, 1=%g+%g, 2=%g+%g, 3=%g+%g, 4=%g+%g\n",
+	   outline[0].x, outline[0].y, outline[1].x, outline[1].y,
+	   outline[2].x, outline[2].y, outline[3].x, outline[3].y,
+	   outline[4].x, outline[4].y);*/
+    dist = PolygonToPointDist(outline, 5, p);
+    if (dist <= 0.0) {
+      best_dist = 0.0;
+      goto done;
+    }
+    else if (dist < best_dist) {
+      best_dist = dist;
+    }
+  }
+
+  /*
+   * Test the final point if cap style is round. The code so far
+   * has only handled the butt and projecting cases.
+   */
+  if (cap_style == CapRound) {
+    dist = hypot(ptr->x - p->x, ptr->y - p->y) - h_width;
+    if (dist <= 0.0) {
+      best_dist = 0.0;
+      goto done;
+    }
+    else if (dist < best_dist) {
+      best_dist = dist;
+    }
+  }
+  
+ done:
+  return best_dist;
+}
+
+
+/*
+ * Return the distance of the given oval to the point given.
+ * The oval is described by its bounding box <xbb,ybb,wbb,hbb>,
+ * the thickness of its outline <width>. Return values are negative
+ * if the point is inside.
+ */
+double
+OvalToPointDist(RadarPoint	*center,
+		int		width,
+		int		height,
+		unsigned int	line_width,
+		RadarPoint	*p)
+{
+  double	x_delta, y_delta;
+  /*  double	x_diameter, y_diameter;*/
+  double	scaled_distance;
+  double	distance_to_outline;
+  double	distance_to_center;
+
+  /*
+   * Compute the distance from the point given to the center
+   * of the oval. Then compute the same distance in a coordinate
+   * system where the oval is a circle with unit radius.
+   */
+
+  x_delta = p->x - center->x;
+  y_delta = p->y - center->y;
+  distance_to_center = hypot(x_delta, y_delta);
+  scaled_distance = hypot(x_delta / ((width + line_width) / 2.0),
+			  y_delta / ((height + line_width) / 2.0));
+
+  /*
+   * If the scaled distance is greater than 1.0 the point is outside
+   * the oval. Compute the distance to the edge and convert it back
+   * to the original coordinate system. This distance is not much
+   * accurate and can overestimate the real distance if the oval is
+   * very eccentric.
+   */
+  if (scaled_distance > 1.0) {
+    distance_to_outline = (distance_to_center / scaled_distance) * (scaled_distance - 1.0);
+    return distance_to_outline;
+  }
+
+  /*
+   * The point is inside the oval. Compute the distance as above and check
+   * if the point is within the outline.
+   */
+  if (scaled_distance > 1.0e-10) {
+    distance_to_outline = (distance_to_center / scaled_distance) * (1.0 - scaled_distance) - line_width;
+  }
+  else {
+    /*
+     * If the point is very close to the center avoid dividing by a
+     * very small number, take another method.
+     */
+    if (width < height)
+      distance_to_outline = ((double) (width - line_width)) / 2;
+    else
+      distance_to_outline = ((double) (height - line_width)) / 2;
+  }
+
+  if (distance_to_outline < 0.0)
+    return 0.0;
+  else
+    return -distance_to_outline;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * GetBezierPoints --
+ *	Use recursive subdivision to approximate the curve. The subdivision stops
+ *	when the error is under eps.
+ *	This algorithm is adaptive, meaning that it computes the minimum number
+ *	of segments needed to render each curve part.
+ *
+ **********************************************************************************
+ */
+static void
+GetBezierPoints(RadarPoint	*controls,
+		RadarList	to_points,
+		double		eps)
+{
+  RadarReal	dist2;
+  RadarPoint	mid_segm, mid_cord, delta;
+
+  /*
+   * Compute distance between cord center and curve at t = 0.5
+   */
+  mid_segm.x = (controls[0].x + 3*controls[1].x + 3*controls[2].x + controls[3].x) / 8.0;
+  mid_segm.y = (controls[0].y + 3*controls[1].y + 3*controls[2].y + controls[3].y) / 8.0;
+  mid_cord.x = (controls[0].x + controls[3].x) / 2.0;
+  mid_cord.y = (controls[0].y + controls[3].y) / 2.0;
+  delta.x = mid_segm.x - mid_cord.x;
+  delta.y = mid_segm.y - mid_cord.y;
+  dist2 = delta.x*delta.x + delta.y*delta.y;
+  
+  if (dist2 > eps) {
+    RadarPoint	new_controls[4];
+    /*
+     * Subdivide the curve at t = 0.5
+     * and compute each new curve.
+     */
+    new_controls[0] = controls[0];
+    new_controls[1].x = (controls[0].x + controls[1].x) / 2.0;
+    new_controls[1].y = (controls[0].y + controls[1].y) / 2.0;
+    new_controls[2].x = (controls[0].x + 2*controls[1].x + controls[2].x) / 4.0;
+    new_controls[2].y = (controls[0].y + 2*controls[1].y + controls[2].y) / 4.0;
+    new_controls[3] = mid_segm;
+    GetBezierPoints(new_controls, to_points, eps);
+    
+    new_controls[0] = mid_segm;
+    new_controls[1].x = (controls[1].x + 2*controls[2].x + controls[3].x) / 4.0;
+    new_controls[1].y = (controls[1].y + 2*controls[2].y + controls[3].y) / 4.0;
+    new_controls[2].x = (controls[2].x + (controls[3].x)) / 2.0;
+    new_controls[2].y = (controls[2].y + (controls[3].y)) / 2.0;
+    new_controls[3] = controls[3];
+    GetBezierPoints(new_controls, to_points, eps);
+  }
+  else {
+    /*
+     * Flat enough add the end to the current path.
+     * The start should already be there.
+     */
+    RadarListAdd(to_points, &controls[3], RadarListTail);
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * GetBezierPath --
+ *	Compute in to_points a new set of points describing a Bezier path based
+ *	on the control points given in from_points.
+ *	If more than four points are given, the algorithm iterate over the
+ *	set using the last point of a segment as the first point of the next.
+ *	If 3 points are left, they are interpreted as a Bezier segment with
+ *	coincident internal control points. If 2 points are left a straight
+ *	is emitted.
+ *
+ **********************************************************************************
+ */
+void
+GetBezierPath(RadarList	from_points,
+	      RadarList	to_points)
+{
+  RadarPoint	*fp;
+  int		num_fp, i;
+  RadarPoint	s[4];
+  
+  fp = (RadarPoint *) RadarListArray(from_points);
+  num_fp = RadarListSize(from_points);
+
+  /*
+   * make sure the output vector is empty, then add the first point.
+   */
+  RadarListEmpty(to_points);
+  RadarListAdd(to_points, &fp[0], RadarListTail);
+
+  for (i = 0; i < num_fp; ) {
+    if (i < (num_fp-3)) {
+      GetBezierPoints(fp, to_points, 1.0);
+      fp += 3;
+      i += 3;
+    }
+    else if (i == (num_fp-3)) {
+      s[0] = fp[0];
+      s[1] = s[2] = fp[1];
+      s[3] = fp[2];
+      GetBezierPoints(s, to_points, 1.0);
+      break;
+    }
+    else if (i == (num_fp-2)) {
+      RadarListAdd(to_points, &fp[1], RadarListTail);
+      break;
+    }
+  }
+}
+
+/*
+ **********************************************************************************
+ *
+ * SmoothPathWithBezier --
+ *	Compute in to_points a new set of points describing a smoothed path based
+ *	on the path given in from_points. The algorithm use Bezier cubic curves.
+ *
+ **********************************************************************************
+ */
+void
+SmoothPathWithBezier(RadarList	from_points,
+		     RadarList	to_points)
+{
+  RadarPoint		*fp;
+  int			num_fp;
+  RadarBool		closed;
+  RadarPoint		s[4];
+  int			i;
+
+  fp = (RadarPoint *) RadarListArray(from_points);
+  num_fp = RadarListSize(from_points);
+
+  /*
+   * make sure the output vector is empty
+   */
+  RadarListEmpty(to_points);
+
+  /*
+   * If the curve is closed, generates a Bezier curve that
+   * spans the closure. Else simply add the first point to
+   * the path.
+   */
+  if ((fp[0].x == fp[num_fp-1].x) && (fp[0].y == fp[num_fp-1].y)) {
+    closed = True;
+    s[0].x = REAL_TO_INT(0.5*fp[num_fp-2].x + 0.5*fp[0].x);
+    s[0].y = REAL_TO_INT(0.5*fp[num_fp-2].y + 0.5*fp[0].y);
+    s[1].x = REAL_TO_INT(0.167*fp[num_fp-2].x + 0.833*fp[0].x);
+    s[1].y = REAL_TO_INT(0.167*fp[num_fp-2].y + 0.833*fp[0].y);
+    s[2].x = REAL_TO_INT(0.833*fp[0].x + 0.167*fp[1].x);
+    s[2].y = REAL_TO_INT(0.833*fp[0].y + 0.167*fp[1].y);
+    s[3].x = REAL_TO_INT(0.5*fp[0].x + 0.5*fp[1].x);
+    s[3].y = REAL_TO_INT(0.5*fp[0].y + 0.5*fp[1].y);
+    RadarListAdd(to_points, s, RadarListTail);
+    GetBezierPoints(s, to_points, 1.0);
+  }
+  else {
+    closed = False;
+    RadarListAdd(to_points, &fp[0], RadarListTail);
+  }
+
+  for (i = 2; i < num_fp; i++, fp++) {
+    /*
+     * Setup the first two control points. This differ
+     * for first segment of open curves.
+     */
+    if ((i == 2) && !closed) {
+      s[0] = fp[0];
+      s[1].x = REAL_TO_INT(0.333*fp[0].x + 0.667*fp[1].x);
+      s[1].y = REAL_TO_INT(0.333*fp[0].y + 0.667*fp[1].y);
+    }
+    else {
+      s[0].x = REAL_TO_INT(0.5*fp[0].x + 0.5*fp[1].x);
+      s[0].y = REAL_TO_INT(0.5*fp[0].y + 0.5*fp[1].y);
+      s[1].x = REAL_TO_INT(0.167*fp[0].x + 0.833*fp[1].x);
+      s[1].y = REAL_TO_INT(0.167*fp[0].y + 0.833*fp[1].y);
+    }
+
+    /*
+     * Setup the last two control points. This also differ
+     * for last segment of open curves.
+     */
+    if ((i == num_fp-1) && !closed) {
+      s[2].x = REAL_TO_INT(0.667*fp[1].x + 0.333*fp[2].x);
+      s[2].y = REAL_TO_INT(0.667*fp[1].y + 0.333*fp[2].y);
+      s[3] = fp[2];
+    }
+    else {
+      s[2].x = REAL_TO_INT(0.833*fp[1].x + 0.167*fp[2].x);
+      s[2].y = REAL_TO_INT(0.833*fp[1].y + 0.167*fp[2].y);
+      s[3].x = REAL_TO_INT(0.5*fp[1].x + 0.5*fp[2].x);
+      s[3].y = REAL_TO_INT(0.5*fp[1].y + 0.5*fp[2].y);
+    }
+
+    /*
+     * If the first two points or the last two are equal
+     * output the last control point. Else generate the
+     * Bezier curve.
+     */
+    if (((fp[0].x == fp[1].x) && (fp[0].y == fp[1].y)) ||
+	((fp[1].x == fp[2].x) && (fp[1].y == fp[2].y))) {
+      RadarListAdd(to_points, &s[3], RadarListTail);
+    }
+    else {
+      GetBezierPoints(s, to_points, 1.0);
+    }
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * GetLineEnd --
+ *	Compute the points describing the given line end style at point p1 for
+ *	the line p1,p2. Point p1 is adjusted to fit the line end.
+ *	If bbox is non null, it is filled with the bounding box of the end.
+ *
+ * For the time being this procedure handles open/filled arrows.
+ *
+ * Here are the parameters describing arrows.
+ *
+ *              *  | ARROW_SHAPE_C
+ *            **   |
+ *          * ***************************
+ *        *  *
+ *      *   *  +p1                      +p2
+ *      | * |*
+ *      |   * ***************************
+ *      |   | **
+ *      |   |   *
+ *      |   |   |
+ *      |---|   | ARROW_SHAPE_A
+ *      |       |
+ *      |-------| ARROW_SHAPE_B
+ *
+ **********************************************************************************
+ */
+void
+GetLineEnd(RadarPoint	*p1,
+	   RadarPoint	*p2,
+	   unsigned int	line_width,
+	   int		cap_style,
+	   LineEnd	end_style,
+	   RadarPoint	*points)
+{
+  RadarReal	dx, dy, length, temp, backup;
+  RadarReal	frac_height, sin_theta, cos_theta;
+  RadarReal	vert_x, vert_y;
+  RadarReal	shape_a, shape_b, shape_c;
+  
+  if (end_style != NULL) {
+    shape_a = end_style->shape_a + 0.001;
+    shape_b = end_style->shape_b + 0.001;
+    shape_c = end_style->shape_c + line_width/2.0 + 0.001;
+
+    frac_height = (line_width/2.0) / shape_c;
+    dx = p1->x - p2->x;
+    dy = p1->y - p2->y;
+    length = hypot(dx, dy);
+    if (length == 0) {
+      sin_theta = cos_theta = 0.0;
+    }
+    else {
+      sin_theta = dy/length;
+      cos_theta = dx/length;
+    }
+
+    if (cap_style != CapProjecting) {
+      temp = frac_height;
+    }
+    else {
+      temp = line_width / shape_c;
+    }
+    backup = temp * shape_b + shape_a * (1.0 - temp) / 2.0;
+    points[0].x = points[5].x = p1->x + backup * cos_theta;
+    points[0].y = points[5].y = p1->y + backup * sin_theta;
+    
+    vert_x = points[0].x - shape_a*cos_theta;
+    vert_y = points[0].y - shape_a*sin_theta;
+    temp = shape_c*sin_theta;
+    points[1].x = REAL_TO_INT(points[0].x - shape_b*cos_theta + temp);
+    points[4].x = REAL_TO_INT(points[1].x - 2*temp);
+    temp = shape_c*cos_theta;
+    points[1].y = REAL_TO_INT(points[0].y - shape_b*sin_theta - temp);
+    points[4].y = REAL_TO_INT(points[1].y + 2*temp);
+    points[2].x = REAL_TO_INT(points[1].x*frac_height + vert_x*(1.0-frac_height));
+    points[2].y = REAL_TO_INT(points[1].y*frac_height + vert_y*(1.0-frac_height));
+    points[3].x = REAL_TO_INT(points[4].x*frac_height + vert_x*(1.0-frac_height));
+    points[3].y = REAL_TO_INT(points[4].y*frac_height + vert_y*(1.0-frac_height));
+  }
+}