PageRenderTime 81ms CodeModel.GetById 37ms RepoModel.GetById 1ms app.codeStats 0ms

/library/tcpdf/barcodes.php

https://bitbucket.org/marcor/gazie
PHP | 2201 lines | 1774 code | 38 blank | 389 comment | 236 complexity | 65c705bbc5382a9d21d210fa2461b63c MD5 | raw file
Possible License(s): LGPL-2.1, LGPL-3.0, GPL-2.0 
    

  1. <?php
    2. 

  2. //============================================================+
    3. 

  3. // File name   : barcodes.php
    4. 

  4. // Version     : 1.0.017
    5. 

  5. // Begin       : 2008-06-09
    6. 

  6. // Last Update : 2011-06-01
    7. 

  7. // Author      : Nicola Asuni - Tecnick.com S.r.l - Via Della Pace, 11 - 09044 - Quartucciu (CA) - ITALY - www.tecnick.com - info@tecnick.com
    8. 

  8. // License     : GNU-LGPL v3 (http://www.gnu.org/copyleft/lesser.html)
    9. 

  9. // -------------------------------------------------------------------
    10. 

  10. // Copyright (C) 2008-2011  Nicola Asuni - Tecnick.com S.r.l.
    11. 

  11. //
    12. 

  12. // This file is part of TCPDF software library.
    13. 

  13. //
    14. 

  14. // TCPDF is free software: you can redistribute it and/or modify it
    15. 

  15. // under the terms of the GNU Lesser General Public License as
    16. 

  16. // published by the Free Software Foundation, either version 3 of the
    17. 

  17. // License, or (at your option) any later version.
    18. 

  18. //
    19. 

  19. // TCPDF is distributed in the hope that it will be useful, but
    20. 

  20. // WITHOUT ANY WARRANTY; without even the implied warranty of
    21. 

  21. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    22. 

  22. // See the GNU Lesser General Public License for more details.
    23. 

  23. //
    24. 

  24. // You should have received a copy of the GNU Lesser General Public License
    25. 

  25. // along with TCPDF.  If not, see <http://www.gnu.org/licenses/>.
    26. 

  26. //
    27. 

  27. // See LICENSE.TXT file for more information.
    28. 

  28. // -------------------------------------------------------------------
    29. 

  29. //
    30. 

  30. // Description : PHP class to creates array representations for
    31. 

  31. //               common 1D barcodes to be used with TCPDF.
    32. 

  32. //
    33. 

  33. //============================================================+
    34. 

  34. 

  35. /**
    36. 

  36.  * @file
    37. 

  37.  * PHP class to creates array representations for common 1D barcodes to be used with TCPDF.
    38. 

  38.  * @package com.tecnick.tcpdf
    39. 

  39.  * @author Nicola Asuni
    40. 

  40.  * @version 1.0.017
    41. 

  41.  */
    42. 

  42. 

  43. /**
    44. 

  44.  * @class TCPDFBarcode
    45. 

  45.  * PHP class to creates array representations for common 1D barcodes to be used with TCPDF (http://www.tcpdf.org).<br>
    46. 

  46.  * @package com.tecnick.tcpdf
    47. 

  47.  * @version 1.0.017
    48. 

  48.  * @author Nicola Asuni
    49. 

  49.  */
    50. 

  50. class TCPDFBarcode {
    51. 

  51. 

  52. 	/**
    53. 

  53. 	 * Array representation of barcode.
    54. 

  54. 	 * @protected
    55. 

  55. 	 */
    56. 

  56. 	protected $barcode_array;
    57. 

  57. 

  58. 	/**
    59. 

  59. 	 * This is the class constructor.
    60. 

  60. 	 * Return an array representations for common 1D barcodes:<ul>
    61. 

  61. 	 * <li>$arrcode['code'] code to be printed on text label</li>
    62. 

  62. 	 * <li>$arrcode['maxh'] max barcode height</li>
    63. 

  63. 	 * <li>$arrcode['maxw'] max barcode width</li>
    64. 

  64. 	 * <li>$arrcode['bcode'][$k] single bar or space in $k position</li>
    65. 

  65. 	 * <li>$arrcode['bcode'][$k]['t'] bar type: true = bar, false = space.</li>
    66. 

  66. 	 * <li>$arrcode['bcode'][$k]['w'] bar width in units.</li>
    67. 

  67. 	 * <li>$arrcode['bcode'][$k]['h'] bar height in units.</li>
    68. 

  68. 	 * <li>$arrcode['bcode'][$k]['p'] bar top position (0 = top, 1 = middle)</li></ul>
    69. 

  69. 	 * @param $code (string) code to print
    70. 

  70.  	 * @param $type (string) type of barcode: <ul><li>C39 : CODE 39 - ANSI MH10.8M-1983 - USD-3 - 3 of 9.</li><li>C39+ : CODE 39 with checksum</li><li>C39E : CODE 39 EXTENDED</li><li>C39E+ : CODE 39 EXTENDED + CHECKSUM</li><li>C93 : CODE 93 - USS-93</li><li>S25 : Standard 2 of 5</li><li>S25+ : Standard 2 of 5 + CHECKSUM</li><li>I25 : Interleaved 2 of 5</li><li>I25+ : Interleaved 2 of 5 + CHECKSUM</li><li>C128 : CODE 128</li><li>C128A : CODE 128 A</li><li>C128B : CODE 128 B</li><li>C128C : CODE 128 C</li><li>EAN2 : 2-Digits UPC-Based Extention</li><li>EAN5 : 5-Digits UPC-Based Extention</li><li>EAN8 : EAN 8</li><li>EAN13 : EAN 13</li><li>UPCA : UPC-A</li><li>UPCE : UPC-E</li><li>MSI : MSI (Variation of Plessey code)</li><li>MSI+ : MSI + CHECKSUM (modulo 11)</li><li>POSTNET : POSTNET</li><li>PLANET : PLANET</li><li>RMS4CC : RMS4CC (Royal Mail 4-state Customer Code) - CBC (Customer Bar Code)</li><li>KIX : KIX (Klant index - Customer index)</li><li>IMB: Intelligent Mail Barcode - Onecode - USPS-B-3200</li><li>CODABAR : CODABAR</li><li>CODE11 : CODE 11</li><li>PHARMA : PHARMACODE</li><li>PHARMA2T : PHARMACODE TWO-TRACKS</li></ul>
    71. 

  71.  	 * @public
    72. 

  72. 	 */
    73. 

  73. 	public function __construct($code, $type) {
    74. 

  74. 		$this->setBarcode($code, $type);
    75. 

  75. 	}
    76. 

  76. 

  77. 	/**
    78. 

  78. 	 * Return an array representations of barcode.
    79. 

  79.  	 * @return array
    80. 

  80.  	 * @public
    81. 

  81. 	 */
    82. 

  82. 	public function getBarcodeArray() {
    83. 

  83. 		return $this->barcode_array;
    84. 

  84. 	}
    85. 

  85. 

  86. 	/**
    87. 

  87. 	 * Send barcode as SVG image object to the standard output.
    88. 

  88. 	 * @param $w (int) Minimum width of a single bar in user units.
    89. 

  89. 	 * @param $h (int) Height of barcode in user units.
    90. 

  90. 	 * @param $color (string) Foreground color (in SVG format) for bar elements (background is transparent).
    91. 

  91.  	 * @public
    92. 

  92. 	 */
    93. 

  93. 	public function getBarcodeSVG($w=2, $h=30, $color='black') {
    94. 

  94. 		// send XML headers
    95. 

  95. 		$code = $this->getBarcodeSVGcode($w, $h, $color);
    96. 

  96. 		header('Content-Type: application/svg+xml');
    97. 

  97. 		header('Cache-Control: public, must-revalidate, max-age=0'); // HTTP/1.1
    98. 

  98. 		header('Pragma: public');
    99. 

  99. 		header('Expires: Sat, 26 Jul 1997 05:00:00 GMT'); // Date in the past
    100. 

  100. 		header('Last-Modified: '.gmdate('D, d M Y H:i:s').' GMT');
    101. 

  101. 		header('Content-Disposition: inline; filename="'.md5($code).'.svg";');
    102. 

  102. 		//header('Content-Length: '.strlen($code));
    103. 

  103. 		echo $code;
    104. 

  104. 	}
    105. 

  105. 

  106. 	/**
    107. 

  107. 	 * Return a SVG string representation of barcode.
    108. 

  108. 	 * @param $w (int) Minimum width of a single bar in user units.
    109. 

  109. 	 * @param $h (int) Height of barcode in user units.
    110. 

  110. 	 * @param $color (string) Foreground color (in SVG format) for bar elements (background is transparent).
    111. 

  111.  	 * @return string SVG code.
    112. 

  112.  	 * @public
    113. 

  113. 	 */
    114. 

  114. 	public function getBarcodeSVGcode($w=2, $h=30, $color='black') {
    115. 

  115. 		// replace table for special characters
    116. 

  116. 		$repstr = array("\0" => '', '&' => '&amp;', '<' => '&lt;', '>' => '&gt;');
    117. 

  117. 		$svg = '<'.'?'.'xml version="1.0" standalone="no"'.'?'.'>'."\n";
    118. 

  118. 		$svg .= '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">'."\n";
    119. 

  119. 		$svg .= '<svg width="'.round(($this->barcode_array['maxw'] * $w), 3).'" height="'.$h.'" version="1.1" xmlns="http://www.w3.org/2000/svg">'."\n";
    120. 

  120. 		$svg .= "\t".'<desc>'.strtr($this->barcode_array['code'], $repstr).'</desc>'."\n";
    121. 

  121. 		$svg .= "\t".'<g id="bars" fill="'.$color.'" stroke="none">'."\n";
    122. 

  122. 		// print bars
    123. 

  123. 		$x = 0;
    124. 

  124. 		foreach ($this->barcode_array['bcode'] as $k => $v) {
    125. 

  125. 			$bw = round(($v['w'] * $w), 3);
    126. 

  126. 			$bh = round(($v['h'] * $h / $this->barcode_array['maxh']), 3);
    127. 

  127. 			if ($v['t']) {
    128. 

  128. 				$y = round(($v['p'] * $h / $this->barcode_array['maxh']), 3);
    129. 

  129. 				// draw a vertical bar
    130. 

  130. 				$svg .= "\t\t".'<rect x="'.$x.'" y="'.$y.'" width="'.$bw.'" height="'.$bh.'" />'."\n";
    131. 

  131. 			}
    132. 

  132. 			$x += $bw;
    133. 

  133. 		}
    134. 

  134. 		$svg .= "\t".'</g>'."\n";
    135. 

  135. 		$svg .= '</svg>'."\n";
    136. 

  136. 		return $svg;
    137. 

  137. 	}
    138. 

  138. 

  139. 	/**
    140. 

  140. 	 * Set the barcode.
    141. 

  141. 	 * @param $code (string) code to print
    142. 

  142.  	 * @param $type (string) type of barcode: <ul><li>C39 : CODE 39 - ANSI MH10.8M-1983 - USD-3 - 3 of 9.</li><li>C39+ : CODE 39 with checksum</li><li>C39E : CODE 39 EXTENDED</li><li>C39E+ : CODE 39 EXTENDED + CHECKSUM</li><li>C93 : CODE 93 - USS-93</li><li>S25 : Standard 2 of 5</li><li>S25+ : Standard 2 of 5 + CHECKSUM</li><li>I25 : Interleaved 2 of 5</li><li>I25+ : Interleaved 2 of 5 + CHECKSUM</li><li>C128 : CODE 128</li><li>C128A : CODE 128 A</li><li>C128B : CODE 128 B</li><li>C128C : CODE 128 C</li><li>EAN2 : 2-Digits UPC-Based Extention</li><li>EAN5 : 5-Digits UPC-Based Extention</li><li>EAN8 : EAN 8</li><li>EAN13 : EAN 13</li><li>UPCA : UPC-A</li><li>UPCE : UPC-E</li><li>MSI : MSI (Variation of Plessey code)</li><li>MSI+ : MSI + CHECKSUM (modulo 11)</li><li>POSTNET : POSTNET</li><li>PLANET : PLANET</li><li>RMS4CC : RMS4CC (Royal Mail 4-state Customer Code) - CBC (Customer Bar Code)</li><li>KIX : KIX (Klant index - Customer index)</li><li>IMB: Intelligent Mail Barcode - Onecode - USPS-B-3200</li><li>CODABAR : CODABAR</li><li>CODE11 : CODE 11</li><li>PHARMA : PHARMACODE</li><li>PHARMA2T : PHARMACODE TWO-TRACKS</li></ul>
    143. 

  143.  	 * @return array barcode array
    144. 

  144.  	 * @public
    145. 

  145. 	 */
    146. 

  146. 	public function setBarcode($code, $type) {
    147. 

  147. 		switch (strtoupper($type)) {
    148. 

  148. 			case 'C39': { // CODE 39 - ANSI MH10.8M-1983 - USD-3 - 3 of 9.
    149. 

  149. 				$arrcode = $this->barcode_code39($code, false, false);
    150. 

  150. 				break;
    151. 

  151. 			}
    152. 

  152. 			case 'C39+': { // CODE 39 with checksum
    153. 

  153. 				$arrcode = $this->barcode_code39($code, false, true);
    154. 

  154. 				break;
    155. 

  155. 			}
    156. 

  156. 			case 'C39E': { // CODE 39 EXTENDED
    157. 

  157. 				$arrcode = $this->barcode_code39($code, true, false);
    158. 

  158. 				break;
    159. 

  159. 			}
    160. 

  160. 			case 'C39E+': { // CODE 39 EXTENDED + CHECKSUM
    161. 

  161. 				$arrcode = $this->barcode_code39($code, true, true);
    162. 

  162. 				break;
    163. 

  163. 			}
    164. 

  164. 			case 'C93': { // CODE 93 - USS-93
    165. 

  165. 				$arrcode = $this->barcode_code93($code);
    166. 

  166. 				break;
    167. 

  167. 			}
    168. 

  168. 			case 'S25': { // Standard 2 of 5
    169. 

  169. 				$arrcode = $this->barcode_s25($code, false);
    170. 

  170. 				break;
    171. 

  171. 			}
    172. 

  172. 			case 'S25+': { // Standard 2 of 5 + CHECKSUM
    173. 

  173. 				$arrcode = $this->barcode_s25($code, true);
    174. 

  174. 				break;
    175. 

  175. 			}
    176. 

  176. 			case 'I25': { // Interleaved 2 of 5
    177. 

  177. 				$arrcode = $this->barcode_i25($code, false);
    178. 

  178. 				break;
    179. 

  179. 			}
    180. 

  180. 			case 'I25+': { // Interleaved 2 of 5 + CHECKSUM
    181. 

  181. 				$arrcode = $this->barcode_i25($code, true);
    182. 

  182. 				break;
    183. 

  183. 			}
    184. 

  184. 			case 'C128': { // CODE 128
    185. 

  185. 				$arrcode = $this->barcode_c128($code, '');
    186. 

  186. 				break;
    187. 

  187. 			}
    188. 

  188. 			case 'C128A': { // CODE 128 A
    189. 

  189. 				$arrcode = $this->barcode_c128($code, 'A');
    190. 

  190. 				break;
    191. 

  191. 			}
    192. 

  192. 			case 'C128B': { // CODE 128 B
    193. 

  193. 				$arrcode = $this->barcode_c128($code, 'B');
    194. 

  194. 				break;
    195. 

  195. 			}
    196. 

  196. 			case 'C128C': { // CODE 128 C
    197. 

  197. 				$arrcode = $this->barcode_c128($code, 'C');
    198. 

  198. 				break;
    199. 

  199. 			}
    200. 

  200. 			case 'EAN2': { // 2-Digits UPC-Based Extention
    201. 

  201. 				$arrcode = $this->barcode_eanext($code, 2);
    202. 

  202. 				break;
    203. 

  203. 			}
    204. 

  204. 			case 'EAN5': { // 5-Digits UPC-Based Extention
    205. 

  205. 				$arrcode = $this->barcode_eanext($code, 5);
    206. 

  206. 				break;
    207. 

  207. 			}
    208. 

  208. 			case 'EAN8': { // EAN 8
    209. 

  209. 				$arrcode = $this->barcode_eanupc($code, 8);
    210. 

  210. 				break;
    211. 

  211. 			}
    212. 

  212. 			case 'EAN13': { // EAN 13
    213. 

  213. 				$arrcode = $this->barcode_eanupc($code, 13);
    214. 

  214. 				break;
    215. 

  215. 			}
    216. 

  216. 			case 'UPCA': { // UPC-A
    217. 

  217. 				$arrcode = $this->barcode_eanupc($code, 12);
    218. 

  218. 				break;
    219. 

  219. 			}
    220. 

  220. 			case 'UPCE': { // UPC-E
    221. 

  221. 				$arrcode = $this->barcode_eanupc($code, 6);
    222. 

  222. 				break;
    223. 

  223. 			}
    224. 

  224. 			case 'MSI': { // MSI (Variation of Plessey code)
    225. 

  225. 				$arrcode = $this->barcode_msi($code, false);
    226. 

  226. 				break;
    227. 

  227. 			}
    228. 

  228. 			case 'MSI+': { // MSI + CHECKSUM (modulo 11)
    229. 

  229. 				$arrcode = $this->barcode_msi($code, true);
    230. 

  230. 				break;
    231. 

  231. 			}
    232. 

  232. 			case 'POSTNET': { // POSTNET
    233. 

  233. 				$arrcode = $this->barcode_postnet($code, false);
    234. 

  234. 				break;
    235. 

  235. 			}
    236. 

  236. 			case 'PLANET': { // PLANET
    237. 

  237. 				$arrcode = $this->barcode_postnet($code, true);
    238. 

  238. 				break;
    239. 

  239. 			}
    240. 

  240. 			case 'RMS4CC': { // RMS4CC (Royal Mail 4-state Customer Code) - CBC (Customer Bar Code)
    241. 

  241. 				$arrcode = $this->barcode_rms4cc($code, false);
    242. 

  242. 				break;
    243. 

  243. 			}
    244. 

  244. 			case 'KIX': { // KIX (Klant index - Customer index)
    245. 

  245. 				$arrcode = $this->barcode_rms4cc($code, true);
    246. 

  246. 				break;
    247. 

  247. 			}
    248. 

  248. 			case 'IMB': { // IMB - Intelligent Mail Barcode - Onecode - USPS-B-3200
    249. 

  249. 				$arrcode = $this->barcode_imb($code);
    250. 

  250. 				break;
    251. 

  251. 			}
    252. 

  252. 			case 'CODABAR': { // CODABAR
    253. 

  253. 				$arrcode = $this->barcode_codabar($code);
    254. 

  254. 				break;
    255. 

  255. 			}
    256. 

  256. 			case 'CODE11': { // CODE 11
    257. 

  257. 				$arrcode = $this->barcode_code11($code);
    258. 

  258. 				break;
    259. 

  259. 			}
    260. 

  260. 			case 'PHARMA': { // PHARMACODE
    261. 

  261. 				$arrcode = $this->barcode_pharmacode($code);
    262. 

  262. 				break;
    263. 

  263. 			}
    264. 

  264. 			case 'PHARMA2T': { // PHARMACODE TWO-TRACKS
    265. 

  265. 				$arrcode = $this->barcode_pharmacode2t($code);
    266. 

  266. 				break;
    267. 

  267. 			}
    268. 

  268. 			default: {
    269. 

  269. 				$this->barcode_array = false;
    270. 

  270. 				$arrcode = false;
    271. 

  271. 				break;
    272. 

  272. 			}
    273. 

  273. 		}
    274. 

  274. 		$this->barcode_array = $arrcode;
    275. 

  275. 	}
    276. 

  276. 

  277. 	/**
    278. 

  278. 	 * CODE 39 - ANSI MH10.8M-1983 - USD-3 - 3 of 9.
    279. 

  279. 	 * General-purpose code in very wide use world-wide
    280. 

  280. 	 * @param $code (string) code to represent.
    281. 

  281. 	 * @param $extended (boolean) if true uses the extended mode.
    282. 

  282. 	 * @param $checksum (boolean) if true add a checksum to the code.
    283. 

  283. 	 * @return array barcode representation.
    284. 

  284. 	 * @protected
    285. 

  285. 	 */
    286. 

  286. 	protected function barcode_code39($code, $extended=false, $checksum=false) {
    287. 

  287. 		$chr['0'] = '111221211';
    288. 

  288. 		$chr['1'] = '211211112';
    289. 

  289. 		$chr['2'] = '112211112';
    290. 

  290. 		$chr['3'] = '212211111';
    291. 

  291. 		$chr['4'] = '111221112';
    292. 

  292. 		$chr['5'] = '211221111';
    293. 

  293. 		$chr['6'] = '112221111';
    294. 

  294. 		$chr['7'] = '111211212';
    295. 

  295. 		$chr['8'] = '211211211';
    296. 

  296. 		$chr['9'] = '112211211';
    297. 

  297. 		$chr['A'] = '211112112';
    298. 

  298. 		$chr['B'] = '112112112';
    299. 

  299. 		$chr['C'] = '212112111';
    300. 

  300. 		$chr['D'] = '111122112';
    301. 

  301. 		$chr['E'] = '211122111';
    302. 

  302. 		$chr['F'] = '112122111';
    303. 

  303. 		$chr['G'] = '111112212';
    304. 

  304. 		$chr['H'] = '211112211';
    305. 

  305. 		$chr['I'] = '112112211';
    306. 

  306. 		$chr['J'] = '111122211';
    307. 

  307. 		$chr['K'] = '211111122';
    308. 

  308. 		$chr['L'] = '112111122';
    309. 

  309. 		$chr['M'] = '212111121';
    310. 

  310. 		$chr['N'] = '111121122';
    311. 

  311. 		$chr['O'] = '211121121';
    312. 

  312. 		$chr['P'] = '112121121';
    313. 

  313. 		$chr['Q'] = '111111222';
    314. 

  314. 		$chr['R'] = '211111221';
    315. 

  315. 		$chr['S'] = '112111221';
    316. 

  316. 		$chr['T'] = '111121221';
    317. 

  317. 		$chr['U'] = '221111112';
    318. 

  318. 		$chr['V'] = '122111112';
    319. 

  319. 		$chr['W'] = '222111111';
    320. 

  320. 		$chr['X'] = '121121112';
    321. 

  321. 		$chr['Y'] = '221121111';
    322. 

  322. 		$chr['Z'] = '122121111';
    323. 

  323. 		$chr['-'] = '121111212';
    324. 

  324. 		$chr['.'] = '221111211';
    325. 

  325. 		$chr[' '] = '122111211';
    326. 

  326. 		$chr['$'] = '121212111';
    327. 

  327. 		$chr['/'] = '121211121';
    328. 

  328. 		$chr['+'] = '121112121';
    329. 

  329. 		$chr['%'] = '111212121';
    330. 

  330. 		$chr['*'] = '121121211';
    331. 

  331. 		$code = strtoupper($code);
    332. 

  332. 		if ($extended) {
    333. 

  333. 			// extended mode
    334. 

  334. 			$code = $this->encode_code39_ext($code);
    335. 

  335. 		}
    336. 

  336. 		if ($code === false) {
    337. 

  337. 			return false;
    338. 

  338. 		}
    339. 

  339. 		if ($checksum) {
    340. 

  340. 			// checksum
    341. 

  341. 			$code .= $this->checksum_code39($code);
    342. 

  342. 		}
    343. 

  343. 		// add start and stop codes
    344. 

  344. 		$code = '*'.$code.'*';
    345. 

  345. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    346. 

  346. 		$k = 0;
    347. 

  347. 		$clen = strlen($code);
    348. 

  348. 		for ($i = 0; $i < $clen; ++$i) {
    349. 

  349. 			$char = $code{$i};
    350. 

  350. 			if(!isset($chr[$char])) {
    351. 

  351. 				// invalid character
    352. 

  352. 				return false;
    353. 

  353. 			}
    354. 

  354. 			for ($j = 0; $j < 9; ++$j) {
    355. 

  355. 				if (($j % 2) == 0) {
    356. 

  356. 					$t = true; // bar
    357. 

  357. 				} else {
    358. 

  358. 					$t = false; // space
    359. 

  359. 				}
    360. 

  360. 				$w = $chr[$char]{$j};
    361. 

  361. 				$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
    362. 

  362. 				$bararray['maxw'] += $w;
    363. 

  363. 				++$k;
    364. 

  364. 			}
    365. 

  365. 			$bararray['bcode'][$k] = array('t' => false, 'w' => 1, 'h' => 1, 'p' => 0);
    366. 

  366. 			$bararray['maxw'] += 1;
    367. 

  367. 			++$k;
    368. 

  368. 		}
    369. 

  369. 		return $bararray;
    370. 

  370. 	}
    371. 

  371. 

  372. 	/**
    373. 

  373. 	 * Encode a string to be used for CODE 39 Extended mode.
    374. 

  374. 	 * @param $code (string) code to represent.
    375. 

  375. 	 * @return encoded string.
    376. 

  376. 	 * @protected
    377. 

  377. 	 */
    378. 

  378. 	protected function encode_code39_ext($code) {
    379. 

  379. 		$encode = array(
    380. 

  380. 			chr(0) => '%U', chr(1) => '$A', chr(2) => '$B', chr(3) => '$C',
    381. 

  381. 			chr(4) => '$D', chr(5) => '$E', chr(6) => '$F', chr(7) => '$G',
    382. 

  382. 			chr(8) => '$H', chr(9) => '$I', chr(10) => '$J', chr(11) => '£K',
    383. 

  383. 			chr(12) => '$L', chr(13) => '$M', chr(14) => '$N', chr(15) => '$O',
    384. 

  384. 			chr(16) => '$P', chr(17) => '$Q', chr(18) => '$R', chr(19) => '$S',
    385. 

  385. 			chr(20) => '$T', chr(21) => '$U', chr(22) => '$V', chr(23) => '$W',
    386. 

  386. 			chr(24) => '$X', chr(25) => '$Y', chr(26) => '$Z', chr(27) => '%A',
    387. 

  387. 			chr(28) => '%B', chr(29) => '%C', chr(30) => '%D', chr(31) => '%E',
    388. 

  388. 			chr(32) => ' ', chr(33) => '/A', chr(34) => '/B', chr(35) => '/C',
    389. 

  389. 			chr(36) => '/D', chr(37) => '/E', chr(38) => '/F', chr(39) => '/G',
    390. 

  390. 			chr(40) => '/H', chr(41) => '/I', chr(42) => '/J', chr(43) => '/K',
    391. 

  391. 			chr(44) => '/L', chr(45) => '-', chr(46) => '.', chr(47) => '/O',
    392. 

  392. 			chr(48) => '0', chr(49) => '1', chr(50) => '2', chr(51) => '3',
    393. 

  393. 			chr(52) => '4', chr(53) => '5', chr(54) => '6', chr(55) => '7',
    394. 

  394. 			chr(56) => '8', chr(57) => '9', chr(58) => '/Z', chr(59) => '%F',
    395. 

  395. 			chr(60) => '%G', chr(61) => '%H', chr(62) => '%I', chr(63) => '%J',
    396. 

  396. 			chr(64) => '%V', chr(65) => 'A', chr(66) => 'B', chr(67) => 'C',
    397. 

  397. 			chr(68) => 'D', chr(69) => 'E', chr(70) => 'F', chr(71) => 'G',
    398. 

  398. 			chr(72) => 'H', chr(73) => 'I', chr(74) => 'J', chr(75) => 'K',
    399. 

  399. 			chr(76) => 'L', chr(77) => 'M', chr(78) => 'N', chr(79) => 'O',
    400. 

  400. 			chr(80) => 'P', chr(81) => 'Q', chr(82) => 'R', chr(83) => 'S',
    401. 

  401. 			chr(84) => 'T', chr(85) => 'U', chr(86) => 'V', chr(87) => 'W',
    402. 

  402. 			chr(88) => 'X', chr(89) => 'Y', chr(90) => 'Z', chr(91) => '%K',
    403. 

  403. 			chr(92) => '%L', chr(93) => '%M', chr(94) => '%N', chr(95) => '%O',
    404. 

  404. 			chr(96) => '%W', chr(97) => '+A', chr(98) => '+B', chr(99) => '+C',
    405. 

  405. 			chr(100) => '+D', chr(101) => '+E', chr(102) => '+F', chr(103) => '+G',
    406. 

  406. 			chr(104) => '+H', chr(105) => '+I', chr(106) => '+J', chr(107) => '+K',
    407. 

  407. 			chr(108) => '+L', chr(109) => '+M', chr(110) => '+N', chr(111) => '+O',
    408. 

  408. 			chr(112) => '+P', chr(113) => '+Q', chr(114) => '+R', chr(115) => '+S',
    409. 

  409. 			chr(116) => '+T', chr(117) => '+U', chr(118) => '+V', chr(119) => '+W',
    410. 

  410. 			chr(120) => '+X', chr(121) => '+Y', chr(122) => '+Z', chr(123) => '%P',
    411. 

  411. 			chr(124) => '%Q', chr(125) => '%R', chr(126) => '%S', chr(127) => '%T');
    412. 

  412. 		$code_ext = '';
    413. 

  413. 		$clen = strlen($code);
    414. 

  414. 		for ($i = 0 ; $i < $clen; ++$i) {
    415. 

  415. 			if (ord($code{$i}) > 127) {
    416. 

  416. 				return false;
    417. 

  417. 			}
    418. 

  418. 			$code_ext .= $encode[$code{$i}];
    419. 

  419. 		}
    420. 

  420. 		return $code_ext;
    421. 

  421. 	}
    422. 

  422. 

  423. 	/**
    424. 

  424. 	 * Calculate CODE 39 checksum (modulo 43).
    425. 

  425. 	 * @param $code (string) code to represent.
    426. 

  426. 	 * @return char checksum.
    427. 

  427. 	 * @protected
    428. 

  428. 	 */
    429. 

  429. 	protected function checksum_code39($code) {
    430. 

  430. 		$chars = array(
    431. 

  431. 			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    432. 

  432. 			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
    433. 

  433. 			'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
    434. 

  434. 			'W', 'X', 'Y', 'Z', '-', '.', ' ', '$', '/', '+', '%');
    435. 

  435. 		$sum = 0;
    436. 

  436. 		$clen = strlen($code);
    437. 

  437. 		for ($i = 0 ; $i < $clen; ++$i) {
    438. 

  438. 			$k = array_keys($chars, $code{$i});
    439. 

  439. 			$sum += $k[0];
    440. 

  440. 		}
    441. 

  441. 		$j = ($sum % 43);
    442. 

  442. 		return $chars[$j];
    443. 

  443. 	}
    444. 

  444. 

  445. 	/**
    446. 

  446. 	 * CODE 93 - USS-93
    447. 

  447. 	 * Compact code similar to Code 39
    448. 

  448. 	 * @param $code (string) code to represent.
    449. 

  449. 	 * @return array barcode representation.
    450. 

  450. 	 * @protected
    451. 

  451. 	 */
    452. 

  452. 	protected function barcode_code93($code) {
    453. 

  453. 		$chr[48] = '131112'; // 0
    454. 

  454. 		$chr[49] = '111213'; // 1
    455. 

  455. 		$chr[50] = '111312'; // 2
    456. 

  456. 		$chr[51] = '111411'; // 3
    457. 

  457. 		$chr[52] = '121113'; // 4
    458. 

  458. 		$chr[53] = '121212'; // 5
    459. 

  459. 		$chr[54] = '121311'; // 6
    460. 

  460. 		$chr[55] = '111114'; // 7
    461. 

  461. 		$chr[56] = '131211'; // 8
    462. 

  462. 		$chr[57] = '141111'; // 9
    463. 

  463. 		$chr[65] = '211113'; // A
    464. 

  464. 		$chr[66] = '211212'; // B
    465. 

  465. 		$chr[67] = '211311'; // C
    466. 

  466. 		$chr[68] = '221112'; // D
    467. 

  467. 		$chr[69] = '221211'; // E
    468. 

  468. 		$chr[70] = '231111'; // F
    469. 

  469. 		$chr[71] = '112113'; // G
    470. 

  470. 		$chr[72] = '112212'; // H
    471. 

  471. 		$chr[73] = '112311'; // I
    472. 

  472. 		$chr[74] = '122112'; // J
    473. 

  473. 		$chr[75] = '132111'; // K
    474. 

  474. 		$chr[76] = '111123'; // L
    475. 

  475. 		$chr[77] = '111222'; // M
    476. 

  476. 		$chr[78] = '111321'; // N
    477. 

  477. 		$chr[79] = '121122'; // O
    478. 

  478. 		$chr[80] = '131121'; // P
    479. 

  479. 		$chr[81] = '212112'; // Q
    480. 

  480. 		$chr[82] = '212211'; // R
    481. 

  481. 		$chr[83] = '211122'; // S
    482. 

  482. 		$chr[84] = '211221'; // T
    483. 

  483. 		$chr[85] = '221121'; // U
    484. 

  484. 		$chr[86] = '222111'; // V
    485. 

  485. 		$chr[87] = '112122'; // W
    486. 

  486. 		$chr[88] = '112221'; // X
    487. 

  487. 		$chr[89] = '122121'; // Y
    488. 

  488. 		$chr[90] = '123111'; // Z
    489. 

  489. 		$chr[45] = '121131'; // -
    490. 

  490. 		$chr[46] = '311112'; // .
    491. 

  491. 		$chr[32] = '311211'; //
    492. 

  492. 		$chr[36] = '321111'; // $
    493. 

  493. 		$chr[47] = '112131'; // /
    494. 

  494. 		$chr[43] = '113121'; // +
    495. 

  495. 		$chr[37] = '211131'; // %
    496. 

  496. 		$chr[128] = '121221'; // ($)
    497. 

  497. 		$chr[129] = '311121'; // (/)
    498. 

  498. 		$chr[130] = '122211'; // (+)
    499. 

  499. 		$chr[131] = '312111'; // (%)
    500. 

  500. 		$chr[42] = '111141'; // start-stop
    501. 

  501. 		$code = strtoupper($code);
    502. 

  502. 		$encode = array(
    503. 

  503. 			chr(0) => chr(131).'U', chr(1) => chr(128).'A', chr(2) => chr(128).'B', chr(3) => chr(128).'C',
    504. 

  504. 			chr(4) => chr(128).'D', chr(5) => chr(128).'E', chr(6) => chr(128).'F', chr(7) => chr(128).'G',
    505. 

  505. 			chr(8) => chr(128).'H', chr(9) => chr(128).'I', chr(10) => chr(128).'J', chr(11) => '£K',
    506. 

  506. 			chr(12) => chr(128).'L', chr(13) => chr(128).'M', chr(14) => chr(128).'N', chr(15) => chr(128).'O',
    507. 

  507. 			chr(16) => chr(128).'P', chr(17) => chr(128).'Q', chr(18) => chr(128).'R', chr(19) => chr(128).'S',
    508. 

  508. 			chr(20) => chr(128).'T', chr(21) => chr(128).'U', chr(22) => chr(128).'V', chr(23) => chr(128).'W',
    509. 

  509. 			chr(24) => chr(128).'X', chr(25) => chr(128).'Y', chr(26) => chr(128).'Z', chr(27) => chr(131).'A',
    510. 

  510. 			chr(28) => chr(131).'B', chr(29) => chr(131).'C', chr(30) => chr(131).'D', chr(31) => chr(131).'E',
    511. 

  511. 			chr(32) => ' ', chr(33) => chr(129).'A', chr(34) => chr(129).'B', chr(35) => chr(129).'C',
    512. 

  512. 			chr(36) => chr(129).'D', chr(37) => chr(129).'E', chr(38) => chr(129).'F', chr(39) => chr(129).'G',
    513. 

  513. 			chr(40) => chr(129).'H', chr(41) => chr(129).'I', chr(42) => chr(129).'J', chr(43) => chr(129).'K',
    514. 

  514. 			chr(44) => chr(129).'L', chr(45) => '-', chr(46) => '.', chr(47) => chr(129).'O',
    515. 

  515. 			chr(48) => '0', chr(49) => '1', chr(50) => '2', chr(51) => '3',
    516. 

  516. 			chr(52) => '4', chr(53) => '5', chr(54) => '6', chr(55) => '7',
    517. 

  517. 			chr(56) => '8', chr(57) => '9', chr(58) => chr(129).'Z', chr(59) => chr(131).'F',
    518. 

  518. 			chr(60) => chr(131).'G', chr(61) => chr(131).'H', chr(62) => chr(131).'I', chr(63) => chr(131).'J',
    519. 

  519. 			chr(64) => chr(131).'V', chr(65) => 'A', chr(66) => 'B', chr(67) => 'C',
    520. 

  520. 			chr(68) => 'D', chr(69) => 'E', chr(70) => 'F', chr(71) => 'G',
    521. 

  521. 			chr(72) => 'H', chr(73) => 'I', chr(74) => 'J', chr(75) => 'K',
    522. 

  522. 			chr(76) => 'L', chr(77) => 'M', chr(78) => 'N', chr(79) => 'O',
    523. 

  523. 			chr(80) => 'P', chr(81) => 'Q', chr(82) => 'R', chr(83) => 'S',
    524. 

  524. 			chr(84) => 'T', chr(85) => 'U', chr(86) => 'V', chr(87) => 'W',
    525. 

  525. 			chr(88) => 'X', chr(89) => 'Y', chr(90) => 'Z', chr(91) => chr(131).'K',
    526. 

  526. 			chr(92) => chr(131).'L', chr(93) => chr(131).'M', chr(94) => chr(131).'N', chr(95) => chr(131).'O',
    527. 

  527. 			chr(96) => chr(131).'W', chr(97) => chr(130).'A', chr(98) => chr(130).'B', chr(99) => chr(130).'C',
    528. 

  528. 			chr(100) => chr(130).'D', chr(101) => chr(130).'E', chr(102) => chr(130).'F', chr(103) => chr(130).'G',
    529. 

  529. 			chr(104) => chr(130).'H', chr(105) => chr(130).'I', chr(106) => chr(130).'J', chr(107) => chr(130).'K',
    530. 

  530. 			chr(108) => chr(130).'L', chr(109) => chr(130).'M', chr(110) => chr(130).'N', chr(111) => chr(130).'O',
    531. 

  531. 			chr(112) => chr(130).'P', chr(113) => chr(130).'Q', chr(114) => chr(130).'R', chr(115) => chr(130).'S',
    532. 

  532. 			chr(116) => chr(130).'T', chr(117) => chr(130).'U', chr(118) => chr(130).'V', chr(119) => chr(130).'W',
    533. 

  533. 			chr(120) => chr(130).'X', chr(121) => chr(130).'Y', chr(122) => chr(130).'Z', chr(123) => chr(131).'P',
    534. 

  534. 			chr(124) => chr(131).'Q', chr(125) => chr(131).'R', chr(126) => chr(131).'S', chr(127) => chr(131).'T');
    535. 

  535. 		$code_ext = '';
    536. 

  536. 		$clen = strlen($code);
    537. 

  537. 		for ($i = 0 ; $i < $clen; ++$i) {
    538. 

  538. 			if (ord($code{$i}) > 127) {
    539. 

  539. 				return false;
    540. 

  540. 			}
    541. 

  541. 			$code_ext .= $encode[$code{$i}];
    542. 

  542. 		}
    543. 

  543. 		// checksum
    544. 

  544. 		$code_ext .= $this->checksum_code93($code_ext);
    545. 

  545. 		// add start and stop codes
    546. 

  546. 		$code = '*'.$code_ext.'*';
    547. 

  547. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    548. 

  548. 		$k = 0;
    549. 

  549. 		$clen = strlen($code);
    550. 

  550. 		for ($i = 0; $i < $clen; ++$i) {
    551. 

  551. 			$char = ord($code{$i});
    552. 

  552. 			if(!isset($chr[$char])) {
    553. 

  553. 				// invalid character
    554. 

  554. 				return false;
    555. 

  555. 			}
    556. 

  556. 			for ($j = 0; $j < 6; ++$j) {
    557. 

  557. 				if (($j % 2) == 0) {
    558. 

  558. 					$t = true; // bar
    559. 

  559. 				} else {
    560. 

  560. 					$t = false; // space
    561. 

  561. 				}
    562. 

  562. 				$w = $chr[$char]{$j};
    563. 

  563. 				$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
    564. 

  564. 				$bararray['maxw'] += $w;
    565. 

  565. 				++$k;
    566. 

  566. 			}
    567. 

  567. 		}
    568. 

  568. 		$bararray['bcode'][$k] = array('t' => true, 'w' => 1, 'h' => 1, 'p' => 0);
    569. 

  569. 		$bararray['maxw'] += 1;
    570. 

  570. 		++$k;
    571. 

  571. 		return $bararray;
    572. 

  572. 	}
    573. 

  573. 

  574. 	/**
    575. 

  575. 	 * Calculate CODE 93 checksum (modulo 47).
    576. 

  576. 	 * @param $code (string) code to represent.
    577. 

  577. 	 * @return string checksum code.
    578. 

  578. 	 * @protected
    579. 

  579. 	 */
    580. 

  580. 	protected function checksum_code93($code) {
    581. 

  581. 		$chars = array(
    582. 

  582. 			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    583. 

  583. 			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
    584. 

  584. 			'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
    585. 

  585. 			'W', 'X', 'Y', 'Z', '-', '.', ' ', '$', '/', '+', '%',
    586. 

  586. 			'<', '=', '>', '?');
    587. 

  587. 		// translate special characters
    588. 

  588. 		$code = strtr($code, chr(128).chr(131).chr(129).chr(130), '<=>?');
    589. 

  589. 		$len = strlen($code);
    590. 

  590. 		// calculate check digit C
    591. 

  591. 		$p = 1;
    592. 

  592. 		$check = 0;
    593. 

  593. 		for ($i = ($len - 1); $i >= 0; --$i) {
    594. 

  594. 			$k = array_keys($chars, $code{$i});
    595. 

  595. 			$check += ($k[0] * $p);
    596. 

  596. 			++$p;
    597. 

  597. 			if ($p > 20) {
    598. 

  598. 				$p = 1;
    599. 

  599. 			}
    600. 

  600. 		}
    601. 

  601. 		$check %= 47;
    602. 

  602. 		$c = $chars[$check];
    603. 

  603. 		$code .= $c;
    604. 

  604. 		// calculate check digit K
    605. 

  605. 		$p = 1;
    606. 

  606. 		$check = 0;
    607. 

  607. 		for ($i = $len; $i >= 0; --$i) {
    608. 

  608. 			$k = array_keys($chars, $code{$i});
    609. 

  609. 			$check += ($k[0] * $p);
    610. 

  610. 			++$p;
    611. 

  611. 			if ($p > 15) {
    612. 

  612. 				$p = 1;
    613. 

  613. 			}
    614. 

  614. 		}
    615. 

  615. 		$check %= 47;
    616. 

  616. 		$k = $chars[$check];
    617. 

  617. 		$checksum = $c.$k;
    618. 

  618. 		// resto respecial characters
    619. 

  619. 		$checksum = strtr($checksum, '<=>?', chr(128).chr(131).chr(129).chr(130));
    620. 

  620. 		return $checksum;
    621. 

  621. 	}
    622. 

  622. 

  623. 	/**
    624. 

  624. 	 * Checksum for standard 2 of 5 barcodes.
    625. 

  625. 	 * @param $code (string) code to process.
    626. 

  626. 	 * @return int checksum.
    627. 

  627. 	 * @protected
    628. 

  628. 	 */
    629. 

  629. 	protected function checksum_s25($code) {
    630. 

  630. 		$len = strlen($code);
    631. 

  631. 		$sum = 0;
    632. 

  632. 		for ($i = 0; $i < $len; $i+=2) {
    633. 

  633. 			$sum += $code{$i};
    634. 

  634. 		}
    635. 

  635. 		$sum *= 3;
    636. 

  636. 		for ($i = 1; $i < $len; $i+=2) {
    637. 

  637. 			$sum += ($code{$i});
    638. 

  638. 		}
    639. 

  639. 		$r = $sum % 10;
    640. 

  640. 		if($r > 0) {
    641. 

  641. 			$r = (10 - $r);
    642. 

  642. 		}
    643. 

  643. 		return $r;
    644. 

  644. 	}
    645. 

  645. 

  646. 	/**
    647. 

  647. 	 * MSI.
    648. 

  648. 	 * Variation of Plessey code, with similar applications
    649. 

  649. 	 * Contains digits (0 to 9) and encodes the data only in the width of bars.
    650. 

  650. 	 * @param $code (string) code to represent.
    651. 

  651. 	 * @param $checksum (boolean) if true add a checksum to the code (modulo 11)
    652. 

  652. 	 * @return array barcode representation.
    653. 

  653. 	 * @protected
    654. 

  654. 	 */
    655. 

  655. 	protected function barcode_msi($code, $checksum=false) {
    656. 

  656. 		$chr['0'] = '100100100100';
    657. 

  657. 		$chr['1'] = '100100100110';
    658. 

  658. 		$chr['2'] = '100100110100';
    659. 

  659. 		$chr['3'] = '100100110110';
    660. 

  660. 		$chr['4'] = '100110100100';
    661. 

  661. 		$chr['5'] = '100110100110';
    662. 

  662. 		$chr['6'] = '100110110100';
    663. 

  663. 		$chr['7'] = '100110110110';
    664. 

  664. 		$chr['8'] = '110100100100';
    665. 

  665. 		$chr['9'] = '110100100110';
    666. 

  666. 		$chr['A'] = '110100110100';
    667. 

  667. 		$chr['B'] = '110100110110';
    668. 

  668. 		$chr['C'] = '110110100100';
    669. 

  669. 		$chr['D'] = '110110100110';
    670. 

  670. 		$chr['E'] = '110110110100';
    671. 

  671. 		$chr['F'] = '110110110110';
    672. 

  672. 		if ($checksum) {
    673. 

  673. 			// add checksum
    674. 

  674. 			$clen = strlen($code);
    675. 

  675. 			$p = 2;
    676. 

  676. 			$check = 0;
    677. 

  677. 			for ($i = ($clen - 1); $i >= 0; --$i) {
    678. 

  678. 				$check += (hexdec($code{$i}) * $p);
    679. 

  679. 				++$p;
    680. 

  680. 				if ($p > 7) {
    681. 

  681. 					$p = 2;
    682. 

  682. 				}
    683. 

  683. 			}
    684. 

  684. 			$check %= 11;
    685. 

  685. 			if ($check > 0) {
    686. 

  686. 				$check = 11 - $check;
    687. 

  687. 			}
    688. 

  688. 			$code .= $check;
    689. 

  689. 		}
    690. 

  690. 		$seq = '110'; // left guard
    691. 

  691. 		$clen = strlen($code);
    692. 

  692. 		for ($i = 0; $i < $clen; ++$i) {
    693. 

  693. 			$digit = $code{$i};
    694. 

  694. 			if (!isset($chr[$digit])) {
    695. 

  695. 				// invalid character
    696. 

  696. 				return false;
    697. 

  697. 			}
    698. 

  698. 			$seq .= $chr[$digit];
    699. 

  699. 		}
    700. 

  700. 		$seq .= '1001'; // right guard
    701. 

  701. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    702. 

  702. 		return $this->binseq_to_array($seq, $bararray);
    703. 

  703. 	}
    704. 

  704. 

  705. 	/**
    706. 

  706. 	 * Standard 2 of 5 barcodes.
    707. 

  707. 	 * Used in airline ticket marking, photofinishing
    708. 

  708. 	 * Contains digits (0 to 9) and encodes the data only in the width of bars.
    709. 

  709. 	 * @param $code (string) code to represent.
    710. 

  710. 	 * @param $checksum (boolean) if true add a checksum to the code
    711. 

  711. 	 * @return array barcode representation.
    712. 

  712. 	 * @protected
    713. 

  713. 	 */
    714. 

  714. 	protected function barcode_s25($code, $checksum=false) {
    715. 

  715. 		$chr['0'] = '10101110111010';
    716. 

  716. 		$chr['1'] = '11101010101110';
    717. 

  717. 		$chr['2'] = '10111010101110';
    718. 

  718. 		$chr['3'] = '11101110101010';
    719. 

  719. 		$chr['4'] = '10101110101110';
    720. 

  720. 		$chr['5'] = '11101011101010';
    721. 

  721. 		$chr['6'] = '10111011101010';
    722. 

  722. 		$chr['7'] = '10101011101110';
    723. 

  723. 		$chr['8'] = '10101110111010';
    724. 

  724. 		$chr['9'] = '10111010111010';
    725. 

  725. 		if ($checksum) {
    726. 

  726. 			// add checksum
    727. 

  727. 			$code .= $this->checksum_s25($code);
    728. 

  728. 		}
    729. 

  729. 		if((strlen($code) % 2) != 0) {
    730. 

  730. 			// add leading zero if code-length is odd
    731. 

  731. 			$code = '0'.$code;
    732. 

  732. 		}
    733. 

  733. 		$seq = '11011010';
    734. 

  734. 		$clen = strlen($code);
    735. 

  735. 		for ($i = 0; $i < $clen; ++$i) {
    736. 

  736. 			$digit = $code{$i};
    737. 

  737. 			if (!isset($chr[$digit])) {
    738. 

  738. 				// invalid character
    739. 

  739. 				return false;
    740. 

  740. 			}
    741. 

  741. 			$seq .= $chr[$digit];
    742. 

  742. 		}
    743. 

  743. 		$seq .= '1101011';
    744. 

  744. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    745. 

  745. 		return $this->binseq_to_array($seq, $bararray);
    746. 

  746. 	}
    747. 

  747. 

  748. 	/**
    749. 

  749. 	 * Convert binary barcode sequence to TCPDF barcode array.
    750. 

  750. 	 * @param $seq (string) barcode as binary sequence.
    751. 

  751. 	 * @param $bararray (array) barcode array.
    752. 

  752. 	 * òparam array $bararray TCPDF barcode array to fill up
    753. 

  753. 	 * @return array barcode representation.
    754. 

  754. 	 * @protected
    755. 

  755. 	 */
    756. 

  756. 	protected function binseq_to_array($seq, $bararray) {
    757. 

  757. 		$len = strlen($seq);
    758. 

  758. 		$w = 0;
    759. 

  759. 		$k = 0;
    760. 

  760. 		for ($i = 0; $i < $len; ++$i) {
    761. 

  761. 			$w += 1;
    762. 

  762. 			if (($i == ($len - 1)) OR (($i < ($len - 1)) AND ($seq{$i} != $seq{($i+1)}))) {
    763. 

  763. 				if ($seq{$i} == '1') {
    764. 

  764. 					$t = true; // bar
    765. 

  765. 				} else {
    766. 

  766. 					$t = false; // space
    767. 

  767. 				}
    768. 

  768. 				$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
    769. 

  769. 				$bararray['maxw'] += $w;
    770. 

  770. 				++$k;
    771. 

  771. 				$w = 0;
    772. 

  772. 			}
    773. 

  773. 		}
    774. 

  774. 		return $bararray;
    775. 

  775. 	}
    776. 

  776. 

  777. 	/**
    778. 

  778. 	 * Interleaved 2 of 5 barcodes.
    779. 

  779. 	 * Compact numeric code, widely used in industry, air cargo
    780. 

  780. 	 * Contains digits (0 to 9) and encodes the data in the width of both bars and spaces.
    781. 

  781. 	 * @param $code (string) code to represent.
    782. 

  782. 	 * @param $checksum (boolean) if true add a checksum to the code
    783. 

  783. 	 * @return array barcode representation.
    784. 

  784. 	 * @protected
    785. 

  785. 	 */
    786. 

  786. 	protected function barcode_i25($code, $checksum=false) {
    787. 

  787. 		$chr['0'] = '11221';
    788. 

  788. 		$chr['1'] = '21112';
    789. 

  789. 		$chr['2'] = '12112';
    790. 

  790. 		$chr['3'] = '22111';
    791. 

  791. 		$chr['4'] = '11212';
    792. 

  792. 		$chr['5'] = '21211';
    793. 

  793. 		$chr['6'] = '12211';
    794. 

  794. 		$chr['7'] = '11122';
    795. 

  795. 		$chr['8'] = '21121';
    796. 

  796. 		$chr['9'] = '12121';
    797. 

  797. 		$chr['A'] = '11';
    798. 

  798. 		$chr['Z'] = '21';
    799. 

  799. 		if ($checksum) {
    800. 

  800. 			// add checksum
    801. 

  801. 			$code .= $this->checksum_s25($code);
    802. 

  802. 		}
    803. 

  803. 		if((strlen($code) % 2) != 0) {
    804. 

  804. 			// add leading zero if code-length is odd
    805. 

  805. 			$code = '0'.$code;
    806. 

  806. 		}
    807. 

  807. 		// add start and stop codes
    808. 

  808. 		$code = 'AA'.strtolower($code).'ZA';
    809. 

  809. 

  810. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    811. 

  811. 		$k = 0;
    812. 

  812. 		$clen = strlen($code);
    813. 

  813. 		for ($i = 0; $i < $clen; $i = ($i + 2)) {
    814. 

  814. 			$char_bar = $code{$i};
    815. 

  815. 			$char_space = $code{$i+1};
    816. 

  816. 			if((!isset($chr[$char_bar])) OR (!isset($chr[$char_space]))) {
    817. 

  817. 				// invalid character
    818. 

  818. 				return false;
    819. 

  819. 			}
    820. 

  820. 			// create a bar-space sequence
    821. 

  821. 			$seq = '';
    822. 

  822. 			$chrlen = strlen($chr[$char_bar]);
    823. 

  823. 			for ($s = 0; $s < $chrlen; $s++){
    824. 

  824. 				$seq .= $chr[$char_bar]{$s} . $chr[$char_space]{$s};
    825. 

  825. 			}
    826. 

  826. 			$seqlen = strlen($seq);
    827. 

  827. 			for ($j = 0; $j < $seqlen; ++$j) {
    828. 

  828. 				if (($j % 2) == 0) {
    829. 

  829. 					$t = true; // bar
    830. 

  830. 				} else {
    831. 

  831. 					$t = false; // space
    832. 

  832. 				}
    833. 

  833. 				$w = $seq{$j};
    834. 

  834. 				$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
    835. 

  835. 				$bararray['maxw'] += $w;
    836. 

  836. 				++$k;
    837. 

  837. 			}
    838. 

  838. 		}
    839. 

  839. 		return $bararray;
    840. 

  840. 	}
    841. 

  841. 

  842. 	/**
    843. 

  843. 	 * C128 barcodes.
    844. 

  844. 	 * Very capable code, excellent density, high reliability; in very wide use world-wide
    845. 

  845. 	 * @param $code (string) code to represent.
    846. 

  846. 	 * @param $type (string) barcode type: A, B, C or empty for automatic switch (AUTO mode)
    847. 

  847. 	 * @return array barcode representation.
    848. 

  848. 	 * @protected
    849. 

  849. 	 */
    850. 

  850. 	protected function barcode_c128($code, $type='') {
    851. 

  851. 		$chr = array(
    852. 

  852. 			'212222', /* 00 */
    853. 

  853. 			'222122', /* 01 */
    854. 

  854. 			'222221', /* 02 */
    855. 

  855. 			'121223', /* 03 */
    856. 

  856. 			'121322', /* 04 */
    857. 

  857. 			'131222', /* 05 */
    858. 

  858. 			'122213', /* 06 */
    859. 

  859. 			'122312', /* 07 */
    860. 

  860. 			'132212', /* 08 */
    861. 

  861. 			'221213', /* 09 */
    862. 

  862. 			'221312', /* 10 */
    863. 

  863. 			'231212', /* 11 */
    864. 

  864. 			'112232', /* 12 */
    865. 

  865. 			'122132', /* 13 */
    866. 

  866. 			'122231', /* 14 */
    867. 

  867. 			'113222', /* 15 */
    868. 

  868. 			'123122', /* 16 */
    869. 

  869. 			'123221', /* 17 */
    870. 

  870. 			'223211', /* 18 */
    871. 

  871. 			'221132', /* 19 */
    872. 

  872. 			'221231', /* 20 */
    873. 

  873. 			'213212', /* 21 */
    874. 

  874. 			'223112', /* 22 */
    875. 

  875. 			'312131', /* 23 */
    876. 

  876. 			'311222', /* 24 */
    877. 

  877. 			'321122', /* 25 */
    878. 

  878. 			'321221', /* 26 */
    879. 

  879. 			'312212', /* 27 */
    880. 

  880. 			'322112', /* 28 */
    881. 

  881. 			'322211', /* 29 */
    882. 

  882. 			'212123', /* 30 */
    883. 

  883. 			'212321', /* 31 */
    884. 

  884. 			'232121', /* 32 */
    885. 

  885. 			'111323', /* 33 */
    886. 

  886. 			'131123', /* 34 */
    887. 

  887. 			'131321', /* 35 */
    888. 

  888. 			'112313', /* 36 */
    889. 

  889. 			'132113', /* 37 */
    890. 

  890. 			'132311', /* 38 */
    891. 

  891. 			'211313', /* 39 */
    892. 

  892. 			'231113', /* 40 */
    893. 

  893. 			'231311', /* 41 */
    894. 

  894. 			'112133', /* 42 */
    895. 

  895. 			'112331', /* 43 */
    896. 

  896. 			'132131', /* 44 */
    897. 

  897. 			'113123', /* 45 */
    898. 

  898. 			'113321', /* 46 */
    899. 

  899. 			'133121', /* 47 */
    900. 

  900. 			'313121', /* 48 */
    901. 

  901. 			'211331', /* 49 */
    902. 

  902. 			'231131', /* 50 */
    903. 

  903. 			'213113', /* 51 */
    904. 

  904. 			'213311', /* 52 */
    905. 

  905. 			'213131', /* 53 */
    906. 

  906. 			'311123', /* 54 */
    907. 

  907. 			'311321', /* 55 */
    908. 

  908. 			'331121', /* 56 */
    909. 

  909. 			'312113', /* 57 */
    910. 

  910. 			'312311', /* 58 */
    911. 

  911. 			'332111', /* 59 */
    912. 

  912. 			'314111', /* 60 */
    913. 

  913. 			'221411', /* 61 */
    914. 

  914. 			'431111', /* 62 */
    915. 

  915. 			'111224', /* 63 */
    916. 

  916. 			'111422', /* 64 */
    917. 

  917. 			'121124', /* 65 */
    918. 

  918. 			'121421', /* 66 */
    919. 

  919. 			'141122', /* 67 */
    920. 

  920. 			'141221', /* 68 */
    921. 

  921. 			'112214', /* 69 */
    922. 

  922. 			'112412', /* 70 */
    923. 

  923. 			'122114', /* 71 */
    924. 

  924. 			'122411', /* 72 */
    925. 

  925. 			'142112', /* 73 */
    926. 

  926. 			'142211', /* 74 */
    927. 

  927. 			'241211', /* 75 */
    928. 

  928. 			'221114', /* 76 */
    929. 

  929. 			'413111', /* 77 */
    930. 

  930. 			'241112', /* 78 */
    931. 

  931. 			'134111', /* 79 */
    932. 

  932. 			'111242', /* 80 */
    933. 

  933. 			'121142', /* 81 */
    934. 

  934. 			'121241', /* 82 */
    935. 

  935. 			'114212', /* 83 */
    936. 

  936. 			'124112', /* 84 */
    937. 

  937. 			'124211', /* 85 */
    938. 

  938. 			'411212', /* 86 */
    939. 

  939. 			'421112', /* 87 */
    940. 

  940. 			'421211', /* 88 */
    941. 

  941. 			'212141', /* 89 */
    942. 

  942. 			'214121', /* 90 */
    943. 

  943. 			'412121', /* 91 */
    944. 

  944. 			'111143', /* 92 */
    945. 

  945. 			'111341', /* 93 */
    946. 

  946. 			'131141', /* 94 */
    947. 

  947. 			'114113', /* 95 */
    948. 

  948. 			'114311', /* 96 */
    949. 

  949. 			'411113', /* 97 */
    950. 

  950. 			'411311', /* 98 */
    951. 

  951. 			'113141', /* 99 */
    952. 

  952. 			'114131', /* 100 */
    953. 

  953. 			'311141', /* 101 */
    954. 

  954. 			'411131', /* 102 */
    955. 

  955. 			'211412', /* 103 START A */
    956. 

  956. 			'211214', /* 104 START B */
    957. 

  957. 			'211232', /* 105 START C */
    958. 

  958. 			'233111', /* STOP */
    959. 

  959. 			'200000'  /* END */
    960. 

  960. 		);
    961. 

  961. 		// ASCII characters for code A (ASCII 00 - 95)
    962. 

  962. 		$keys_a = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_';
    963. 

  963. 		$keys_a .= chr(0).chr(1).chr(2).chr(3).chr(4).chr(5).chr(6).chr(7).chr(8).chr(9);
    964. 

  964. 		$keys_a .= chr(10).chr(11).chr(12).chr(13).chr(14).chr(15).chr(16).chr(17).chr(18).chr(19);
    965. 

  965. 		$keys_a .= chr(20).chr(21).chr(22).chr(23).chr(24).chr(25).chr(26).chr(27).chr(28).chr(29);
    966. 

  966. 		$keys_a .= chr(30).chr(31);
    967. 

  967. 		// ASCII characters for code B (ASCII 32 - 127)
    968. 

  968. 		$keys_b = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~'.chr(127);
    969. 

  969. 		// special codes
    970. 

  970. 		$fnc_a = array(241 => 102, 242 => 97, 243 => 96, 244 => 101);
    971. 

  971. 		$fnc_b = array(241 => 102, 242 => 97, 243 => 96, 244 => 100);
    972. 

  972. 		// array of symbols
    973. 

  973. 		$code_data = array();
    974. 

  974. 		// lenght of the code
    975. 

  975. 		$len = strlen($code);
    976. 

  976. 		switch(strtoupper($type)) {
    977. 

  977. 			case 'A': { // MODE A
    978. 

  978. 				$startid = 103;
    979. 

  979. 				for ($i = 0; $i < $len; ++$i) {
    980. 

  980. 					$char = $code{$i};
    981. 

  981. 					$char_id = ord($char);
    982. 

  982. 					if (($char_id >= 241) AND ($char_id <= 244)) {
    983. 

  983. 						$code_data[] = $fnc_a[$char_id];
    984. 

  984. 					} elseif (($char_id >= 0) AND ($char_id <= 95)) {
    985. 

  985. 						$code_data[] = strpos($keys_a, $char);
    986. 

  986. 					} else {
    987. 

  987. 						return false;
    988. 

  988. 					}
    989. 

  989. 				}
    990. 

  990. 				break;
    991. 

  991. 			}
    992. 

  992. 			case 'B': { // MODE B
    993. 

  993. 				$startid = 104;
    994. 

  994. 				for ($i = 0; $i < $len; ++$i) {
    995. 

  995. 					$char = $code{$i};
    996. 

  996. 					$char_id = ord($char);
    997. 

  997. 					if (($char_id >= 241) AND ($char_id <= 244)) {
    998. 

  998. 						$code_data[] = $fnc_b[$char_id];
    999. 

  999. 					} elseif (($char_id >= 32) AND ($char_id <= 127)) {
    1000. 

  1000. 						$code_data[] = strpos($keys_b, $char);
    1001. 

  1001. 					} else {
    1002. 

  1002. 						return false;
    1003. 

  1003. 					}
    1004. 

  1004. 				}
    1005. 

  1005. 				break;
    1006. 

  1006. 			}
    1007. 

  1007. 			case 'C': { // MODE C
    1008. 

  1008. 				$startid = 105;
    1009. 

  1009. 				if (ord($code{0}) == 241) {
    1010. 

  1010. 					$code_data[] = 102;
    1011. 

  1011. 					$code = substr($code, 1);
    1012. 

  1012. 					--$len;
    1013. 

  1013. 				}
    1014. 

  1014. 				if (($len % 2) != 0) {
    1015. 

  1015. 					// the length must be even
    1016. 

  1016. 					return false;
    1017. 

  1017. 				}
    1018. 

  1018. 				for ($i = 0; $i < $len; $i+=2) {
    1019. 

  1019. 					$chrnum = $code{$i}.$code{$i+1};
    1020. 

  1020. 					if (preg_match('/([0-9]{2})/', $chrnum) > 0) {
    1021. 

  1021. 						$code_data[] = intval($chrnum);
    1022. 

  1022. 					} else {
    1023. 

  1023. 						return false;
    1024. 

  1024. 					}
    1025. 

  1025. 				}
    1026. 

  1026. 				break;
    1027. 

  1027. 			}
    1028. 

  1028. 			default: { // MODE AUTO
    1029. 

  1029. 				// split code into sequences
    1030. 

  1030. 				$sequence = array();
    1031. 

  1031. 				// get numeric sequences (if any)
    1032. 

  1032. 				$numseq = array();
    1033. 

  1033. 				preg_match_all('/([0-9]{4,})/', $code, $numseq, PREG_OFFSET_CAPTURE);
    1034. 

  1034. 				if (isset($numseq[1]) AND !empty($numseq[1])) {
    1035. 

  1035. 					$end_offset = 0;
    1036. 

  1036. 					foreach ($numseq[1] as $val) {
    1037. 

  1037. 						$offset = $val[1];
    1038. 

  1038. 						if ($offset > $end_offset) {
    1039. 

  1039. 							// non numeric sequence
    1040. 

  1040. 							$sequence = array_merge($sequence, $this->get128ABsequence(substr($code, $end_offset, ($offset - $end_offset))));
    1041. 

  1041. 						}
    1042. 

  1042. 						// numeric sequence
    1043. 

  1043. 						$slen = strlen($val[0]);
    1044. 

  1044. 						if (($slen % 2) != 0) {
    1045. 

  1045. 							// the length must be even
    1046. 

  1046. 							--$slen;
    1047. 

  1047. 						}
    1048. 

  1048. 						$sequence[] = array('C', substr($code, $offset, $slen), $slen);
    1049. 

  1049. 						$end_offset = $offset + $slen;
    1050. 

  1050. 					}
    1051. 

  1051. 					if ($end_offset < $len) {
    1052. 

  1052. 						$sequence = array_merge($sequence, $this->get128ABsequence(substr($code, $end_offset)));
    1053. 

  1053. 					}
    1054. 

  1054. 				} else {
    1055. 

  1055. 					// text code (non C mode)
    1056. 

  1056. 					$sequence = array_merge($sequence, $this->get128ABsequence($code));
    1057. 

  1057. 				}
    1058. 

  1058. 				// process the sequence
    1059. 

  1059. 				foreach ($sequence as $key => $seq) {
    1060. 

  1060. 					switch($seq[0]) {
    1061. 

  1061. 						case 'A': {
    1062. 

  1062. 							if ($key == 0) {
    1063. 

  1063. 								$startid = 103;
    1064. 

  1064. 							} elseif ($sequence[($key - 1)][0] != 'A') {
    1065. 

  1065. 								if (($seq[2] == 1) AND ($key > 0) AND ($sequence[($key - 1)][0] == 'B') AND (!isset($sequence[($key - 1)][3]))) {
    1066. 

  1066. 									// single character shift
    1067. 

  1067. 									$code_data[] = 98;
    1068. 

  1068. 									// mark shift
    1069. 

  1069. 									$sequence[$key][3] = true;
    1070. 

  1070. 								} elseif (!isset($sequence[($key - 1)][3])) {
    1071. 

  1071. 									$code_data[] = 101;
    1072. 

  1072. 								}
    1073. 

  1073. 							}
    1074. 

  1074. 							for ($i = 0; $i < $seq[2]; ++$i) {
    1075. 

  1075. 								$char = $seq[1]{$i};
    1076. 

  1076. 								$char_id = ord($char);
    1077. 

  1077. 								if (($char_id >= 241) AND ($char_id <= 244)) {
    1078. 

  1078. 									$code_data[] = $fnc_a[$char_id];
    1079. 

  1079. 								} else {
    1080. 

  1080. 									$code_data[] = strpos($keys_a, $char);
    1081. 

  1081. 								}
    1082. 

  1082. 							}
    1083. 

  1083. 							break;
    1084. 

  1084. 						}
    1085. 

  1085. 						case 'B': {
    1086. 

  1086. 							if ($key == 0) {
    1087. 

  1087. 								$tmpchr = ord($seq[1]{0});
    1088. 

  1088. 								if (($seq[2] == 1) AND ($tmpchr >= 241) AND ($tmpchr <= 244) AND isset($sequence[($key + 1)]) AND ($sequence[($key + 1)][0] != 'B')) {
    1089. 

  1089. 									switch ($sequence[($key + 1)][0]) {
    1090. 

  1090. 										case 'A': {
    1091. 

  1091. 											$startid = 103;
    1092. 

  1092. 											$sequence[$key][0] = 'A';
    1093. 

  1093. 											$code_data[] = $fnc_a[$tmpchr];
    1094. 

  1094. 											break;
    1095. 

  1095. 										}
    1096. 

  1096. 										case 'C': {
    1097. 

  1097. 											$startid = 105;
    1098. 

  1098. 											$sequence[$key][0] = 'C';
    1099. 

  1099. 											$code_data[] = $fnc_a[$tmpchr];
    1100. 

  1100. 											break;
    1101. 

  1101. 										}
    1102. 

  1102. 									}
    1103. 

  1103. 									break;
    1104. 

  1104. 								} else {
    1105. 

  1105. 									$startid = 104;
    1106. 

  1106. 								}
    1107. 

  1107. 							} elseif ($sequence[($key - 1)][0] != 'B') {
    1108. 

  1108. 								if (($seq[2] == 1) AND ($key > 0) AND ($sequence[($key - 1)][0] == 'A') AND (!isset($sequence[($key - 1)][3]))) {
    1109. 

  1109. 									// single character shift
    1110. 

  1110. 									$code_data[] = 98;
    1111. 

  1111. 									// mark shift
    1112. 

  1112. 									$sequence[$key][3] = true;
    1113. 

  1113. 								} elseif (!isset($sequence[($key - 1)][3])) {
    1114. 

  1114. 									$code_data[] = 100;
    1115. 

  1115. 								}
    1116. 

  1116. 							}
    1117. 

  1117. 							for ($i = 0; $i < $seq[2]; ++$i) {
    1118. 

  1118. 								$char = $seq[1]{$i};
    1119. 

  1119. 								$char_id = ord($char);
    1120. 

  1120. 								if (($char_id >= 241) AND ($char_id <= 244)) {
    1121. 

  1121. 									$code_data[] = $fnc_b[$char_id];
    1122. 

  1122. 								} else {
    1123. 

  1123. 									$code_data[] = strpos($keys_b, $char);
    1124. 

  1124. 								}
    1125. 

  1125. 							}
    1126. 

  1126. 							break;
    1127. 

  1127. 						}
    1128. 

  1128. 						case 'C': {
    1129. 

  1129. 							if ($key == 0) {
    1130. 

  1130. 								$startid = 105;
    1131. 

  1131. 							} elseif ($sequence[($key - 1)][0] != 'C') {
    1132. 

  1132. 								$code_data[] = 99;
    1133. 

  1133. 							}
    1134. 

  1134. 							for ($i = 0; $i < $seq[2]; $i+=2) {
    1135. 

  1135. 								$chrnum = $seq[1]{$i}.$seq[1]{$i+1};
    1136. 

  1136. 								$code_data[] = intval($chrnum);
    1137. 

  1137. 							}
    1138. 

  1138. 							break;
    1139. 

  1139. 						}
    1140. 

  1140. 					}
    1141. 

  1141. 				}
    1142. 

  1142. 			}
    1143. 

  1143. 		}
    1144. 

  1144. 		// calculate check character
    1145. 

  1145. 		$sum = $startid;
    1146. 

  1146. 		foreach ($code_data as $key => $val) {
    1147. 

  1147. 			$sum += ($val * ($key + 1));
    1148. 

  1148. 		}
    1149. 

  1149. 		// add check character
    1150. 

  1150. 		$code_data[] = ($sum % 103);
    1151. 

  1151. 		// add stop sequence
    1152. 

  1152. 		$code_data[] = 106;
    1153. 

  1153. 		$code_data[] = 107;
    1154. 

  1154. 		// add start code at the beginning
    1155. 

  1155. 		array_unshift($code_data, $startid);
    1156. 

  1156. 		// build barcode array
    1157. 

  1157. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    1158. 

  1158. 		foreach ($code_data as $val) {
    1159. 

  1159. 			$seq = $chr[$val];
    1160. 

  1160. 			for ($j = 0; $j < 6; ++$j) {
    1161. 

  1161. 				if (($j % 2) == 0) {
    1162. 

  1162. 					$t = true; // bar
    1163. 

  1163. 				} else {
    1164. 

  1164. 					$t = false; // space
    1165. 

  1165. 				}
    1166. 

  1166. 				$w = $seq{$j};
    1167. 

  1167. 				$bararray['bcode'][] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
    1168. 

  1168. 				$bararray['maxw'] += $w;
    1169. 

  1169. 			}
    1170. 

  1170. 		}
    1171. 

  1171. 		return $bararray;
    1172. 

  1172. 	}
    1173. 

  1173. 

  1174. 	/**
    1175. 

  1175. 	 * Split text code in A/B sequence for 128 code
    1176. 

  1176. 	 * @param $code (string) code to split.
    1177. 

  1177. 	 * @return array sequence
    1178. 

  1178. 	 * @protected
    1179. 

  1179. 	 */
    1180. 

  1180. 	protected function get128ABsequence($code) {
    1181. 

  1181. 		$len = strlen($code);
    1182. 

  1182. 		$sequence = array();
    1183. 

  1183. 		// get A sequences (if any)
    1184. 

  1184. 		$numseq = array();
    1185. 

  1185. 		preg_match_all('/([\0-\31])/', $code, $numseq, PREG_OFFSET_CAPTURE);
    1186. 

  1186. 		if (isset($numseq[1]) AND !empty($numseq[1])) {
    1187. 

  1187. 			$end_offset = 0;
    1188. 

  1188. 			foreach ($numseq[1] as $val) {
    1189. 

  1189. 				$offset = $val[1];
    1190. 

  1190. 				if ($offset > $end_offset) {
    1191. 

  1191. 					// B sequence
    1192. 

  1192. 					$sequence[] = array('B', substr($code, $end_offset, ($offset - $end_offset)), ($offset - $end_offset));
    1193. 

  1193. 				}
    1194. 

  1194. 				// A sequence
    1195. 

  1195. 				$slen = strlen($val[0]);
    1196. 

  1196. 				$sequence[] = array('A', substr($code, $offset, $slen), $slen);
    1197. 

  1197. 				$end_offset = $offset + $slen;
    1198. 

  1198. 			}
    1199. 

  1199. 			if ($end_offset < $len) {
    1200. 

  1200. 				$sequence[] = array('B', substr($code, $end_offset), ($len - $end_offset));
    1201. 

  1201. 			}
    1202. 

  1202. 		} else {
    1203. 

  1203. 			// only B sequence
    1204. 

  1204. 			$sequence[] = array('B', $code, $len);
    1205. 

  1205. 		}
    1206. 

  1206. 		return $sequence;
    1207. 

  1207. 	}
    1208. 

  1208. 

  1209. 	/**
    1210. 

  1210. 	 * EAN13 and UPC-A barcodes.
    1211. 

  1211. 	 * EAN13: European Article Numbering international retail product code
    1212. 

  1212. 	 * UPC-A: Universal product code seen on almost all retail products in the USA and Canada
    1213. 

  1213. 	 * UPC-E: Short version of UPC symbol
    1214. 

  1214. 	 * @param $code (string) code to represent.
    1215. 

  1215. 	 * @param $len (string) barcode type: 6 = UPC-E, 8 = EAN8, 13 = EAN13, 12 = UPC-A
    1216. 

  1216. 	 * @return array barcode representation.
    1217. 

  1217. 	 * @protected
    1218. 

  1218. 	 */
    1219. 

  1219. 	protected function barcode_eanupc($code, $len=13) {
    1220. 

  1220. 		$upce = false;
    1221. 

  1221. 		if ($len == 6) {
    1222. 

  1222. 			$len = 12; // UPC-A
    1223. 

  1223. 			$upce = true; // UPC-E mode
    1224. 

  1224. 		}
    1225. 

  1225. 		$data_len = $len - 1;
    1226. 

  1226. 		//Padding
    1227. 

  1227. 		$code = str_pad($code, $data_len, '0', STR_PAD_LEFT);
    1228. 

  1228. 		$code_len = strlen($code);
    1229. 

  1229. 		// calculate check digit
    1230. 

  1230. 		$sum_a = 0;
    1231. 

  1231. 		for ($i = 1; $i < $data_len; $i+=2) {
    1232. 

  1232. 			$sum_a += $code{$i};
    1233. 

  1233. 		}
    1234. 

  1234. 		if ($len > 12) {
    1235. 

  1235. 			$sum_a *= 3;
    1236. 

  1236. 		}
    1237. 

  1237. 		$sum_b = 0;
    1238. 

  1238. 		for ($i = 0; $i < $data_len; $i+=2) {
    1239. 

  1239. 			$sum_b += ($code{$i});
    1240. 

  1240. 		}
    1241. 

  1241. 		if ($len < 13) {
    1242. 

  1242. 			$sum_b *= 3;
    1243. 

  1243. 		}
    1244. 

  1244. 		$r = ($sum_a + $sum_b) % 10;
    1245. 

  1245. 		if($r > 0) {
    1246. 

  1246. 			$r = (10 - $r);
    1247. 

  1247. 		}
    1248. 

  1248. 		if ($code_len == $data_len) {
    1249. 

  1249. 			// add check digit
    1250. 

  1250. 			$code .= $r;
    1251. 

  1251. 		} elseif ($r !== intval($code{$data_len})) {
    1252. 

  1252. 			// wrong checkdigit
    1253. 

  1253. 			return false;
    1254. 

  1254. 		}
    1255. 

  1255. 		if ($len == 12) {
    1256. 

  1256. 			// UPC-A
    1257. 

  1257. 			$code = '0'.$code;
    1258. 

  1258. 			++$len;
    1259. 

  1259. 		}
    1260. 

  1260. 		if ($upce) {
    1261. 

  1261. 			// convert UPC-A to UPC-E
    1262. 

  1262. 			$tmp = substr($code, 4, 3);
    1263. 

  1263. 			if (($tmp == '000') OR ($tmp == '100') OR ($tmp == '200')) {
    1264. 

  1264. 				// manufacturer code ends in 000, 100, or 200
    1265. 

  1265. 				$upce_code = substr($code, 2, 2).substr($code, 9, 3).substr($code, 4, 1);
    1266. 

  1266. 			} else {
    1267. 

  1267. 				$tmp = substr($code, 5, 2);
    1268. 

  1268. 				if ($tmp == '00') {
    1269. 

  1269. 					// manufacturer code ends in 00
    1270. 

  1270. 					$upce_code = substr($code, 2, 3).substr($code, 10, 2).'3';
    1271. 

  1271. 				} else {
    1272. 

  1272. 					$tmp = substr($code, 6, 1);
    1273. 

  1273. 					if ($tmp == '0') {
    1274. 

  1274. 						// manufacturer code ends in 0
    1275. 

  1275. 						$upce_code = substr($code, 2, 4).substr($code, 11, 1).'4';
    1276. 

  1276. 					} else {
    1277. 

  1277. 						// manufacturer code does not end in zero
    1278. 

  1278. 						$upce_code = substr($code, 2, 5).substr($code, 11, 1);
    1279. 

  1279. 					}
    1280. 

  1280. 				}
    1281. 

  1281. 			}
    1282. 

  1282. 		}
    1283. 

  1283. 		//Convert digits to bars
    1284. 

  1284. 		$codes = array(
    1285. 

  1285. 			'A'=>array( // left odd parity
    1286. 

  1286. 				'0'=>'0001101',
    1287. 

  1287. 				'1'=>'0011001',
    1288. 

  1288. 				'2'=>'0010011',
    1289. 

  1289. 				'3'=>'0111101',
    1290. 

  1290. 				'4'=>'0100011',
    1291. 

  1291. 				'5'=>'0110001',
    1292. 

  1292. 				'6'=>'0101111',
    1293. 

  1293. 				'7'=>'0111011',
    1294. 

  1294. 				'8'=>'0110111',
    1295. 

  1295. 				'9'=>'0001011'),
    1296. 

  1296. 			'B'=>array( // left even parity
    1297. 

  1297. 				'0'=>'0100111',
    1298. 

  1298. 				'1'=>'0110011',
    1299. 

  1299. 				'2'=>'0011011',
    1300. 

  1300. 				'3'=>'0100001',
    1301. 

  1301. 				'4'=>'0011101',
    1302. 

  1302. 				'5'=>'0111001',
    1303. 

  1303. 				'6'=>'0000101',
    1304. 

  1304. 				'7'=>'0010001',
    1305. 

  1305. 				'8'=>'0001001',
    1306. 

  1306. 				'9'=>'0010111'),
    1307. 

  1307. 			'C'=>array( // right
    1308. 

  1308. 				'0'=>'1110010',
    1309. 

  1309. 				'1'=>'1100110',
    1310. 

  1310. 				'2'=>'1101100',
    1311. 

  1311. 				'3'=>'1000010',
    1312. 

  1312. 				'4'=>'1011100',
    1313. 

  1313. 				'5'=>'1001110',
    1314. 

  1314. 				'6'=>'1010000',
    1315. 

  1315. 				'7'=>'1000100',
    1316. 

  1316. 				'8'=>'1001000',
    1317. 

  1317. 				'9'=>'1110100')
    1318. 

  1318. 		);
    1319. 

  1319. 		$parities = array(
    1320. 

  1320. 			'0'=>array('A','A','A','A','A','A'),
    1321. 

  1321. 			'1'=>array('A','A','B','A','B','B'),
    1322. 

  1322. 			'2'=>array('A','A','B','B','A','B'),
    1323. 

  1323. 			'3'=>array('A','A','B','B','B','A'),
    1324. 

  1324. 			'4'=>array('A','B','A','A','B','B'),
    1325. 

  1325. 			'5'=>array('A','B','B','A','A','B'),
    1326. 

  1326. 			'6'=>array('A','B','B','B','A','A'),
    1327. 

  1327. 			'7'=>array('A','B','A','B','A','B'),
    1328. 

  1328. 			'8'=>array('A','B','A','B','B','A'),
    1329. 

  1329. 			'9'=>array('A','B','B','A','B','A')
    1330. 

  1330. 		);
    1331. 

  1331. 		$upce_parities = array();
    1332. 

  1332. 		$upce_parities[0] = array(
    1333. 

  1333. 			'0'=>array('B','B','B','A','A','A'),
    1334. 

  1334. 			'1'=>array('B','B','A','B','A','A'),
    1335. 

  1335. 			'2'=>array('B','B','A','A','B','A'),
    1336. 

  1336. 			'3'=>array('B','B','A','A','A','B'),
    1337. 

  1337. 			'4'=>array('B','A','B','B','A','A'),
    1338. 

  1338. 			'5'=>array('B','A','A','B','B','A'),
    1339. 

  1339. 			'6'=>array('B','A','A','A','B','B'),
    1340. 

  1340. 			'7'=>array('B','A','B','A','B','A'),
    1341. 

  1341. 			'8'=>array('B','A','B','A','A','B'),
    1342. 

  1342. 			'9'=>array('B','A','A','B','A','B')
    1343. 

  1343. 		);
    1344. 

  1344. 		$upce_parities[1] = array(
    1345. 

  1345. 			'0'=>array('A','A','A','B','B','B'),
    1346. 

  1346. 			'1'=>array('A','A','B','A','B','B'),
    1347. 

  1347. 			'2'=>array('A','A','B','B','A','B'),
    1348. 

  1348. 			'3'=>array('A','A','B','B','B','A'),
    1349. 

  1349. 			'4'=>array('A','B','A','A','B','B'),
    1350. 

  1350. 			'5'=>array('A','B','B','A','A','B'),
    1351. 

  1351. 			'6'=>array('A','B','B','B','A','A'),
    1352. 

  1352. 			'7'=>array('A','B','A','B','A','B'),
    1353. 

  1353. 			'8'=>array('A','B','A','B','B','A'),
    1354. 

  1354. 			'9'=>array('A','B','B','A','B','A')
    1355. 

  1355. 		);
    1356. 

  1356. 		$k = 0;
    1357. 

  1357. 		$seq = '101'; // left guard bar
    1358. 

  1358. 		if ($upce) {
    1359. 

  1359. 			$bararray = array('code' => $upce_code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    1360. 

  1360. 			$p = $upce_parities[$code{1}][$r];
    1361. 

  1361. 			for ($i = 0; $i < 6; ++$i) {
    1362. 

  1362. 				$seq .= $codes[$p[$i]][$upce_code{$i}];
    1363. 

  1363. 			}
    1364. 

  1364. 			$seq .= '010101'; // right guard bar
    1365. 

  1365. 		} else {
    1366. 

  1366. 			$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    1367. 

  1367. 			$half_len = ceil($len / 2);
    1368. 

  1368. 			if ($len == 8) {
    1369. 

  1369. 				for ($i = 0; $i < $half_len; ++$i) {
    1370. 

  1370. 					$seq .= $codes['A'][$code{$i}];
    1371. 

  1371. 				}
    1372. 

  1372. 			} else {
    1373. 

  1373. 				$p = $parities[$code{0}];
    1374. 

  1374. 				for ($i = 1; $i < $half_len; ++$i) {
    1375. 

  1375. 					$seq .= $codes[$p[$i-1]][$code{$i}];
    1376. 

  1376. 				}
    1377. 

  1377. 			}
    1378. 

  1378. 			$seq .= '01010'; // center guard bar
    1379. 

  1379. 			for ($i = $half_len; $i < $len; ++$i) {
    1380. 

  1380. 				$seq .= $codes['C'][$code{$i}];
    1381. 

  1381. 			}
    1382. 

  1382. 			$seq .= '101'; // right guard bar
    1383. 

  1383. 		}
    1384. 

  1384. 		$clen = strlen($seq);
    1385. 

  1385. 		$w = 0;
    1386. 

  1386. 		for ($i = 0; $i < $clen; ++$i) {
    1387. 

  1387. 			$w += 1;
    1388. 

  1388. 			if (($i == ($clen - 1)) OR (($i < ($clen - 1)) AND ($seq{$i} != $seq{($i+1)}))) {
    1389. 

  1389. 				if ($seq{$i} == '1') {
    1390. 

  1390. 					$t = true; // bar
    1391. 

  1391. 				} else {
    1392. 

  1392. 					$t = false; // space
    1393. 

  1393. 				}
    1394. 

  1394. 				$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
    1395. 

  1395. 				$bararray['maxw'] += $w;
    1396. 

  1396. 				++$k;
    1397. 

  1397. 				$w = 0;
    1398. 

  1398. 			}
    1399. 

  1399. 		}
    1400. 

  1400. 		return $bararray;
    1401. 

  1401. 	}
    1402. 

  1402. 

  1403. 	/**
    1404. 

  1404. 	 * UPC-Based Extentions
    1405. 

  1405. 	 * 2-Digit Ext.: Used to indicate magazines and newspaper issue numbers
    1406. 

  1406. 	 * 5-Digit Ext.: Used to mark suggested retail price of books
    1407. 

  1407. 	 * @param $code (string) code to represent.
    1408. 

  1408. 	 * @param $len (string) barcode type: 2 = 2-Digit, 5 = 5-Digit
    1409. 

  1409. 	 * @return array barcode representation.
    1410. 

  1410. 	 * @protected
    1411. 

  1411. 	 */
    1412. 

  1412. 	protected function barcode_eanext($code, $len=5) {
    1413. 

  1413. 		//Padding
    1414. 

  1414. 		$code = str_pad($code, $len, '0', STR_PAD_LEFT);
    1415. 

  1415. 		// calculate check digit
    1416. 

  1416. 		if ($len == 2) {
    1417. 

  1417. 			$r = $code % 4;
    1418. 

  1418. 		} elseif ($len == 5) {
    1419. 

  1419. 			$r = (3 * ($code{0} + $code{2} + $code{4})) + (9 * ($code{1} + $code{3}));
    1420. 

  1420. 			$r %= 10;
    1421. 

  1421. 		} else {
    1422. 

  1422. 			return false;
    1423. 

  1423. 		}
    1424. 

  1424. 		//Convert digits to bars
    1425. 

  1425. 		$codes = array(
    1426. 

  1426. 			'A'=>array( // left odd parity
    1427. 

  1427. 				'0'=>'0001101',
    1428. 

  1428. 				'1'=>'0011001',
    1429. 

  1429. 				'2'=>'0010011',
    1430. 

  1430. 				'3'=>'0111101',
    1431. 

  1431. 				'4'=>'0100011',
    1432. 

  1432. 				'5'=>'0110001',
    1433. 

  1433. 				'6'=>'0101111',
    1434. 

  1434. 				'7'=>'0111011',
    1435. 

  1435. 				'8'=>'0110111',
    1436. 

  1436. 				'9'=>'0001011'),
    1437. 

  1437. 			'B'=>array( // left even parity
    1438. 

  1438. 				'0'=>'0100111',
    1439. 

  1439. 				'1'=>'0110011',
    1440. 

  1440. 				'2'=>'0011011',
    1441. 

  1441. 				'3'=>'0100001',
    1442. 

  1442. 				'4'=>'0011101',
    1443. 

  1443. 				'5'=>'0111001',
    1444. 

  1444. 				'6'=>'0000101',
    1445. 

  1445. 				'7'=>'0010001',
    1446. 

  1446. 				'8'=>'0001001',
    1447. 

  1447. 				'9'=>'0010111')
    1448. 

  1448. 		);
    1449. 

  1449. 		$parities = array();
    1450. 

  1450. 		$parities[2] = array(
    1451. 

  1451. 			'0'=>array('A','A'),
    1452. 

  1452. 			'1'=>array('A','B'),
    1453. 

  1453. 			'2'=>array('B','A'),
    1454. 

  1454. 			'3'=>array('B','B')
    1455. 

  1455. 		);
    1456. 

  1456. 		$parities[5] = array(
    1457. 

  1457. 			'0'=>array('B','B','A','A','A'),
    1458. 

  1458. 			'1'=>array('B','A','B','A','A'),
    1459. 

  1459. 			'2'=>array('B','A','A','B','A'),
    1460. 

  1460. 			'3'=>array('B','A','A','A','B'),
    1461. 

  1461. 			'4'=>array('A','B','B','A','A'),
    1462. 

  1462. 			'5'=>array('A','A','B','B','A'),
    1463. 

  1463. 			'6'=>array('A','A','A','B','B'),
    1464. 

  1464. 			'7'=>array('A','B','A','B','A'),
    1465. 

  1465. 			'8'=>array('A','B','A','A','B'),
    1466. 

  1466. 			'9'=>array('A','A','B','A','B')
    1467. 

  1467. 		);
    1468. 

  1468. 		$p = $parities[$len][$r];
    1469. 

  1469. 		$seq = '1011'; // left guard bar
    1470. 

  1470. 		$seq .= $codes[$p[0]][$code{0}];
    1471. 

  1471. 		for ($i = 1; $i < $len; ++$i) {
    1472. 

  1472. 			$seq .= '01'; // separator
    1473. 

  1473. 			$seq .= $codes[$p[$i]][$code{$i}];
    1474. 

  1474. 		}
    1475. 

  1475. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    1476. 

  1476. 		return $this->binseq_to_array($seq, $bararray);
    1477. 

  1477. 	}
    1478. 

  1478. 

  1479. 	/**
    1480. 

  1480. 	 * POSTNET and PLANET barcodes.
    1481. 

  1481. 	 * Used by U.S. Postal Service for automated mail sorting
    1482. 

  1482. 	 * @param $code (string) zip code to represent. Must be a string containing a zip code of the form DDDDD or DDDDD-DDDD.
    1483. 

  1483. 	 * @param $planet (boolean) if true print the PLANET barcode, otherwise print POSTNET
    1484. 

  1484. 	 * @return array barcode representation.
    1485. 

  1485. 	 * @protected
    1486. 

  1486. 	 */
    1487. 

  1487. 	protected function barcode_postnet($code, $planet=false) {
    1488. 

  1488. 		// bar lenght
    1489. 

  1489. 		if ($planet) {
    1490. 

  1490. 			$barlen = Array(
    1491. 

  1491. 				0 => Array(1,1,2,2,2),
    1492. 

  1492. 				1 => Array(2,2,2,1,1),
    1493. 

  1493. 				2 => Array(2,2,1,2,1),
    1494. 

  1494. 				3 => Array(2,2,1,1,2),
    1495. 

  1495. 				4 => Array(2,1,2,2,1),
    1496. 

  1496. 				5 => Array(2,1,2,1,2),
    1497. 

  1497. 				6 => Array(2,1,1,2,2),
    1498. 

  1498. 				7 => Array(1,2,2,2,1),
    1499. 

  1499. 				8 => Array(1,2,2,1,2),
    1500. 

  1500. 				9 => Array(1,2,1,2,2)
    1501. 

  1501. 			);
    1502. 

  1502. 		} else {
    1503. 

  1503. 			$barlen = Array(
    1504. 

  1504. 				0 => Array(2,2,1,1,1),
    1505. 

  1505. 				1 => Array(1,1,1,2,2),
    1506. 

  1506. 				2 => Array(1,1,2,1,2),
    1507. 

  1507. 				3 => Array(1,1,2,2,1),
    1508. 

  1508. 				4 => Array(1,2,1,1,2),
    1509. 

  1509. 				5 => Array(1,2,1,2,1),
    1510. 

  1510. 				6 => Array(1,2,2,1,1),
    1511. 

  1511. 				7 => Array(2,1,1,1,2),
    1512. 

  1512. 				8 => Array(2,1,1,2,1),
    1513. 

  1513. 				9 => Array(2,1,2,1,1)
    1514. 

  1514. 			);
    1515. 

  1515. 		}
    1516. 

  1516. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 2, 'bcode' => array());
    1517. 

  1517. 		$k = 0;
    1518. 

  1518. 		$code = str_replace('-', '', $code);
    1519. 

  1519. 		$code = str_replace(' ', '', $code);
    1520. 

  1520. 		$len = strlen($code);
    1521. 

  1521. 		// calculate checksum
    1522. 

  1522. 		$sum = 0;
    1523. 

  1523. 		for ($i = 0; $i < $len; ++$i) {
    1524. 

  1524. 			$sum += intval($code{$i});
    1525. 

  1525. 		}
    1526. 

  1526. 		$chkd = ($sum % 10);
    1527. 

  1527. 		if($chkd > 0) {
    1528. 

  1528. 			$chkd = (10 - $chkd);
    1529. 

  1529. 		}
    1530. 

  1530. 		$code .= $chkd;
    1531. 

  1531. 		$len = strlen($code);
    1532. 

  1532. 		// start bar
    1533. 

  1533. 		$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => 2, 'p' => 0);
    1534. 

  1534. 		$bararray['bcode'][$k++] = array('t' => 0, 'w' => 1, 'h' => 2, 'p' => 0);
    1535. 

  1535. 		$bararray['maxw'] += 2;
    1536. 

  1536. 		for ($i = 0; $i < $len; ++$i) {
    1537. 

  1537. 			for ($j = 0; $j < 5; ++$j) {
    1538. 

  1538. 				$h = $barlen[$code{$i}][$j];
    1539. 

  1539. 				$p = floor(1 / $h);
    1540. 

  1540. 				$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => $h, 'p' => $p);
    1541. 

  1541. 				$bararray['bcode'][$k++] = array('t' => 0, 'w' => 1, 'h' => 2, 'p' => 0);
    1542. 

  1542. 				$bararray['maxw'] += 2;
    1543. 

  1543. 			}
    1544. 

  1544. 		}
    1545. 

  1545. 		// end bar
    1546. 

  1546. 		$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => 2, 'p' => 0);
    1547. 

  1547. 		$bararray['maxw'] += 1;
    1548. 

  1548. 		return $bararray;
    1549. 

  1549. 	}
    1550. 

  1550. 

  1551. 	/**
    1552. 

  1552. 	 * RMS4CC - CBC - KIX
    1553. 

  1553. 	 * RMS4CC (Royal Mail 4-state Customer Code) - CBC (Customer Bar Code) - KIX (Klant index - Customer index)
    1554. 

  1554. 	 * RM4SCC is the name of the barcode symbology used by the Royal Mail for its Cleanmail service.
    1555. 

  1555. 	 * @param $code (string) code to print
    1556. 

  1556. 	 * @param $kix (boolean) if true prints the KIX variation (doesn't use the start and end symbols, and the checksum) - in this case the house number must be sufficed with an X and placed at the end of the code.
    1557. 

  1557. 	 * @return array barcode representation.
    1558. 

  1558. 	 * @protected
    1559. 

  1559. 	 */
    1560. 

  1560. 	protected function barcode_rms4cc($code, $kix=false) {
    1561. 

  1561. 		$notkix = !$kix;
    1562. 

  1562. 		// bar mode
    1563. 

  1563. 		// 1 = pos 1, length 2
    1564. 

  1564. 		// 2 = pos 1, length 3
    1565. 

  1565. 		// 3 = pos 2, length 1
    1566. 

  1566. 		// 4 = pos 2, length 2
    1567. 

  1567. 		$barmode = array(
    1568. 

  1568. 			'0' => array(3,3,2,2),
    1569. 

  1569. 			'1' => array(3,4,1,2),
    1570. 

  1570. 			'2' => array(3,4,2,1),
    1571. 

  1571. 			'3' => array(4,3,1,2),
    1572. 

  1572. 			'4' => array(4,3,2,1),
    1573. 

  1573. 			'5' => array(4,4,1,1),
    1574. 

  1574. 			'6' => array(3,1,4,2),
    1575. 

  1575. 			'7' => array(3,2,3,2),
    1576. 

  1576. 			'8' => array(3,2,4,1),
    1577. 

  1577. 			'9' => array(4,1,3,2),
    1578. 

  1578. 			'A' => array(4,1,4,1),
    1579. 

  1579. 			'B' => array(4,2,3,1),
    1580. 

  1580. 			'C' => array(3,1,2,4),
    1581. 

  1581. 			'D' => array(3,2,1,4),
    1582. 

  1582. 			'E' => array(3,2,2,3),
    1583. 

  1583. 			'F' => array(4,1,1,4),
    1584. 

  1584. 			'G' => array(4,1,2,3),
    1585. 

  1585. 			'H' => array(4,2,1,3),
    1586. 

  1586. 			'I' => array(1,3,4,2),
    1587. 

  1587. 			'J' => array(1,4,3,2),
    1588. 

  1588. 			'K' => array(1,4,4,1),
    1589. 

  1589. 			'L' => array(2,3,3,2),
    1590. 

  1590. 			'M' => array(2,3,4,1),
    1591. 

  1591. 			'N' => array(2,4,3,1),
    1592. 

  1592. 			'O' => array(1,3,2,4),
    1593. 

  1593. 			'P' => array(1,4,1,4),
    1594. 

  1594. 			'Q' => array(1,4,2,3),
    1595. 

  1595. 			'R' => array(2,3,1,4),
    1596. 

  1596. 			'S' => array(2,3,2,3),
    1597. 

  1597. 			'T' => array(2,4,1,3),
    1598. 

  1598. 			'U' => array(1,1,4,4),
    1599. 

  1599. 			'V' => array(1,2,3,4),
    1600. 

  1600. 			'W' => array(1,2,4,3),
    1601. 

  1601. 			'X' => array(2,1,3,4),
    1602. 

  1602. 			'Y' => array(2,1,4,3),
    1603. 

  1603. 			'Z' => array(2,2,3,3)
    1604. 

  1604. 		);
    1605. 

  1605. 		$code = strtoupper($code);
    1606. 

  1606. 		$len = strlen($code);
    1607. 

  1607. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 3, 'bcode' => array());
    1608. 

  1608. 		if ($notkix) {
    1609. 

  1609. 			// table for checksum calculation (row,col)
    1610. 

  1610. 			$checktable = array(
    1611. 

  1611. 				'0' => array(1,1),
    1612. 

  1612. 				'1' => array(1,2),
    1613. 

  1613. 				'2' => array(1,3),
    1614. 

  1614. 				'3' => array(1,4),
    1615. 

  1615. 				'4' => array(1,5),
    1616. 

  1616. 				'5' => array(1,0),
    1617. 

  1617. 				'6' => array(2,1),
    1618. 

  1618. 				'7' => array(2,2),
    1619. 

  1619. 				'8' => array(2,3),
    1620. 

  1620. 				'9' => array(2,4),
    1621. 

  1621. 				'A' => array(2,5),
    1622. 

  1622. 				'B' => array(2,0),
    1623. 

  1623. 				'C' => array(3,1),
    1624. 

  1624. 				'D' => array(3,2),
    1625. 

  1625. 				'E' => array(3,3),
    1626. 

  1626. 				'F' => array(3,4),
    1627. 

  1627. 				'G' => array(3,5),
    1628. 

  1628. 				'H' => array(3,0),
    1629. 

  1629. 				'I' => array(4,1),
    1630. 

  1630. 				'J' => array(4,2),
    1631. 

  1631. 				'K' => array(4,3),
    1632. 

  1632. 				'L' => array(4,4),
    1633. 

  1633. 				'M' => array(4,5),
    1634. 

  1634. 				'N' => array(4,0),
    1635. 

  1635. 				'O' => array(5,1),
    1636. 

  1636. 				'P' => array(5,2),
    1637. 

  1637. 				'Q' => array(5,3),
    1638. 

  1638. 				'R' => array(5,4),
    1639. 

  1639. 				'S' => array(5,5),
    1640. 

  1640. 				'T' => array(5,0),
    1641. 

  1641. 				'U' => array(0,1),
    1642. 

  1642. 				'V' => array(0,2),
    1643. 

  1643. 				'W' => array(0,3),
    1644. 

  1644. 				'X' => array(0,4),
    1645. 

  1645. 				'Y' => array(0,5),
    1646. 

  1646. 				'Z' => array(0,0)
    1647. 

  1647. 			);
    1648. 

  1648. 			$row = 0;
    1649. 

  1649. 			$col = 0;
    1650. 

  1650. 			for ($i = 0; $i < $len; ++$i) {
    1651. 

  1651. 				$row += $checktable[$code{$i}][0];
    1652. 

  1652. 				$col += $checktable[$code{$i}][1];
    1653. 

  1653. 			}
    1654. 

  1654. 			$row %= 6;
    1655. 

  1655. 			$col %= 6;
    1656. 

  1656. 			$chk = array_keys($checktable, array($row,$col));
    1657. 

  1657. 			$code .= $chk[0];
    1658. 

  1658. 			++$len;
    1659. 

  1659. 		}
    1660. 

  1660. 		$k = 0;
    1661. 

  1661. 		if ($notkix) {
    1662. 

  1662. 			// start bar
    1663. 

  1663. 			$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => 2, 'p' => 0);
    1664. 

  1664. 			$bararray['bcode'][$k++] = array('t' => 0, 'w' => 1, 'h' => 2, 'p' => 0);
    1665. 

  1665. 			$bararray['maxw'] += 2;
    1666. 

  1666. 		}
    1667. 

  1667. 		for ($i = 0; $i < $len; ++$i) {
    1668. 

  1668. 			for ($j = 0; $j < 4; ++$j) {
    1669. 

  1669. 				switch ($barmode[$code{$i}][$j]) {
    1670. 

  1670. 					case 1: {
    1671. 

  1671. 						$p = 0;
    1672. 

  1672. 						$h = 2;
    1673. 

  1673. 						break;
    1674. 

  1674. 					}
    1675. 

  1675. 					case 2: {
    1676. 

  1676. 						$p = 0;
    1677. 

  1677. 						$h = 3;
    1678. 

  1678. 						break;
    1679. 

  1679. 					}
    1680. 

  1680. 					case 3: {
    1681. 

  1681. 						$p = 1;
    1682. 

  1682. 						$h = 1;
    1683. 

  1683. 						break;
    1684. 

  1684. 					}
    1685. 

  1685. 					case 4: {
    1686. 

  1686. 						$p = 1;
    1687. 

  1687. 						$h = 2;
    1688. 

  1688. 						break;
    1689. 

  1689. 					}
    1690. 

  1690. 				}
    1691. 

  1691. 				$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => $h, 'p' => $p);
    1692. 

  1692. 				$bararray['bcode'][$k++] = array('t' => 0, 'w' => 1, 'h' => 2, 'p' => 0);
    1693. 

  1693. 				$bararray['maxw'] += 2;
    1694. 

  1694. 			}
    1695. 

  1695. 		}
    1696. 

  1696. 		if ($notkix) {
    1697. 

  1697. 			// stop bar
    1698. 

  1698. 			$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => 3, 'p' => 0);
    1699. 

  1699. 			$bararray['maxw'] += 1;
    1700. 

  1700. 		}
    1701. 

  1701. 		return $bararray;
    1702. 

  1702. 	}
    1703. 

  1703. 

  1704. 	/**
    1705. 

  1705. 	 * CODABAR barcodes.
    1706. 

  1706. 	 * Older code often used in library systems, sometimes in blood banks
    1707. 

  1707. 	 * @param $code (string) code to represent.
    1708. 

  1708. 	 * @return array barcode representation.
    1709. 

  1709. 	 * @protected
    1710. 

  1710. 	 */
    1711. 

  1711. 	protected function barcode_codabar($code) {
    1712. 

  1712. 		$chr = array(
    1713. 

  1713. 			'0' => '11111221',
    1714. 

  1714. 			'1' => '11112211',
    1715. 

  1715. 			'2' => '11121121',
    1716. 

  1716. 			'3' => '22111111',
    1717. 

  1717. 			'4' => '11211211',
    1718. 

  1718. 			'5' => '21111211',
    1719. 

  1719. 			'6' => '12111121',
    1720. 

  1720. 			'7' => '12112111',
    1721. 

  1721. 			'8' => '12211111',
    1722. 

  1722. 			'9' => '21121111',
    1723. 

  1723. 			'-' => '11122111',
    1724. 

  1724. 			'$' => '11221111',
    1725. 

  1725. 			':' => '21112121',
    1726. 

  1726. 			'/' => '21211121',
    1727. 

  1727. 			'.' => '21212111',
    1728. 

  1728. 			'+' => '11222221',
    1729. 

  1729. 			'A' => '11221211',
    1730. 

  1730. 			'B' => '12121121',
    1731. 

  1731. 			'C' => '11121221',
    1732. 

  1732. 			'D' => '11122211'
    1733. 

  1733. 		);
    1734. 

  1734. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    1735. 

  1735. 		$k = 0;
    1736. 

  1736. 		$w = 0;
    1737. 

  1737. 		$seq = '';
    1738. 

  1738. 		$code = 'A'.strtoupper($code).'A';
    1739. 

  1739. 		$len = strlen($code);
    1740. 

  1740. 		for ($i = 0; $i < $len; ++$i) {
    1741. 

  1741. 			if (!isset($chr[$code{$i}])) {
    1742. 

  1742. 				return false;
    1743. 

  1743. 			}
    1744. 

  1744. 			$seq = $chr[$code{$i}];
    1745. 

  1745. 			for ($j = 0; $j < 8; ++$j) {
    1746. 

  1746. 				if (($j % 2) == 0) {
    1747. 

  1747. 					$t = true; // bar
    1748. 

  1748. 				} else {
    1749. 

  1749. 					$t = false; // space
    1750. 

  1750. 				}
    1751. 

  1751. 				$w = $seq{$j};
    1752. 

  1752. 				$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
    1753. 

  1753. 				$bararray['maxw'] += $w;
    1754. 

  1754. 				++$k;
    1755. 

  1755. 			}
    1756. 

  1756. 		}
    1757. 

  1757. 		return $bararray;
    1758. 

  1758. 	}
    1759. 

  1759. 

  1760. 	/**
    1761. 

  1761. 	 * CODE11 barcodes.
    1762. 

  1762. 	 * Used primarily for labeling telecommunications equipment
    1763. 

  1763. 	 * @param $code (string) code to represent.
    1764. 

  1764. 	 * @return array barcode representation.
    1765. 

  1765. 	 * @protected
    1766. 

  1766. 	 */
    1767. 

  1767. 	protected function barcode_code11($code) {
    1768. 

  1768. 		$chr = array(
    1769. 

  1769. 			'0' => '111121',
    1770. 

  1770. 			'1' => '211121',
    1771. 

  1771. 			'2' => '121121',
    1772. 

  1772. 			'3' => '221111',
    1773. 

  1773. 			'4' => '112121',
    1774. 

  1774. 			'5' => '212111',
    1775. 

  1775. 			'6' => '122111',
    1776. 

  1776. 			'7' => '111221',
    1777. 

  1777. 			'8' => '211211',
    1778. 

  1778. 			'9' => '211111',
    1779. 

  1779. 			'-' => '112111',
    1780. 

  1780. 			'S' => '112211'
    1781. 

  1781. 		);
    1782. 

  1782. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    1783. 

  1783. 		$k = 0;
    1784. 

  1784. 		$w = 0;
    1785. 

  1785. 		$seq = '';
    1786. 

  1786. 		$len = strlen($code);
    1787. 

  1787. 		// calculate check digit C
    1788. 

  1788. 		$p = 1;
    1789. 

  1789. 		$check = 0;
    1790. 

  1790. 		for ($i = ($len - 1); $i >= 0; --$i) {
    1791. 

  1791. 			$digit = $code{$i};
    1792. 

  1792. 			if ($digit == '-') {
    1793. 

  1793. 				$dval = 10;
    1794. 

  1794. 			} else {
    1795. 

  1795. 				$dval = intval($digit);
    1796. 

  1796. 			}
    1797. 

  1797. 			$check += ($dval * $p);
    1798. 

  1798. 			++$p;
    1799. 

  1799. 			if ($p > 10) {
    1800. 

  1800. 				$p = 1;
    1801. 

  1801. 			}
    1802. 

  1802. 		}
    1803. 

  1803. 		$check %= 11;
    1804. 

  1804. 		if ($check == 10) {
    1805. 

  1805. 			$check = '-';
    1806. 

  1806. 		}
    1807. 

  1807. 		$code .= $check;
    1808. 

  1808. 		if ($len > 10) {
    1809. 

  1809. 			// calculate check digit K
    1810. 

  1810. 			$p = 1;
    1811. 

  1811. 			$check = 0;
    1812. 

  1812. 			for ($i = $len; $i >= 0; --$i) {
    1813. 

  1813. 				$digit = $code{$i};
    1814. 

  1814. 				if ($digit == '-') {
    1815. 

  1815. 					$dval = 10;
    1816. 

  1816. 				} else {
    1817. 

  1817. 					$dval = intval($digit);
    1818. 

  1818. 				}
    1819. 

  1819. 				$check += ($dval * $p);
    1820. 

  1820. 				++$p;
    1821. 

  1821. 				if ($p > 9) {
    1822. 

  1822. 					$p = 1;
    1823. 

  1823. 				}
    1824. 

  1824. 			}
    1825. 

  1825. 			$check %= 11;
    1826. 

  1826. 			$code .= $check;
    1827. 

  1827. 			++$len;
    1828. 

  1828. 		}
    1829. 

  1829. 		$code = 'S'.$code.'S';
    1830. 

  1830. 		$len += 3;
    1831. 

  1831. 		for ($i = 0; $i < $len; ++$i) {
    1832. 

  1832. 			if (!isset($chr[$code{$i}])) {
    1833. 

  1833. 				return false;
    1834. 

  1834. 			}
    1835. 

  1835. 			$seq = $chr[$code{$i}];
    1836. 

  1836. 			for ($j = 0; $j < 6; ++$j) {
    1837. 

  1837. 				if (($j % 2) == 0) {
    1838. 

  1838. 					$t = true; // bar
    1839. 

  1839. 				} else {
    1840. 

  1840. 					$t = false; // space
    1841. 

  1841. 				}
    1842. 

  1842. 				$w = $seq{$j};
    1843. 

  1843. 				$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
    1844. 

  1844. 				$bararray['maxw'] += $w;
    1845. 

  1845. 				++$k;
    1846. 

  1846. 			}
    1847. 

  1847. 		}
    1848. 

  1848. 		return $bararray;
    1849. 

  1849. 	}
    1850. 

  1850. 

  1851. 	/**
    1852. 

  1852. 	 * Pharmacode
    1853. 

  1853. 	 * Contains digits (0 to 9)
    1854. 

  1854. 	 * @param $code (string) code to represent.
    1855. 

  1855. 	 * @return array barcode representation.
    1856. 

  1856. 	 * @protected
    1857. 

  1857. 	 */
    1858. 

  1858. 	protected function barcode_pharmacode($code) {
    1859. 

  1859. 		$seq = '';
    1860. 

  1860. 		$code = intval($code);
    1861. 

  1861. 		while ($code > 0) {
    1862. 

  1862. 			if (($code % 2) == 0) {
    1863. 

  1863. 				$seq .= '11100';
    1864. 

  1864. 				$code -= 2;
    1865. 

  1865. 			} else {
    1866. 

  1866. 				$seq .= '100';
    1867. 

  1867. 				$code -= 1;
    1868. 

  1868. 			}
    1869. 

  1869. 			$code /= 2;
    1870. 

  1870. 		}
    1871. 

  1871. 		$seq = substr($seq, 0, -2);
    1872. 

  1872. 		$seq = strrev($seq);
    1873. 

  1873. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
    1874. 

  1874. 		return $this->binseq_to_array($seq, $bararray);
    1875. 

  1875. 	}
    1876. 

  1876. 

  1877. 	/**
    1878. 

  1878. 	 * Pharmacode two-track
    1879. 

  1879. 	 * Contains digits (0 to 9)
    1880. 

  1880. 	 * @param $code (string) code to represent.
    1881. 

  1881. 	 * @return array barcode representation.
    1882. 

  1882. 	 * @protected
    1883. 

  1883. 	 */
    1884. 

  1884. 	protected function barcode_pharmacode2t($code) {
    1885. 

  1885. 		$seq = '';
    1886. 

  1886. 		$code = intval($code);
    1887. 

  1887. 		do {
    1888. 

  1888. 			switch ($code % 3) {
    1889. 

  1889. 				case 0: {
    1890. 

  1890. 					$seq .= '3';
    1891. 

  1891. 					$code = ($code - 3) / 3;
    1892. 

  1892. 					break;
    1893. 

  1893. 				}
    1894. 

  1894. 				case 1: {
    1895. 

  1895. 					$seq .= '1';
    1896. 

  1896. 					$code = ($code - 1) / 3;
    1897. 

  1897. 					break;
    1898. 

  1898. 				}
    1899. 

  1899. 				case 2: {
    1900. 

  1900. 					$seq .= '2';
    1901. 

  1901. 					$code = ($code - 2) / 3;
    1902. 

  1902. 					break;
    1903. 

  1903. 				}
    1904. 

  1904. 			}
    1905. 

  1905. 		} while($code != 0);
    1906. 

  1906. 		$seq = strrev($seq);
    1907. 

  1907. 		$k = 0;
    1908. 

  1908. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 2, 'bcode' => array());
    1909. 

  1909. 		$len = strlen($seq);
    1910. 

  1910. 		for ($i = 0; $i < $len; ++$i) {
    1911. 

  1911. 			switch ($seq{$i}) {
    1912. 

  1912. 				case '1': {
    1913. 

  1913. 					$p = 1;
    1914. 

  1914. 					$h = 1;
    1915. 

  1915. 					break;
    1916. 

  1916. 				}
    1917. 

  1917. 				case '2': {
    1918. 

  1918. 					$p = 0;
    1919. 

  1919. 					$h = 1;
    1920. 

  1920. 					break;
    1921. 

  1921. 				}
    1922. 

  1922. 				case '3': {
    1923. 

  1923. 					$p = 0;
    1924. 

  1924. 					$h = 2;
    1925. 

  1925. 					break;
    1926. 

  1926. 				}
    1927. 

  1927. 			}
    1928. 

  1928. 			$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => $h, 'p' => $p);
    1929. 

  1929. 			$bararray['bcode'][$k++] = array('t' => 0, 'w' => 1, 'h' => 2, 'p' => 0);
    1930. 

  1930. 			$bararray['maxw'] += 2;
    1931. 

  1931. 		}
    1932. 

  1932. 		unset($bararray['bcode'][($k - 1)]);
    1933. 

  1933. 		--$bararray['maxw'];
    1934. 

  1934. 		return $bararray;
    1935. 

  1935. 	}
    1936. 

  1936. 

  1937. 

  1938. 	/**
    1939. 

  1939. 	 * IMB - Intelligent Mail Barcode - Onecode - USPS-B-3200
    1940. 

  1940. 	 * (requires PHP bcmath extension)
    1941. 

  1941. 	 * Intelligent Mail barcode is a 65-bar code for use on mail in the United States.
    1942. 

  1942. 	 * The fields are described as follows:<ul><li>The Barcode Identifier shall be assigned by USPS to encode the presort identification that is currently printed in human readable form on the optional endorsement line (OEL) as well as for future USPS use. This shall be two digits, with the second digit in the range of 0–4. The allowable encoding ranges shall be 00–04, 10–14, 20–24, 30–34, 40–44, 50–54, 60–64, 70–74, 80–84, and 90–94.</li><li>The Service Type Identifier shall be assigned by USPS for any combination of services requested on the mailpiece. The allowable encoding range shall be 000http://it2.php.net/manual/en/function.dechex.php–999. Each 3-digit value shall correspond to a particular mail class with a particular combination of service(s). Each service program, such as OneCode Confirm and OneCode ACS, shall provide the list of Service Type Identifier values.</li><li>The Mailer or Customer Identifier shall be assigned by USPS as a unique, 6 or 9 digit number that identifies a business entity. The allowable encoding range for the 6 digit Mailer ID shall be 000000- 899999, while the allowable encoding range for the 9 digit Mailer ID shall be 900000000-999999999.</li><li>The Serial or Sequence Number shall be assigned by the mailer for uniquely identifying and tracking mailpieces. The allowable encoding range shall be 000000000–999999999 when used with a 6 digit Mailer ID and 000000-999999 when used with a 9 digit Mailer ID. e. The Delivery Point ZIP Code shall be assigned by the mailer for routing the mailpiece. This shall replace POSTNET for routing the mailpiece to its final delivery point. The length may be 0, 5, 9, or 11 digits. The allowable encoding ranges shall be no ZIP Code, 00000–99999,  000000000–999999999, and 00000000000–99999999999.</li></ul>
    1943. 

  1943. 	 * @param $code (string) code to print, separate the ZIP (routing code) from the rest using a minus char '-' (BarcodeID_ServiceTypeID_MailerID_SerialNumber-RoutingCode)
    1944. 

  1944. 	 * @return array barcode representation.
    1945. 

  1945. 	 * @protected
    1946. 

  1946. 	 */
    1947. 

  1947. 	protected function barcode_imb($code) {
    1948. 

  1948. 		$asc_chr = array(4,0,2,6,3,5,1,9,8,7,1,2,0,6,4,8,2,9,5,3,0,1,3,7,4,6,8,9,2,0,5,1,9,4,3,8,6,7,1,2,4,3,9,5,7,8,3,0,2,1,4,0,9,1,7,0,2,4,6,3,7,1,9,5,8);
    1949. 

  1949. 		$dsc_chr = array(7,1,9,5,8,0,2,4,6,3,5,8,9,7,3,0,6,1,7,4,6,8,9,2,5,1,7,5,4,3,8,7,6,0,2,5,4,9,3,0,1,6,8,2,0,4,5,9,6,7,5,2,6,3,8,5,1,9,8,7,4,0,2,6,3);
    1950. 

  1950. 		$asc_pos = array(3,0,8,11,1,12,8,11,10,6,4,12,2,7,9,6,7,9,2,8,4,0,12,7,10,9,0,7,10,5,7,9,6,8,2,12,1,4,2,0,1,5,4,6,12,1,0,9,4,7,5,10,2,6,9,11,2,12,6,7,5,11,0,3,2);
    1951. 

  1951. 		$dsc_pos = array(2,10,12,5,9,1,5,4,3,9,11,5,10,1,6,3,4,1,10,0,2,11,8,6,1,12,3,8,6,4,4,11,0,6,1,9,11,5,3,7,3,10,7,11,8,2,10,3,5,8,0,3,12,11,8,4,5,1,3,0,7,12,9,8,10);
    1952. 

  1952. 		$code_arr = explode('-', $code);
    1953. 

  1953. 		$tracking_number = $code_arr[0];
    1954. 

  1954. 		if (isset($code_arr[1])) {
    1955. 

  1955. 			$routing_code = $code_arr[1];
    1956. 

  1956. 		} else {
    1957. 

  1957. 			$routing_code = '';
    1958. 

  1958. 		}
    1959. 

  1959. 		// Conversion of Routing Code
    1960. 

  1960. 		switch (strlen($routing_code)) {
    1961. 

  1961. 			case 0: {
    1962. 

  1962. 				$binary_code = 0;
    1963. 

  1963. 				break;
    1964. 

  1964. 			}
    1965. 

  1965. 			case 5: {
    1966. 

  1966. 				$binary_code = bcadd($routing_code, '1');
    1967. 

  1967. 				break;
    1968. 

  1968. 			}
    1969. 

  1969. 			case 9: {
    1970. 

  1970. 				$binary_code = bcadd($routing_code, '100001');
    1971. 

  1971. 				break;
    1972. 

  1972. 			}
    1973. 

  1973. 			case 11: {
    1974. 

  1974. 				$binary_code = bcadd($routing_code, '1000100001');
    1975. 

  1975. 				break;
    1976. 

  1976. 			}
    1977. 

  1977. 			default: {
    1978. 

  1978. 				return false;
    1979. 

  1979. 				break;
    1980. 

  1980. 			}
    1981. 

  1981. 		}
    1982. 

  1982. 		$binary_code = bcmul($binary_code, 10);
    1983. 

  1983. 		$binary_code = bcadd($binary_code, $tracking_number{0});
    1984. 

  1984. 		$binary_code = bcmul($binary_code, 5);
    1985. 

  1985. 		$binary_code = bcadd($binary_code, $tracking_number{1});
    1986. 

  1986. 		$binary_code .= substr($tracking_number, 2, 18);
    1987. 

  1987. 		// convert to hexadecimal
    1988. 

  1988. 		$binary_code = $this->dec_to_hex($binary_code);
    1989. 

  1989. 		// pad to get 13 bytes
    1990. 

  1990. 		$binary_code = str_pad($binary_code, 26, '0', STR_PAD_LEFT);
    1991. 

  1991. 		// convert string to array of bytes
    1992. 

  1992. 		$binary_code_arr = chunk_split($binary_code, 2, "\r");
    1993. 

  1993. 		$binary_code_arr = substr($binary_code_arr, 0, -1);
    1994. 

  1994. 		$binary_code_arr = explode("\r", $binary_code_arr);
    1995. 

  1995. 		// calculate frame check sequence
    1996. 

  1996. 		$fcs = $this->imb_crc11fcs($binary_code_arr);
    1997. 

  1997. 		// exclude first 2 bits from first byte
    1998. 

  1998. 		$first_byte = sprintf('%2s', dechex((hexdec($binary_code_arr[0]) << 2) >> 2));
    1999. 

  1999. 		$binary_code_102bit = $first_byte.substr($binary_code, 2);
    2000. 

  2000. 		// convert binary data to codewords
    2001. 

  2001. 		$codewords = array();
    2002. 

  2002. 		$data = $this->hex_to_dec($binary_code_102bit);
    2003. 

  2003. 		$codewords[0] = bcmod($data, 636) * 2;
    2004. 

  2004. 		$data = bcdiv($data, 636);
    2005. 

  2005. 		for ($i = 1; $i < 9; ++$i) {
    2006. 

  2006. 			$codewords[$i] = bcmod($data, 1365);
    2007. 

  2007. 			$data = bcdiv($data, 1365);
    2008. 

  2008. 		}
    2009. 

  2009. 		$codewords[9] = $data;
    2010. 

  2010. 		if (($fcs >> 10) == 1) {
    2011. 

  2011. 			$codewords[9] += 659;
    2012. 

  2012. 		}
    2013. 

  2013. 		// generate lookup tables
    2014. 

  2014. 		$table2of13 = $this->imb_tables(2, 78);
    2015. 

  2015. 		$table5of13 = $this->imb_tables(5, 1287);
    2016. 

  2016. 		// convert codewords to characters
    2017. 

  2017. 		$characters = array();
    2018. 

  2018. 		$bitmask = 512;
    2019. 

  2019. 		foreach($codewords as $k => $val) {
    2020. 

  2020. 			if ($val <= 1286) {
    2021. 

  2021. 				$chrcode = $table5of13[$val];
    2022. 

  2022. 			} else {
    2023. 

  2023. 				$chrcode = $table2of13[($val - 1287)];
    2024. 

  2024. 			}
    2025. 

  2025. 			if (($fcs & $bitmask) > 0) {
    2026. 

  2026. 				// bitwise invert
    2027. 

  2027. 				$chrcode = ((~$chrcode) & 8191);
    2028. 

  2028. 			}
    2029. 

  2029. 			$characters[] = $chrcode;
    2030. 

  2030. 			$bitmask /= 2;
    2031. 

  2031. 		}
    2032. 

  2032. 		$characters = array_reverse($characters);
    2033. 

  2033. 		// build bars
    2034. 

  2034. 		$k = 0;
    2035. 

  2035. 		$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 3, 'bcode' => array());
    2036. 

  2036. 		for ($i = 0; $i < 65; ++$i) {
    2037. 

  2037. 			$asc = (($characters[$asc_chr[$i]] & pow(2, $asc_pos[$i])) > 0);
    2038. 

  2038. 			$dsc = (($characters[$dsc_chr[$i]] & pow(2, $dsc_pos[$i])) > 0);
    2039. 

  2039. 			if ($asc AND $dsc) {
    2040. 

  2040. 				// full bar (F)
    2041. 

  2041. 				$p = 0;
    2042. 

  2042. 				$h = 3;
    2043. 

  2043. 			} elseif ($asc) {
    2044. 

  2044. 				// ascender (A)
    2045. 

  2045. 				$p = 0;
    2046. 

  2046. 				$h = 2;
    2047. 

  2047. 			} elseif ($dsc) {
    2048. 

  2048. 				// descender (D)
    2049. 

  2049. 				$p = 1;
    2050. 

  2050. 				$h = 2;
    2051. 

  2051. 			} else {
    2052. 

  2052. 				// tracker (T)
    2053. 

  2053. 				$p = 1;
    2054. 

  2054. 				$h = 1;
    2055. 

  2055. 			}
    2056. 

  2056. 			$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => $h, 'p' => $p);
    2057. 

  2057. 			$bararray['bcode'][$k++] = array('t' => 0, 'w' => 1, 'h' => 2, 'p' => 0);
    2058. 

  2058. 			$bararray['maxw'] += 2;
    2059. 

  2059. 		}
    2060. 

  2060. 		unset($bararray['bcode'][($k - 1)]);
    2061. 

  2061. 		--$bararray['maxw'];
    2062. 

  2062. 		return $bararray;
    2063. 

  2063. 	}
    2064. 

  2064. 

  2065. 	/**
    2066. 

  2066. 	 * Convert large integer number to hexadecimal representation.
    2067. 

  2067. 	 * (requires PHP bcmath extension)
    2068. 

  2068. 	 * @param $number (string) number to convert specified as a string
    2069. 

  2069. 	 * @return string hexadecimal representation
    2070. 

  2070. 	 */
    2071. 

  2071. 	public function dec_to_hex($number) {
    2072. 

  2072. 		$i = 0;
    2073. 

  2073. 		$hex = array();
    2074. 

  2074. 		if($number == 0) {
    2075. 

  2075. 			return '00';
    2076. 

  2076. 		}
    2077. 

  2077. 		while($number > 0) {
    2078. 

  2078. 			if($number == 0) {
    2079. 

  2079. 				array_push($hex, '0');
    2080. 

  2080. 			} else {
    2081. 

  2081. 				array_push($hex, strtoupper(dechex(bcmod($number, '16'))));
    2082. 

  2082. 				$number = bcdiv($number, '16', 0);
    2083. 

  2083. 			}
    2084. 

  2084. 		}
    2085. 

  2085. 		$hex = array_reverse($hex);
    2086. 

  2086. 		return implode($hex);
    2087. 

  2087. 	}
    2088. 

  2088. 

  2089. 	/**
    2090. 

  2090. 	 * Convert large hexadecimal number to decimal representation (string).
    2091. 

  2091. 	 * (requires PHP bcmath extension)
    2092. 

  2092. 	 * @param $hex (string) hexadecimal number to convert specified as a string
    2093. 

  2093. 	 * @return string hexadecimal representation
    2094. 

  2094. 	 */
    2095. 

  2095. 	public function hex_to_dec($hex) {
    2096. 

  2096. 		$dec = 0;
    2097. 

  2097. 		$bitval = 1;
    2098. 

  2098. 		$len = strlen($hex);
    2099. 

  2099. 		for($pos = ($len - 1); $pos >= 0; --$pos) {
    2100. 

  2100. 			$dec = bcadd($dec, bcmul(hexdec($hex{$pos}), $bitval));
    2101. 

  2101. 			$bitval = bcmul($bitval, 16);
    2102. 

  2102. 		}
    2103. 

  2103. 		return $dec;
    2104. 

  2104. 	}
    2105. 

  2105. 

  2106. 	/**
    2107. 

  2107. 	 * Intelligent Mail Barcode calculation of Frame Check Sequence
    2108. 

  2108. 	 * @param $code_arr (string) array of hexadecimal values (13 bytes holding 102 bits right justified).
    2109. 

  2109. 	 * @return int 11 bit Frame Check Sequence as integer (decimal base)
    2110. 

  2110. 	 * @protected
    2111. 

  2111. 	 */
    2112. 

  2112. 	protected function imb_crc11fcs($code_arr) {
    2113. 

  2113. 		$genpoly = 0x0F35; // generator polynomial
    2114. 

  2114. 		$fcs = 0x07FF; // Frame Check Sequence
    2115. 

  2115. 		// do most significant byte skipping the 2 most significant bits
    2116. 

  2116. 		$data = hexdec($code_arr[0]) << 5;
    2117. 

  2117. 		for ($bit = 2; $bit < 8; ++$bit) {
    2118. 

  2118. 			if (($fcs ^ $data) & 0x400) {
    2119. 

  2119. 				$fcs = ($fcs << 1) ^ $genpoly;
    2120. 

  2120. 			} else {
    2121. 

  2121. 				$fcs = ($fcs << 1);
    2122. 

  2122. 			}
    2123. 

  2123. 			$fcs &= 0x7FF;
    2124. 

  2124. 			$data <<= 1;
    2125. 

  2125. 		}
    2126. 

  2126. 		// do rest of bytes
    2127. 

  2127. 		for ($byte = 1; $byte < 13; ++$byte) {
    2128. 

  2128. 			$data = hexdec($code_arr[$byte]) << 3;
    2129. 

  2129. 			for ($bit = 0; $bit < 8; ++$bit) {
    2130. 

  2130. 				if (($fcs ^ $data) & 0x400) {
    2131. 

  2131. 					$fcs = ($fcs << 1) ^ $genpoly;
    2132. 

  2132. 				} else {
    2133. 

  2133. 					$fcs = ($fcs << 1);
    2134. 

  2134. 				}
    2135. 

  2135. 				$fcs &= 0x7FF;
    2136. 

  2136. 				$data <<= 1;
    2137. 

  2137. 			}
    2138. 

  2138. 		}
    2139. 

  2139. 		return $fcs;
    2140. 

  2140. 	}
    2141. 

  2141. 

  2142. 	/**
    2143. 

  2143. 	 * Reverse unsigned short value
    2144. 

  2144. 	 * @param $num (int) value to reversr
    2145. 

  2145. 	 * @return int reversed value
    2146. 

  2146. 	 * @protected
    2147. 

  2147. 	 */
    2148. 

  2148. 	protected function imb_reverse_us($num) {
    2149. 

  2149. 		$rev = 0;
    2150. 

  2150. 		for ($i = 0; $i < 16; ++$i) {
    2151. 

  2151. 			$rev <<= 1;
    2152. 

  2152. 			$rev |= ($num & 1);
    2153. 

  2153. 			$num >>= 1;
    2154. 

  2154. 		}
    2155. 

  2155. 		return $rev;
    2156. 

  2156. 	}
    2157. 

  2157. 

  2158. 	/**
    2159. 

  2159. 	 * generate Nof13 tables used for Intelligent Mail Barcode
    2160. 

  2160. 	 * @param $n (int) is the type of table: 2 for 2of13 table, 5 for 5of13table
    2161. 

  2161. 	 * @param $size (int) size of table (78 for n=2 and 1287 for n=5)
    2162. 

  2162. 	 * @return array requested table
    2163. 

  2163. 	 * @protected
    2164. 

  2164. 	 */
    2165. 

  2165. 	protected function imb_tables($n, $size) {
    2166. 

  2166. 		$table = array();
    2167. 

  2167. 		$lli = 0; // LUT lower index
    2168. 

  2168. 		$lui = $size - 1; // LUT upper index
    2169. 

  2169. 		for ($count = 0; $count < 8192; ++$count) {
    2170. 

  2170. 			$bit_count = 0;
    2171. 

  2171. 			for ($bit_index = 0; $bit_index < 13; ++$bit_index) {
    2172. 

  2172. 				$bit_count += intval(($count & (1 << $bit_index)) != 0);
    2173. 

  2173. 			}
    2174. 

  2174. 			// if we don't have the right number of bits on, go on to the next value
    2175. 

  2175. 			if ($bit_count == $n) {
    2176. 

  2176. 				$reverse = ($this->imb_reverse_us($count) >> 3);
    2177. 

  2177. 				// if the reverse is less than count, we have already visited this pair before
    2178. 

  2178. 				if ($reverse >= $count) {
    2179. 

  2179. 					// If count is symmetric, place it at the first free slot from the end of the list.
    2180. 

  2180. 					// Otherwise, place it at the first free slot from the beginning of the list AND place $reverse ath the next free slot from the beginning of the list
    2181. 

  2181. 					if ($reverse == $count) {
    2182. 

  2182. 						$table[$lui] = $count;
    2183. 

  2183. 						--$lui;
    2184. 

  2184. 					} else {
    2185. 

  2185. 						$table[$lli] = $count;
    2186. 

  2186. 						++$lli;
    2187. 

  2187. 						$table[$lli] = $reverse;
    2188. 

  2188. 						++$lli;
    2189. 

  2189. 					}
    2190. 

  2190. 				}
    2191. 

  2191. 			}
    2192. 

  2192. 		}
    2193. 

  2193. 		return $table;
    2194. 

  2194. 	}
    2195. 

  2195. 

  2196. } // end of class
    2197. 

  2197. //============================================================+
    2198. 

  2198. // END OF FILE
    2199. 

  2199. //============================================================+
    2200. 

  2200. 

  2201. ?>
    2202. 

  2202.