gecko-dev/other-licenses/libart_lgpl/testart.c
alex.fritze%crocodile-clips.com 5c676d4a47 Landing of SVG_20020806_BRANCH, Bug 182533. Refactoring of SVG backend, new GDI+ and Libart rendering
backends, text support on Windows (GDI+), rudimentary text support on Linux (libart/freetype2), presentation
attributes, lots of bug fixes (see bug 182533 for dependency list).

Not part of default build; code is #ifdef'ed out.

r=sicking, sr=jst for dom and htmlparser changes
r=bsmedberg, sr=tor for config changes
r=dbaron, sr=bzbarsky for content and layout changes
r=tor, sr=bzbarsky for gfx changes
2004-02-07 12:39:26 +00:00

635 lines
14 KiB
C

/* Libart_LGPL - library of basic graphic primitives
* Copyright (C) 1998, 1999 Raph Levien
*
* This library 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 library 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 library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "art_misc.h"
#include "art_vpath.h"
#include "art_svp.h"
#include "art_svp_vpath.h"
#include "art_gray_svp.h"
#include "art_rgb_svp.h"
#include "art_svp_vpath_stroke.h"
#include "art_svp_ops.h"
#include "art_affine.h"
#include "art_rgb_affine.h"
#include "art_rgb_bitmap_affine.h"
#include "art_rgb_rgba_affine.h"
#include "art_alphagamma.h"
#include "art_svp_point.h"
#include "art_vpath_dash.h"
#include "art_render.h"
#include "art_render_gradient.h"
#include "art_render_svp.h"
#include "art_svp_intersect.h"
#ifdef DEAD_CODE
static void
test_affine (void) {
double src[6];
double dst[6];
double src2[6];
char str[128];
int i;
ArtPoint ps, pd, ptmp;
for (i = 0; i < 6; i++)
{
src[i] = (rand () * 2.0 / RAND_MAX) - 1.0;
src2[i] = (rand () * 2.0 / RAND_MAX) - 1.0;
}
#if 0
src[0] = 0.9999999;
src[1] = -0.000001;
src[2] = 0.000001;
src[3] = 0.9999999;
src[4] = 0;
src[5] = 0;
#if 1
src[0] = 0.98480775;
src[1] = -0.17364818;
src[2] = 0.17364818;
src[3] = 0.98480775;
#endif
src2[0] = 0.98480775;
src2[1] = -0.17364818;
src2[2] = 0.17364818;
src2[3] = 0.98480775;
#endif
ps.x = rand() * 100.0 / RAND_MAX;
ps.y = rand() * 100.0 / RAND_MAX;
art_affine_point (&pd, &ps, src);
art_affine_invert (dst, src);
art_affine_point (&ptmp, &pd, dst);
art_affine_to_string (str, src);
printf ("src = %s\n", str);
art_affine_to_string (str, dst);
printf ("dst = %s\n", str);
printf ("point (%g, %g) -> (%g, %g) -> (%g, %g)\n",
ps.x, ps.y, pd.x, pd.y, ptmp.x, ptmp.y);
art_affine_point (&ptmp, &ps, src);
art_affine_point (&pd, &ptmp, src2);
art_affine_to_string (str, src2);
printf ("src2 = %s\n", str);
printf ("point (%g, %g) -> (%g, %g) -> (%g, %g)\n",
ps.x, ps.y, ptmp.x, ptmp.y, pd.x, pd.y);
art_affine_multiply (dst, src, src2);
art_affine_to_string (str, dst);
printf ("dst = %s\n", str);
art_affine_point (&pd, &ps, dst);
printf ("point (%g, %g) -> (%g, %g)\n",
ps.x, ps.y, pd.x, pd.y);
}
#endif
static ArtVpath *
randstar (int n)
{
ArtVpath *vec;
int i;
double r, th;
vec = art_new (ArtVpath, n + 2);
for (i = 0; i < n; i++)
{
vec[i].code = i ? ART_LINETO : ART_MOVETO;
r = rand () * (250.0 / RAND_MAX);
#if 0
r = r + 0.9 * (250 - r);
#endif
th = i * 2 * M_PI / n;
vec[i].x = 250 + r * cos (th);
vec[i].y = 250 - r * sin (th);
}
vec[i].code = ART_LINETO;
vec[i].x = vec[0].x;
vec[i].y = vec[0].y;
i++;
vec[i].code = ART_END;
vec[i].x = 0;
vec[i].y = 0;
return vec;
}
#define TILE_SIZE 512
#define NUM_ITERS 1
#define COLOR
#ifdef COLOR
#define BYTES_PP 3
#else
#define BYTES_PP 1
#endif
#ifndef nDEAD_CODE
static void
print_svp (ArtSVP *vp)
{
int i, j;
for (i = 0; i < vp->n_segs; i++)
{
printf ("segment %d, dir = %s (%f, %f) - (%f, %f)\n",
i, vp->segs[i].dir ? "down" : "up",
vp->segs[i].bbox.x0,
vp->segs[i].bbox.y0,
vp->segs[i].bbox.x1,
vp->segs[i].bbox.y1);
for (j = 0; j < vp->segs[i].n_points; j++)
printf (" (%g, %g)\n",
vp->segs[i].points[j].x,
vp->segs[i].points[j].y);
}
}
#endif
static void
print_vpath (ArtVpath *vpath)
{
int i;
for (i = 0; vpath[i].code != ART_END; i++)
printf ("%g %g %s\n",
vpath[i].x, vpath[i].y,
vpath[i].code == ART_MOVETO_OPEN ? "moveto %open" :
vpath[i].code == ART_MOVETO ? "moveto" :
vpath[i].code == ART_LINETO ? "lineto" :
"?");
printf ("stroke\n");
}
static void
make_testpat (void)
{
ArtVpath *vpath, *vpath2, *vpath3;
ArtSVP *svp, *svp2;
ArtSVP *svp3;
art_u8 buf[512 * 512 * BYTES_PP];
int i, j;
int iter;
art_u8 colorimg[256][256][3];
art_u8 rgbaimg[256][256][4];
art_u8 bitimg[16][2];
int x, y;
double affine[6];
double affine2[6];
double affine3[6];
ArtAlphaGamma *alphagamma;
double dash_data[] = { 20 };
ArtVpathDash dash;
dash.offset = 0;
dash.n_dash = 1;
dash.dash = dash_data;
#ifdef TEST_AFFINE
test_affine ();
exit (0);
#endif
vpath = randstar (50);
svp = art_svp_from_vpath (vpath);
art_free (vpath);
vpath2 = randstar (50);
#if 1
vpath3 = art_vpath_dash (vpath2, &dash);
art_free (vpath2);
svp2 = art_svp_vpath_stroke (vpath3,
ART_PATH_STROKE_JOIN_MITER,
ART_PATH_STROKE_CAP_BUTT,
15,
4,
0.5);
art_free (vpath3);
#else
svp2 = art_svp_from_vpath (vpath2);
#endif
#if 1
svp3 = art_svp_intersect (svp, svp2);
#else
svp3 = svp2;
#endif
#if 0
print_svp (svp);
#endif
for (y = 0; y < 256; y++)
for (x = 0; x < 256; x++)
{
colorimg[y][x][0] = (x + y) >> 1;
colorimg[y][x][1] = (x + (255 - y)) >> 1;
colorimg[y][x][2] = ((255 - x) + y) >> 1;
rgbaimg[y][x][0] = (x + y) >> 1;
rgbaimg[y][x][1] = (x + (255 - y)) >> 1;
rgbaimg[y][x][2] = ((255 - x) + y) >> 1;
rgbaimg[y][x][3] = y;
}
for (y = 0; y < 16; y++)
for (x = 0; x < 2; x++)
bitimg[y][x] = (x << 4) | y;
affine[0] = 0.5;
affine[1] = .2;
affine[2] = -.2;
affine[3] = 0.5;
affine[4] = 64;
affine[5] = 64;
affine2[0] = 1;
affine2[1] = -.2;
affine2[2] = .2;
affine2[3] = 1;
affine2[4] = 128;
affine2[5] = 128;
affine3[0] = 5;
affine3[1] = -.2;
affine3[2] = .2;
affine3[3] = 5;
affine3[4] = 384;
affine3[5] = 32;
#if 0
alphagamma = art_alphagamma_new (1.8);
#else
alphagamma = NULL;
#endif
#ifdef COLOR
printf ("P6\n512 512\n255\n");
#else
printf ("P5\n512 512\n255\n");
#endif
for (iter = 0; iter < NUM_ITERS; iter++)
for (j = 0; j < 512; j += TILE_SIZE)
for (i = 0; i < 512; i += TILE_SIZE)
{
#ifdef COLOR
art_rgb_svp_aa (svp, i, j, i + TILE_SIZE, j + TILE_SIZE,
0xffe0a0, 0x100040,
buf + (j * 512 + i) * BYTES_PP, 512 * BYTES_PP,
alphagamma);
art_rgb_svp_alpha (svp2, i, j, i + TILE_SIZE, j + TILE_SIZE,
0xff000080,
buf + (j * 512 + i) * BYTES_PP, 512 * BYTES_PP,
alphagamma);
art_rgb_svp_alpha (svp3, i, j, i + TILE_SIZE, j + TILE_SIZE,
0x00ff0080,
buf + (j * 512 + i) * BYTES_PP, 512 * BYTES_PP,
alphagamma);
art_rgb_affine (buf + (j * 512 + i) * BYTES_PP,
i, j, i + TILE_SIZE, j + TILE_SIZE, 512 * BYTES_PP,
(art_u8 *)colorimg, 256, 256, 256 * 3,
affine,
ART_FILTER_NEAREST, alphagamma);
art_rgb_rgba_affine (buf + (j * 512 + i) * BYTES_PP,
i, j, i + TILE_SIZE, j + TILE_SIZE,
512 * BYTES_PP,
(art_u8 *)rgbaimg, 256, 256, 256 * 4,
affine2,
ART_FILTER_NEAREST, alphagamma);
art_rgb_bitmap_affine (buf + (j * 512 + i) * BYTES_PP,
i, j, i + TILE_SIZE, j + TILE_SIZE,
512 * BYTES_PP,
(art_u8 *)bitimg, 16, 16, 2,
0xffff00ff,
affine3,
ART_FILTER_NEAREST, alphagamma);
#else
art_gray_svp_aa (svp, i, j, i + TILE_SIZE, j + TILE_SIZE,
buf + (j * 512 + i) * BYTES_PP, 512 * BYTES_PP);
#endif
}
art_svp_free (svp2);
art_svp_free (svp3);
art_svp_free (svp);
#if 1
fwrite (buf, 1, 512 * 512 * BYTES_PP, stdout);
#endif
}
static void
test_dist (void)
{
ArtVpath *vpath;
ArtSVP *svp;
art_u8 buf[512 * 512 * BYTES_PP];
int x, y;
int ix;
double dist;
int wind;
vpath = randstar (20);
#ifdef NO_STROKE
svp = art_svp_from_vpath (vpath);
#else
svp = art_svp_vpath_stroke (vpath,
ART_PATH_STROKE_JOIN_MITER,
ART_PATH_STROKE_CAP_BUTT,
15,
4,
0.5);
#endif
art_rgb_svp_aa (svp, 0, 0, 512, 512,
0xffe0a0, 0x100040,
buf, 512 * BYTES_PP,
NULL);
ix = 0;
for (y = 0; y < 512; y++)
{
for (x = 0; x < 512; x++)
{
wind = art_svp_point_wind (svp, x, y);
buf[ix] = 204 - wind * 51;
dist = art_svp_point_dist (svp, x, y);
if (((x | y) & 0x3f) == 0)
{
fprintf (stderr, "%d,%d: %f\n", x, y, dist);
}
buf[ix + 1] = 255 - dist;
ix += 3;
}
}
printf ("P6\n512 512\n255\n");
fwrite (buf, 1, 512 * 512 * BYTES_PP, stdout);
}
static void
test_dash (void)
{
ArtVpath *vpath, *vpath2;
double dash_data[] = { 10, 4, 1, 4};
ArtVpathDash dash;
dash.offset = 0;
dash.n_dash = 3;
dash.dash = dash_data;
vpath = randstar (50);
vpath2 = art_vpath_dash (vpath, &dash);
printf ("%%!\n");
print_vpath (vpath2);
printf ("showpage\n");
art_free (vpath);
art_free (vpath2);
}
static void
test_render_gradient (art_u8 *buf)
{
ArtGradientLinear gradient;
ArtGradientStop stops[3] = {
{ 0.0, { 0x7fff, 0x0000, 0x0000, 0x7fff }},
{ 0.5, { 0x0000, 0x0000, 0x0000, 0x1000 }},
{ 1.0, { 0x0000, 0x7fff, 0x0000, 0x7fff }}
};
ArtVpath *vpath;
ArtSVP *svp;
ArtRender *render;
gradient.a = 0.003;
gradient.b = -0.0015;
gradient.c = 0.1;
gradient.spread = ART_GRADIENT_PAD;
gradient.n_stops = sizeof(stops) / sizeof(stops[0]);
gradient.stops = stops;
vpath = randstar (50);
svp = art_svp_from_vpath (vpath);
render = art_render_new (0, 0, 512, 512, buf, 512 * 3, 3, 8, ART_ALPHA_NONE,
NULL);
art_render_svp (render, svp);
art_render_gradient_linear (render, &gradient, ART_FILTER_NEAREST);
art_render_invoke (render);
}
static void
test_render_rad_gradient (art_u8 *buf)
{
ArtGradientRadial gradient;
ArtGradientStop stops[3] = {
{ 0.0, { 0xffff, 0x0000, 0x0000, 0xffff }},
{ 0.5, { 0xe000, 0xe000, 0x0000, 0xe000 }},
{ 1.0, { 0x0000, 0x0000, 0x0000, 0x0000 }}
};
ArtVpath *vpath;
ArtSVP *svp;
ArtRender *render;
gradient.affine[0] = 3.0 / 512;
gradient.affine[1] = 0;
gradient.affine[2] = 0;
gradient.affine[3] = 3.0 / 512;
gradient.affine[4] = -1.5;
gradient.affine[5] = -1.5;
gradient.fx = 0.9;
gradient.fy = 0.1;
gradient.n_stops = sizeof(stops) / sizeof(stops[0]);
gradient.stops = stops;
vpath = randstar (50);
svp = art_svp_from_vpath (vpath);
render = art_render_new (0, 0, 512, 512, buf, 512 * 3, 3, 8, ART_ALPHA_NONE,
NULL);
art_render_svp (render, svp);
art_render_gradient_radial (render, &gradient, ART_FILTER_NEAREST);
art_render_invoke (render);
}
static void
test_gradient (void)
{
ArtVpath *vpath;
ArtSVP *svp;
art_u8 buf[512 * 512 * 3];
ArtRender *render;
ArtPixMaxDepth color[3] = {0x0000, 0x0000, 0x8000 };
int i;
const int n_iter = 1;
vpath = randstar (50);
svp = art_svp_from_vpath (vpath);
for (i = 0; i < n_iter; i++)
{
#define USE_RENDER
#ifdef USE_RENDER
render = art_render_new (0, 0, 512, 512, buf, 512 * 3, 3, 8, ART_ALPHA_NONE,
NULL);
art_render_clear_rgb (render, 0xfff0c0);
art_render_svp (render, svp);
art_render_image_solid (render, color);
art_render_invoke (render);
#else
art_rgb_svp_aa (svp, 0, 0, 512, 512, 0xfff0c0, 0x000080,
buf, 512 * 3, NULL);
#endif
}
#if 1
test_render_gradient (buf);
#endif
test_render_rad_gradient (buf);
printf ("P6\n512 512\n255\n");
fwrite (buf, 1, 512 * 512 * 3, stdout);
}
static void
output_svp_ppm (const ArtSVP *svp)
{
art_u8 buf[512 * 512 * 3];
art_rgb_svp_aa (svp, 0, 0, 512, 512, 0xfff0c0, 0x000080,
buf, 512 * 3, NULL);
printf ("P6\n512 512\n255\n");
fwrite (buf, 1, 512 * 512 * 3, stdout);
}
static void
test_intersect (void)
{
ArtVpath vpath[] = {
#if 0
/* two triangles */
{ ART_MOVETO, 100, 100 },
{ ART_LINETO, 300, 400 },
{ ART_LINETO, 400, 200 },
{ ART_LINETO, 100, 100 },
{ ART_MOVETO, 110, 110 },
{ ART_LINETO, 310, 410 },
{ ART_LINETO, 410, 210 },
{ ART_LINETO, 110, 110 },
#endif
#if 0
/* a bowtie */
{ ART_MOVETO, 100, 100 },
{ ART_LINETO, 400, 400 },
{ ART_LINETO, 400, 100 },
{ ART_LINETO, 100, 400 },
{ ART_LINETO, 100, 100 },
#endif
#if 1
/* a square */
{ ART_MOVETO, 100, 100 },
{ ART_LINETO, 100, 400 },
{ ART_LINETO, 400, 400 },
{ ART_LINETO, 400, 100 },
{ ART_LINETO, 100, 100 },
#endif
#if 1
/* another square */
#define XOFF 10
#define YOFF 10
{ ART_MOVETO, 100 + XOFF, 100 + YOFF },
{ ART_LINETO, 100 + XOFF, 400 + YOFF },
{ ART_LINETO, 400 + XOFF, 400 + YOFF },
{ ART_LINETO, 400 + XOFF, 100 + YOFF },
{ ART_LINETO, 100 + XOFF, 100 + YOFF },
#endif
{ ART_END, 0, 0}
};
ArtSVP *svp, *svp2;
ArtSvpWriter *swr;
svp = art_svp_from_vpath (vpath);
#define RUN_INTERSECT
#ifdef RUN_INTERSECT
swr = art_svp_writer_rewind_new (ART_WIND_RULE_ODDEVEN);
art_svp_intersector (svp, swr);
svp2 = art_svp_writer_rewind_reap (swr);
#endif
#if 0
output_svp_ppm (svp2);
#else
print_svp (svp2);
#endif
art_svp_free (svp);
#ifdef RUN_INTERSECT
art_svp_free (svp2);
#endif
}
static void
usage (void)
{
fprintf (stderr, "usage: testart <test>\n"
" where <test> is one of:\n"
" testpat -- make random star + gradients test pattern\n"
" gradient -- test pattern for rendered gradients\n"
" dash -- dash test (output is valid PostScript)\n"
" dist -- distance test\n"
" intersect -- softball test for intersector\n");
exit (1);
}
int
main (int argc, char **argv)
{
if (argc < 2)
usage ();
if (!strcmp (argv[1], "testpat"))
make_testpat ();
else if (!strcmp (argv[1], "gradient"))
test_gradient ();
else if (!strcmp (argv[1], "dist"))
test_dist ();
else if (!strcmp (argv[1], "dash"))
test_dash ();
else if (!strcmp (argv[1], "intersect"))
test_intersect ();
else
usage ();
return 0;
}