1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
#include "../test/utils.h"
#include "gtk-utils.h"
#define NUM_GRADIENTS 9
#define NUM_STOPS 3
#define NUM_REPEAT 4
#define SIZE 128
#define WIDTH (SIZE * NUM_GRADIENTS)
#define HEIGHT (SIZE * NUM_REPEAT)
/*
* We want to test all the possible relative positions of the start
* and end circle:
*
* - The start circle can be smaller/equal/bigger than the end
* circle. A radial gradient can be classified in one of these
* three cases depending on the sign of dr.
*
* - The smaller circle can be completely inside/internally
* tangent/outside (at least in part) of the bigger circle. This
* classification is the same as the one which can be computed by
* examining the sign of a = (dx^2 + dy^2 - dr^2).
*
* - If the two circles have the same size, neither can be inside or
* internally tangent
*
* This test draws radial gradients whose circles always have the same
* centers (0, 0) and (1, 0), but with different radiuses. From left
* to right:
*
* - Degenerate start circle completely inside the end circle
* 0.00 -> 1.75; dr = 1.75 > 0; a = 1 - 1.75^2 < 0
*
* - Small start circle completely inside the end circle
* 0.25 -> 1.75; dr = 1.5 > 0; a = 1 - 1.50^2 < 0
*
* - Small start circle internally tangent to the end circle
* 0.50 -> 1.50; dr = 1.0 > 0; a = 1 - 1.00^2 = 0
*
* - Small start circle outside of the end circle
* 0.50 -> 1.00; dr = 0.5 > 0; a = 1 - 0.50^2 > 0
*
* - Start circle with the same size as the end circle
* 1.00 -> 1.00; dr = 0.0 = 0; a = 1 - 0.00^2 > 0
*
* - Small end circle outside of the start circle
* 1.00 -> 0.50; dr = -0.5 > 0; a = 1 - 0.50^2 > 0
*
* - Small end circle internally tangent to the start circle
* 1.50 -> 0.50; dr = -1.0 > 0; a = 1 - 1.00^2 = 0
*
* - Small end circle completely inside the start circle
* 1.75 -> 0.25; dr = -1.5 > 0; a = 1 - 1.50^2 < 0
*
* - Degenerate end circle completely inside the start circle
* 0.00 -> 1.75; dr = 1.75 > 0; a = 1 - 1.75^2 < 0
*
*/
const static double radiuses[NUM_GRADIENTS] = {
0.00,
0.25,
0.50,
0.50,
1.00,
1.00,
1.50,
1.75,
1.75
};
#define double_to_color(x) \
(((uint32_t) ((x)*65536)) - (((uint32_t) ((x)*65536)) >> 16))
#define PIXMAN_STOP(offset,r,g,b,a) \
{ pixman_double_to_fixed (offset), \
{ \
double_to_color (r), \
double_to_color (g), \
double_to_color (b), \
double_to_color (a) \
} \
}
static const pixman_gradient_stop_t stops[NUM_STOPS] = {
PIXMAN_STOP (0.0, 1, 0, 0, 0.75),
PIXMAN_STOP (0.70710678, 0, 1, 0, 0),
PIXMAN_STOP (1.0, 0, 0, 1, 1)
};
static pixman_image_t *
create_radial (int index)
{
pixman_point_fixed_t p0, p1;
pixman_fixed_t r0, r1;
double x0, x1, radius0, radius1, left, right, center;
x0 = 0;
x1 = 1;
radius0 = radiuses[index];
radius1 = radiuses[NUM_GRADIENTS - index - 1];
/* center the gradient */
left = MIN (x0 - radius0, x1 - radius1);
right = MAX (x0 + radius0, x1 + radius1);
center = (left + right) * 0.5;
x0 -= center;
x1 -= center;
/* scale to make it fit within a 1x1 rect centered in (0,0) */
x0 *= 0.25;
x1 *= 0.25;
radius0 *= 0.25;
radius1 *= 0.25;
p0.x = pixman_double_to_fixed (x0);
p0.y = pixman_double_to_fixed (0);
p1.x = pixman_double_to_fixed (x1);
p1.y = pixman_double_to_fixed (0);
r0 = pixman_double_to_fixed (radius0);
r1 = pixman_double_to_fixed (radius1);
return pixman_image_create_radial_gradient (&p0, &p1,
r0, r1,
stops, NUM_STOPS);
}
static const pixman_repeat_t repeat[NUM_REPEAT] = {
PIXMAN_REPEAT_NONE,
PIXMAN_REPEAT_NORMAL,
PIXMAN_REPEAT_REFLECT,
PIXMAN_REPEAT_PAD
};
int
main (int argc, char **argv)
{
pixman_transform_t transform;
pixman_image_t *src_img, *dest_img;
int i, j;
enable_divbyzero_exceptions ();
dest_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,
WIDTH, HEIGHT,
NULL, 0);
draw_checkerboard (dest_img, 25, 0xffaaaaaa, 0xffbbbbbb);
pixman_transform_init_identity (&transform);
/*
* The create_radial() function returns gradients centered in the
* origin and whose interesting part fits a 1x1 square. We want to
* paint these gradients on a SIZExSIZE square and to make things
* easier we want the origin in the top-left corner of the square
* we want to see.
*/
pixman_transform_translate (NULL, &transform,
pixman_double_to_fixed (0.5),
pixman_double_to_fixed (0.5));
pixman_transform_scale (NULL, &transform,
pixman_double_to_fixed (SIZE),
pixman_double_to_fixed (SIZE));
/*
* Gradients are evaluated at the center of each pixel, so we need
* to translate by half a pixel to trigger some interesting
* cornercases. In particular, the original implementation of PDF
* radial gradients tried to divide by 0 when using this transform
* on the "tangent circles" cases.
*/
pixman_transform_translate (NULL, &transform,
pixman_double_to_fixed (0.5),
pixman_double_to_fixed (0.5));
for (i = 0; i < NUM_GRADIENTS; i++)
{
src_img = create_radial (i);
pixman_image_set_transform (src_img, &transform);
for (j = 0; j < NUM_REPEAT; j++)
{
pixman_image_set_repeat (src_img, repeat[j]);
pixman_image_composite32 (PIXMAN_OP_OVER,
src_img,
NULL,
dest_img,
0, 0,
0, 0,
i * SIZE, j * SIZE,
SIZE, SIZE);
}
pixman_image_unref (src_img);
}
show_image (dest_img);
pixman_image_unref (dest_img);
return 0;
}
|
