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
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "cairoint.h"
#include "cairo-error-private.h"
void
_cairo_stroke_style_init (cairo_stroke_style_t *style)
{
VG (VALGRIND_MAKE_MEM_UNDEFINED (style, sizeof (cairo_stroke_style_t)));
style->line_width = CAIRO_GSTATE_LINE_WIDTH_DEFAULT;
style->line_cap = CAIRO_GSTATE_LINE_CAP_DEFAULT;
style->line_join = CAIRO_GSTATE_LINE_JOIN_DEFAULT;
style->miter_limit = CAIRO_GSTATE_MITER_LIMIT_DEFAULT;
style->dash = NULL;
style->num_dashes = 0;
style->dash_offset = 0.0;
}
cairo_status_t
_cairo_stroke_style_init_copy (cairo_stroke_style_t *style,
const cairo_stroke_style_t *other)
{
if (CAIRO_INJECT_FAULT ())
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
VG (VALGRIND_MAKE_MEM_UNDEFINED (style, sizeof (cairo_stroke_style_t)));
style->line_width = other->line_width;
style->line_cap = other->line_cap;
style->line_join = other->line_join;
style->miter_limit = other->miter_limit;
style->num_dashes = other->num_dashes;
if (other->dash == NULL) {
style->dash = NULL;
} else {
style->dash = _cairo_malloc_ab (style->num_dashes, sizeof (double));
if (unlikely (style->dash == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
memcpy (style->dash, other->dash,
style->num_dashes * sizeof (double));
}
style->dash_offset = other->dash_offset;
return CAIRO_STATUS_SUCCESS;
}
void
_cairo_stroke_style_fini (cairo_stroke_style_t *style)
{
if (style->dash) {
free (style->dash);
style->dash = NULL;
}
style->num_dashes = 0;
VG (VALGRIND_MAKE_MEM_NOACCESS (style, sizeof (cairo_stroke_style_t)));
}
/*
* For a stroke in the given style, compute the maximum distance
* from the path that vertices could be generated. In the case
* of rotation in the ctm, the distance will not be exact.
*/
void
_cairo_stroke_style_max_distance_from_path (const cairo_stroke_style_t *style,
const cairo_matrix_t *ctm,
double *dx, double *dy)
{
double style_expansion = 0.5;
if (style->line_cap == CAIRO_LINE_CAP_SQUARE)
style_expansion = M_SQRT1_2;
if (style->line_join == CAIRO_LINE_JOIN_MITER &&
style_expansion < M_SQRT2 * style->miter_limit)
{
style_expansion = M_SQRT2 * style->miter_limit;
}
style_expansion *= style->line_width;
*dx = style_expansion * hypot (ctm->xx, ctm->xy);
*dy = style_expansion * hypot (ctm->yy, ctm->yx);
}
/*
* Computes the period of a dashed stroke style.
* Returns 0 for non-dashed styles.
*/
double
_cairo_stroke_style_dash_period (const cairo_stroke_style_t *style)
{
double period;
unsigned int i;
period = 0.0;
for (i = 0; i < style->num_dashes; i++)
period += style->dash[i];
if (style->num_dashes & 1)
period *= 2.0;
return period;
}
/*
* Coefficient of the linear approximation (minimizing square difference)
* of the surface covered by round caps
*
* This can be computed in the following way:
* the area inside the circle with radius w/2 and the region -d/2 <= x <= d/2 is:
* f(w,d) = 2 * integrate (sqrt (w*w/4 - x*x), x, -d/2, d/2)
* The square difference to a generic linear approximation (c*d) in the range (0,w) would be:
* integrate ((f(w,d) - c*d)^2, d, 0, w)
* To minimize this difference it is sufficient to find a solution of the differential with
* respect to c:
* solve ( diff (integrate ((f(w,d) - c*d)^2, d, 0, w), c), c)
* Which leads to c = 9/32*pi*w
* Since we're not interested in the true area, but just in a coverage extimate,
* we always divide the real area by the line width (w).
* The same computation for square caps would be
* f(w,d) = 2 * integrate(w/2, x, -d/2, d/2)
* c = 1*w
* but in this case it would not be an approximation, since f is already linear in d.
*/
#define ROUND_MINSQ_APPROXIMATION (9*M_PI/32)
/*
* Computes the length of the "on" part of a dashed stroke style,
* taking into account also line caps.
* Returns 0 for non-dashed styles.
*/
double
_cairo_stroke_style_dash_stroked (const cairo_stroke_style_t *style)
{
double stroked, cap_scale;
unsigned int i;
switch (style->line_cap) {
default: ASSERT_NOT_REACHED;
case CAIRO_LINE_CAP_BUTT: cap_scale = 0.0; break;
case CAIRO_LINE_CAP_ROUND: cap_scale = ROUND_MINSQ_APPROXIMATION; break;
case CAIRO_LINE_CAP_SQUARE: cap_scale = 1.0; break;
}
stroked = 0.0;
if (style->num_dashes & 1) {
/* Each dash element is used both as on and as off. The order in which they are summed is
* irrelevant, so sum the coverage of one dash element, taken both on and off at each iteration */
for (i = 0; i < style->num_dashes; i++)
stroked += style->dash[i] + cap_scale * MIN (style->dash[i], style->line_width);
} else {
/* Even (0, 2, ...) dashes are on and simply counted for the coverage, odd dashes are off, thus
* their coverage is approximated based on the area covered by the caps of adjacent on dases. */
for (i = 0; i < style->num_dashes; i+=2)
stroked += style->dash[i] + cap_scale * MIN (style->dash[i+1], style->line_width);
}
return stroked;
}
/*
* Verifies if _cairo_stroke_style_dash_approximate should be used to generate
* an approximation of the dash pattern in the specified style, when used for
* stroking a path with the given CTM and tolerance.
* Always %FALSE for non-dashed styles.
*/
cairo_bool_t
_cairo_stroke_style_dash_can_approximate (const cairo_stroke_style_t *style,
const cairo_matrix_t *ctm,
double tolerance)
{
double period;
if (! style->num_dashes)
return FALSE;
period = _cairo_stroke_style_dash_period (style);
return _cairo_matrix_transformed_circle_major_axis (ctm, period) < tolerance;
}
/*
* Create a 2-dashes approximation of a dashed style, by making the "on" and "off"
* parts respect the original ratio.
*/
void
_cairo_stroke_style_dash_approximate (const cairo_stroke_style_t *style,
const cairo_matrix_t *ctm,
double tolerance,
double *dash_offset,
double *dashes,
unsigned int *num_dashes)
{
double coverage, scale, offset;
cairo_bool_t on = TRUE;
unsigned int i = 0;
coverage = _cairo_stroke_style_dash_stroked (style) / _cairo_stroke_style_dash_period (style);
coverage = MIN (coverage, 1.0);
scale = tolerance / _cairo_matrix_transformed_circle_major_axis (ctm, 1.0);
/* We stop searching for a starting point as soon as the
* offset reaches zero. Otherwise when an initial dash
* segment shrinks to zero it will be skipped over. */
offset = style->dash_offset;
while (offset > 0.0 && offset >= style->dash[i]) {
offset -= style->dash[i];
on = !on;
if (++i == style->num_dashes)
i = 0;
}
*num_dashes = 2;
/*
* We want to create a new dash pattern with the same relative coverage,
* but composed of just 2 elements with total length equal to scale.
* Based on the formula in _cairo_stroke_style_dash_stroked:
* scale * coverage = dashes[0] + cap_scale * MIN (dashes[1], line_width)
* = MIN (dashes[0] + cap_scale * (scale - dashes[0]),
* dashes[0] + cap_scale * line_width) =
* = MIN (dashes[0] * (1 - cap_scale) + cap_scale * scale,
* dashes[0] + cap_scale * line_width)
*
* Solving both cases we get:
* dashes[0] = scale * (coverage - cap_scale) / (1 - cap_scale)
* when scale - dashes[0] <= line_width
* dashes[0] = scale * coverage - cap_scale * line_width
* when scale - dashes[0] > line_width.
*
* Comparing the two cases we get:
* second > first
* second > scale * (coverage - cap_scale) / (1 - cap_scale)
* second - cap_scale * second - scale * coverage + scale * cap_scale > 0
* (scale * coverage - cap_scale * line_width) - cap_scale * second - scale * coverage + scale * cap_scale > 0
* - line_width - second + scale > 0
* scale - second > line_width
* which is the condition for the second solution to be the valid one.
* So when second > first, the second solution is the correct one (i.e.
* the solution is always MAX (first, second).
*/
switch (style->line_cap) {
default:
ASSERT_NOT_REACHED;
dashes[0] = 0.0;
break;
case CAIRO_LINE_CAP_BUTT:
/* Simplified formula (substituting 0 for cap_scale): */
dashes[0] = scale * coverage;
break;
case CAIRO_LINE_CAP_ROUND:
dashes[0] = MAX(scale * (coverage - ROUND_MINSQ_APPROXIMATION) / (1.0 - ROUND_MINSQ_APPROXIMATION),
scale * coverage - ROUND_MINSQ_APPROXIMATION * style->line_width);
break;
case CAIRO_LINE_CAP_SQUARE:
/*
* Special attention is needed to handle the case cap_scale == 1 (since the first solution
* is either indeterminate or -inf in this case). Since dash lengths are always >=0, using
* 0 as first solution always leads to the correct solution.
*/
dashes[0] = MAX(0.0, scale * coverage - style->line_width);
break;
}
dashes[1] = scale - dashes[0];
*dash_offset = on ? 0.0 : dashes[0];
}
|