init web ems all
This commit is contained in:
agtuser
64
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/BlockPair.php
vendored
Executable file
64
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/BlockPair.php
vendored
Executable file
@@ -0,0 +1,64 @@
|
||||
<?php
|
||||
/**
|
||||
* BaconQrCode
|
||||
*
|
||||
* @link http://github.com/Bacon/BaconQrCode For the canonical source repository
|
||||
* @copyright 2013 Ben 'DASPRiD' Scholzen
|
||||
* @license http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
|
||||
*/
|
||||
|
||||
namespace BaconQrCode\Encoder;
|
||||
|
||||
use SplFixedArray;
|
||||
|
||||
/**
|
||||
* Block pair.
|
||||
*/
|
||||
class BlockPair
|
||||
{
|
||||
/**
|
||||
* Data bytes in the block.
|
||||
*
|
||||
* @var SplFixedArray
|
||||
*/
|
||||
protected $dataBytes;
|
||||
|
||||
/**
|
||||
* Error correction bytes in the block.
|
||||
*
|
||||
* @var SplFixedArray
|
||||
*/
|
||||
protected $errorCorrectionBytes;
|
||||
|
||||
/**
|
||||
* Creates a new block pair.
|
||||
*
|
||||
* @param SplFixedArray $data
|
||||
* @param SplFixedArray $errorCorrection
|
||||
*/
|
||||
public function __construct(SplFixedArray $data, SplFixedArray $errorCorrection)
|
||||
{
|
||||
$this->dataBytes = $data;
|
||||
$this->errorCorrectionBytes = $errorCorrection;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the data bytes.
|
||||
*
|
||||
* @return SplFixedArray
|
||||
*/
|
||||
public function getDataBytes()
|
||||
{
|
||||
return $this->dataBytes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the error correction bytes.
|
||||
*
|
||||
* @return SplFixedArray
|
||||
*/
|
||||
public function getErrorCorrectionBytes()
|
||||
{
|
||||
return $this->errorCorrectionBytes;
|
||||
}
|
||||
}
|
||||
158
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/ByteMatrix.php
vendored
Executable file
158
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/ByteMatrix.php
vendored
Executable file
@@ -0,0 +1,158 @@
|
||||
<?php
|
||||
/**
|
||||
* BaconQrCode
|
||||
*
|
||||
* @link http://github.com/Bacon/BaconQrCode For the canonical source repository
|
||||
* @copyright 2013 Ben 'DASPRiD' Scholzen
|
||||
* @license http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
|
||||
*/
|
||||
|
||||
namespace BaconQrCode\Encoder;
|
||||
|
||||
use SplFixedArray;
|
||||
|
||||
/**
|
||||
* Byte matrix.
|
||||
*/
|
||||
class ByteMatrix
|
||||
{
|
||||
/**
|
||||
* Bytes in the matrix, represented as array.
|
||||
*
|
||||
* @var SplFixedArray
|
||||
*/
|
||||
protected $bytes;
|
||||
|
||||
/**
|
||||
* Width of the matrix.
|
||||
*
|
||||
* @var integer
|
||||
*/
|
||||
protected $width;
|
||||
|
||||
/**
|
||||
* Height of the matrix.
|
||||
*
|
||||
* @var integer
|
||||
*/
|
||||
protected $height;
|
||||
|
||||
/**
|
||||
* Creates a new byte matrix.
|
||||
*
|
||||
* @param integer $width
|
||||
* @param integer $height
|
||||
*/
|
||||
public function __construct($width, $height)
|
||||
{
|
||||
$this->height = $height;
|
||||
$this->width = $width;
|
||||
$this->bytes = new SplFixedArray($height);
|
||||
|
||||
for ($y = 0; $y < $height; $y++) {
|
||||
$this->bytes[$y] = new SplFixedArray($width);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the width of the matrix.
|
||||
*
|
||||
* @return integer
|
||||
*/
|
||||
public function getWidth()
|
||||
{
|
||||
return $this->width;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the height of the matrix.
|
||||
*
|
||||
* @return integer
|
||||
*/
|
||||
public function getHeight()
|
||||
{
|
||||
return $this->height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the internal representation of the matrix.
|
||||
*
|
||||
* @return SplFixedArray
|
||||
*/
|
||||
public function getArray()
|
||||
{
|
||||
return $this->bytes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the byte for a specific position.
|
||||
*
|
||||
* @param integer $x
|
||||
* @param integer $y
|
||||
* @return integer
|
||||
*/
|
||||
public function get($x, $y)
|
||||
{
|
||||
return $this->bytes[$y][$x];
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the byte for a specific position.
|
||||
*
|
||||
* @param integer $x
|
||||
* @param integer $y
|
||||
* @param integer $value
|
||||
* @return void
|
||||
*/
|
||||
public function set($x, $y, $value)
|
||||
{
|
||||
$this->bytes[$y][$x] = (int) $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the matrix with a specific value.
|
||||
*
|
||||
* @param integer $value
|
||||
* @return void
|
||||
*/
|
||||
public function clear($value)
|
||||
{
|
||||
for ($y = 0; $y < $this->height; $y++) {
|
||||
for ($x = 0; $x < $this->width; $x++) {
|
||||
$this->bytes[$y][$x] = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a string representation of the matrix.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function __toString()
|
||||
{
|
||||
$result = '';
|
||||
|
||||
for ($y = 0; $y < $this->height; $y++) {
|
||||
for ($x = 0; $x < $this->width; $x++) {
|
||||
switch ($this->bytes[$y][$x]) {
|
||||
case 0:
|
||||
$result .= ' 0';
|
||||
break;
|
||||
|
||||
case 1:
|
||||
$result .= ' 1';
|
||||
break;
|
||||
|
||||
default:
|
||||
$result .= ' ';
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
$result .= "\n";
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
687
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/Encoder.php
vendored
Executable file
687
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/Encoder.php
vendored
Executable file
@@ -0,0 +1,687 @@
|
||||
<?php
|
||||
/**
|
||||
* BaconQrCode
|
||||
*
|
||||
* @link http://github.com/Bacon/BaconQrCode For the canonical source repository
|
||||
* @copyright 2013 Ben 'DASPRiD' Scholzen
|
||||
* @license http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
|
||||
*/
|
||||
|
||||
namespace BaconQrCode\Encoder;
|
||||
|
||||
use BaconQrCode\Common\BitArray;
|
||||
use BaconQrCode\Common\CharacterSetEci;
|
||||
use BaconQrCode\Common\ErrorCorrectionLevel;
|
||||
use BaconQrCode\Common\Mode;
|
||||
use BaconQrCode\Common\ReedSolomonCodec;
|
||||
use BaconQrCode\Common\Version;
|
||||
use BaconQrCode\Exception;
|
||||
use SplFixedArray;
|
||||
|
||||
/**
|
||||
* Encoder.
|
||||
*/
|
||||
class Encoder
|
||||
{
|
||||
/**
|
||||
* Default byte encoding.
|
||||
*/
|
||||
const DEFAULT_BYTE_MODE_ECODING = 'ISO-8859-1';
|
||||
|
||||
/**
|
||||
* The original table is defined in the table 5 of JISX0510:2004 (p.19).
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $alphanumericTable = array(
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x00-0x0f
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x10-0x1f
|
||||
36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, // 0x20-0x2f
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, // 0x30-0x3f
|
||||
-1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 0x40-0x4f
|
||||
25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, // 0x50-0x5f
|
||||
);
|
||||
|
||||
/**
|
||||
* Codec cache.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $codecs = array();
|
||||
|
||||
/**
|
||||
* Encodes "content" with the error correction level "ecLevel".
|
||||
*
|
||||
* @param string $content
|
||||
* @param ErrorCorrectionLevel $ecLevel
|
||||
* @param ? $hints
|
||||
* @return QrCode
|
||||
*/
|
||||
public static function encode($content, ErrorCorrectionLevel $ecLevel, $encoding = self::DEFAULT_BYTE_MODE_ECODING)
|
||||
{
|
||||
// Pick an encoding mode appropriate for the content. Note that this
|
||||
// will not attempt to use multiple modes / segments even if that were
|
||||
// more efficient. Would be nice.
|
||||
$mode = self::chooseMode($content, $encoding);
|
||||
|
||||
// This will store the header information, like mode and length, as well
|
||||
// as "header" segments like an ECI segment.
|
||||
$headerBits = new BitArray();
|
||||
|
||||
// Append ECI segment if applicable
|
||||
if ($mode->get() === Mode::BYTE && $encoding !== self::DEFAULT_BYTE_MODE_ECODING) {
|
||||
$eci = CharacterSetEci::getCharacterSetEciByName($encoding);
|
||||
|
||||
if ($eci !== null) {
|
||||
self::appendEci($eci, $headerBits);
|
||||
}
|
||||
}
|
||||
|
||||
// (With ECI in place,) Write the mode marker
|
||||
self::appendModeInfo($mode, $headerBits);
|
||||
|
||||
// Collect data within the main segment, separately, to count its size
|
||||
// if needed. Don't add it to main payload yet.
|
||||
$dataBits = new BitArray();
|
||||
self::appendBytes($content, $mode, $dataBits, $encoding);
|
||||
|
||||
// Hard part: need to know version to know how many bits length takes.
|
||||
// But need to know how many bits it takes to know version. First we
|
||||
// take a guess at version by assuming version will be the minimum, 1:
|
||||
$provisionalBitsNeeded = $headerBits->getSize()
|
||||
+ $mode->getCharacterCountBits(Version::getVersionForNumber(1))
|
||||
+ $dataBits->getSize();
|
||||
$provisionalVersion = self::chooseVersion($provisionalBitsNeeded, $ecLevel);
|
||||
|
||||
// Use that guess to calculate the right version. I am still not sure
|
||||
// this works in 100% of cases.
|
||||
$bitsNeeded = $headerBits->getSize()
|
||||
+ $mode->getCharacterCountBits($provisionalVersion)
|
||||
+ $dataBits->getSize();
|
||||
$version = self::chooseVersion($bitsNeeded, $ecLevel);
|
||||
|
||||
$headerAndDataBits = new BitArray();
|
||||
$headerAndDataBits->appendBitArray($headerBits);
|
||||
|
||||
// Find "length" of main segment and write it.
|
||||
$numLetters = ($mode->get() === Mode::BYTE ? $dataBits->getSizeInBytes() : strlen($content));
|
||||
self::appendLengthInfo($numLetters, $version, $mode, $headerAndDataBits);
|
||||
|
||||
// Put data together into the overall payload.
|
||||
$headerAndDataBits->appendBitArray($dataBits);
|
||||
$ecBlocks = $version->getEcBlocksForLevel($ecLevel);
|
||||
$numDataBytes = $version->getTotalCodewords() - $ecBlocks->getTotalEcCodewords();
|
||||
|
||||
// Terminate the bits properly.
|
||||
self::terminateBits($numDataBytes, $headerAndDataBits);
|
||||
|
||||
// Interleave data bits with error correction code.
|
||||
$finalBits = self::interleaveWithEcBytes(
|
||||
$headerAndDataBits,
|
||||
$version->getTotalCodewords(),
|
||||
$numDataBytes,
|
||||
$ecBlocks->getNumBlocks()
|
||||
);
|
||||
|
||||
$qrCode = new QrCode();
|
||||
$qrCode->setErrorCorrectionLevel($ecLevel);
|
||||
$qrCode->setMode($mode);
|
||||
$qrCode->setVersion($version);
|
||||
|
||||
// Choose the mask pattern and set to "qrCode".
|
||||
$dimension = $version->getDimensionForVersion();
|
||||
$matrix = new ByteMatrix($dimension, $dimension);
|
||||
$maskPattern = self::chooseMaskPattern($finalBits, $ecLevel, $version, $matrix);
|
||||
$qrCode->setMaskPattern($maskPattern);
|
||||
|
||||
// Build the matrix and set it to "qrCode".
|
||||
MatrixUtil::buildMatrix($finalBits, $ecLevel, $version, $maskPattern, $matrix);
|
||||
$qrCode->setMatrix($matrix);
|
||||
|
||||
return $qrCode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the alphanumeric code for a byte.
|
||||
*
|
||||
* @param string|integer $code
|
||||
* @return integer
|
||||
*/
|
||||
protected static function getAlphanumericCode($code)
|
||||
{
|
||||
$code = (is_string($code) ? ord($code) : $code);
|
||||
|
||||
if (isset(self::$alphanumericTable[$code])) {
|
||||
return self::$alphanumericTable[$code];
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Chooses the best mode for a given content.
|
||||
*
|
||||
* @param string $content
|
||||
* @param string $encoding
|
||||
* @return Mode
|
||||
*/
|
||||
protected static function chooseMode($content, $encoding = null)
|
||||
{
|
||||
if (strcasecmp($encoding, 'SHIFT-JIS') === 0) {
|
||||
return self::isOnlyDoubleByteKanji($content) ? new Mode(Mode::KANJI) : new Mode(Mode::BYTE);
|
||||
}
|
||||
|
||||
$hasNumeric = false;
|
||||
$hasAlphanumeric = false;
|
||||
$contentLength = strlen($content);
|
||||
|
||||
for ($i = 0; $i < $contentLength; $i++) {
|
||||
$char = $content[$i];
|
||||
|
||||
if (ctype_digit($char)) {
|
||||
$hasNumeric = true;
|
||||
} elseif (self::getAlphanumericCode($char) !== -1) {
|
||||
$hasAlphanumeric = true;
|
||||
} else {
|
||||
return new Mode(Mode::BYTE);
|
||||
}
|
||||
}
|
||||
|
||||
if ($hasAlphanumeric) {
|
||||
return new Mode(Mode::ALPHANUMERIC);
|
||||
} elseif ($hasNumeric) {
|
||||
return new Mode(Mode::NUMERIC);
|
||||
}
|
||||
|
||||
return new Mode(Mode::BYTE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the mask penalty for a matrix.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return integer
|
||||
*/
|
||||
protected static function calculateMaskPenalty(ByteMatrix $matrix)
|
||||
{
|
||||
return (
|
||||
MaskUtil::applyMaskPenaltyRule1($matrix)
|
||||
+ MaskUtil::applyMaskPenaltyRule2($matrix)
|
||||
+ MaskUtil::applyMaskPenaltyRule3($matrix)
|
||||
+ MaskUtil::applyMaskPenaltyRule4($matrix)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Chooses the best mask pattern for a matrix.
|
||||
*
|
||||
* @param BitArray $bits
|
||||
* @param ErrorCorrectionLevel $ecLevel
|
||||
* @param Version $version
|
||||
* @param ByteMatrix $matrix
|
||||
* @return integer
|
||||
*/
|
||||
protected static function chooseMaskPattern(
|
||||
BitArray $bits,
|
||||
ErrorCorrectionLevel $ecLevel,
|
||||
Version $version,
|
||||
ByteMatrix $matrix
|
||||
) {
|
||||
$minPenality = PHP_INT_MAX;
|
||||
$bestMaskPattern = -1;
|
||||
|
||||
for ($maskPattern = 0; $maskPattern < QrCode::NUM_MASK_PATTERNS; $maskPattern++) {
|
||||
MatrixUtil::buildMatrix($bits, $ecLevel, $version, $maskPattern, $matrix);
|
||||
$penalty = self::calculateMaskPenalty($matrix);
|
||||
|
||||
if ($penalty < $minPenality) {
|
||||
$minPenality = $penalty;
|
||||
$bestMaskPattern = $maskPattern;
|
||||
}
|
||||
}
|
||||
|
||||
return $bestMaskPattern;
|
||||
}
|
||||
|
||||
/**
|
||||
* Chooses the best version for the input.
|
||||
*
|
||||
* @param integer $numInputBits
|
||||
* @param ErrorCorrectionLevel $ecLevel
|
||||
* @return Version
|
||||
* @throws Exception\WriterException
|
||||
*/
|
||||
protected static function chooseVersion($numInputBits, ErrorCorrectionLevel $ecLevel)
|
||||
{
|
||||
for ($versionNum = 1; $versionNum <= 40; $versionNum++) {
|
||||
$version = Version::getVersionForNumber($versionNum);
|
||||
$numBytes = $version->getTotalCodewords();
|
||||
|
||||
$ecBlocks = $version->getEcBlocksForLevel($ecLevel);
|
||||
$numEcBytes = $ecBlocks->getTotalEcCodewords();
|
||||
|
||||
$numDataBytes = $numBytes - $numEcBytes;
|
||||
$totalInputBytes = intval(($numInputBits + 8) / 8);
|
||||
|
||||
if ($numDataBytes >= $totalInputBytes) {
|
||||
return $version;
|
||||
}
|
||||
}
|
||||
|
||||
throw new Exception\WriterException('Data too big');
|
||||
}
|
||||
|
||||
/**
|
||||
* Terminates the bits in a bit array.
|
||||
*
|
||||
* @param integer $numDataBytes
|
||||
* @param BitArray $bits
|
||||
* @throws Exception\WriterException
|
||||
*/
|
||||
protected static function terminateBits($numDataBytes, BitArray $bits)
|
||||
{
|
||||
$capacity = $numDataBytes << 3;
|
||||
|
||||
if ($bits->getSize() > $capacity) {
|
||||
throw new Exception\WriterException('Data bits cannot fit in the QR code');
|
||||
}
|
||||
|
||||
for ($i = 0; $i < 4 && $bits->getSize() < $capacity; $i++) {
|
||||
$bits->appendBit(false);
|
||||
}
|
||||
|
||||
$numBitsInLastByte = $bits->getSize() & 0x7;
|
||||
|
||||
if ($numBitsInLastByte > 0) {
|
||||
for ($i = $numBitsInLastByte; $i < 8; $i++) {
|
||||
$bits->appendBit(false);
|
||||
}
|
||||
}
|
||||
|
||||
$numPaddingBytes = $numDataBytes - $bits->getSizeInBytes();
|
||||
|
||||
for ($i = 0; $i < $numPaddingBytes; $i++) {
|
||||
$bits->appendBits(($i & 0x1) === 0 ? 0xec : 0x11, 8);
|
||||
}
|
||||
|
||||
if ($bits->getSize() !== $capacity) {
|
||||
throw new Exception\WriterException('Bits size does not equal capacity');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets number of data- and EC bytes for a block ID.
|
||||
*
|
||||
* @param integer $numTotalBytes
|
||||
* @param integer $numDataBytes
|
||||
* @param integer $numRsBlocks
|
||||
* @param integer $blockId
|
||||
* @return array
|
||||
* @throws Exception\WriterException
|
||||
*/
|
||||
protected static function getNumDataBytesAndNumEcBytesForBlockId(
|
||||
$numTotalBytes,
|
||||
$numDataBytes,
|
||||
$numRsBlocks,
|
||||
$blockId
|
||||
) {
|
||||
if ($blockId >= $numRsBlocks) {
|
||||
throw new Exception\WriterException('Block ID too large');
|
||||
}
|
||||
|
||||
$numRsBlocksInGroup2 = $numTotalBytes % $numRsBlocks;
|
||||
$numRsBlocksInGroup1 = $numRsBlocks - $numRsBlocksInGroup2;
|
||||
$numTotalBytesInGroup1 = intval($numTotalBytes / $numRsBlocks);
|
||||
$numTotalBytesInGroup2 = $numTotalBytesInGroup1 + 1;
|
||||
$numDataBytesInGroup1 = intval($numDataBytes / $numRsBlocks);
|
||||
$numDataBytesInGroup2 = $numDataBytesInGroup1 + 1;
|
||||
$numEcBytesInGroup1 = $numTotalBytesInGroup1 - $numDataBytesInGroup1;
|
||||
$numEcBytesInGroup2 = $numTotalBytesInGroup2 - $numDataBytesInGroup2;
|
||||
|
||||
if ($numEcBytesInGroup1 !== $numEcBytesInGroup2) {
|
||||
throw new Exception\WriterException('EC bytes mismatch');
|
||||
}
|
||||
|
||||
if ($numRsBlocks !== $numRsBlocksInGroup1 + $numRsBlocksInGroup2) {
|
||||
throw new Exception\WriterException('RS blocks mismatch');
|
||||
}
|
||||
|
||||
if ($numTotalBytes !==
|
||||
(($numDataBytesInGroup1 + $numEcBytesInGroup1) * $numRsBlocksInGroup1)
|
||||
+ (($numDataBytesInGroup2 + $numEcBytesInGroup2) * $numRsBlocksInGroup2)
|
||||
) {
|
||||
throw new Exception\WriterException('Total bytes mismatch');
|
||||
}
|
||||
|
||||
if ($blockId < $numRsBlocksInGroup1) {
|
||||
return array($numDataBytesInGroup1, $numEcBytesInGroup1);
|
||||
} else {
|
||||
return array($numDataBytesInGroup2, $numEcBytesInGroup2);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Interleaves data with EC bytes.
|
||||
*
|
||||
* @param BitArray $bits
|
||||
* @param integer $numTotalBytes
|
||||
* @param integer $numDataBytes
|
||||
* @param integer $numRsBlocks
|
||||
* @return BitArray
|
||||
* @throws Exception\WriterException
|
||||
*/
|
||||
protected static function interleaveWithEcBytes(BitArray $bits, $numTotalBytes, $numDataBytes, $numRsBlocks)
|
||||
{
|
||||
if ($bits->getSizeInBytes() !== $numDataBytes) {
|
||||
throw new Exception\WriterException('Number of bits and data bytes does not match');
|
||||
}
|
||||
|
||||
$dataBytesOffset = 0;
|
||||
$maxNumDataBytes = 0;
|
||||
$maxNumEcBytes = 0;
|
||||
|
||||
$blocks = new SplFixedArray($numRsBlocks);
|
||||
|
||||
for ($i = 0; $i < $numRsBlocks; $i++) {
|
||||
list($numDataBytesInBlock, $numEcBytesInBlock) = self::getNumDataBytesAndNumEcBytesForBlockId(
|
||||
$numTotalBytes,
|
||||
$numDataBytes,
|
||||
$numRsBlocks,
|
||||
$i
|
||||
);
|
||||
|
||||
$size = $numDataBytesInBlock;
|
||||
$dataBytes = $bits->toBytes(8 * $dataBytesOffset, $size);
|
||||
$ecBytes = self::generateEcBytes($dataBytes, $numEcBytesInBlock);
|
||||
$blocks[$i] = new BlockPair($dataBytes, $ecBytes);
|
||||
|
||||
$maxNumDataBytes = max($maxNumDataBytes, $size);
|
||||
$maxNumEcBytes = max($maxNumEcBytes, count($ecBytes));
|
||||
$dataBytesOffset += $numDataBytesInBlock;
|
||||
}
|
||||
|
||||
if ($numDataBytes !== $dataBytesOffset) {
|
||||
throw new Exception\WriterException('Data bytes does not match offset');
|
||||
}
|
||||
|
||||
$result = new BitArray();
|
||||
|
||||
for ($i = 0; $i < $maxNumDataBytes; $i++) {
|
||||
foreach ($blocks as $block) {
|
||||
$dataBytes = $block->getDataBytes();
|
||||
|
||||
if ($i < count($dataBytes)) {
|
||||
$result->appendBits($dataBytes[$i], 8);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for ($i = 0; $i < $maxNumEcBytes; $i++) {
|
||||
foreach ($blocks as $block) {
|
||||
$ecBytes = $block->getErrorCorrectionBytes();
|
||||
|
||||
if ($i < count($ecBytes)) {
|
||||
$result->appendBits($ecBytes[$i], 8);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($numTotalBytes !== $result->getSizeInBytes()) {
|
||||
throw new Exception\WriterException('Interleaving error: ' . $numTotalBytes . ' and ' . $result->getSizeInBytes() . ' differ');
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates EC bytes for given data.
|
||||
*
|
||||
* @param SplFixedArray $dataBytes
|
||||
* @param integer $numEcBytesInBlock
|
||||
* @return SplFixedArray
|
||||
*/
|
||||
protected static function generateEcBytes(SplFixedArray $dataBytes, $numEcBytesInBlock)
|
||||
{
|
||||
$numDataBytes = count($dataBytes);
|
||||
$toEncode = new SplFixedArray($numDataBytes + $numEcBytesInBlock);
|
||||
|
||||
for ($i = 0; $i < $numDataBytes; $i++) {
|
||||
$toEncode[$i] = $dataBytes[$i] & 0xff;
|
||||
}
|
||||
|
||||
$ecBytes = new SplFixedArray($numEcBytesInBlock);
|
||||
$codec = self::getCodec($numDataBytes, $numEcBytesInBlock);
|
||||
$codec->encode($toEncode, $ecBytes);
|
||||
|
||||
return $ecBytes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets an RS codec and caches it.
|
||||
*
|
||||
* @param integer $numDataBytes
|
||||
* @param integer $numEcBytesInBlock
|
||||
* @return ReedSolomonCodec
|
||||
*/
|
||||
protected static function getCodec($numDataBytes, $numEcBytesInBlock)
|
||||
{
|
||||
$cacheId = $numDataBytes . '-' . $numEcBytesInBlock;
|
||||
|
||||
if (!isset(self::$codecs[$cacheId])) {
|
||||
self::$codecs[$cacheId] = new ReedSolomonCodec(
|
||||
8,
|
||||
0x11d,
|
||||
0,
|
||||
1,
|
||||
$numEcBytesInBlock,
|
||||
255 - $numDataBytes - $numEcBytesInBlock
|
||||
);
|
||||
}
|
||||
|
||||
return self::$codecs[$cacheId];
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends mode information to a bit array.
|
||||
*
|
||||
* @param Mode $mode
|
||||
* @param BitArray $bits
|
||||
* @return void
|
||||
*/
|
||||
protected static function appendModeInfo(Mode $mode, BitArray $bits)
|
||||
{
|
||||
$bits->appendBits($mode->get(), 4);
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends length information to a bit array.
|
||||
*
|
||||
* @param integer $numLetters
|
||||
* @param Version $version
|
||||
* @param Mode $mode
|
||||
* @param BitArray $bits
|
||||
* @return void
|
||||
* @throws Exception\WriterException
|
||||
*/
|
||||
protected static function appendLengthInfo($numLetters, Version $version, Mode $mode, BitArray $bits)
|
||||
{
|
||||
$numBits = $mode->getCharacterCountBits($version);
|
||||
|
||||
if ($numLetters >= (1 << $numBits)) {
|
||||
throw new Exception\WriterException($numLetters . ' is bigger than ' . ((1 << $numBits) - 1));
|
||||
}
|
||||
|
||||
$bits->appendBits($numLetters, $numBits);
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends bytes to a bit array in a specific mode.
|
||||
*
|
||||
* @param stirng $content
|
||||
* @param Mode $mode
|
||||
* @param BitArray $bits
|
||||
* @param string $encoding
|
||||
* @return void
|
||||
* @throws Exception\WriterException
|
||||
*/
|
||||
protected static function appendBytes($content, Mode $mode, BitArray $bits, $encoding)
|
||||
{
|
||||
switch ($mode->get()) {
|
||||
case Mode::NUMERIC:
|
||||
self::appendNumericBytes($content, $bits);
|
||||
break;
|
||||
|
||||
case Mode::ALPHANUMERIC:
|
||||
self::appendAlphanumericBytes($content, $bits);
|
||||
break;
|
||||
|
||||
case Mode::BYTE:
|
||||
self::append8BitBytes($content, $bits, $encoding);
|
||||
break;
|
||||
|
||||
case Mode::KANJI:
|
||||
self::appendKanjiBytes($content, $bits);
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new Exception\WriterException('Invalid mode: ' . $mode->get());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends numeric bytes to a bit array.
|
||||
*
|
||||
* @param string $content
|
||||
* @param BitArray $bits
|
||||
* @return void
|
||||
*/
|
||||
protected static function appendNumericBytes($content, BitArray $bits)
|
||||
{
|
||||
$length = strlen($content);
|
||||
$i = 0;
|
||||
|
||||
while ($i < $length) {
|
||||
$num1 = (int) $content[$i];
|
||||
|
||||
if ($i + 2 < $length) {
|
||||
// Encode three numeric letters in ten bits.
|
||||
$num2 = (int) $content[$i + 1];
|
||||
$num3 = (int) $content[$i + 2];
|
||||
$bits->appendBits($num1 * 100 + $num2 * 10 + $num3, 10);
|
||||
$i += 3;
|
||||
} elseif ($i + 1 < $length) {
|
||||
// Encode two numeric letters in seven bits.
|
||||
$num2 = (int) $content[$i + 1];
|
||||
$bits->appendBits($num1 * 10 + $num2, 7);
|
||||
$i += 2;
|
||||
} else {
|
||||
// Encode one numeric letter in four bits.
|
||||
$bits->appendBits($num1, 4);
|
||||
$i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends alpha-numeric bytes to a bit array.
|
||||
*
|
||||
* @param string $content
|
||||
* @param BitArray $bits
|
||||
* @return void
|
||||
*/
|
||||
protected static function appendAlphanumericBytes($content, BitArray $bits)
|
||||
{
|
||||
$length = strlen($content);
|
||||
$i = 0;
|
||||
|
||||
while ($i < $length) {
|
||||
if (-1 === ($code1 = self::getAlphanumericCode($content[$i]))) {
|
||||
throw new Exception\WriterException('Invalid alphanumeric code');
|
||||
}
|
||||
|
||||
if ($i + 1 < $length) {
|
||||
if (-1 === ($code2 = self::getAlphanumericCode($content[$i + 1]))) {
|
||||
throw new Exception\WriterException('Invalid alphanumeric code');
|
||||
}
|
||||
|
||||
// Encode two alphanumeric letters in 11 bits.
|
||||
$bits->appendBits($code1 * 45 + $code2, 11);
|
||||
$i += 2;
|
||||
} else {
|
||||
// Encode one alphanumeric letter in six bits.
|
||||
$bits->appendBits($code1, 6);
|
||||
$i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends regular 8-bit bytes to a bit array.
|
||||
*
|
||||
* @param string $content
|
||||
* @param BitArray $bits
|
||||
* @return void
|
||||
*/
|
||||
protected static function append8BitBytes($content, BitArray $bits, $encoding)
|
||||
{
|
||||
if (false === ($bytes = @iconv('utf-8', $encoding, $content))) {
|
||||
throw new Exception\WriterException('Could not encode content to ' . $encoding);
|
||||
}
|
||||
|
||||
$length = strlen($bytes);
|
||||
|
||||
for ($i = 0; $i < $length; $i++) {
|
||||
$bits->appendBits(ord($bytes[$i]), 8);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends KANJI bytes to a bit array.
|
||||
*
|
||||
* @param string $content
|
||||
* @param BitArray $bits
|
||||
* @return void
|
||||
*/
|
||||
protected static function appendKanjiBytes($content, BitArray $bits)
|
||||
{
|
||||
if (strlen($content) % 2 > 0) {
|
||||
// We just do a simple length check here. The for loop will check
|
||||
// individual characters.
|
||||
throw new Exception\WriterException('Content does not seem to be encoded in SHIFT-JIS');
|
||||
}
|
||||
|
||||
$length = strlen($content);
|
||||
|
||||
for ($i = 0; $i < $length; $i += 2) {
|
||||
$byte1 = ord($content[$i]) & 0xff;
|
||||
$byte2 = ord($content[$i + 1]) & 0xff;
|
||||
$code = ($byte1 << 8) | $byte2;
|
||||
|
||||
if ($code >= 0x8140 && $code <= 0x9ffc) {
|
||||
$subtracted = $code - 0x8140;
|
||||
} elseif ($code >= 0xe040 && $code <= 0xebbf) {
|
||||
$subtracted = $code - 0xc140;
|
||||
} else {
|
||||
throw new Exception\WriterException('Invalid byte sequence');
|
||||
}
|
||||
|
||||
$encoded = (($subtracted >> 8) * 0xc0) + ($subtracted & 0xff);
|
||||
|
||||
$bits->appendBits($encoded, 13);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends ECI information to a bit array.
|
||||
*
|
||||
* @param CharacterSetEci $eci
|
||||
* @param BitArray $bits
|
||||
* @return void
|
||||
*/
|
||||
protected static function appendEci(CharacterSetEci $eci, BitArray $bits)
|
||||
{
|
||||
$mode = new Mode(Mode::ECI);
|
||||
$bits->appendBits($mode->get(), 4);
|
||||
$bits->appendBits($eci->get(), 8);
|
||||
}
|
||||
}
|
||||
291
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/MaskUtil.php
vendored
Executable file
291
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/MaskUtil.php
vendored
Executable file
@@ -0,0 +1,291 @@
|
||||
<?php
|
||||
/**
|
||||
* BaconQrCode
|
||||
*
|
||||
* @link http://github.com/Bacon/BaconQrCode For the canonical source repository
|
||||
* @copyright 2013 Ben 'DASPRiD' Scholzen
|
||||
* @license http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
|
||||
*/
|
||||
|
||||
namespace BaconQrCode\Encoder;
|
||||
|
||||
use BaconQrCode\Common\BitUtils;
|
||||
|
||||
/**
|
||||
* Mask utility.
|
||||
*/
|
||||
class MaskUtil
|
||||
{
|
||||
/**#@+
|
||||
* Penalty weights from section 6.8.2.1
|
||||
*/
|
||||
const N1 = 3;
|
||||
const N2 = 3;
|
||||
const N3 = 40;
|
||||
const N4 = 10;
|
||||
/**#@-*/
|
||||
|
||||
/**
|
||||
* Applies mask penalty rule 1 and returns the penalty.
|
||||
*
|
||||
* Finds repetitive cells with the same color and gives penalty to them.
|
||||
* Example: 00000 or 11111.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return integer
|
||||
*/
|
||||
public static function applyMaskPenaltyRule1(ByteMatrix $matrix)
|
||||
{
|
||||
return (
|
||||
self::applyMaskPenaltyRule1Internal($matrix, true)
|
||||
+ self::applyMaskPenaltyRule1Internal($matrix, false)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies mask penalty rule 2 and returns the penalty.
|
||||
*
|
||||
* Finds 2x2 blocks with the same color and gives penalty to them. This is
|
||||
* actually equivalent to the spec's rule, which is to find MxN blocks and
|
||||
* give a penalty proportional to (M-1)x(N-1), because this is the number of
|
||||
* 2x2 blocks inside such a block.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return integer
|
||||
*/
|
||||
public static function applyMaskPenaltyRule2(ByteMatrix $matrix)
|
||||
{
|
||||
$penalty = 0;
|
||||
$array = $matrix->getArray();
|
||||
$width = $matrix->getWidth();
|
||||
$height = $matrix->getHeight();
|
||||
|
||||
for ($y = 0; $y < $height - 1; $y++) {
|
||||
for ($x = 0; $x < $width - 1; $x++) {
|
||||
$value = $array[$y][$x];
|
||||
|
||||
if ($value === $array[$y][$x + 1] && $value === $array[$y + 1][$x] && $value === $array[$y + 1][$x + 1]) {
|
||||
$penalty++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return self::N2 * $penalty;
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies mask penalty rule 3 and returns the penalty.
|
||||
*
|
||||
* Finds consecutive cells of 00001011101 or 10111010000, and gives penalty
|
||||
* to them. If we find patterns like 000010111010000, we give penalties
|
||||
* twice (i.e. 40 * 2).
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return integer
|
||||
*/
|
||||
public static function applyMaskPenaltyRule3(ByteMatrix $matrix)
|
||||
{
|
||||
$penalty = 0;
|
||||
$array = $matrix->getArray();
|
||||
$width = $matrix->getWidth();
|
||||
$height = $matrix->getHeight();
|
||||
|
||||
for ($y = 0; $y < $height; $y++) {
|
||||
for ($x = 0; $x < $width; $x++) {
|
||||
if (
|
||||
$x + 6 < $width
|
||||
&& $array[$y][$x] === 1
|
||||
&& $array[$y][$x + 1] === 0
|
||||
&& $array[$y][$x + 2] === 1
|
||||
&& $array[$y][$x + 3] === 1
|
||||
&& $array[$y][$x + 4] === 1
|
||||
&& $array[$y][$x + 5] === 0
|
||||
&& $array[$y][$x + 6] === 1
|
||||
&& (
|
||||
(
|
||||
$x + 10 < $width
|
||||
&& $array[$y][$x + 7] === 0
|
||||
&& $array[$y][$x + 8] === 0
|
||||
&& $array[$y][$x + 9] === 0
|
||||
&& $array[$y][$x + 10] === 0
|
||||
)
|
||||
|| (
|
||||
$x - 4 >= 0
|
||||
&& $array[$y][$x - 1] === 0
|
||||
&& $array[$y][$x - 2] === 0
|
||||
&& $array[$y][$x - 3] === 0
|
||||
&& $array[$y][$x - 4] === 0
|
||||
)
|
||||
)
|
||||
) {
|
||||
$penalty += self::N3;
|
||||
}
|
||||
|
||||
if (
|
||||
$y + 6 < $height
|
||||
&& $array[$y][$x] === 1
|
||||
&& $array[$y + 1][$x] === 0
|
||||
&& $array[$y + 2][$x] === 1
|
||||
&& $array[$y + 3][$x] === 1
|
||||
&& $array[$y + 4][$x] === 1
|
||||
&& $array[$y + 5][$x] === 0
|
||||
&& $array[$y + 6][$x] === 1
|
||||
&& (
|
||||
(
|
||||
$y + 10 < $height
|
||||
&& $array[$y + 7][$x] === 0
|
||||
&& $array[$y + 8][$x] === 0
|
||||
&& $array[$y + 9][$x] === 0
|
||||
&& $array[$y + 10][$x] === 0
|
||||
)
|
||||
|| (
|
||||
$y - 4 >= 0
|
||||
&& $array[$y - 1][$x] === 0
|
||||
&& $array[$y - 2][$x] === 0
|
||||
&& $array[$y - 3][$x] === 0
|
||||
&& $array[$y - 4][$x] === 0
|
||||
)
|
||||
)
|
||||
) {
|
||||
$penalty += self::N3;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $penalty;
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies mask penalty rule 4 and returns the penalty.
|
||||
*
|
||||
* Calculates the ratio of dark cells and gives penalty if the ratio is far
|
||||
* from 50%. It gives 10 penalty for 5% distance.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return integer
|
||||
*/
|
||||
public static function applyMaskPenaltyRule4(ByteMatrix $matrix)
|
||||
{
|
||||
$numDarkCells = 0;
|
||||
|
||||
$array = $matrix->getArray();
|
||||
$width = $matrix->getWidth();
|
||||
$height = $matrix->getHeight();
|
||||
|
||||
for ($y = 0; $y < $height; $y++) {
|
||||
$arrayY = $array[$y];
|
||||
|
||||
for ($x = 0; $x < $width; $x++) {
|
||||
if ($arrayY[$x] === 1) {
|
||||
$numDarkCells++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$numTotalCells = $height * $width;
|
||||
$darkRatio = $numDarkCells / $numTotalCells;
|
||||
$fixedPercentVariances = (int) (abs($darkRatio - 0.5) * 20);
|
||||
|
||||
return $fixedPercentVariances * self::N4;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the mask bit for "getMaskPattern" at "x" and "y".
|
||||
*
|
||||
* See 8.8 of JISX0510:2004 for mask pattern conditions.
|
||||
*
|
||||
* @param integer $maskPattern
|
||||
* @param integer $x
|
||||
* @param integer $y
|
||||
* @return integer
|
||||
* @throws Exception\InvalidArgumentException
|
||||
*/
|
||||
public static function getDataMaskBit($maskPattern, $x, $y)
|
||||
{
|
||||
switch ($maskPattern) {
|
||||
case 0:
|
||||
$intermediate = ($y + $x) & 0x1;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
$intermediate = $y & 0x1;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
$intermediate = $x % 3;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
$intermediate = ($y + $x) % 3;
|
||||
break;
|
||||
|
||||
case 4:
|
||||
$intermediate = (BitUtils::unsignedRightShift($y, 1) + ($x / 3)) & 0x1;
|
||||
break;
|
||||
|
||||
case 5:
|
||||
$temp = $y * $x;
|
||||
$intermediate = ($temp & 0x1) + ($temp % 3);
|
||||
break;
|
||||
|
||||
case 6:
|
||||
$temp = $y * $x;
|
||||
$intermediate = (($temp & 0x1) + ($temp % 3)) & 0x1;
|
||||
break;
|
||||
|
||||
case 7:
|
||||
$temp = $y * $x;
|
||||
$intermediate = (($temp % 3) + (($y + $x) & 0x1)) & 0x1;
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new Exception\InvalidArgumentException('Invalid mask pattern: ' . $maskPattern);
|
||||
}
|
||||
|
||||
return $intermediate === 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function for applyMaskPenaltyRule1.
|
||||
*
|
||||
* We need this for doing this calculation in both vertical and horizontal
|
||||
* orders respectively.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @param boolean $isHorizontal
|
||||
* @return integer
|
||||
*/
|
||||
protected static function applyMaskPenaltyRule1Internal(ByteMatrix $matrix, $isHorizontal)
|
||||
{
|
||||
$penalty = 0;
|
||||
$iLimit = $isHorizontal ? $matrix->getHeight() : $matrix->getWidth();
|
||||
$jLimit = $isHorizontal ? $matrix->getWidth() : $matrix->getHeight();
|
||||
$array = $matrix->getArray();
|
||||
|
||||
for ($i = 0; $i < $iLimit; $i++) {
|
||||
$numSameBitCells = 0;
|
||||
$prevBit = -1;
|
||||
|
||||
for ($j = 0; $j < $jLimit; $j++) {
|
||||
$bit = $isHorizontal ? $array[$i][$j] : $array[$j][$i];
|
||||
|
||||
if ($bit === $prevBit) {
|
||||
$numSameBitCells++;
|
||||
} else {
|
||||
if ($numSameBitCells >= 5) {
|
||||
$penalty += self::N1 + ($numSameBitCells - 5);
|
||||
}
|
||||
|
||||
$numSameBitCells = 1;
|
||||
$prevBit = $bit;
|
||||
}
|
||||
}
|
||||
|
||||
if ($numSameBitCells >= 5) {
|
||||
$penalty += self::N1 + ($numSameBitCells - 5);
|
||||
}
|
||||
}
|
||||
|
||||
return $penalty;
|
||||
}
|
||||
}
|
||||
580
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/MatrixUtil.php
vendored
Executable file
580
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/MatrixUtil.php
vendored
Executable file
@@ -0,0 +1,580 @@
|
||||
<?php
|
||||
/**
|
||||
* BaconQrCode
|
||||
*
|
||||
* @link http://github.com/Bacon/BaconQrCode For the canonical source repository
|
||||
* @copyright 2013 Ben 'DASPRiD' Scholzen
|
||||
* @license http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
|
||||
*/
|
||||
|
||||
namespace BaconQrCode\Encoder;
|
||||
|
||||
use BaconQrCode\Common\BitArray;
|
||||
use BaconQrCode\Common\ErrorCorrectionLevel;
|
||||
use BaconQrCode\Common\Version;
|
||||
use BaconQrCode\Exception;
|
||||
|
||||
/**
|
||||
* Matrix utility.
|
||||
*/
|
||||
class MatrixUtil
|
||||
{
|
||||
/**
|
||||
* Position detection pattern.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $positionDetectionPattern = array(
|
||||
array(1, 1, 1, 1, 1, 1, 1),
|
||||
array(1, 0, 0, 0, 0, 0, 1),
|
||||
array(1, 0, 1, 1, 1, 0, 1),
|
||||
array(1, 0, 1, 1, 1, 0, 1),
|
||||
array(1, 0, 1, 1, 1, 0, 1),
|
||||
array(1, 0, 0, 0, 0, 0, 1),
|
||||
array(1, 1, 1, 1, 1, 1, 1),
|
||||
);
|
||||
|
||||
/**
|
||||
* Position adjustment pattern.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $positionAdjustmentPattern = array(
|
||||
array(1, 1, 1, 1, 1),
|
||||
array(1, 0, 0, 0, 1),
|
||||
array(1, 0, 1, 0, 1),
|
||||
array(1, 0, 0, 0, 1),
|
||||
array(1, 1, 1, 1, 1),
|
||||
);
|
||||
|
||||
/**
|
||||
* Coordinates for position adjustment patterns for each version.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $positionAdjustmentPatternCoordinateTable = array(
|
||||
array(null, null, null, null, null, null, null), // Version 1
|
||||
array( 6, 18, null, null, null, null, null), // Version 2
|
||||
array( 6, 22, null, null, null, null, null), // Version 3
|
||||
array( 6, 26, null, null, null, null, null), // Version 4
|
||||
array( 6, 30, null, null, null, null, null), // Version 5
|
||||
array( 6, 34, null, null, null, null, null), // Version 6
|
||||
array( 6, 22, 38, null, null, null, null), // Version 7
|
||||
array( 6, 24, 42, null, null, null, null), // Version 8
|
||||
array( 6, 26, 46, null, null, null, null), // Version 9
|
||||
array( 6, 28, 50, null, null, null, null), // Version 10
|
||||
array( 6, 30, 54, null, null, null, null), // Version 11
|
||||
array( 6, 32, 58, null, null, null, null), // Version 12
|
||||
array( 6, 34, 62, null, null, null, null), // Version 13
|
||||
array( 6, 26, 46, 66, null, null, null), // Version 14
|
||||
array( 6, 26, 48, 70, null, null, null), // Version 15
|
||||
array( 6, 26, 50, 74, null, null, null), // Version 16
|
||||
array( 6, 30, 54, 78, null, null, null), // Version 17
|
||||
array( 6, 30, 56, 82, null, null, null), // Version 18
|
||||
array( 6, 30, 58, 86, null, null, null), // Version 19
|
||||
array( 6, 34, 62, 90, null, null, null), // Version 20
|
||||
array( 6, 28, 50, 72, 94, null, null), // Version 21
|
||||
array( 6, 26, 50, 74, 98, null, null), // Version 22
|
||||
array( 6, 30, 54, 78, 102, null, null), // Version 23
|
||||
array( 6, 28, 54, 80, 106, null, null), // Version 24
|
||||
array( 6, 32, 58, 84, 110, null, null), // Version 25
|
||||
array( 6, 30, 58, 86, 114, null, null), // Version 26
|
||||
array( 6, 34, 62, 90, 118, null, null), // Version 27
|
||||
array( 6, 26, 50, 74, 98, 122, null), // Version 28
|
||||
array( 6, 30, 54, 78, 102, 126, null), // Version 29
|
||||
array( 6, 26, 52, 78, 104, 130, null), // Version 30
|
||||
array( 6, 30, 56, 82, 108, 134, null), // Version 31
|
||||
array( 6, 34, 60, 86, 112, 138, null), // Version 32
|
||||
array( 6, 30, 58, 86, 114, 142, null), // Version 33
|
||||
array( 6, 34, 62, 90, 118, 146, null), // Version 34
|
||||
array( 6, 30, 54, 78, 102, 126, 150), // Version 35
|
||||
array( 6, 24, 50, 76, 102, 128, 154), // Version 36
|
||||
array( 6, 28, 54, 80, 106, 132, 158), // Version 37
|
||||
array( 6, 32, 58, 84, 110, 136, 162), // Version 38
|
||||
array( 6, 26, 54, 82, 110, 138, 166), // Version 39
|
||||
array( 6, 30, 58, 86, 114, 142, 170), // Version 40
|
||||
);
|
||||
|
||||
/**
|
||||
* Type information coordinates.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $typeInfoCoordinates = array(
|
||||
array(8, 0),
|
||||
array(8, 1),
|
||||
array(8, 2),
|
||||
array(8, 3),
|
||||
array(8, 4),
|
||||
array(8, 5),
|
||||
array(8, 7),
|
||||
array(8, 8),
|
||||
array(7, 8),
|
||||
array(5, 8),
|
||||
array(4, 8),
|
||||
array(3, 8),
|
||||
array(2, 8),
|
||||
array(1, 8),
|
||||
array(0, 8),
|
||||
);
|
||||
|
||||
/**
|
||||
* Version information polynomial.
|
||||
*
|
||||
* @var integer
|
||||
*/
|
||||
protected static $versionInfoPoly = 0x1f25;
|
||||
|
||||
/**
|
||||
* Type information polynomial.
|
||||
*
|
||||
* @var integer
|
||||
*/
|
||||
protected static $typeInfoPoly = 0x537;
|
||||
|
||||
/**
|
||||
* Type information mask pattern.
|
||||
*
|
||||
* @var integer
|
||||
*/
|
||||
protected static $typeInfoMaskPattern = 0x5412;
|
||||
|
||||
/**
|
||||
* Clears a given matrix.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
public static function clearMatrix(ByteMatrix $matrix)
|
||||
{
|
||||
$matrix->clear(-1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds a complete matrix.
|
||||
*
|
||||
* @param BitArray $dataBits
|
||||
* @param ErrorCorrectionLevel $level
|
||||
* @param Version $version
|
||||
* @param integer $maskPattern
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
public static function buildMatrix(
|
||||
BitArray $dataBits,
|
||||
ErrorCorrectionLevel $level,
|
||||
Version $version,
|
||||
$maskPattern,
|
||||
ByteMatrix $matrix
|
||||
) {
|
||||
self::clearMatrix($matrix);
|
||||
self::embedBasicPatterns($version, $matrix);
|
||||
self::embedTypeInfo($level, $maskPattern, $matrix);
|
||||
self::maybeEmbedVersionInfo($version, $matrix);
|
||||
self::embedDataBits($dataBits, $maskPattern, $matrix);
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds type information into a matrix.
|
||||
*
|
||||
* @param ErrorCorrectionLevel $level
|
||||
* @param integer $maskPattern
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
protected static function embedTypeInfo(ErrorCorrectionLevel $level, $maskPattern, ByteMatrix $matrix)
|
||||
{
|
||||
$typeInfoBits = new BitArray();
|
||||
self::makeTypeInfoBits($level, $maskPattern, $typeInfoBits);
|
||||
|
||||
$typeInfoBitsSize = $typeInfoBits->getSize();
|
||||
|
||||
for ($i = 0; $i < $typeInfoBitsSize; $i++) {
|
||||
$bit = $typeInfoBits->get($typeInfoBitsSize - 1 - $i);
|
||||
|
||||
$x1 = self::$typeInfoCoordinates[$i][0];
|
||||
$y1 = self::$typeInfoCoordinates[$i][1];
|
||||
|
||||
$matrix->set($x1, $y1, $bit);
|
||||
|
||||
if ($i < 8) {
|
||||
$x2 = $matrix->getWidth() - $i - 1;
|
||||
$y2 = 8;
|
||||
} else {
|
||||
$x2 = 8;
|
||||
$y2 = $matrix->getHeight() - 7 + ($i - 8);
|
||||
}
|
||||
|
||||
$matrix->set($x2, $y2, $bit);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates type information bits and appends them to a bit array.
|
||||
*
|
||||
* @param ErrorCorrectionLevel $level
|
||||
* @param integer $maskPattern
|
||||
* @param BitArray $bits
|
||||
* @return void
|
||||
* @throws Exception\RuntimeException
|
||||
*/
|
||||
protected static function makeTypeInfoBits(ErrorCorrectionLevel $level, $maskPattern, BitArray $bits)
|
||||
{
|
||||
$typeInfo = ($level->get() << 3) | $maskPattern;
|
||||
$bits->appendBits($typeInfo, 5);
|
||||
|
||||
$bchCode = self::calculateBchCode($typeInfo, self::$typeInfoPoly);
|
||||
$bits->appendBits($bchCode, 10);
|
||||
|
||||
$maskBits = new BitArray();
|
||||
$maskBits->appendBits(self::$typeInfoMaskPattern, 15);
|
||||
$bits->xorBits($maskBits);
|
||||
|
||||
if ($bits->getSize() !== 15) {
|
||||
throw new Exception\RuntimeException('Bit array resulted in invalid size: ' . $bits->getSize());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds version information if required.
|
||||
*
|
||||
* @param Version $version
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
protected static function maybeEmbedVersionInfo(Version $version, ByteMatrix $matrix)
|
||||
{
|
||||
if ($version->getVersionNumber() < 7) {
|
||||
return;
|
||||
}
|
||||
|
||||
$versionInfoBits = new BitArray();
|
||||
self::makeVersionInfoBits($version, $versionInfoBits);
|
||||
|
||||
$bitIndex = 6 * 3 - 1;
|
||||
|
||||
for ($i = 0; $i < 6; $i++) {
|
||||
for ($j = 0; $j < 3; $j++) {
|
||||
$bit = $versionInfoBits->get($bitIndex);
|
||||
$bitIndex--;
|
||||
|
||||
$matrix->set($i, $matrix->getHeight() - 11 + $j, $bit);
|
||||
$matrix->set($matrix->getHeight() - 11 + $j, $i, $bit);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates version information bits and appends them to a bit array.
|
||||
*
|
||||
* @param Version $version
|
||||
* @param BitArray $bits
|
||||
* @return void
|
||||
* @throws Exception\RuntimeException
|
||||
*/
|
||||
protected static function makeVersionInfoBits(Version $version, BitArray $bits)
|
||||
{
|
||||
$bits->appendBits($version->getVersionNumber(), 6);
|
||||
|
||||
$bchCode = self::calculateBchCode($version->getVersionNumber(), self::$versionInfoPoly);
|
||||
$bits->appendBits($bchCode, 12);
|
||||
|
||||
if ($bits->getSize() !== 18) {
|
||||
throw new Exception\RuntimeException('Bit array resulted in invalid size: ' . $bits->getSize());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the BHC code for a value and a polynomial.
|
||||
*
|
||||
* @param integer $value
|
||||
* @param integer $poly
|
||||
* @return integer
|
||||
*/
|
||||
protected static function calculateBchCode($value, $poly)
|
||||
{
|
||||
$msbSetInPoly = self::findMsbSet($poly);
|
||||
$value <<= $msbSetInPoly - 1;
|
||||
|
||||
while (self::findMsbSet($value) >= $msbSetInPoly) {
|
||||
$value ^= $poly << (self::findMsbSet($value) - $msbSetInPoly);
|
||||
}
|
||||
|
||||
return $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds and MSB set.
|
||||
*
|
||||
* @param integer $value
|
||||
* @return integer
|
||||
*/
|
||||
protected static function findMsbSet($value)
|
||||
{
|
||||
$numDigits = 0;
|
||||
|
||||
while ($value !== 0) {
|
||||
$value >>= 1;
|
||||
$numDigits++;
|
||||
}
|
||||
|
||||
return $numDigits;
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds basic patterns into a matrix.
|
||||
*
|
||||
* @param Version $version
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
protected static function embedBasicPatterns(Version $version, ByteMatrix $matrix)
|
||||
{
|
||||
self::embedPositionDetectionPatternsAndSeparators($matrix);
|
||||
self::embedDarkDotAtLeftBottomCorner($matrix);
|
||||
self::maybeEmbedPositionAdjustmentPatterns($version, $matrix);
|
||||
self::embedTimingPatterns($matrix);
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds position detection patterns and separators into a byte matrix.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
protected static function embedPositionDetectionPatternsAndSeparators(ByteMatrix $matrix)
|
||||
{
|
||||
$pdpWidth = count(self::$positionDetectionPattern[0]);
|
||||
|
||||
self::embedPositionDetectionPattern(0, 0, $matrix);
|
||||
self::embedPositionDetectionPattern($matrix->getWidth() - $pdpWidth, 0, $matrix);
|
||||
self::embedPositionDetectionPattern(0, $matrix->getWidth() - $pdpWidth, $matrix);
|
||||
|
||||
$hspWidth = 8;
|
||||
|
||||
self::embedHorizontalSeparationPattern(0, $hspWidth - 1, $matrix);
|
||||
self::embedHorizontalSeparationPattern($matrix->getWidth() - $hspWidth, $hspWidth - 1, $matrix);
|
||||
self::embedHorizontalSeparationPattern(0, $matrix->getWidth() - $hspWidth, $matrix);
|
||||
|
||||
$vspSize = 7;
|
||||
|
||||
self::embedVerticalSeparationPattern($vspSize, 0, $matrix);
|
||||
self::embedVerticalSeparationPattern($matrix->getHeight() - $vspSize - 1, 0, $matrix);
|
||||
self::embedVerticalSeparationPattern($vspSize, $matrix->getHeight() - $vspSize, $matrix);
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds a single position detection pattern into a byte matrix.
|
||||
*
|
||||
* @param integer $xStart
|
||||
* @param integer $yStart
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
protected static function embedPositionDetectionPattern($xStart, $yStart, ByteMatrix $matrix)
|
||||
{
|
||||
for ($y = 0; $y < 7; $y++) {
|
||||
for ($x = 0; $x < 7; $x++) {
|
||||
$matrix->set($xStart + $x, $yStart + $y, self::$positionDetectionPattern[$y][$x]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds a single horizontal separation pattern.
|
||||
*
|
||||
* @param integer $xStart
|
||||
* @param integer $yStart
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
* @throws Exception\RuntimeException
|
||||
*/
|
||||
protected static function embedHorizontalSeparationPattern($xStart, $yStart, ByteMatrix $matrix)
|
||||
{
|
||||
for ($x = 0; $x < 8; $x++) {
|
||||
if ($matrix->get($xStart + $x, $yStart) !== -1) {
|
||||
throw new Exception\RuntimeException('Byte already set');
|
||||
}
|
||||
|
||||
$matrix->set($xStart + $x, $yStart, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds a single vertical separation pattern.
|
||||
*
|
||||
* @param integer $xStart
|
||||
* @param integer $yStart
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
* @throws Exception\RuntimeException
|
||||
*/
|
||||
protected static function embedVerticalSeparationPattern($xStart, $yStart, ByteMatrix $matrix)
|
||||
{
|
||||
for ($y = 0; $y < 7; $y++) {
|
||||
if ($matrix->get($xStart, $yStart + $y) !== -1) {
|
||||
throw new Exception\RuntimeException('Byte already set');
|
||||
}
|
||||
|
||||
$matrix->set($xStart, $yStart + $y, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds a dot at the left bottom corner.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
* @throws Exception\RuntimeException
|
||||
*/
|
||||
protected static function embedDarkDotAtLeftBottomCorner(ByteMatrix $matrix)
|
||||
{
|
||||
if ($matrix->get(8, $matrix->getHeight() - 8) === 0) {
|
||||
throw new Exception\RuntimeException('Byte already set to 0');
|
||||
}
|
||||
|
||||
$matrix->set(8, $matrix->getHeight() - 8, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds position adjustment patterns if required.
|
||||
*
|
||||
* @param Version $version
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
protected static function maybeEmbedPositionAdjustmentPatterns(Version $version, ByteMatrix $matrix)
|
||||
{
|
||||
if ($version->getVersionNumber() < 2) {
|
||||
return;
|
||||
}
|
||||
|
||||
$index = $version->getVersionNumber() - 1;
|
||||
|
||||
$coordinates = self::$positionAdjustmentPatternCoordinateTable[$index];
|
||||
$numCoordinates = count($coordinates);
|
||||
|
||||
for ($i = 0; $i < $numCoordinates; $i++) {
|
||||
for ($j = 0; $j < $numCoordinates; $j++) {
|
||||
$y = $coordinates[$i];
|
||||
$x = $coordinates[$j];
|
||||
|
||||
if ($x === null || $y === null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($matrix->get($x, $y) === -1) {
|
||||
self::embedPositionAdjustmentPattern($x - 2, $y - 2, $matrix);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds a single position adjustment pattern.
|
||||
*
|
||||
* @param integer $xStart
|
||||
* @param intger $yStart
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
protected static function embedPositionAdjustmentPattern($xStart, $yStart, ByteMatrix $matrix)
|
||||
{
|
||||
for ($y = 0; $y < 5; $y++) {
|
||||
for ($x = 0; $x < 5; $x++) {
|
||||
$matrix->set($xStart + $x, $yStart + $y, self::$positionAdjustmentPattern[$y][$x]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds timing patterns into a matrix.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
protected static function embedTimingPatterns(ByteMatrix $matrix)
|
||||
{
|
||||
$matrixWidth = $matrix->getWidth();
|
||||
|
||||
for ($i = 8; $i < $matrixWidth - 8; $i++) {
|
||||
$bit = ($i + 1) % 2;
|
||||
|
||||
if ($matrix->get($i, 6) === -1) {
|
||||
$matrix->set($i, 6, $bit);
|
||||
}
|
||||
|
||||
if ($matrix->get(6, $i) === -1) {
|
||||
$matrix->set(6, $i, $bit);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Embeds "dataBits" using "getMaskPattern".
|
||||
*
|
||||
* For debugging purposes, it skips masking process if "getMaskPattern" is
|
||||
* -1. See 8.7 of JISX0510:2004 (p.38) for how to embed data bits.
|
||||
*
|
||||
* @param BitArray $dataBits
|
||||
* @param integer $maskPattern
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
* @throws Exception\WriterException
|
||||
*/
|
||||
protected static function embedDataBits(BitArray $dataBits, $maskPattern, ByteMatrix $matrix)
|
||||
{
|
||||
$bitIndex = 0;
|
||||
$direction = -1;
|
||||
|
||||
// Start from the right bottom cell.
|
||||
$x = $matrix->getWidth() - 1;
|
||||
$y = $matrix->getHeight() - 1;
|
||||
|
||||
while ($x > 0) {
|
||||
// Skip vertical timing pattern.
|
||||
if ($x === 6) {
|
||||
$x--;
|
||||
}
|
||||
|
||||
while ($y >= 0 && $y < $matrix->getHeight()) {
|
||||
for ($i = 0; $i < 2; $i++) {
|
||||
$xx = $x - $i;
|
||||
|
||||
// Skip the cell if it's not empty.
|
||||
if ($matrix->get($xx, $y) !== -1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($bitIndex < $dataBits->getSize()) {
|
||||
$bit = $dataBits->get($bitIndex);
|
||||
$bitIndex++;
|
||||
} else {
|
||||
// Padding bit. If there is no bit left, we'll fill the
|
||||
// left cells with 0, as described in 8.4.9 of
|
||||
// JISX0510:2004 (p. 24).
|
||||
$bit = false;
|
||||
}
|
||||
|
||||
// Skip masking if maskPattern is -1.
|
||||
if ($maskPattern !== -1 && MaskUtil::getDataMaskBit($maskPattern, $xx, $y)) {
|
||||
$bit = !$bit;
|
||||
}
|
||||
|
||||
$matrix->set($xx, $y, $bit);
|
||||
}
|
||||
|
||||
$y += $direction;
|
||||
}
|
||||
|
||||
$direction = -$direction;
|
||||
$y += $direction;
|
||||
$x -= 2;
|
||||
}
|
||||
|
||||
// All bits should be consumed
|
||||
if ($bitIndex !== $dataBits->getSize()) {
|
||||
throw new Exception\WriterException('Not all bits consumed (' . $bitIndex . ' out of ' . $dataBits->getSize() .')');
|
||||
}
|
||||
}
|
||||
}
|
||||
201
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/QrCode.php
vendored
Executable file
201
phpMyAdmin/vendor/bacon/bacon-qr-code/src/BaconQrCode/Encoder/QrCode.php
vendored
Executable file
@@ -0,0 +1,201 @@
|
||||
<?php
|
||||
/**
|
||||
* BaconQrCode
|
||||
*
|
||||
* @link http://github.com/Bacon/BaconQrCode For the canonical source repository
|
||||
* @copyright 2013 Ben 'DASPRiD' Scholzen
|
||||
* @license http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
|
||||
*/
|
||||
|
||||
namespace BaconQrCode\Encoder;
|
||||
|
||||
use BaconQrCode\Common\ErrorCorrectionLevel;
|
||||
use BaconQrCode\Common\Mode;
|
||||
use BaconQrCode\Common\Version;
|
||||
|
||||
/**
|
||||
* QR code.
|
||||
*/
|
||||
class QrCode
|
||||
{
|
||||
/**
|
||||
* Number of possible mask patterns.
|
||||
*/
|
||||
const NUM_MASK_PATTERNS = 8;
|
||||
|
||||
/**
|
||||
* Mode of the QR code.
|
||||
*
|
||||
* @var Mode
|
||||
*/
|
||||
protected $mode;
|
||||
|
||||
/**
|
||||
* EC level of the QR code.
|
||||
*
|
||||
* @var ErrorCorrectionLevel
|
||||
*/
|
||||
protected $errorCorrectionLevel;
|
||||
|
||||
/**
|
||||
* Version of the QR code.
|
||||
*
|
||||
* @var Version
|
||||
*/
|
||||
protected $version;
|
||||
|
||||
/**
|
||||
* Mask pattern of the QR code.
|
||||
*
|
||||
* @var integer
|
||||
*/
|
||||
protected $maskPattern = -1;
|
||||
|
||||
/**
|
||||
* Matrix of the QR code.
|
||||
*
|
||||
* @var ByteMatrix
|
||||
*/
|
||||
protected $matrix;
|
||||
|
||||
/**
|
||||
* Gets the mode.
|
||||
*
|
||||
* @return Mode
|
||||
*/
|
||||
public function getMode()
|
||||
{
|
||||
return $this->mode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the mode.
|
||||
*
|
||||
* @param Mode $mode
|
||||
* @return void
|
||||
*/
|
||||
public function setMode(Mode $mode)
|
||||
{
|
||||
$this->mode = $mode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the EC level.
|
||||
*
|
||||
* @return ErrorCorrectionLevel
|
||||
*/
|
||||
public function getErrorCorrectionLevel()
|
||||
{
|
||||
return $this->errorCorrectionLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the EC level.
|
||||
*
|
||||
* @param ErrorCorrectionLevel $errorCorrectionLevel
|
||||
* @return void
|
||||
*/
|
||||
public function setErrorCorrectionLevel(ErrorCorrectionLevel $errorCorrectionLevel)
|
||||
{
|
||||
$this->errorCorrectionLevel = $errorCorrectionLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the version.
|
||||
*
|
||||
* @return Version
|
||||
*/
|
||||
public function getVersion()
|
||||
{
|
||||
return $this->version;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the version.
|
||||
*
|
||||
* @param Version $version
|
||||
* @return void
|
||||
*/
|
||||
public function setVersion(Version $version)
|
||||
{
|
||||
$this->version = $version;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the mask pattern.
|
||||
*
|
||||
* @return integer
|
||||
*/
|
||||
public function getMaskPattern()
|
||||
{
|
||||
return $this->maskPattern;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the mask pattern.
|
||||
*
|
||||
* @param integer $maskPattern
|
||||
* @return void
|
||||
*/
|
||||
public function setMaskPattern($maskPattern)
|
||||
{
|
||||
$this->maskPattern = $maskPattern;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the matrix.
|
||||
*
|
||||
* @return ByteMatrix
|
||||
*/
|
||||
public function getMatrix()
|
||||
{
|
||||
return $this->matrix;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the matrix.
|
||||
*
|
||||
* @param ByteMatrix $matrix
|
||||
* @return void
|
||||
*/
|
||||
public function setMatrix(ByteMatrix $matrix)
|
||||
{
|
||||
$this->matrix = $matrix;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validates whether a mask pattern is valid.
|
||||
*
|
||||
* @param integer $maskPattern
|
||||
* @return boolean
|
||||
*/
|
||||
public static function isValidMaskPattern($maskPattern)
|
||||
{
|
||||
return $maskPattern > 0 && $maskPattern < self::NUM_MASK_PATTERNS;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a string representation of the QR code.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function __toString()
|
||||
{
|
||||
$result = "<<\n"
|
||||
. " mode: " . $this->mode . "\n"
|
||||
. " ecLevel: " . $this->errorCorrectionLevel . "\n"
|
||||
. " version: " . $this->version . "\n"
|
||||
. " maskPattern: " . $this->maskPattern . "\n";
|
||||
|
||||
if ($this->matrix === null) {
|
||||
$result .= " matrix: null\n";
|
||||
} else {
|
||||
$result .= " matrix:\n";
|
||||
$result .= $this->matrix;
|
||||
}
|
||||
|
||||
$result .= ">>\n";
|
||||
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user