{
linedraw_internal_t*i = (linedraw_internal_t*)d->internal;
gfxline_t*l = rfx_alloc(sizeof(gfxline_t));
+
+ if(!i->start) {
+ /* starts with a line, not with a moveto. That needs we first
+ need an explicit moveto to (0,0) */
+ linedraw_moveTo(d, 0, 0);
+ }
+
l->type = gfx_lineTo;
d->x = l->x = x;
d->y = l->y = y;
+
l->next = 0;
if(i->next)
i->next->next = l;
{
linedraw_internal_t*i = (linedraw_internal_t*)d->internal;
gfxline_t*l = rfx_alloc(sizeof(gfxline_t));
+
+ if(!i->start) {
+ /* starts with a line, not with a moveto. That needs we first
+ need an explicit moveto to (0,0) */
+ linedraw_moveTo(d, 0, 0);
+ }
+
l->type = gfx_splineTo;
d->x = l->x = x;
d->y = l->y = y;
void gfxdrawer_target_gfxline(gfxdrawer_t*d)
{
linedraw_internal_t*i = (linedraw_internal_t*)rfx_calloc(sizeof(linedraw_internal_t));
+ d->x = 0x7fffffff;
+ d->y = 0x7fffffff;
d->internal = i;
d->moveTo = linedraw_moveTo;
d->lineTo = linedraw_lineTo;
}
}
+gfxline_t * gfxline_clone(gfxline_t*line)
+{
+ gfxline_t*dest = 0;
+ gfxline_t*pos = 0;
+ while(line) {
+ gfxline_t*n = rfx_calloc(sizeof(gfxline_t));
+ *n = *line;
+ n->next = 0;
+ if(!pos) {
+ dest = pos = n;
+ } else {
+ pos->next = n;
+ pos = n;
+ }
+ line = line->next;
+ }
+ return dest;
+}
+
gfxline_t* gfxtool_dash_line(gfxline_t*line, float*dashes, float phase)
{
gfxdrawer_t d;
void gfxline_show(gfxline_t*l, FILE*fi)
{
while(l) {
- if(l->type == moveTo) {
+ if(l->type == gfx_moveTo) {
fprintf(fi, "moveTo %.2f,%.2f\n", l->x, l->y);
}
- if(l->type == lineTo) {
+ if(l->type == gfx_lineTo) {
fprintf(fi, "lineTo %.2f,%.2f\n", l->x, l->y);
}
- if(l->type == splineTo) {
+ if(l->type == gfx_splineTo) {
fprintf(fi, "splineTo %.2f,%.2f %.2f,%.2f\n", l->sx, l->sy, l->x, l->y);
}
l = l->next;
test.control.y += test.end.y;
}
-#define PROBES
+//#define PROBES
#ifdef PROBES
/* measure the spline's accurancy, by taking a number of probes */
for(t=0;t<probes;t++) {
/* convert control point representation to
d*x^3 + c*x^2 + b*x + a */
-
- /* FIXME: we need to do this for the subspline between [start,end],
- not [0,1] */
dx= s->end.x - s->control2.x*3 + s->control1.x*3 - s->start.x;
dy= s->end.y - s->control2.y*3 + s->control1.y*3 - s->start.y;
+ /* we need to do this for the subspline between [start,end], not [0,1]
+ as a transformation of t->a*t+b does nothing to highest coefficient
+ of the spline except multiply it with a^3, we just need to modify
+ d here. */
+ {double m = end-start;
+ dx*=m*m*m;
+ dy*=m*m*m;
+ }
+
/* use the integral over (f(x)-g(x))^2 between 0 and 1
to measure the approximation quality.
- (it boils down to const*d^2)
- */
+ (it boils down to const*d^2) */
recurse = (dx*dx + dy*dy > quality2);
#endif
return num;
}
-void gfxdraw_conicTo(gfxdrawer_t*draw, double cx, double cy, double tox, double toy)
+void gfxdraw_conicTo(gfxdrawer_t*draw, double cx, double cy, double tox, double toy, double quality)
{
double c1x = (draw->x + 2 * cx) / 3;
double c1y = (draw->y + 2 * cy) / 3;
double c2x = (2 * cx + tox) / 3;
double c2y = (2 * cy + toy) / 3;
- gfxdraw_cubicTo(draw, c1x, c1y, c2x, c2y, tox, toy);
+ gfxdraw_cubicTo(draw, c1x, c1y, c2x, c2y, tox, toy, quality);
}
-void gfxdraw_cubicTo(gfxdrawer_t*draw, double c1x, double c1y, double c2x, double c2y, double x, double y)
+void gfxdraw_cubicTo(gfxdrawer_t*draw, double c1x, double c1y, double c2x, double c2y, double x, double y, double quality)
{
qspline_t q[128];
cspline_t c;
- double maxerror = 0.04;
+ double maxerror = quality>0 ? quality : 1.0;
int t,num;
c.start.x = draw->x;
c.end.x = x;
c.end.y = y;
- num = approximate3(&c, q, 128, maxerror*maxerror);
+ num = approximate3(&c, q, 128, maxerror);
for(t=0;t<num;t++) {
gfxpoint_t mid;
}
}
-void gfxline_append(gfxline_t*line1, gfxline_t*line2)
+gfxline_t* gfxline_append(gfxline_t*line1, gfxline_t*line2)
+{
+ gfxline_t*l = line1;;
+ if(!l)
+ return line2;
+ while(l->next) {
+ l = l->next;
+ }
+ l->next = line2;
+ return line1;
+}
+
+void gfxline_transform(gfxline_t*line, gfxmatrix_t*matrix)
{
- while(line1) {
- line1 = line1->next;
+ while(line) {
+ double x = matrix->m00*line->x + matrix->m10*line->y + matrix->tx;
+ double y = matrix->m01*line->x + matrix->m11*line->y + matrix->ty;
+ line->x = x;
+ line->y = y;
+ if(line->type == gfx_splineTo) {
+ double sx = matrix->m00*line->sx + matrix->m10*line->sy + matrix->tx;
+ double sy = matrix->m01*line->sx + matrix->m11*line->sy + matrix->ty;
+ line->sx = sx;
+ line->sy = sy;
+ }
+ line = line->next;
}
- line1->next = line2;
+}
+
+void gfxmatrix_dump(gfxmatrix_t*m, FILE*fi, char*prefix)
+{
+ fprintf(fi, "%f %f | %f\n", m->m00, m->m10, m->tx);
+ fprintf(fi, "%f %f | %f\n", m->m01, m->m11, m->ty);
}