system/lib/Barcode.php
<?php
/*
* BarCode Coder Library (BCC Library)
* BCCL Version 2.0.1
* Porting : Barcode PHP
* DEMONTE Jean-Baptiste
* Date : September 25, 2010
*
*
* Author : DEMONTE Jean-Baptiste (firejocker)
* HOUREZ Jonathan
* Contact : jbdemonte @ gmail.com
* Web site: http://barcode-coder.com/
* dual licence : http://www.cecill.info/licences/Licence_CeCILL_V2-fr.html
* http://www.gnu.org/licenses/gpl.html
*
* Managed :
*
* standard 2 of 5 (std25)
* interleaved 2 of 5 (int25)
* ean 8 (ean8)
* ean 13 (ean13)
* code 11 (code11)
* code 39 (code39)
* code 93 (code93)
* code 128 (code128)
* codabar (codabar)
* msi (msi)
* datamatrix (datamatrix)
*
* Output :
*
* GD
* FPDF
*/
class Barcode {
static public function gd($res, $color, $x, $y, $angle, $type, $datas, $width = null, $height = null){
return self::_draw(__FUNCTION__, $res, $color, $x, $y, $angle, $type, $datas, $width, $height);
}
static public function fpdf($res, $color, $x, $y, $angle, $type, $datas, $width = null, $height = null){
return self::_draw(__FUNCTION__, $res, $color, $x, $y, $angle, $type, $datas, $width, $height);
}
static private function _draw($call, $res, $color, $x, $y, $angle, $type, $datas, $width, $height){
$digit = '';
$hri = '';
$code = '';
$crc = true;
$rect = false;
$b2d = false;
if (is_array($datas)){
foreach(array('code' => '', 'crc' => true, 'rect' => false) as $v => $def){
$$v = isset($datas[$v]) ? $datas[$v] : $def;
}
$code = $code;
} else {
$code = $datas;
}
if ($code == '') return false;
$code = (string) $code;
$type = strtolower($type);
switch($type){
case 'std25':
case 'int25':
$digit = BarcodeI25::getDigit($code, $crc, $type);
$hri = BarcodeI25::compute($code, $crc, $type);
break;
case 'ean8':
case 'ean13':
$digit = BarcodeEAN::getDigit($code, $type);
$hri = BarcodeEAN::compute($code, $type);
break;
case 'code11':
$digit = Barcode11::getDigit($code);
$hri = $code;
break;
case 'code39':
$digit = Barcode39::getDigit($code);
$hri = $code;
break;
case 'code93':
$digit = Barcode93::getDigit($code, $crc);
$hri = $code;
break;
case 'code128':
$digit = Barcode128::getDigit($code);
$hri = $code;
break;
case 'codabar':
$digit = BarcodeCodabar::getDigit($code);
$hri = $code;
break;
case 'msi':
$digit = BarcodeMSI::getDigit($code, $crc);
$hri = BarcodeMSI::compute($code, $crc);
break;
case 'datamatrix':
$digit = BarcodeDatamatrix::getDigit($code, $rect);
$hri = $code;
$b2d = true;
break;
}
if ($digit == '') return false;
if ( $b2d ){
$width = is_null($width) ? 5 : $width;
$height = $width;
} else {
$width = is_null($width) ? 1 : $width;
$height = is_null($height) ? 50 : $height;
$digit = self::bitStringTo2DArray($digit);
}
if ( $call == 'gd' ){
$result = self::digitToGDRenderer($res, $color, $x, $y, $angle, $width, $height, $digit);
} else if ( $call == 'fpdf' ){
$result = self::digitToFPDFRenderer($res, $color, $x, $y, $angle, $width, $height, $digit);
}
$result['hri'] = $hri;
return $result;
}
// convert a bit string to an array of array of bit char
private static function bitStringTo2DArray( $digit ){
$d = array();
$len = strlen($digit);
for($i=0; $i<$len; $i++) $d[$i] = $digit[$i];
return(array($d));
}
// GD barcode renderer
private static function digitToGDRenderer($gd, $color, $xi, $yi, $angle, $mw, $mh, $digit){
$lines = count($digit);
$columns = count($digit[0]);
$angle = deg2rad(-$angle);
$cos = cos($angle);
$sin = sin($angle);
self::_rotate($columns * $mw / 2, $lines * $mh / 2, $cos, $sin , $x, $y);
$xi -=$x;
$yi -=$y;
for($y=0; $y<$lines; $y++){
$len = 0;
$current = $digit[$y][0];
for($x=0; $x<$columns; $x++){
if ($current == $digit[$y][$x]) {
$len++;
} else {
if ($current == '1'){
$px = $len * $mw;
$xt = $xi + ($x - $len) * $mw;
if ($angle == 0){
if ($px > 2){
imagefilledrectangle($gd, $xt, $yi + $y * $mh, $xt + $px - 1, $yi + ($y + 1) * $mh, $color);
} else {
for($i = 0; $i < $px; $i++){
imageline($gd, $xt + $i, $yi + $y * $mh, $xt + $i, $yi + ($y + 1) * $mh, $color);
}
}
} else {
for($i = 0; $i < $px; $i++){
self::_rotate($xt + $i - $xi, $y * $mh, $cos, $sin , $x1, $y1);
self::_rotate($xt + $i - $xi, ($y + 1) * $mh, $cos, $sin , $x2, $y2);
imageline($gd, $xi + $x1, $yi + $y1, $xi + $x2, $yi + $y2, $color);
}
}
}
$current = $digit[$y][$x];
$len=1;
}
}
if ( ($len > 0) && ($current == '1') ){
$px = $len * $mw;
$xt = $xi + ($columns - $len) * $mw;
$y = $lines - 1;
if ($angle == 0){
if ($px > 2){
imagefilledrectangle($gd, $xt, $yi + $y * $mh, $xt + $px - 1, $yi + ($y + 1) * $mh, $color);
} else {
for($i = 0; $i < $px; $i++){
imageline($gd, $xt + $i, $yi + $y * $mh, $xt + $i, $yi + ($y + 1) * $mh, $color);
}
}
} else {
for($i = 0; $i < $px; $i++){
self::_rotate($xt + $i - $xi, $y * $mh, $cos, $sin , $x1, $y1);
self::_rotate($xt + $i - $xi, ($y + 1) * $mh, $cos, $sin , $x2, $y2);
imageline($gd, $xi + $x1, $yi + $y1, $xi + $x2, $yi + $y2, $color);
}
}
}
}
return self::result($xi, $yi, $columns, $lines, $mw, $mh, $cos, $sin);
}
// GD barcode renderer
private static function digitToFPDFRenderer($pdf, $color, $xi, $yi, $angle, $mw, $mh, $digit){
$lines = count($digit);
$columns = count($digit[0]);
$angle = deg2rad(-$angle);
$cos = cos($angle);
$sin = sin($angle);
$pdf->SetLineWidth($mw);
if (!is_array($color)){
if (preg_match('`([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})`i', $color, $m)){
$color = array(hexdec($m[1]),hexdec($m[2]),hexdec($m[3]));
} else {
$color = array(0,0,0);
}
}
$color = array_values($color);
$pdf->SetDrawColor($color[0],$color[1],$color[2]);
$pdf->SetFillColor($color[0],$color[1],$color[2]);
self::_rotate($columns * $mw / 2, $lines * $mh / 2, $cos, $sin , $x, $y);
$xi -=$x;
$yi -=$y;
for($y=0; $y<$lines; $y++){
$len = 0;
$current = $digit[$y][0];
for($x=0; $x<$columns; $x++){
if ($current == $digit[$y][$x]) {
$len++;
} else {
if ($current == '1'){
$px = $len ;
$xt = $xi + ($x - $len) * $mw;
if ($angle == 0){
if ($px > 2){
$pdf->rect($xt, $yi + $y * $mh, $px - 1, $mh, 'F');
} else {
for($i = 0; $i < $px; $i++){
$pdf->line($xt + $i, $yi + $y * $mh, $xt + $i, $yi + ($y + 1) * $mh);
}
}
} else {
for($i = 0; $i < $px; $i++){
self::_rotate($xt + $i - $xi, $y * $mh, $cos, $sin , $x1, $y1);
self::_rotate($xt + $i - $xi, ($y + 1) * $mh, $cos, $sin , $x2, $y2);
$pdf->line($xi + $x1, $yi + $y1, $xi + $x2, $yi + $y2);
}
}
}
$current = $digit[$y][$x];
$len=1;
}
}
if ( ($len > 0) && ($current == '1') ){
$px = $len ;
$xt = $xi + ($columns - $len) * $mw;
$y = $lines - 1;
if ($angle == 0){
if ($px > 2){
$pdf->rect($xt, $yi + $y * $mh, $px - 1, $mh, 'F');
} else {
for($i = 0; $i < $px; $i++){
$pdf->line($xt + $i, $yi + $y * $mh, $xt + $i, $yi + ($y + 1) * $mh);
}
}
} else {
for($i = 0; $i < $px; $i++){
self::_rotate($xt + $i - $xi, $y * $mh, $cos, $sin , $x1, $y1);
self::_rotate($xt + $i - $xi, ($y + 1) * $mh, $cos, $sin , $x2, $y2);
$pdf->line($xi + $x1, $yi + $y1, $xi + $x2, $yi + $y2);
}
}
}
}
return self::result($xi, $yi, $columns, $lines, $mw, $mh, $cos, $sin);
}
static private function result($xi, $yi, $columns, $lines, $mw, $mh, $cos, $sin){
self::_rotate(0, 0, $cos, $sin , $x1, $y1);
self::_rotate($columns * $mw, 0, $cos, $sin , $x2, $y2);
self::_rotate($columns * $mw, $lines * $mh, $cos, $sin , $x3, $y3);
self::_rotate(0, $lines * $mh, $cos, $sin , $x4, $y4);
return array(
'width' => $columns * $mw,
'height'=> $lines * $mh,
'p1' => array(
'x' => $xi + $x1,
'y' => $yi + $y1
),
'p2' => array(
'x' => $xi + $x2,
'y' => $yi + $y2
),
'p3' => array(
'x' => $xi + $x3,
'y' => $yi + $y3
),
'p4' => array(
'x' => $xi + $x4,
'y' => $yi + $y4
)
);
}
static private function _rotate($x1, $y1, $cos, $sin , &$x, &$y){
$x = $x1 * $cos - $y1 * $sin;
$y = $x1 * $sin + $y1 * $cos;
}
static public function rotate($x1, $y1, $angle , &$x, &$y){
$angle = deg2rad(-$angle);
$cos = cos($angle);
$sin = sin($angle);
$x = $x1 * $cos - $y1 * $sin;
$y = $x1 * $sin + $y1 * $cos;
}
}
class BarcodeI25 {
static private $encoding = array('NNWWN', 'WNNNW', 'NWNNW', 'WWNNN', 'NNWNW', 'WNWNN', 'NWWNN', 'NNNWW', 'WNNWN','NWNWN');
static public function compute($code, $crc, $type){
if (! $crc) {
if (strlen($code) % 2) $code = '0' . $code;
} else {
if ( ($type == 'int25') && (strlen($code) % 2 == 0) ) $code = '0' . $code;
$odd = true;
$sum = 0;
for($i=strlen($code)-1; $i>-1; $i--){
$v = intval($code[$i]);
$sum += $odd ? 3 * $v : $v;
$odd = ! $odd;
}
$code .= (string) ((10 - $sum % 10) % 10);
}
return($code);
}
static public function getDigit($code, $crc, $type){
$code = self::compute($code, $crc, $type);
if ($code == '') return($code);
$result = '';
if ($type == 'int25') { // Interleaved 2 of 5
// start
$result .= '1010';
// digits + CRC
$end = strlen($code) / 2;
for($i=0; $i<$end; $i++){
$c1 = $code[2*$i];
$c2 = $code[2*$i+1];
for($j=0; $j<5; $j++){
$result .= '1';
if (self::$encoding[$c1][$j] == 'W') $result .= '1';
$result .= '0';
if (self::$encoding[$c2][$j] == 'W') $result .= '0';
}
}
// stop
$result .= '1101';
} else if ($type == 'std25') {
// Standard 2 of 5 is a numeric-only barcode that has been in use a long time.
// Unlike Interleaved 2 of 5, all of the information is encoded in the bars; the spaces are fixed width and are used only to separate the bars.
// The code is self-checking and does not include a checksum.
// start
$result .= '11011010';
// digits + CRC
$end = strlen($code);
for($i=0; $i<$end; $i++){
$c = $code[$i];
for($j=0; $j<5; $j++){
$result .= '1';
if (self::$encoding[$c][$j] == 'W') $result .= '11';
$result .= '0';
}
}
// stop
$result .= '11010110';
}
return($result);
}
}
class BarcodeEAN {
static private $encoding = array(
array('0001101', '0100111', '1110010'),
array('0011001', '0110011', '1100110'),
array('0010011', '0011011', '1101100'),
array('0111101', '0100001', '1000010'),
array('0100011', '0011101', '1011100'),
array('0110001', '0111001', '1001110'),
array('0101111', '0000101', '1010000'),
array('0111011', '0010001', '1000100'),
array('0110111', '0001001', '1001000'),
array('0001011', '0010111', '1110100')
);
static private $first = array('000000','001011','001101','001110','010011','011001','011100','010101','010110','011010');
static public function getDigit($code, $type){
// Check len (12 for ean13, 7 for ean8)
$len = $type == 'ean8' ? 7 : 12;
$code = substr($code, 0, $len);
if (!preg_match('`[0-9]{'.$len.'}`', $code)) return('');
// get checksum
$code = self::compute($code, $type);
// process analyse
$result = '101'; // start
if ($type == 'ean8'){
// process left part
for($i=0; $i<4; $i++){
$result .= self::$encoding[intval($code[$i])][0];
}
// center guard bars
$result .= '01010';
// process right part
for($i=4; $i<8; $i++){
$result .= self::$encoding[intval($code[$i])][2];
}
} else { // ean13
// extract first digit and get sequence
$seq = self::$first[ intval($code[0]) ];
// process left part
for($i=1; $i<7; $i++){
$result .= self::$encoding[intval($code[$i])][ intval($seq[$i-1]) ];
}
// center guard bars
$result .= '01010';
// process right part
for($i=7; $i<13; $i++){
$result .= self::$encoding[intval($code[$i])][ 2 ];
}
} // ean13
$result .= '101'; // stop
return($result);
}
static public function compute($code, $type){
$len = $type == 'ean13' ? 12 : 7;
$code = substr($code, 0, $len);
if (!preg_match('`[0-9]{'.$len.'}`', $code)) return('');
$sum = 0;
$odd = true;
for($i=$len-1; $i>-1; $i--){
$sum += ($odd ? 3 : 1) * intval($code[$i]);
$odd = ! $odd;
}
return($code . ( (string) ((10 - $sum % 10) % 10)));
}
}
class BarcodeMSI {
static private $encoding = array(
'100100100100', '100100100110', '100100110100', '100100110110',
'100110100100', '100110100110', '100110110100', '100110110110',
'110100100100', '110100100110');
static public function compute($code, $crc){
if (is_array($crc)){
if ($crc['crc1'] == 'mod10'){
$code = self::computeMod10($code);
} else if ($crc['crc1'] == 'mod11'){
$code = self::computeMod11($code);
}
if ($crc['crc2'] == 'mod10'){
$code = self::computeMod10($code);
} else if ($crc['crc2'] == 'mod11'){
$code = self::computeMod11($code);
}
} else if ($crc){
$code = self::computeMod10($code);
}
return($code);
}
static private function computeMod10($code){
$len = strlen($code);
$toPart1 = $len % 2;
$n1 = 0;
$sum = 0;
for($i=0; $i<$len; $i++){
if ($toPart1) {
$n1 = 10 * $n1 + intval($code[$i]);
} else {
$sum += intval($code[$i]);
}
$toPart1 = ! $toPart1;
}
$s1 = (string) (2 * $n1);
$len = strlen($s1);
for($i=0; $i<$len; $i++){
$sum += intval($s1[$i]);
}
return($code . ( (string) (10 - $sum % 10) % 10));
}
static private function computeMod11($code){
$sum = 0;
$weight = 2;
for($i=strlen($code)-1; $i>-1; $i--){
$sum += $weight * intval($code[$i]);
$weight = $weight == 7 ? 2 : $weight + 1;
}
return($code . ( (string) (11 - $sum % 11) % 11) );
}
static public function getDigit($code, $crc){
if (preg_match('`[^0-9]`', $code)) return '';
$index = 0;
$result = '';
$code = self::compute($code, false);
// start
$result = '110';
// digits
$len = strlen($code);
for($i=0; $i<$len; $i++){
$result .= self::$encoding[ intval($code[$i]) ];
}
// stop
$result .= '1001';
return($result);
}
}
class Barcode11 {
static private $encoding = array(
'101011', '1101011', '1001011', '1100101',
'1011011', '1101101', '1001101', '1010011',
'1101001', '110101', '101101');
static public function getDigit($code){
if (preg_match('`[^0-9\-]`', $code)) return '';
$result = '';
$intercharacter = '0';
// start
$result = '1011001' . $intercharacter;
// digits
$len = strlen($code);
for($i=0; $i<$len; $i++){
$index = $code[$i] == '-' ? 10 : intval($code[$i]);
$result .= self::$encoding[ $index ] . $intercharacter;
}
// checksum
$weightC = 0;
$weightSumC = 0;
$weightK = 1; // start at 1 because the right-most character is 'C' checksum
$weightSumK = 0;
for($i=$len-1; $i>-1; $i--){
$weightC = $weightC == 10 ? 1 : $weightC + 1;
$weightK = $weightK == 10 ? 1 : $weightK + 1;
$index = $code[$i] == '-' ? 10 : intval($code[$i]);
$weightSumC += $weightC * $index;
$weightSumK += $weightK * $index;
}
$c = $weightSumC % 11;
$weightSumK += $c;
$k = $weightSumK % 11;
$result .= self::$encoding[$c] . $intercharacter;
if ($len >= 10){
$result .= self::$encoding[$k] . $intercharacter;
}
// stop
$result .= '1011001';
return($result);
}
}
class Barcode39 {
static private $encoding = array(
'101001101101', '110100101011', '101100101011', '110110010101',
'101001101011', '110100110101', '101100110101', '101001011011',
'110100101101', '101100101101', '110101001011', '101101001011',
'110110100101', '101011001011', '110101100101', '101101100101',
'101010011011', '110101001101', '101101001101', '101011001101',
'110101010011', '101101010011', '110110101001', '101011010011',
'110101101001', '101101101001', '101010110011', '110101011001',
'101101011001', '101011011001', '110010101011', '100110101011',
'110011010101', '100101101011', '110010110101', '100110110101',
'100101011011', '110010101101', '100110101101', '100100100101',
'100100101001', '100101001001', '101001001001', '100101101101');
static public function getDigit($code){
$table = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%*';
$result = '';
$intercharacter = '0';
if (strpos($code, '*') !== false) return('');
// Add Start and Stop charactere : *
$code = strtoupper('*' . $code . '*');
$len = strlen($code);
for($i=0; $i<$len; $i++){
$index = strpos($table, $code[$i]);
if ($index === false) return('');
if ($i > 0) $result .= $intercharacter;
$result .= self::$encoding[ $index ];
}
return($result);
}
}
class Barcode93{
static private $encoding = array(
'100010100', '101001000', '101000100', '101000010',
'100101000', '100100100', '100100010', '101010000',
'100010010', '100001010', '110101000', '110100100',
'110100010', '110010100', '110010010', '110001010',
'101101000', '101100100', '101100010', '100110100',
'100011010', '101011000', '101001100', '101000110',
'100101100', '100010110', '110110100', '110110010',
'110101100', '110100110', '110010110', '110011010',
'101101100', '101100110', '100110110', '100111010',
'100101110', '111010100', '111010010', '111001010',
'101101110', '101110110', '110101110', '100100110',
'111011010', '111010110', '100110010', '101011110');
static public function getDigit($code, $crc){
$table = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%____*'; // _ => ($), (%), (/) et (+)
$result = '';
if (strpos($code, '*') !== false) return('');
$code = strtoupper($code);
// start : *
$result .= self::$encoding[47];
// digits
$len = strlen($code);
for($i=0; $i<$len; $i++){
$c = $code[$i];
$index = strpos($table, $c);
if ( ($c == '_') || ($index === false) ) return('');
$result .= self::$encoding[ $index ];
}
// checksum
if ($crc){
$weightC = 0;
$weightSumC = 0;
$weightK = 1; // start at 1 because the right-most character is 'C' checksum
$weightSumK = 0;
for($i=$len-1; $i>-1; $i--){
$weightC = $weightC == 20 ? 1 : $weightC + 1;
$weightK = $weightK == 15 ? 1 : $weightK + 1;
$index = strpos($table, $code[$i]);
$weightSumC += $weightC * $index;
$weightSumK += $weightK * $index;
}
$c = $weightSumC % 47;
$weightSumK += $c;
$k = $weightSumK % 47;
$result .= self::$encoding[$c];
$result .= self::$encoding[$k];
}
// stop : *
$result .= self::$encoding[47];
// Terminaison bar
$result .= '1';
return($result);
}
}
class Barcode128 {
static private $encoding = array(
'11011001100', '11001101100', '11001100110', '10010011000',
'10010001100', '10001001100', '10011001000', '10011000100',
'10001100100', '11001001000', '11001000100', '11000100100',
'10110011100', '10011011100', '10011001110', '10111001100',
'10011101100', '10011100110', '11001110010', '11001011100',
'11001001110', '11011100100', '11001110100', '11101101110',
'11101001100', '11100101100', '11100100110', '11101100100',
'11100110100', '11100110010', '11011011000', '11011000110',
'11000110110', '10100011000', '10001011000', '10001000110',
'10110001000', '10001101000', '10001100010', '11010001000',
'11000101000', '11000100010', '10110111000', '10110001110',
'10001101110', '10111011000', '10111000110', '10001110110',
'11101110110', '11010001110', '11000101110', '11011101000',
'11011100010', '11011101110', '11101011000', '11101000110',
'11100010110', '11101101000', '11101100010', '11100011010',
'11101111010', '11001000010', '11110001010', '10100110000',
'10100001100', '10010110000', '10010000110', '10000101100',
'10000100110', '10110010000', '10110000100', '10011010000',
'10011000010', '10000110100', '10000110010', '11000010010',
'11001010000', '11110111010', '11000010100', '10001111010',
'10100111100', '10010111100', '10010011110', '10111100100',
'10011110100', '10011110010', '11110100100', '11110010100',
'11110010010', '11011011110', '11011110110', '11110110110',
'10101111000', '10100011110', '10001011110', '10111101000',
'10111100010', '11110101000', '11110100010', '10111011110',
'10111101110', '11101011110', '11110101110', '11010000100',
'11010010000', '11010011100', '11000111010');
static public function getDigit($code){
$tableB = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
$result = "";
$sum = 0;
$isum = 0;
$i = 0;
$j = 0;
$value = 0;
// check each characters
$len = strlen($code);
for($i=0; $i<$len; $i++){
if (strpos($tableB, $code[$i]) === false) return("");
}
// check firsts characters : start with C table only if enought numeric
$tableCActivated = $len> 1;
$c = '';
for($i=0; $i<3 && $i<$len; $i++){
$tableCActivated &= preg_match('`[0-9]`', $code[$i]);
}
$sum = $tableCActivated ? 105 : 104;
// start : [105] : C table or [104] : B table
$result = self::$encoding[ $sum ];
$i = 0;
while( $i < $len ){
if (! $tableCActivated){
$j = 0;
// check next character to activate C table if interresting
while ( ($i + $j < $len) && preg_match('`[0-9]`', $code[$i+$j]) ) $j++;
// 6 min everywhere or 4 mini at the end
$tableCActivated = ($j > 5) || (($i + $j - 1 == $len) && ($j > 3));
if ( $tableCActivated ){
$result .= self::$encoding[ 99 ]; // C table
$sum += ++$isum * 99;
}
// 2 min for table C so need table B
} else if ( ($i == $len - 1) || (preg_match('`[^0-9]`', $code[$i])) || (preg_match('`[^0-9]`', $code[$i+1])) ) { //todo : verifier le JS : len - 1!!! XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
$tableCActivated = false;
$result .= self::$encoding[ 100 ]; // B table
$sum += ++$isum * 100;
}
if ( $tableCActivated ) {
$value = intval(substr($code, $i, 2)); // Add two characters (numeric)
$i += 2;
} else {
$value = strpos($tableB, $code[$i]); // Add one character
$i++;
}
$result .= self::$encoding[ $value ];
$sum += ++$isum * $value;
}
// Add CRC
$result .= self::$encoding[ $sum % 103 ];
// Stop
$result .= self::$encoding[ 106 ];
// Termination bar
$result .= '11';
return($result);
}
}
class BarcodeCodabar {
static private $encoding = array(
'101010011', '101011001', '101001011', '110010101',
'101101001', '110101001', '100101011', '100101101',
'100110101', '110100101', '101001101', '101100101',
'1101011011', '1101101011', '1101101101', '1011011011',
'1011001001', '1010010011', '1001001011', '1010011001');
static public function getDigit($code){
$table = '0123456789-$:/.+';
$result = '';
$intercharacter = '0';
// add start : A->D : arbitrary choose A
$result .= self::$encoding[16] . $intercharacter;
$len = strlen($code);
for($i=0; $i<$len; $i++){
$index = strpos($table, $code[$i]);
if ($index === false) return('');
$result .= self::$encoding[ $index ] . $intercharacter;
}
// add stop : A->D : arbitrary choose A
$result .= self::$encoding[16];
return($result);
}
}
class BarcodeDatamatrix {
static private $encoding = array(
'101010011', '101011001', '101001011', '110010101',
'101101001', '110101001', '100101011', '100101101',
'100110101', '110100101', '101001101', '101100101',
'1101011011', '1101101011', '1101101101', '1011011011',
'1011001001', '1010010011', '1001001011', '1010011001');
static private $lengthRows = array(
10, 12, 14, 16, 18, 20, 22, 24, 26, // 24 squares et 6 rectangular
32, 36, 40, 44, 48, 52, 64, 72, 80, 88, 96, 104, 120, 132, 144,
8, 8, 12, 12, 16, 16);
static private $lengthCols = array(
10, 12, 14, 16, 18, 20, 22, 24, 26, // Number of columns for the entire datamatrix
32, 36, 40, 44, 48, 52, 64, 72, 80, 88, 96, 104, 120, 132, 144,
18, 32, 26, 36, 36, 48);
static private $mappingRows = array(
8, 10, 12, 14, 16, 18, 20, 22, 24, // Number of rows for the mapping matrix
28, 32, 36, 40, 44, 48, 56, 64, 72, 80, 88, 96, 108, 120, 132,
6, 6, 10, 10, 14, 14);
static private $mappingCols = array(
8, 10, 12, 14, 16, 18, 20, 22, 24, // Number of columns for the mapping matrix
28, 32, 36, 40, 44, 48, 56, 64, 72, 80, 88, 96, 108, 120, 132,
16, 28, 24, 32, 32, 44);
static private $dataCWCount = array(
3, 5, 8, 12, 18, 22, 30, 36, // Number of data codewords for the datamatrix
44, 62, 86, 114, 144, 174, 204, 280, 368, 456, 576, 696, 816, 1050,
1304, 1558, 5, 10, 16, 22, 32, 49);
static private $solomonCWCount = array(
5, 7, 10, 12, 14, 18, 20, 24, 28, // Number of Reed-Solomon codewords for the datamatrix
36, 42, 48, 56, 68, 84, 112, 144, 192, 224, 272, 336, 408, 496, 620,
7, 11, 14, 18, 24, 28);
static private $dataRegionRows = array(
8, 10, 12, 14, 16, 18, 20, 22, // Number of rows per region
24, 14, 16, 18, 20, 22, 24, 14, 16, 18, 20, 22, 24, 18, 20, 22,
6, 6, 10, 10, 14, 14);
static private $dataRegionCols = array(
8, 10, 12, 14, 16, 18, 20, 22, // Number of columns per region
24, 14, 16, 18, 20, 22, 24, 14, 16, 18, 20, 22, 24, 18, 20, 22,
16, 14, 24, 16, 16, 22);
static private $regionRows = array(
1, 1, 1, 1, 1, 1, 1, 1, // Number of regions per row
1, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 6, 6, 6,
1, 1, 1, 1, 1, 1);
static private $regionCols = array(
1, 1, 1, 1, 1, 1, 1, 1, // Number of regions per column
1, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 6, 6, 6,
1, 2, 1, 2, 2, 2);
static private $interleavedBlocks = array(
1, 1, 1, 1, 1, 1, 1, 1, // Number of blocks
1, 1, 1, 1, 1, 1, 2, 2, 4, 4, 4, 4, 6, 6, 8, 8,
1, 1, 1, 1, 1, 1);
static private $logTab = array(
-255, 255, 1, 240, 2, 225, 241, 53, 3, // Table of log for the Galois field
38, 226, 133, 242, 43, 54, 210, 4, 195, 39, 114, 227, 106, 134, 28,
243, 140, 44, 23, 55, 118, 211, 234, 5, 219, 196, 96, 40, 222, 115,
103, 228, 78, 107, 125, 135, 8, 29, 162, 244, 186, 141, 180, 45, 99,
24, 49, 56, 13, 119, 153, 212, 199, 235, 91, 6, 76, 220, 217, 197,
11, 97, 184, 41, 36, 223, 253, 116, 138, 104, 193, 229, 86, 79, 171,
108, 165, 126, 145, 136, 34, 9, 74, 30, 32, 163, 84, 245, 173, 187,
204, 142, 81, 181, 190, 46, 88, 100, 159, 25, 231, 50, 207, 57, 147,
14, 67, 120, 128, 154, 248, 213, 167, 200, 63, 236, 110, 92, 176, 7,
161, 77, 124, 221, 102, 218, 95, 198, 90, 12, 152, 98, 48, 185, 179,
42, 209, 37, 132, 224, 52, 254, 239, 117, 233, 139, 22, 105, 27, 194,
113, 230, 206, 87, 158, 80, 189, 172, 203, 109, 175, 166, 62, 127,
247, 146, 66, 137, 192, 35, 252, 10, 183, 75, 216, 31, 83, 33, 73,
164, 144, 85, 170, 246, 65, 174, 61, 188, 202, 205, 157, 143, 169, 82,
72, 182, 215, 191, 251, 47, 178, 89, 151, 101, 94, 160, 123, 26, 112,
232, 21, 51, 238, 208, 131, 58, 69, 148, 18, 15, 16, 68, 17, 121, 149,
129, 19, 155, 59, 249, 70, 214, 250, 168, 71, 201, 156, 64, 60, 237,
130, 111, 20, 93, 122, 177, 150);
static private $aLogTab = array(
1, 2, 4, 8, 16, 32, 64, 128, 45, 90, // Table of aLog for the Galois field
180, 69, 138, 57, 114, 228, 229, 231, 227, 235, 251, 219, 155, 27, 54,
108, 216, 157, 23, 46, 92, 184, 93, 186, 89, 178, 73, 146, 9, 18, 36,
72, 144, 13, 26, 52, 104, 208, 141, 55, 110, 220, 149, 7, 14, 28, 56,
112, 224, 237, 247, 195, 171, 123, 246, 193, 175, 115, 230, 225, 239,
243, 203, 187, 91, 182, 65, 130, 41, 82, 164, 101, 202, 185, 95, 190,
81, 162, 105, 210, 137, 63, 126, 252, 213, 135, 35, 70, 140, 53, 106,
212, 133, 39, 78, 156, 21, 42, 84, 168, 125, 250, 217, 159, 19, 38, 76,
152, 29, 58, 116, 232, 253, 215, 131, 43, 86, 172, 117, 234, 249, 223,
147, 11, 22, 44, 88, 176, 77, 154, 25, 50, 100, 200, 189, 87, 174, 113,
226, 233, 255, 211, 139, 59, 118, 236, 245, 199, 163, 107, 214, 129,
47, 94, 188, 85, 170, 121, 242, 201, 191, 83, 166, 97, 194, 169, 127,
254, 209, 143, 51, 102, 204, 181, 71, 142, 49, 98, 196, 165, 103, 206,
177, 79, 158, 17, 34, 68, 136, 61, 122, 244, 197, 167, 99, 198, 161,
111, 222, 145, 15, 30, 60, 120, 240, 205, 183, 67, 134, 33, 66, 132,
37, 74, 148, 5, 10, 20, 40, 80, 160, 109, 218, 153, 31, 62, 124, 248,
221, 151, 3, 6, 12, 24, 48, 96, 192, 173, 119, 238, 241, 207, 179, 75,
150, 1);
static private function champGaloisMult($a, $b){ // MULTIPLICATION IN GALOIS FIELD GF(2^8)
if(!$a || !$b) return 0;
return self::$aLogTab[(self::$logTab[$a] + self::$logTab[$b]) % 255];
}
static private function champGaloisDoub($a, $b){ // THE OPERATION a * 2^b IN GALOIS FIELD GF(2^8)
if (!$a) return 0;
if (!$b) return $a;
return self::$aLogTab[(self::$logTab[$a] + $b) % 255];
}
static private function champGaloisSum($a, $b){ // SUM IN GALOIS FIELD GF(2^8)
return $a ^ $b;
}
static private function selectIndex($dataCodeWordsCount, $rectangular){ // CHOOSE THE GOOD INDEX FOR TABLES
if (($dataCodeWordsCount<1 || $dataCodeWordsCount>1558) && !$rectangular) return -1;
if (($dataCodeWordsCount<1 || $dataCodeWordsCount>49) && $rectangular) return -1;
$n = $rectangular ? 24 : 0;
while (self::$dataCWCount[$n] < $dataCodeWordsCount) $n++;
return $n;
}
static private function encodeDataCodeWordsASCII($text) {
$dataCodeWords = array();
$n = 0;
$len = strlen($text);
for ($i=0; $i<$len; $i++){
$c = ord($text[$i]);
if ($c > 127) {
$dataCodeWords[$n] = 235;
$c -= 127;
$n++;
} else if (($c>=48 && $c<=57) && ($i+1<$len) && (preg_match('`[0-9]`', $text[$i+1]))) {
$c = (($c - 48) * 10) + intval($text[$i+1]);
$c += 130;
$i++;
} else $c++;
$dataCodeWords[$n] = $c;
$n++;
}
return $dataCodeWords;
}
static private function addPadCW(&$tab, $from, $to){
if ($from >= $to) return ;
$tab[$from] = 129;
for ($i=$from+1; $i<$to; $i++){
$r = ((149 * ($i+1)) % 253) + 1;
$tab[$i] = (129 + $r) % 254;
}
}
static private function calculSolFactorTable($solomonCWCount){ // CALCULATE THE REED SOLOMON FACTORS
$g = array_fill(0, $solomonCWCount+1, 1);
for($i = 1; $i <= $solomonCWCount; $i++) {
for($j = $i - 1; $j >= 0; $j--) {
$g[$j] = self::champGaloisDoub($g[$j], $i);
if($j > 0) $g[$j] = self::champGaloisSum($g[$j], $g[$j-1]);
}
}
return $g;
}
static private function addReedSolomonCW($nSolomonCW, $coeffTab, $nDataCW, &$dataTab, $blocks){ // Add the Reed Solomon codewords
$temp = 0;
$errorBlocks = $nSolomonCW / $blocks;
$correctionCW = array();
for($k = 0; $k < $blocks; $k++) {
for ($i=0; $i < $errorBlocks; $i++) $correctionCW[$i] = 0;
for ($i=$k; $i<$nDataCW; $i+=$blocks){
$temp = self::champGaloisSum($dataTab[$i], $correctionCW[$errorBlocks-1]);
for ($j=$errorBlocks-1; $j>=0; $j--){
if ( !$temp ) {
$correctionCW[$j] = 0;
} else {
$correctionCW[$j] = self::champGaloisMult($temp, $coeffTab[$j]);
}
if ($j>0) $correctionCW[$j] = self::champGaloisSum($correctionCW[$j-1], $correctionCW[$j]);
}
}
// Renversement des blocs calcules
$j = $nDataCW + $k;
for ($i=$errorBlocks-1; $i>=0; $i--){
$dataTab[$j] = $correctionCW[$i];
$j=$j+$blocks;
}
}
return $dataTab;
}
static private function getBits($entier){ // Transform integer to tab of bits
$bits = array();
for ($i=0; $i<8; $i++){
$bits[$i] = $entier & (128 >> $i) ? 1 : 0;
}
return $bits;
}
static private function next($etape, $totalRows, $totalCols, $codeWordsBits, &$datamatrix, &$assigned){ // Place codewords into the matrix
$chr = 0; // Place of the 8st bit from the first character to [4][0]
$row = 4;
$col = 0;
do {
// Check for a special case of corner
if(($row == $totalRows) && ($col == 0)){
self::patternShapeSpecial1($datamatrix, $assigned, $codeWordsBits[$chr], $totalRows, $totalCols);
$chr++;
} else if(($etape<3) && ($row == $totalRows-2) && ($col == 0) && ($totalCols%4 != 0)){
self::patternShapeSpecial2($datamatrix, $assigned, $codeWordsBits[$chr], $totalRows, $totalCols);
$chr++;
} else if(($row == $totalRows-2) && ($col == 0) && ($totalCols%8 == 4)){
self::patternShapeSpecial3($datamatrix, $assigned, $codeWordsBits[$chr], $totalRows, $totalCols);
$chr++;
}
else if(($row == $totalRows+4) && ($col == 2) && ($totalCols%8 == 0)){
self::patternShapeSpecial4($datamatrix, $assigned, $codeWordsBits[$chr], $totalRows, $totalCols);
$chr++;
}
// Go up and right in the datamatrix
do {
if(($row < $totalRows) && ($col >= 0) && (!isset($assigned[$row][$col]) || $assigned[$row][$col]!=1)) {
self::patternShapeStandard($datamatrix, $assigned, $codeWordsBits[$chr], $row, $col, $totalRows, $totalCols);
$chr++;
}
$row -= 2;
$col += 2;
} while (($row >= 0) && ($col < $totalCols));
$row += 1;
$col += 3;
// Go down and left in the datamatrix
do {
if(($row >= 0) && ($col < $totalCols) && (!isset($assigned[$row][$col]) || $assigned[$row][$col]!=1)){
self::patternShapeStandard($datamatrix, $assigned, $codeWordsBits[$chr], $row, $col, $totalRows, $totalCols);
$chr++;
}
$row += 2;
$col -= 2;
} while (($row < $totalRows) && ($col >=0));
$row += 3;
$col += 1;
} while (($row < $totalRows) || ($col < $totalCols));
}
static private function patternShapeStandard(&$datamatrix, &$assigned, $bits, $row, $col, $totalRows, $totalCols){ // Place bits in the matrix (standard or special case)
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[0], $row-2, $col-2, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[1], $row-2, $col-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[2], $row-1, $col-2, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[3], $row-1, $col-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[4], $row-1, $col, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[5], $row, $col-2, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[6], $row, $col-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[7], $row, $col, $totalRows, $totalCols);
}
static private function patternShapeSpecial1(&$datamatrix, &$assigned, $bits, $totalRows, $totalCols ){
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[0], $totalRows-1, 0, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[1], $totalRows-1, 1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[2], $totalRows-1, 2, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[3], 0, $totalCols-2, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[4], 0, $totalCols-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[5], 1, $totalCols-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[6], 2, $totalCols-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[7], 3, $totalCols-1, $totalRows, $totalCols);
}
static private function patternShapeSpecial2(&$datamatrix, &$assigned, $bits, $totalRows, $totalCols ){
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[0], $totalRows-3, 0, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[1], $totalRows-2, 0, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[2], $totalRows-1, 0, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[3], 0, $totalCols-4, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[4], 0, $totalCols-3, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[5], 0, $totalCols-2, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[6], 0, $totalCols-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[7], 1, $totalCols-1, $totalRows, $totalCols);
}
static private function patternShapeSpecial3(&$datamatrix, &$assigned, $bits, $totalRows, $totalCols ){
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[0], $totalRows-3, 0, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[1], $totalRows-2, 0, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[2], $totalRows-1, 0, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[3], 0, $totalCols-2, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[4], 0, $totalCols-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[5], 1, $totalCols-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[6], 2, $totalCols-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[7], 3, $totalCols-1, $totalRows, $totalCols);
}
static private function patternShapeSpecial4(&$datamatrix, &$assigned, $bits, $totalRows, $totalCols ){
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[0], $totalRows-1, 0, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[1], $totalRows-1, $totalCols-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[2], 0, $totalCols-3, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[3], 0, $totalCols-2, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[4], 0, $totalCols-1, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[5], 1, $totalCols-3, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[6], 1, $totalCols-2, $totalRows, $totalCols);
self::placeBitInDatamatrix($datamatrix, $assigned, $bits[7], 1, $totalCols-1, $totalRows, $totalCols);
}
static private function placeBitInDatamatrix(&$datamatrix, &$assigned, $bit, $row, $col, $totalRows, $totalCols){ // Put a bit into the matrix
if ($row < 0) {
$row += $totalRows;
$col += 4 - (($totalRows+4)%8);
}
if ($col < 0) {
$col += $totalCols;
$row += 4 - (($totalCols+4)%8);
}
if (!isset($assigned[$row][$col]) || $assigned[$row][$col] != 1) {
$datamatrix[$row][$col] = $bit;
$assigned[$row][$col] = 1;
}
}
static private function addFinderPattern($datamatrix, $rowsRegion, $colsRegion, $rowsRegionCW, $colsRegionCW){ // Add the finder pattern
$totalRowsCW = ($rowsRegionCW+2) * $rowsRegion;
$totalColsCW = ($colsRegionCW+2) * $colsRegion;
$datamatrixTemp = array();
$datamatrixTemp[0] = array_fill(0, $totalColsCW+2, 0);
for ($i=0; $i<$totalRowsCW; $i++){
$datamatrixTemp[$i+1] = array();
$datamatrixTemp[$i+1][0] = 0;
$datamatrixTemp[$i+1][$totalColsCW+1] = 0;
for ($j=0; $j<$totalColsCW; $j++){
if ($i%($rowsRegionCW+2) == 0){
if ($j%2 == 0){
$datamatrixTemp[$i+1][$j+1] = 1;
} else {
$datamatrixTemp[$i+1][$j+1] = 0;
}
} else if ($i%($rowsRegionCW+2) == $rowsRegionCW+1){
$datamatrixTemp[$i+1][$j+1] = 1;
} else if ($j%($colsRegionCW+2) == $colsRegionCW+1){
if ($i%2 == 0){
$datamatrixTemp[$i+1][$j+1] = 0;
} else {
$datamatrixTemp[$i+1][$j+1] = 1;
}
} else if ($j%($colsRegionCW+2) == 0){
$datamatrixTemp[$i+1][$j+1] = 1;
} else{
$datamatrixTemp[$i+1][$j+1] = 0;
$datamatrixTemp[$i+1][$j+1] = $datamatrix[$i-1-(2*(floor($i/($rowsRegionCW+2))))][$j-1-(2*(floor($j/($colsRegionCW+2))))]; // todo : parseInt => ?
}
}
}
$datamatrixTemp[$totalRowsCW+1] = array();
for ($j=0; $j<$totalColsCW+2; $j++){
$datamatrixTemp[$totalRowsCW+1][$j] = 0;
}
return $datamatrixTemp;
}
static public function getDigit($text, $rectangular){
$dataCodeWords = self::encodeDataCodeWordsASCII($text); // Code the text in the ASCII mode
$dataCWCount = count($dataCodeWords);
$index = self::selectIndex($dataCWCount, $rectangular); // Select the index for the data tables
$totalDataCWCount = self::$dataCWCount[$index]; // Number of data CW
$solomonCWCount = self::$solomonCWCount[$index]; // Number of Reed Solomon CW
$totalCWCount = $totalDataCWCount + $solomonCWCount; // Number of CW
$rowsTotal = self::$lengthRows[$index]; // Size of symbol
$colsTotal = self::$lengthCols[$index];
$rowsRegion = self::$regionRows[$index]; // Number of region
$colsRegion = self::$regionCols[$index];
$rowsRegionCW = self::$dataRegionRows[$index];
$colsRegionCW = self::$dataRegionCols[$index];
$rowsLengthMatrice = $rowsTotal-2*$rowsRegion; // Size of matrice data
$colsLengthMatrice = $colsTotal-2*$colsRegion;
$blocks = self::$interleavedBlocks[$index]; // Number of Reed Solomon blocks
$errorBlocks = $solomonCWCount / $blocks;
$dataBlocks = $totalDataCWCount / $blocks;
self::addPadCW($dataCodeWords, $dataCWCount, $totalDataCWCount); // Add codewords pads
$g = self::calculSolFactorTable($errorBlocks); // Calculate correction coefficients
self::addReedSolomonCW($solomonCWCount, $g, $totalDataCWCount, $dataCodeWords, $blocks); // Add Reed Solomon codewords
$codeWordsBits = array(); // Calculte bits from codewords
for ($i=0; $i<$totalCWCount; $i++){
$codeWordsBits[$i] = self::getBits($dataCodeWords[$i]);
}
$datamatrix = array_fill(0, $colsLengthMatrice, array());
$assigned = array_fill(0, $colsLengthMatrice, array());
// Add the bottom-right corner if needed
if ( (($rowsLengthMatrice * $colsLengthMatrice) % 8) == 4) {
$datamatrix[$rowsLengthMatrice-2][$colsLengthMatrice-2] = 1;
$datamatrix[$rowsLengthMatrice-1][$colsLengthMatrice-1] = 1;
$datamatrix[$rowsLengthMatrice-1][$colsLengthMatrice-2] = 0;
$datamatrix[$rowsLengthMatrice-2][$colsLengthMatrice-1] = 0;
$assigned[$rowsLengthMatrice-2][$colsLengthMatrice-2] = 1;
$assigned[$rowsLengthMatrice-1][$colsLengthMatrice-1] = 1;
$assigned[$rowsLengthMatrice-1][$colsLengthMatrice-2] = 1;
$assigned[$rowsLengthMatrice-2][$colsLengthMatrice-1] = 1;
}
// Put the codewords into the matrix
self::next(0,$rowsLengthMatrice,$colsLengthMatrice, $codeWordsBits, $datamatrix, $assigned);
// Add the finder pattern
$datamatrix = self::addFinderPattern($datamatrix, $rowsRegion, $colsRegion, $rowsRegionCW, $colsRegionCW);
return $datamatrix;
}
}
?>