]> Raphaƫl G. Git Repositories - cdn/blob - vendor/phpqrcode/phpqrcode.php
Add ausweis generator
[cdn] / vendor / phpqrcode / phpqrcode.php
1 <?php
2
3 /*
4 * PHP QR Code encoder
5 *
6 * This file contains MERGED version of PHP QR Code library.
7 * It was auto-generated from full version for your convenience.
8 *
9 * This merged version was configured to not require any external files,
10 * with disabled cache, error logging and weaker but faster mask matching.
11 * If you need tune it up please use non-merged version.
12 *
13 * For full version, documentation, examples of use please visit:
14 *
15 * http://phpqrcode.sourceforge.net/
16 * https://sourceforge.net/projects/phpqrcode/
17 * https://github.com/t0k4rt/phpqrcode
18 *
19 * PHP QR Code is distributed under LGPL 3
20 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
21 *
22 * This library is free software; you can redistribute it and/or
23 * modify it under the terms of the GNU Lesser General Public
24 * License as published by the Free Software Foundation; either
25 * version 3 of the License, or any later version.
26 *
27 * This library is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
30 * Lesser General Public License for more details.
31 *
32 * You should have received a copy of the GNU Lesser General Public
33 * License along with this library; if not, write to the Free Software
34 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
35 */
36
37
38
39 /*
40 * Version: 1.1.4
41 * Build: 2010100721
42 */
43
44
45
46 //---- qrconst.php -----------------------------
47
48
49
50
51
52 /*
53 * PHP QR Code encoder
54 *
55 * Common constants
56 *
57 * Based on libqrencode C library distributed under LGPL 2.1
58 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <fukuchi@megaui.net>
59 *
60 * PHP QR Code is distributed under LGPL 3
61 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
62 *
63 * This library is free software; you can redistribute it and/or
64 * modify it under the terms of the GNU Lesser General Public
65 * License as published by the Free Software Foundation; either
66 * version 3 of the License, or any later version.
67 *
68 * This library is distributed in the hope that it will be useful,
69 * but WITHOUT ANY WARRANTY; without even the implied warranty of
70 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
71 * Lesser General Public License for more details.
72 *
73 * You should have received a copy of the GNU Lesser General Public
74 * License along with this library; if not, write to the Free Software
75 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
76 */
77
78 // Encoding modes
79
80 define('QR_MODE_NUL', -1);
81 define('QR_MODE_NUM', 0);
82 define('QR_MODE_AN', 1);
83 define('QR_MODE_8', 2);
84 define('QR_MODE_KANJI', 3);
85 define('QR_MODE_STRUCTURE', 4);
86
87 // Levels of error correction.
88
89 define('QR_ECLEVEL_L', 0);
90 define('QR_ECLEVEL_M', 1);
91 define('QR_ECLEVEL_Q', 2);
92 define('QR_ECLEVEL_H', 3);
93
94 // Supported output formats
95
96 define('QR_FORMAT_TEXT', 0);
97 define('QR_FORMAT_PNG', 1);
98
99 class qrstr {
100 public static function set(&$srctab, $x, $y, $repl, $replLen = false) {
101 $srctab[$y] = substr_replace($srctab[$y], ($replLen !== false)?substr($repl,0,$replLen):$repl, $x, ($replLen !== false)?$replLen:strlen($repl));
102 }
103 }
104
105
106
107 //---- merged_config.php -----------------------------
108
109
110
111
112 /*
113 * PHP QR Code encoder
114 *
115 * Config file, tuned-up for merged verion
116 */
117
118 define('QR_CACHEABLE', false); // use cache - more disk reads but less CPU power, masks and format templates are stored there
119 define('QR_CACHE_DIR', false); // used when QR_CACHEABLE === true
120 define('QR_LOG_DIR', false); // default error logs dir
121
122 define('QR_FIND_BEST_MASK', true); // if true, estimates best mask (spec. default, but extremally slow; set to false to significant performance boost but (propably) worst quality code
123 define('QR_FIND_FROM_RANDOM', 2); // if false, checks all masks available, otherwise value tells count of masks need to be checked, mask id are got randomly
124 define('QR_DEFAULT_MASK', 2); // when QR_FIND_BEST_MASK === false
125
126 define('QR_PNG_MAXIMUM_SIZE', 1024); // maximum allowed png image width (in pixels), tune to make sure GD and PHP can handle such big images
127
128
129
130
131 //---- qrtools.php -----------------------------
132
133
134
135
136 /*
137 * PHP QR Code encoder
138 *
139 * Toolset, handy and debug utilites.
140 *
141 * PHP QR Code is distributed under LGPL 3
142 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
143 *
144 * This library is free software; you can redistribute it and/or
145 * modify it under the terms of the GNU Lesser General Public
146 * License as published by the Free Software Foundation; either
147 * version 3 of the License, or any later version.
148 *
149 * This library is distributed in the hope that it will be useful,
150 * but WITHOUT ANY WARRANTY; without even the implied warranty of
151 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
152 * Lesser General Public License for more details.
153 *
154 * You should have received a copy of the GNU Lesser General Public
155 * License along with this library; if not, write to the Free Software
156 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
157 */
158
159 class QRtools {
160
161 //----------------------------------------------------------------------
162 public static function binarize($frame)
163 {
164 $len = count($frame);
165 foreach ($frame as &$frameLine) {
166
167 for($i=0; $i<$len; $i++) {
168 $frameLine[$i] = (ord($frameLine[$i])&1)?'1':'0';
169 }
170 }
171
172 return $frame;
173 }
174
175 //----------------------------------------------------------------------
176 public static function tcpdfBarcodeArray($code, $mode = 'QR,L', $tcPdfVersion = '4.5.037')
177 {
178 $barcode_array = array();
179
180 if (!is_array($mode))
181 $mode = explode(',', $mode);
182
183 $eccLevel = 'L';
184
185 if (count($mode) > 1) {
186 $eccLevel = $mode[1];
187 }
188
189 $qrTab = QRcode::text($code, false, $eccLevel);
190 $size = count($qrTab);
191
192 $barcode_array['num_rows'] = $size;
193 $barcode_array['num_cols'] = $size;
194 $barcode_array['bcode'] = array();
195
196 foreach ($qrTab as $line) {
197 $arrAdd = array();
198 foreach(str_split($line) as $char)
199 $arrAdd[] = ($char=='1')?1:0;
200 $barcode_array['bcode'][] = $arrAdd;
201 }
202
203 return $barcode_array;
204 }
205
206 //----------------------------------------------------------------------
207 public static function clearCache()
208 {
209 self::$frames = array();
210 }
211
212 //----------------------------------------------------------------------
213 public static function buildCache()
214 {
215 QRtools::markTime('before_build_cache');
216
217 $mask = new QRmask();
218 for ($a=1; $a <= QRSPEC_VERSION_MAX; $a++) {
219 $frame = QRspec::newFrame($a);
220 if (QR_IMAGE) {
221 $fileName = QR_CACHE_DIR.'frame_'.$a.'.png';
222 QRimage::png(self::binarize($frame), $fileName, 1, 0);
223 }
224
225 $width = count($frame);
226 $bitMask = array_fill(0, $width, array_fill(0, $width, 0));
227 for ($maskNo=0; $maskNo<8; $maskNo++)
228 $mask->makeMaskNo($maskNo, $width, $frame, $bitMask, true);
229 }
230
231 QRtools::markTime('after_build_cache');
232 }
233
234 //----------------------------------------------------------------------
235 public static function log($outfile, $err)
236 {
237 if (QR_LOG_DIR !== false) {
238 if ($err != '') {
239 if ($outfile !== false) {
240 file_put_contents(QR_LOG_DIR.basename($outfile).'-errors.txt', date('Y-m-d H:i:s').': '.$err, FILE_APPEND);
241 } else {
242 file_put_contents(QR_LOG_DIR.'errors.txt', date('Y-m-d H:i:s').': '.$err, FILE_APPEND);
243 }
244 }
245 }
246 }
247
248 //----------------------------------------------------------------------
249 public static function dumpMask($frame)
250 {
251 $width = count($frame);
252 for($y=0;$y<$width;$y++) {
253 for($x=0;$x<$width;$x++) {
254 echo ord($frame[$y][$x]).',';
255 }
256 }
257 }
258
259 //----------------------------------------------------------------------
260 public static function markTime($markerId)
261 {
262 list($usec, $sec) = explode(" ", microtime());
263 $time = ((float)$usec + (float)$sec);
264
265 if (!isset($GLOBALS['qr_time_bench']))
266 $GLOBALS['qr_time_bench'] = array();
267
268 $GLOBALS['qr_time_bench'][$markerId] = $time;
269 }
270
271 //----------------------------------------------------------------------
272 public static function timeBenchmark()
273 {
274 self::markTime('finish');
275
276 $lastTime = 0;
277 $startTime = 0;
278 $p = 0;
279
280 echo '<table cellpadding="3" cellspacing="1">
281 <thead><tr style="border-bottom:1px solid silver"><td colspan="2" style="text-align:center">BENCHMARK</td></tr></thead>
282 <tbody>';
283
284 foreach($GLOBALS['qr_time_bench'] as $markerId=>$thisTime) {
285 if ($p > 0) {
286 echo '<tr><th style="text-align:right">till '.$markerId.': </th><td>'.number_format($thisTime-$lastTime, 6).'s</td></tr>';
287 } else {
288 $startTime = $thisTime;
289 }
290
291 $p++;
292 $lastTime = $thisTime;
293 }
294
295 echo '</tbody><tfoot>
296 <tr style="border-top:2px solid black"><th style="text-align:right">TOTAL: </th><td>'.number_format($lastTime-$startTime, 6).'s</td></tr>
297 </tfoot>
298 </table>';
299 }
300
301 public static function save($content, $filename_path)
302 {
303 try {
304 $handle = fopen($filename_path, "w");
305 fwrite($handle, $content);
306 fclose($handle);
307 return true;
308 } catch (Exception $e) {
309 echo 'Exception reƧue : ', $e->getMessage(), "\n";
310 }
311
312 }
313
314 }
315
316 //##########################################################################
317
318 QRtools::markTime('start');
319
320
321
322
323 //---- qrspec.php -----------------------------
324
325
326
327
328 /*
329 * PHP QR Code encoder
330 *
331 * QR Code specifications
332 *
333 * Based on libqrencode C library distributed under LGPL 2.1
334 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <fukuchi@megaui.net>
335 *
336 * PHP QR Code is distributed under LGPL 3
337 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
338 *
339 * The following data / specifications are taken from
340 * "Two dimensional symbol -- QR-code -- Basic Specification" (JIS X0510:2004)
341 * or
342 * "Automatic identification and data capture techniques --
343 * QR Code 2005 bar code symbology specification" (ISO/IEC 18004:2006)
344 *
345 * This library is free software; you can redistribute it and/or
346 * modify it under the terms of the GNU Lesser General Public
347 * License as published by the Free Software Foundation; either
348 * version 3 of the License, or any later version.
349 *
350 * This library is distributed in the hope that it will be useful,
351 * but WITHOUT ANY WARRANTY; without even the implied warranty of
352 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
353 * Lesser General Public License for more details.
354 *
355 * You should have received a copy of the GNU Lesser General Public
356 * License along with this library; if not, write to the Free Software
357 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
358 */
359
360 define('QRSPEC_VERSION_MAX', 40);
361 define('QRSPEC_WIDTH_MAX', 177);
362
363 define('QRCAP_WIDTH', 0);
364 define('QRCAP_WORDS', 1);
365 define('QRCAP_REMINDER', 2);
366 define('QRCAP_EC', 3);
367
368 class QRspec {
369
370 public static $capacity = array(
371 array( 0, 0, 0, array( 0, 0, 0, 0)),
372 array( 21, 26, 0, array( 7, 10, 13, 17)), // 1
373 array( 25, 44, 7, array( 10, 16, 22, 28)),
374 array( 29, 70, 7, array( 15, 26, 36, 44)),
375 array( 33, 100, 7, array( 20, 36, 52, 64)),
376 array( 37, 134, 7, array( 26, 48, 72, 88)), // 5
377 array( 41, 172, 7, array( 36, 64, 96, 112)),
378 array( 45, 196, 0, array( 40, 72, 108, 130)),
379 array( 49, 242, 0, array( 48, 88, 132, 156)),
380 array( 53, 292, 0, array( 60, 110, 160, 192)),
381 array( 57, 346, 0, array( 72, 130, 192, 224)), //10
382 array( 61, 404, 0, array( 80, 150, 224, 264)),
383 array( 65, 466, 0, array( 96, 176, 260, 308)),
384 array( 69, 532, 0, array( 104, 198, 288, 352)),
385 array( 73, 581, 3, array( 120, 216, 320, 384)),
386 array( 77, 655, 3, array( 132, 240, 360, 432)), //15
387 array( 81, 733, 3, array( 144, 280, 408, 480)),
388 array( 85, 815, 3, array( 168, 308, 448, 532)),
389 array( 89, 901, 3, array( 180, 338, 504, 588)),
390 array( 93, 991, 3, array( 196, 364, 546, 650)),
391 array( 97, 1085, 3, array( 224, 416, 600, 700)), //20
392 array(101, 1156, 4, array( 224, 442, 644, 750)),
393 array(105, 1258, 4, array( 252, 476, 690, 816)),
394 array(109, 1364, 4, array( 270, 504, 750, 900)),
395 array(113, 1474, 4, array( 300, 560, 810, 960)),
396 array(117, 1588, 4, array( 312, 588, 870, 1050)), //25
397 array(121, 1706, 4, array( 336, 644, 952, 1110)),
398 array(125, 1828, 4, array( 360, 700, 1020, 1200)),
399 array(129, 1921, 3, array( 390, 728, 1050, 1260)),
400 array(133, 2051, 3, array( 420, 784, 1140, 1350)),
401 array(137, 2185, 3, array( 450, 812, 1200, 1440)), //30
402 array(141, 2323, 3, array( 480, 868, 1290, 1530)),
403 array(145, 2465, 3, array( 510, 924, 1350, 1620)),
404 array(149, 2611, 3, array( 540, 980, 1440, 1710)),
405 array(153, 2761, 3, array( 570, 1036, 1530, 1800)),
406 array(157, 2876, 0, array( 570, 1064, 1590, 1890)), //35
407 array(161, 3034, 0, array( 600, 1120, 1680, 1980)),
408 array(165, 3196, 0, array( 630, 1204, 1770, 2100)),
409 array(169, 3362, 0, array( 660, 1260, 1860, 2220)),
410 array(173, 3532, 0, array( 720, 1316, 1950, 2310)),
411 array(177, 3706, 0, array( 750, 1372, 2040, 2430)) //40
412 );
413
414 //----------------------------------------------------------------------
415 public static function getDataLength($version, $level)
416 {
417 return self::$capacity[$version][QRCAP_WORDS] - self::$capacity[$version][QRCAP_EC][$level];
418 }
419
420 //----------------------------------------------------------------------
421 public static function getECCLength($version, $level)
422 {
423 return self::$capacity[$version][QRCAP_EC][$level];
424 }
425
426 //----------------------------------------------------------------------
427 public static function getWidth($version)
428 {
429 return self::$capacity[$version][QRCAP_WIDTH];
430 }
431
432 //----------------------------------------------------------------------
433 public static function getRemainder($version)
434 {
435 return self::$capacity[$version][QRCAP_REMINDER];
436 }
437
438 //----------------------------------------------------------------------
439 public static function getMinimumVersion($size, $level)
440 {
441
442 for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
443 $words = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
444 if($words >= $size)
445 return $i;
446 }
447
448 return -1;
449 }
450
451 //######################################################################
452
453 public static $lengthTableBits = array(
454 array(10, 12, 14),
455 array( 9, 11, 13),
456 array( 8, 16, 16),
457 array( 8, 10, 12)
458 );
459
460 //----------------------------------------------------------------------
461 public static function lengthIndicator($mode, $version)
462 {
463 if ($mode == QR_MODE_STRUCTURE)
464 return 0;
465
466 if ($version <= 9) {
467 $l = 0;
468 } else if ($version <= 26) {
469 $l = 1;
470 } else {
471 $l = 2;
472 }
473
474 return self::$lengthTableBits[$mode][$l];
475 }
476
477 //----------------------------------------------------------------------
478 public static function maximumWords($mode, $version)
479 {
480 if($mode == QR_MODE_STRUCTURE)
481 return 3;
482
483 if($version <= 9) {
484 $l = 0;
485 } else if($version <= 26) {
486 $l = 1;
487 } else {
488 $l = 2;
489 }
490
491 $bits = self::$lengthTableBits[$mode][$l];
492 $words = (1 << $bits) - 1;
493
494 if($mode == QR_MODE_KANJI) {
495 $words *= 2; // the number of bytes is required
496 }
497
498 return $words;
499 }
500
501 // Error correction code -----------------------------------------------
502 // Table of the error correction code (Reed-Solomon block)
503 // See Table 12-16 (pp.30-36), JIS X0510:2004.
504
505 public static $eccTable = array(
506 array(array( 0, 0), array( 0, 0), array( 0, 0), array( 0, 0)),
507 array(array( 1, 0), array( 1, 0), array( 1, 0), array( 1, 0)), // 1
508 array(array( 1, 0), array( 1, 0), array( 1, 0), array( 1, 0)),
509 array(array( 1, 0), array( 1, 0), array( 2, 0), array( 2, 0)),
510 array(array( 1, 0), array( 2, 0), array( 2, 0), array( 4, 0)),
511 array(array( 1, 0), array( 2, 0), array( 2, 2), array( 2, 2)), // 5
512 array(array( 2, 0), array( 4, 0), array( 4, 0), array( 4, 0)),
513 array(array( 2, 0), array( 4, 0), array( 2, 4), array( 4, 1)),
514 array(array( 2, 0), array( 2, 2), array( 4, 2), array( 4, 2)),
515 array(array( 2, 0), array( 3, 2), array( 4, 4), array( 4, 4)),
516 array(array( 2, 2), array( 4, 1), array( 6, 2), array( 6, 2)), //10
517 array(array( 4, 0), array( 1, 4), array( 4, 4), array( 3, 8)),
518 array(array( 2, 2), array( 6, 2), array( 4, 6), array( 7, 4)),
519 array(array( 4, 0), array( 8, 1), array( 8, 4), array(12, 4)),
520 array(array( 3, 1), array( 4, 5), array(11, 5), array(11, 5)),
521 array(array( 5, 1), array( 5, 5), array( 5, 7), array(11, 7)), //15
522 array(array( 5, 1), array( 7, 3), array(15, 2), array( 3, 13)),
523 array(array( 1, 5), array(10, 1), array( 1, 15), array( 2, 17)),
524 array(array( 5, 1), array( 9, 4), array(17, 1), array( 2, 19)),
525 array(array( 3, 4), array( 3, 11), array(17, 4), array( 9, 16)),
526 array(array( 3, 5), array( 3, 13), array(15, 5), array(15, 10)), //20
527 array(array( 4, 4), array(17, 0), array(17, 6), array(19, 6)),
528 array(array( 2, 7), array(17, 0), array( 7, 16), array(34, 0)),
529 array(array( 4, 5), array( 4, 14), array(11, 14), array(16, 14)),
530 array(array( 6, 4), array( 6, 14), array(11, 16), array(30, 2)),
531 array(array( 8, 4), array( 8, 13), array( 7, 22), array(22, 13)), //25
532 array(array(10, 2), array(19, 4), array(28, 6), array(33, 4)),
533 array(array( 8, 4), array(22, 3), array( 8, 26), array(12, 28)),
534 array(array( 3, 10), array( 3, 23), array( 4, 31), array(11, 31)),
535 array(array( 7, 7), array(21, 7), array( 1, 37), array(19, 26)),
536 array(array( 5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
537 array(array(13, 3), array( 2, 29), array(42, 1), array(23, 28)),
538 array(array(17, 0), array(10, 23), array(10, 35), array(19, 35)),
539 array(array(17, 1), array(14, 21), array(29, 19), array(11, 46)),
540 array(array(13, 6), array(14, 23), array(44, 7), array(59, 1)),
541 array(array(12, 7), array(12, 26), array(39, 14), array(22, 41)), //35
542 array(array( 6, 14), array( 6, 34), array(46, 10), array( 2, 64)),
543 array(array(17, 4), array(29, 14), array(49, 10), array(24, 46)),
544 array(array( 4, 18), array(13, 32), array(48, 14), array(42, 32)),
545 array(array(20, 4), array(40, 7), array(43, 22), array(10, 67)),
546 array(array(19, 6), array(18, 31), array(34, 34), array(20, 61)),//40
547 );
548
549 //----------------------------------------------------------------------
550 // CACHEABLE!!!
551
552 public static function getEccSpec($version, $level, array &$spec)
553 {
554 if (count($spec) < 5) {
555 $spec = array(0,0,0,0,0);
556 }
557
558 $b1 = self::$eccTable[$version][$level][0];
559 $b2 = self::$eccTable[$version][$level][1];
560 $data = self::getDataLength($version, $level);
561 $ecc = self::getECCLength($version, $level);
562
563 if($b2 == 0) {
564 $spec[0] = $b1;
565 $spec[1] = (int)($data / $b1);
566 $spec[2] = (int)($ecc / $b1);
567 $spec[3] = 0;
568 $spec[4] = 0;
569 } else {
570 $spec[0] = $b1;
571 $spec[1] = (int)($data / ($b1 + $b2));
572 $spec[2] = (int)($ecc / ($b1 + $b2));
573 $spec[3] = $b2;
574 $spec[4] = $spec[1] + 1;
575 }
576 }
577
578 // Alignment pattern ---------------------------------------------------
579
580 // Positions of alignment patterns.
581 // This array includes only the second and the third position of the
582 // alignment patterns. Rest of them can be calculated from the distance
583 // between them.
584
585 // See Table 1 in Appendix E (pp.71) of JIS X0510:2004.
586
587 public static $alignmentPattern = array(
588 array( 0, 0),
589 array( 0, 0), array(18, 0), array(22, 0), array(26, 0), array(30, 0), // 1- 5
590 array(34, 0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
591 array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), //11-15
592 array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), //16-20
593 array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), //21-25
594 array(30, 58), array(34, 62), array(26, 50), array(30, 54), array(26, 52), //26-30
595 array(30, 56), array(34, 60), array(30, 58), array(34, 62), array(30, 54), //31-35
596 array(24, 50), array(28, 54), array(32, 58), array(26, 54), array(30, 58), //35-40
597 );
598
599
600 /** --------------------------------------------------------------------
601 * Put an alignment marker.
602 * @param frame
603 * @param width
604 * @param ox,oy center coordinate of the pattern
605 */
606 public static function putAlignmentMarker(array &$frame, $ox, $oy)
607 {
608 $finder = array(
609 "\xa1\xa1\xa1\xa1\xa1",
610 "\xa1\xa0\xa0\xa0\xa1",
611 "\xa1\xa0\xa1\xa0\xa1",
612 "\xa1\xa0\xa0\xa0\xa1",
613 "\xa1\xa1\xa1\xa1\xa1"
614 );
615
616 $yStart = $oy-2;
617 $xStart = $ox-2;
618
619 for($y=0; $y<5; $y++) {
620 QRstr::set($frame, $xStart, $yStart+$y, $finder[$y]);
621 }
622 }
623
624 //----------------------------------------------------------------------
625 public static function putAlignmentPattern($version, &$frame, $width)
626 {
627 if($version < 2)
628 return;
629
630 $d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
631 if($d < 0) {
632 $w = 2;
633 } else {
634 $w = (int)(($width - self::$alignmentPattern[$version][0]) / $d + 2);
635 }
636
637 if($w * $w - 3 == 1) {
638 $x = self::$alignmentPattern[$version][0];
639 $y = self::$alignmentPattern[$version][0];
640 self::putAlignmentMarker($frame, $x, $y);
641 return;
642 }
643
644 $cx = self::$alignmentPattern[$version][0];
645 for($x=1; $x<$w - 1; $x++) {
646 self::putAlignmentMarker($frame, 6, $cx);
647 self::putAlignmentMarker($frame, $cx, 6);
648 $cx += $d;
649 }
650
651 $cy = self::$alignmentPattern[$version][0];
652 for($y=0; $y<$w-1; $y++) {
653 $cx = self::$alignmentPattern[$version][0];
654 for($x=0; $x<$w-1; $x++) {
655 self::putAlignmentMarker($frame, $cx, $cy);
656 $cx += $d;
657 }
658 $cy += $d;
659 }
660 }
661
662 // Version information pattern -----------------------------------------
663
664 // Version information pattern (BCH coded).
665 // See Table 1 in Appendix D (pp.68) of JIS X0510:2004.
666
667 // size: [QRSPEC_VERSION_MAX - 6]
668
669 public static $versionPattern = array(
670 0x07c94, 0x085bc, 0x09a99, 0x0a4d3, 0x0bbf6, 0x0c762, 0x0d847, 0x0e60d,
671 0x0f928, 0x10b78, 0x1145d, 0x12a17, 0x13532, 0x149a6, 0x15683, 0x168c9,
672 0x177ec, 0x18ec4, 0x191e1, 0x1afab, 0x1b08e, 0x1cc1a, 0x1d33f, 0x1ed75,
673 0x1f250, 0x209d5, 0x216f0, 0x228ba, 0x2379f, 0x24b0b, 0x2542e, 0x26a64,
674 0x27541, 0x28c69
675 );
676
677 //----------------------------------------------------------------------
678 public static function getVersionPattern($version)
679 {
680 if($version < 7 || $version > QRSPEC_VERSION_MAX)
681 return 0;
682
683 return self::$versionPattern[$version -7];
684 }
685
686 // Format information --------------------------------------------------
687 // See calcFormatInfo in tests/test_qrspec.c (orginal qrencode c lib)
688
689 public static $formatInfo = array(
690 array(0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976),
691 array(0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0),
692 array(0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed),
693 array(0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b)
694 );
695
696 public static function getFormatInfo($mask, $level)
697 {
698 if($mask < 0 || $mask > 7)
699 return 0;
700
701 if($level < 0 || $level > 3)
702 return 0;
703
704 return self::$formatInfo[$level][$mask];
705 }
706
707 // Frame ---------------------------------------------------------------
708 // Cache of initial frames.
709
710 public static $frames = array();
711
712 /** --------------------------------------------------------------------
713 * Put a finder pattern.
714 * @param frame
715 * @param width
716 * @param ox,oy upper-left coordinate of the pattern
717 */
718 public static function putFinderPattern(&$frame, $ox, $oy)
719 {
720 $finder = array(
721 "\xc1\xc1\xc1\xc1\xc1\xc1\xc1",
722 "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
723 "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
724 "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
725 "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
726 "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
727 "\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
728 );
729
730 for($y=0; $y<7; $y++) {
731 QRstr::set($frame, $ox, $oy+$y, $finder[$y]);
732 }
733 }
734
735 //----------------------------------------------------------------------
736 public static function createFrame($version)
737 {
738 $width = self::$capacity[$version][QRCAP_WIDTH];
739 $frameLine = str_repeat ("\0", $width);
740 $frame = array_fill(0, $width, $frameLine);
741
742 // Finder pattern
743 self::putFinderPattern($frame, 0, 0);
744 self::putFinderPattern($frame, $width - 7, 0);
745 self::putFinderPattern($frame, 0, $width - 7);
746
747 // Separator
748 $yOffset = $width - 7;
749
750 for($y=0; $y<7; $y++) {
751 $frame[$y][7] = "\xc0";
752 $frame[$y][$width - 8] = "\xc0";
753 $frame[$yOffset][7] = "\xc0";
754 $yOffset++;
755 }
756
757 $setPattern = str_repeat("\xc0", 8);
758
759 QRstr::set($frame, 0, 7, $setPattern);
760 QRstr::set($frame, $width-8, 7, $setPattern);
761 QRstr::set($frame, 0, $width - 8, $setPattern);
762
763 // Format info
764 $setPattern = str_repeat("\x84", 9);
765 QRstr::set($frame, 0, 8, $setPattern);
766 QRstr::set($frame, $width - 8, 8, $setPattern, 8);
767
768 $yOffset = $width - 8;
769
770 for($y=0; $y<8; $y++,$yOffset++) {
771 $frame[$y][8] = "\x84";
772 $frame[$yOffset][8] = "\x84";
773 }
774
775 // Timing pattern
776
777 for($i=1; $i<$width-15; $i++) {
778 $frame[6][7+$i] = chr(0x90 | ($i & 1));
779 $frame[7+$i][6] = chr(0x90 | ($i & 1));
780 }
781
782 // Alignment pattern
783 self::putAlignmentPattern($version, $frame, $width);
784
785 // Version information
786 if($version >= 7) {
787 $vinf = self::getVersionPattern($version);
788
789 $v = $vinf;
790
791 for($x=0; $x<6; $x++) {
792 for($y=0; $y<3; $y++) {
793 $frame[($width - 11)+$y][$x] = chr(0x88 | ($v & 1));
794 $v = $v >> 1;
795 }
796 }
797
798 $v = $vinf;
799 for($y=0; $y<6; $y++) {
800 for($x=0; $x<3; $x++) {
801 $frame[$y][$x+($width - 11)] = chr(0x88 | ($v & 1));
802 $v = $v >> 1;
803 }
804 }
805 }
806
807 // and a little bit...
808 $frame[$width - 8][8] = "\x81";
809
810 return $frame;
811 }
812
813 //----------------------------------------------------------------------
814 public static function debug($frame, $binary_mode = false)
815 {
816 if ($binary_mode) {
817
818 foreach ($frame as &$frameLine) {
819 $frameLine = join('<span class="m">&nbsp;&nbsp;</span>', explode('0', $frameLine));
820 $frameLine = join('&#9608;&#9608;', explode('1', $frameLine));
821 }
822
823 ?>
824 <style>
825 .m { background-color: white; }
826 </style>
827 <?php
828 echo '<pre><tt><br/ ><br/ ><br/ >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;';
829 echo join("<br/ >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", $frame);
830 echo '</tt></pre><br/ ><br/ ><br/ ><br/ ><br/ ><br/ >';
831
832 } else {
833
834 foreach ($frame as &$frameLine) {
835 $frameLine = join('<span class="m">&nbsp;</span>', explode("\xc0", $frameLine));
836 $frameLine = join('<span class="m">&#9618;</span>', explode("\xc1", $frameLine));
837 $frameLine = join('<span class="p">&nbsp;</span>', explode("\xa0", $frameLine));
838 $frameLine = join('<span class="p">&#9618;</span>', explode("\xa1", $frameLine));
839 $frameLine = join('<span class="s">&#9671;</span>', explode("\x84", $frameLine)); //format 0
840 $frameLine = join('<span class="s">&#9670;</span>', explode("\x85", $frameLine)); //format 1
841 $frameLine = join('<span class="x">&#9762;</span>', explode("\x81", $frameLine)); //special bit
842 $frameLine = join('<span class="c">&nbsp;</span>', explode("\x90", $frameLine)); //clock 0
843 $frameLine = join('<span class="c">&#9719;</span>', explode("\x91", $frameLine)); //clock 1
844 $frameLine = join('<span class="f">&nbsp;</span>', explode("\x88", $frameLine)); //version
845 $frameLine = join('<span class="f">&#9618;</span>', explode("\x89", $frameLine)); //version
846 $frameLine = join('&#9830;', explode("\x01", $frameLine));
847 $frameLine = join('&#8901;', explode("\0", $frameLine));
848 }
849
850 ?>
851 <style>
852 .p { background-color: yellow; }
853 .m { background-color: #00FF00; }
854 .s { background-color: #FF0000; }
855 .c { background-color: aqua; }
856 .x { background-color: pink; }
857 .f { background-color: gold; }
858 </style>
859 <?php
860 echo "<pre><tt>";
861 echo join("<br/ >", $frame);
862 echo "</tt></pre>";
863
864 }
865 }
866
867 //----------------------------------------------------------------------
868 public static function serial($frame)
869 {
870 return gzcompress(join("\n", $frame), 9);
871 }
872
873 //----------------------------------------------------------------------
874 public static function unserial($code)
875 {
876 return explode("\n", gzuncompress($code));
877 }
878
879 //----------------------------------------------------------------------
880 public static function newFrame($version)
881 {
882 if($version < 1 || $version > QRSPEC_VERSION_MAX)
883 return null;
884
885 if(!isset(self::$frames[$version])) {
886
887 $fileName = QR_CACHE_DIR.'frame_'.$version.'.dat';
888
889 if (QR_CACHEABLE) {
890 if (file_exists($fileName)) {
891 self::$frames[$version] = self::unserial(file_get_contents($fileName));
892 } else {
893 self::$frames[$version] = self::createFrame($version);
894 file_put_contents($fileName, self::serial(self::$frames[$version]));
895 }
896 } else {
897 self::$frames[$version] = self::createFrame($version);
898 }
899 }
900
901 if(is_null(self::$frames[$version]))
902 return null;
903
904 return self::$frames[$version];
905 }
906
907 //----------------------------------------------------------------------
908 public static function rsBlockNum($spec) { return $spec[0] + $spec[3]; }
909 public static function rsBlockNum1($spec) { return $spec[0]; }
910 public static function rsDataCodes1($spec) { return $spec[1]; }
911 public static function rsEccCodes1($spec) { return $spec[2]; }
912 public static function rsBlockNum2($spec) { return $spec[3]; }
913 public static function rsDataCodes2($spec) { return $spec[4]; }
914 public static function rsEccCodes2($spec) { return $spec[2]; }
915 public static function rsDataLength($spec) { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]); }
916 public static function rsEccLength($spec) { return ($spec[0] + $spec[3]) * $spec[2]; }
917
918 }
919
920
921
922 //---- qrimage.php -----------------------------
923
924
925
926
927 /*
928 * PHP QR Code encoder
929 *
930 * Image output of code using GD2
931 *
932 * PHP QR Code is distributed under LGPL 3
933 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
934 *
935 * This library is free software; you can redistribute it and/or
936 * modify it under the terms of the GNU Lesser General Public
937 * License as published by the Free Software Foundation; either
938 * version 3 of the License, or any later version.
939 *
940 * This library is distributed in the hope that it will be useful,
941 * but WITHOUT ANY WARRANTY; without even the implied warranty of
942 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
943 * Lesser General Public License for more details.
944 *
945 * You should have received a copy of the GNU Lesser General Public
946 * License along with this library; if not, write to the Free Software
947 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
948 */
949
950 define('QR_IMAGE', true);
951
952 class QRimage {
953
954 //----------------------------------------------------------------------
955 public static function png($frame, $filename = false, $pixelPerPoint = 4, $outerFrame = 4,$saveandprint=FALSE, $back_color, $fore_color)
956 {
957 $image = self::image($frame, $pixelPerPoint, $outerFrame, $back_color, $fore_color);
958
959 if ($filename === false) {
960 Header("Content-type: image/png");
961 ImagePng($image);
962 } else {
963 if($saveandprint===TRUE){
964 ImagePng($image, $filename);
965 header("Content-type: image/png");
966 ImagePng($image);
967 }else{
968 ImagePng($image, $filename);
969 }
970 }
971
972 ImageDestroy($image);
973 }
974
975 //----------------------------------------------------------------------
976 public static function jpg($frame, $filename = false, $pixelPerPoint = 8, $outerFrame = 4, $q = 85)
977 {
978 $image = self::image($frame, $pixelPerPoint, $outerFrame);
979
980 if ($filename === false) {
981 Header("Content-type: image/jpeg");
982 ImageJpeg($image, null, $q);
983 } else {
984 ImageJpeg($image, $filename, $q);
985 }
986
987 ImageDestroy($image);
988 }
989
990 //----------------------------------------------------------------------
991 private static function image($frame, $pixelPerPoint = 4, $outerFrame = 4, $back_color = 0xFFFFFF, $fore_color = 0x000000)
992 {
993 $h = count($frame);
994 $w = strlen($frame[0]);
995
996 $imgW = $w + 2*$outerFrame;
997 $imgH = $h + 2*$outerFrame;
998
999 $base_image =ImageCreate($imgW, $imgH);
1000
1001 // convert a hexadecimal color code into decimal format (red = 255 0 0, green = 0 255 0, blue = 0 0 255)
1002 $r1 = round((($fore_color & 0xFF0000) >> 16), 5);
1003 $g1 = round((($fore_color & 0x00FF00) >> 8), 5);
1004 $b1 = round(($fore_color & 0x0000FF), 5);
1005
1006 // convert a hexadecimal color code into decimal format (red = 255 0 0, green = 0 255 0, blue = 0 0 255)
1007 $r2 = round((($back_color & 0xFF0000) >> 16), 5);
1008 $g2 = round((($back_color & 0x00FF00) >> 8), 5);
1009 $b2 = round(($back_color & 0x0000FF), 5);
1010
1011
1012
1013 $col[0] = ImageColorAllocate($base_image, $r2, $g2, $b2);
1014 $col[1] = ImageColorAllocate($base_image, $r1, $g1, $b1);
1015
1016 imagefill($base_image, 0, 0, $col[0]);
1017
1018 for($y=0; $y<$h; $y++) {
1019 for($x=0; $x<$w; $x++) {
1020 if ($frame[$y][$x] == '1') {
1021 ImageSetPixel($base_image,$x+$outerFrame,$y+$outerFrame,$col[1]);
1022 }
1023 }
1024 }
1025
1026 $target_image =ImageCreate($imgW * $pixelPerPoint, $imgH * $pixelPerPoint);
1027 ImageCopyResized($target_image, $base_image, 0, 0, 0, 0, $imgW * $pixelPerPoint, $imgH * $pixelPerPoint, $imgW, $imgH);
1028 ImageDestroy($base_image);
1029
1030 return $target_image;
1031 }
1032 }
1033
1034
1035
1036
1037 //---- qrinput.php -----------------------------
1038
1039
1040
1041
1042 /*
1043 * PHP QR Code encoder
1044 *
1045 * Input encoding class
1046 *
1047 * Based on libqrencode C library distributed under LGPL 2.1
1048 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <fukuchi@megaui.net>
1049 *
1050 * PHP QR Code is distributed under LGPL 3
1051 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
1052 *
1053 * This library is free software; you can redistribute it and/or
1054 * modify it under the terms of the GNU Lesser General Public
1055 * License as published by the Free Software Foundation; either
1056 * version 3 of the License, or any later version.
1057 *
1058 * This library is distributed in the hope that it will be useful,
1059 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1060 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1061 * Lesser General Public License for more details.
1062 *
1063 * You should have received a copy of the GNU Lesser General Public
1064 * License along with this library; if not, write to the Free Software
1065 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1066 */
1067
1068 define('STRUCTURE_HEADER_BITS', 20);
1069 define('MAX_STRUCTURED_SYMBOLS', 16);
1070
1071 class QRinputItem {
1072
1073 public $mode;
1074 public $size;
1075 public $data;
1076 public $bstream;
1077
1078 public function __construct($mode, $size, $data, $bstream = null)
1079 {
1080 $setData = array_slice($data, 0, $size);
1081
1082 if (count($setData) < $size) {
1083 $setData = array_merge($setData, array_fill(0,$size-count($setData),0));
1084 }
1085
1086 if(!QRinput::check($mode, $size, $setData)) {
1087 throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',',$setData));
1088 }
1089
1090 $this->mode = $mode;
1091 $this->size = $size;
1092 $this->data = $setData;
1093 $this->bstream = $bstream;
1094 }
1095
1096 //----------------------------------------------------------------------
1097 public function encodeModeNum($version)
1098 {
1099 try {
1100
1101 $words = (int)($this->size / 3);
1102 $bs = new QRbitstream();
1103
1104 $val = 0x1;
1105 $bs->appendNum(4, $val);
1106 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_NUM, $version), $this->size);
1107
1108 for($i=0; $i<$words; $i++) {
1109 $val = (ord($this->data[$i*3 ]) - ord('0')) * 100;
1110 $val += (ord($this->data[$i*3+1]) - ord('0')) * 10;
1111 $val += (ord($this->data[$i*3+2]) - ord('0'));
1112 $bs->appendNum(10, $val);
1113 }
1114
1115 if($this->size - $words * 3 == 1) {
1116 $val = ord($this->data[$words*3]) - ord('0');
1117 $bs->appendNum(4, $val);
1118 } else if($this->size - $words * 3 == 2) {
1119 $val = (ord($this->data[$words*3 ]) - ord('0')) * 10;
1120 $val += (ord($this->data[$words*3+1]) - ord('0'));
1121 $bs->appendNum(7, $val);
1122 }
1123
1124 $this->bstream = $bs;
1125 return 0;
1126
1127 } catch (Exception $e) {
1128 return -1;
1129 }
1130 }
1131
1132 //----------------------------------------------------------------------
1133 public function encodeModeAn($version)
1134 {
1135 try {
1136 $words = (int)($this->size / 2);
1137 $bs = new QRbitstream();
1138
1139 $bs->appendNum(4, 0x02);
1140 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_AN, $version), $this->size);
1141
1142 for($i=0; $i<$words; $i++) {
1143 $val = (int)QRinput::lookAnTable(ord($this->data[$i*2 ])) * 45;
1144 $val += (int)QRinput::lookAnTable(ord($this->data[$i*2+1]));
1145
1146 $bs->appendNum(11, $val);
1147 }
1148
1149 if($this->size & 1) {
1150 $val = QRinput::lookAnTable(ord($this->data[$words * 2]));
1151 $bs->appendNum(6, $val);
1152 }
1153
1154 $this->bstream = $bs;
1155 return 0;
1156
1157 } catch (Exception $e) {
1158 return -1;
1159 }
1160 }
1161
1162 //----------------------------------------------------------------------
1163 public function encodeMode8($version)
1164 {
1165 try {
1166 $bs = new QRbitstream();
1167
1168 $bs->appendNum(4, 0x4);
1169 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_8, $version), $this->size);
1170
1171 for($i=0; $i<$this->size; $i++) {
1172 $bs->appendNum(8, ord($this->data[$i]));
1173 }
1174
1175 $this->bstream = $bs;
1176 return 0;
1177
1178 } catch (Exception $e) {
1179 return -1;
1180 }
1181 }
1182
1183 //----------------------------------------------------------------------
1184 public function encodeModeKanji($version)
1185 {
1186 try {
1187
1188 $bs = new QRbitrtream();
1189
1190 $bs->appendNum(4, 0x8);
1191 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int)($this->size / 2));
1192
1193 for($i=0; $i<$this->size; $i+=2) {
1194 $val = (ord($this->data[$i]) << 8) | ord($this->data[$i+1]);
1195 if($val <= 0x9ffc) {
1196 $val -= 0x8140;
1197 } else {
1198 $val -= 0xc140;
1199 }
1200
1201 $h = ($val >> 8) * 0xc0;
1202 $val = ($val & 0xff) + $h;
1203
1204 $bs->appendNum(13, $val);
1205 }
1206
1207 $this->bstream = $bs;
1208 return 0;
1209
1210 } catch (Exception $e) {
1211 return -1;
1212 }
1213 }
1214
1215 //----------------------------------------------------------------------
1216 public function encodeModeStructure()
1217 {
1218 try {
1219 $bs = new QRbitstream();
1220
1221 $bs->appendNum(4, 0x03);
1222 $bs->appendNum(4, ord($this->data[1]) - 1);
1223 $bs->appendNum(4, ord($this->data[0]) - 1);
1224 $bs->appendNum(8, ord($this->data[2]));
1225
1226 $this->bstream = $bs;
1227 return 0;
1228
1229 } catch (Exception $e) {
1230 return -1;
1231 }
1232 }
1233
1234 //----------------------------------------------------------------------
1235 public function estimateBitStreamSizeOfEntry($version)
1236 {
1237 $bits = 0;
1238
1239 if($version == 0)
1240 $version = 1;
1241
1242 switch($this->mode) {
1243 case QR_MODE_NUM: $bits = QRinput::estimateBitsModeNum($this->size); break;
1244 case QR_MODE_AN: $bits = QRinput::estimateBitsModeAn($this->size); break;
1245 case QR_MODE_8: $bits = QRinput::estimateBitsMode8($this->size); break;
1246 case QR_MODE_KANJI: $bits = QRinput::estimateBitsModeKanji($this->size);break;
1247 case QR_MODE_STRUCTURE: return STRUCTURE_HEADER_BITS;
1248 default:
1249 return 0;
1250 }
1251
1252 $l = QRspec::lengthIndicator($this->mode, $version);
1253 $m = 1 << $l;
1254 $num = (int)(($this->size + $m - 1) / $m);
1255
1256 $bits += $num * (4 + $l);
1257
1258 return $bits;
1259 }
1260
1261 //----------------------------------------------------------------------
1262 public function encodeBitStream($version)
1263 {
1264 try {
1265
1266 unset($this->bstream);
1267 $words = QRspec::maximumWords($this->mode, $version);
1268
1269 if($this->size > $words) {
1270
1271 $st1 = new QRinputItem($this->mode, $words, $this->data);
1272 $st2 = new QRinputItem($this->mode, $this->size - $words, array_slice($this->data, $words));
1273
1274 $st1->encodeBitStream($version);
1275 $st2->encodeBitStream($version);
1276
1277 $this->bstream = new QRbitstream();
1278 $this->bstream->append($st1->bstream);
1279 $this->bstream->append($st2->bstream);
1280
1281 unset($st1);
1282 unset($st2);
1283
1284 } else {
1285
1286 $ret = 0;
1287
1288 switch($this->mode) {
1289 case QR_MODE_NUM: $ret = $this->encodeModeNum($version); break;
1290 case QR_MODE_AN: $ret = $this->encodeModeAn($version); break;
1291 case QR_MODE_8: $ret = $this->encodeMode8($version); break;
1292 case QR_MODE_KANJI: $ret = $this->encodeModeKanji($version);break;
1293 case QR_MODE_STRUCTURE: $ret = $this->encodeModeStructure(); break;
1294
1295 default:
1296 break;
1297 }
1298
1299 if($ret < 0)
1300 return -1;
1301 }
1302
1303 return $this->bstream->size();
1304
1305 } catch (Exception $e) {
1306 return -1;
1307 }
1308 }
1309 };
1310
1311 //##########################################################################
1312
1313 class QRinput {
1314
1315 public $items;
1316
1317 private $version;
1318 private $level;
1319
1320 //----------------------------------------------------------------------
1321 public function __construct($version = 0, $level = QR_ECLEVEL_L)
1322 {
1323 if ($version < 0 || $version > QRSPEC_VERSION_MAX || $level > QR_ECLEVEL_H) {
1324 throw new Exception('Invalid version no');
1325 }
1326
1327 $this->version = $version;
1328 $this->level = $level;
1329 }
1330
1331 //----------------------------------------------------------------------
1332 public function getVersion()
1333 {
1334 return $this->version;
1335 }
1336
1337 //----------------------------------------------------------------------
1338 public function setVersion($version)
1339 {
1340 if($version < 0 || $version > QRSPEC_VERSION_MAX) {
1341 throw new Exception('Invalid version no');
1342 return -1;
1343 }
1344
1345 $this->version = $version;
1346
1347 return 0;
1348 }
1349
1350 //----------------------------------------------------------------------
1351 public function getErrorCorrectionLevel()
1352 {
1353 return $this->level;
1354 }
1355
1356 //----------------------------------------------------------------------
1357 public function setErrorCorrectionLevel($level)
1358 {
1359 if($level > QR_ECLEVEL_H) {
1360 throw new Exception('Invalid ECLEVEL');
1361 return -1;
1362 }
1363
1364 $this->level = $level;
1365
1366 return 0;
1367 }
1368
1369 //----------------------------------------------------------------------
1370 public function appendEntry(QRinputItem $entry)
1371 {
1372 $this->items[] = $entry;
1373 }
1374
1375 //----------------------------------------------------------------------
1376 public function append($mode, $size, $data)
1377 {
1378 try {
1379 $entry = new QRinputItem($mode, $size, $data);
1380 $this->items[] = $entry;
1381 return 0;
1382 } catch (Exception $e) {
1383 return -1;
1384 }
1385 }
1386
1387 //----------------------------------------------------------------------
1388
1389 public function insertStructuredAppendHeader($size, $index, $parity)
1390 {
1391 if( $size > MAX_STRUCTURED_SYMBOLS ) {
1392 throw new Exception('insertStructuredAppendHeader wrong size');
1393 }
1394
1395 if( $index <= 0 || $index > MAX_STRUCTURED_SYMBOLS ) {
1396 throw new Exception('insertStructuredAppendHeader wrong index');
1397 }
1398
1399 $buf = array($size, $index, $parity);
1400
1401 try {
1402 $entry = new QRinputItem(QR_MODE_STRUCTURE, 3, buf);
1403 array_unshift($this->items, $entry);
1404 return 0;
1405 } catch (Exception $e) {
1406 return -1;
1407 }
1408 }
1409
1410 //----------------------------------------------------------------------
1411 public function calcParity()
1412 {
1413 $parity = 0;
1414
1415 foreach($this->items as $item) {
1416 if($item->mode != QR_MODE_STRUCTURE) {
1417 for($i=$item->size-1; $i>=0; $i--) {
1418 $parity ^= $item->data[$i];
1419 }
1420 }
1421 }
1422
1423 return $parity;
1424 }
1425
1426 //----------------------------------------------------------------------
1427 public static function checkModeNum($size, $data)
1428 {
1429 for($i=0; $i<$size; $i++) {
1430 if((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))){
1431 return false;
1432 }
1433 }
1434
1435 return true;
1436 }
1437
1438 //----------------------------------------------------------------------
1439 public static function estimateBitsModeNum($size)
1440 {
1441 $w = (int)$size / 3;
1442 $bits = $w * 10;
1443
1444 switch($size - $w * 3) {
1445 case 1:
1446 $bits += 4;
1447 break;
1448 case 2:
1449 $bits += 7;
1450 break;
1451 default:
1452 break;
1453 }
1454
1455 return $bits;
1456 }
1457
1458 //----------------------------------------------------------------------
1459 public static $anTable = array(
1460 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1461 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1462 36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
1463 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1,
1464 -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1465 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
1466 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1467 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1468 );
1469
1470 //----------------------------------------------------------------------
1471 public static function lookAnTable($c)
1472 {
1473 return (($c > 127)?-1:self::$anTable[$c]);
1474 }
1475
1476 //----------------------------------------------------------------------
1477 public static function checkModeAn($size, $data)
1478 {
1479 for($i=0; $i<$size; $i++) {
1480 if (self::lookAnTable(ord($data[$i])) == -1) {
1481 return false;
1482 }
1483 }
1484
1485 return true;
1486 }
1487
1488 //----------------------------------------------------------------------
1489 public static function estimateBitsModeAn($size)
1490 {
1491 $w = (int)($size / 2);
1492 $bits = $w * 11;
1493
1494 if($size & 1) {
1495 $bits += 6;
1496 }
1497
1498 return $bits;
1499 }
1500
1501 //----------------------------------------------------------------------
1502 public static function estimateBitsMode8($size)
1503 {
1504 return $size * 8;
1505 }
1506
1507 //----------------------------------------------------------------------
1508 public function estimateBitsModeKanji($size)
1509 {
1510 return (int)(($size / 2) * 13);
1511 }
1512
1513 //----------------------------------------------------------------------
1514 public static function checkModeKanji($size, $data)
1515 {
1516 if($size & 1)
1517 return false;
1518
1519 for($i=0; $i<$size; $i+=2) {
1520 $val = (ord($data[$i]) << 8) | ord($data[$i+1]);
1521 if( $val < 0x8140
1522 || ($val > 0x9ffc && $val < 0xe040)
1523 || $val > 0xebbf) {
1524 return false;
1525 }
1526 }
1527
1528 return true;
1529 }
1530
1531 /***********************************************************************
1532 * Validation
1533 **********************************************************************/
1534
1535 public static function check($mode, $size, $data)
1536 {
1537 if($size <= 0)
1538 return false;
1539
1540 switch($mode) {
1541 case QR_MODE_NUM: return self::checkModeNum($size, $data); break;
1542 case QR_MODE_AN: return self::checkModeAn($size, $data); break;
1543 case QR_MODE_KANJI: return self::checkModeKanji($size, $data); break;
1544 case QR_MODE_8: return true; break;
1545 case QR_MODE_STRUCTURE: return true; break;
1546
1547 default:
1548 break;
1549 }
1550
1551 return false;
1552 }
1553
1554
1555 //----------------------------------------------------------------------
1556 public function estimateBitStreamSize($version)
1557 {
1558 $bits = 0;
1559
1560 foreach($this->items as $item) {
1561 $bits += $item->estimateBitStreamSizeOfEntry($version);
1562 }
1563
1564 return $bits;
1565 }
1566
1567 //----------------------------------------------------------------------
1568 public function estimateVersion()
1569 {
1570 $version = 0;
1571 $prev = 0;
1572 do {
1573 $prev = $version;
1574 $bits = $this->estimateBitStreamSize($prev);
1575 $version = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
1576 if ($version < 0) {
1577 return -1;
1578 }
1579 } while ($version > $prev);
1580
1581 return $version;
1582 }
1583
1584 //----------------------------------------------------------------------
1585 public static function lengthOfCode($mode, $version, $bits)
1586 {
1587 $payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
1588 switch($mode) {
1589 case QR_MODE_NUM:
1590 $chunks = (int)($payload / 10);
1591 $remain = $payload - $chunks * 10;
1592 $size = $chunks * 3;
1593 if($remain >= 7) {
1594 $size += 2;
1595 } else if($remain >= 4) {
1596 $size += 1;
1597 }
1598 break;
1599 case QR_MODE_AN:
1600 $chunks = (int)($payload / 11);
1601 $remain = $payload - $chunks * 11;
1602 $size = $chunks * 2;
1603 if($remain >= 6)
1604 $size++;
1605 break;
1606 case QR_MODE_8:
1607 $size = (int)($payload / 8);
1608 break;
1609 case QR_MODE_KANJI:
1610 $size = (int)(($payload / 13) * 2);
1611 break;
1612 case QR_MODE_STRUCTURE:
1613 $size = (int)($payload / 8);
1614 break;
1615 default:
1616 $size = 0;
1617 break;
1618 }
1619
1620 $maxsize = QRspec::maximumWords($mode, $version);
1621 if($size < 0) $size = 0;
1622 if($size > $maxsize) $size = $maxsize;
1623
1624 return $size;
1625 }
1626
1627 //----------------------------------------------------------------------
1628 public function createBitStream()
1629 {
1630 $total = 0;
1631
1632 foreach($this->items as $item) {
1633 $bits = $item->encodeBitStream($this->version);
1634
1635 if($bits < 0)
1636 return -1;
1637
1638 $total += $bits;
1639 }
1640
1641 return $total;
1642 }
1643
1644 //----------------------------------------------------------------------
1645 public function convertData()
1646 {
1647 $ver = $this->estimateVersion();
1648 if($ver > $this->getVersion()) {
1649 $this->setVersion($ver);
1650 }
1651
1652 for(;;) {
1653 $bits = $this->createBitStream();
1654
1655 if($bits < 0)
1656 return -1;
1657
1658 $ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
1659 if($ver < 0) {
1660 throw new Exception('WRONG VERSION');
1661 } else if($ver > $this->getVersion()) {
1662 $this->setVersion($ver);
1663 } else {
1664 break;
1665 }
1666 }
1667
1668 return 0;
1669 }
1670
1671 //----------------------------------------------------------------------
1672 public function appendPaddingBit(&$bstream)
1673 {
1674 $bits = $bstream->size();
1675 $maxwords = QRspec::getDataLength($this->version, $this->level);
1676 $maxbits = $maxwords * 8;
1677
1678 if ($maxbits == $bits) {
1679 return 0;
1680 }
1681
1682 if ($maxbits - $bits < 5) {
1683 return $bstream->appendNum($maxbits - $bits, 0);
1684 }
1685
1686 $bits += 4;
1687 $words = (int)(($bits + 7) / 8);
1688
1689 $padding = new QRbitstream();
1690 $ret = $padding->appendNum($words * 8 - $bits + 4, 0);
1691
1692 if($ret < 0)
1693 return $ret;
1694
1695 $padlen = $maxwords - $words;
1696
1697 if($padlen > 0) {
1698
1699 $padbuf = array();
1700 for($i=0; $i<$padlen; $i++) {
1701 $padbuf[$i] = ($i&1)?0x11:0xec;
1702 }
1703
1704 $ret = $padding->appendBytes($padlen, $padbuf);
1705
1706 if($ret < 0)
1707 return $ret;
1708
1709 }
1710
1711 $ret = $bstream->append($padding);
1712
1713 return $ret;
1714 }
1715
1716 //----------------------------------------------------------------------
1717 public function mergeBitStream()
1718 {
1719 if($this->convertData() < 0) {
1720 return null;
1721 }
1722
1723 $bstream = new QRbitstream();
1724
1725 foreach($this->items as $item) {
1726 $ret = $bstream->append($item->bstream);
1727 if($ret < 0) {
1728 return null;
1729 }
1730 }
1731
1732 return $bstream;
1733 }
1734
1735 //----------------------------------------------------------------------
1736 public function getBitStream()
1737 {
1738
1739 $bstream = $this->mergeBitStream();
1740
1741 if($bstream == null) {
1742 return null;
1743 }
1744
1745 $ret = $this->appendPaddingBit($bstream);
1746 if($ret < 0) {
1747 return null;
1748 }
1749
1750 return $bstream;
1751 }
1752
1753 //----------------------------------------------------------------------
1754 public function getByteStream()
1755 {
1756 $bstream = $this->getBitStream();
1757 if($bstream == null) {
1758 return null;
1759 }
1760
1761 return $bstream->toByte();
1762 }
1763 }
1764
1765
1766
1767
1768
1769
1770 //---- qrbitstream.php -----------------------------
1771
1772
1773
1774
1775 /*
1776 * PHP QR Code encoder
1777 *
1778 * Bitstream class
1779 *
1780 * Based on libqrencode C library distributed under LGPL 2.1
1781 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <fukuchi@megaui.net>
1782 *
1783 * PHP QR Code is distributed under LGPL 3
1784 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
1785 *
1786 * This library is free software; you can redistribute it and/or
1787 * modify it under the terms of the GNU Lesser General Public
1788 * License as published by the Free Software Foundation; either
1789 * version 3 of the License, or any later version.
1790 *
1791 * This library is distributed in the hope that it will be useful,
1792 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1793 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1794 * Lesser General Public License for more details.
1795 *
1796 * You should have received a copy of the GNU Lesser General Public
1797 * License along with this library; if not, write to the Free Software
1798 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1799 */
1800
1801 class QRbitstream {
1802
1803 public $data = array();
1804
1805 //----------------------------------------------------------------------
1806 public function size()
1807 {
1808 return count($this->data);
1809 }
1810
1811 //----------------------------------------------------------------------
1812 public function allocate($setLength)
1813 {
1814 $this->data = array_fill(0, $setLength, 0);
1815 return 0;
1816 }
1817
1818 //----------------------------------------------------------------------
1819 public static function newFromNum($bits, $num)
1820 {
1821 $bstream = new QRbitstream();
1822 $bstream->allocate($bits);
1823
1824 $mask = 1 << ($bits - 1);
1825 for($i=0; $i<$bits; $i++) {
1826 if($num & $mask) {
1827 $bstream->data[$i] = 1;
1828 } else {
1829 $bstream->data[$i] = 0;
1830 }
1831 $mask = $mask >> 1;
1832 }
1833
1834 return $bstream;
1835 }
1836
1837 //----------------------------------------------------------------------
1838 public static function newFromBytes($size, $data)
1839 {
1840 $bstream = new QRbitstream();
1841 $bstream->allocate($size * 8);
1842 $p=0;
1843
1844 for($i=0; $i<$size; $i++) {
1845 $mask = 0x80;
1846 for($j=0; $j<8; $j++) {
1847 if($data[$i] & $mask) {
1848 $bstream->data[$p] = 1;
1849 } else {
1850 $bstream->data[$p] = 0;
1851 }
1852 $p++;
1853 $mask = $mask >> 1;
1854 }
1855 }
1856
1857 return $bstream;
1858 }
1859
1860 //----------------------------------------------------------------------
1861 public function append(QRbitstream $arg)
1862 {
1863 if (is_null($arg)) {
1864 return -1;
1865 }
1866
1867 if($arg->size() == 0) {
1868 return 0;
1869 }
1870
1871 if($this->size() == 0) {
1872 $this->data = $arg->data;
1873 return 0;
1874 }
1875
1876 $this->data = array_values(array_merge($this->data, $arg->data));
1877
1878 return 0;
1879 }
1880
1881 //----------------------------------------------------------------------
1882 public function appendNum($bits, $num)
1883 {
1884 if ($bits == 0)
1885 return 0;
1886
1887 $b = QRbitstream::newFromNum($bits, $num);
1888
1889 if(is_null($b))
1890 return -1;
1891
1892 $ret = $this->append($b);
1893 unset($b);
1894
1895 return $ret;
1896 }
1897
1898 //----------------------------------------------------------------------
1899 public function appendBytes($size, $data)
1900 {
1901 if ($size == 0)
1902 return 0;
1903
1904 $b = QRbitstream::newFromBytes($size, $data);
1905
1906 if(is_null($b))
1907 return -1;
1908
1909 $ret = $this->append($b);
1910 unset($b);
1911
1912 return $ret;
1913 }
1914
1915 //----------------------------------------------------------------------
1916 public function toByte()
1917 {
1918
1919 $size = $this->size();
1920
1921 if($size == 0) {
1922 return array();
1923 }
1924
1925 $data = array_fill(0, (int)(($size + 7) / 8), 0);
1926 $bytes = (int)($size / 8);
1927
1928 $p = 0;
1929
1930 for($i=0; $i<$bytes; $i++) {
1931 $v = 0;
1932 for($j=0; $j<8; $j++) {
1933 $v = $v << 1;
1934 $v |= $this->data[$p];
1935 $p++;
1936 }
1937 $data[$i] = $v;
1938 }
1939
1940 if($size & 7) {
1941 $v = 0;
1942 for($j=0; $j<($size & 7); $j++) {
1943 $v = $v << 1;
1944 $v |= $this->data[$p];
1945 $p++;
1946 }
1947 $data[$bytes] = $v;
1948 }
1949
1950 return $data;
1951 }
1952
1953 }
1954
1955
1956
1957
1958 //---- qrsplit.php -----------------------------
1959
1960
1961
1962
1963 /*
1964 * PHP QR Code encoder
1965 *
1966 * Input splitting classes
1967 *
1968 * Based on libqrencode C library distributed under LGPL 2.1
1969 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <fukuchi@megaui.net>
1970 *
1971 * PHP QR Code is distributed under LGPL 3
1972 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
1973 *
1974 * The following data / specifications are taken from
1975 * "Two dimensional symbol -- QR-code -- Basic Specification" (JIS X0510:2004)
1976 * or
1977 * "Automatic identification and data capture techniques --
1978 * QR Code 2005 bar code symbology specification" (ISO/IEC 18004:2006)
1979 *
1980 * This library is free software; you can redistribute it and/or
1981 * modify it under the terms of the GNU Lesser General Public
1982 * License as published by the Free Software Foundation; either
1983 * version 3 of the License, or any later version.
1984 *
1985 * This library is distributed in the hope that it will be useful,
1986 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1987 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1988 * Lesser General Public License for more details.
1989 *
1990 * You should have received a copy of the GNU Lesser General Public
1991 * License along with this library; if not, write to the Free Software
1992 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1993 */
1994 class QRsplit {
1995
1996 public $dataStr = '';
1997 public $input;
1998 public $modeHint;
1999
2000 //----------------------------------------------------------------------
2001 public function __construct($dataStr, $input, $modeHint)
2002 {
2003 $this->dataStr = $dataStr;
2004 $this->input = $input;
2005 $this->modeHint = $modeHint;
2006 }
2007
2008 //----------------------------------------------------------------------
2009 public static function isdigitat($str, $pos)
2010 {
2011 if ($pos >= strlen($str))
2012 return false;
2013
2014 return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
2015 }
2016
2017 //----------------------------------------------------------------------
2018 public static function isalnumat($str, $pos)
2019 {
2020 if ($pos >= strlen($str))
2021 return false;
2022
2023 return (QRinput::lookAnTable(ord($str[$pos])) >= 0);
2024 }
2025
2026 //----------------------------------------------------------------------
2027 public function identifyMode($pos)
2028 {
2029 if ($pos >= strlen($this->dataStr))
2030 return QR_MODE_NUL;
2031
2032 $c = $this->dataStr[$pos];
2033
2034 if(self::isdigitat($this->dataStr, $pos)) {
2035 return QR_MODE_NUM;
2036 } else if(self::isalnumat($this->dataStr, $pos)) {
2037 return QR_MODE_AN;
2038 } else if($this->modeHint == QR_MODE_KANJI) {
2039
2040 if ($pos+1 < strlen($this->dataStr))
2041 {
2042 $d = $this->dataStr[$pos+1];
2043 $word = (ord($c) << 8) | ord($d);
2044 if(($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
2045 return QR_MODE_KANJI;
2046 }
2047 }
2048 }
2049
2050 return QR_MODE_8;
2051 }
2052
2053 //----------------------------------------------------------------------
2054 public function eatNum()
2055 {
2056 $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
2057
2058 $p = 0;
2059 while(self::isdigitat($this->dataStr, $p)) {
2060 $p++;
2061 }
2062
2063 $run = $p;
2064 $mode = $this->identifyMode($p);
2065
2066 if($mode == QR_MODE_8) {
2067 $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
2068 + QRinput::estimateBitsMode8(1) // + 4 + l8
2069 - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
2070 if($dif > 0) {
2071 return $this->eat8();
2072 }
2073 }
2074 if($mode == QR_MODE_AN) {
2075 $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
2076 + QRinput::estimateBitsModeAn(1) // + 4 + la
2077 - QRinput::estimateBitsModeAn($run + 1);// - 4 - la
2078 if($dif > 0) {
2079 return $this->eatAn();
2080 }
2081 }
2082
2083 $ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
2084 if($ret < 0)
2085 return -1;
2086
2087 return $run;
2088 }
2089
2090 //----------------------------------------------------------------------
2091 public function eatAn()
2092 {
2093 $la = QRspec::lengthIndicator(QR_MODE_AN, $this->input->getVersion());
2094 $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
2095
2096 $p = 0;
2097
2098 while(self::isalnumat($this->dataStr, $p)) {
2099 if(self::isdigitat($this->dataStr, $p)) {
2100 $q = $p;
2101 while(self::isdigitat($this->dataStr, $q)) {
2102 $q++;
2103 }
2104
2105 $dif = QRinput::estimateBitsModeAn($p) // + 4 + la
2106 + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
2107 - QRinput::estimateBitsModeAn($q); // - 4 - la
2108
2109 if($dif < 0) {
2110 break;
2111 } else {
2112 $p = $q;
2113 }
2114 } else {
2115 $p++;
2116 }
2117 }
2118
2119 $run = $p;
2120
2121 if(!self::isalnumat($this->dataStr, $p)) {
2122 $dif = QRinput::estimateBitsModeAn($run) + 4 + $la
2123 + QRinput::estimateBitsMode8(1) // + 4 + l8
2124 - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
2125 if($dif > 0) {
2126 return $this->eat8();
2127 }
2128 }
2129
2130 $ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
2131 if($ret < 0)
2132 return -1;
2133
2134 return $run;
2135 }
2136
2137 //----------------------------------------------------------------------
2138 public function eatKanji()
2139 {
2140 $p = 0;
2141
2142 while($this->identifyMode($p) == QR_MODE_KANJI) {
2143 $p += 2;
2144 }
2145
2146 $ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
2147 if($ret < 0)
2148 return -1;
2149
2150 return $ret;
2151 }
2152
2153 //----------------------------------------------------------------------
2154 public function eat8()
2155 {
2156 $la = QRspec::lengthIndicator(QR_MODE_AN, $this->input->getVersion());
2157 $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
2158
2159 $p = 1;
2160 $dataStrLen = strlen($this->dataStr);
2161
2162 while($p < $dataStrLen) {
2163
2164 $mode = $this->identifyMode($p);
2165 if($mode == QR_MODE_KANJI) {
2166 break;
2167 }
2168 if($mode == QR_MODE_NUM) {
2169 $q = $p;
2170 while(self::isdigitat($this->dataStr, $q)) {
2171 $q++;
2172 }
2173 $dif = QRinput::estimateBitsMode8($p) // + 4 + l8
2174 + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
2175 - QRinput::estimateBitsMode8($q); // - 4 - l8
2176 if($dif < 0) {
2177 break;
2178 } else {
2179 $p = $q;
2180 }
2181 } else if($mode == QR_MODE_AN) {
2182 $q = $p;
2183 while(self::isalnumat($this->dataStr, $q)) {
2184 $q++;
2185 }
2186 $dif = QRinput::estimateBitsMode8($p) // + 4 + l8
2187 + QRinput::estimateBitsModeAn($q - $p) + 4 + $la
2188 - QRinput::estimateBitsMode8($q); // - 4 - l8
2189 if($dif < 0) {
2190 break;
2191 } else {
2192 $p = $q;
2193 }
2194 } else {
2195 $p++;
2196 }
2197 }
2198
2199 $run = $p;
2200 $ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
2201
2202 if($ret < 0)
2203 return -1;
2204
2205 return $run;
2206 }
2207
2208 //----------------------------------------------------------------------
2209 public function splitString()
2210 {
2211 while (strlen($this->dataStr) > 0)
2212 {
2213 if($this->dataStr == '')
2214 return 0;
2215
2216 $mode = $this->identifyMode(0);
2217
2218 switch ($mode) {
2219 case QR_MODE_NUM: $length = $this->eatNum(); break;
2220 case QR_MODE_AN: $length = $this->eatAn(); break;
2221 case QR_MODE_KANJI:
2222 if ($mode == QR_MODE_KANJI)
2223 $length = $this->eatKanji();
2224 else $length = $this->eat8();
2225 break;
2226 default: $length = $this->eat8(); break;
2227
2228 }
2229
2230 if($length == 0) return 0;
2231 if($length < 0) return -1;
2232
2233 $this->dataStr = substr($this->dataStr, $length);
2234 }
2235 }
2236
2237 //----------------------------------------------------------------------
2238 public function toUpper()
2239 {
2240 $stringLen = strlen($this->dataStr);
2241 $p = 0;
2242
2243 while ($p<$stringLen) {
2244 $mode = self::identifyMode(substr($this->dataStr, $p));
2245 if($mode == QR_MODE_KANJI) {
2246 $p += 2;
2247 } else {
2248 if (ord($this->dataStr[$p]) >= ord('a') && ord($this->dataStr[$p]) <= ord('z')) {
2249 $this->dataStr[$p] = chr(ord($this->dataStr[$p]) - 32);
2250 }
2251 $p++;
2252 }
2253 }
2254
2255 return $this->dataStr;
2256 }
2257
2258 //----------------------------------------------------------------------
2259 public static function splitStringToQRinput($string, QRinput $input, $modeHint, $casesensitive = true)
2260 {
2261 if(is_null($string) || $string == '\0' || $string == '') {
2262 throw new Exception('empty string!!!');
2263 }
2264
2265 $split = new QRsplit($string, $input, $modeHint);
2266
2267 if(!$casesensitive)
2268 $split->toUpper();
2269
2270 return $split->splitString();
2271 }
2272 }
2273
2274
2275
2276 //---- qrrscode.php -----------------------------
2277
2278
2279
2280
2281 /*
2282 * PHP QR Code encoder
2283 *
2284 * Reed-Solomon error correction support
2285 *
2286 * Copyright (C) 2002, 2003, 2004, 2006 Phil Karn, KA9Q
2287 * (libfec is released under the GNU Lesser General Public License.)
2288 *
2289 * Based on libqrencode C library distributed under LGPL 2.1
2290 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <fukuchi@megaui.net>
2291 *
2292 * PHP QR Code is distributed under LGPL 3
2293 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
2294 *
2295 * This library is free software; you can redistribute it and/or
2296 * modify it under the terms of the GNU Lesser General Public
2297 * License as published by the Free Software Foundation; either
2298 * version 3 of the License, or any later version.
2299 *
2300 * This library is distributed in the hope that it will be useful,
2301 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2302 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2303 * Lesser General Public License for more details.
2304 *
2305 * You should have received a copy of the GNU Lesser General Public
2306 * License along with this library; if not, write to the Free Software
2307 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2308 */
2309
2310 class QRrsItem {
2311
2312 public $mm; // Bits per symbol
2313 public $nn; // Symbols per block (= (1<<mm)-1)
2314 public $alpha_to = array(); // log lookup table
2315 public $index_of = array(); // Antilog lookup table
2316 public $genpoly = array(); // Generator polynomial
2317 public $nroots; // Number of generator roots = number of parity symbols
2318 public $fcr; // First consecutive root, index form
2319 public $prim; // Primitive element, index form
2320 public $iprim; // prim-th root of 1, index form
2321 public $pad; // Padding bytes in shortened block
2322 public $gfpoly;
2323
2324 //----------------------------------------------------------------------
2325 public function modnn($x)
2326 {
2327 while ($x >= $this->nn) {
2328 $x -= $this->nn;
2329 $x = ($x >> $this->mm) + ($x & $this->nn);
2330 }
2331
2332 return $x;
2333 }
2334
2335 //----------------------------------------------------------------------
2336 public static function init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
2337 {
2338 // Common code for intializing a Reed-Solomon control block (char or int symbols)
2339 // Copyright 2004 Phil Karn, KA9Q
2340 // May be used under the terms of the GNU Lesser General Public License (LGPL)
2341
2342 $rs = null;
2343
2344 // Check parameter ranges
2345 if($symsize < 0 || $symsize > 8) return $rs;
2346 if($fcr < 0 || $fcr >= (1<<$symsize)) return $rs;
2347 if($prim <= 0 || $prim >= (1<<$symsize)) return $rs;
2348 if($nroots < 0 || $nroots >= (1<<$symsize)) return $rs; // Can't have more roots than symbol values!
2349 if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
2350
2351 $rs = new QRrsItem();
2352 $rs->mm = $symsize;
2353 $rs->nn = (1<<$symsize)-1;
2354 $rs->pad = $pad;
2355
2356 $rs->alpha_to = array_fill(0, $rs->nn+1, 0);
2357 $rs->index_of = array_fill(0, $rs->nn+1, 0);
2358
2359 // PHP style macro replacement ;)
2360 $NN =& $rs->nn;
2361 $A0 =& $NN;
2362
2363 // Generate Galois field lookup tables
2364 $rs->index_of[0] = $A0; // log(zero) = -inf
2365 $rs->alpha_to[$A0] = 0; // alpha**-inf = 0
2366 $sr = 1;
2367
2368 for($i=0; $i<$rs->nn; $i++) {
2369 $rs->index_of[$sr] = $i;
2370 $rs->alpha_to[$i] = $sr;
2371 $sr <<= 1;
2372 if($sr & (1<<$symsize)) {
2373 $sr ^= $gfpoly;
2374 }
2375 $sr &= $rs->nn;
2376 }
2377
2378 if($sr != 1){
2379 // field generator polynomial is not primitive!
2380 $rs = NULL;
2381 return $rs;
2382 }
2383
2384 /* Form RS code generator polynomial from its roots */
2385 $rs->genpoly = array_fill(0, $nroots+1, 0);
2386
2387 $rs->fcr = $fcr;
2388 $rs->prim = $prim;
2389 $rs->nroots = $nroots;
2390 $rs->gfpoly = $gfpoly;
2391
2392 /* Find prim-th root of 1, used in decoding */
2393 for($iprim=1;($iprim % $prim) != 0;$iprim += $rs->nn)
2394 ; // intentional empty-body loop!
2395
2396 $rs->iprim = (int)($iprim / $prim);
2397 $rs->genpoly[0] = 1;
2398
2399 for ($i = 0,$root=$fcr*$prim; $i < $nroots; $i++, $root += $prim) {
2400 $rs->genpoly[$i+1] = 1;
2401
2402 // Multiply rs->genpoly[] by @**(root + x)
2403 for ($j = $i; $j > 0; $j--) {
2404 if ($rs->genpoly[$j] != 0) {
2405 $rs->genpoly[$j] = $rs->genpoly[$j-1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
2406 } else {
2407 $rs->genpoly[$j] = $rs->genpoly[$j-1];
2408 }
2409 }
2410 // rs->genpoly[0] can never be zero
2411 $rs->genpoly[0] = $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[0]] + $root)];
2412 }
2413
2414 // convert rs->genpoly[] to index form for quicker encoding
2415 for ($i = 0; $i <= $nroots; $i++)
2416 $rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
2417
2418 return $rs;
2419 }
2420
2421 //----------------------------------------------------------------------
2422 public function encode_rs_char($data, &$parity)
2423 {
2424 $MM =& $this->mm;
2425 $NN =& $this->nn;
2426 $ALPHA_TO =& $this->alpha_to;
2427 $INDEX_OF =& $this->index_of;
2428 $GENPOLY =& $this->genpoly;
2429 $NROOTS =& $this->nroots;
2430 $FCR =& $this->fcr;
2431 $PRIM =& $this->prim;
2432 $IPRIM =& $this->iprim;
2433 $PAD =& $this->pad;
2434 $A0 =& $NN;
2435
2436 $parity = array_fill(0, $NROOTS, 0);
2437
2438 for($i=0; $i< ($NN-$NROOTS-$PAD); $i++) {
2439
2440 $feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
2441 if($feedback != $A0) {
2442 // feedback term is non-zero
2443
2444 // This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
2445 // always be for the polynomials constructed by init_rs()
2446 $feedback = $this->modnn($NN - $GENPOLY[$NROOTS] + $feedback);
2447
2448 for($j=1;$j<$NROOTS;$j++) {
2449 $parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS-$j])];
2450 }
2451 }
2452
2453 // Shift
2454 array_shift($parity);
2455 if($feedback != $A0) {
2456 array_push($parity, $ALPHA_TO[$this->modnn($feedback + $GENPOLY[0])]);
2457 } else {
2458 array_push($parity, 0);
2459 }
2460 }
2461 }
2462 }
2463
2464 //##########################################################################
2465
2466 class QRrs {
2467
2468 public static $items = array();
2469
2470 //----------------------------------------------------------------------
2471 public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
2472 {
2473 foreach(self::$items as $rs) {
2474 if($rs->pad != $pad) continue;
2475 if($rs->nroots != $nroots) continue;
2476 if($rs->mm != $symsize) continue;
2477 if($rs->gfpoly != $gfpoly) continue;
2478 if($rs->fcr != $fcr) continue;
2479 if($rs->prim != $prim) continue;
2480
2481 return $rs;
2482 }
2483
2484 $rs = QRrsItem::init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad);
2485 array_unshift(self::$items, $rs);
2486
2487 return $rs;
2488 }
2489 }
2490
2491
2492
2493 //---- qrmask.php -----------------------------
2494
2495
2496
2497
2498 /*
2499 * PHP QR Code encoder
2500 *
2501 * Masking
2502 *
2503 * Based on libqrencode C library distributed under LGPL 2.1
2504 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <fukuchi@megaui.net>
2505 *
2506 * PHP QR Code is distributed under LGPL 3
2507 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
2508 *
2509 * This library is free software; you can redistribute it and/or
2510 * modify it under the terms of the GNU Lesser General Public
2511 * License as published by the Free Software Foundation; either
2512 * version 3 of the License, or any later version.
2513 *
2514 * This library is distributed in the hope that it will be useful,
2515 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2516 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2517 * Lesser General Public License for more details.
2518 *
2519 * You should have received a copy of the GNU Lesser General Public
2520 * License along with this library; if not, write to the Free Software
2521 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2522 */
2523
2524 define('N1', 3);
2525 define('N2', 3);
2526 define('N3', 40);
2527 define('N4', 10);
2528
2529 class QRmask {
2530
2531 public $runLength = array();
2532
2533 //----------------------------------------------------------------------
2534 public function __construct()
2535 {
2536 $this->runLength = array_fill(0, QRSPEC_WIDTH_MAX + 1, 0);
2537 }
2538
2539 //----------------------------------------------------------------------
2540 public function writeFormatInformation($width, &$frame, $mask, $level)
2541 {
2542 $blacks = 0;
2543 $format = QRspec::getFormatInfo($mask, $level);
2544
2545 for($i=0; $i<8; $i++) {
2546 if($format & 1) {
2547 $blacks += 2;
2548 $v = 0x85;
2549 } else {
2550 $v = 0x84;
2551 }
2552
2553 $frame[8][$width - 1 - $i] = chr($v);
2554 if($i < 6) {
2555 $frame[$i][8] = chr($v);
2556 } else {
2557 $frame[$i + 1][8] = chr($v);
2558 }
2559 $format = $format >> 1;
2560 }
2561
2562 for($i=0; $i<7; $i++) {
2563 if($format & 1) {
2564 $blacks += 2;
2565 $v = 0x85;
2566 } else {
2567 $v = 0x84;
2568 }
2569
2570 $frame[$width - 7 + $i][8] = chr($v);
2571 if($i == 0) {
2572 $frame[8][7] = chr($v);
2573 } else {
2574 $frame[8][6 - $i] = chr($v);
2575 }
2576
2577 $format = $format >> 1;
2578 }
2579
2580 return $blacks;
2581 }
2582
2583 //----------------------------------------------------------------------
2584 public function mask0($x, $y) { return ($x+$y)&1; }
2585 public function mask1($x, $y) { return ($y&1); }
2586 public function mask2($x, $y) { return ($x%3); }
2587 public function mask3($x, $y) { return ($x+$y)%3; }
2588 public function mask4($x, $y) { return (((int)($y/2))+((int)($x/3)))&1; }
2589 public function mask5($x, $y) { return (($x*$y)&1)+($x*$y)%3; }
2590 public function mask6($x, $y) { return ((($x*$y)&1)+($x*$y)%3)&1; }
2591 public function mask7($x, $y) { return ((($x*$y)%3)+(($x+$y)&1))&1; }
2592
2593 //----------------------------------------------------------------------
2594 private function generateMaskNo($maskNo, $width, $frame)
2595 {
2596 $bitMask = array_fill(0, $width, array_fill(0, $width, 0));
2597
2598 for($y=0; $y<$width; $y++) {
2599 for($x=0; $x<$width; $x++) {
2600 if(ord($frame[$y][$x]) & 0x80) {
2601 $bitMask[$y][$x] = 0;
2602 } else {
2603 $maskFunc = call_user_func(array($this, 'mask'.$maskNo), $x, $y);
2604 $bitMask[$y][$x] = ($maskFunc == 0)?1:0;
2605 }
2606
2607 }
2608 }
2609
2610 return $bitMask;
2611 }
2612
2613 //----------------------------------------------------------------------
2614 public static function serial($bitFrame)
2615 {
2616 $codeArr = array();
2617
2618 foreach ($bitFrame as $line)
2619 $codeArr[] = join('', $line);
2620
2621 return gzcompress(join("\n", $codeArr), 9);
2622 }
2623
2624 //----------------------------------------------------------------------
2625 public static function unserial($code)
2626 {
2627 $codeArr = array();
2628
2629 $codeLines = explode("\n", gzuncompress($code));
2630 foreach ($codeLines as $line)
2631 $codeArr[] = str_split($line);
2632
2633 return $codeArr;
2634 }
2635
2636 //----------------------------------------------------------------------
2637 public function makeMaskNo($maskNo, $width, $s, &$d, $maskGenOnly = false)
2638 {
2639 $b = 0;
2640 $bitMask = array();
2641
2642 $fileName = QR_CACHE_DIR.'mask_'.$maskNo.DIRECTORY_SEPARATOR.'mask_'.$width.'_'.$maskNo.'.dat';
2643
2644 if (QR_CACHEABLE) {
2645 if (file_exists($fileName)) {
2646 $bitMask = self::unserial(file_get_contents($fileName));
2647 } else {
2648 $bitMask = $this->generateMaskNo($maskNo, $width, $s, $d);
2649 if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo))
2650 mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
2651 file_put_contents($fileName, self::serial($bitMask));
2652 }
2653 } else {
2654 $bitMask = $this->generateMaskNo($maskNo, $width, $s, $d);
2655 }
2656
2657 if ($maskGenOnly)
2658 return;
2659
2660 $d = $s;
2661
2662 for($y=0; $y<$width; $y++) {
2663 for($x=0; $x<$width; $x++) {
2664 if($bitMask[$y][$x] == 1) {
2665 $d[$y][$x] = chr(ord($s[$y][$x]) ^ (int)$bitMask[$y][$x]);
2666 }
2667 $b += (int)(ord($d[$y][$x]) & 1);
2668 }
2669 }
2670
2671 return $b;
2672 }
2673
2674 //----------------------------------------------------------------------
2675 public function makeMask($width, $frame, $maskNo, $level)
2676 {
2677 $masked = array_fill(0, $width, str_repeat("\0", $width));
2678 $this->makeMaskNo($maskNo, $width, $frame, $masked);
2679 $this->writeFormatInformation($width, $masked, $maskNo, $level);
2680
2681 return $masked;
2682 }
2683
2684 //----------------------------------------------------------------------
2685 public function calcN1N3($length)
2686 {
2687 $demerit = 0;
2688
2689 for($i=0; $i<$length; $i++) {
2690
2691 if($this->runLength[$i] >= 5) {
2692 $demerit += (N1 + ($this->runLength[$i] - 5));
2693 }
2694 if($i & 1) {
2695 if(($i >= 3) && ($i < ($length-2)) && ($this->runLength[$i] % 3 == 0)) {
2696 $fact = (int)($this->runLength[$i] / 3);
2697 if(($this->runLength[$i-2] == $fact) &&
2698 ($this->runLength[$i-1] == $fact) &&
2699 ($this->runLength[$i+1] == $fact) &&
2700 ($this->runLength[$i+2] == $fact)) {
2701 if(($this->runLength[$i-3] < 0) || ($this->runLength[$i-3] >= (4 * $fact))) {
2702 $demerit += N3;
2703 } else if((($i+3) >= $length) || ($this->runLength[$i+3] >= (4 * $fact))) {
2704 $demerit += N3;
2705 }
2706 }
2707 }
2708 }
2709 }
2710 return $demerit;
2711 }
2712
2713 //----------------------------------------------------------------------
2714 public function evaluateSymbol($width, $frame)
2715 {
2716 $head = 0;
2717 $demerit = 0;
2718
2719 for($y=0; $y<$width; $y++) {
2720 $head = 0;
2721 $this->runLength[0] = 1;
2722
2723 $frameY = $frame[$y];
2724
2725 if ($y>0)
2726 $frameYM = $frame[$y-1];
2727
2728 for($x=0; $x<$width; $x++) {
2729 if(($x > 0) && ($y > 0)) {
2730 $b22 = ord($frameY[$x]) & ord($frameY[$x-1]) & ord($frameYM[$x]) & ord($frameYM[$x-1]);
2731 $w22 = ord($frameY[$x]) | ord($frameY[$x-1]) | ord($frameYM[$x]) | ord($frameYM[$x-1]);
2732
2733 if(($b22 | ($w22 ^ 1))&1) {
2734 $demerit += N2;
2735 }
2736 }
2737 if(($x == 0) && (ord($frameY[$x]) & 1)) {
2738 $this->runLength[0] = -1;
2739 $head = 1;
2740 $this->runLength[$head] = 1;
2741 } else if($x > 0) {
2742 if((ord($frameY[$x]) ^ ord($frameY[$x-1])) & 1) {
2743 $head++;
2744 $this->runLength[$head] = 1;
2745 } else {
2746 $this->runLength[$head]++;
2747 }
2748 }
2749 }
2750
2751 $demerit += $this->calcN1N3($head+1);
2752 }
2753
2754 for($x=0; $x<$width; $x++) {
2755 $head = 0;
2756 $this->runLength[0] = 1;
2757
2758 for($y=0; $y<$width; $y++) {
2759 if($y == 0 && (ord($frame[$y][$x]) & 1)) {
2760 $this->runLength[0] = -1;
2761 $head = 1;
2762 $this->runLength[$head] = 1;
2763 } else if($y > 0) {
2764 if((ord($frame[$y][$x]) ^ ord($frame[$y-1][$x])) & 1) {
2765 $head++;
2766 $this->runLength[$head] = 1;
2767 } else {
2768 $this->runLength[$head]++;
2769 }
2770 }
2771 }
2772
2773 $demerit += $this->calcN1N3($head+1);
2774 }
2775
2776 return $demerit;
2777 }
2778
2779
2780 //----------------------------------------------------------------------
2781 public function mask($width, $frame, $level)
2782 {
2783 $minDemerit = PHP_INT_MAX;
2784 $bestMaskNum = 0;
2785 $bestMask = array();
2786
2787 $checked_masks = array(0,1,2,3,4,5,6,7);
2788
2789 if (QR_FIND_FROM_RANDOM !== false) {
2790
2791 $howManuOut = 8-(QR_FIND_FROM_RANDOM % 9);
2792 for ($i = 0; $i < $howManuOut; $i++) {
2793 $remPos = rand (0, count($checked_masks)-1);
2794 unset($checked_masks[$remPos]);
2795 $checked_masks = array_values($checked_masks);
2796 }
2797
2798 }
2799
2800 $bestMask = $frame;
2801
2802 foreach($checked_masks as $i) {
2803 $mask = array_fill(0, $width, str_repeat("\0", $width));
2804
2805 $demerit = 0;
2806 $blacks = 0;
2807 $blacks = $this->makeMaskNo($i, $width, $frame, $mask);
2808 $blacks += $this->writeFormatInformation($width, $mask, $i, $level);
2809 $blacks = (int)(100 * $blacks / ($width * $width));
2810 $demerit = (int)((int)(abs($blacks - 50) / 5) * N4);
2811 $demerit += $this->evaluateSymbol($width, $mask);
2812
2813 if($demerit < $minDemerit) {
2814 $minDemerit = $demerit;
2815 $bestMask = $mask;
2816 $bestMaskNum = $i;
2817 }
2818 }
2819
2820 return $bestMask;
2821 }
2822
2823 //----------------------------------------------------------------------
2824 }
2825
2826
2827
2828
2829 //---- qrencode.php -----------------------------
2830
2831
2832
2833
2834 /*
2835 * PHP QR Code encoder
2836 *
2837 * Main encoder classes.
2838 *
2839 * Based on libqrencode C library distributed under LGPL 2.1
2840 * Copyright (C) 2006, 2007, 2008, 2009 Kentaro Fukuchi <fukuchi@megaui.net>
2841 *
2842 * PHP QR Code is distributed under LGPL 3
2843 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
2844 *
2845 * This library is free software; you can redistribute it and/or
2846 * modify it under the terms of the GNU Lesser General Public
2847 * License as published by the Free Software Foundation; either
2848 * version 3 of the License, or any later version.
2849 *
2850 * This library is distributed in the hope that it will be useful,
2851 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2852 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
2853 * Lesser General Public License for more details.
2854 *
2855 * You should have received a copy of the GNU Lesser General Public
2856 * License along with this library; if not, write to the Free Software
2857 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2858 */
2859
2860 class QRrsblock {
2861 public $dataLength;
2862 public $data = array();
2863 public $eccLength;
2864 public $ecc = array();
2865
2866 public function __construct($dl, $data, $el, &$ecc, QRrsItem $rs)
2867 {
2868 $rs->encode_rs_char($data, $ecc);
2869
2870 $this->dataLength = $dl;
2871 $this->data = $data;
2872 $this->eccLength = $el;
2873 $this->ecc = $ecc;
2874 }
2875 };
2876
2877 //##########################################################################
2878
2879 class QRrawcode {
2880 public $version;
2881 public $datacode = array();
2882 public $ecccode = array();
2883 public $blocks;
2884 public $rsblocks = array(); //of RSblock
2885 public $count;
2886 public $dataLength;
2887 public $eccLength;
2888 public $b1;
2889
2890 //----------------------------------------------------------------------
2891 public function __construct(QRinput $input)
2892 {
2893 $spec = array(0,0,0,0,0);
2894
2895 $this->datacode = $input->getByteStream();
2896 if(is_null($this->datacode)) {
2897 throw new Exception('null imput string');
2898 }
2899
2900 QRspec::getEccSpec($input->getVersion(), $input->getErrorCorrectionLevel(), $spec);
2901
2902 $this->version = $input->getVersion();
2903 $this->b1 = QRspec::rsBlockNum1($spec);
2904 $this->dataLength = QRspec::rsDataLength($spec);
2905 $this->eccLength = QRspec::rsEccLength($spec);
2906 $this->ecccode = array_fill(0, $this->eccLength, 0);
2907 $this->blocks = QRspec::rsBlockNum($spec);
2908
2909 $ret = $this->init($spec);
2910 if($ret < 0) {
2911 throw new Exception('block alloc error');
2912 return null;
2913 }
2914
2915 $this->count = 0;
2916 }
2917
2918 //----------------------------------------------------------------------
2919 public function init(array $spec)
2920 {
2921 $dl = QRspec::rsDataCodes1($spec);
2922 $el = QRspec::rsEccCodes1($spec);
2923 $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
2924
2925
2926 $blockNo = 0;
2927 $dataPos = 0;
2928 $eccPos = 0;
2929 for($i=0; $i<QRspec::rsBlockNum1($spec); $i++) {
2930 $ecc = array_slice($this->ecccode,$eccPos);
2931 $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
2932 $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
2933
2934 $dataPos += $dl;
2935 $eccPos += $el;
2936 $blockNo++;
2937 }
2938
2939 if(QRspec::rsBlockNum2($spec) == 0)
2940 return 0;
2941
2942 $dl = QRspec::rsDataCodes2($spec);
2943 $el = QRspec::rsEccCodes2($spec);
2944 $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
2945
2946 if($rs == NULL) return -1;
2947
2948 for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
2949 $ecc = array_slice($this->ecccode,$eccPos);
2950 $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
2951 $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
2952
2953 $dataPos += $dl;
2954 $eccPos += $el;
2955 $blockNo++;
2956 }
2957
2958 return 0;
2959 }
2960
2961 //----------------------------------------------------------------------
2962 public function getCode()
2963 {
2964 $ret;
2965
2966 if($this->count < $this->dataLength) {
2967 $row = $this->count % $this->blocks;
2968 $col = $this->count / $this->blocks;
2969 if($col >= $this->rsblocks[0]->dataLength) {
2970 $row += $this->b1;
2971 }
2972 $ret = $this->rsblocks[$row]->data[$col];
2973 } else if($this->count < $this->dataLength + $this->eccLength) {
2974 $row = ($this->count - $this->dataLength) % $this->blocks;
2975 $col = ($this->count - $this->dataLength) / $this->blocks;
2976 $ret = $this->rsblocks[$row]->ecc[$col];
2977 } else {
2978 return 0;
2979 }
2980 $this->count++;
2981
2982 return $ret;
2983 }
2984 }
2985
2986 //##########################################################################
2987
2988 class QRcode {
2989
2990 public $version;
2991 public $width;
2992 public $data;
2993
2994 //----------------------------------------------------------------------
2995 public function encodeMask(QRinput $input, $mask)
2996 {
2997 if($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
2998 throw new Exception('wrong version');
2999 }
3000 if($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
3001 throw new Exception('wrong level');
3002 }
3003
3004 $raw = new QRrawcode($input);
3005
3006 QRtools::markTime('after_raw');
3007
3008 $version = $raw->version;
3009 $width = QRspec::getWidth($version);
3010 $frame = QRspec::newFrame($version);
3011
3012 $filler = new FrameFiller($width, $frame);
3013 if(is_null($filler)) {
3014 return NULL;
3015 }
3016
3017 // inteleaved data and ecc codes
3018 for($i=0; $i<$raw->dataLength + $raw->eccLength; $i++) {
3019 $code = $raw->getCode();
3020 $bit = 0x80;
3021 for($j=0; $j<8; $j++) {
3022 $addr = $filler->next();
3023 $filler->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
3024 $bit = $bit >> 1;
3025 }
3026 }
3027
3028 QRtools::markTime('after_filler');
3029
3030 unset($raw);
3031
3032 // remainder bits
3033 $j = QRspec::getRemainder($version);
3034 for($i=0; $i<$j; $i++) {
3035 $addr = $filler->next();
3036 $filler->setFrameAt($addr, 0x02);
3037 }
3038
3039 $frame = $filler->frame;
3040 unset($filler);
3041
3042
3043 // masking
3044 $maskObj = new QRmask();
3045 if($mask < 0) {
3046
3047 if (QR_FIND_BEST_MASK) {
3048 $masked = $maskObj->mask($width, $frame, $input->getErrorCorrectionLevel());
3049 } else {
3050 $masked = $maskObj->makeMask($width, $frame, (intval(QR_DEFAULT_MASK) % 8), $input->getErrorCorrectionLevel());
3051 }
3052 } else {
3053 $masked = $maskObj->makeMask($width, $frame, $mask, $input->getErrorCorrectionLevel());
3054 }
3055
3056 if($masked == NULL) {
3057 return NULL;
3058 }
3059
3060 QRtools::markTime('after_mask');
3061
3062 $this->version = $version;
3063 $this->width = $width;
3064 $this->data = $masked;
3065
3066 return $this;
3067 }
3068
3069 //----------------------------------------------------------------------
3070 public function encodeInput(QRinput $input)
3071 {
3072 return $this->encodeMask($input, -1);
3073 }
3074
3075 //----------------------------------------------------------------------
3076 public function encodeString8bit($string, $version, $level)
3077 {
3078 if($string == NULL) {
3079 throw new Exception('empty string!');
3080 return NULL;
3081 }
3082
3083 $input = new QRinput($version, $level);
3084 if($input == NULL) return NULL;
3085
3086 $ret = $input->append($input, QR_MODE_8, strlen($string), str_split($string));
3087 if($ret < 0) {
3088 unset($input);
3089 return NULL;
3090 }
3091 return $this->encodeInput($input);
3092 }
3093
3094 //----------------------------------------------------------------------
3095 public function encodeString($string, $version, $level, $hint, $casesensitive)
3096 {
3097
3098 if($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
3099 throw new Exception('bad hint');
3100 return NULL;
3101 }
3102
3103 $input = new QRinput($version, $level);
3104 if($input == NULL) return NULL;
3105
3106 $ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
3107 if($ret < 0) {
3108 return NULL;
3109 }
3110
3111 return $this->encodeInput($input);
3112 }
3113
3114 //----------------------------------------------------------------------
3115 public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false, $back_color = 0xFFFFFF, $fore_color = 0x000000)
3116 {
3117 $enc = QRencode::factory($level, $size, $margin, $back_color, $fore_color);
3118 return $enc->encodePNG($text, $outfile, $saveandprint=false);
3119 }
3120
3121 //----------------------------------------------------------------------
3122 public static function text($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4)
3123 {
3124 $enc = QRencode::factory($level, $size, $margin);
3125 return $enc->encode($text, $outfile);
3126 }
3127
3128 //----------------------------------------------------------------------
3129 public static function eps($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false, $back_color = 0xFFFFFF, $fore_color = 0x000000, $cmyk = false)
3130 {
3131 $enc = QRencode::factory($level, $size, $margin, $back_color, $fore_color, $cmyk);
3132 return $enc->encodeEPS($text, $outfile, $saveandprint=false);
3133 }
3134
3135 //----------------------------------------------------------------------
3136 public static function svg($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false, $back_color = 0xFFFFFF, $fore_color = 0x000000)
3137 {
3138 $enc = QRencode::factory($level, $size, $margin, $back_color, $fore_color);
3139 return $enc->encodeSVG($text, $outfile, $saveandprint=false);
3140 }
3141
3142 //----------------------------------------------------------------------
3143 public static function raw($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4)
3144 {
3145 $enc = QRencode::factory($level, $size, $margin);
3146 return $enc->encodeRAW($text, $outfile);
3147 }
3148 }
3149
3150 //##########################################################################
3151
3152 class FrameFiller {
3153
3154 public $width;
3155 public $frame;
3156 public $x;
3157 public $y;
3158 public $dir;
3159 public $bit;
3160
3161 //----------------------------------------------------------------------
3162 public function __construct($width, &$frame)
3163 {
3164 $this->width = $width;
3165 $this->frame = $frame;
3166 $this->x = $width - 1;
3167 $this->y = $width - 1;
3168 $this->dir = -1;
3169 $this->bit = -1;
3170 }
3171
3172 //----------------------------------------------------------------------
3173 public function setFrameAt($at, $val)
3174 {
3175 $this->frame[$at['y']][$at['x']] = chr($val);
3176 }
3177
3178 //----------------------------------------------------------------------
3179 public function getFrameAt($at)
3180 {
3181 return ord($this->frame[$at['y']][$at['x']]);
3182 }
3183
3184 //----------------------------------------------------------------------
3185 public function next()
3186 {
3187 do {
3188
3189 if($this->bit == -1) {
3190 $this->bit = 0;
3191 return array('x'=>$this->x, 'y'=>$this->y);
3192 }
3193
3194 $x = $this->x;
3195 $y = $this->y;
3196 $w = $this->width;
3197
3198 if($this->bit == 0) {
3199 $x--;
3200 $this->bit++;
3201 } else {
3202 $x++;
3203 $y += $this->dir;
3204 $this->bit--;
3205 }
3206
3207 if($this->dir < 0) {
3208 if($y < 0) {
3209 $y = 0;
3210 $x -= 2;
3211 $this->dir = 1;
3212 if($x == 6) {
3213 $x--;
3214 $y = 9;
3215 }
3216 }
3217 } else {
3218 if($y == $w) {
3219 $y = $w - 1;
3220 $x -= 2;
3221 $this->dir = -1;
3222 if($x == 6) {
3223 $x--;
3224 $y -= 8;
3225 }
3226 }
3227 }
3228 if($x < 0 || $y < 0) return null;
3229
3230 $this->x = $x;
3231 $this->y = $y;
3232
3233 } while(ord($this->frame[$y][$x]) & 0x80);
3234
3235 return array('x'=>$x, 'y'=>$y);
3236 }
3237
3238 } ;
3239
3240 //##########################################################################
3241
3242 class QRencode {
3243
3244 public $casesensitive = true;
3245 public $eightbit = false;
3246
3247 public $version = 0;
3248 public $size = 3;
3249 public $margin = 4;
3250 public $back_color = 0xFFFFFF;
3251 public $fore_color = 0x000000;
3252
3253 public $structured = 0; // not supported yet
3254
3255 public $level = QR_ECLEVEL_L;
3256 public $hint = QR_MODE_8;
3257
3258 //----------------------------------------------------------------------
3259 public static function factory($level = QR_ECLEVEL_L, $size = 3, $margin = 4, $back_color = 0xFFFFFF, $fore_color = 0x000000, $cmyk = false)
3260 {
3261 $enc = new QRencode();
3262 $enc->size = $size;
3263 $enc->margin = $margin;
3264 $enc->fore_color = $fore_color;
3265 $enc->back_color = $back_color;
3266 $enc->cmyk = $cmyk;
3267
3268 switch ($level.'') {
3269 case '0':
3270 case '1':
3271 case '2':
3272 case '3':
3273 $enc->level = $level;
3274 break;
3275 case 'l':
3276 case 'L':
3277 $enc->level = QR_ECLEVEL_L;
3278 break;
3279 case 'm':
3280 case 'M':
3281 $enc->level = QR_ECLEVEL_M;
3282 break;
3283 case 'q':
3284 case 'Q':
3285 $enc->level = QR_ECLEVEL_Q;
3286 break;
3287 case 'h':
3288 case 'H':
3289 $enc->level = QR_ECLEVEL_H;
3290 break;
3291 }
3292
3293 return $enc;
3294 }
3295
3296 //----------------------------------------------------------------------
3297 public function encodeRAW($intext, $outfile = false)
3298 {
3299 $code = new QRcode();
3300
3301 if($this->eightbit) {
3302 $code->encodeString8bit($intext, $this->version, $this->level);
3303 } else {
3304 $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
3305 }
3306
3307 return $code->data;
3308 }
3309
3310 //----------------------------------------------------------------------
3311 public function encode($intext, $outfile = false)
3312 {
3313 $code = new QRcode();
3314
3315 if($this->eightbit) {
3316 $code->encodeString8bit($intext, $this->version, $this->level);
3317 } else {
3318 $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
3319 }
3320
3321 QRtools::markTime('after_encode');
3322
3323 if ($outfile!== false) {
3324 file_put_contents($outfile, join("\n", QRtools::binarize($code->data)));
3325 } else {
3326 return QRtools::binarize($code->data);
3327 }
3328 }
3329
3330 //----------------------------------------------------------------------
3331 public function encodePNG($intext, $outfile = false,$saveandprint=false)
3332 {
3333 try {
3334
3335 ob_start();
3336 $tab = $this->encode($intext);
3337 $err = ob_get_contents();
3338 ob_end_clean();
3339
3340 if ($err != '')
3341 QRtools::log($outfile, $err);
3342
3343 $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
3344
3345 QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint, $this->back_color, $this->fore_color);
3346
3347 } catch (Exception $e) {
3348
3349 QRtools::log($outfile, $e->getMessage());
3350
3351 }
3352 }
3353
3354 //----------------------------------------------------------------------
3355 public function encodeEPS($intext, $outfile = false,$saveandprint=false)
3356 {
3357 try {
3358
3359 ob_start();
3360 $tab = $this->encode($intext);
3361 $err = ob_get_contents();
3362 ob_end_clean();
3363
3364 if ($err != '')
3365 QRtools::log($outfile, $err);
3366
3367 $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
3368
3369 QRvect::eps($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint, $this->back_color, $this->fore_color, $this->cmyk);
3370
3371 } catch (Exception $e) {
3372
3373 QRtools::log($outfile, $e->getMessage());
3374
3375 }
3376 }
3377
3378 //----------------------------------------------------------------------
3379 public function encodeSVG($intext, $outfile = false,$saveandprint=false)
3380 {
3381 try {
3382
3383 ob_start();
3384 $tab = $this->encode($intext);
3385 $err = ob_get_contents();
3386 ob_end_clean();
3387
3388 if ($err != '')
3389 QRtools::log($outfile, $err);
3390
3391 $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
3392
3393 QRvect::svg($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint, $this->back_color, $this->fore_color);
3394
3395 } catch (Exception $e) {
3396
3397 QRtools::log($outfile, $e->getMessage());
3398
3399 }
3400 }
3401 }
3402
3403
3404
3405
3406 //---- qrvect.php -----------------------------
3407
3408
3409
3410
3411 /*
3412 * PHP QR Code encoder
3413 *
3414 * Image output of code using GD2
3415 *
3416 * PHP QR Code is distributed under LGPL 3
3417 * Copyright (C) 2010 Dominik Dzienia <deltalab at poczta dot fm>
3418 *
3419 * This library is free software; you can redistribute it and/or
3420 * modify it under the terms of the GNU Lesser General Public
3421 * License as published by the Free Software Foundation; either
3422 * version 3 of the License, or any later version.
3423 *
3424 * This library is distributed in the hope that it will be useful,
3425 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3426 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3427 * Lesser General Public License for more details.
3428 *
3429 * You should have received a copy of the GNU Lesser General Public
3430 * License along with this library; if not, write to the Free Software
3431 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
3432 */
3433
3434 define('QR_VECT', true);
3435
3436 class QRvect {
3437
3438 //----------------------------------------------------------------------
3439 public static function eps($frame, $filename = false, $pixelPerPoint = 4, $outerFrame = 4,$saveandprint=FALSE, $back_color = 0xFFFFFF, $fore_color = 0x000000, $cmyk = false)
3440 {
3441 $vect = self::vectEPS($frame, $pixelPerPoint, $outerFrame, $back_color, $fore_color, $cmyk);
3442
3443 if ($filename === false) {
3444 header("Content-Type: application/postscript");
3445 header('Content-Disposition: filename="qrcode.eps"');
3446 echo $vect;
3447 } else {
3448 if($saveandprint===TRUE){
3449 QRtools::save($vect, $filename);
3450 header("Content-Type: application/postscript");
3451 header('Content-Disposition: filename="qrcode.eps"');
3452 echo $vect;
3453 }else{
3454 QRtools::save($vect, $filename);
3455 }
3456 }
3457 }
3458
3459
3460 //----------------------------------------------------------------------
3461 private static function vectEPS($frame, $pixelPerPoint = 4, $outerFrame = 4, $back_color = 0xFFFFFF, $fore_color = 0x000000, $cmyk = false)
3462 {
3463 $h = count($frame);
3464 $w = strlen($frame[0]);
3465
3466 $imgW = $w + 2*$outerFrame;
3467 $imgH = $h + 2*$outerFrame;
3468
3469 if ($cmyk)
3470 {
3471 // convert color value into decimal eps format
3472 $c = round((($fore_color & 0xFF000000) >> 16) / 255, 5);
3473 $m = round((($fore_color & 0x00FF0000) >> 16) / 255, 5);
3474 $y = round((($fore_color & 0x0000FF00) >> 8) / 255, 5);
3475 $k = round(($fore_color & 0x000000FF) / 255, 5);
3476 $fore_color_string = $c.' '.$m.' '.$y.' '.$k.' setcmykcolor'."\n";
3477
3478 // convert color value into decimal eps format
3479 $c = round((($back_color & 0xFF000000) >> 16) / 255, 5);
3480 $m = round((($back_color & 0x00FF0000) >> 16) / 255, 5);
3481 $y = round((($back_color & 0x0000FF00) >> 8) / 255, 5);
3482 $k = round(($back_color & 0x000000FF) / 255, 5);
3483 $back_color_string = $c.' '.$m.' '.$y.' '.$k.' setcmykcolor'."\n";
3484 }
3485 else
3486 {
3487 // convert a hexadecimal color code into decimal eps format (green = 0 1 0, blue = 0 0 1, ...)
3488 $r = round((($fore_color & 0xFF0000) >> 16) / 255, 5);
3489 $b = round((($fore_color & 0x00FF00) >> 8) / 255, 5);
3490 $g = round(($fore_color & 0x0000FF) / 255, 5);
3491 $fore_color_string = $r.' '.$b.' '.$g.' setrgbcolor'."\n";
3492
3493 // convert a hexadecimal color code into decimal eps format (green = 0 1 0, blue = 0 0 1, ...)
3494 $r = round((($back_color & 0xFF0000) >> 16) / 255, 5);
3495 $b = round((($back_color & 0x00FF00) >> 8) / 255, 5);
3496 $g = round(($back_color & 0x0000FF) / 255, 5);
3497 $back_color_string = $r.' '.$b.' '.$g.' setrgbcolor'."\n";
3498 }
3499
3500 $output =
3501 '%!PS-Adobe EPSF-3.0'."\n".
3502 '%%Creator: PHPQrcodeLib'."\n".
3503 '%%Title: QRcode'."\n".
3504 '%%CreationDate: '.date('Y-m-d')."\n".
3505 '%%DocumentData: Clean7Bit'."\n".
3506 '%%LanguageLevel: 2'."\n".
3507 '%%Pages: 1'."\n".
3508 '%%BoundingBox: 0 0 '.$imgW * $pixelPerPoint.' '.$imgH * $pixelPerPoint."\n";
3509
3510 // set the scale
3511 $output .= $pixelPerPoint.' '.$pixelPerPoint.' scale'."\n";
3512 // position the center of the coordinate system
3513
3514 $output .= $outerFrame.' '.$outerFrame.' translate'."\n";
3515
3516
3517
3518
3519 // redefine the 'rectfill' operator to shorten the syntax
3520 $output .= '/F { rectfill } def'."\n";
3521
3522 // set the symbol color
3523 $output .= $back_color_string;
3524 $output .= '-'.$outerFrame.' -'.$outerFrame.' '.($w + 2*$outerFrame).' '.($h + 2*$outerFrame).' F'."\n";
3525
3526
3527 // set the symbol color
3528 $output .= $fore_color_string;
3529
3530 // Convert the matrix into pixels
3531
3532 for($i=0; $i<$h; $i++) {
3533 for($j=0; $j<$w; $j++) {
3534 if( $frame[$i][$j] == '1') {
3535 $y = $h - 1 - $i;
3536 $x = $j;
3537 $output .= $x.' '.$y.' 1 1 F'."\n";
3538 }
3539 }
3540 }
3541
3542
3543 $output .='%%EOF';
3544
3545 return $output;
3546 }
3547
3548 //----------------------------------------------------------------------
3549 public static function svg($frame, $filename = false, $pixelPerPoint = 4, $outerFrame = 4,$saveandprint=FALSE, $back_color, $fore_color)
3550 {
3551 $vect = self::vectSVG($frame, $pixelPerPoint, $outerFrame, $back_color, $fore_color);
3552
3553 if ($filename === false) {
3554 header("Content-Type: image/svg+xml");
3555 //header('Content-Disposition: attachment, filename="qrcode.svg"');
3556 echo $vect;
3557 } else {
3558 if($saveandprint===TRUE){
3559 QRtools::save($vect, $filename);
3560 header("Content-Type: image/svg+xml");
3561 //header('Content-Disposition: filename="'.$filename.'"');
3562 echo $vect;
3563 }else{
3564 QRtools::save($vect, $filename);
3565 }
3566 }
3567 }
3568
3569
3570 //----------------------------------------------------------------------
3571 private static function vectSVG($frame, $pixelPerPoint = 4, $outerFrame = 4, $back_color = 0xFFFFFF, $fore_color = 0x000000)
3572 {
3573 $h = count($frame);
3574 $w = strlen($frame[0]);
3575
3576 $imgW = $w + 2*$outerFrame;
3577 $imgH = $h + 2*$outerFrame;
3578
3579
3580 $output =
3581 '<?xml version="1.0" encoding="utf-8"?>'."\n".
3582 '<svg version="1.1" baseProfile="full" width="'.$imgW * $pixelPerPoint.'" height="'.$imgH * $pixelPerPoint.'" viewBox="0 0 '.$imgW * $pixelPerPoint.' '.$imgH * $pixelPerPoint.'"
3583 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ev="http://www.w3.org/2001/xml-events">'."\n".
3584 '<desc></desc>'."\n";
3585
3586 $output =
3587 '<?xml version="1.0" encoding="utf-8"?>'."\n".
3588 '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">'."\n".
3589 '<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" xmlns:xlink="http://www.w3.org/1999/xlink" width="'.$imgW * $pixelPerPoint.'" height="'.$imgH * $pixelPerPoint.'" viewBox="0 0 '.$imgW * $pixelPerPoint.' '.$imgH * $pixelPerPoint.'">'."\n".
3590 '<desc></desc>'."\n";
3591
3592 if(!empty($back_color)) {
3593 $backgroundcolor = str_pad(dechex($back_color), 6, "0", STR_PAD_LEFT);
3594 $output .= '<rect width="'.$imgW * $pixelPerPoint.'" height="'.$imgH * $pixelPerPoint.'" fill="#'.$backgroundcolor.'" cx="0" cy="0" />'."\n";
3595 }
3596
3597 $output .=
3598 '<defs>'."\n".
3599 '<rect id="p" width="'.$pixelPerPoint.'" height="'.$pixelPerPoint.'" />'."\n".
3600 '</defs>'."\n".
3601 '<g fill="#'.str_pad(dechex($fore_color), 6, "0", STR_PAD_LEFT).'">'."\n";
3602
3603
3604 // Convert the matrix into pixels
3605
3606 for($i=0; $i<$h; $i++) {
3607 for($j=0; $j<$w; $j++) {
3608 if( $frame[$i][$j] == '1') {
3609 $y = ($i + $outerFrame) * $pixelPerPoint;
3610 $x = ($j + $outerFrame) * $pixelPerPoint;
3611 $output .= '<use x="'.$x.'" y="'.$y.'" xlink:href="#p" />'."\n";
3612 }
3613 }
3614 }
3615 $output .=
3616 '</g>'."\n".
3617 '</svg>';
3618
3619 return $output;
3620 }
3621 }
3622
3623
3624
3625