1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 | 'use strict';
|
23 |
|
24 | Object.defineProperty(exports, "__esModule", {
|
25 | value: true
|
26 | });
|
27 | exports.getTilingPatternIR = exports.Pattern = undefined;
|
28 |
|
29 | var _util = require('../shared/util');
|
30 |
|
31 | var _colorspace = require('./colorspace');
|
32 |
|
33 | var _primitives = require('./primitives');
|
34 |
|
35 | var ShadingType = {
|
36 | FUNCTION_BASED: 1,
|
37 | AXIAL: 2,
|
38 | RADIAL: 3,
|
39 | FREE_FORM_MESH: 4,
|
40 | LATTICE_FORM_MESH: 5,
|
41 | COONS_PATCH_MESH: 6,
|
42 | TENSOR_PATCH_MESH: 7
|
43 | };
|
44 | var Pattern = function PatternClosure() {
|
45 | function Pattern() {
|
46 | (0, _util.unreachable)('should not call Pattern constructor');
|
47 | }
|
48 | Pattern.prototype = {
|
49 | getPattern: function Pattern_getPattern(ctx) {
|
50 | (0, _util.unreachable)('Should not call Pattern.getStyle: ' + ctx);
|
51 | }
|
52 | };
|
53 | Pattern.parseShading = function (shading, matrix, xref, res, handler, pdfFunctionFactory) {
|
54 | var dict = (0, _primitives.isStream)(shading) ? shading.dict : shading;
|
55 | var type = dict.get('ShadingType');
|
56 | try {
|
57 | switch (type) {
|
58 | case ShadingType.AXIAL:
|
59 | case ShadingType.RADIAL:
|
60 | return new Shadings.RadialAxial(dict, matrix, xref, res, pdfFunctionFactory);
|
61 | case ShadingType.FREE_FORM_MESH:
|
62 | case ShadingType.LATTICE_FORM_MESH:
|
63 | case ShadingType.COONS_PATCH_MESH:
|
64 | case ShadingType.TENSOR_PATCH_MESH:
|
65 | return new Shadings.Mesh(shading, matrix, xref, res, pdfFunctionFactory);
|
66 | default:
|
67 | throw new _util.FormatError('Unsupported ShadingType: ' + type);
|
68 | }
|
69 | } catch (ex) {
|
70 | if (ex instanceof _util.MissingDataException) {
|
71 | throw ex;
|
72 | }
|
73 | handler.send('UnsupportedFeature', { featureId: _util.UNSUPPORTED_FEATURES.shadingPattern });
|
74 | (0, _util.warn)(ex);
|
75 | return new Shadings.Dummy();
|
76 | }
|
77 | };
|
78 | return Pattern;
|
79 | }();
|
80 | var Shadings = {};
|
81 | Shadings.SMALL_NUMBER = 1e-6;
|
82 | Shadings.RadialAxial = function RadialAxialClosure() {
|
83 | function RadialAxial(dict, matrix, xref, res, pdfFunctionFactory) {
|
84 | this.matrix = matrix;
|
85 | this.coordsArr = dict.getArray('Coords');
|
86 | this.shadingType = dict.get('ShadingType');
|
87 | this.type = 'Pattern';
|
88 | var cs = dict.get('ColorSpace', 'CS');
|
89 | cs = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
|
90 | this.cs = cs;
|
91 | var t0 = 0.0,
|
92 | t1 = 1.0;
|
93 | if (dict.has('Domain')) {
|
94 | var domainArr = dict.getArray('Domain');
|
95 | t0 = domainArr[0];
|
96 | t1 = domainArr[1];
|
97 | }
|
98 | var extendStart = false,
|
99 | extendEnd = false;
|
100 | if (dict.has('Extend')) {
|
101 | var extendArr = dict.getArray('Extend');
|
102 | extendStart = extendArr[0];
|
103 | extendEnd = extendArr[1];
|
104 | }
|
105 | if (this.shadingType === ShadingType.RADIAL && (!extendStart || !extendEnd)) {
|
106 | var x1 = this.coordsArr[0];
|
107 | var y1 = this.coordsArr[1];
|
108 | var r1 = this.coordsArr[2];
|
109 | var x2 = this.coordsArr[3];
|
110 | var y2 = this.coordsArr[4];
|
111 | var r2 = this.coordsArr[5];
|
112 | var distance = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
|
113 | if (r1 <= r2 + distance && r2 <= r1 + distance) {
|
114 | (0, _util.warn)('Unsupported radial gradient.');
|
115 | }
|
116 | }
|
117 | this.extendStart = extendStart;
|
118 | this.extendEnd = extendEnd;
|
119 | var fnObj = dict.get('Function');
|
120 | var fn = pdfFunctionFactory.createFromArray(fnObj);
|
121 | var diff = t1 - t0;
|
122 | var step = diff / 10;
|
123 | var colorStops = this.colorStops = [];
|
124 | if (t0 >= t1 || step <= 0) {
|
125 | (0, _util.info)('Bad shading domain.');
|
126 | return;
|
127 | }
|
128 | var color = new Float32Array(cs.numComps),
|
129 | ratio = new Float32Array(1);
|
130 | var rgbColor;
|
131 | for (var i = t0; i <= t1; i += step) {
|
132 | ratio[0] = i;
|
133 | fn(ratio, 0, color, 0);
|
134 | rgbColor = cs.getRgb(color, 0);
|
135 | var cssColor = _util.Util.makeCssRgb(rgbColor[0], rgbColor[1], rgbColor[2]);
|
136 | colorStops.push([(i - t0) / diff, cssColor]);
|
137 | }
|
138 | var background = 'transparent';
|
139 | if (dict.has('Background')) {
|
140 | rgbColor = cs.getRgb(dict.get('Background'), 0);
|
141 | background = _util.Util.makeCssRgb(rgbColor[0], rgbColor[1], rgbColor[2]);
|
142 | }
|
143 | if (!extendStart) {
|
144 | colorStops.unshift([0, background]);
|
145 | colorStops[1][0] += Shadings.SMALL_NUMBER;
|
146 | }
|
147 | if (!extendEnd) {
|
148 | colorStops[colorStops.length - 1][0] -= Shadings.SMALL_NUMBER;
|
149 | colorStops.push([1, background]);
|
150 | }
|
151 | this.colorStops = colorStops;
|
152 | }
|
153 | RadialAxial.prototype = {
|
154 | getIR: function RadialAxial_getIR() {
|
155 | var coordsArr = this.coordsArr;
|
156 | var shadingType = this.shadingType;
|
157 | var type, p0, p1, r0, r1;
|
158 | if (shadingType === ShadingType.AXIAL) {
|
159 | p0 = [coordsArr[0], coordsArr[1]];
|
160 | p1 = [coordsArr[2], coordsArr[3]];
|
161 | r0 = null;
|
162 | r1 = null;
|
163 | type = 'axial';
|
164 | } else if (shadingType === ShadingType.RADIAL) {
|
165 | p0 = [coordsArr[0], coordsArr[1]];
|
166 | p1 = [coordsArr[3], coordsArr[4]];
|
167 | r0 = coordsArr[2];
|
168 | r1 = coordsArr[5];
|
169 | type = 'radial';
|
170 | } else {
|
171 | (0, _util.unreachable)('getPattern type unknown: ' + shadingType);
|
172 | }
|
173 | var matrix = this.matrix;
|
174 | if (matrix) {
|
175 | p0 = _util.Util.applyTransform(p0, matrix);
|
176 | p1 = _util.Util.applyTransform(p1, matrix);
|
177 | if (shadingType === ShadingType.RADIAL) {
|
178 | var scale = _util.Util.singularValueDecompose2dScale(matrix);
|
179 | r0 *= scale[0];
|
180 | r1 *= scale[1];
|
181 | }
|
182 | }
|
183 | return ['RadialAxial', type, this.colorStops, p0, p1, r0, r1];
|
184 | }
|
185 | };
|
186 | return RadialAxial;
|
187 | }();
|
188 | Shadings.Mesh = function MeshClosure() {
|
189 | function MeshStreamReader(stream, context) {
|
190 | this.stream = stream;
|
191 | this.context = context;
|
192 | this.buffer = 0;
|
193 | this.bufferLength = 0;
|
194 | var numComps = context.numComps;
|
195 | this.tmpCompsBuf = new Float32Array(numComps);
|
196 | var csNumComps = context.colorSpace.numComps;
|
197 | this.tmpCsCompsBuf = context.colorFn ? new Float32Array(csNumComps) : this.tmpCompsBuf;
|
198 | }
|
199 | MeshStreamReader.prototype = {
|
200 | get hasData() {
|
201 | if (this.stream.end) {
|
202 | return this.stream.pos < this.stream.end;
|
203 | }
|
204 | if (this.bufferLength > 0) {
|
205 | return true;
|
206 | }
|
207 | var nextByte = this.stream.getByte();
|
208 | if (nextByte < 0) {
|
209 | return false;
|
210 | }
|
211 | this.buffer = nextByte;
|
212 | this.bufferLength = 8;
|
213 | return true;
|
214 | },
|
215 | readBits: function MeshStreamReader_readBits(n) {
|
216 | var buffer = this.buffer;
|
217 | var bufferLength = this.bufferLength;
|
218 | if (n === 32) {
|
219 | if (bufferLength === 0) {
|
220 | return (this.stream.getByte() << 24 | this.stream.getByte() << 16 | this.stream.getByte() << 8 | this.stream.getByte()) >>> 0;
|
221 | }
|
222 | buffer = buffer << 24 | this.stream.getByte() << 16 | this.stream.getByte() << 8 | this.stream.getByte();
|
223 | var nextByte = this.stream.getByte();
|
224 | this.buffer = nextByte & (1 << bufferLength) - 1;
|
225 | return (buffer << 8 - bufferLength | (nextByte & 0xFF) >> bufferLength) >>> 0;
|
226 | }
|
227 | if (n === 8 && bufferLength === 0) {
|
228 | return this.stream.getByte();
|
229 | }
|
230 | while (bufferLength < n) {
|
231 | buffer = buffer << 8 | this.stream.getByte();
|
232 | bufferLength += 8;
|
233 | }
|
234 | bufferLength -= n;
|
235 | this.bufferLength = bufferLength;
|
236 | this.buffer = buffer & (1 << bufferLength) - 1;
|
237 | return buffer >> bufferLength;
|
238 | },
|
239 | align: function MeshStreamReader_align() {
|
240 | this.buffer = 0;
|
241 | this.bufferLength = 0;
|
242 | },
|
243 | readFlag: function MeshStreamReader_readFlag() {
|
244 | return this.readBits(this.context.bitsPerFlag);
|
245 | },
|
246 | readCoordinate: function MeshStreamReader_readCoordinate() {
|
247 | var bitsPerCoordinate = this.context.bitsPerCoordinate;
|
248 | var xi = this.readBits(bitsPerCoordinate);
|
249 | var yi = this.readBits(bitsPerCoordinate);
|
250 | var decode = this.context.decode;
|
251 | var scale = bitsPerCoordinate < 32 ? 1 / ((1 << bitsPerCoordinate) - 1) : 2.3283064365386963e-10;
|
252 | return [xi * scale * (decode[1] - decode[0]) + decode[0], yi * scale * (decode[3] - decode[2]) + decode[2]];
|
253 | },
|
254 | readComponents: function MeshStreamReader_readComponents() {
|
255 | var numComps = this.context.numComps;
|
256 | var bitsPerComponent = this.context.bitsPerComponent;
|
257 | var scale = bitsPerComponent < 32 ? 1 / ((1 << bitsPerComponent) - 1) : 2.3283064365386963e-10;
|
258 | var decode = this.context.decode;
|
259 | var components = this.tmpCompsBuf;
|
260 | for (var i = 0, j = 4; i < numComps; i++, j += 2) {
|
261 | var ci = this.readBits(bitsPerComponent);
|
262 | components[i] = ci * scale * (decode[j + 1] - decode[j]) + decode[j];
|
263 | }
|
264 | var color = this.tmpCsCompsBuf;
|
265 | if (this.context.colorFn) {
|
266 | this.context.colorFn(components, 0, color, 0);
|
267 | }
|
268 | return this.context.colorSpace.getRgb(color, 0);
|
269 | }
|
270 | };
|
271 | function decodeType4Shading(mesh, reader) {
|
272 | var coords = mesh.coords;
|
273 | var colors = mesh.colors;
|
274 | var operators = [];
|
275 | var ps = [];
|
276 | var verticesLeft = 0;
|
277 | while (reader.hasData) {
|
278 | var f = reader.readFlag();
|
279 | var coord = reader.readCoordinate();
|
280 | var color = reader.readComponents();
|
281 | if (verticesLeft === 0) {
|
282 | if (!(0 <= f && f <= 2)) {
|
283 | throw new _util.FormatError('Unknown type4 flag');
|
284 | }
|
285 | switch (f) {
|
286 | case 0:
|
287 | verticesLeft = 3;
|
288 | break;
|
289 | case 1:
|
290 | ps.push(ps[ps.length - 2], ps[ps.length - 1]);
|
291 | verticesLeft = 1;
|
292 | break;
|
293 | case 2:
|
294 | ps.push(ps[ps.length - 3], ps[ps.length - 1]);
|
295 | verticesLeft = 1;
|
296 | break;
|
297 | }
|
298 | operators.push(f);
|
299 | }
|
300 | ps.push(coords.length);
|
301 | coords.push(coord);
|
302 | colors.push(color);
|
303 | verticesLeft--;
|
304 | reader.align();
|
305 | }
|
306 | mesh.figures.push({
|
307 | type: 'triangles',
|
308 | coords: new Int32Array(ps),
|
309 | colors: new Int32Array(ps)
|
310 | });
|
311 | }
|
312 | function decodeType5Shading(mesh, reader, verticesPerRow) {
|
313 | var coords = mesh.coords;
|
314 | var colors = mesh.colors;
|
315 | var ps = [];
|
316 | while (reader.hasData) {
|
317 | var coord = reader.readCoordinate();
|
318 | var color = reader.readComponents();
|
319 | ps.push(coords.length);
|
320 | coords.push(coord);
|
321 | colors.push(color);
|
322 | }
|
323 | mesh.figures.push({
|
324 | type: 'lattice',
|
325 | coords: new Int32Array(ps),
|
326 | colors: new Int32Array(ps),
|
327 | verticesPerRow: verticesPerRow
|
328 | });
|
329 | }
|
330 | var MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3;
|
331 | var MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20;
|
332 | var TRIANGLE_DENSITY = 20;
|
333 | var getB = function getBClosure() {
|
334 | function buildB(count) {
|
335 | var lut = [];
|
336 | for (var i = 0; i <= count; i++) {
|
337 | var t = i / count,
|
338 | t_ = 1 - t;
|
339 | lut.push(new Float32Array([t_ * t_ * t_, 3 * t * t_ * t_, 3 * t * t * t_, t * t * t]));
|
340 | }
|
341 | return lut;
|
342 | }
|
343 | var cache = [];
|
344 | return function getB(count) {
|
345 | if (!cache[count]) {
|
346 | cache[count] = buildB(count);
|
347 | }
|
348 | return cache[count];
|
349 | };
|
350 | }();
|
351 | function buildFigureFromPatch(mesh, index) {
|
352 | var figure = mesh.figures[index];
|
353 | (0, _util.assert)(figure.type === 'patch', 'Unexpected patch mesh figure');
|
354 | var coords = mesh.coords,
|
355 | colors = mesh.colors;
|
356 | var pi = figure.coords;
|
357 | var ci = figure.colors;
|
358 | var figureMinX = Math.min(coords[pi[0]][0], coords[pi[3]][0], coords[pi[12]][0], coords[pi[15]][0]);
|
359 | var figureMinY = Math.min(coords[pi[0]][1], coords[pi[3]][1], coords[pi[12]][1], coords[pi[15]][1]);
|
360 | var figureMaxX = Math.max(coords[pi[0]][0], coords[pi[3]][0], coords[pi[12]][0], coords[pi[15]][0]);
|
361 | var figureMaxY = Math.max(coords[pi[0]][1], coords[pi[3]][1], coords[pi[12]][1], coords[pi[15]][1]);
|
362 | var splitXBy = Math.ceil((figureMaxX - figureMinX) * TRIANGLE_DENSITY / (mesh.bounds[2] - mesh.bounds[0]));
|
363 | splitXBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT, Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitXBy));
|
364 | var splitYBy = Math.ceil((figureMaxY - figureMinY) * TRIANGLE_DENSITY / (mesh.bounds[3] - mesh.bounds[1]));
|
365 | splitYBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT, Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitYBy));
|
366 | var verticesPerRow = splitXBy + 1;
|
367 | var figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow);
|
368 | var figureColors = new Int32Array((splitYBy + 1) * verticesPerRow);
|
369 | var k = 0;
|
370 | var cl = new Uint8Array(3),
|
371 | cr = new Uint8Array(3);
|
372 | var c0 = colors[ci[0]],
|
373 | c1 = colors[ci[1]],
|
374 | c2 = colors[ci[2]],
|
375 | c3 = colors[ci[3]];
|
376 | var bRow = getB(splitYBy),
|
377 | bCol = getB(splitXBy);
|
378 | for (var row = 0; row <= splitYBy; row++) {
|
379 | cl[0] = (c0[0] * (splitYBy - row) + c2[0] * row) / splitYBy | 0;
|
380 | cl[1] = (c0[1] * (splitYBy - row) + c2[1] * row) / splitYBy | 0;
|
381 | cl[2] = (c0[2] * (splitYBy - row) + c2[2] * row) / splitYBy | 0;
|
382 | cr[0] = (c1[0] * (splitYBy - row) + c3[0] * row) / splitYBy | 0;
|
383 | cr[1] = (c1[1] * (splitYBy - row) + c3[1] * row) / splitYBy | 0;
|
384 | cr[2] = (c1[2] * (splitYBy - row) + c3[2] * row) / splitYBy | 0;
|
385 | for (var col = 0; col <= splitXBy; col++, k++) {
|
386 | if ((row === 0 || row === splitYBy) && (col === 0 || col === splitXBy)) {
|
387 | continue;
|
388 | }
|
389 | var x = 0,
|
390 | y = 0;
|
391 | var q = 0;
|
392 | for (var i = 0; i <= 3; i++) {
|
393 | for (var j = 0; j <= 3; j++, q++) {
|
394 | var m = bRow[row][i] * bCol[col][j];
|
395 | x += coords[pi[q]][0] * m;
|
396 | y += coords[pi[q]][1] * m;
|
397 | }
|
398 | }
|
399 | figureCoords[k] = coords.length;
|
400 | coords.push([x, y]);
|
401 | figureColors[k] = colors.length;
|
402 | var newColor = new Uint8Array(3);
|
403 | newColor[0] = (cl[0] * (splitXBy - col) + cr[0] * col) / splitXBy | 0;
|
404 | newColor[1] = (cl[1] * (splitXBy - col) + cr[1] * col) / splitXBy | 0;
|
405 | newColor[2] = (cl[2] * (splitXBy - col) + cr[2] * col) / splitXBy | 0;
|
406 | colors.push(newColor);
|
407 | }
|
408 | }
|
409 | figureCoords[0] = pi[0];
|
410 | figureColors[0] = ci[0];
|
411 | figureCoords[splitXBy] = pi[3];
|
412 | figureColors[splitXBy] = ci[1];
|
413 | figureCoords[verticesPerRow * splitYBy] = pi[12];
|
414 | figureColors[verticesPerRow * splitYBy] = ci[2];
|
415 | figureCoords[verticesPerRow * splitYBy + splitXBy] = pi[15];
|
416 | figureColors[verticesPerRow * splitYBy + splitXBy] = ci[3];
|
417 | mesh.figures[index] = {
|
418 | type: 'lattice',
|
419 | coords: figureCoords,
|
420 | colors: figureColors,
|
421 | verticesPerRow: verticesPerRow
|
422 | };
|
423 | }
|
424 | function decodeType6Shading(mesh, reader) {
|
425 | var coords = mesh.coords;
|
426 | var colors = mesh.colors;
|
427 | var ps = new Int32Array(16);
|
428 | var cs = new Int32Array(4);
|
429 | while (reader.hasData) {
|
430 | var f = reader.readFlag();
|
431 | if (!(0 <= f && f <= 3)) {
|
432 | throw new _util.FormatError('Unknown type6 flag');
|
433 | }
|
434 | var i, ii;
|
435 | var pi = coords.length;
|
436 | for (i = 0, ii = f !== 0 ? 8 : 12; i < ii; i++) {
|
437 | coords.push(reader.readCoordinate());
|
438 | }
|
439 | var ci = colors.length;
|
440 | for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
|
441 | colors.push(reader.readComponents());
|
442 | }
|
443 | var tmp1, tmp2, tmp3, tmp4;
|
444 | switch (f) {
|
445 | case 0:
|
446 | ps[12] = pi + 3;
|
447 | ps[13] = pi + 4;
|
448 | ps[14] = pi + 5;
|
449 | ps[15] = pi + 6;
|
450 | ps[8] = pi + 2;
|
451 | ps[11] = pi + 7;
|
452 | ps[4] = pi + 1;
|
453 | ps[7] = pi + 8;
|
454 | ps[0] = pi;
|
455 | ps[1] = pi + 11;
|
456 | ps[2] = pi + 10;
|
457 | ps[3] = pi + 9;
|
458 | cs[2] = ci + 1;
|
459 | cs[3] = ci + 2;
|
460 | cs[0] = ci;
|
461 | cs[1] = ci + 3;
|
462 | break;
|
463 | case 1:
|
464 | tmp1 = ps[12];
|
465 | tmp2 = ps[13];
|
466 | tmp3 = ps[14];
|
467 | tmp4 = ps[15];
|
468 | ps[12] = tmp4;
|
469 | ps[13] = pi + 0;
|
470 | ps[14] = pi + 1;
|
471 | ps[15] = pi + 2;
|
472 | ps[8] = tmp3;
|
473 | ps[11] = pi + 3;
|
474 | ps[4] = tmp2;
|
475 | ps[7] = pi + 4;
|
476 | ps[0] = tmp1;
|
477 | ps[1] = pi + 7;
|
478 | ps[2] = pi + 6;
|
479 | ps[3] = pi + 5;
|
480 | tmp1 = cs[2];
|
481 | tmp2 = cs[3];
|
482 | cs[2] = tmp2;
|
483 | cs[3] = ci;
|
484 | cs[0] = tmp1;
|
485 | cs[1] = ci + 1;
|
486 | break;
|
487 | case 2:
|
488 | tmp1 = ps[15];
|
489 | tmp2 = ps[11];
|
490 | ps[12] = ps[3];
|
491 | ps[13] = pi + 0;
|
492 | ps[14] = pi + 1;
|
493 | ps[15] = pi + 2;
|
494 | ps[8] = ps[7];
|
495 | ps[11] = pi + 3;
|
496 | ps[4] = tmp2;
|
497 | ps[7] = pi + 4;
|
498 | ps[0] = tmp1;
|
499 | ps[1] = pi + 7;
|
500 | ps[2] = pi + 6;
|
501 | ps[3] = pi + 5;
|
502 | tmp1 = cs[3];
|
503 | cs[2] = cs[1];
|
504 | cs[3] = ci;
|
505 | cs[0] = tmp1;
|
506 | cs[1] = ci + 1;
|
507 | break;
|
508 | case 3:
|
509 | ps[12] = ps[0];
|
510 | ps[13] = pi + 0;
|
511 | ps[14] = pi + 1;
|
512 | ps[15] = pi + 2;
|
513 | ps[8] = ps[1];
|
514 | ps[11] = pi + 3;
|
515 | ps[4] = ps[2];
|
516 | ps[7] = pi + 4;
|
517 | ps[0] = ps[3];
|
518 | ps[1] = pi + 7;
|
519 | ps[2] = pi + 6;
|
520 | ps[3] = pi + 5;
|
521 | cs[2] = cs[0];
|
522 | cs[3] = ci;
|
523 | cs[0] = cs[1];
|
524 | cs[1] = ci + 1;
|
525 | break;
|
526 | }
|
527 | ps[5] = coords.length;
|
528 | coords.push([(-4 * coords[ps[0]][0] - coords[ps[15]][0] + 6 * (coords[ps[4]][0] + coords[ps[1]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[13]][0] + coords[ps[7]][0])) / 9, (-4 * coords[ps[0]][1] - coords[ps[15]][1] + 6 * (coords[ps[4]][1] + coords[ps[1]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[13]][1] + coords[ps[7]][1])) / 9]);
|
529 | ps[6] = coords.length;
|
530 | coords.push([(-4 * coords[ps[3]][0] - coords[ps[12]][0] + 6 * (coords[ps[2]][0] + coords[ps[7]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[4]][0] + coords[ps[14]][0])) / 9, (-4 * coords[ps[3]][1] - coords[ps[12]][1] + 6 * (coords[ps[2]][1] + coords[ps[7]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[4]][1] + coords[ps[14]][1])) / 9]);
|
531 | ps[9] = coords.length;
|
532 | coords.push([(-4 * coords[ps[12]][0] - coords[ps[3]][0] + 6 * (coords[ps[8]][0] + coords[ps[13]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[11]][0] + coords[ps[1]][0])) / 9, (-4 * coords[ps[12]][1] - coords[ps[3]][1] + 6 * (coords[ps[8]][1] + coords[ps[13]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[11]][1] + coords[ps[1]][1])) / 9]);
|
533 | ps[10] = coords.length;
|
534 | coords.push([(-4 * coords[ps[15]][0] - coords[ps[0]][0] + 6 * (coords[ps[11]][0] + coords[ps[14]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[2]][0] + coords[ps[8]][0])) / 9, (-4 * coords[ps[15]][1] - coords[ps[0]][1] + 6 * (coords[ps[11]][1] + coords[ps[14]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[2]][1] + coords[ps[8]][1])) / 9]);
|
535 | mesh.figures.push({
|
536 | type: 'patch',
|
537 | coords: new Int32Array(ps),
|
538 | colors: new Int32Array(cs)
|
539 | });
|
540 | }
|
541 | }
|
542 | function decodeType7Shading(mesh, reader) {
|
543 | var coords = mesh.coords;
|
544 | var colors = mesh.colors;
|
545 | var ps = new Int32Array(16);
|
546 | var cs = new Int32Array(4);
|
547 | while (reader.hasData) {
|
548 | var f = reader.readFlag();
|
549 | if (!(0 <= f && f <= 3)) {
|
550 | throw new _util.FormatError('Unknown type7 flag');
|
551 | }
|
552 | var i, ii;
|
553 | var pi = coords.length;
|
554 | for (i = 0, ii = f !== 0 ? 12 : 16; i < ii; i++) {
|
555 | coords.push(reader.readCoordinate());
|
556 | }
|
557 | var ci = colors.length;
|
558 | for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
|
559 | colors.push(reader.readComponents());
|
560 | }
|
561 | var tmp1, tmp2, tmp3, tmp4;
|
562 | switch (f) {
|
563 | case 0:
|
564 | ps[12] = pi + 3;
|
565 | ps[13] = pi + 4;
|
566 | ps[14] = pi + 5;
|
567 | ps[15] = pi + 6;
|
568 | ps[8] = pi + 2;
|
569 | ps[9] = pi + 13;
|
570 | ps[10] = pi + 14;
|
571 | ps[11] = pi + 7;
|
572 | ps[4] = pi + 1;
|
573 | ps[5] = pi + 12;
|
574 | ps[6] = pi + 15;
|
575 | ps[7] = pi + 8;
|
576 | ps[0] = pi;
|
577 | ps[1] = pi + 11;
|
578 | ps[2] = pi + 10;
|
579 | ps[3] = pi + 9;
|
580 | cs[2] = ci + 1;
|
581 | cs[3] = ci + 2;
|
582 | cs[0] = ci;
|
583 | cs[1] = ci + 3;
|
584 | break;
|
585 | case 1:
|
586 | tmp1 = ps[12];
|
587 | tmp2 = ps[13];
|
588 | tmp3 = ps[14];
|
589 | tmp4 = ps[15];
|
590 | ps[12] = tmp4;
|
591 | ps[13] = pi + 0;
|
592 | ps[14] = pi + 1;
|
593 | ps[15] = pi + 2;
|
594 | ps[8] = tmp3;
|
595 | ps[9] = pi + 9;
|
596 | ps[10] = pi + 10;
|
597 | ps[11] = pi + 3;
|
598 | ps[4] = tmp2;
|
599 | ps[5] = pi + 8;
|
600 | ps[6] = pi + 11;
|
601 | ps[7] = pi + 4;
|
602 | ps[0] = tmp1;
|
603 | ps[1] = pi + 7;
|
604 | ps[2] = pi + 6;
|
605 | ps[3] = pi + 5;
|
606 | tmp1 = cs[2];
|
607 | tmp2 = cs[3];
|
608 | cs[2] = tmp2;
|
609 | cs[3] = ci;
|
610 | cs[0] = tmp1;
|
611 | cs[1] = ci + 1;
|
612 | break;
|
613 | case 2:
|
614 | tmp1 = ps[15];
|
615 | tmp2 = ps[11];
|
616 | ps[12] = ps[3];
|
617 | ps[13] = pi + 0;
|
618 | ps[14] = pi + 1;
|
619 | ps[15] = pi + 2;
|
620 | ps[8] = ps[7];
|
621 | ps[9] = pi + 9;
|
622 | ps[10] = pi + 10;
|
623 | ps[11] = pi + 3;
|
624 | ps[4] = tmp2;
|
625 | ps[5] = pi + 8;
|
626 | ps[6] = pi + 11;
|
627 | ps[7] = pi + 4;
|
628 | ps[0] = tmp1;
|
629 | ps[1] = pi + 7;
|
630 | ps[2] = pi + 6;
|
631 | ps[3] = pi + 5;
|
632 | tmp1 = cs[3];
|
633 | cs[2] = cs[1];
|
634 | cs[3] = ci;
|
635 | cs[0] = tmp1;
|
636 | cs[1] = ci + 1;
|
637 | break;
|
638 | case 3:
|
639 | ps[12] = ps[0];
|
640 | ps[13] = pi + 0;
|
641 | ps[14] = pi + 1;
|
642 | ps[15] = pi + 2;
|
643 | ps[8] = ps[1];
|
644 | ps[9] = pi + 9;
|
645 | ps[10] = pi + 10;
|
646 | ps[11] = pi + 3;
|
647 | ps[4] = ps[2];
|
648 | ps[5] = pi + 8;
|
649 | ps[6] = pi + 11;
|
650 | ps[7] = pi + 4;
|
651 | ps[0] = ps[3];
|
652 | ps[1] = pi + 7;
|
653 | ps[2] = pi + 6;
|
654 | ps[3] = pi + 5;
|
655 | cs[2] = cs[0];
|
656 | cs[3] = ci;
|
657 | cs[0] = cs[1];
|
658 | cs[1] = ci + 1;
|
659 | break;
|
660 | }
|
661 | mesh.figures.push({
|
662 | type: 'patch',
|
663 | coords: new Int32Array(ps),
|
664 | colors: new Int32Array(cs)
|
665 | });
|
666 | }
|
667 | }
|
668 | function updateBounds(mesh) {
|
669 | var minX = mesh.coords[0][0],
|
670 | minY = mesh.coords[0][1],
|
671 | maxX = minX,
|
672 | maxY = minY;
|
673 | for (var i = 1, ii = mesh.coords.length; i < ii; i++) {
|
674 | var x = mesh.coords[i][0],
|
675 | y = mesh.coords[i][1];
|
676 | minX = minX > x ? x : minX;
|
677 | minY = minY > y ? y : minY;
|
678 | maxX = maxX < x ? x : maxX;
|
679 | maxY = maxY < y ? y : maxY;
|
680 | }
|
681 | mesh.bounds = [minX, minY, maxX, maxY];
|
682 | }
|
683 | function packData(mesh) {
|
684 | var i, ii, j, jj;
|
685 | var coords = mesh.coords;
|
686 | var coordsPacked = new Float32Array(coords.length * 2);
|
687 | for (i = 0, j = 0, ii = coords.length; i < ii; i++) {
|
688 | var xy = coords[i];
|
689 | coordsPacked[j++] = xy[0];
|
690 | coordsPacked[j++] = xy[1];
|
691 | }
|
692 | mesh.coords = coordsPacked;
|
693 | var colors = mesh.colors;
|
694 | var colorsPacked = new Uint8Array(colors.length * 3);
|
695 | for (i = 0, j = 0, ii = colors.length; i < ii; i++) {
|
696 | var c = colors[i];
|
697 | colorsPacked[j++] = c[0];
|
698 | colorsPacked[j++] = c[1];
|
699 | colorsPacked[j++] = c[2];
|
700 | }
|
701 | mesh.colors = colorsPacked;
|
702 | var figures = mesh.figures;
|
703 | for (i = 0, ii = figures.length; i < ii; i++) {
|
704 | var figure = figures[i],
|
705 | ps = figure.coords,
|
706 | cs = figure.colors;
|
707 | for (j = 0, jj = ps.length; j < jj; j++) {
|
708 | ps[j] *= 2;
|
709 | cs[j] *= 3;
|
710 | }
|
711 | }
|
712 | }
|
713 | function Mesh(stream, matrix, xref, res, pdfFunctionFactory) {
|
714 | if (!(0, _primitives.isStream)(stream)) {
|
715 | throw new _util.FormatError('Mesh data is not a stream');
|
716 | }
|
717 | var dict = stream.dict;
|
718 | this.matrix = matrix;
|
719 | this.shadingType = dict.get('ShadingType');
|
720 | this.type = 'Pattern';
|
721 | this.bbox = dict.getArray('BBox');
|
722 | var cs = dict.get('ColorSpace', 'CS');
|
723 | cs = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
|
724 | this.cs = cs;
|
725 | this.background = dict.has('Background') ? cs.getRgb(dict.get('Background'), 0) : null;
|
726 | var fnObj = dict.get('Function');
|
727 | var fn = fnObj ? pdfFunctionFactory.createFromArray(fnObj) : null;
|
728 | this.coords = [];
|
729 | this.colors = [];
|
730 | this.figures = [];
|
731 | var decodeContext = {
|
732 | bitsPerCoordinate: dict.get('BitsPerCoordinate'),
|
733 | bitsPerComponent: dict.get('BitsPerComponent'),
|
734 | bitsPerFlag: dict.get('BitsPerFlag'),
|
735 | decode: dict.getArray('Decode'),
|
736 | colorFn: fn,
|
737 | colorSpace: cs,
|
738 | numComps: fn ? 1 : cs.numComps
|
739 | };
|
740 | var reader = new MeshStreamReader(stream, decodeContext);
|
741 | var patchMesh = false;
|
742 | switch (this.shadingType) {
|
743 | case ShadingType.FREE_FORM_MESH:
|
744 | decodeType4Shading(this, reader);
|
745 | break;
|
746 | case ShadingType.LATTICE_FORM_MESH:
|
747 | var verticesPerRow = dict.get('VerticesPerRow') | 0;
|
748 | if (verticesPerRow < 2) {
|
749 | throw new _util.FormatError('Invalid VerticesPerRow');
|
750 | }
|
751 | decodeType5Shading(this, reader, verticesPerRow);
|
752 | break;
|
753 | case ShadingType.COONS_PATCH_MESH:
|
754 | decodeType6Shading(this, reader);
|
755 | patchMesh = true;
|
756 | break;
|
757 | case ShadingType.TENSOR_PATCH_MESH:
|
758 | decodeType7Shading(this, reader);
|
759 | patchMesh = true;
|
760 | break;
|
761 | default:
|
762 | (0, _util.unreachable)('Unsupported mesh type.');
|
763 | break;
|
764 | }
|
765 | if (patchMesh) {
|
766 | updateBounds(this);
|
767 | for (var i = 0, ii = this.figures.length; i < ii; i++) {
|
768 | buildFigureFromPatch(this, i);
|
769 | }
|
770 | }
|
771 | updateBounds(this);
|
772 | packData(this);
|
773 | }
|
774 | Mesh.prototype = {
|
775 | getIR: function Mesh_getIR() {
|
776 | return ['Mesh', this.shadingType, this.coords, this.colors, this.figures, this.bounds, this.matrix, this.bbox, this.background];
|
777 | }
|
778 | };
|
779 | return Mesh;
|
780 | }();
|
781 | Shadings.Dummy = function DummyClosure() {
|
782 | function Dummy() {
|
783 | this.type = 'Pattern';
|
784 | }
|
785 | Dummy.prototype = {
|
786 | getIR: function Dummy_getIR() {
|
787 | return ['Dummy'];
|
788 | }
|
789 | };
|
790 | return Dummy;
|
791 | }();
|
792 | function getTilingPatternIR(operatorList, dict, args) {
|
793 | var matrix = dict.getArray('Matrix');
|
794 | var bbox = _util.Util.normalizeRect(dict.getArray('BBox'));
|
795 | var xstep = dict.get('XStep');
|
796 | var ystep = dict.get('YStep');
|
797 | var paintType = dict.get('PaintType');
|
798 | var tilingType = dict.get('TilingType');
|
799 | if (bbox[2] - bbox[0] === 0 || bbox[3] - bbox[1] === 0) {
|
800 | throw new _util.FormatError('Invalid getTilingPatternIR /BBox array: [' + bbox + '].');
|
801 | }
|
802 | return ['TilingPattern', args, operatorList, matrix, bbox, xstep, ystep, paintType, tilingType];
|
803 | }
|
804 | exports.Pattern = Pattern;
|
805 | exports.getTilingPatternIR = getTilingPatternIR; |
\ | No newline at end of file |