render.cpp revision 6b15695578f07a3f72c4c9475c1a261a3021472a
/* Copyright (C) 2001-2005 Peter Selinger.
This file is part of potrace. It is free software and it is covered
by the GNU General Public License. See the file COPYING for details. */
/* $Id$ */
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "render.h"
#include "auxiliary.h"
/* ---------------------------------------------------------------------- */
/* routines for anti-aliased rendering of curves */
/* we use the following method. Given a point (x,y) (with real-valued
coordinates) in the plane, let (xi,yi) be the integer part of the
coordinates, i.e., xi=floor(x), yi=floor(y). Define a path from
(x,y) to infinity as follows: path(x,y) =
(x,y)--(xi+1,y)--(xi+1,yi)--(+infty,yi). Now as the point (x,y)
moves smoothly across the plane, the path path(x,y) sweeps
(non-smoothly) across a certain area. We proportionately blacken
the area as the path moves "downward", and we whiten the area as
the path moves "upward". This way, after the point has traversed a
closed curve, the interior of the curve has been darkened
(counterclockwise movement) or lightened (clockwise movement). (The
"grey shift" is actually proportional to the winding number). By
choosing the above path with mostly integer coordinates, we achieve
that only pixels close to (x,y) receive grey values and are subject
to round-off errors. The grey value of pixels far away from (x,y)
is always in "integer" (where 0=black, 1=white). As a special
trick, we keep an accumulator rm->a1, which holds a double value to
be added to the grey value to be added to the current pixel
(xi,yi). Only when changing "current" pixels, we convert this
double value to an integer. This way we avoid round-off errors at
the meeting points of line segments. Another speedup measure is
that we sometimes use the rm->incrow_buf array to postpone
incrementing or decrementing an entire row. If incrow_buf[y]=x+1!=0,
then all the pixels (x,y),(x+1,y),(x+2,y),... are scheduled to be
incremented/decremented (which one is the case will be clear from
context). This keeps the greymap operations reasonably local. */
/* allocate a new rendering state */
if (!rm) {
return NULL;
}
if (!rm->incrow_buf) {
return NULL;
}
return rm;
}
/* free a given rendering state. Note: this does not free the
underlying greymap. */
}
/* close path */
}
/* assert (rm->x0i != rm->x1i || rm->y0i != rm->y1i); */
/* the persistent state is now undefined */
}
/* move point */
/* close the previous path */
}
/* add b to pixels (x,y) and all pixels to the right of it. However,
use rm->incrow_buf as a buffer to economize on multiple calls */
int i, x0;
return;
}
if (x < 0) {
x = 0;
}
if (rm->incrow_buf[y] == 0) {
return;
}
rm->incrow_buf[y] = 0;
if (x0 < x) {
for (i=x0; i<x; i++) {
}
} else {
for (i=x; i<x0; i++) {
}
}
}
/* render a straight line */
int i, j;
int s;
if (sn) {
}
if (tn) {
}
r0 = 0;
i = 0;
j = 0;
i++;
s = 1;
} else {
j++;
s = 0;
}
/* render line from r0 to r1 segment of (rm->x1,rm->y1)..(x2,y2) */
/* move point to r1 */
/* move point across pixel boundary */
rxi++;
ryi++;
rxi--;
ryi--;
}
}
/* move point to (x2,y2) */
r1 = 1;
/* assert (rxi != rm->x1i || ryi != rm->y1i); */
}
/* render a Bezier curve. */
void render_curveto(render_t *rm, double x2, double y2, double x3, double y3, double x4, double y4) {
/* we approximate the curve by small line segments. The interval
size, epsilon, is determined on the fly so that the distance
between the true curve and its approximation does not exceed the
desired accuracy delta. */
/* let dd = maximal value of 2nd derivative over curve - this must
occur at an endpoint. */
}
}